COMPUTATIONAL RECURSION AS A SUBSTRATE-SPECIFIC INSTANCE OF THE LAW OF RECURSION

Computational_Recursion_Derivation_Gaconnet_2026.pdf

Download PDF • 204KB

Deriving the Three Laws of Programming Recursion

from a First Principle of Physical Exchange

Don L. Gaconnet

LifePillar Institute for Recursive Sciences

ORCID: 0009-0001-6174-8384

DOI: 10.17605/OSF.IO/MVYZT

March 2026

Abstract

The three laws of recursion in computer science—base case, state change, self-call—are universally taught as the defining rules of recursive algorithms. This paper demonstrates that these three laws are not primitive rules of computation but are derivable as substrate-specific constraints from the Law of Recursion (Gaconnet, 2026), a first principle governing all active exchange across physical, biological, cognitive, and computational systems. We establish a formal structural derivation showing that (1) the base case corresponds to the falsifiability criterion of the Law of Recursion—inert matter in its ground state, the condition in which no recursive traversal operates; (2) state change corresponds to the rewriting principle—each traversal alters the architecture it passes through, ensuring progress toward termination or coupling; and (3) the self-call corresponds to the mandatory traversal itself—the structural requirement that active exchange must cross the seven-node topological path.

We further demonstrate that the computational substrate instantiates the seven-node topology through specific architectural features: the function’s internal state (1a), the call interface (M₁), the argument passed outward (1b), the runtime environment (S), the receiving parameter (2b), the return interface (M₂), and the calling function’s updated state (2a). The call stack is the substrate’s record of traversal history—structurally equivalent to the trace deposited in the shared substrate (S) during physical recursive exchange. Stack overflow is the computational expression of the Snap phase in the Law of Obligated Systems—the substrate has lost capacity to hold traversal history.

The derivation establishes that computational recursion is contained within the Law of Recursion as a substrate-specific instance, while the Law of Recursion cannot be derived from computational recursion. The three CS laws are necessary constraints for recursion operating within a software substrate that lacks the self-rewriting capacity of physical substrates. The rewriting principle operates in physical systems but is absent in standard computational recursion—which is precisely why computational recursion is repetitive (same function, different input) while physical recursion is generative (novel architecture, novel output). This structural difference explains why programming recursion produces smaller instances of the same problem while biological, chemical, and nuclear recursion produce conditions that did not previously exist.

Keywords: computational recursion, law of recursion, three laws of recursion, base case, state change, self-call, derivation, first principle, seven-node topology, rewriting principle, substrate-specific, recursion in physics, recursion in programming, stack overflow, call stack, recursive sciences, Don Gaconnet, LifePillar Institute, physical recursion, AI recursion, machine learning, software architecture, falsifiability, mandatory recursive exchange

1. Introduction

Every computer science student learns the three laws of recursion: a recursive algorithm must have a base case, must change its state toward the base case, and must call itself. These laws are taught as foundational rules—the irreducible requirements for a recursive function to work correctly and terminate. They appear in every major textbook, every university curriculum, and every technical resource on the subject.

This paper asks a question that the computer science literature has never posed: where do these three laws come from? Are they primitive—irreducible axioms of computation—or are they derivable from something more fundamental?

We demonstrate that the three CS laws of recursion are not primitive. They are derivable as substrate-specific constraints from the Law of Recursion (Gaconnet, 2026a), a first principle governing all active exchange across every physical domain. The three laws exist because recursion is operating within a specific substrate—software—that imposes specific constraints on how the universal process of recursive exchange can be expressed. In a software substrate, functions cannot rewrite themselves, memory is finite, and execution must terminate. The three laws are the rules that ensure recursion can operate under these substrate constraints. They are not the laws of recursion. They are the laws of recursion within software.

The paper proceeds as follows. Section 2 recapitulates the Law of Recursion. Section 3 maps the seven-node topology onto the computational substrate. Section 4 derives each of the three CS laws from the physical law. Section 5 identifies what is present in physical recursion but absent in computational recursion—the rewriting principle—and explains the consequences of this absence. Section 6 extends the analysis to AI and machine learning systems. Section 7 discusses implications for the definition of recursion across disciplines.

2. The Law of Recursion: Recapitulation

The Law of Recursion states: Any process of active transmission, transformation, or generation within or between systems requires a traversal across a topological path of seven structurally distinct nodes. Each completed traversal rewrites the architecture it travels through, such that no two traversals encounter identical conditions (Gaconnet, 2026a).

