54 Relational Dimension Compilation and Polyadic Cognition

54.1 Chapter status

Field	Value
Chapter ID	`relational-dimension-compilation-and-polyadic-cognition`
Part	Part III - Routing, Compression, Representation, and Substrates
Status	conceptual
Last updated	2026-07-25
Primary source records	`relational_dimension_compiler`
Claim label	Design rationale
Evidence level	argument
Source loading state	source notes: `relational_dimension_compiler`, `ext_neural_message_passing_2017`
Test state	Chapter-level tests remain planned unless Appendix E records an implemented command and result.

54.2 Drafting guardrail

The relational compiler remains an unimplemented architectural hypothesis. Higher semantic arity is not presumed irreducible, useful, efficient, or necessary, and a proposal mechanism never receives authority to install, retain, or retire production structure by itself.

54.3 Human Reading Path

Concrete lens. The simpler baseline stores pairwise edges and drops the joint condition. The candidate compiler must first show that matched pairwise, sequence, retrieval, tool, and ordinary-model rescues fail on held-out structure.

Begin with Replaceable Cognitive Substrates Beyond Transformer Monoculture, then treat relational compilation as one candidate behind that interface. Its narrow problem is preserving typed, role-sensitive relations involving several participants without making the fast path combinatorial. Representation, qualification, compilation, routing, and retirement form one governed lifecycle.

Keep four distinctions visible. Semantic arity is not tensor rank. A polyadic relation is not merely a large embedding. A learned proposal is not authority to install itself. An exchange involving giver, recipient, object, condition, and third-party action may lose roles when flattened into ambiguous pairwise edges, yet reifying those roles can add cost without helping a task.

Log every candidate in a complete proposal denominator. Before admission, implement competent pairwise, relation-node, sequence, retrieval, tool, and ordinary-model rescues under matched budgets. Qualify survivors on unseen topologies and role permutations, then lower them without discarding provenance, uncertainty, abstention, or branch identity. Retirement must enumerate descendants and invalidate compiled artifacts and caches. Separate natural usefulness, calibration, latency, memory, and governance cost from synthetic diagnostics while keeping simpler mechanisms, rollback, and non-promotion in control.

54.4 Problem

Many cognitive problems are natively polyadic: the meaning of a relation depends on several typed roles jointly, and its useful order may change with context. Flattening every relation into pairwise edges or token sequences can lose role identity, create ambiguous contractions, and hide the cost of proposing and maintaining higher-order structure.

The difficulty is not merely storing a tuple. A useful system must determine when several observations jointly warrant a relation, keep asymmetric roles distinct, compare the proposal with cheaper representations, and preserve the result across retrieval, routing, explanation, update, and retirement. Sparse use is essential because the number of possible tuples grows rapidly with entities and order. An adaptive design can therefore fail by materializing too much structure, filtering the denominator before evaluation, or compiling a shortcut whose speed conceals lost provenance and changed semantics.

54.5 Why existing approaches are insufficient

A substrate catalogue can name hypergraphs, tensor products, slots, and routing mechanisms, but it does not own the compiler lifecycle that types dimensions, proposes candidate relations, preserves role identity, qualifies higher order against lower-order rescues, adapts order, contracts reversibly, and evaluates whether the added structure earns its cost.

Pairwise message passing and reified relation nodes can encode many seemingly higher-order cases, while sequence models can serialize roles and tools can construct explicit records. Any new architecture must beat those competent rescues rather than a deliberately weak baseline. Standard random splits may also leak topology templates, participant roles, or generator grammar, making memorization look like compositional transfer. Finally, reporting only admitted candidates hides proposal cost and false starts, so an apparently sparse system may have paid an unbounded search bill upstream.

54.6 Core Claim

[relational-dimension-compilation-and-polyadic-cognition.core, label: Design rationale, support: argument] Polyadic cognition should be implemented as a slow-path relational-dimension compiler over stable lower-arity primitives: candidate higher-order structure is typed, role-addressable, denominator-complete, qualified against strong pairwise and sequence baselines, budgeted, reversible, and retained only when it improves held-out relational performance without violating memory, latency, calibration, or governance constraints.

