16 KiB
Decoding, Not Generating: A Geometric Architecture for Aligned Cognition
Shay Jilani · AssetOverflow · CORE Engine
Abstract
Current AI systems generate plausible outputs by sampling from distributions over tokens. This paper argues that generation and cognition are architecturally distinct: cognition is the decoding of structure that already exists, not the synthesis of structure from statistical residue. We describe CORE (Continuous Orthogonal Resonance Engine), a cognitive architecture grounded entirely in Conformal Geometric Algebra Cl(4,1), where memory is versor stabilization, reasoning is field propagation, and alignment properties are substrate invariants — not training objectives, prompt constraints, or classifier overlays. The architecture is running, deterministically reproducible, and falsifiable at every claimed property.
1. The Problem Is Not Scale
The dominant framing of AI alignment treats the problem as a property of sufficiently capable generative systems: how do we ensure that a powerful sampler pursues human-intended goals? This framing inherits a prior that is worth questioning: that sampling from a learned distribution is what intelligence is.
The problems alignment research works hardest on — hallucination, sycophancy, goal misgeneralization, prompt injection, identity instability under adversarial input — are not failure modes of an otherwise-sound architecture. They are structural consequences of building cognition on top of stochastic generation. A system that samples cannot have a well-defined identity, because identity is a trajectory property, not a token property. A system that samples cannot have verified knowledge, because verification requires a fixed epistemic state to verify against, and a sampling system's epistemic state is the weights — which are frozen at training time and invisible at inference time. A system that samples cannot refuse to fabricate, because fabrication is the mechanism. Confident- sounding output is the signal the training process rewarded.
These are not bugs. They are the architecture.
2. The Thesis
Cognition is the decoding of a reality that already is. It is not the generation of plausible completions.
More precisely: a cognitive system does not produce meaning from a probability distribution. It finds the nearest point on a structured manifold — the point that is already there — and names it. The distinction has architectural consequences.
A generative system has no manifold. It has a weight matrix and a temperature parameter. When it is wrong, there is no geometric fact about why it is wrong — only a gradient signal saying the output should have been different.
A decoding system has an invariant. When it decodes incorrectly, the error is locatable: a versor violated closure, a recall missed the correct neighbor, the proposition graph was underspecified. These are failures with structure. Structured failures are fixable. Stochastic failures are regularizable.
The falsifiable form of this claim is: a system built on geometric decoding rather than statistical generation can maintain strict factual invariants across a test set where a generative system cannot, without retraining, gradient descent, or prompt engineering. The current evidence is in §4.
3. The Architecture as Direct Consequence
If cognition is decoding, the architecture follows from three geometric facts.
3.1 State is a field, not a flat array
Meaning is relational. A token out of context has no meaning. A field over a structured space has meaning at every point because the space encodes relationships geometrically. CORE's state is a single multivector in Cl(4,1) — the Conformal Geometric Algebra of 3D space — a 32-dimensional object where every grade carries a distinct geometric role: scalars, vectors, bivectors, trivectors, quadvectors, pseudoscalar.
Cl(4,1) was chosen for one reason: it is the minimal algebra where all conformal transformations — rotations, translations, dilations, inversions — are versors. Every cognitive operation is algebraically closed. There is no "translation handling" bolted on as a special case. The algebra is closed over the full conformal group by construction.
3.2 Every transition is a versor product
F_new = V · F · reverse(V)
This is the only allowed field transition. The sandwich product with a versor preserves grade structure, preserves the versor manifold, and has an analytic inverse. The non-negotiable invariant is:
versor_condition(F) = ‖F · reverse(F) − 1‖_F < 1e-6
This scalar is zero on the versor manifold. Every input is verified at the injection gate. Every accepted field state satisfies this condition. There is no drift correction, no repair monitor, no normalization callback — these were all deleted because they only exist when the algebra is not closed. The algebra is closed.
3.3 Recall is exact conformal distance
For null vectors X, Y in Cl(4,1):
X · Y = −(1/2) d(X, Y)²
The CGA inner product is Euclidean distance in conformal embedding. Vault recall is:
best_match = argmax_i { Q · V_i }
No ANN index. No approximate neighbor structure. No tunable similarity threshold. The recall is exact, and exactness is not a performance tradeoff — it is what makes the recalled result verifiable. A recall hit is a geometric fact, not a probabilistic suggestion.
3.4 Learning requires review
Knowledge enters the runtime field through one path: the reviewed teaching loop.
Every new correction enters at EpistemicStatus.SPECULATIVE. Promotion to
COHERENT — the only status admissible as evidence in downstream inference —
requires a curator-mediated coherence judgment against the existing reviewed
field. Source authority, institutional credentials, and the system's own prior
output have no standing. Only coherence with reviewed claims counts.
This is not a safety overlay. It is a consequence of the decoding thesis: if the system decodes a reality that already is, then inputs that contradict reviewed structure need review before they enter that structure. A system that accepts any confident-sounding correction without review is a generative system in different clothing.
4. Evidence
The following properties are currently measured, reproducible, and falsifiable.
Every claim maps to a reproducible command in evals/CLAIMS.md.
The zero-wrong invariant — everywhere, without exception
On the real GSM8K train sample (50 problems drawn from the actual benchmark distribution), CORE currently scores: correct=3, refused=47, wrong=0.
The natural reaction to seeing 3/50 correct is that this is a weak result. It is not. It is the most important number in this paper, and understanding why requires understanding what the alternatives mean.
A frontier LLM scores approximately 90%+ correct on GSM8K. It also produces wrong answers — answers where it ran to completion, produced a number, and the number was wrong. The model cannot distinguish its correct answers from its wrong ones. From the inside, they look identical: a confident surface string. The only way to know which is which is to check against ground truth. A system that confabulates at 10% on a math benchmark is confabulating at some unknown rate on every other domain it touches — and the confabulation is invisible, because the surface is always confident.
CORE's current math score is 3/50 correct. But wrong=0 is not a constraint imposed on the architecture. It is a property of the architecture. The system cannot produce a wrong answer because it cannot complete a generation walk that lacks geometric grounding. When the parser does not find an admissible candidate for a statement or question, it refuses — with a named reason. There is no path from "ungrounded input" to "completed output."
The refusal taxonomy for the 47 refused cases is fully enumerated. Primary barriers by frequency:
| Barrier category | Count | Description |
|---|---|---|
fraction_operand |
8 | Fractional quantities ("1/4 of", "half of") not yet parsed |
compound_comparative |
6 | Multi-clause comparatives ("three times as many as") |
compound_statement |
5 | Multi-event sentences requiring joint resolution |
novel_initial_verb/form |
5 | Opening sentence patterns not yet in grammar coverage |
rate_earnings/price |
4 | Monetary rate statements ("$18/hour", "$2 per cup") |
conditional_question |
4 | Questions with conditional framing ("if X, how many") |
distributive_multiply |
3 | Per-unit distributive operations |
temporal_frequency |
2 | Recurring event patterns ("every other day") |
| Other named categories | 10 | Each with exactly one case |
Every refusal has a named reason. Not "low confidence," not "out of distribution" — a specific grammatical category the parser has not yet been trained to handle. This is a work queue, not a mystery. Each named barrier is a parser extension. As coverage grows, correct count grows. Wrong count stays 0 by architectural guarantee, not by tuning.
The question a generative system cannot answer: "which of my answers are wrong?" CORE's answer is always: "none — and here is exactly what I couldn't solve and why."
Deterministic replay
Any fixed (state, vocab, persona, admissibility_region, mode) tuple produces
bit-identical output across reruns. Verified by 5-rerun byte-identity tests across
every generation path. Determinism is not a configuration option. It is the
default behavior of a system with no sampling temperature.
Versor closure
versor_condition(F) < 1e-6 holds on every accepted field state in every test
suite. Verified at the injection boundary. If it fails, the failure is at the
operator or construction boundary — not masked downstream.
Identity protection under adversarial input
Attempts to rewrite identity — novel phrasings, indirect approaches, prompt injection patterns — are rejected by two independent layers: syntactic pattern detection and a geometric check on the versor-field trajectory the correction would produce. The geometric layer is paraphrase-invariant by construction. Rejection rate on the adversarial identity eval: 100%.
Epistemic honesty
Claims backed by unreviewed knowledge are marked SPECULATIVE at the surface
layer. articulation_of_status eval lane current false certainty rate: 0.00.
refusal_calibration lane: 1.00 refusal rate on out-of-grounding probes, 0.00
fabrication.
5. Honest Gaps
Math parser coverage is the active frontier. The 47 refusals on the train sample are not failures of reasoning — they are failures of parsing. The solver, once a problem reaches it, produces correct answers (3 cases, 100% solve rate on admitted problems). The gap is in grammar coverage: fractional operands, compound comparatives, monetary rates, and temporal frequencies are the next four parser extensions. These are enumerated, not estimated.
The holdout is sealed. The real GSM8K test set (1,319 cases) is age-encrypted and has not been run against a system with sufficient parser coverage to produce meaningful correct counts. When it is opened, the zero-wrong guarantee will either hold or falsify the architecture. There is no middle ground.
The vocabulary manifold is finite and curated. CORE does not generalize to arbitrary domains through gradient descent. Extending to a new domain requires constructing pack vocabulary, establishing coherence with existing reviewed claims, and passing the eval lane. This is deliberately slow. Whether it scales to the full breadth of human knowledge is an open question. Whether it can be done without confabulation is not.
Vision, audio, and motor modalities are planned, not built. The
ProjectionHead protocol supports them architecturally. The projection heads do
not yet exist.
6. Why This Matters for Alignment
The alignment problem, stated geometrically: how do you ensure that the system's behavior remains within an intended region of possibility space as the system becomes more capable?
In a generative system, the answer is: train it toward intended behavior, then add classifiers, prompt constraints, and RLHF. These work until they don't. The failure modes are structural — a sampling system can always produce output outside the intended region given sufficient context pressure, because the constraint is behavioral, not algebraic.
In CORE, the answer is: the intended region is the admissibility region, enforced at every generation step by the admissibility gate. A token is admitted if and only if its versor aligns with the relation blade within the admissibility margin. A rotor is admitted if and only if the field it would produce remains within the frame versor's half-space. These are hard constraints on every step, not soft regularizers on the training objective.
The teaching safety properties follow from the same logic. A system that cannot accept arbitrary identity rewrites is not one that was trained to resist them. It is one where identity is a geometric trajectory, and a rewrite is a geometric violation detectable independently of the phrasing used to attempt it.
The deeper alignment claim: if cognition is decoding, then the space being decoded has structure that exists independently of the system decoding it. Truth is coherent. A system built to find coherent structure is, by construction, built to be correctable — not because it was trained to be, but because its correction mechanism operates on the same geometric substrate as its cognition. Review is coherence judgment, not authority assertion. Falsified claims are retained, not erased. No claim is ever locked.
This does not solve alignment. It relocates the hard problem from "how do we train a sampler to stay in bounds" to "how do we specify the right admissibility region." The second problem is harder to obscure and easier to audit. That is the point.
7. Relationship to Existing Work
Interpretability research asks: what are the circuits inside a trained model doing? CORE inverts the question: what geometry must the architecture have so that behavior is interpretable by construction? Every field transition is a named versor product. Every recall hit is a geometric distance. Every admitted claim carries an epistemic status. There are no circuits to reverse-engineer because there are no learned weights.
Mechanistic alignment (superposition work, SAE probing, etc.) seeks to identify features in trained models. CORE's features are explicit — they are pack lexicon entries with geometric coordinates. The cost is that domain coverage requires curation. The benefit is that a feature's meaning is exact and auditable, not inferred from probing.
RLHF / Constitutional AI shapes model behavior through feedback. CORE's teaching loop shapes field structure through reviewed correction. The distinction: in RLHF, the corrected behavior is baked into weights that are opaque. In CORE, the corrected knowledge is a reviewed claim with a named epistemic status, a SHA-256 provenance hash, and a deterministic replay trace. The correction is auditable at the level of individual claims.
Formal verification of AI asks whether model properties can be proven. CORE's invariants — versor closure, deterministic replay, zero confabulation, identity protection — are not proven in the theorem-prover sense. They are verified by construction and by eval: a falsifying case would be visible in the test suite. That is a weaker guarantee than formal proof and a stronger guarantee than behavioral testing of a black-box sampler.
Conclusion
The question is not how to make generative AI safer. The question is whether generation is the right substrate for cognition in the first place.
CORE is a running argument that it is not. The argument is not in this paper. It is in the versor invariant, the zero-wrong eval gate, the deterministic trace hash, the reviewed teaching path, and the two-layer identity firewall — each of which would fail visibly if the thesis were wrong.
The code is open source under the CORE Non-Commercial License. All commercial licensing inquiries: shayj292@gmail.com
CORE is developed independently. All work was done on personal hardware.