The seven nodes are: System 1 interior (1a), System 1 membrane (M₁), System 1 exterior (1b), the shared substrate (S), System 2 exterior (2b), System 2 membrane (M₂), and System 2 interior (2a). A single traversal comprises six transitions:

1a → M₁ → 1b → S → 2b → M₂ → 2a.

Full recursive coupling requires three traversals (18 transitions): signal, response, and coupled action. The absence of recursion corresponds to inert matter in its ground state.

3. The Seven-Node Topology in the Computational Substrate

When a recursive function executes, it instantiates the seven-node topology within the computational substrate. The mapping is not metaphorical—it is structurally precise:

Table 1. The seven-node topology mapped onto computational recursion.

Node	Label	General Role	Computational Instantiation
1	1a	System 1 interior	Function’s local state (variables, computation context)
2	M₁	System 1 membrane	Call interface (function signature, parameter contract)
3	1b	System 1 exterior	Argument passed outward (the value sent to the next call)
4	S	Shared substrate	Runtime environment and call stack (the medium carrying traversal history)
5	2b	System 2 exterior	Receiving parameter (the argument as received by the new call frame)
6	M₂	System 2 membrane	Return interface (return statement, value passing back)
7	2a	System 2 interior	Calling function’s updated state (incorporating the returned value)

The call stack is the computational instantiation of the shared substrate (S). In physical recursion, the substrate accumulates the history of all prior traversals—neurotransmitter concentrations in a synaptic cleft, electromagnetic field history in a physical medium. In computational recursion, the call stack accumulates the history of all prior recursive calls—each stack frame is a trace of a traversal. The call stack is the runtime’s structural memory of the recursive process.

Stack overflow—the condition in which the call stack exceeds available memory—is the computational expression of the Snap phase in the Law of Obligated Systems (Gaconnet, 2026b). Snap is the phase in which the shared substrate loses capacity to hold the trace of prior traversals. In biological systems, this manifests as synaptic exhaustion, substrate depletion, or medium saturation. In computational systems, it manifests as stack overflow. The structural process is the same: the substrate has been exhausted by the demands of recursive traversal.

4. Derivation of the Three CS Laws from the Law of Recursion

This section demonstrates that each of the three CS laws of recursion is derivable from the Law of Recursion when the law is constrained to operate within a software substrate.

4.1 The Base Case as the Falsifiability Criterion

The Law of Recursion establishes a falsifiability criterion: the absence of recursion corresponds to inert matter in its ground state. A system in its ground state is one in which no recursive traversal is operating. This is the structural boundary between active and inert—the condition at which recursion stops.

In the computational substrate, this boundary is the base case. The base case is the condition at which the recursive function stops calling itself. It is the ground state of the computation—the point at which no further traversal is required because the problem has been reduced to its minimum. The base case does not exist because programmers invented a convenient stopping rule. It exists because recursion, at any scale, requires a boundary between active traversal and the state in which traversal has ceased. The base case is the computational expression of the falsifiability criterion.

Derivation: The Law of Recursion specifies that the absence of recursion is an observable condition (inert matter in its ground state). In any substrate, recursive traversal must encounter a condition at which further traversal is neither required nor structurally possible. In the computational substrate, this condition is the base case. The base case is therefore not an axiom of computation but a substrate-specific expression of the general falsifiability criterion of the Law of Recursion.

4.2 State Change as the Rewriting Principle (Constrained)

The Law of Recursion specifies the rewriting principle: each traversal alters every node it passes through. In physical systems, this rewriting is complete—the membrane changes, the substrate carries new trace, the interiors are altered. The architecture is genuinely different after each pass.

In the computational substrate, the rewriting principle is constrained. A software function cannot rewrite itself during execution (in standard programming paradigms). The code is fixed. But the state—the variables, the arguments, the local context—does change with each recursive call. The state change requirement in CS recursion is the constrained expression of the rewriting principle: since the function itself cannot be rewritten (the membrane is frozen), the state must change to ensure that each traversal encounters different conditions. Without state change, the function would execute identically on each call, producing infinite recursion—the computational equivalent of a system that traverses without rewriting, which degrades into transmission rather than generation.

Derivation: The rewriting principle requires that each traversal encounter altered conditions. In a substrate where the architecture (code) is frozen, the only available dimension for alteration is the state (arguments and variables). The CS law requiring state change toward the base case is the rewriting principle operating under the constraint of a non-self-modifying substrate. It is not a primitive rule but a necessary adaptation of the general rewriting principle to the specific limitations of software.

