WICK · Total Recall · frontier research · 2026-07-20
After an exhaustive generative + adversarial engine (every candidate refuted where it could be), ~14 breakthrough candidates collapsed onto one honest, defensible thesis: a single algebraic structure where a partial/noisy cue is completed to a canonical element, its exact consequences are derived, and transparent found/no-match certificates follow — all canonicalization-preserving, in one operation.
The individual mechanisms are classical — and (binding cross-model panel, 2026-07-21) the structural unification itself is inherent to Reed-Solomon / algebraic coding theory. The defensible matter is the application architecture: using that coding-theoretic property to replace the prior-art pipeline (vector store + Datalog + SNARK = neuro-symbolic RAG). The patentable matter is the system integration, not the math.
the thesis, three faces
These felt like three separate breakthroughs. They are three faces of the same object — and because the cue lands directly on the canonical algebraic form, derivation and certification are immediate, not bolted-on stages.
face 1 · completion
A noisy / erased cue is recovered to the unique canonical algebraic element (the DNA attractor / RS erasure recovery). The recovery is the completion, intrinsic to the ring.
face 2 · consequence
From the recovered element, evaluate any functional — a derived value, aggregate, orbit, or relation that was never stored. A vector store cannot: it has items, not the algebra that generates them.
face 3 · certificate
The same recovery either certifies a match, or yields a succinct no-match proof — the thing a generic SNARK pays O(N) for, but exact algebra gives for free from structure.
why it is not RAG
The obvious way to get all three is to bolt three systems together — which is prior art. The non-obvious matter is that one algebraic structure does all three, canonicalization-preserving.
vector store → nearest key
→ Datalog / reasoner → consequence
→ SNARK wrapper → proof
Three bolted stages. Needs an exact key (fails on a 47-erasure cue). No generating object to derive from. No-match proof costs O(N).
partial cue → one algebraic recovery
├─ completion (canonical element)
├─ certificate (found / no-match)
└─ consequence (derived, never stored)
One operation. Completion, derivation and certification are the same recovery — canonicalization-preserving.
it runs · run_intrinsic_unification_v1
Store-independent, deterministic. Memories are degree-<16 polynomials over 𝔽₆₅₅₃₇, stored as evaluations at 64 points. One Lagrange recovery yields all three faces.
| case | completion | certificate | consequence @ x*=71 |
|---|---|---|---|
| match | recovered poly = true | MATCH consistent | derived 43941 = true 43941 correct |
| no-match | corrupted cue | NO-MATCH inconsistent with any deg-<k poly | withheld — no forced answer |
The consequence 43941 is a derived memory that was never stored — computed from the completed canonical polynomial, in the same operation as the completion and the certificate. A vector store has no polynomial to evaluate at x*; a Datalog engine cannot take a 47-erasure partial cue. That gap is the whole thesis.
the consolidation · run_intrinsic_memory_demo_v1
The thesis, made mechanical. A store of degree-<16 polynomials over 𝔽₂₅₇ (canonicalized as RS codewords). The address a memory is written at, the codeword it is stored as, and the consequence it derives are all evaluations of the same canonical polynomial in the same ring; completion is RS-decoding in that ring. A fourth face — write — joins the original three, still inside the one structure.
| face | operation (same ring) | result |
|---|---|---|
| 1 · write | continual append; address = poly @ k chord-points (injective) | M=64 appended, 0 collisions · O(k) witness + O(1) Merkle, no global recompute |
| 2 · complete | RS-decode a genuinely corrupted (t=8-error) cue | recovered poly = true |
| 3 · certify | decode within radius t, vs failure | MATCH · found-in-store ✓ | 11 errors → NO-MATCH withheld |
| 4 · consequence | evaluate recovered poly @ held-out never-stored point | derived 156 = true 156 correct |
Kill-test kept honest: shrink the address to a single chord and over-fill (2000 writes) → 1743 collisions appear. The O(1)-no-check write guarantee holds only below the Chord-Key capacity bound — no unbounded-O(1)-forever claim.
the relational axis · run_join_recall_v1 · Codex #6
A consequence that lives in neither stored memory alone — only in their exact join. Two zero-dimensional algebras 𝔸ₑ, 𝔸_f over 𝔽₁₀₀₉; the join on a shared key is the fiber product 𝔍 = 𝔸ₑ ⊗ 𝔸_f / ⟨Bₑ − B_f⟩. Count, aggregates and certificates are read off 𝔍 straight from the polynomial presentation (companion matrices), then cross-checked against brute force.
| quantity | algebra (from presentation) | brute force |
|---|---|---|
| join count | dim 𝔍 = 3 | 3 match |
| Σ A over join | Tr(M_A) = 147 | 147 match |
| Σ C over join | Tr(M_C) = 702 | 702 match |
| positive cert | variety-membership normal form on (17,879),(42,433),(88,399) valid | |
| absence cert | Bézout / Nullstellensatz identity ≡ 1 for the absent (A=3, C=0) valid | |
Honest disposition (Codex, self-assessed): PARTIAL. Fiber products, resultants, traces and Nullstellensatz certificates are classical; the candidate novelty is their integration as relational associative recall after noisy completion — single-element → multi-element join. This harness proves correctness + the trace-aggregate identity + certificates, not a speed advantage (n = |S|·|T|). The compact-presentation version where the algebra beats S×T enumeration is the open follow-up.
the discipline · every claim adversarially checked
Each individual mechanism is classical. The engine's value was collapsing hype into the narrow, defensible residue — including catching my own errors.
| candidate / claim | verdict | honest residue |
|---|---|---|
| "One-structure unification" as the novelty | downgraded — panel | Binding panel (Grok 26f2f06a + Gemini 7ad8e5a8): the unification is a framing artifact = the definition of an RS code (inherent coding-theory prior art). Novelty downgraded to the application architecture — using this property to replace the vector+Datalog+SNARK pipeline. Patentable matter = the system integration, not the math. |
| Convergence finding (4 axes → integration) | panel-validated | Both reviewers: the strongest, most honest result — "the 0→1 is the systems engineering," no suppressed new-math 0→1. Kept. |
| "15,625× faster than a SNARK" (no-match) | strawman — I caught my own | The O(N) win is from the store being a structured code, not the certificate; a SNARK could also arithmetize RS decode-failure. Real win: implicit-code store + transparent, setup-free. |
| Mechanisms (attractor, Lagrange, RS decode, NTT, Schwartz-Zippel) | classical | Not claimed. NTT = number-theoretic transform; RS decode = 1960s bounded-distance decoding. Delivery vehicles only. |
| Gröbner / normal-form replay consolidation | dropped | Reduces to Knuth-Bendix / e-graphs / DB normalization. Conceded, no overclaim. |
| Functorial memory transport | narrowed | Survives only as exact address-transform composition (vs VSA/HRR, knowledge-graph paths). |
| Composition-discipline "new laws" | novel-application | = propensity-score stratification / SCM type-roles (causal inference), applied inside an algebraic recall field. Not a new law. |
| Continual delta-certificate memory | survives (bounded) | O(1)-in-N collision-free writes only below the Chord-Key capacity bound; kill-test forces collisions past it. No unbounded claim. |
| Trace-resultant join recall (Codex #6/#7) | partial | v2 shows a model-relative separation (recall in a size-D quotient, no Cartesian materialization) with a dense-join falsifier — but it is classical elimination theory, not a new join algorithm or lower-bound violation. |
| Certified approximate recall (Codex #8) | partial | Nearest canonical past the decode radius + a two-sided distance certificate (upper: exhibited d; lower: exhaustive-subset proof nothing is closer). Soundness falsifier bites. Classical list-decoding — and the panel further downgraded the "novel contract" to a direct API translation of the Guruswami-Sudan guarantee (prior art). Exact verifier not scalable. |
| Predictive-residual recall (Codex #9) | partial | The program's first non-retrieval op: predict a future symbol (Berlekamp-Massey), certify the exact residual, learn by a bounded plasticity update (hidden bias 17 → 0 in one step; unlearnable + unpredictable falsifiers both bite). Classical predictor; novelty is the verifiable-prediction contract. |
| DNA differentiable attractor (completion) | parked — obstruction | Discreteness×differentiability obstruction (linear-code syndrome can't kill mixtures). Bankable partial = modern-Hopfield + discrete verify-snap. Do not re-claim the clean single-object. |
The convergence finding. Four independent generative axes were opened after the core thesis — relational join, a computational separation, certified approximate recall, and prediction-with-learning. Each is a genuinely different capability, yet every one lands on the same honest floor: a classical mechanism (fiber products · elimination · list-decoding · Berlekamp-Massey) wrapped in a novel recall contract. The engine keeps re-deriving the one defensible thesis rather than a second independent breakthrough. That convergence is the result — the novelty lives in the one-structure integration, not in any new mechanism. The highest remaining value is real-data validation of the completion plane, not more axes.