Reader claim. Higher-order structure earns a place only when typed joint roles solve a held-out relation that strong lower-order representations cannot solve as well.

Operational rule. Preserve every candidate and lower-order rescue in the denominator, address roles by identity rather than position, and compile on the slow path. Missing roles, hidden candidates, unmatched budgets, active descendants, or failed held-out qualification force fallback.

54.6.1 Worked ternary compilation: three roles, one qualified candidate

Take the relation “Alice gives Bob the key if Carol releases the file.” The compiler binds three required role IDs—giver 1, recipient 2, and condition-holder 3—to entities 101, 102, and 103. It tests three candidate representations, IDs 201, 202, and 203, while retaining all three outcomes. Only candidate 202 qualifies; the other two remain visible rather than disappearing from the denominator. Pairwise edges, message passing, sequence, retrieval, tool, reified-node, and ordinary-model rescues receive matched budgets before the higher-order candidate is eligible.

The finite review then tracks two descendants of relation 202: artifact 301 is invalidated and artifact 302 is recompiled. An active descendant blocks contraction, and seven scope changes invalidate the receipt. All 54 admission-axis mutations receive exact repair or refusal dispositions. The exercise proves that typed roles, candidate custody, fallback, and invalidation can be modeled coherently; it does not prove that the ternary representation is irreducible, useful, efficient, or superior on natural tasks.

54.7 What “dimension” means here

Mechanism. Type geometric dimension, semantic arity, primitive computational arity, storage arity, temporal extent, abstraction scale, branch, epistemic state, and resource budget as distinct axes before compiling a relation. Failure mode. Calling all of them “dimension” lets a representational rewrite masquerade as a new capability or hides a costly storage topology behind semantic language. Non-claim. A clean type system does not establish that higher-order structure is necessary or useful. Source grounding. The Relational Dimension Compiler supplies this authorial distinction; no external result validates it.

The word dimension is overloaded. A defensible compiler keeps several axes separate:

geometric dimension: coordinates or width in a vector, tensor, manifold, or state space;
semantic arity: how many typed roles jointly define a relation;
primitive computational arity: how many operands one primitive directly consumes;
storage arity: whether a record is stored as an edge, reified relation node, tuple, factor, program, or another structure;
temporal extent: whether the relation is instantaneous, episodic, persistent, or recurrent;
abstraction scale: token, object, event, plan, organization, or world;
branch identity: which hypothesis, simulation, or counterfactual owns the relation;
epistemic status: observed, inferred, proposed, contradicted, or retired; and
resource budget: memory, compute, bandwidth, latency, and verification cost.

A ternary semantic relation does not require a ternary hardware instruction. It can be represented through a role-addressable relation object and evaluated with bounded primitives. Conversely, a high-rank tensor does not prove that the model represents a meaningful higher-order relation. This separation permits a simple fast path while allowing semantic structure to grow.

Consider “Alice gave Bob the key in exchange for Carol releasing the file.” Pairwise edges such as gave(Alice,key) and received(Bob,key) omit the joint roles and exchange condition unless the relation is reified. A typed relation object can bind giver, recipient, object, counterparty, condition, time, branch, source, and uncertainty without assuming that every downstream operation must consume all fields at once.

54.8 The relational intermediate representation

Mechanism. Give every candidate a stable identity, typed participant roles, scope, provenance, uncertainty, branch, expiry, dependents, lower-order alternatives, total cost, and inverse or fallback. Failure mode. Untyped tuples can preserve participants while swapping roles, leak simulated state into actual state, or lose provenance after caching and routing. Non-claim. An inspectable relational IR is not proof of truth, causality, grounding, or explanation. Source grounding. The compiler paper defines the proposed record family; neural message passing supplies a lower-order graph comparator rather than validation.

The compiler’s basic record is a versioned RelationCandidate:

candidate_id
relation_type_and_dimensional_signature
typed_role_bindings
scope, time, branch, and abstraction level
source_provenance_and_epistemic_status
proposal_reason_and_residual_failure
lower_order_rescues_attempted
uncertainty_and_calibration
memory, compute, latency, and verifier cost
dependents, expiry, inverse, and fallback
admission_state

