el/lang/examples/transduce.el

// transduce.el — transduction decomposes a signal into components and the
// relations between them. Runnable: this is the worked example for the
// transduce surface, and it exits non-zero if any claim in it stops being true.
//
//   elc lang/examples/transduce.el > transduce.c
//   cc -std=c11 -O2 -I lang/runtime -o transduce transduce.c \
//        lang/runtime/el_runtime.c lang/runtime/el_seed.c \
//        lang/runtime/engram_store.c lang/runtime/engram_vindex.c \
//        lang/runtime/engram_cognition.c lang/runtime/engram_geometry.c \
//        lang/runtime/engram_reason.c lang/runtime/engram_verify.c \
//        -lcurl -lpthread -lm
//   ./transduce          # exits 0 only if every check passes
//
// It writes to an IN-MEMORY engram (leave ENGRAM_STORE unset) and contacts no
// server. The same claims are asserted by the native harness in
// lang/tests/native/test_transduce.el.
//
// WHAT CHANGED, AND WHY IT MATTERS. #144 shipped
// `transduce(signal, modality) -> Geometry`: one vector per signal. That made
// transduction a CONVERSION — take a thing, encode it, store a position — and
// what a conversion returns is a fingerprint. A fingerprint can be matched and
// ranked, and that is all it can ever do. It cannot be decomposed, cannot have
// one part grounded while another is not, and cannot be contradicted in one
// part while holding in another, because it has no parts.
//
// A song is not a point. It decomposes into pitch, interval, rhythm, harmonic
// function — components, each with its own geometry, plus the relations among
// them. THE SONG IS THE STRUCTURE OF THE RELATIONS. transduce now returns a
// Manifold, and a realizer's job is to say what its modality's components ARE.

fn check(ok: Int, label: String) -> Int {
    if ok > 0 {
        println("  ok    " + label)
        return 0
    }
    println("  FAIL  " + label)
    exit(1)
    return 1
}

fn near(a: Float, b: Float) -> Int {
    let d: Float = a - b
    if d > 0.001 { return 0 }
    if d < -0.001 { return 0 }
    return 1
}

fn eq_int(a: Int, b: Int) -> Int {
    if a == b { return 1 }
    return 0
}

// ── A DECOMPOSING realizer, written entirely in El ──────────────────────────
// "tone" signals are note letters, e.g. "CEG". This does NOT return one vector
// for the chord. It returns the PARTS — one component per note, one per
// interval between adjacent notes — and the relations that make those parts a
// chord rather than an unordered bag of pitches.
//
// The interval is deliberately a COMPONENT, not a field on a note. An interval
// is a thing with its own geometry belonging to neither endpoint; modelling it
// as an attribute of one of them is the same collapse, one level down.
fn tone_realizer(signal: String) -> Manifold {
    let m: Manifold = manifold_new()
    let n: Int = str_len(signal)
    let i: Int = 0
    while i < n {
        let code: Int = str_char_code(signal, i)
        let g: Geometry = geometry_new(2)
        let s0: Int = geometry_set(g, 0, int_to_float(code))
        let s1: Int = geometry_set(g, 1, int_to_float(i))
        let idx: Int = manifold_add(m, "note:" + int_to_str(i), "pitch", g)
        let f: Int = geometry_free(g)
        i = i + 1
    }
    let j: Int = 1
    while j < n {
        let a: Int = str_char_code(signal, j - 1)
        let b: Int = str_char_code(signal, j)
        let lo: String = "note:" + int_to_str(j - 1)
        let hi: String = "note:" + int_to_str(j)
        let key: String = "interval:" + int_to_str(j - 1) + "-" + int_to_str(j)
        let g: Geometry = geometry_new(1)
        let s: Int = geometry_set(g, 0, int_to_float(b - a))
        let idx: Int = manifold_add(m, key, "interval", g)
        let f: Int = geometry_free(g)
        let e1: Int = manifold_relate(m, key, "spans", lo, 0.9)
        let e2: Int = manifold_relate(m, key, "spans", hi, 0.9)
        let e3: Int = manifold_relate(m, lo, "sounds_before", hi, 0.8)
        j = j + 1
    }
    m
}

// #144's contract, kept as a control: one vector for the whole signal.
fn fingerprint_realizer(signal: String) -> Geometry {
    let g: Geometry = geometry_new(4)
    let n: Int = str_len(signal)
    let a: Int = geometry_set(g, 0, int_to_float(n))
    g
}

