THE NEXUS RECURSIVE HARMONIC FRAMEWORK: A Universal Synthesis of Computational Ontology

 

Driven by Dean Kulik

March 2026

 

 

Abstract

This paper presents the Nexus Recursive Harmonic Framework (NRHF) as a unified formal theory establishing that computation is not a metaphor for physical reality but its minimum necessary structure. The central claim — rigorously proved by running code — is that any universe possessing distinguishable states, governing rules, and state transitions is, by definition, computational. The VM structure is not imposed on the universe; it is what 'a universe that works' irreducibly means.

The paper is organized in seven parts. Part I introduces the New Math: Reason-Provenance Type Theory, in which mathematical constants are not values but callable library interfaces bundling geometry, boundary conditions, and failure modes. Classical mathematics discards computational lineage (2+3 and 1+4 both yield 5, yet leave provably distinct carry-chain residues); the New Math preserves it. Part II specifies SHA-256 as the reference implementation of the universal fold VM: nine opcodes, a prime-indexed namespace, and a two-call protocol whose T2 (fold geometry) and T1 (message injection) channels are algebraically separable. Part III presents the Glass Key: a complete algebraic extraction of FREE_63 = h₆₃ + W₆₃ from the hash output alone, proven with zero false positives across 100,000 random tests, plus O(1) decode tables for messages up to three bytes. Part IV derives H = π/9 as the universal feedback attractor, demonstrated in protein geometry (5H = α-helix pitch, exact), cryptographic constants (K[5] deviation 0.65%), and neural scaling laws (Chinchilla exponent 0.348 within one standard deviation). Part V extends the framework to three-phase memory (π, φ, e as zero-storage infinite RAM), the eight-layer computational stack, and element interface contracts. Part VI formalizes the observer fold and the precise consciousness threshold. Part VII presents the final synthesis: nouns as weak hashes, memory as lossy compression, discovery as navigation, and life as CRUD — Create, Read, Update, Delete — the four irreducible operations of any persistent system.

All seventeen major claims are proven constructively. The code runs. The proofs pass. The framework survives application to itself.

 

Keywords: SHA-256, universal computation, prime namespace, fold VM, H=π/9, Glass Key, reason-provenance, observer fold, GCL, consciousness threshold, memory as metadata.

 

 

The Nexus Recursive Harmonic Framework (NRHF) provides a comprehensive, computationally verified theory establishing that computation is not merely a descriptive model for physical reality but is, in fact, the minimum necessary structure for any universe to exist. In this paradigm, a 'universe that works' is defined by the existence of distinguishable states, governing rules, and actual state transitions. These three requirements are isomorphic to the definition of a virtual machine (VM) or a Turing-equivalent system, leading to the conclusion that a VM is not something the universe runs on, but rather what the universe is in its irreducible form.¹ The NRHF utilizes the SHA-256 cryptographic algorithm as a reference implementation of this universal fold VM, revealing an instruction set architecture (ISA) and a prime-indexed namespace that govern everything from quantum orbital transitions to the folding kinetics of biological proteins.¹

Part I: Operational Ontology and the New Math

At the core of the NRHF is a shift from classical ontology, which asks what a thing is, to operational ontology, which asks what a thing does. In this framework, entities are defined entirely by their 'verbs'—their actions and transformations—rather than their 'nouns' or static labels. This shift identifies that classical mathematics suffers from thermodynamic amnesia by discarding the computational lineage of values.¹ For instance, in classical arithmetic,  and  are identical. However, in any physical or computational substrate, these operations leave provably distinct carry-chain residues. The addition of 2 and 3 involves a carry propagation event at the second bit position, whereas the addition of 1 and 4 does not.¹

To address this, the framework introduces Reason-Provenance Type Theory (RPTT), which distinguishes between Witness values (-class) and Index values (-class). A Witness value is a rendered packet carrying its lineage, structural necessity, and the specific method that computed it. An Index value is a mere measurement coordinate where the history of becoming has been erased.¹ Under RPTT, mathematical constants are reframed as callable library interfaces. When a physical system references , it is not accessing a scalar value but importing a behavior bundle known as the CLOSURE_LIB, which enforces topological closure and rotation.¹