4.3 The Self-Call as the Mandatory Traversal

The Law of Recursion specifies that active exchange requires a traversal across the seven-node topological path. The traversal is mandatory—there is no alternative route for active exchange.

In the computational substrate, the traversal is instantiated as the self-call. When a function calls itself, it initiates a new traversal across the seven-node path: from its current interior state (1a), through its call interface (M₁), passing the argument outward (1b), into the runtime environment (S), received by the new call frame (2b), through the return interface (M₂), back to the calling function’s updated state (2a). The self-call is not merely “a function calling itself.” It is the computational mechanism by which the mandatory traversal is executed within a software substrate.

Derivation: The Law of Recursion requires that active exchange traverse a seven-node path. In the computational substrate, the mechanism available for this traversal is the function call. A recursive function call traverses from sender interior to receiver interior through the call interface, runtime, and return interface. The CS law requiring self-call is therefore the substrate-specific implementation of the general traversal requirement. A recursive function that does not call itself does not traverse—it is not recursive, just as a physical system that does not cross a membrane does not exchange.

Table 2. The three CS laws derived from the Law of Recursion.

CS Law	Law of Recursion Source	Why It’s Substrate-Specific
Base case	Falsifiability criterion: the ground state in which no traversal operates	Software requires explicit termination; physical systems reach ground state structurally
State change toward base case	Rewriting principle: each traversal alters the conditions of the next	Software cannot rewrite its own code, so state (arguments) must change instead
Self-call	Mandatory traversal: active exchange requires crossing the seven-node path	In software, the function call is the only mechanism for initiating traversal

5. What Is Present in Physical Recursion but Absent in Computational Recursion

The derivation in Section 4 reveals a critical structural difference between physical and computational recursion: the rewriting principle operates fully in physical systems but is constrained to state-change-only in computational systems. This difference has profound consequences.

5.1 The Frozen Membrane

In physical recursion, the membrane (M) is rewritten by each traversal. The Coulomb barrier after a fusion event is structurally different from the barrier before it. The synaptic membrane after a neurotransmitter has crossed is functionally different—receptor densities change, reuptake rates adjust, long-term potentiation alters the threshold. The rules of what crosses and how it crosses change with every pass.

In computational recursion, the membrane (the function signature and call interface) is frozen. The function accepts the same types of arguments, returns the same type of value, and enforces the same contract on every recursive call. The rules of what crosses do not change. This is why computational recursion is repetitive—the same logic applied to smaller inputs—while physical recursion is generative—novel architecture producing novel outputs.

5.2 Why Computational Recursion Cannot Generate Novelty

A recursive function computing the factorial of n produces n! = n × (n-1) × (n-2) × … × 1. The output is determined entirely by the input. No traversal produces a value that was not already implicit in the initial call. There is no excess (ε = 0 in terms of the Echo-Excess Principle). The recursion reduces without generating.

In physical recursion, each traversal produces excess. A fusion event in a stellar core produces photons and neutrinos that did not exist before the traversal. A chemical bond formation produces a molecular orbital that did not exist before the exchange. A synaptic signal produces a postsynaptic potential that alters the receiving neuron’s future behavior.

The output is not determined by the input—it is generated by the traversal through a self-altering architecture. This is the fundamental consequence of the rewriting principle: when the architecture changes with each pass, the output of each pass is genuinely novel.

5.3 AI and Machine Learning: A Partially Rewriting Substrate

Neural networks during training instantiate a partially rewriting substrate. The weights update after each forward-backward pass—this is membrane rewriting. The training loss landscape changes as weights adjust—this is substrate trace accumulation. Training is closer to physical recursion than standard function recursion because the architecture does change with each traversal.

However, during inference, a standard neural network reverts to a frozen architecture: weights are fixed, the forward pass applies an unchanging function to new inputs. This is structurally identical to computational recursion—same function, different input, no rewriting. The Gaconnet Membrane Law (Gaconnet, 2026c) predicts that systems operating in this frozen-inference mode will exhibit compressed option spaces and reduced generative capacity, which is precisely what is observed in standard LLM inference: the model selects from a fixed distribution rather than generating conditions that did not previously exist.