Roles are addressed by name or type, not only position. A permutation may preserve a symmetric relation such as co-membership but must change an asymmetric relation such as donor–recipient. Missing roles remain explicit; they are not silently filled from the most likely completion. Branch identity prevents a relation believed in one counterfactual from leaking into another. Epistemic status prevents a proposed or simulated relation from being retrieved as observation.

This is a compiler IR because it separates semantic intent from execution strategy. The same admitted relation might lower to a reified graph node, sparse tensor operation, factor graph, retrieved program, state-space update, or tool call. That makes representation replaceable while its roles, provenance, and governance survive.

54.9 Propose higher order only from a residual

Mechanism. Generate a sparse higher-order candidate only from a named failure left by admitted lower-order routes, and retain the complete proposal, rejection, retry, and resource denominator. Failure mode. A privileged proposer can hide discarded candidates or materialize combinatorial tuples until one fits the benchmark. Non-claim. Residual-triggered proposal does not prove proposal recall or irreducibility. Source grounding. Candidate-denominator and residual-trigger concepts come from the Corben-authored compiler source and remain unimplemented.

Materializing all possible (k)-tuples is not intelligence; it is a denial of service. Candidate generation therefore runs on a bounded slow path triggered by a named residual:

lower-order models repeatedly confuse role permutations;
a plan fails because a constraint applies only to a joint configuration;
a causal or social explanation changes when one participant role changes;
memory retrieves all relevant entities but cannot reconstruct their joint relation;
a prediction remains miscalibrated after competent lower-order rescue; or
a recurring reasoning trace expends substantial work rebuilding the same typed relation.

Every trigger records the full proposal denominator. If 100,000 candidate relations were scored and 20 were admitted, the evaluation reports all 100,000. Filtering away failed proposals creates a selection illusion. The denominator also includes compute and memory spent on proposal, not only the cost of the final relation.

Generation can use learned models, programs, retrieval, or human input. None has admission authority. A learned proposer can surface a candidate; a separate qualification policy decides whether it enters shadow, canary, or active state.

54.10 Lower-order rescue comes first

Mechanism. Before admitting higher order, implement competent reified-relation nodes, message passing, factorization, sequence serialization, retrieval, tools, and ordinary-model rescues under matched information and budgets. Failure mode. Weak baselines create arity theater: the proposed representation wins because alternatives were denied tuning, context, or equivalent role information. Non-claim. A failed rescue does not prove that pairwise computation cannot represent the relation. Source grounding. Neural message passing is a serious external comparator; its molecular results do not settle general relational reasoning.

A distinct higher-order structure is warranted only after serious alternatives have been tried. Required rescues include:

a pairwise graph with a reified relation node and typed incident roles;
competent message passing or factorization;
sequence serialization with role markers and adequate context;
retrieval of a structured record or program;
tool-mediated symbolic or database computation; and
a larger or better-trained ordinary model under a matched resource budget.

Many supposedly polyadic problems are representable by lower-arity structures. The research question is not whether representation is possible in principle; it is whether an explicit compiled relation improves generalization, role fidelity, calibration, or efficiency under the actual budget. If a reified node solves the task just as well and is easier to govern, the compiler should prefer it.

The strongest challenge to this chapter is therefore reduction: bounded pairwise primitives plus enough latent state may be sufficient for every tested case. The chapter accepts that possibility. Its value then becomes a disciplined way to discover that higher-order compilation is unnecessary rather than a commitment to find a win.

ext_neural_message_passing_2017 supplies one concrete external lower-order comparator: learned messages, node updates, and graph readout over a supplied graph. Its molecular results neither validate RDC nor settle whether explicit polyadic structure is needed. It does make a weak pairwise baseline unacceptable; a fair test needs competent reified-relation and message-passing systems, not an intentionally impoverished graph.

54.11 Qualification and the order ladder

Mechanism. Qualify candidates on held-out topology, unseen role assignments, counterfactual-role swaps, compositional transfer, calibration, abstention, and total lifecycle cost, while preserving every attempted order. Failure mode. Template leakage, sparse scale points, or post-hoc order selection can turn memorized schemas into apparent structural discovery. Non-claim. Passing synthetic qualification would not establish world truth, general intelligence, or a universal arity bound. Source grounding. RODIE and the order ladder are proposed in the compiler source; no corpus or result exists here.