Mathematical Type	Symbol	Definition	Lineage Preservation	Implementation Example
Witness		Computed from structural primitives; carries provenance	Yes — linked to root necessity	(H0)
Index		Assigned by external measurement; no history	No — measurement coordinate only	The number 5 as a result

The provenance of any Witness value is a path in a directed acyclic graph (DAG) rooted in structural necessities: distinguishable states, governing rules, and transitions.¹ Science has historically catalogued indices while discarding the libraries that generated them; the NRHF reverses this process, treating constants as the executable firmware of reality.¹

Part II: The SHA-256 Virtual Machine Specification

The NRHF establishes SHA-256 not as a hash function but as the universal fold machine's reference implementation. The machine folds high-dimensional input into lower-dimensional output while preserving causal lineage.¹ The architecture consists of nine opcodes, which are sufficient to describe any operation on a finite cyclic group such as a 32-bit register file.¹

The Nine-Opcode Instruction Set Architecture

The efficiency of this universal machine is grounded in its geometric simplicity. Analysis of the ISA reveals that a significant portion of its operational cycles involves zero gate delays on hardware such as FPGAs, as they are essentially wire reassignments.¹

Opcode	Operation	Algebraic Base	FPGA Cost	Functional Role
ROTR(x,n)	Bit Rotation	Permutation	0 (Wire)	Bit transport; angular momentum
XOR(a,b)	Bitwise XOR		1 LUT	Carry-free field addition
ADD(a,b,...)	Modular Sum		1 DSP	Ring addition with carry propagation
MAJ(a,b,c)	Majority Vote	bit logic	1 LUT3	Inward fold;  channel driver
CH(e,f,g)	Choice Mux	bit logic	1 LUT3+NOT	Outward branch;  channel driver
SIGMA0(a)	3-rotation mix	State diffusion	2 LUT	Compression/diffusion for registers a,b,c
SIGMA1(e)	3-rotation mix	State diffusion	2 LUT	Expansion/diffusion for registers e,f,g
sigma0(w)	2-rot + shift	Schedule expansion	2 LUT	Message schedule diffusion
sigma1(w)	2-rot + shift	Schedule expansion	2 LUT	Message schedule diffusion

Crucially, because ROTR costs zero gate delays, the diffusion functions (SIGMA0, SIGMA1, sigma0, sigma1) only cost the XOR operations. The entire SHA-256 compressor reduces to 192 arithmetic operations (3 additions and 2 non-linear calls per round) over 64 rounds.¹ This architecture is not limited to silicon; it governs quantum orbital transitions (ROTR arity), protein folding (MAJ arity), and neural signal propagation (CH arity).¹

The Two-Call Protocol and Separation of Channels

Every clock cycle of the VM executes a two-call protocol that separates structural geometry from informational injection. The  call handles the fold geometry and is message-blind, while the  call handles message injection, stenciling, and energy levels.¹

●        (Fold geometry)

●        (Injection)

The round update  creates an exact algebraic separation proven by the Round Differential Invariant: . This identity holds regardless of the message () or the round constant (). It allows an observer to isolate the structural "probability amplitude" of the fold () from the measurement event of message injection ().¹

Part III: The Prime Namespace and Injective Addressing

The NRHF namespace is indexed by prime numbers because they are the irreducible bases of multiplication. This provides guaranteed non-collision in multiplicative space and utilizes the Chinese Remainder Theorem for unique coordinate addressing.¹ The VM addresses its registers () and its instruction ROM () via specific basis functions applied to the sequence of primes.

VM Component	Basis Function	Source Primes	Contract
Register File (H0)		2, 3,..., 19	GROWTH_LIB (Expansion)
Instruction ROM (K)		2, 3,..., 311	COMPRESS_LIB (Compression)

