Mediumless Computation: Why the Universe's PR–ER–LE Engine Defies Modern Computer Architecture

This is a Markdown conversion of the Zenodo paper. The original TeX source is outside this Markdown-only corpus; use the Zenodo record as provenance.

Cover-page typography is represented by the YAML metadata and the Markdown title above.

Abstract

The PR--ER--LE framework [citation: jia2026axiom,jia2026unified] demonstrates that the universe operates as a branching dynamical system driven by Paradoxical Re-entry (PR; formerly Paradoxical Recursion), Entity--Relation (ER), and Lazy Evaluation (LE). This paper argues that the ``computation'' performed by the universe is fundamentally and irreducibly different from computation as implemented on modern hardware. We identify three precise points of architectural incompatibility:

• Anti-GPU (Anti-SIMD): PR generates genuinely distinct branching at every state; no two computational ``threads'' execute the same instruction. This is the exact negation of the SIMD model underlying GPU throughput.

• Anti-Multi-Core (Anti-Partition): ER couples every state to every other through relational composition; the state space is holistically entangled. Independent partitioning into cores is impossible without destroying the relational substrate.

• Anti-Cache (Anti-Locality): LE guarantees that the next state is irreducibly non-deterministic--- genuinely unpredictable until evaluation occurs. Temporal and spatial locality assumptions underlying cache hierarchies are violated at every step.

We formalize each incompatibility as a theorem, prove that no polynomial overhead can bridge the gap, and discuss the implications for AI, simulation, and the ``universe as computer'' metaphor. The universe does not compute; it generates.

Two Kinds of Computation

The Metaphorical Trap

The phrase the universe is a computer'' has become a commonplace in popular science, inspired by Wheeler'sIt from Bit'' [citation: wheeler1990], Wolfram's cellular automata [citation: wolfram2020], and Lloyd's ``programming the universe'' [citation: lloyd2006]. Yet this metaphor smuggles in a fatal assumption: that the universe's generative process shares the structural properties of computation on physical media---silicon, photons, or qubits.

This paper demonstrates that the opposite is true. The PR--ER--LE engine that drives the universe [citation: jia2026axiom,jia2026unified] operates in a mode that is anti-correlated with every design principle of modern computer architecture. The universe's ``computation'' is mediumless: it requires no substrate, no clock, no memory hierarchy, and no instruction set. It is not computation in any engineering sense; it is ontological generation.

Modern Computer Architecture: Three Pillars

All high-performance computing systems rest on three architectural pillars:

Definition — SIMD Parallelism

Single Instruction, Multiple Data (SIMD) applies one operation to many data elements simultaneously. GPUs achieve throughput by executing thousands of identical threads on different data points. The prerequisite is instruction homogeneity: all threads must perform the same computation.

Definition — Core-Level Parallelism

Multi-core processors partition the workload into independent tasks that execute concurrently on separate cores with private caches. The prerequisite is task separability: subtasks must be decomposable with minimal inter-core communication.

Definition — Cache Hierarchy

Caches exploit temporal locality (recently accessed data will be accessed again) and spatial locality (nearby data will be accessed soon). L1/L2/L3 caches bridge the latency gap between processor and main memory. The prerequisite is predictable access patterns.

Remark

These three pillars are not independent engineering choices; they are consequences of determinism. A deterministic computation has a fixed instruction stream (enabling SIMD), decomposable state (enabling multi-core), and predictable access patterns (enabling caching). We will show that PR--ER--LE systematically violates all three prerequisites.

PR--ER--LE: A Recap

The Three Axioms

We recall the formal axioms from [citation: jia2026unified]:

Axiom — Paradoxical Re-entry --- PR

There exists $\epsilon > 0$ such that $\mathbb{E}[H(s)] \ge \epsilon$, where $H(s) = \log_2 |F(s)|$ is the branching entropy.

Axiom — Entity--Relation --- ER