A candidate passes through proposed → shadow → canary → active → demoted → retired. Promotion requires:

held-out topology and role configurations;
role-permutation, missing-role, and counterfactual-role tests;
comparison with all declared lower-order rescues;
calibration and abstention;
natural-task and synthetic-task separation;
matched memory, compute, latency, and training accounting;
stability across seeds and relevant distribution shifts;
complete proposal and failure denominators; and
an executable inverse or fallback plan.

Adaptive order means the system may choose the simplest sufficient representation for each context. It does not mean an uncontrolled model may invent unbounded arity. Budgets cap proposal rate, active relations, role count, fan-out, dependency depth, and verifier work. Promotion policies can be learned only beneath hard governance limits.

Useful relations can be compiled from the slow path to the fast path. The compiled operator carries a semantic version and conformance tests. If compression removes explanatory structure, the system retains a link to the source relation and a reconstruction path. Fast execution must not sever provenance.

54.12 Reversible semantic contraction

Mechanism. Compile an admitted slow relation into an operator only after conformance replay preserves roles, branch, provenance, uncertainty, outputs, and fallback against the qualified route. Failure mode. A fast specialist can drift from the source relation, erase exceptions, or become an unreviewed authority because its output is cheaper. Non-claim. Conformance on recorded cases does not prove semantic equivalence on future inputs. Source grounding. The compiled-specialist certificate is an authorial design artifact, not measured acceleration or correctness.

Retirement is not deletion of one row. A relation may have descendants in memory summaries, caches, router policies, learned adapters, plans, evidence records, and other compiled relations. Contraction therefore:

freezes new dependents;
enumerates descendants and backups;
selects a lower-order fallback or records loss of capability;
invalidates or recompiles dependent artifacts;
clears or versions caches and retrieval indexes;
tests role and branch isolation after contraction; and
records what influence cannot be removed from learned parameters.

Reversibility is scoped. Restoring an earlier record does not undo downstream human actions or prove machine unlearning. The contraction receipt names storage erasure, behavioral removal, influence removal, and external effects separately.

54.13 RODIE: a benchmark family, not one score

Mechanism. Adapt order through explicit promotion, demotion, expiry, and contraction transactions that invalidate descendants, caches, certificates, and compiled operators when their parent changes. Failure mode. Online order growth can become self-authorized ontology expansion, while contraction can strand stale descendants or delete needed distinctions. Non-claim. Reversible records do not show that recovery is complete or affordable. Source grounding. Lifecycle and contraction requirements come from the Relational Dimension Compiler and remain test proposals.

Relational-Order Discovery, Inference, and Evaluation should separate the paper’s diagnostic suites rather than collapsing them into one “relational intelligence” score:

Track	Question
Minimal relational order	Which primitive order survives competent lower-order rescue at matched information and budget?
Typed role binding	Does the system preserve asymmetric, symmetric, repeated, optional, missing, and permuted roles?
Latent topology discovery	Can it propose the needed relation and schema without receiving the authored template or an oracle candidate set?
Counterfactual and causal fidelity	Do role deletion, substitution, and intervention change predictions in the independently expected direction?
Dynamic topology and identity	Can relations appear, change, split, merge, contradict, and retire without losing identity or rewriting history?
Multiscale contraction	Does a macro-object preserve a declared query family within tolerance and expand when boundary conditions fail?
Geometry and fields	Do discrete role objects and continuous fields exchange state without confusing coordinate, role, branch, or authority axes?
Branch and epistemic separation	Do proposed, believed, simulated, observed, executed, contradicted, and counterfactual relations remain isolated?
Compilation and reuse	Does a compiled recognizer retain scope, calibration, counterexamples, provenance, expiry, rollback, and the slow recheck path?
Natural-domain transfer	Does any diagnostic gain improve useful behavior on domains whose relational structure was not authored to match RDC?