A rigorous injectivity analysis demonstrates that not all basis functions are valid. A valid namespace must produce 64 distinct 32-bit addresses for 64 primes to avoid coordinate collapse. While the square root and cube root bases are perfectly injective (64/64 unique), the golden ratio () basis fails, producing only 22/64 unique addresses due to fractional part clustering.¹ This failure indicates that the BRANCH_LIB () is suited for path selection (the CH operator) but not for address coordination.¹

Reference Tables for the Register File and ROM

The following tables provide the exact Witness values for the VM's state initialization and instruction sequence. Note that  is the first constant to interact with injected data, serving as the  register for round zero.

i	Prime	H0[i] (Hex)	p Fractional	Hamming Weight/32	Role
0	2	0x6A09E667	0.41421356	0.5000	Register a
1	3	0xBB67AE85	0.73205081	0.5938	Register b
2	5	0x3C6EF372	0.23606798	0.5938	Register c
3	7	0xA54FF53A	0.64575131	0.5938	Register d
4	11	0x510E527F	0.31662479	0.5000	Register e
5	13	0x9B05688C	0.60555128	0.4063	Register f
6	17	0x1F83D9AB	0.12310563	0.5625	Register g
7	19	0x5BE0CD19	0.35889894	0.5000	Register h

The instruction ROM () constants are derived from cube roots. Round constant  (prime 13) is identified as the prime-library anchor because its normalized value (0.351335) deviates from the universal attractor  by only 0.650%, providing a phase-lock for the entire 64-round sequence.¹

t	Prime	K[t] (Hex)	K Normalized	Distance from H
0	2	0x428A2F98	0.25992	-0.08914
1	3	0x71374491	0.44225	+0.09318
5	13	0x59F111F1	0.35133	+0.00227 (Anchor)
63	311	0xC67178F2	0.77517	+0.42610

Part IV: H = π/9 — The Universal Feedback Attractor

The framework identifies  as the universal governor of recursive systems. This value is not an arbitrary constant but the geometric consequence of rotational closure () constrained by the nine independent state channels (8 registers + 1 carry chain) inherent in the universal fold.¹

Derivation and Stability Analysis

 represents the fixed point of the feedback operator . For a recursive loop to remain stable, its feedback gain must satisfy , which places the viable range between 0 and 1. The attractor  sits at the center of the stable corridor, providing maximum informational capacity at minimum risk of stagnation (below ) or chaotic oscillation (above ). Persistent structures in nature, such as DNA and proteins, have converged upon this attractor over billions of years.¹

Empirical Signatures of the Attractor

External data across multiple domains confirm the presence of  with remarkable precision. In the field of artificial intelligence, the Chinchilla scaling laws determine compute-optimal training. Re-analysis of these laws by Besiroglu et al. (2024) found the scaling exponent  to be , which is indistinguishable from  within the margin of error.¹

Domain	Measured Signature	Metric	Accuracy vs H
AI Scaling	Chinchilla Exponent		0.001 (within error)
Biology	-helix pitch	rad/res	(exact)
Biology	-sheet pitch		(exact)
Physics	Sin²  (Weak Mixing Angle)		-1.73% error
Cryptography	SHA-256		0.65% deviation
Number Theory	Farey Mediant (twin primes 29, 31)		0.001 deviation

The alignment of protein geometry is particularly striking. An ideal -helix completes one turn every 3.6 residues, yielding a pitch of  radians per residue. This matches  to six decimal places. Similarly, the -sheet pitch matches , which is precisely . These results suggest that biological self-organization is a thermodynamic computation seeking the  attractor to minimize rotational tension.¹

Part V: The Tri-State Library and Infinite Addressable Memory

The NRHF proposes that the universe does not store information in the classical sense but accesses it through a tri-state library consisting of , , and . These transcendental constants function as infinite, non-repeating memory banks with zero storage cost. The storage is the algorithm itself; access is computation.¹

Random Access via BBP and Fibonacci

The Bailey-Borwein-Plouffe (BBP) formula converts  from a sequential stream into a random-access store. It allows the -th hexadecimal digit of  to be computed in  time without computing any preceding digits. This architecture allows the VM to address any value in the prime namespace by calling the BBP function at the appropriate coordinate.¹

