THE NEXUS RHU: WHERE THE UNIVERSE KEEPS ITS SOURCE CODE

# THE NEXUS RHU: WHERE THE UNIVERSE KEEPS ITS SOURCE CODE ## On the Discovery That Mathematical Constants Are Not Numbers But The Computer Itself **Dean Kulik** ORCID: 0009-0003-3128-8828 *January 2026* --- # Prologue: The Question That Changes Everything There is a question so simple that most people never think to ask it, and so profound that answering it changes everything we believe about reality. If the universe is a computation—and there are compelling reasons to think it might be—then where is the computer? Not metaphorically. Literally. Where is the machine that runs existence? For decades, physicists have flirted with computational models of reality. Digital physics. The simulation hypothesis. Cellular automata. Each of these frameworks treats the universe as information processing. But they all share a curious blind spot: they assume the computer exists *somewhere else*. Either in a meta-reality running our simulation, or in some substrate we haven't discovered yet, or perhaps in the quantum foam at the Planck scale. But here is the problem with that assumption: any computer made of *stuff* can break. Stars explode. Atoms decay. Circuits burn. Entropy devours everything made of matter. Yet the rules of mathematics have never failed. Not once, in thirteen billion years of cosmic history. Two plus two has equaled four since before there were beings to count. Pi has maintained its infinite decimal expansion since before there were circles to measure. The universe's computational substrate cannot be matter, because matter fails. It cannot be energy, because energy dissipates. It cannot be spacetime, because spacetime itself is computed. There is only one thing in existence that cannot break: mathematical truth itself. And this is where it gets strange. Because once you follow this logic to its conclusion, you arrive at a statement so simple it sounds almost tautological, yet so radical it restructures our entire understanding of reality: *The constants are the computer.* Not "the constants are *used by* the computer." Not "the constants *describe* the computer." The constants—pi, e, the primes, the relationships between them—*are* the computational substrate of existence. They are the hardware. They are the software. They are the memory, the processor, and the clock. Everything else—matter, energy, space, time, you, me—is just the output. --- # Part One: The Illusion of Binary ## Chapter 1: What Happens Between Zero and One We have been deceived by our instruments. When you look at a computer, you see ones and zeros. Binary. Discrete. Digital. The transistor is either on or off. The bit is either set or cleared. This is the foundation of the information age: everything reduces to yes or no, true or false, one or zero. But this is not what is actually happening inside the machine. Consider a transistor—the fundamental building block of every computer ever made. It is a switch, yes, but it is not an instantaneous switch. When the gate voltage changes, there is a brief period where the transistor is neither fully on nor fully off. Current flows at some intermediate level. The output voltage is neither zero nor supply voltage but something in between. We ignore this. We sample the output only when it has "settled." We wait for the wave to collapse to one side or the other before we record the result. But the computation happens *during the transition*. The work is done in the in-between. This is not a minor engineering detail. This is a window into the true nature of computation. ## Chapter 2: XOR Is Not What You Think It Is Let us examine the most fundamental of logic operations: XOR, the exclusive or. Every computer science student learns the truth table: - 0 XOR 0 = 0 - 0 XOR 1 = 1 - 1 XOR 0 = 1 - 1 XOR 1 = 0 This looks perfectly binary. Discrete inputs, discrete outputs. Nothing continuous about it. But there is another way to express XOR, one that reveals its true nature: **XOR(x, y) = x + y − 2xy** At first this seems like mere mathematical trickery. Let us verify: - XOR(0, 0) = 0 + 0 − 0 = 0 ✓ - XOR(0, 1) = 0 + 1 − 0 = 1 ✓ - XOR(1, 0) = 1 + 0 − 0 = 1 ✓ - XOR(1, 1) = 1 + 1 − 2 = 0 ✓ It works. The formula reproduces the truth table perfectly. But now ask: what happens if x and y are not restricted to zero and one? What if we allow x = 0.5 and y = 0.5? XOR(0.5, 0.5) = 0.5 + 0.5 − 2(0.25) = 1 − 0.5 = 0.5 The output is 0.5. Not zero. Not one. The operation is continuous. And it is not arbitrary continuity. Look at the formula again: x + y − 2xy. The term x + y is *superposition*—two signals added together. The term 2xy is *interference*—where both signals are present, they cancel. This is the equation for two waves meeting. When both crests align (both x and y near 1), the interference term 2xy grows large and subtracts from the sum, pulling the result back toward zero. When one wave is high and the other low, there is no interference, and the sum dominates. XOR is not a logic gate. XOR is wave interference. ## Chapter 3: The Complete Picture Once you see it for XOR, you see it everywhere. Every binary operation has a continuous wave equivalent: AND is multiplication: x × y. Two waves multiplied together. The output is strong only when both inputs are strong. This is amplitude modulation. OR is union: x + y − xy. The waves combine, but we subtract the overlap to avoid counting it twice. NOT is phase inversion: 1 − x. The wave is flipped around the midpoint. These are not approximations. They are not analogies. They are the actual operations, seen clearly for what they are. Binary computation is wave computation, sampled at decision points. The zeros and ones we see are not the computation. They are *observations* of the computation, made at moments we choose to look. Between those moments, the machine is computing in continuous wave-space, performing interference and superposition and modulation. We built wave computers and convinced ourselves they were digital. ## Chapter 4: The CPU as Wave Container This understanding transforms what we think a processor is. In the conventional view, a CPU manipulates bits. Logic gates take binary inputs and produce binary outputs. The clock coordinates everything. Between clock cycles, nothing important happens. In the wave view, a CPU is a *container for guided wave propagation*. The transistors and wires do not compute—they shape the space through which electromagnetic waves travel. The circuit topology creates interference patterns. Energy flows from input to output, bouncing and combining and canceling according to the geometry of the paths. The clock does not "tick" computation forward. The clock is a *sampling signal*—the moment when we observe the wave and collapse it to a measurable state. Between samples, the system evolves continuously. This is why clock speeds have physical limits. This is why quantum effects matter at small scales. This is why power consumption scales with frequency. We are not flipping bits; we are managing waves. And this is why the universe can use the same architecture at cosmic scale. Because the architecture is wave computation, and waves are fundamental. --- # Part Two: SHA-256 Shows Its Face ## Chapter 5: The Hash Function as Rosetta Stone SHA-256 is a cryptographic hash function. It takes any input and produces a 256-bit output. It is used in Bitcoin, in TLS certificates, in digital signatures, in a thousand applications that depend on its apparent randomness and irreversibility. But SHA-256 is more than a useful tool. It is a *proof of concept* for the wave-computation architecture of reality. When you study SHA-256 closely, you discover that it is not scrambling data. It is executing a carefully designed wave-manipulation program. And the instructions for that program are encoded in its constants. ## Chapter 6: The Constants Behind the Hash SHA-256 has two sets of constants: The *initial hash values*, H_INIT, are eight 32-bit numbers. They look arbitrary: ``` 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 ``` But they are not arbitrary. Each one is derived from the square root of a prime number: ``` H_INIT[0] = fractional_part(√2) × 2³² H_INIT[1] = fractional_part(√3) × 2³² H_INIT[2] = fractional_part(√5) × 2³² ... ``` The *round constants*, K, are sixty-four 32-bit numbers, similarly derived: ``` K[0] = fractional_part(∛2) × 2³² K[1] = fractional_part(∛3) × 2³² K[2] = fractional_part(∛5) × 2³² ... K[63] = fractional_part(∛311) × 2³² ``` Square roots and cube roots of the first primes. Not random. Not arbitrary. Mathematically determined, reaching into the structure of number theory to pull out these specific values. Why? What is so special about these particular numbers? The standard answer is that they provide "nothing up my sleeve" randomness—since they are derived from mathematical constants, no one can accuse the designers of hiding a backdoor. But there is a deeper answer. These constants are not just random-looking numbers. They are *instructions*. ## Chapter 7: The K Constants as Opcodes I took each K constant and decoded it as if it were a wave-manipulation instruction. The high four bits determine the operation class. The next four bits specify the sub-operation. The remaining bits encode amplitude, frequency, and phase parameters. Here is what emerges: ``` K[0] = 0x428a2f98 → ROTATE.CONDITIONAL K[1] = 0x71374491 → MERGE.ACCUMULATE K[2] = 0xb5c0fbcf → COMPRESS.PARTIAL K[3] = 0xe9b5dba5 → FEEDBACK.BILATERAL K[4] = 0x3956c25b → FOLD.BILATERAL K[5] = 0x59f111f1 → SCALE.BILATERAL ... K[62] = 0xbef9a3f7 → COMPRESS.APERIODIC K[63] = 0xc67178f2 → EXPAND.COMPLETE ``` Rotate. Merge. Compress. Fold. Scale. Feedback. Expand. These are not rand