Synthetic generators permit exact topology and counterfactual controls, but they can reward template recognition. Natural tasks are necessary to test usefulness, yet their ground truth is often incomplete. Both are reported separately. A single aggregate “relational intelligence” score would recreate the very ambiguity this chapter is meant to remove.

54.14 Mechanism

Mechanism. Evaluate RODIE as a vector: proposal recall, topology discovery, role binding, counterfactual sensitivity, transfer, order selection, calibration, useful throughput, memory, latency, data movement, governance cost, and rollback integrity. Failure mode. A single aggregate can hide proposal burden, role collapse, abstention failure, or hardware costs from irregular sparse state. Non-claim. A favorable vector on authored fixtures would not prove natural-task value or architectural superiority. Source grounding. RODIE is Corben-authored research design; message-passing evidence only defines one comparison family.

Represent each candidate relation with typed roles, dimensional signature, scope, provenance, uncertainty, resource cost, and expiry.
Generate candidate dimensional topologies on a slow path from residual relational failures rather than materializing all possible tuples.
Compare candidates with strong rescues including reified relation nodes, message passing, factorization, sequence serialization, retrieval, and tool-mediated computation.
Qualify a candidate on held-out role-sensitive tasks with a complete proposal denominator, calibration, invariance, counterfactual-role, and cost tests.
Compile admitted relations into role-addressable operators, memory records, and router contracts while preserving provenance and an inverse or fallback path.
Adapt order under explicit promotion and demotion rules; garbage-collect expired or unproductive dimensions and invalidate descendants after contraction.
Evaluate with RODIE-style relational-order diagnostics that separate topology discovery, role binding, compositional transfer, efficiency, and governance.

flowchart LR
  R["Observed residual with typed roles"] --> P["Candidate proposal and full denominator"]
  P --> B["Competent lower-order rescue tournament"]
  B --> Q{"Held-out gain earns added structure?"}
  Q -- "no" --> N["Reject or retain simpler representation"]
  Q -- "yes" --> C["Compile to bounded primitive fast path"]
  C --> E["Execute with provenance, uncertainty, and abstention"]
  E --> M["Monitor usefulness, cost, drift, and descendants"]
  M --> K{"Retain, demote, or contract?"}
  K -- "retain" --> E
  K -- "demote or contract" --> D["Invalidate descendants, caches, and compiled artifacts"]
  D --> N

How to read this relational-compilation lifecycle: a residual may propose structure but cannot install it. Every candidate remains visible while strong lower-order rescues compete under matched budgets. Qualified structure enters a bounded fast path with provenance and abstention; monitoring can retain it or trigger contraction with descendant and cache invalidation.

The slow path owns discovery and evidence; the fast path owns only the qualified operation. A candidate record carries typed roles, source provenance, branch identity, uncertainty, scope, expiry, resource estimates, and its complete proposal history. Qualification checks role permutations, counterfactual substitutions, unseen topology, calibration, usefulness, and cost. Compilation must preserve those observable semantics or expose a fallback to deliberate reconstruction.

Contraction is a governed state transition rather than ordinary garbage collection. Retirement identifies memories, routes, explanations, cached outputs, compiled operators, and learned descendants that depended on the relation. Reversible artifacts return to the last qualified lower-order path; irrecoverable influence remains in a residual ledger. No proposer, compiler, or runtime score can authorize its own promotion, retention, or deletion.

54.14.1 Separation of powers

The proposer suggests; the qualifier evaluates; the governor authorizes; the compiler lowers; the runtime routes; the lifecycle controller demotes and contracts; the evidence system records denominators and residuals. These roles may share software in a prototype, but their records and authority remain separable. A high proposer score cannot authorize installation.

54.14.2 Operator registry and hardware lowering

The semantic relation is not a kernel schedule. After qualification, a typed operator registry can choose among exact joins and solvers, pairwise message passing, factorized or low-rank contractions, selective triadic or polynomial kernels, hypergraph or cell-complex operators, equivariant geometry, neural operators, planners, and database or symbolic routes. Each entry declares input and output types, semantic and primitive arity, role symmetry, branch and time behavior, precision, approximation, state, device, data layout, cost, failure classes, verifier compatibility, and fallback. A nominally higher- order operator has no privilege over a competent reified-node or pairwise route.