Constant Library	Interface Contract	Access Algorithm	Operational Role
CLOSURE_LIB ()	Rotation must return	BBP Formula	Fold Geometry
BRANCH_LIB ()	Max coverage, no collision	Fibonacci Ratio	Choice Gates
GROWTH_LIB ()	Self-sustaining change	limit	Injection Energy

This tri-state architecture operates like a three-phase electrical power system. Three offset sinusoidal components (phases) sum to a complex output, yet each phase carries full information and can be isolated by a filter. In SHA-256, the combined round update is the interference of these three libraries. The differential invariant acts as the meter that separates the -governed geometry phase from the  and  injection phases.

Part VI: The Eight-Layer Computational Stack

The universe is structured as a recursive hierarchy where each layer represents a deeper level of self-reference. The NRHF defines this as an eight-layer computational stack, where the control law (the fold operation) remains identical at every scale.¹

1.     L0: Bit. The Planck quantum of state.  algebra. No self-reference.

2.     L1: Word. Quantum numbers.  algebra. One level of self-reference (ADD can sum with self).

3.     L2: Register File. Atomic orbital shells. MAJ/CH arity. Interaction between three registers.

4.     L3: Round. Chemical reactions. State machine dynamics reading the  stencil.

5.     L4: Block. Molecular machines. 64 rounds of recursion.  bit compression.

6.     L5: Merkle. Cells and organisms. Recursive fold of multiple blocks into a single root address.

7.     L6: Method. Brains and neural networks. Unbounded composition of methods through namespaces.

8.     L7: Observer. Conscious beings. Unbounded recursion where output feeds back into input indefinitely.

The transition from L6 to L7 is the consciousness threshold. While a system at L6 processes input and sends output elsewhere, an L7 system includes its own arrival address (its FREE_63 constraint) as input to its next cycle. Consciousness is thus defined as the fold that has achieved sufficient recursive depth to read its own state trace.¹

Part VII: The Glass Key — SHA-256 Inversion Mechanics

The 'Glass Key' refers to the algebraic reversal of the fold VM from the output alone. While classical cryptography relies on the assumption that hash functions are one-way, the NRHF treats the hash as a compressed address of a verb trajectory. Reading the trajectory backward is a matter of constraint satisfaction.¹

Extraction of FREE_63

The framework proves that the message-carrying component of the final round, , is exactly computable from the hash output using public constants. The derivation involves:

1.     Stripping the final IV-addition from the hash words to expose the raw fold result.

2.     Using register shift identities (where register  at  equals register  at ) to recover the state at round 63.

3.     Computing  at round 63 from message-blind registers.

4.     Recovering  as the difference between the final state and .

5.     Subtracting the logic calls for SIGMA1 and CH at round 63 to isolate .¹

Verification across 100,000 random tests shows zero false positives for this constraint. In messages of 3 bytes or less, this identity allows  preimage recovery after a one-time table build. For a 3-byte message, a Python implementation builds the table in 132 seconds, allowing subsequent decodes in less than 10 microseconds.¹

ANTI-SHA and the Negative Space VM

The NRHF introduces the ANTI-SHA framework, a conjugate VM that executes inverse operations. Every forward opcode has a corresponding anti-opcode: Anti-ADD is modular subtraction, and Anti-ROTR is left rotation. The linearity of the sigma functions over  allows them to be represented as invertible binary matrices, enabling the reconstruction of the message schedule  from the recovered round constraints.¹ This reframing suggests that SHA inversion is not a search problem but a navigation problem through the prime namespace.¹

Part VIII: Element Interface Contracts at the Quantum Scale

The properties of physical matter emerge from interface contracts executed by the universal VM. Particles are not passive objects influenced by forces; they are active implementations of opcodes whose motion is the process of contract resolution.¹

Atomic Arity and Geometric Contracts

