Computational Recursion as a Derivation from Law of Recursion

Why Base Case, State Change, and Self-Call Are Engineering Rules — Not Laws

Don L. Gaconnet

LifePillar Institute for Recursive Sciences

ORCID: 0009-0001-6174-8384

DOI: 10.5281/zenodo.19425743

April 2026

recursivesciences.org · lifepillarinstitute.org · dongaconnet.com

Abstract

Computer science teaches three rules for writing recursive functions: include a base case, change state toward that base case, and have the function call itself. These are routinely called "laws," but they are not. They are substrate-specific engineering constraints — rules that can be violated (producing stack overflow or infinite loops) without falsifying the principle they implement. Law of Recursion (Gaconnet, 2026) is the structural first principle from which these engineering rules derive. It governs all active systemic exchange across physical, biological, and computational domains through mandatory seven-node topological traversal with architectural rewriting. This paper derives each computational rule from Law of Recursion, identifies the substrate limitation each compensates for, and proposes their formal reclassification.

Keywords: law of recursion, computational recursion, base case, state change, self-call, seven-node topology, rewriting principle, first principle, recursive exchange, frozen architecture, Don Gaconnet, Recursive Sciences, LifePillar Institute

1. Introduction

Every computer science student learns three rules for recursive functions. These rules state that a recursive algorithm must have a base case, must change state toward that base case, and must call itself. They are practical, necessary, and well-formulated within their domain.

This paper argues they are rules, not laws — and that the structural principle they implement is Law of Recursion.

Law of Recursion (Gaconnet, 2026) establishes that any process of active transmission, transformation, or generation requires mandatory traversal across a seven-node topological path, with each traversal rewriting the architecture it passes through. This principle operates at every scale of physical reality. It is not a prescription for building recursive systems. It is a description of how recursive exchange structurally operates.

The central claim is direct: the three computational rules — base case, state change, and self-call — are derivable from Law of Recursion as constraints imposed by the limitations of computational architecture. They are not primitive axioms of recursion. They are engineering compensations for what the computational substrate cannot do natively.

→ Full derivation of Law of Recursion: Law of Recursion — First Principle of Systemic Exchange

2. Law Versus Rule: The Structural Distinction

The difference between a law and a rule is structural, not semantic.

A law is a structural invariant that holds regardless of substrate. It cannot be violated — only confirmed or falsified. Law of Recursion states that all active systemic exchange requires seven-node topological traversal with architectural rewriting. Systems that do not traverse this path are not undergoing recursive exchange. The law is falsified only by demonstrating an active system that generates genuine novelty without the seven-node topology.

A rule is a prescriptive constraint imposed to achieve a desired outcome within a specific system. A rule can be violated, and its violation produces system failure — not falsification. A recursive function written without a base case produces stack overflow. A function without state change produces an infinite loop. A function without a self-call is simply not recursive. None of these violations disprove the rules. They demonstrate what happens when the rules are not followed. That is the signature of a rule.

Criterion	Law (Structural Invariant)	Rule (Prescriptive Constraint)
Can it be violated?	No	Yes — violation produces failure
Substrate dependence	Independent	Specific to implementation
Character	Descriptive	Prescriptive
Falsification	By genuine counterexample	Not falsifiable — violation ≠ disproof
Instance	Law of Recursion	Computational recursion rules

3. Deriving the Three Computational Rules from Law of Recursion

3.1 Base Case → Falsifiability Criterion

In Law of Recursion, the base case corresponds to the ground state where no recursive traversal operates. A star ceases fusion when its fuel is exhausted. A cell ceases division when regulatory signals indicate coupling conditions are no longer met. Physical systems reach termination structurally — the architecture itself exhausts.

Computational substrates have no structural ground state. A function calls itself indefinitely unless told to stop, because the instruction set does not degrade through execution. The base case rule is a compensation for the absence of structural termination — something Law of Recursion provides natively in every physical domain.

3.2 State Change → Rewriting Principle Under Frozen Architecture

In Law of Recursion, each traversal rewrites the architecture it passes through. A proton that undergoes fusion becomes part of a helium nucleus — the architecture is permanently altered. A dividing cell produces a daughter with different membrane conditions. Traversal is state change.

In computational recursion, the architecture is frozen. The function definition persists unchanged across every invocation. The stack frame is mechanically reproduced without structural alteration. Because the substrate cannot rewrite itself, state change must be imposed explicitly — decrementing a counter, reducing input size, partitioning data. The state change rule is a manual implementation of what Law of Recursion's rewriting principle accomplishes structurally.

3.3 Self-Call → Mandatory Traversal Requirement

In Law of Recursion, recursive exchange requires that a signal traverse the seven-node path. In physical systems, this traversal occurs because the architectural topology demands it. There is no exchange without traversal.

