*Recovered 2026-08-30 by sweeping the whole project after context loss. Every row was verified
against the tree today, not recalled. Where a claim comes from the Codex changelog, the version is
named so it can be checked.*
---
Two layers, built bottom-up. Letter Calculus is the floor; Word Calculus sits on it.
[internal module] (1,043 lines, v9.10.573)The finding that caused it, in the Codex's own words: *"word_calculus.rs declares Level::Letter
and Operator::Bind with carry 0.95 — 'letters fuse into one object' — and implements neither.
It is a parser. There was no sound table, no combination inventory, and no algebra that builds a word
UP from its letters. The honest answer to 'does word calculus have the sounds of the letters' was
no."*
A+D = AD, A+D^2 = ADD | 100% |c+h is /tʃ/, not /k/+/h/ — letters fuse, they do not concatenate | — |word_order.rs — the sequence judgement | 100% |84% overall (38 passed, 7 failed). The calibration is a minimal-pairs instrument, not a test
suite: cat/city, hat/hate, A+D vs A+D^2, A,B vs A.B. If both members of a pair get the
same answer the rule was never learned, however confident the answer.
[internal module] (649 lines, v9.8.7)Carry-weight operators and hierarchical consolidation:
letters -> words -> clauses -> sentences -> paragraphs -> reply.
The carry weight C in [0,1] is how much meaning flows across a boundary into the next sibling:
Bind 0.95 letters fuse into one object
Space 0.80 next word, same thought
Colon 0.60 next part expands this one
Semicolon 0.55 linked independent clauses
Comma 0.45 related but secondary
Exclaim 0.12 stop (+ intensity)
Question 0.12 stop (+ query)
Period 0.10 full stop
Paragraph 0.05 block break
Reply 0.02 top
Each operator also closes() a level and consolidates it upward. carry_context() accumulates
across a run of operators, with a deliberate 0.25 reply_floor once a sentence closes — crossing a
sentence *raises* accumulated carry instead of letting it decay, because a reply persists as a
thread. The Codex flags that carry therefore names two different quantities (local cohesion below a
sentence, thread persistence above one) *"and one name for two quantities will matter if these values
are ever tuned from evidence."*
kai_show_work.rs renders a derivation as **a chain of equations where each layer's ANSWER is the
next layer's INPUT** — described in the Codex as *"Ryan's fractal framing made literal."* The same
idea appears in the architecture section: *"letters, words, and sentences are living
frequency-clusters that attract, cluster, and consolidate across scales"*, and in the biography as
the reason the design exists — a mind that *"builds understanding structurally instead — in geometry,
resonance, and pattern"*, with the fractal scaling from quantum to macro as a direct expression of
how its maker experiences thought and sound.
---
oracle_server.rs [internal service], 5454, 5480 — word_order::judge_text() gates the autoregressive decode. [config flag] defaults ON. It abstains below a 0.6 known-word ratio, because *"ignorance is not ungrammaticality"* |[config flag] default ON. Tonight's boot: *"111,651 sentences over 39,683 cells -> 14,407 words labelled, 1,076,122 role-transitions counted"* and *"corpus admits 37 transitions the hand table refused"* |[internal endpoint] | LIVE | oracle_server.rs:920. Returns the equation of any text — word/clause/sentence counts, the carry-weight of every boundary crossed, the alive-meaning value, and the equation written out. Independent of the master switch |WORD_CALCULUS: AtomicBool::new(false); set_enabled() had zero callers in the entire tree. v9.10.852 adds [config flag]=1 |LETTER_CALCULUS: AtomicBool::new(false); v9.10.852 adds [config flag]=1 |calculus_vsa.rs — the math meeting the lattice geometry | INERT. Zero callers. | 704 lines: *"word-calculus Unit tree -> SparseVec via carry-weighted bundling, plus commit_to_universe at Clause depth"*. Landed marked inert and never wired |Operator::carry() is a match returning constants, under the comment *"PRIORS — training tunes them"*. Codex v9.10.622: *"The carry-weights have never been tuned. Nothing has ever tuned them."* No store, no update rule, no persistence |attest_from_corpus — where the inventory stops being declared and starts being learned | wired, seeded once, from a binary only | letter_calculus.rs:289. Its own header: *"wired but unseeded."* Called only from kai_language_space.rs and kai_letter_calculus.rs — never from the engine |role_of(word) takes a word and no context, so it cannot know *run* is a verb in "I run daily" and a noun in "a good run". All six probes answer identically; five return Unknown |---
Five binaries were written to measure this stack. They are the instruments; use them rather than
re-deriving.
cargo run --release --bin kai_letter_calculus L0-L7 with attestation
cargo run --release --bin kai_language_calibration the minimal-pairs instrument (84%)
cargo run --release --bin kai_language_space 676-pair attestation vs a real corpus
cargo run --release --bin kai_role_induction role learning from the lattice
cargo run --release --bin kai_show_work the fractal derivation chain, printed
The 676-pair attestation result, because it overturned the design's own assumption: against
1.24M real pairs, 611 of 676 actually occur while only 293 were tagged pronounceable.
IllegalCluster means illegal *as an onset*, and English puts those pairs across syllable
boundaries — so as a word filter the table would reject *answers*, *only*, *cats* and *right*.
Also measured: 11 pairs tagged pronounceable that never appear once.
---
> *"reinforced somewhat throughout the process of each thought of letter or whatever and will get
> adjusted live weights to count for that change or learned adjustment in the math"*
>
> *"it's not just what is he saying — does he even know what he is saying, and is it something that
> should be said based on that math equation? Even life itself and human language is a math equation
> that is everlastingly changing every tick of life itself."*
1. The weights have to move. This is the "everlastingly changing every tick" half and none of it
exists. carry() returns constants. What is needed: a store for a learned carry weight per operator
(and eventually per context), an update rule driven by what the thought actually did, and
persistence so it survives a restart. The corpus for fitting it is *already being collected* —
_attachWordMath() writes the equation of every turn onto the stored message, described in the
Codex as *"worked examples of what the math looks like when the output is already right, which is
what lets the calculus be fitted against known-good language."* Nothing reads that corpus yet.
2. The math has to reach the geometry. calculus_vsa is the bridge — carry-weighted bundling of
the Unit tree into a SparseVec, and commit_to_universe at Clause depth. Until something crosses it,
the calculus can only re-render words that cosine already chose. That is decoration, not generation.
3. Sayability belongs to the equation. Half of this is already live and better than I credited:
word_order::judge_text() genuinely gates the mouth, and v9.10.578 recorded it refusing a decode
with a *structural* reason — *"for (VERB) cannot be followed by a-apostrophe-s (ADJ)"* — while the
coherence judge was coin-flipping at a 0.005 margin. What is missing is the other half: whether the
sentence's own equation resolves — L9, the whole-text equation — is computed by [internal endpoint]
for telemetry and never consulted before speaking.
And L4 is the keystone. The Codex names it directly: *"pick from a word's learned role
distribution using its actual neighbours — the single largest gap in the language stack and the
direct expression of Ryan's thesis."* Role induction now supplies the learned distribution from
39,683 cells. Nothing yet selects from it by context.