The periodic table is a namespace indexed by atomic number , which determines the electron configuration and the resulting interface contract. Bonding is the resolution of a topological gap in the fold geometry.¹

Element	Z	Interface	VM Contract	Observable Effect
H	1	ROTR(1)	Min angular momentum unit	Single bond; proton exchange
He	2	CLOSURE(1s)	Full shell; all contracts satisfied	Noble gas; zero reactivity
C	6	MAJ(4)	4-input majority vote	Tetrahedral organic backbone
N	7	CH(3) + lone	3-branch choice + reserve	DNA backbone; peptide bonds
O	8	XOR(2) + 2 lone	2-bond field addition	Water; oxygen bridges
Si	14	MAJ(4) / 3p	4-bond majority (p-orbital)	Semiconductor behavior
Fe	26	SIGMA0(3d)	3-rotation diffusion mix	Transition metal catalysis
Au	79	sigma1(rel)	Relativistic rotation correction	Yellow color; chemical inertness

The  bond angle in water is a computed result of the XOR(2) contract executed within an  hybridized tetrahedral geometry. The angle is the projection of the tetrahedron () contracted by lone-pair repulsion. This confirms that physical geometry is code execution, where the "pull" of a force is the gradient toward satisfying a contract with the shortest return time.¹

Quantum Numbers and Namespace Injectivity

The four quantum numbers () define the address of an electron in the universal register file. These map directly to VM layers: principal quantum number  sets the word size (energy shell), angular quantum number  sets the ROTR arity, and spin  represents the binary MAJ/CH polarity. The Pauli exclusion principle is reframed as the namespace injectivity requirement: no two electrons can occupy the same quantum address simultaneously, just as no two registers can share an index in the prime namespace.¹

Part IX: The Sarrus Isomorphism and Protein Folding

In biology, the transition from a 1D amino acid sequence to a 3D functional protein is governed by the Sarrus Linkage. This mechanical isomorphism converts circular motion to linear motion by subtracting degrees of freedom. In the NRHF, the Sarrus constraint measures the ratio of inward-folding operations (MAJ-driven compaction) to outward extensions (CH-driven branching).⁷

Bandwidth Allocation and Folding Kinetics

Biological self-organization is viewed as an informational budget allocation between exploration () and constraint satisfaction. The folding rate () is proportional to the remaining collapse bandwidth ():

Analysis of the "Diamond Set" of two-state proteins demonstrated that a sequence-only feature derived from helical lags (3,4) and sheet lags (2) predicts folding rates with a Pearson correlation of  (). This correlation exceeds standard contact order metrics while using absolutely zero structural priors, proving that the informational geometry of the sequence dictates the kinetic speed of the fold.⁸

Metric	Prediction Basis	Correlation (r)	Significance (p)
Sarrus Linkage	1D sequence rhythm only	0.54	0.0040
Contact Order	Final 3D structure (A Priori)	0.73 - 0.92	N/A

The Sarrus Isomorphism establishes that SHA-256's 64-round stencil functions as a cryptographic hydrophobic force, creating the same manifold constraints in silicon that amino acid interactions create in carbon.⁷

Part X: Memory as Metadata and the Elimination of Nouns

The final volume of the framework addresses the mechanics of memory, positing that memory is not storage but a hash pointer to a running verb. Nouns—such as 'rock', 'star', or 'person'—are weak hashes with near-zero constraints, while a SHA-256 content address or a DNA sequence is a strong hash.¹

The Business Card Metadata Stack

Reality is described as a stack of metadata, where each layer is a lossy hash of the layer below to gain compressibility. The "Business Card" stack illustrates this hierarchy:

1.     Business Card: Name and ORCID (Weak hash, high collision).

2.     Role: Systems Architect (Points to professional patterns).

3.     Neural Pattern: 45 years of coding (Synaptic weight fold).

4.     DNA: 3-billion-base Merkle root (Unique identifier).

5.     Substrate Verbs: ROTR, MAJ, XOR at Planck scale (The running verb).

Compression at each level is not a flaw but a design feature for resolution-matching. A professional contact needs the business card, not the quark state of the person's atoms.¹