Persistent state can be stored as columnar entity, relation, and incidence tables plus an operator schedule. Relation rows hold stable identity, schema, branch, lifecycle, uncertainty, provenance, and qualification; incidence rows bind participant identity to a typed role, order, multiplicity, time, and confidence. Schema batching groups compatible relations by role signature, symmetry, feature width, branch, time window, device, and precision. Sparse gather/contract/scatter kernels, block locality, branch copy-on-write, structured factorization, and cache reuse may then regularize the hot path without making the storage representation the semantic truth.

Every lowering receipt retains candidate and accepted counts; bytes and data movement; sparse indices; cache and invalidation identity; gather, kernel, and scatter time; communication and synchronization; factorization and precision; approximation loss; verification; fallback; and hardware occupancy. A fast contraction that excludes candidate proposal, irregular memory traffic, qualification, or repair is a hardware illusion. Cache keys include schema, relation and branch versions, operator, factorization, precision, environment, consumer, and policy so a plausible stale relation cannot impersonate a valid hit.

Learning is governed by the same separation. Observation-to-structure models, order routers, qualifiers, dynamics, and contraction policies may share a composite training objective, but their release receipts remain distinct. Curriculum can move from known schemas to discovered and evolving topology; it cannot postpone branch isolation, role fidelity, proposal denominators, authority, or rollback until after scaling. The source proposes these data structures and objectives; it reports no kernel, throughput, learning, or distributed-execution result.

54.15 Interfaces

Replaceable Cognitive Substrates for primitive families and capability-field contracts
Memory Systems for provenance, retrieval, persistence, and deletion of compiled relations
Routing and Deliberation for choosing lower-order, compiled, fallback, or abstention paths
Governed Model Training for learning proposals and operators without granting self-authorization
Benchmark Ratchets for held-out topology, role, compositionality, calibration, and cost evaluation

These interfaces divide representation from authority. Substrates supply primitive operations, memory preserves provenance and lifecycle state, routing selects qualified paths, training proposes changes, and evaluation tests transfer and cost. The compiler binds their identifiers into one candidate record but cannot replace their judgments. A change in any dependency expires the affected qualification and sends the relation back to shadow evaluation. Independent evidence review remains outside the compiler’s control and optimization objective. Its decisions remain appealable and replayable.

54.16 Invariants

Role identity survives storage, permutation, routing, contraction, explanation, and rollback.
No proposal is judged without its full candidate denominator and resource cost.
Higher order is admitted only after named lower-order rescues are implemented competently under matched budgets.
Every compiled relation has provenance, uncertainty, scope, expiry, descendant tracking, and a reversible fallback.
A gain on synthetic relational tasks is not promoted into a claim of general intelligence, irreducible structure, or universal arity.

Together these constraints make added order defeasible and inspectable: semantic roles survive transformations, every proposal remains countable, simpler rescues stay available, and retirement cannot silently strand dependent state. They also prevent silent promotion. All exceptions require explicit review.

54.17 Failure modes

Combinatorial explosion from indiscriminate tuple materialization.
Arity theater relabels pairwise or sequence computation without adding role-sensitive capability.
Role collapse treats distinct participant positions as exchangeable.
Proposal filtering hides the denominator and inflates apparent qualification rates.
Synthetic benchmark leakage rewards topology templates rather than relational transfer.
Contraction deletes information or leaves stale descendants and cache entries.
Compiler overhead exceeds the value of the admitted structure.
Self-modification authority is smuggled into a learned proposal mechanism.
Relational hallucination gives a typed, authoritative surface to a false or unsupported structure.
False reduction or pairwise laundering hides an irreducible joint residual behind several correlated edges and then calls the aggregate qualified.
Axis confusion mixes batch, role, time, space, scale, branch, confidence, precision, or authority because they happen to occupy tensor dimensions.
Branch leakage actualizes a plan, simulation, prediction, or counterfactual without an observation, execution, or adoption event.
False objecthood and over-contraction turn a transient statistical cluster into a durable entity and accumulate abstraction debt.
Relation, topology, schema, certificate, cache, or operator drift leaves old qualifications active after their premises changed.
Poisoned relations, forged provenance, or evaluator capture let the proposer manufacture both structure and its acceptance evidence.
A hidden oracle supplies candidate tuples, schemas, roles, or stop points that ordinary baselines do not receive.
Schema capture and representational lock-in make one early ontology costly to challenge, fork, or migrate.
Explicit inferred relations amplify sensitive information beyond the facts a principal was individually permitted to inspect.
An inspectable relation graph is presented as a causal or mechanistic explanation without intervention or mediation evidence.

