Informational Metabolics in a Dual-Phase Cellular Automaton: Verifiable Delay Functions, 4x21 Geometric Confinement, and the Algorithmic Exhaust of Observation

Author’s Prologue: A Path to Cellular Automata

Before diving into the mechanics of Linked Digital Dynamics (LDD), I want to briefly share the context of this work. My background did not begin in theoretical physics; it began in the social sciences. I was studying the emergent behaviors of complex networks and agents, which eventually required me to move under increasing confinement into the strict logic of number theory to test my intuition.

My guiding thesis through this interdisciplinary journey was a simple epistemological equation: $1 = O + C + E$. For anything to be considered part of classical reality ( $1$), it must be Observable ( $O$), Communicable ( $C$), and Effectual ( $E$).

For years, I operated on this intuitive conjecture, trying to map how ideal models resolve into logical, computational realities. As I refined this into Latin square dynamics, I belatedly realized that the mathematics of information, communication, and computation theory were always leading me to a single destination: Cellular Automata. Discovering that the Wolfram Physics Project and Mathematica had already established the exact computational environment needed to resolve these intuitive models was a revelation.

As you read the following framework and experiment with the code, you will see how the LDD engine is simply the literal, discrete execution of this equation—where observation is geometric confinement, communication is phase-locking, and effect is the thermodynamic drag of computation.

1. Abstract

The Wolfram Physics Project has provided a profound new lens for viewing spacetime as an emergent property of discrete computation. Yet, as a community, we often grapple with the combinatorial explosion inherent in un-pruned multiway systems—what might be thought of as a "Cosmological Halting Problem." This paper introduces Linked Digital Dynamics (LDD), an exploratory cellular automaton that attempts to model a strict thermodynamic filter over these multiway branches.

By treating the substate as a simple $6 \times 6$ dual-phase grid, we observe that even minimal localized interactions generate massive combinatorial phase spaces (e.g., $2^{72}$ conditions). To explore how a universe might compute this without freezing, LDD introduces a simulated physical cost: a Verifiable Delay Function (VDF). Using a $4 \times 21$ geometric confinement matrix (the "Anvil Strike"), this toy model shears off incompatible geometries as Algorithmic Exhaust (entropy). Through an executable Wolfram Language Macro-Engine shared below, we can visually explore how this underlying "Informational Metabolic Hunt" naturally segregates a chaotic substate into stable, fast-ticking islands and dense, slow-ticking wells. LDD is presented here as a computational sandbox to invite community feedback on whether emergent gravity and relativistic time dilation might be fruitfully modeled as the macroscopic unevenness of computational friction.

2. Introduction: Exploring the Cosmological Halting Problem

Like many in this community, I have been deeply inspired by the shift toward modeling physics as fundamental, discrete computation. However, while experimenting with localized multiway graphs, I repeatedly ran into a practical computational wall. If every point in space represents a discrete locus evaluating causal branches, the system must navigate a massive phase space of potential states.

Consider a minimal collision of two $6 \times 6$ binary substates (an un-sponged False Vacuum). This simple interaction yields over 4.7 sextillion ( $2^{72}$) possible combinatorial starting conditions. If the universe were purely probabilistic and smooth, searching through this phase space to find a stable interaction seems computationally prohibitive. Without a rigorous pruning mechanism, a discrete universe risks freezing under the weight of its own combinatorial explosion.

Testing a Thermodynamic Cost for Computation Linked Digital Dynamics (LDD) is my attempt to build a computable model that addresses this by enforcing a strict thermodynamic cost for time. Inspired by cryptographic principles, I wanted to test what happens if the multiway graph is aggressively filtered by Topological Drag—a Verifiable Delay Function (VDF) that forces potential states to "prove" their structural integrity before solidifying.

