The 3¹² Convergence Lattice — CSF and the Tesseract Are One Object

TL;DR

The project was carrying two designs — "CSF" (a binary memory/compression format) and "the Tesseract" (a 4-cube reasoning geometry). They are not two things. They are one object: a 3**12 = 531,441-cell balanced-ternary lattice. CSF is how a point on the lattice is stored; the Tesseract spiral is how a point moves across it toward a fixed point. The substrate is already built (src/csf/v07/ + src/converged_tesseract.py); this doc unifies the vocabulary and the docs. Per the anti-sprawl law, two design threads collapse to one Convergence-Core object.

0. What is real vs. what is the contribution

The contribution is the bottom three rows: a mapping, not new machinery. Everything above the divider already exists or is externally grounded.

1. The "pair" problem

Two threads grew up separately in the repo:

• CSF — Convergence-Fitted Searchable Format. A family of binary containers for memory

(CSF-FORMAT-SPECIFICATION.md): v0.3 symbolic, v0.7 qutrit engine, v0.8 CSF-Pack, v1 segmented. Framed as storage.

• The Tesseract — a 4-cube reasoning geometry: the Status-Cube (belief × observer × state)

× a depth axis, with an inference trajectory that contracts to a fixed point (research/2026-06-19-convergence-tesseract-spiral.md). Framed as geometry / reasoning.

The North Star forbids exactly this: "One loop. Four objects. Everything else is implementation. Reject architectural sprawl." Two parallel design vocabularies for what is provably one mathematical object is sprawl. This doc removes it.

2. The lattice: why 3**12

2.1 Base— not mysticism, radix economy [grounded]

The width of a positional number system trades digit-count against per-digit cost. Radix economy E(b, N) = b · floor(log_b N + 1) is minimised, over real bases, at b = e ≈ 2.718; the closest integer is 3, so ternary is the most economical integer radix for large state spaces ([Wikipedia: Radix economy]; [Quanta, How BaseComputing Beats Binary]; Hayes, Third Base, American Scientist). Balanced ternary {-1, 0, +1} additionally gives symmetric arithmetic (negation = digit flip; sign = leading nonzero digit) — the property that made Setun (1958) work. This is the principled reason the lattice is base-3 and the CSF engine is a qutrit engine, not a bit engine.

2.2 Twelve axes — the Convergence-12 [hypothesis — design]

The North Star defines Convergence 12: twelve native components, each owning one stage of the loop or the system itself (CONVERGANCE-SIGMA0-BRIEFING.md). The lattice gives each component one ternary axis:

