1 Introduction and Foundational Motivation
Modern programming language design, software engineering, and formal verification are plagued by a profound fragmentation. Disjoint computational models—such as the untyped lambda calculus, term rewriting systems (TRS), e-graphs, compiler intermediate representations (IR), and virtual machine bytecodes—are treated as separate worlds. They occupy distinct namespaces, employ incompatible metatheories, and rely on ad-hoc, pairwise compiler pipelines that leak implementation details and fail to preserve observational boundaries.
This paper argues that this fragmentation is unnecessary. We show that a broad class of closed formal systems can be represented through a single, quotient-mediated semantic kernel without loss of operational behavior. This kernel is not a new “universal language,” but rather a view-independent substrate: different programming languages and formalisms become different decoders over the same invariant structure.
1.1 Primal Modeling Assumptions
To build a mathematically closed computational substrate, we establish a set of minimal design assumptions. These are not proposed as cosmological truths about reality, but rather as the foundational design requirements for a closed algebraic representation of computation.
The universe of discourse (carrier space) is non-empty: \(\Omega \neq \emptyset \).
The substrate contains a unique element representing the empty or inactive context, denoted by \(\emptyset \), from which distinction begins.
The representation must support self-referential structures. This requires the algebraic capability to form pairs of carrier names, beginning with the initial pair: \(P = (\emptyset , \emptyset )\).
To drive computation, the system must distinguish the active operator from the operand it acts upon. In algebraic terms, this asymmetric relationship is modeled via Kuratowski pairing [ 5 ] :
This asymmetry, which we denote by \(\Delta \), serves as the operational drive for directed rewriting steps.
1.2 The 4-Carrier System and Design Heuristics
The computational substrate is spanned by four primitive carriers: Identity (\(I\)), Rewrite (\(R\)), Adjacency (\(A\)), and State (\(S\)). We conjecture that exactly four independent roles are necessary and sufficient to form a closed, non-trivial computational substrate:
Identity (\(C_I\)): Establishes a notion of stable normal forms and equivalence-preserving transformations. Without it, states dissolve into noise.
Rewrite (\(C_R\)): Represents directed, non-invertible selection. Without it, transitions are symmetric, preventing one-way directed computation.
State (\(C_S\)): Enables repeatable observables and state-space closure under self-application. Without it, the system collapses to a strictly linear, non-duplicating fragment that is sub-universal.
Adjacency (\(C_A\)): Maps topological interaction and function application. Without it, parameters cannot be composed into ordered causal chains.
Under this design heuristic, no carrier can serve dual roles without collapsing the representation space:
If \(C_I = C_S\), the quotient structure collapses, identifying observational equivalence with syntactic identity.
If \(C_R = C_A\), causality becomes mutable, leading to non-deterministic, non-confluent rewrites.
If \(C_I = C_R\), the invariant becomes strategy-dependent, making evaluation order determine the semantic outcome.
Thus, a minimal carrier set size of exactly 4 is indicated.
This 4-carrier structure provides a clean algebraic justification for the token hierarchies of digital computing:
1 Bit: Distinguishes existence from absence (atom vs. void).
2 Bits: Identifies one of the four active roles (\(C_I, C_R, C_A, C_S\)).
4 Bits (One Nibble): Represents a directed pair of names (an input pointer to a carrier role and an output pointer from a carrier role), expressing adjacency.
8 Bits (One Byte): Represents a pair of pairs—a source context and a target context—expressing a directed rewrite step.
1.3 Occam and the Description-Length Heuristic
For a candidate substrate model \(M\), we motivate the minimality of a 4-carrier substrate using a description-length marginal likelihood heuristic:
where \(\theta \) represents the parameter space (matrices and rules) and \(D\) represents a reference computation. Given the 4-carrier limit, any substrate with \(n {\gt} 4\) carriers introduces redundant gauge flexibility that increases description length. The terminal ISAR kernel minimizes this description length, acting as a Minimum Description Length (MDL) substrate.