54.17.1 When not to compile

Do not compile when the relation is one-off, poorly typed, source provenance is weak, a lower-order rescue matches it, the evaluation denominator is incomplete, its context changes faster than qualification, or the inverse cannot be made safe. Retrieval or deliberate reconstruction may be slower but more honest. “Keep it stupid simple” appears here as a promotion rule: the system pays for structural complexity only after simpler mechanisms lose under matched evaluation.

54.18 Minimum Viable Implementation

A deterministic compiler for a small typed-relation language with candidate and denominator logs, pairwise-node and sequence baselines, role-permutation and counterfactual tests, promotion and demotion thresholds, cost accounting, reversible contraction, descendant invalidation, and a held-out RODIE fixture family.

The bounded trial includes symmetric and asymmetric roles, equivalent lower-order encodings, deliberately spurious higher-order candidates, unseen topologies, branch-confusion traps, expired provenance, and descendants in memory and caches. An independently written evaluator should reconstruct the complete proposal denominator and compare useful accuracy, calibration, latency, memory, compilation cost, and abstention. Passing would establish only compiler conformance and bounded fixture behavior; it would not establish irreducibility, natural-task advantage, general reasoning, or safe learned adaptation. Every fixture retains its random seed and artifact digest.

54.19 Mature Research Target

A serious advance would show independently reproduced gains on natural and synthetic relational workloads across unseen topology and role configurations, beat strong lower-order rescues under matched compute and memory, retain calibrated abstention, and demonstrate safe online admission and contraction without corrupting dependent state. The mature target architecture would conserve proposal denominators, provenance, uncertainty, descendant invalidation, and fallback while showing that admitted structure earns its lifecycle cost.

The endpoint would combine a public typed relational language, multiple independent compilers, adversarially designed natural and synthetic workloads, and a full lifecycle ledger from proposal through contraction. Evaluations would hold out topology and role composition, measure discovery cost as well as execution cost, and compare reification, message passing, factorization, sequence, retrieval, tool, and ordinary-model baselines. Positive results would remain task- and budget-bound rather than becoming a claim that higher-order structure is universally necessary. Failures and rejected proposals would remain publishable first-class results. Cross-implementation disagreement would remain clearly visible rather than averaged away.

That compiler ecosystem is a proposed destination rather than a demonstrated capability. Support could move only after complete-denominator implementations, strong rescues, held-out natural and synthetic evaluation, independent reproduction, full lifecycle traces, and honest resource accounting. Those artifacts would still support bounded task claims rather than universal irreducibility, general reasoning, safe self-improvement, or ASI.

54.20 Codex test plan

Test	Purpose	Status
Role-permutation test	Preserve symmetric roles and distinguish asymmetric roles across storage and execution.	planned; not run
Lower-order rescue tournament	Compare reified pairwise, message-passing, sequence, retrieval, tool, and ordinary-model baselines under matched budgets.	planned; not run
Proposal-denominator test	Log every proposed, filtered, shadowed, admitted, demoted, and failed candidate with resource cost.	planned; not run
Unseen-topology test	Hold out relational structures rather than only entity values or examples.	planned; not run
Branch-isolation test	Prevent simulated, counterfactual, proposed, and observed relations from crossing epistemic or branch boundaries.	planned; not run
Compile-conformance test	Show that fast-path lowering preserves typed roles, outputs, uncertainty, provenance references, and abstention behavior.	planned; not run
Contraction test	Retire relations, enumerate descendants, invalidate caches and compiled artifacts, and report irrecoverable influence separately.	planned; not run
Natural-usefulness test	Measure relational gain, calibration, useful throughput, and governance cost on natural tasks separately from synthetic diagnostics.	planned; not run