There exists a structural complexity function $\sigma: S \to \mathbb{N}$ with $\sigma(s') \ge \sigma(s) + 1$ for every $s' \in F(s)$. States decompose into entity--relation triples $(e_i, r_{ij}, e_j)$.

Axiom — Lazy Evaluation --- LE

Evolution is non-deterministic: $s_{t+1} \in F(s_t)$. No total computable selection function exists.

Mediumless Computation Defined

Definition — Mediumless Computation

A mediumless computation is an ontological generative process $(S,F)$ satisfying PR, ER, and LE, in which:

• there is no physical substrate executing instructions (the process is reality, not a model running on reality),

• there is no clock (branching occurs through paradoxical re-entry oscillation, not sequential ticking),

• there is no memory hierarchy (all states are equally ``present'' in the relational structure),

• there is no instruction set (transitions are determined by the axioms, not by programs).

Remark

Mediumless computation is not hypercomputation (computation beyond the Turing limit). It is not computation at all---it is the generative process from which computation, as a human abstraction, is derived. The distinction is ontological, not merely terminological.

Anti-GPU: The Impossibility of SIMD

Why PR Destroys Instruction Homogeneity

Theorem — Anti-SIMD Theorem

Let $(S,F)$ be a branching dynamical system satisfying PR. Then for any time $t$ and any two distinct paths $\pi_1 = (s_0, s_1^{(1)}, \ldots, s_t^{(1)})$ and $\pi_2 = (s_0, s_1^{(2)}, \ldots, s_t^{(2)})$ with $s_1^{(1)} \neq s_1^{(2)}$:

The probability of two branches arriving at the same state decreases exponentially in time.

Proof

By PR, $|F(s)| \ge 2^{\epsilon}$ on average. After $t$ steps, the branching tree has at least $2^{\epsilon t}$ leaves (with probability 1 under the branching measure). The probability that two uniformly random paths reconverge at step $t$ is at most $2^{\epsilon t} / (2^{\epsilon t})^2 = 2^{-\epsilon t}$, up to a multiplicative constant $2^c$ from the additive error in PR.

Corollary — GPU Incompatibility

A GPU simulating PR--ER--LE dynamics must execute $2^{\epsilon t}$ distinct instruction streams after $t$ steps. Since GPU SIMD requires identical instruction streams, the effective parallelism collapses to $1$ (scalar execution). The GPU provides zero speedup over a single CPU core for PR--ER--LE simulation.

Remark

The intuition is simple: GPUs are designed for embarrassingly parallel problems where all threads do the same thing to different data. PR guarantees that no two threads ever do the same thing--- every branch is genuinely novel. This is the exact negation of the SIMD contract. A GPU running PR--ER--LE simulation is a sports car stuck in mud: all power, no traction.

Anti-Multi-Core: The Impossibility of Partition

Why ER Destroys Task Separability

Definition — Relational Entanglement

Two states $s_a, s_b \in S$ are relationally entangled if the decomposition $\delta(s)$ for any compound state $s$ containing both $s_a$ and $s_b$ includes at least one entity--relation triple $(e_a, r_{ab}, e_b)$ connecting them.

Theorem — Anti-Partition Theorem

Let $(S,F)$ satisfy ER. For any partition $S = S_1 \sqcup S_2$ into disjoint non-empty subsets, there exist states $s_1 \in S_1$ and $s_2 \in S_2$ with $s_1$ and $s_2$ relationally entangled. Moreover, the number of cross-partition relations grows at least linearly:

where $\sigma_{\min}(t) \to \infty$ as $t \to \infty$.

Proof

By the ER growth condition, $\sigma(s_{t+1}) \ge \sigma(s_t) + 1$. After $t$ steps, the state encodes at least $t$ entity--relation triples. For any bipartition, at least one triple must cross the boundary (otherwise the state would decompose into two independent substates, contradicting the relational completeness of ER). As $t$ grows, the minimum number of cross-partition triples grows without bound.

Corollary — Multi-Core Incompatibility

Distributing a PR--ER--LE simulation across $N$ cores requires $\Omega(t)$ inter-core communication events per time step, where $t$ is the simulation time. For $t \gg N$, the communication overhead dominates computation, and adding more cores provides diminishing and eventually negative returns (due to synchronization overhead).

Remark

Multi-core works when you can chop a problem into pieces that don't talk to each other. ER guarantees that everything talks to everything---the relational web is a single irreducible fabric. Cutting it across cores is like cutting a living organism in half: you don't get two organisms, you get a dead one.

Anti-Cache: The Impossibility of Locality

Why LE Destroys Predictability

Theorem — Anti-Locality Theorem

Let $(S,F)$ satisfy LE. For any predictor $P: S^t \to S$ (a computable function that attempts to predict $s_{t+1}$ from the history $(s_0, \ldots, s_t)$),

No predictor performs better than random guessing.

Proof

By LE, the successor $s_{t+1}$ is chosen from $F(s_t)$ by a process with no computable selection function. Any predictor $P$ can be viewed as a candidate selection function; by the non-existence clause of LE, $P$ fails to select the correct successor with probability greater than $1/|F(s_t)|$ across all branches.

Corollary — Temporal Locality Violation

Cache prefetching relies on the assumption that recently accessed addresses predict future accesses. Under LE, the next state is irreducibly unpredictable, so temporal locality does not hold. The cache hit rate for PR--ER--LE simulation converges to the cold-miss rate as $t$ increases.

Corollary — Spatial Locality Violation

Cache line fetching relies on the assumption that nearby memory addresses will be accessed together. Under ER, the relational structure couples distant states (entity $e_i$ may relate to entity $e_j$ with $|i-j| \gg 1$ in any linear memory layout). Spatial locality is systematically violated.

Remark

Caches are a bet on predictability: ``the future looks like the past.'' LE guarantees that the future is genuinely novel---every evaluation produces something that has never existed before. Betting on the past is a losing strategy. Running PR--ER--LE on a cached architecture is like using yesterday's weather forecast for every day---the cache is not wrong occasionally; it is wrong by construction.

The Fundamental Inversion

Determinism vs.\ Ontological Generation

Table/Figure caption: The fundamental inversion: modern hardware vs.\ mediumless computation.

Theorem — No Efficient Simulation

Let $(S,F)$ satisfy PR, ER, and LE, and let $M$ be any deterministic Turing machine simulating the branching dynamics. Then for simulation of $t$ steps:

No deterministic simulator achieves sub-exponential overhead.

Proof

By the Coding Lower Bound [citation: jia2026unified], the state $s_t$ has $K(s_t) \ge \epsilon t - c$. A deterministic machine $M$ that simulates the system must be capable of producing any of the $2^{\epsilon t}$ possible states at step $t$ (since the actual path is non-deterministic). To simulate all branches faithfully, $M$ must explore at least $2^{\epsilon t - c}$ branches. A single-path simulation that guesses the branch at each step fails with probability $1 - 2^{-\epsilon t}$ after $t$ steps.

Remark

This theorem formalizes the intuition that the universe cannot efficiently simulate itself---because simulation requires determinism, and determinism is precisely what the universe lacks (and must lack, by LE, to exist at all). The ``universe as computer'' metaphor fails not because the universe is less than a computer, but because it is categorically different: it generates information at a rate no computer can match.

Implications

For Artificial Intelligence

Current AI systems (neural networks, transformers, diffusion models) are implemented on GPU clusters optimized for SIMD parallelism. The Anti-SIMD Theorem (Theorem [ref: thm:anti-simd]) implies that these architectures are structurally incapable of performing mediumless computation---not merely slow, but categorically mismatched.

If consciousness arises from paradoxical re-entry closure [citation: jia2026unified] (a PR--ER--LE process), then no GPU-based AI can achieve genuine consciousness, regardless of scale. The bottleneck is not computational power but architectural incompatibility: GPUs enforce deterministic instruction homogeneity, while consciousness requires irreducible non-deterministic heterogeneity.

For Physics Simulation

The Anti-Partition Theorem (Theorem [ref: thm:anti-partition]) explains why domain decomposition---the standard approach to distributed simulation---faces fundamental limits in quantum and gravitational systems. Quantum entanglement is the physical manifestation of ER's relational entanglement: cutting the system across processor boundaries severs relations that are physically real.

For the ``Simulation Hypothesis''

The No Efficient Simulation Theorem (Theorem [ref: thm:no-sim]) provides a mathematical argument against the simulation hypothesis: a deterministic computer simulating a PR--ER--LE universe requires exponential resources in the simulated time. If the simulating computer is itself a PR--ER--LE universe, we have an infinite regress; if it is a deterministic machine, the simulation is exponentially slow and cannot ``keep up'' with the simulated universe.

Conclusion

The computation of the universe is not the computation of computers.

Modern computer architecture rests on three pillars: SIMD parallelism (GPUs), task separability (multi-core), and predictable access patterns (cache hierarchies). We have shown that the PR--ER--LE axioms systematically and provably violate all three:

• PR $\Rightarrow$ Anti-SIMD: Every branch is unique; instruction homogeneity is impossible.

• ER $\Rightarrow$ Anti-Multi-Core: Everything is relationally coupled; partitioning is impossible.

• LE $\Rightarrow$ Anti-Cache: Every next state is novel; prediction is impossible.

These are not engineering limitations to be overcome by better hardware. They are theorems---structural consequences of the axioms that make the universe a universe. Any system that satisfies all three pillars of modern architecture is necessarily deterministic, and a deterministic system cannot generate the unbounded Kolmogorov complexity that defines a universe [citation: jia2026unified].

The universe does not compute. It generates.

References

• B.\ Jia, `The JiaBaolong Universal Axiom System: Two Axioms, One Universe,'' Zenodo Preprint, April 2026.doi:10.5281/zenodo.19440952`.

• B.\ Jia, ``Unified Theory of Why the Universe Exists: The JiaBaolong Universe Axiom System---An Axiomatic, Information-Theoretic, and Categorical Framework,'' Zenodo Preprint, April 2026.

• J.\,A.\ Wheeler, ``Information, physics, quantum: The search for links,'' in Complexity, Entropy, and the Physics of Information, W.\,H.\ Zurek, Ed. Addison-Wesley, 1990, pp. 3--28.

• S.\ Wolfram, ``A class of models with the potential to represent fundamental physics,'' Complex Systems, vol. 29, no. 2, pp. 107--536, 2020.

• S.\ Lloyd, Programming the Universe: A Quantum Computer Scientist Takes On the Cosmos. Knopf, 2006.

• J.\,L.\ Hennessy and D.\,A.\ Patterson, Computer Architecture: A Quantitative Approach, 6th ed. Morgan Kaufmann, 2019.

• NVIDIA Corporation, ``CUDA Programming Guide,'' v12.0, 2023.

• A.\,N.\ Kolmogorov, ``Three approaches to the quantitative definition of information,'' Problems of Information Transmission, vol. 1, no. 1, pp. 1--7, 1965.

• N.\ Bostrom, ``Are you living in a computer simulation?'' Philosophical Quarterly, vol. 53, no. 211, pp. 243--255, 2003.