A system state is one point in {-1,0,+1}^12 = 3**12 = 531,441 cells. The mapping in this table is a design proposal (each axis's semantics is a hypothesis to validate against the running components), but the size and shape are implemented: qutrit_delta.py hard-codes NUM_DIMENSIONS = 12 and TOTAL_POSITIONS =NUM_DIMENSIONS = 12** 12.

2.3 The Status-Cube is a 3**3 projection [implemented]

The Status-Cube (belief × observer × state) is three of the twelve axes. It is the human-readable shadow of the full lattice — a 3**3 = 27-cell projection. "Tesseract" in the spiral paper means the 3-cube × ℝ depth product; the lattice generalises that to all twelve axes. No physics is claimed; "tesseract/lattice" is a precise geometric object, and any 4-D-spacetime reading is metaphor and out of scope (consistent with the spiral paper's honesty pass).

3. The singularity: one lattice, two faces

The two faces share one state representation, so they are one object. Concretely:

3.1 Storage face — CSF writes a point [implemented]

A lattice cell is a 12-vector of QutritState(amplitude 0-7, phase 0-7). Change is a list of QutritDelta(dim_index, amp_delta, phase_delta) packed to 2 bytes each (qutrit_delta.py). The QuantumDustField (quantum_dust.py) holds a baseline (converged cells) + active deltas (deviations); every other cell is implicit "dust." get_state resolves baseline ⊕ deltas, else returns None (dust). This is CSF's symbolic v0.7 lineage — the storage face.

3.2 Motion face — the Tesseract moves the point [implemented]

ConvergedTesseract (converged_tesseract.py) never materialises all 531,441 cells. It loads a minimal observer-collapsed wavefront — the cells within a ternary-Hamming radius of the present center, ranked by information density (active deltas > baseline > dust). The wavefront is the spiral's current position; advancing update_present(t) walks the lattice. loop_lm.converge_step supplies the stopping rule: iterate until ‖h_t − h_{t-1}‖ / ‖h_{t-1}‖ < ε, i.e. until the trajectory reaches a fixed point h* ≈ f(h*). Storage face says where; motion face says toward what.

3.3 The cross-grounding — claimed, then measured and refined [measured (X3)]

The most economical observation in quantum_dust.py is that "no change" is nearly free: most cells are dust, so confirmations cost nothing. This resembles BitNet b1.58's empirical finding that ~66 % of ternary weights settle to 0 and zeros are skipped (matmul → add) (§5). The original draft of this section claimed the two were "the same phenomenon." X3 measured it and refined that down (§6.1):

• The naive dust_percentage (address sparsity) is ~99.95 % for every field — a category

error vs BitNet, which has no empty address space.

• The fair, BitNet-comparable metric is value-sparsity (fraction of stored (cell, dim)

amplitude slots equal to 0). It is population-dependent: 0.137 for a uniform-random field (≈ the 1/8 prior — confirming the metric is honest), 0.835 for the realistic populator, and it reaches BitNet's 0.66 only when the population is deliberately tuned to it.

• BitNet's ~66 % is a learned 2/3 ternary mass; the dust field's rate is **structural /

data-dependent**. They share a substrate, not a mechanism — matching the number is a coincidence of population.

So the lattice unification (§3.1–3.2, all [implemented]) stands; the sparsity-equivalence sub-claim is weaker than first stated and now reads "the dust field can exhibit BitNet-like value sparsity," not "is the same phenomenon." Honest convergence, exactly as the External Reality Rule intends.

4. Where this lives in the loop

        ┌──────────────── one 3^12 balanced-ternary lattice ────────────────┐

        │                                                                    │

 Observe ─► Remember ─► Reason ─► Act ─► Verify ─► Converge                   │

   │           │          │        │       │          │                      │

   │        CSF writes   Tesseract wavefront walks   convergence-exit         │

   │        the point    selects/moves the point     contracts to h*         │

   └────────── storage face ──────┴────────── motion face ──────────────────┘

Nothing new is added to the loop. The lattice is the substrate the four core objects (Memory, Task, Tool, ConvergenceRecord) already live on:

• a Memory is a stored lattice point (+ its delta history) — CSF face;
• a ConvergenceRecord is a measured contraction step toward h* — Tesseract face;
• Tasks/Tools select which axis (component) the next delta acts on.

5. External grounding (sources)

Why base-3 (storage radix):

• Radix economy — baseminimises digit-cost; optimum is e, nearest integer 3.

Wikipedia: Radix economy · Quanta — How BaseComputing Beats Binary · American Scientist — Third Base

Ternary as a real compute substrate (storage ↔ compute):

• BitNet b1.58 — every weight {-1,0,+1}, ~66 % zeros, matmul→add, ~16–32× memory cut.

arXiv:2402.17764 · microsoft/BitNet

• Sparse-BitNet — 1.58-bit models are naturally semi-structured-sparsity friendly.

arXiv:2603.05168

• T-SAR — CPU-only ternary LLM inference via in-place SIMD ALU reorganisation.

arXiv:2511.13676

• Hyperdimensional computing / Vector Symbolic Architectures — ternary {-1,0,1} sparse

high-dimensional codes. arXiv:2111.06077 · Part II — arXiv:2112.15424

Spiral / motion-to-fixed-point (the Tesseract face):

• Geiping et al. — *Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth

Approach*; reports emergent orbit trajectories, directional drift, per-token convergence rates. arXiv:2502.05171

• STARS — Stabilizing Recurrent Dynamics …: constrains latent states to **asymptotically

stable fixed points via Jacobian Spectral Radius Regularisation with random loop sampling. Directly addresses the spiral paper's open non-normal-operator** gap. arXiv:2605.26733

• SpiralFormer — looped transformers learn hierarchical dependencies via multi-resolution

recursion. arXiv:2602.11698

• A Survey on Latent Reasoning. arXiv:2507.06203
• Ouro LoopLM (weight-tied recurrence + Q-exit), the substrate the spiral paper extends.

arXiv:2510.25741

6. Falsify before you believe

X3 and X4 are the load-bearing ones: X3 tests whether storage-sparsity and compute-sparsity are the same phenomenon; X4 tests whether the spiral actually spirals. Both were run on 2026-06-19 — see §6.1.

6.1 Measured results (2026-06-19)

Run via a Workflow (implement → run → 3-lens adversarial verify; all six verifier lenses returned sound, reproduced = true). Reproducible scripts: experiments/x3_dust_vs_bitnet_sparsity.py and experiments/x4_converge_step_instrument.py (run as PYTHONPATH=src python …); raw numbers in experiments/results/.

X3 — dust vs BitNet sparsity → refined. Address sparsity (dust_percentage) = 0.99951 for every field — a category error vs BitNet, which has no empty address space. The fair value-sparsity (zero fraction over stored (cell,dim) amplitudes) is population-dependent: 0.137 uniform-random (≈ the 1/8 prior — the metric is honest) · 0.835 realistic populator · 0.6625 only when deliberately tuned to BitNet's 0.66 · spread 0.698. BitNet's% is learned; the field's rate is structural / data-dependent. → The sparsity-equivalence sub-claim (§3.3) is weakened, not confirmed; the lattice unification itself (§3.1–3.2) is untouched.

X4 — converge_step contraction instrument → supported (semantics). On synthetic trajectories of known type (eps = 0.05, max_steps = 12): contraction h_t = h* + 0.5^t(h_0−h*) → deltas [0.50, 0.47, 0.39, 0.25, 0.13, 0.068, 0.034], exits stepauto/issue-732fixed_point; orbit (constant-norm rotation) → rel pinned at 0.134, max_depth, no false fixed_point; divergence 1.3^t·h_0 → rel 0.30, max_depth. The instrument faithfully reports contraction and is not fooled by orbits or divergence. Honest caveats: this validates the measurement semantics against a faithful reference implementation, not a real Ouro trajectory — the verification ran on branch auto/issue-732 where loop_lm.converge_step is absent (it ships here on research/convergence-tesseract-spiral, loop_lm.py §3); the optional real Ouro-1.4B CPU run failed cleanly on a huggingface-hub version conflict (torch is CPU-only).

Still open: X1 (CSF round-trip integrity) and X2 (wavefront minimality) — not yet run.

7. Honest scope

• The mapping (§3) is the contribution; the lattice itself is pre-existing code.
• The axis semantics in §2.2 are a design proposal, not measured behaviour.
• {-1,0,+1} (balanced) vs {0,1,2} (the engine's current unsigned pos % 3) differ by a

−1 shift; the engine stores unsigned today. Adopting balanced ternary end-to-end is a follow-up, not a claim of current state.

• "Tesseract / lattice" is geometry (3-cube × axes), not a physics result.
• This is all inference-time / storage-time: no pretraining, no weight modification —

consistent with the North Star ("learning through retrieval, not retraining").

8. What changes in the repo (consolidation, not addition)

Tracked by the comet leap COMET-LEAP-P2-TESSERACT-CSF-SINGULARITY.md:

1. This doc becomes the single design reference for the 3**12 lattice.
2. CSF-FORMAT-SPECIFICATION.md gains a "lattice view" pointer

(qutrit_delta = the storage face).

1. RESEARCH-CANON.md gains the external anchors above under the right

components.

1. convergence-core-mapping.md reclassifies CSF from

"implementation-detail leak" to "storage face of the lattice."

1. research/2026-06-19-convergence-tesseract-spiral.md

gains the STARS citation (closes its non-normal gap) and a cross-link here.

1. skills/convergence-mathematical-foundations

gains a "3¹² Convergence Lattice" section.