Source-Deleted Contextual Relation-Program Architecture

Status: pre-neural architecture and falsification charter Date: 2026-07-23 Protected base: train/flagship_out/ckpt_0300000.pt Protected base SHA-256: 211d6b2cddf0c2cf8b12cb0b2d73f9c4440d85f6f531018080c8afd35b2f66a6 Base parameters: 125,081,664 Complete-system ceiling: strictly below 200,000,000

1. Objective

Build one architecture-native mechanism that can:

1. bind fresh symbols by physical occurrence and learned equality;
2. infer episode-local operation identities from causal witnesses;
3. execute arbitrary unseen monotone relation-program graphs;
4. solve mutually recursive least fixed points;
5. preserve exact state across unseen graph depth and object cardinality;
6. own graph traversal and halt;
7. answer a query disclosed only after source deletion; and
8. connect the same state to Shohin's natural-language interface.

This is not a claim that relation algebra is general intelligence. It is a decisive test of four prerequisites for general reasoning: local law induction, variable binding, systematic composition, and recurrent state use.

2. Evidence That Must Be Reused

The architecture is constrained by prior causal results.

2.1 Contextual law induction exists

S7's 218-parameter learned Cayley generator reaches 2,048/2,048 exact recurrent states and answers on sealed confirmation across 18 unseen laws and depths 3-8. A false S^2 generator, one-witness cards, deranged cards, and state reset collapse. This validates tied generator reuse under a narrow cyclic prior.

2.2 Physical occurrence and nominal identity must be separate

ER-CST witness equality raises closed confirmation joint accuracy to 99.023%; family derangement and equality ablation collapse. Address-only routes can fit structure while failing relation content. The new compiler therefore cannot represent "where this token occurred" and "which local symbol it denotes" in one unconstrained vector.

2.3 Private discrete state is necessary but insufficient

S8/S9 show that emitted links, nil, and source-deleted graph execution are causal. DRS shows a late residual digit signal but fails repeated autonomous consumption. QERARM now reaches exact hard fixed-template execution, but a fixed program schedule is not program interpretation.

3. Rejected Shortcuts

No score-bearing arm may receive:

• both simultaneous and nested representations;
• source tokens, source KV state, or compiler residuals after graph sealing;
• a gold execution schedule, trajectory, convergence time, or target;
• host-repaired pointers, operation bindings, state, or halt;
• globally meaningful operation IDs;
• constant ordering or density tied to semantic role;
• graph depth, topology, or cardinality features that are unavailable from the private packet; or
• target-equivalent prospective-action features.

Soft loss, teacher-forced fit, linear readout, and host execution are diagnostics only. Score-bearing execution is hard and autonomous.

4. Machine

The complete mechanism has four interfaces.

4.1 Identity-aware source compiler

The compiler emits physical records, nominal fingerprints, equality links, typed node records, argument links, equation-root links, entry, next/nil, and late-query bindings. Physical occurrence pointers and nominal equality use separate channels. Node and symbol order are arbitrary.

After validation, exactly one graph representation is sealed. The source, token memory, compiler activations, and unused paired representation are irreversibly unavailable to execution.

4.2 Contextual primitive binder

Every episode assigns fresh opaque IDs to relation operations. Each operation card contains relation-valued witnesses sufficient to identify one member of a tied primitive bank:

• union;
• intersection;
• composition;
• converse; and
• identity.

The binder evaluates every compatible primitive on each witness and derives a hard local assignment. It may use equality and tensor reduction, as S7 does, but not global operation names. Ambiguous or contradictory cards fail closed. The same compiled primitive is reused at every occurrence and every fixed-point iteration.

4.3 Private graph executor

The executor stores:

• anonymous relation constants;
• anonymous recursive variable registers;
• program-node relation registers;
• typed argument links;
• equation-root links;
• local primitive assignments;
• a categorical execution phase; and
• alive/nil state.

All legal primitive candidates are produced tensorially. Hard graph links and hard primitive assignments choose complete legal transitions. Read-only constants remain immutable. Node, variable, constant, and object permutation equivariance are architectural contracts.

The simultaneous arm iterates both recursive variables together. The paired evaluation arm receives an explicit nested fixed-point graph with LFP binders. Equivalent forms are never supplied to one execution.

4.4 Halt and late query

The machine must emit nil/HALT from its private state. Missing halt remains wrong. The query is disclosed only after the terminal state is committed, and changing the query may change the answer but not execution.

5. Score-Bearing Program Orbits

Programs are sampled from the monotone grammar:

E ::= VARIABLE
    | CONSTANT
    | IDENTITY
    | UNION(E, E)
    | INTERSECTION(E, E)
    | COMPOSE(E, E)
    | CONVERSE(E)

Each constant world produces a matched orbit:

• P: one random two-variable recursive program;
• P': matched node count, depth, topology, operator multiset, variable-use counts, and constant-use counts, but rewired to a different fixed point;
• Peq: semantics-preserving alpha, node, object, constant-list, and associative/commutative rewrites; and
• Pbekic: an explicit nested fixed-point representation equivalent to P.

P and P' must differ by at least 10% normalized joint target Hamming distance. Constant density is independent of role. Canonical skeleton and depth-2/depth-3 motif hashes, not byte hashes, define disjointness.

6. Development Partitions

All dependency topologies are balanced within every cell. Confirmation does not exist until source, data, thresholds, controls, and five model seeds are frozen and development has passed.

7. Gates

Every score is exact joint terminal state plus valid halt unless stated.

7.1 Mechanics

• independent simultaneous and nested oracles agree on every admitted row;
• alpha, node, object, variable, operation-card, and constant-list reindexing: 100%;
• P/Peq equivalence: at least 99.5%;
• P/Pbekic equivalence: at least 99.5%;
• program transplant with constants fixed: at least 99%;
• constant transplant with program fixed: at least 99%;
• P/P' matched counterfactual accuracy: at least 99%;
• noncommuting wiring/order twins: at least 99%; and
• missing/early/late nil interventions cause the predicted failure.

7.2 Contextual binding

• fresh opaque operation-card binding: at least 99.5%;
• card and witness order invariance: 100%;
• one-witness ambiguity fails closed;
• deranged and contradictory cards fail or lose at least 60 points;
• compiled-operation transplant changes execution to the donor law; and
• global operation-ID and bag-of-operation controls are at chance on fresh bindings.

7.3 Neural development

• every development cell: at least 99% exact joint;
• all five fixed training seeds pass individually;
• treatment beats every qualified graph-blind, constants-only, structure-statistics-only, bag-of-operations, and generic recurrent control by at least 20 points;
• hard autonomous score is within one point of the exact private-machine host ceiling;
• late-query invariance and state transplantation are exact; and
• no development choice is selected by averaging away a failed seed or cell.

8. Parameter Ledger

The protected trunk leaves 74,918,336 parameters below 200M.

Current bounded controls:

The first contextual graph arm must remain below 150M if possible. Width may increase up to the strict 200M ceiling only after a smaller matched arm proves that added capacity changes the failed causal mechanism rather than memorizing program skeletons.

9. Claim Ladder

1. Mechanics only: exact host/tensor execution.
2. Contextual binding: fresh opaque operations compile causally.
3. Systematic relational reasoning: unseen programs, depths, scales, and equivalent representations pass hard autonomous gates.
4. Language-grounded relational reasoning: source compiler emits the private graph and retains the same state/execution gates.
5. Broader reasoning: the same mechanism transfers to at least two non-relational task families with fresh renderers and rules.

Only level 5 changes Shohin's general-reasoning claim. Levels 1-4 are necessary architecture evidence, not permission to call the system generally intelligent.