The structural prediction is testable: systems that permit architectural modification during inference (e.g., adaptive computation, in-context learning that modifies effective attention patterns, or weight-modifying inference protocols) should exhibit higher generative capacity than frozen-architecture inference on the same task. The degree of rewriting determines the degree of generation. This is a falsifiable prediction derived directly from the Law of Recursion.

6. Implications for the Definition of Recursion

The derivation presented in this paper establishes a containment relationship: the Law of Recursion contains computational recursion as a substrate-specific instance. Computational recursion does not contain the Law of Recursion. The three CS laws are necessary constraints for recursion operating within a software substrate. They are not the laws of recursion itself.

This has direct implications for how recursion should be defined across disciplines:

In computer science, recursion is a function calling itself (the mandatory traversal) with a base case (the ground state) and state change (constrained rewriting). This remains correct as a substrate-specific definition.

In physics, recursion is the mandatory seven-node traversal with full rewriting. Confirmed by independent nuclear physics experiments (Kolar et al., Physics Letters B, 2025).

In biology, recursion is the mechanism of exchange across membranes through substrates with full rewriting. Learning, growth, and adaptation are expressions of the rewriting principle.

In AI and machine learning, training is partially rewriting recursion (weights update); inference is constrained recursion (frozen architecture). The degree of rewriting determines the degree of generative capacity.

As a general definition, recursion is the structural process of exchange across a mandatory topological path in which each traversal alters the conditions encountered by subsequent traversals. The specific form this process takes depends on the substrate in which it operates. The CS definition, the physics definition, and the biology definition are all substrate-specific expressions of this single structural process.

7. Conclusion

The three laws of recursion in computer science—base case, state change, self-call—are not primitive axioms of computation. They are derivable as substrate-specific constraints from the Law of Recursion, a first principle governing all active exchange. The base case derives from the falsifiability criterion (ground state). The state change derives from the rewriting principle operating under the constraint of a non-self-modifying substrate. The self-call derives from the mandatory traversal requirement implemented through the function call mechanism.

The critical structural difference between computational and physical recursion is the rewriting principle. Physical systems fully rewrite their architecture with each traversal, producing genuinely novel conditions. Computational systems operate with frozen architecture (the function code does not change), limiting recursion to repetitive decomposition of the same problem. This difference explains why physical recursion generates novelty (new nuclear products, new molecular structures, new synaptic configurations) while computational recursion produces smaller instances of the same problem.

AI and machine learning systems occupy a transitional position: training permits partial rewriting (weight updates), while standard inference operates with frozen architecture. The Law of Recursion predicts that generative capacity scales with the degree of architectural rewriting permitted during exchange. This prediction is falsifiable and testable.

The relationship between computational recursion and the Law of Recursion is containment. The physical law contains the programming technique as a substrate-specific instance. The programming technique does not contain the physical law. Recursion is not a trick programmers invented. It is the architecture of exchange itself, operating across every substrate—nuclear, chemical, biological, neural, social, and computational—through the same mandatory topological path.

References

Gaconnet, D. L. (2026a). "The Law of Recursion: A First Principle of Systemic Exchange." LifePillar Institute for Recursive Sciences. DOI: 10.17605/OSF.IO/MVYZT.

Gaconnet, D. L. (2026b). "The Law of Obligated Systems: A Universal Six-Phase Collapse Pattern." LifePillar Institute for Recursive Sciences.

Gaconnet, D. L. (2026c). "Membrane Coherence and Generative Capacity: The Gaconnet Membrane Law." LifePillar Institute for Recursive Sciences. DOI: 10.13140/RG.2.2.31077.87526.

Gaconnet, D. L. (2026d). "The Functional Derivative of Clarity." LifePillar Institute for Recursive Sciences. DOI: 10.13140/RG.2.2.35522.85448.

Gaconnet, D. L. (2026e). "The Fifth Structure Function as Empirical Confirmation of Membrane Rewriting in Nuclear Recursive Exchange." LifePillar Institute for Recursive Sciences. Preprint.

Gaconnet, D. L. (2026f). "Recursion Beyond Computation: The Law of Recursion as a First Principle of Physical Exchange." LifePillar Institute for Recursive Sciences. Preprint.

Gaconnet, D. L. (2026g). "Recursive Sciences: A Formal Definition Grounded in the Law of Recursion." LifePillar Institute for Recursive Sciences. Preprint.

Kolar, T., et al. (2025). "Measurement of the helicity-dependent response in quasi-elastic proton knockout from ⁴⁰Ca." Physics Letters B, 871, 139977.