fn main() -> Void {
    println("a realizer declared in El is a first-class realizer")
    let reg: Int = realizer_register("tone", "tone_realizer")
    let _c: Int = check(reg, "an El fn registers as a realizer by name")
    let _c: Int = check(realizer_has("tone"), "the modality now has an organ")

    println("transduction decomposes a signal into parts")
    let m: Manifold = transduce("CEG", "tone")
    let _c: Int = check(manifold_is(m), "transduce returns a real Manifold")
    let sz: Int = manifold_size(m)
    let _c: Int = check(eq_int(sz, 5), "three notes and two intervals are five parts")
    let rc: Int = manifold_rel_count(m)
    let _c: Int = check(eq_int(rc, 6), "and they stand in six stated relations")

    println("every part is addressable BY KEY, which is what survives persistence")
    let i_c: Int = manifold_index_of(m, "note:0")
    let _c: Int = check(1 - eq_int(i_c, -1), "the first note is addressable on its own")
    let i_iv: Int = manifold_index_of(m, "interval:0-1")
    let _c: Int = check(1 - eq_int(i_iv, -1), "so is the interval between the first two")
    let miss: Int = manifold_index_of(m, "never_added")
    let _c: Int = check(eq_int(miss, -1), "an unknown key is -1, not component 0")

    println("parts carry their own geometry, and may differ in width")
    let gn: Geometry = manifold_geometry(m, i_c)
    let _c: Int = check(eq_int(geometry_dim(gn), 2), "a note component is 2 wide")
    let _c: Int = check(near(geometry_get(gn, 0), 67.0), "and it is C — the signal reached the realizer")
    let gi: Geometry = manifold_geometry(m, i_iv)
    let _c: Int = check(eq_int(geometry_dim(gi), 1), "an interval component is 1 wide")
    // A single vector per signal cannot represent parts of unequal width at all.
    let _c: Int = check(near(geometry_get(gi, 0), 2.0), "C to E is two semitones")
    let f1: Int = geometry_free(gn)
    let f2: Int = geometry_free(gi)

    println("the relations are content no single part carries")
    // That "2" above is not a property of C and not a property of E. It exists
    // only BETWEEN them, so a representation with no relations cannot hold it.
    let spans: Int = 0
    let k: Int = 0
    while k < rc {
        if str_eq(manifold_rel_name(m, k), "spans") {
            if str_eq(manifold_rel_from(m, k), "interval:0-1") { spans = spans + 1 }
        }
        k = k + 1
    }
    let _c: Int = check(eq_int(spans, 2), "the interval is wired to both notes it spans")

    println("relation weight IS the grounding (correspondence-and-censorship §1)")
    let wk: Int = 0
    let found: Int = 0
    while wk < rc {
        if str_eq(manifold_rel_name(m, wk), "sounds_before") {
            if near(manifold_rel_weight(m, wk), 0.8) > 0 { found = 1 }
        }
        wk = wk + 1
    }
    let _c: Int = check(found, "the ordering relation carries the weight its realizer stated")

    println("the decomposition persists as real, separately addressable nodes")
    let ids: [String] = el_list_empty()
    let n0: Int = engram_node_count()
    let e0: Int = engram_edge_count()
    let pi: Int = 0
    while pi < sz {
        let key: String = manifold_key(m, pi)
        let g: Geometry = manifold_geometry(m, pi)
        let id: String = engram_node("component " + key, "Concept", 0.6)
        let att: Int = node_attach_geometry(id, g)
        ids = el_list_append(ids, id)
        let ff: Int = geometry_free(g)
        pi = pi + 1
    }
    let ri: Int = 0
    while ri < rc {
        let fi: Int = manifold_index_of(m, manifold_rel_from(m, ri))
        let ti: Int = manifold_index_of(m, manifold_rel_to(m, ri))
        engram_connect(el_list_get(ids, fi), el_list_get(ids, ti),
                       manifold_rel_weight(m, ri), manifold_rel_name(m, ri))
        ri = ri + 1
    }
    let _c: Int = check(eq_int(engram_node_count() - n0, 5), "one signal became five nodes")
    let _c: Int = check(eq_int(engram_edge_count() - e0, 6), "and six edges between them")

    println("each part's geometry is independently readable back off its node")
    let id_c: String = el_list_get(ids, manifold_index_of(m, "note:0"))
    let id_iv: String = el_list_get(ids, manifold_index_of(m, "interval:0-1"))
    let _c: Int = check(eq_int(node_geometry_dim(id_c), 2), "note:0 node carries a 2-wide geometry")
    let _c: Int = check(eq_int(node_geometry_dim(id_iv), 1), "interval:0-1 node carries a 1-wide one")

    println("one part can be grounded without touching its siblings")
    let ear: String = engram_node("evidence: heard a C in the recording", "Memory", 0.7)
    engram_connect(ear, id_c, 0.95, "corroborates")
    let _c: Int = check(engram_edge_between(ear, id_c), "evidence attaches to note:0 specifically")
    let id_g: String = el_list_get(ids, manifold_index_of(m, "note:2"))
    let _c: Int = check(1 - engram_edge_between(ear, id_g), "and NOT to note:2 — the sibling is untouched")
    // This is the whole gain, and it is impossible with a fingerprint: with one
    // node per signal, "the C is corroborated" and "the G is not" have the same
    // grounding target and cannot both be recorded.
    let _c: Int = check(eq_int(node_geometry_dim(id_g), 2), "note:2 geometry is intact regardless")

    println("a fingerprint realizer transduces NOTHING")
    // #144's contract exactly: signal in, one Geometry out. It resolves, so the
    // organ is present — but it does not decompose, so it does not transduce.
    // "No organ" and "an organ that only fingerprints" must not look alike.
    let rf: Int = realizer_register("fingerprint", "fingerprint_realizer")
    let _c: Int = check(rf, "the symbol resolves, so registration succeeds")
    let mf: Manifold = transduce("x", "fingerprint")
    let _c: Int = check(1 - manifold_is(mf), "a single vector is not a transduction")

    println("the one-part case is a size-one manifold, not a bare vector")
    let g1: Geometry = geometry_new(3)
    let s1: Int = geometry_set(g1, 0, 5.0)
    let ms: Manifold = manifold_single("level", "scalar", g1)
    let _c: Int = check(manifold_is(ms), "manifold_single yields a real Manifold")
    let _c: Int = check(eq_int(manifold_size(ms), 1), "of size one — visibly degenerate, not hidden")
    let fg: Int = geometry_free(g1)
    let fs: Int = manifold_free(ms)

    println("no organ is still reported as no organ")
    let me: Manifold = transduce("anything", "echolocation")
    let _c: Int = check(1 - manifold_is(me), "no realizer means no manifold, not a fake one")

    let fm: Int = manifold_free(m)

    // Reaching here means nothing called exit(1) along the way.
    println("")
    println("all checks passed")
}