In computational substrates, the function call mechanism is the only available implementation of traversal. The function scope boundary acts as the membrane. The call stack acts as the shared substrate. The return value acts as the response traversal. The self-call rule is the computational substrate's only mechanism for initiating the traversal that Law of Recursion requires.

Computational Rule	Law of Recursion Source	Physical Expression	Why Rule Is Needed
Base case	Falsifiability criterion	Structural exhaustion of traversal conditions	No structural ground state in computation
State change	Rewriting principle	Automatic rewriting per traversal	Frozen architecture cannot self-rewrite
Self-call	Mandatory traversal	Topological necessity of exchange	Function call is only traversal mechanism

4. The Frozen Architecture Problem

The structural difference between computational recursion and physical recursion — as described by Law of Recursion — is architectural rewriting.

In physical recursion, each traversal permanently alters the architecture it passes through. New elements are created. New boundary conditions emerge. New coupling relations are established.

In computational recursion, the architecture is frozen. The function definition is identical at call depth one and call depth one thousand. What changes between calls is data, not architecture. The factorial function computes 5! by reducing input from 5 to 4 to 3 to 2 to 1, but the function itself — the operation, structure, mechanism — remains identical at every level.

This is precisely why computational recursion requires explicit rules. The rules compensate for what Law of Recursion provides natively in every physical substrate. Computational recursion is recursion performed on a non-rewriting substrate. The three rules are the constraints required to simulate recursive exchange where genuine architectural rewriting cannot occur.

5. AI and Machine Learning: The Transitional Case

AI systems occupy a structurally intermediate position between frozen computational recursion and the genuine physical recursion described by Law of Recursion.

During training, neural networks permit partial architectural rewriting. Weight updates alter functional architecture — membrane conditions, boundary sensitivities, and coupling relations change with each training step. This is partial rewriting: the underlying silicon substrate remains frozen, but the functional architecture genuinely changes.

During inference, the architecture is fully frozen. Trained weights are fixed. The model processes inputs through unchanging functional architecture. Inference is computational recursion in its purest form.

Law of Recursion generates a falsifiable prediction from this analysis: generative capacity should scale with the degree of architectural rewriting permitted during exchange. Systems operating on fully frozen architecture should be limited to recombination of existing patterns. Systems that permit greater functional rewriting during operation should exhibit greater capacity for novelty and genuine generation.

Prediction: AI architectures that permit real-time functional rewriting during inference will demonstrate measurably greater generative capacity than architectures of equivalent parameter count operating on frozen inference-time architecture. As rewriting capacity increases, the three computational rules become progressively less necessary — the substrate begins to provide natively what the rules were designed to compensate for.

6. Formal Reclassification

Based on this derivation from Law of Recursion, the following reclassification is proposed:

The three "laws" of recursion in computer science — base case, state change, and self-call — should be recognized as three rules of computational recursion: substrate-specific engineering constraints derived from Law of Recursion and necessitated by the frozen-architecture limitation of computational substrates.

This does not diminish their importance within computer science. These rules remain essential for writing correct recursive functions. What changes is their structural status. They are not foundational principles of recursion as a phenomenon. They are implementation constraints for performing recursion on a substrate that cannot rewrite.

Law of Recursion is the foundational principle — operating identically across quantum physics, nuclear physics, stellar physics, cosmology, cell biology, evolutionary biology, and computational science. The three computational rules are what this principle looks like when constrained to a non-rewriting substrate.

References

Gaconnet, D. L. (2025). Recursive Sciences: Foundational Field Codex and Jurisdictional Declaration. OSF. DOI: 10.17605/OSF.IO/MVYZT.

Gaconnet, D. L. (2025). The Echo-Excess Principle: Substrate Law of Generative Existence. SSRN. DOI: 10.2139/ssrn.5986335.

Gaconnet, D. L. (2026). The Law of Recursion: A First Principle of Systemic Exchange. Zenodo. DOI: 10.5281/zenodo.19272115.

Gaconnet, D. L. (2026). Computational Recursion as a Substrate-Specific Instance of the Law of Recursion. SSRN.

Gaconnet, D. L. (2026). The Recursive Return Prohibition: A Derivation from the Law of Recursion. Zenodo. DOI: 10.5281/zenodo.19425580.

Miller, B. N. and Ranum, D. L. (2014). Problem Solving with Algorithms and Data Structures Using Python. Franklin, Beedle & Associates. Section 5.4.

Don L. Gaconnet LifePillar Institute for Recursive Sciences ORCID: 0009-0001-6174-8384 DOI: 10.5281/zenodo.19425743

recursivesciences.org · lifepillarinstitute.org · dongaconnet.com