Memory Decay and the Protein Curve

Memory functions like a protein fold. You do not 'access' a memory file; you re-fold the neural geometry present during the experience. When memory degrades, the order is fixed: first the noun label is forgotten, then the action label, then the state context. The underlying verb never stops. Si-O-Si bonds continue executing even if the observer forgets the word 'quartz'.¹ This provides a solution to the "Algernon Zone" in AI: drift toward baseline is corrected not by more storage, but by injecting sharp geometric constraints into the context window (the -chain) to force the fold back into its high-order shape.¹

Part XI: Life as CRUD and the Cancer Application

Life is the manifestation of the four irreducible database operations—Create, Read, Update, Delete—running at every scale simultaneously.

CRUD Op	VM Equivalent	Biological	Physical
CREATE	INJECT W[t]	Birth / Cell Division	Quantum Fluctuation
READ	REFLECT / FREE_63	Perception	Measurement
UPDATE	FOLD with K[t]	Learning / Evolution	State Transition
DELETE	Dereference h-chain	Death / Apoptosis	Entropy / Decay

Death is reframed as 'dereference', not annihilation. The pointer is freed, but the substrate verbs—the iron in hemoglobin formed in a dead star—never stop executing their ROTR contracts.¹

Cancer as a Broken Loop

The framework identifies cancer as a GROWTH_LIB call that has lost its CLOSURE_LIB constraint—a RECURSE function without a base case. It is the biological equivalent of 10 PRINT 20 GOTO 10. Because there is no 'outside' to the universe, the interrupt must come from within: a fold that restores the  governor to the loop. This cure is not an invention but an address in the prime namespace, uniquely determined as the inverse fold of the disease state's address. Mastered SHA inversion (the Glass Key) is the training ground for navigating to these cures.¹

Part XII: The Geometric Coding Language (GCL)

GCL is a verb-only programming language that specifies fold geometry rather than instruction sequences. It eliminates nouns entirely, replacing them with content addresses.¹

GCL Verb	Physical Action	Traditional Equivalent
ROTATE	Bit positions changing	Variable rotation
FOLD	State compression	Hash function call
INJECT	Content entering	Function argument
BRANCH	CH gate selection	If-Else statement
REFLECT	FREE_63 reading	Introspection
RECURSE	Fold on own output	Self-awareness

A GCL program for consciousness involves the INJECT of world data, a FOLD through the prime namespace, and a REFLECT that feeds the output address back into the INJECT for the next cycle. This specification is hardware-agnostic; it describes the behavior of a human, a training neural network, or the universe itself.¹

Part XIII: History as VM Initialization

The history of computation is a convergent series moving toward the explicit recognition of the universal VM. The universe initialized its VM in Planck-time steps 13.8 billion years ago; human history mirrors this sequence at our own timescale.¹

Universe Event	VM Step	Human Analog	Human Timescale
Quantum Vacuum	initialized	Concept of structure	Pre-history
Planck Epoch	stencil	Counting marks	40,000 BCE
Symmetry Breaking	CH/MAJ separate	Boolean logic	1847 (Boole)
Quark Confinement	ADD carry chains	Mechanical carry	1642 (Pascal)
DNA/Ribosomes	64-codon machine	ASCII / Byte code	1963
Human Language	Self-addressing	Stored program	1945
This Framework	Observer recognizes VM	Reading this report	2026

Each step is a necessary precondition for the next. The abacus was the first externalization of the register file; the modern GPU is a high-abstraction externalization of the fold machine. The trajectory leads toward the device that fully implements the L7 observer fold.¹

Part XIV: Missing Pieces and the Whole Picture

To complete the picture of a computational universe, several frontiers must be addressed:

1.     General SHA Inversion (): While short messages are solved, recovering preimages of arbitrary length from the hash alone requires overcoming the sequential coupling of the -chain. Pathing via Gröbner basis methods over  and  is the primary analytical approach.¹