This led to the concept of Informational Metabolics. In this framework, a pro-causal trajectory does not calculate all possible futures; it "hunts" for adjacent structural support within a rigid $4 \times 21$ spatial confinement matrix. If the geometry perfectly phase-locks, it metabolizes that potential into a stable structure. If it fails, the unmatched data is sheared off into the substate as Algorithmic Exhaust.

3. Ontology of the Strata: Substate, Microstate, and Macrostate

To circumvent the combinatorial explosion of the multiway graph, LDD proposes that reality does not compute in a single continuous layer. Information must survive severe geometric compression to ascend from pure potential to classical reality.

• I. The Substate (The False Vacuum): The foundational layer, modeled computationally as a $6 \times 6$ branchial buffer. This is a region of pure, un-sponged potential—a completely frictionless state of non-constructive optimism where multiway branches freely generate. It possesses zero entropy.
• II. The Microstate (The Thermodynamic Forge): Defined by the $4 \times 21$ Geometric Confinement Matrix. When two offset causal trajectories attempt to interact, their multiway potential is forced into an orthogonal cross-reading we call the Anvil Strike. It is a literal cryptographic pruning function testing if discrete geometries can support one another.
• III. The Macrostate (Linear Indifference): The resulting classical reality, composed exclusively of localized motifs that survived the Anvil Strike. A Macrostate observer exists in a state of Linear Indifference—because its internal structure balances the thermodynamic drag, it feels no friction from its own existence, experiencing discrete processing purely as smooth spacetime.

4. Cryptographic Thermodynamics: The Cost of Observation

In classical physics, entropy is a measure of disorder. In LDD, entropy is strictly redefined as Algorithmic Exhaust—the literal byproduct of failed computation.

Because the substate is continuously attempting to expand, the universe requires an anchoring mechanism. The VDF acts as the fundamental clock speed of the universe, imposing Topological Drag modeled as a $+2, -1$ pro-causal ratchet. The $+2$ represents optimistic branchial generation, and the $-1$ represents the thermodynamic computational cost exacted by the universe.

When a trajectory enters the $4 \times 21$ confinement cage, the VDF enforces Mutually Assured Cooperation. Optimistic multiway data only survives if it has adjacent structural support. Incompatible data snaps under the tension and is sheared off the event horizon back into the substate as Algorithmic Exhaust.

5. Informational Metabolics: The Darwinian Engine of Reality

LDD requires a radical inversion of perspective: a localized multiway branch is an active, hungry computational agent. We term this survival mechanism the Informational Metabolic Hunt.

The massive $2^{72}$ combinatorial phase space of the False Vacuum is the raw caloric potential of the universe. As a trajectory is pushed forward by the VDF, it must consume this substate potential to maintain phase-lock. A successful "hunt" occurs when two distinct trajectories possess the exact geometric seeds required to interlock. Conversely, trajectories with incompatible seeds cannot metabolize the local substate; they "starve" within the Anvil Strike and drop out of the macro-reality. Only the most geometrically optimized structures survive the friction of time.

6. Informational Relativity and Cosmogenesis

Because LDD posits that time is locally computed labor rather than a universal background dimension, there is no absolute clock. By decoupling a local observer's VDF speed from the computational phase of an external node, we organically generate Informational Relativity.

A stable macrostate motif requires an $8 \times 8$ harmonic membrane to resolve chiral pressure. The literal edge of this membrane acts as the particle's Event Horizon, which exhibits Causal Elasticity. An observer can tolerate a slight relational phase offset ( $\Delta$) with an external node without breaking phase-lock. However, if the relativistic tension exceeds the harmonic capacity, the boundary violently shears into Algorithmic Exhaust.

This perfectly mirrors Einsteinian mechanics:

• Spatial Expansion (Redshift): If an external node's VDF computes slower ( $\Delta > 0$), the computational channel stretches.
• Informational Collisions (Blueshift): If the node computes faster ( $\Delta < 0$), the computational distance collapses, aggressively forcing its multiway state onto the observer.

7. The LDD Engine: A Computable Laboratory