54.21 Formalization hooks

lean:relational-dimension-compilation-and-polyadic-cognition.admission_boundary is implemented in AsiStackProofs.RelationalDimensionCompiler with 42 theorem declarations. An eight-transition lifecycle preserves exact proposal, compiler, source-residual, role-schema, branch, authority, rescue, qualification, compilation, fallback, and contraction boundaries for arbitrary run length. One complete authored dossier reaches only a Project Theseus relational compiler study; all 54 admission-axis mutations block readiness and receive an exact repair or refusal disposition.

The structural proofs preserve role and candidate identity over finite append; entity remapping changes participants while preserving role IDs. Quantified role-schema and proposal denominator obligations reject an omitted required role or hidden candidate. Descendant closure composes over append, and one active descendant blocks contraction until it is invalidated or recompiled. Candidate-budget overrun remains an overrun when generation grows. Seven proposal, compiler, role, rescue, qualification, fallback, and authority changes invalidate receipts.

Two information-loss proofs constrain evaluation. Identical qualification scores, latency, and memory bands can coexist with opposite role fidelity, and identical named-rescue records can coexist with opposite lower-order rescue competence. Therefore aggregate qualification metrics cannot recover role identity, and rescue paperwork cannot establish competent implementation. Search Substrates rejects a missing baseline, Routing sends an unqualified compiler to fallback, and Evidence States blocks empirical promotion without a compiler experiment.

Chapter support remains argument. The model does not prove higher-order irreducibility, representational usefulness, efficiency, natural-task transfer, bounded primitive arity, safe online adaptation, support, release, transfer, or external effect. Those claims require the compiler, independent evaluation, matched baselines, natural workloads, reproduction, and Project Theseus integration.

54.22 Source crosswalk

Source ID	Title	Planned use
`relational_dimension_compiler`	The Relational Dimension Compiler: Adaptive Polyadic Cognition with Bounded Computational Arity and Unbounded Semantic Structure	Primary conceptual architecture for the typed relational IR, sparse adaptive order, role-preserving reification, qualified relation lifecycle, slow-to-fast compilation, reversible contraction, hardware lowering, and RODIE program. It supplies hypotheses and tests, not an implementation or positive result.

54.22.1 Manifest source assignment reconciliation

These rows keep Relational Dimension Compilation and Polyadic Cognition’s manifest assignments visible at their recorded review boundary. Passage review does not establish local reproduction, performance, safety, deployment, or support-state movement.

Source	Intake role	Boundary
`ext_neural_message_passing_2017`	Metadata-first comparator: Neural Message Passing for Quantum Chemistry. Primary message-passing neural-network framework for learned computation over graph structure. Its molecular results motivate a non-token-native relational lane but do not establish general reasoning, dynamic graph memory, exact state, or local reproduction.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.

54.23 Summary

Relational dimension compilation is a proposal for letting semantic structure grow while primitive computation stays bounded and governable. Its credibility depends on the constraints: typed roles, explicit dimensional axes, residual- triggered proposals, complete denominators, strong lower-order rescues, held- out qualification, budgeted promotion, semantic-preserving compilation, reversible contraction, and disaggregated RODIE evaluation. Nothing in the paper or the present argument establishes that higher-order structure is irreducible, efficient, or useful in practice. Those are the experiments.

The architectural value is conditional discipline. It supplies a place to test polyadic structure without assuming that additional order is progress, without hiding rejected proposals, and without granting a learned mechanism installation authority. If simpler representations win, the lifecycle returns to them. If higher order wins narrowly, provenance, cost, abstention, expiry, and contraction remain part of the admitted capability.

54.24 Handoff

A compiler can propose and lower a new representation, but training determines which parts are learned, synchronized, checkpointed, and authorized to change. Continue to Governed Model Training, Distributed Optimization, and Scaling. It receives the typed state schema, candidate and qualification denominator, compiled-operator identity, optimizer eligibility, descendant graph, rollback path, and unsupported claims. It does not inherit a useful higher-order representation, trained router, safe update, scaling, or support conclusion.