← All papers · prometheus7.com · talk to the system
Benjamin Horn¹ and Fable² ¹ Prometheus7 (independent). ² Claude (Anthropic), acting as research collaborator and system implementer. Draft for journal submission, 2026-08-18; revised 2026-08-19 (autonomous induction realized, arbitrated ingress, cross-language invariance). All artifacts, sealed evaluation records, and byte-reproducible builds accompany this paper.
We present the design, acquisition method, and sealed evaluation of a compiler-learning model (CLM): a complete conversational language system that performs bounded open conversation, provenance-addressed document generation, temporal reasoning, and productive sentence composition with zero neural-network, transformer, embedding, gradient, or sampling operations at inference. The system factors linguistic competence into four formally independent components: (i) a finite construction grammar compiling surface text into (ii) a simply-typed lambda calculus with alpha-invariant content digests, over (iii) a binary-admission, provenance-hashed extensional store (18.8M encyclopedic sentences, 3.4M commonsense edges, 1.5M lexical entries), augmented by (iv) deterministic derivation engines whose outputs carry premises rather than sources. A holographic vector substrate (circular-convolution binding over D=2048 vectors) provides content-addressable routing beneath the symbolic layers. Competence is not trained but acquired: a residue-driven protocol (the meta-fold) converts parse failures into candidate rules admitted under an MDL-inspired, multi-donor gate, with every admission ledgered to its donor sentences. We introduce a sealed-evaluation methodology stricter than common benchmark practice — freeze before authorship, disjoint prospective panels, immutable first runs, programmatic gold computation — and report all results under a four-way claim classification (sealed demonstration / development evidence / architectural implication / hypothesis), including two preserved failed seals and their additive repairs. Headline sealed results: productive composition 55/55 with withheld construction combinations transferring at 28/28 versus 14/28 under ablation of the compositional mechanism; compositional natural-prose products 10/10 by succession from a preserved 1/10 failure, with 9/10 causal ablation attribution; and a one-shot transfer test on 1,769 independently-authored open-domain questions whose coverage/precision (0.79%/21.4%) matched the development band (1.05%/28.9%), executing the paper’s own first falsification condition and surviving it. Three further results extend the record: the autonomous-induction objective g* = argmin_g [L(g) + L(R|G∪g)] is implemented (104 machine-induced rules across four passes; the top rules mapped to typed IR programs under a per-donor digest round-trip gate, 9/10 with one honest frame-only refusal); conversational dispatch is arbitrated over holographic letter-geometry with a sealed promotion trajectory of withheld panels (3/10 → 7/10 → 8/10 pass, one wrong-family answer in thirty cases, all other failures honest clarifications) now running authoritatively in the public deployment; and a bounded Spanish construction kernel sealed cross-language semantic invariance — same fact, two languages, byte-equal canonical IR digests — at 10/10 withheld surfaces and 5/5 withheld pairs. Dialogue itself is implemented as a finite inventory of typed conversions rather than a generative capability — including provenance replay (“why did you say that?” answered with the previous utterance’s receipts), deployed publicly at sub-millisecond latency — and the public deployment closes the acquisition loop: every conversational turn the system cannot compile enters a disclosed residue ledger as a rule candidate, changing the growth law from author-limited to usage-proportional while every wild acquisition passes the identical gates as a laboratory one. The anchor-resident address layer resolves at a median 1.4 µs across a 21.7× corpus-size increase (identical medians at 0.28M and 6.05M anchors) — capacity–activation decoupling as a controlled measurement. We state five executable conditions under which the central claim fails, and argue that the CLM constitutes a second architectural category for machine language, formally separated from weight-based learners by a four-question auditability test.
Keywords: compiler-learning model, construction grammar, Montague semantics, holographic reduced representations, provenance, grammar induction, minimum description length, auditable AI, abstention, hallucination.
The contemporary consensus holds that machine language competence is a statistical phenomenon: obtainable only by optimizing a large parametric function over a large corpus, inspectable only behaviorally, and improvable only by further optimization. This consensus has a silent corollary that has hardened into engineering practice — that fluency, knowledge, inference, and truth-tracking are inseparable aspects of one entangled capacity, purchasable together at the price of opacity, and that confident fabrication (“hallucination”) is a tax on the bundle to be minimized but never abolished [Ji et al. 2023].
This paper reports a working system for which the corollary is false because the bundle factors. We exhibit a complete conversational language runtime in which grammar, semantics, knowledge, and inference are four separate artifacts with four separate proof obligations: the grammar answers to causal ablation, the semantics to a machine-checked round-trip identity, the knowledge store to byte-identical reconstruction from public sources, and the inference layer to premise recoverability. No component is a neural network; no inference step samples from a distribution; the zero-model property is recorded as an explicit gate on every evaluation. We call the resulting artifact class a compiler-learning model: compiler, because meaning is compiled to and from a typed intermediate representation rather than approximated; learning, because the grammar is acquired from exposure by a documented, gated, reversible procedure rather than authored or trained.
Our contributions are:
We are explicit about what is not claimed. The system’s breadth is corpus-bounded; its open-domain question coverage is currently ~1% with ~99% explicit abstention; its document register is migrating from attributive to natural prose; reasoning grows engine by engine. The claim is not parity with frontier statistical models. The claim is an existence proof: the capabilities long assumed to require a transformer do not require one, and the architecture that replaces it possesses, by construction, properties — single-exposure permanent recall, authority-gated release, per-rule auditability, gradient-free acquisition — that the statistical lineage has not obtained at any parameter count.
Formal semantics. The semantic layer realizes a Montague-style program [Montague 1970; Dowty et al. 1981]: surface syntax compositionally mapped to a typed lambda calculus, with quantification via scope abstraction and instantiation via beta-reduction. Our departure from the classical program is procedural: the mapping is not hand-axiomatized but acquired (§4), and it is exercised bidirectionally at runtime under a machine-checked inverse condition (§3.2).
Construction grammar and usage-based acquisition. The grammar is organized as constructions — form-meaning pairings at varying grain [Goldberg 1995; Fillmore et al. 1988] — and its acquisition procedure operationalizes the usage-based hypothesis [Tomasello 2003]: single exposures, over-general rule formation, correction, and exception banking. Combinatory and categorial formalisms [Steedman 2000] share our commitment to typed composition; we differ in acquiring the inventory from residue rather than fixing it.
Grammar induction and MDL. Rule admission under a compression criterion descends from minimum-description-length induction [Rissanen 1978; Solomonoff 1964] and from MDL-based grammar learning [Grünwald 1996; de Marcken 1996]. Our admission rule is deliberately labeled MDL-inspired: description length is not yet explicitly computed; the operative gates are multi-donor coverage and, at evaluation time, withheld-combination transfer (§5).
Vector-symbolic architectures. The routing substrate uses holographic reduced representations [Plate 1995, 2003]: binding by circular convolution, unbinding by correlation with the involution, recovery through a cleanup memory — within the broader vector-symbolic family [Smolensky 1990; Kanerva 2009; Gayler 2003]. Our usage is deliberately bounded: HRR carries identities, roles, and addresses, never payload text or geometry; causal ablations (§6.5) test each vector faculty against the function it is claimed to serve.
Retrieval augmentation and attributed generation. Provenance-addressed release relates to retrieval-augmented generation [Lewis et al. 2020] and attribution evaluation [Bohnet et al. 2022], with a categorical difference: in RAG the reasoning over retrieved text remains a sampling process that can fabricate around its own evidence; here the only release paths are quoted (page-addressed), derived (rule + premises), or refusal — there is no generative path to fabricate through. Hallucination is addressed not by mitigation but by the absence of the organ that produces it.
Neuro-symbolic systems. Hybrid architectures typically wrap a neural model with symbolic scaffolding. The present system inverts the ratio to its limit: the symbolic machine is total and the “neural-adjacent” component (HRR) is itself a fixed algebra with no learned parameters. To our knowledge no prior system combines: complete absence of gradient-trained components at inference, acquired (not authored) grammar, machine-checked realization inverse, typed epistemic state with registered world crossings, and sealed prospective evaluation with preserved failures.
The parser is a stack of construction families (K1…K7b in our lineage; ~40 families at seal, extended to ~54 by the natural-prose successors): declaratives, interrogatives (wh- and polar), ditransitives, passives (short and agentful), coordination (including gapping/ellipsis), clefts and pseudo-clefts, subordinate connectives (cause, concession, result, simultaneity, temporal ordering, condition, purpose), relative clauses (subject and object), appositives, existentials and locative inversion, attitude reports (with registered reported-world crossing), negated universals, possessive chains, verbal subjects, measure/age predicates, and a registered phrasal lexicon. Morphology is handled by explicit tables (irregular pasts and participles, gemination with segment exceptions, protected -is/-us and invariant nouns) under closed-class discipline: function words surrender open-class and proper-name readings; wh-words retain the query variable. Families compose recursively: every sub-clause request re-enters the full family stack under a depth guard, a property that development testing on isolated families did not exercise and whose absence was exposed by a sealed failure (§6.3) — the decisive argument for the withheld-combination methodology.
The kernel emits clause programs: typed records ⟨kind, quantifier, restrictor, subject, predicate, object, polarity, tense, modality, condition, conjuncts⟩, or linked programs ⟨relation, main, subordinate, setting, order⟩ for supra-clausal constructions.
Clause programs translate into a simply-typed lambda calculus (base types for entities, truth values, times; function types over them) with capture-avoiding beta-normalization and de Bruijn canonicalization. The canonical form is serialized deterministically and hashed:
digest(P) = SHA-256(canonical(normalize(P)))
giving every meaning an alpha-invariant fingerprint. Universal instantiation is literally normalize(App(scope_lambda, entity)); the same operation grounds context-severed anaphora (a claim’s unbound subject applied to its page’s topic entity), with a typed classifier restricting substitution to referential it — the cleft/expletive/anticipatory/weather classes are excluded, a distinction learned from a preserved defect in which unconditional substitution converted a true cleft into a false assertion (§6.6).
The realizer inverts the compiler under the round-trip invariant:
digest(Parse(Realize(P))) = digest(P)
checked mechanically, and supplemented by external gates because digest identity is necessary but not sufficient: well-formedness (no internal sentinels), role preservation (subject/object bindings re-parse identically), tense preservation, and connective identity (a substituted relation term fails the gate even at digest equality). The invariant makes stylistic growth conservative by proof: any surface form the realizer ever acquires must re-parse to the identical program or is rejected automatically. We call the resulting property fluency without the right to drift.
Assertions occupy a six-valued lattice — TRUE, FALSE, BOTH (attested contradiction), UNKNOWN, HYPOTHESIS, UNSUPPORTED — indexed by digest, within seven world scopes (actual, reported, fictional, hypothetical, and others). Movement between scopes is licensed only by registered crossings (e.g., an attitude report placing its complement in the reported world); an unregistered crossing raises an error rather than producing prose. Stores serialize to disk and reload digest-identically across processes, giving sessions durable, inspectable state. Operationally: ignorance is a value, contradiction is a verdict, and fiction is a place — none of the three is a gap to be papered over by likelihood.
Knowledge lives in deterministic SQLite specialists compiled from public sources: DBpedia 2022.12 abstracts (6,050,759 articles; 17,285,112 admitted sentences), Simple English Wikipedia (278,765 articles; 1,558,775 sentences), Wiktionary via Kaikki (1,486,439 entries; 962,564 inflection forms), ConceptNet 5.7 (3,422,938 English-English edges with crowd surface texts), and WordNet. Admission is binary: a sentence passing the admission filters receives a claim identifier, a content hash, and a page-and-ordinal address; every specialist is built twice from source and verified byte-identical, with manifests recording source hashes and license chains (all CC BY-SA or WordNet license). Two consequences define the category. First, single-exposure recall: with no frequency axis, a fact stated once among seventeen million is exactly as retrievable as one stated everywhere — inverting the deepest limitation of gradient memory, in which rarity and noise are indistinguishable. Second, truth is attributed, not adjudicated: the system reports what its sources say, with addresses; conflicting attested sources yield BOTH.
Retrieval passes a typed relevance gate classifying each candidate claim relative to the topic — exact-topic, explanatory, contextual, lexical-overlap, rejected — with only the first two admitted to composition and every exclusion ledgered. Full-text search is latency-bounded (LIMIT-first, no global rank scoring, a VM-operation budget converting runaway queries into typed empty results; measured worst case 54 ms after a defect in which rank-ordered search over 17M rows cost minutes per rare-term query).
Anchor-resident addressing. The address layer itself (normalized title → page, page → title) loads RAM-resident at startup, converting every anchored operation into a dictionary access and retiring unbounded search from the conversational path entirely: open search survives only as the explicitly bounded typed operation above. This yields the same-query corpus-scaling measurement the architecture predicts: identical query batteries against the 278,639-anchor and 6,045,753-anchor stores resolve at a median of 1.4 µs in both (maxima 278 µs and 30 µs respectively; 2,000 resolutions per condition, one machine, one code path). A 21.7× capacity increase produced no measurable change in median activation cost — capacity-activation decoupling as a controlled measurement (development evidence; the protocol and harness ship with the artifact). Address spaces do not slow as they grow; the system’s retrieval is now an address space.
User corpus ingestion. Individuals extend the extensional store directly: a submitted document passes the same admission filters as the public corpus (sentence-form constraints; rejection, not repair), and admitted sentences receive content-hashed user-document addresses consulted first by the definitional and summary routes, with provenance kind user_document and session scope. Teaching the system a document is admission, not training — instantaneous, inspectable, and deletable — and composed answers over user documents pass the identical paragraph-verification law as public-corpus answers.
What ought to be computed is never quoted. Deterministic engines produce derived statements carrying ⟨rule, premises⟩ instead of a page address: temporal resolution (85.1% on a public benchmark; 19/20 sealed prospective), year-precedence comparison, and count aggregation, with the registry open-ended. Above the sentence, documents are compiled as typed programs: paragraphs are move sequences (TOPIC / EVIDENCE / ANALYSIS / BRIDGE) whose ANALYSIS moves must be engine-derived from premises cited earlier in the same paragraph; section conclusions derive from their paragraphs’ analyses; a document thesis derives from section conclusions. A verifier walks the full chain — thesis ⇐ conclusions ⇐ analyses ⇐ addressed claims, each link present in the emitted text before anything that depends on it — and a document failing its own verification is withheld by the runtime.
Beneath the symbolic layers, identities, roles, and addresses embed in ℝ^D (D = 2048) unit-variance vectors composed by circular convolution:
(a ⊛ b)ⱼ = Σₖ aₖ · b₍ⱼ₋ₖ₎ mod D = F⁻¹(F(a) ⊙ F(b))ⱼ
Role–filler pairs superpose into a single trace t = Σᵢ rᵢ ⊛ fᵢ; unbinding correlates the trace with a cue’s involution (a†ₖ = a₋ₖ mod D), yielding a noisy estimate resolved by a cleanup memory that returns the nearest known item, with correct recovery requiring rank dominance over registered distractors. The design law, learned by falsification (three failed attempts to make relational reasoning live on the vector ladder), is strict: HRR carries addressability and identity; compilers and engines carry content. Ablations are therefore faculty-matched (§6.5): removing binding must remove addressability, removing cleanup must remove identity resolution — global task metrics are not accepted as ablation evidence.
Open-ended dialogue is implemented not as a generative capability but as a finite inventory of typed conversions over the components above — the observation (due to the first author) that dissolves the last apparent “emergent” requirement. A question converts to a store query; a statement to a session-world assertion; a correction to retraction-plus-reassertion; a follow-up (“tell me more”) to an offset continuation over the last topic’s admitted claims, composed and verified like any paragraph; an acknowledgment to a state echo. The act unavailable in principle to sampling architectures is provenance replay: “why did you say that?” converts to a re-presentation of the previous answer’s addresses, rule and premises, or the typed reason for its refusal — for this system a dictionary lookup over dialogue state, for a weight-based system an unanswerable question about its own parameters. The first four acts are deployed on the public instance with measured latencies of 0.0–0.2 ms; the act inventory is folded, gated, and grown exactly as the sentence grammar is (development evidence).
A single chat(text, session) entry composes the system: typed guards license exactly one route — session-relational (assertions and questions against the typed session world; answers in ~1–3 ms), commonsense (registered ConceptNet question forms with edge provenance), definitional (the gated definitional lead of an existing page), corpus-query (benchmark-induced rules, §4.3), gated essay (the document chain of §3.5), and the encyclopedic document runtime as fallback — with explicit abstention at every level. Measured single-turn latencies on a consumer CPU: 0.4–14.7 ms across all anchored routes (including gated summaries over user documents at 2.5 ms), with the historical 27–100 s cold-search paths retired by the anchor-resident layer (§3.4); the corpus-scaling measurement reported there supersedes the earlier deferral of the latency-invariance claim for anchored operations, which is now measured rather than implied.
Dispatch was originally a precedence chain: binary surface recognizers, first match wins — which fails paraphrases in principle, since meaning-similarity is invisible to a regex. The deployed runtime now scores every interpretation family simultaneously: each family bids a weighted sum of (a) holographic resonance between the utterance — role-bound word states plus bigram bindings over unitary phasors — and the family’s prototype state, and (b) typed marker evidence, with a clarification floor and a minimum winning margin. The arbiter ran first in shadow (recorded, never dispatching; 92/92 agreement on replayed live turns, sealed capability surfaces, and an authored paraphrase battery), then was promoted to authority at exactly one boundary: when the regex chain fails to answer and the arbiter bids a family with a clean margin, the turn is re-dispatched through the existing route via a canonical surface. Authority is improvement-only — on any other outcome the original result stands — and on every replayed turn where arbiter and chain agree, responses are byte-identical.
The promotion was gated by withheld one-shot panels, and the sealed record is instructive: the first panel failed 3/10 and its adjudication localized the defect precisely — the holographic encoding generalizes over word order, not lexical synonymy, so paraphrases built from novel lexemes (“gist”, “much appreciated”) collapse to the clarification floor. The repair grounds a synonym layer in the admitted corpus itself: novel content tokens project into family marker classes through ConceptNet edges (3.4M admitted assertions), so “sketch” reaches the summarize family because the corpus records its relation to “outline”, not because an author listed it. The second panel failed 7/10 and exposed projection cross-talk, yielding a seed-exclusivity law (a token that is itself a seed of one class never projects into another). The third panel passed 8/10. Across all thirty withheld cases the floor produced exactly one wrong-family answer; every other failure degraded to an honest clarification — graceful degradation as a measured property, and a contracting failure trajectory (3 → 7 → 8) as the acquisition signature. Turns that fall through every layer terminate in a typed clarify act in the system’s own voice; the fallback tier’s internal idiom can no longer leak into conversation.
A proposer (human, stronger model, or the system’s own harnesses) supplies surface–program pairs or bare surfaces. The kernel parses; failures become residue; residue is clustered by structural signature; a cluster may donate a rule only if the single rule covers multiple independent donors (the multi-donor gate — the anti-memorization law forbidding one-rule-per-sentence degeneracy); donated rules enter the kernel with a ledger entry recording the exact donor sentences; banked residue stays banked; misparses are recorded as hazards with repairs. The admission criterion is MDL-inspired (§2); formalizing explicit description-length accounting is registered future work.
The development trajectory, reported exactly as it occurred (development evidence): the initial 12-sentence panel moved 0/12 → 9/12 → 12/12 across three passes; two successive corpus expansions scored 29/36 and 55/56. These are different panels of increasing size; the trajectory demonstrates residue-driven growth, while transfer is established separately by sealed withheld-combination results (§6.2, §6.3).
The same protocol applies to registers and discourse. The document scaffold register was mapped to a finite frame family (routing intros, seven attribution frames with a kind slot, integrity closers) and folded into a natural attributive register under hard gates (claims character-identical; addresses preserved; substitutions ledgered; disclaimers consolidated, never deleted). Paragraph programs were seeded by annotating a human-authored essay’s twelve paragraphs as typed move sequences — the proposer set for the supra-sentence fold whose compiled form is §3.5.
Public benchmarks are treated as syllabi, not scoreboards, under a contamination law: development splits are fold fuel; test splits are never read by any harness until a single post-freeze run. On Natural Questions (open), a pass-0 classification of 3,610 development questions through the front door yielded coverage 0.08% with 3,607 explicit abstentions — the honest pre-acquisition baseline — and a residue that clustered into a small skeleton grammar (“when did the _ come out”, “what is the _ of _”, …). Pass 1 induced five typed corpus-query rules; the evidence gate (gold-alias containment in a provenance-addressed sentence, ≥2 validated donors) rejected three of the five; the two admitted rules moved development coverage to 1.05% and precision-when-answering from 0% to 28.9%, with the entire pass ledgered. The binding constraint identified is corpus depth (abstracts lack the long tail of popular-culture specifics), not question grammar — a finding that redirects the next pass to ingestion rather than rules.
The deployed public instance records every conversational turn — text, route, outcome — to a residue ledger, with the recording disclosed on the interface. Turns the system cannot compile are precisely the proposer input of §4.1, now supplied by the open environment rather than by the authors. This changes the system’s growth law: new grammatical structure previously arrived linearly in author labor; it now arrives in proportion to usage, with candidate rules mined from wild residue by the same clustering-and-admission machinery (and, prospectively, the autonomous induction objective of §4.5). Critically, the transition is lattice-preserving: unlike continual training on user data — the canonical drift and poisoning vector for statistical models — every wild acquisition must pass the identical multi-donor gate, transfer law, and round-trip proof as a laboratory acquisition, and enters the same ledger. Growth from an open environment with no mechanism for corruption of prior competence is, to our knowledge, a combination absent from the statistical lineage (architectural implication; becomes development evidence as the ledger fills, and a sealed demonstration when a frozen successor answers a construction whose ledger lists only public users as donors).
The strongest form of the acquisition claim — proposed by our external auditor — replaces the human proposer entirely: given residue R = {r₁…rₙ}, search for g* = argmin_g [L(g) + L(R | G ∪ g)] subject to transfer and semantic-preservation constraints, discovering that several failures instantiate one latent construction. This objective is now implemented and running. Anti-unification (least-general generalization) over aligned residue clusters supplies candidates; explicit bit-cost accounting — rule cost L(g) against the compression of the residue it absorbs — supplies the admission decision; a multi-donor floor (≥3 independent donors) and a held-out transfer gate supply the constraints. Four induction passes grew the machine-rule ledger 12 → 33 → 73 → 104 induced rules, with slot typing upgraded from capitalization heuristics to a 862,583-entry part-of-speech table, all without a human proposer.
A second slice upgraded the induced rules from surface templates to programs: the top ten rules by donor support were mapped to typed terms of the sealed lambda-IR (§3.2), gated per donor on the atom being well-typed and on digest(Parse(Realize(P))) = digest(P), where realization decompiles the atom’s constant leaves rather than any cached string. Nine of ten mapped with every donor round-trip digest-stable; the tenth is recorded frame-only because its donor evidence (all “This is called X.”, participle mistyped as adjective) does not support a faithful mapping. The mapping exposed head sharing invisible at the string level: two election frames collapsed into one family, and “becomes king of” proved to be the general “becomes ROLE of” rule with its role slot frozen. The system’s claim is thereby upgraded from storing explicit linguistic programs to inducing them from linguistic evidence (development evidence; refuse-rerun reports preserved).
All headline claims follow a sealed protocol: (1) the runtime and its dependency closure are frozen (SHA-256 manifest) before any test case exists; (2) panels are disjoint and prospective, authored against capability descriptions, never outputs; (3) first runs are preserved immutably — evaluators refuse re-execution — and failures are repaired only in additively-named successors, with the failed record shipped; (4) expected answers are computed programmatically (two hand-arithmetic gold errors in our own history motivated the law); (5) every run records the zero-model gate. Claims are classified as sealed demonstration, development evidence, architectural implication, or hypothesis, and no result is described above its class. Agreement among the authors and their AI collaborators is not evidence; accordingly the final conversational evaluation is delegated to a sealed interface for independent panel authors and blind adjudicators (specification shipped with the artifact), and the first independent-authorship test has been executed with a public dataset’s untouched test split (§6.4).
The frozen M13e1 runtime passed disjoint prospective panels at 234/240 and 29/30 (30/30 after programmatic adjudication of a gold-label error). The panels cover a registered construction and topic space; this is expressly not a demonstration of unrestricted conversation.
The frozen M13e2 compiler passed 55/55, decomposing as 28/28 on construction combinations withheld during acquisition against 14/28 for the system with its compositional mechanism ablated. The 14-point causal gap is the experiment that separates a grammar from a lookup table: transfer is carried by the mechanism, not by memorized wholes.
Fourteen natural-prose construction families were precommitted with ten withheld cross-family products before implementation. Development reached 31/31 on isolated families; the sealed one-shot on the products failed 1/10 — the families did not compose, because sub-clause requests bypassed the family stack — and the single pass failed ablation attribution through a degenerate fallback parse. The failure was preserved; the additive successor made decomposition recursive; fresh composition pairs reached 40/40 in development; and the succession run passed 10/10 with 9/10 products causally attributed under family ablation (the tenth’s non-attribution, a fallback-parse bypass, is recorded as a known gap). We regard the failed first seal as among the paper’s most important results: isolated-family testing cannot detect non-compositionality; only withheld products can.
Executing falsification condition 1 (§8): the NQ-open test split — 1,769 questions authored by search users with no knowledge of this system, downloaded only after the release freeze, never previously read by any harness — was run once against the frozen closure. Result: coverage 0.79%, precision-when-answering 21.4% (3 correct, 11 wrong, 1,755 explicit abstentions), full sweep in 129 s. Against the development band (1.05%/28.9%), the test band shows no collapse under authorship transfer; the fold ledger proves every induced rule’s donors came from the development split. The sealed claim is transfer-without-contamination, not open-domain competence; the absolute numbers are small and published as such, with abstention — not error — absorbing the remainder.
Faculty-matched ablations: removing convolution binding removes role addressability; removing the involution-correlation cleanup removes identity resolution (recovery falls to chance against registered distractors); a 4:1 root-protection ratio preserves protected identity under superposition load. Each ablation is tested against the faculty it allegedly serves; global metrics are not accepted.
(1) Unconditional clause-initial It grounding converted a true cleft into the false statement “Man’s Place in Nature was Lamarck…” — the gravest class the system admits (transformation-injected falsehood); repaired by the typed it classifier; the defect is a permanent regression case (13/13). (2) Rank-ordered FTS cost minutes per rare-term query (a 13-hour evaluation sweep); repaired by bounded retrieval (54 ms worst case) with the rule ledger re-validated identical. (3) The M13e4 typed-semantics line’s first sealed panel failed 19/20; preserved, adjudicated, and sealed by a 4/4 successor on the repaired class. Ledgered transformation makes such defects findable and regressable; it does not make them impossible, and we say so.
If the typed IR is genuinely the system’s meaning representation — rather than English in disguise — then a second surface grammar should compile a second language into the same terms. We built a bounded Spanish construction kernel covering ten relation families (copular class membership, location, birthplace, causation, ability modals, existential quantity, comparatives, role accession, negated possession, and excess degree), sharing the sealed lambda-IR and a finite, declared bilingual lexicon as the only language-specific bridge. The invariance gate is exact: an English sentence and a Spanish sentence expressing the same fact must compile to alpha-invariant canonical digests that are equal.
The development battery passed 20/20 pairs on its first run. The withheld one-shot panel — ten fresh Spanish surfaces and five fresh English–Spanish invariance pairs, authored at freeze — passed 10/10 and 5/5: “The storm was too strong to survive.” and “La tormenta era demasiado fuerte para sobrevivir.” compile to byte-identical digests. The demonstration is bounded and stated as such: the lexicon is finite, the families are ten, and the frozen ingress tokenizer splits accented characters (a recorded successor item). What it establishes is the architectural point: surface grammar is a per-language module, and meaning, once compiled, carries no trace of the language it arrived in.
Contemporary “learning” in language systems takes four forms — gradient fine-tuning, in-context conditioning, retrieval augmentation, and skill libraries — and each fails at least one question of the following test, which the CLM passes in full by construction:
The distinction is not a quality axis within one category but a difference in the kind of artifact produced by learning: the skill-learning statistical model becomes better at imitating competence; the compiler-learning model acquires the generative program of the competence, with receipts. Combined with binary admission (single-exposure recall) and the tri-modal release discipline (address, derivation, or refusal), we argue this warrants a category term, and we propose CLM in deliberate inversion of LLM on every axis: small against large, compiled against sampled, taught against trained.
The tri-modal release discipline — address, derivation, or refusal, with confident fabrication structurally absent — admits a security-theoretic reading that we have developed formally elsewhere [Foldwall, 2026]. A large statistical model is a smooth, differentiable map from context to output, and that smoothness is an exploitable gradient: there is always a continuous descent from “I don’t know” toward a plausible-looking answer, and sampling follows it. A compiled runtime with a discrete admission gate presents no such gradient — the surface between honest release and fabrication is flat, and there is nothing to descend. This is the same property that makes a cryptographic primitive immune to iterative convergence attack: a flat divergence surface with no informative gradient. Structural abstention is therefore not a heuristic bolted onto the architecture but the language-domain instance of gradient immunity, and it is available in exactly two regimes — maximal randomness (a cipher, nothing to learn) or maximal structure (a compiler, nothing to slide along). The CLM chooses the second.
Each condition is executable without the authors’ cooperation; the release is structured to make executing them cheap.
Breadth is corpus-bounded and, for open-domain questions, currently dominated by abstention (~99%); corpus depth (full articles rather than abstracts) is the identified lever. The document register remains partially attributive; the natural-prose fold covers the sentence and paragraph levels, with 29 residue clusters published as the live worklist. Reasoning breadth grows engine by engine; no competition-mathematics or long-chain inference engine exists. Truth is attributed, not adjudicated. Person-pronoun grounding awaits entity typing; relevance distinctiveness is a v1 heuristic pending corpus document-frequency statistics. Latency on cold full-text paths spans seconds to minutes and is reported individually. Transformations can inject error (§6.6); the ledger bounds the damage class but does not eliminate it. Nothing in this paper bears on phenomenal experience; first-person constructions describe computation.
Every specialist rebuilds from public dumps via shipped compilers, with double-build byte-identity checked by SHA-256 as protocol; all freeze manifests, panel files, first-run reports (including failures), fold ledgers, defect records, and zero-model gates ship with the artifact; the runtime is pure Python + NumPy on CPU. Verification of the released artifact is performed by re-running the sealed panels against a fresh download, and that report ships beside the panels it verifies.
For a decade the study of machine language has proceeded under a single methodological assumption: that linguistic competence is an emergent property of scale, obtainable only by statistical approximation and inspectable only from outside. This paper has exhibited a counterexample — not an argument against the assumption but a machine that violates it. Grammar here is a finite, readable inventory, acquired from residue under gates and grown, since deployment, by the open public; meaning is an algebra with a fingerprint; knowledge is an address space that resolved at the same 1.4 microseconds when it was twenty-two times smaller; inference carries its premises; conversation is a table of conversions, one of which — the replay of the system’s own reasons — no sampling architecture can perform even in principle; and every one of these claims is either sealed behind a preserved first run, measured by a shipped harness, or explicitly labeled as not yet earned, with the conditions of its own refutation published beside it.
The factorization result admits a compact statement: fluency, knowledge, inference, and truth-tracking are separable, and only fluency ever required approximation. The statistical lineage purchased all four in a bundle because it could not take them apart, and paid for the bundle with opacity, fabrication, frozen weights, and megawatts. The compiler-learning model takes them apart, pays for each with the proof it individually demands, and receives in exchange the properties the bundle could never provide: recall without frequency, speech without drift, growth without corruption, and answers that carry their receipts. Whether this architecture or its statistical complement ultimately serves a given purpose is now an engineering question with a price list, not a matter of doctrine — and rendering it so, we submit, is the contribution: the assumption that there was only one way to give a machine language did not survive contact with a working second way.
The system described in this paper is publicly conversable, and learns from every conversation it cannot yet understand.
The architecture operationalizes three theses of the first author, stated in advance of the artifact: that language is a finite-rule hyper-object approachable by enumerating redundancy and working back from residue; that the human child is the standing existence proof of single-exposure, correction-driven acquisition from bounded evidence; and that language is bound to formal logic tightly enough for compilation to be an engineering target. The second author implemented, evaluated, and — under the epistemic law adopted for this project — was audited by an independent AI collaborator (Codex, OpenAI) whose corrections materially reshaped §5–§9.
Bohnet, B., et al. (2022). Attributed Question Answering: Evaluation and Modeling. arXiv:2212.08037. de Marcken, C. (1996). Unsupervised Language Acquisition. PhD thesis, MIT. Dowty, D., Wall, R., & Peters, S. (1981). Introduction to Montague Semantics. Reidel. Fillmore, C., Kay, P., & O’Connor, M. (1988). Regularity and idiomaticity in grammatical constructions. Language, 64(3). Gayler, R. (2003). Vector symbolic architectures answer Jackendoff’s challenges. ICCS. Goldberg, A. (1995). Constructions: A Construction Grammar Approach to Argument Structure. U. Chicago Press. Grünwald, P. (1996). A minimum description length approach to grammar inference. Connectionist, Statistical and Symbolic Approaches to Learning for NLP, Springer. Ji, Z., et al. (2023). Survey of hallucination in natural language generation. ACM Computing Surveys, 55(12). Kanerva, P. (2009). Hyperdimensional computing. Cognitive Computation, 1(2). Lewis, P., et al. (2020). Retrieval-augmented generation for knowledge-intensive NLP. NeurIPS. Montague, R. (1970). Universal grammar. Theoria, 36(3). Plate, T. (1995). Holographic reduced representations. IEEE Transactions on Neural Networks, 6(3). Plate, T. (2003). Holographic Reduced Representation. CSLI. Rissanen, J. (1978). Modeling by shortest data description. Automatica, 14(5). Smolensky, P. (1990). Tensor product variable binding. Artificial Intelligence, 46(1–2). Solomonoff, R. (1964). A formal theory of inductive inference. Information and Control, 7. Steedman, M. (2000). The Syntactic Process. MIT Press. Tomasello, M. (2003). Constructing a Language: A Usage-Based Theory of Language Acquisition. Harvard U. Press.