To move from philosophy to falsifiable physics, I have developed a native Wolfram Language laboratory.

I. The Holographic Relativistic Micro-Engine This module isolates a single $4 \times 21$ Anvil Strike. Using the dual-slider architecture, you can physically drag an external node through the entire spectrum of informational Doppler shift. You can also load highly ordered "Custom Seeds" (orthogonal arrays) to witness how perfect geometry acts as a "Still Life," surviving VDF loops without evaporating.

ClearAll[SeedFrameA, SeedFrameB, InitializeFalseVacuum, VDFSubstateMix, AnvilStrike, LDDChronoverticalTick, LDDDashboard];

(* I. CUSTOM STARTING CONDITIONS *)
SeedFrameA = {{1, 0, 1, 0, 1, 0}, {0, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 0}, {0, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 0}, {0, 1, 0, 1, 0, 1}};
SeedFrameB = {{1, 1, 1, 1, 1, 1}, {0, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 1}, {0, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 1}, {0, 0, 0, 0, 0, 0}};

InitializeFalseVacuum[] := RandomInteger[1, {6, 6}];
VDFSubstateMix[grid_] := Mod[grid + ListConvolve[{{1, 1, 1}, {1, 0, 1}, {1, 1, 1}}, grid, 2], 2];

(* II. MICROSTATE CONFINEMENT & ALGORITHMIC EXHAUST *)
AnvilStrike[gridA_, gridB_, ticksA_, ticksB_] := Module[
  {trajA, trajB, phaseSpace, cage, stabilizedCage, preSum, postSum, entropy},
  trajA = Join[Flatten[gridA], IntegerDigits[Mod[ticksA, 64], 2, 6]];
  trajB = Join[Flatten[gridB], IntegerDigits[Mod[ticksB, 64], 2, 6]];
  phaseSpace = Join[trajA, trajB];
  cage = Partition[phaseSpace[[Mod[Range[84]*5, 84] + 1]], 21];
  preSum = Total[Flatten[cage]];
  stabilizedCage = cage * UnitStep[ListConvolve[{{1, 1, 1}, {1, 0, 1}, {1, 1, 1}}, cage, {2, 2}, 0] - 1];
  postSum = Total[Flatten[stabilizedCage]];
  entropy = preSum - postSum;
  <|"Microstate" -> stabilizedCage, "Entropy" -> entropy, "ExhaustBits" -> (cage - stabilizedCage)|>
];

(* III. CHRONOVERTICAL TICK *)
LDDChronoverticalTick[gridA_, gridB_, localVDF_, deltaVDF_] := Module[
  {ticksA, ticksB, mixedA, mixedB},
  ticksA = localVDF;
  ticksB = Max[0, localVDF + deltaVDF]; 
  mixedA = Nest[VDFSubstateMix, gridA, ticksA];
  mixedB = Nest[VDFSubstateMix, gridB, ticksB];
  AnvilStrike[mixedA, mixedB, ticksA, ticksB]
];