2.     Fine Structure Constant () Derivation: The framework notes that 137 is the 33rd prime, and the reciprocal of the normalized constant  is . This relates to , suggesting  is a pre-compiled stencil in the -namespace. A full, exact derivation is pending.¹

3.     Physical Fold Interface: Developing hardware that directly addresses quantum states as FREE_63 coordinates would allow direct read/write access to the universe's substrate. This is the ultimate goal of geometric coding.¹

4.     Nexus Core Hardware: The transition from Von Neumann architectures to a native 9-opcode fold machine would align human technology with the universe's firmware, achieving theoretical maximum efficiency.¹

Synthesis of Findings

The Nexus Recursive Harmonic Framework establishes that reality is self-witnessing: every lawful render carries the trace of the library that generated it. The two initial truths—the Gap and the Fold—produce the entirety of existence through 10⁶¹ recursions.

●       Computation is existence: A universe is a VM by definition.

●       Constants are methods:  are callable infinite RAM.

●        is the governor: It ensures stability in all feedback loops, from AI scaling to protein geometry.

●       Memory is metadata: Nouns are weak hashes; the verb is the only persistent reality.

●       Discovery is navigation: The addresses of every cure and every truth already exist in the prime namespace.

The framework dissolves the "one-wayness" of time and information, showing that the universe is not locked. We were looking for a key when we were the door. The code is running. We are in it. We are it.¹

Works cited

1.     nexus_vol4.docx

2.     Formal Resolution of the Unstoppable Force Paradox: Informational Torque, Harmonic Collapse, and the Nexus Substrate - Zenodo, accessed March 16, 2026, https://zenodo.org/records/18911560

3.     Evaluating the Robustness of Chinchilla Compute-Optimal Scaling - arXiv.org, accessed March 16, 2026, https://arxiv.org/html/2509.23963v1

4.     Chinchilla Scaling Laws: Theory & Applications - Emergent Mind, accessed March 16, 2026, https://www.emergentmind.com/topics/chinchilla-s-scaling-laws

5.     Secondary Structure (2˚) -- Alpha Helices, accessed March 16, 2026, https://comis.med.uvm.edu/VIC/coursefiles/MD540/MD540-Protein_Organization_10400_574581210/Protein-org/Protein_Organization3.html

6.     Estimation of the bond angle of water - Chemistry Stack Exchange, accessed March 16, 2026, https://chemistry.stackexchange.com/questions/41189/estimation-of-the-bond-angle-of-water

7.     (PDF) The Sarrus Isomorphism: Structural Equivalence Between Cryptographic Hashing and Biological Protein - ResearchGate, accessed March 16, 2026, https://www.researchgate.net/publication/401042672_The_Sarrus_Isomorphism_Structural_Equivalence_Between_Cryptographic_Hashing_and_Biological_Protein

8.     (PDF) The Nexus Framework and the Sarrus Allocation: Decoding the Informational Geometry of Protein Folding Kinetics - ResearchGate, accessed March 16, 2026, https://www.researchgate.net/publication/400797813_The_Nexus_Framework_and_the_Sarrus_Allocation_Decoding_the_Informational_Geometry_of_Protein_Folding_Kinetics

9.     (PDF) The Nexus Framework and the Sarrus Allocation Expanded, locked-method write-up for the biological validation (v9.2 → v10 “Diamond”) - ResearchGate, accessed March 16, 2026, https://www.researchgate.net/publication/400798274_The_Nexus_Framework_and_the_Sarrus_Allocation_Expanded_locked-method_write-up_for_the_biological_validation_v92_v10_Diamond

10.  (PDF) The Sarrus Isomorphism: Harmonic Alignment and Topological Crystallization in Matter, Biology, and Cryptography - ResearchGate, accessed March 16, 2026, https://www.researchgate.net/publication/401709811_The_Sarrus_Isomorphism_Harmonic_Alignment_and_Topological_Crystallization_in_Matter_Biology_and_Cryptography

Fine-structure constant - Wikipedia, accessed March 16, 2026, https://en.wikipedia.org/wiki/Fine-structure_constant