(* IV. INTERACTIVE DASHBOARD *)
LDDDashboard[] := DynamicModule[
  {gridA, gridB, result},
  gridA = SeedFrameA; gridB = SeedFrameB;
  Manipulate[
   result = LDDChronoverticalTick[gridA, gridB, localVDF, deltaVDF];
   Column[{
     Style["LDD: Holographic Relativistic CA Engine", Bold, 16, FontFamily -> "Helvetica"], Spacer[10],
     Row[{Style["Local VDF Speed: ", 12], Style[localVDF, Bold, 14], Spacer[20], Style["Relativity (\[Delta]): ", 12], Style[deltaVDF, Bold, 14], Spacer[30], Style["Algorithmic Exhaust (Entropy): ", 12, Red], Style[result["Entropy"], Bold, 16, Red]}], Spacer[15],
     Text@Grid[{{Column[{Style["Observer A Frame (Local)", 10], ArrayPlot[Nest[VDFSubstateMix, gridA, localVDF], ImageSize -> 130, Mesh -> True, ColorFunction -> "DeepSeaColors"]}], Column[{Style["Observer B Frame (External)", 10], ArrayPlot[Nest[VDFSubstateMix, gridB, Max[0, localVDF + deltaVDF]], ImageSize -> 130, Mesh -> True, ColorFunction -> "DeepSeaColors"]}]}}, Spacings -> {5, 1}], Spacer[20],
     Style["Phase-Locked Microstate (4x21 Confinement)", Bold, 12], ArrayPlot[result["Microstate"], ImageSize -> 550, Mesh -> True, ColorFunction -> "SunsetColors"], Spacer[10],
     Style["Non-Constructive Optimism (Sheared Entropy)", 10, Gray], ArrayPlot[result["ExhaustBits"], ImageSize -> 550, Mesh -> True, ColorFunction -> "Monochrome"]
     }, Alignment -> Center],
   {{localVDF, 42, "Observer A Baseline (Local VDF)"}, 1, 256, 1, Appearance -> "Labeled"},
   {{deltaVDF, 0, "Informational Relativity (\[Delta])"}, -512, 512, 1, Appearance -> "Labeled"},
   Row[{Button["Load Custom Seeds (A & B)", {gridA = SeedFrameA; gridB = SeedFrameB;}], Spacer[10], Button["Generate Random Vacuum", {gridA = InitializeFalseVacuum[]; gridB = InitializeFalseVacuum[];}]}],
   ControlPlacement -> Top, TrackedSymbols :> {localVDF, deltaVDF}
  ]
]
LDDDashboard[]

II. The Macroscopic Spacetime Lattice (Deep Time Simulation) This module expands the engine into a macroscopic lattice of 144 interacting observers. Using Deep Time Controls, you can age the universe by hundreds of ticks instantly. You will observe the False Vacuum segregate into cold islands of stable matter (fast-ticking clocks / vacuum) and dense, hot entropic borders (slow-ticking clocks / time dilation).

ClearAll[InitializeMacroVacuum, VDFSubstateMix, MacroAnvilStrike, MacroNetworkTick, LDDMacroDashboard];

InitializeMacroVacuum[size_] := Table[<|"Substate" -> RandomInteger[1, {6, 6}], "VDFClock" -> 0, "Entropy" -> 0.0|>, {size}, {size}];
VDFSubstateMix[grid_] := Mod[grid + ListConvolve[{{1, 1, 1}, {1, 0, 1}, {1, 1, 1}}, grid, 2], 2];

MacroAnvilStrike[nodeA_, nodeB_] := Module[
  {trajA, trajB, phaseSpace, cage, stabilizedCage, preSum, postSum},
  trajA = Join[Flatten[nodeA["Substate"]], IntegerDigits[Mod[nodeA["VDFClock"], 64], 2, 6]];
  trajB = Join[Flatten[nodeB["Substate"]], IntegerDigits[Mod[nodeB["VDFClock"], 64], 2, 6]];
  phaseSpace = Join[trajA, trajB];
  cage = Partition[phaseSpace[[Mod[Range[84]*5, 84] + 1]], 21];
  preSum = Total[Flatten[cage]];
  stabilizedCage = cage * UnitStep[ListConvolve[{{1, 1, 1}, {1, 0, 1}, {1, 1, 1}}, cage, {2, 2}, 0] - 1];
  postSum = Total[Flatten[stabilizedCage]];
  preSum - postSum
];

MacroNetworkTick[network_] := Module[
  {size, nextNetwork, n, s, e, w, localEntropy},
  size = Length[network]; nextNetwork = network;
  Do[
    n = network[[Mod[i - 1, size, 1], j]]; s = network[[Mod[i + 1, size, 1], j]];
    e = network[[i, Mod[j + 1, size, 1]]]; w = network[[i, Mod[j - 1, size, 1]]];
    localEntropy = Mean[{MacroAnvilStrike[network[[i,j]], n], MacroAnvilStrike[network[[i,j]], s], MacroAnvilStrike[network[[i,j]], e], MacroAnvilStrike[network[[i,j]], w]}];
    If[localEntropy < 1.5, nextNetwork[[i,j, "VDFClock"]] += 1; nextNetwork[[i,j, "Substate"]] = VDFSubstateMix[network[[i,j, "Substate"]]];];
    nextNetwork[[i,j, "Entropy"]] = localEntropy;
  , {i, size}, {j, size}];
  nextNetwork
];

LDDMacroDashboard[] := DynamicModule[
  {gridSize = 12, macroNetwork, totalAge = 0},
  macroNetwork = InitializeMacroVacuum[gridSize];
  Manipulate[
   Column[{
     Style["LDD: Macroscopic Spacetime Lattice", Bold, 16, FontFamily -> "Helvetica"], Spacer[5],
     Row[{Style["Age of Universe (Total Ticks): ", 14, White], Style[totalAge, Bold, 16, Cyan]}], Spacer[15],
     Row[{
       Column[{Style["Algorithmic Exhaust (Gravitational Heatmap)", Bold, 12, White], Style["Dark = Perfect Phase Lock (Baryonic Matter/Vacuum)\nBright/Hot = High Entropy (Event Horizons/Chaos)", 10, Gray], MatrixPlot[Map[#["Entropy"] &, macroNetwork, {2}], ColorFunction -> "ThermometerColors", ImageSize -> 300, Frame -> False, Mesh -> True, MeshStyle -> Opacity[0.2]]}], Spacer[40],
       Column[{Style["Informational Relativity (Local VDF Ticks)", Bold, 12, White], Style["Bright = Fast Clocks (Low Drag)\nDark = Slow Clocks (Time Dilation/Gravity Wells)", 10, Gray], MatrixPlot[Map[#["VDFClock"] &, macroNetwork, {2}], ColorFunction -> "SunsetColors", ImageSize -> 300, Frame -> False, Mesh -> True, MeshStyle -> Opacity[0.2]]}]
     }]
    }, Alignment -> Center, Background -> Black],
   Row[{Style["Advance Time: ", Bold, 12], Button["+1 Tick", {macroNetwork = MacroNetworkTick[macroNetwork]; totalAge += 1;}], Button["+10 Ticks", {Do[macroNetwork = MacroNetworkTick[macroNetwork], {10}]; totalAge += 10;}], Button["+100 Ticks", {Do[macroNetwork = MacroNetworkTick[macroNetwork], {100}]; totalAge += 100;}]}], Spacer[10],
   Button["Inject Big Bang (Regenerate Network)", {macroNetwork = InitializeMacroVacuum[gridSize]; totalAge = 0;}],
   ControlPlacement -> Top
  ]
]
LDDMacroDashboard[]

8. Conclusion and Call to Action: Mining the Substate

Linked Digital Dynamics demonstrates that a discrete, computable universe must possess a physical thermodynamic cost to prevent a combinatorial explosion. The Cosmological Halting Problem is solved by the Verifiable Delay Function—a pro-causal ratchet that violently shears off non-constructive optimism as Algorithmic Exhaust. In this model, gravity, time dilation, and event horizons are simply emergent, macroscopic artifacts of localized computational friction.

I present this framework not as a completed map of physics, but as a foundational sandbox. The true work lies in exploring the $2^{72}$ phase space of the False Vacuum.

I issue a direct challenge to the Wolfram Community: Mine the Substate. Using the provided Mathematica engine, search the combinatorial starting conditions for the exact binary seeds—the cryptographic "Latin squares" and orthogonal arrays—that yield perfectly stable, zero-entropy loops. By discovering which specific geometric matrices survive the thermodynamic forge of the $4 \times 21$ Anvil Strike, we can begin to isolate the literal discrete DNA of ordinary matter, dark matter, and the frictionless vacuum.