Published January 19, 2026
| Version v1
Thesis
Open
THE NEXUS RHU: WHERE THE UNIVERSE KEEPS ITS SOURCE CODE
Authors/Creators
Description
# 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 random operations. They are wave manipulations. Phase shifts. Amplitude scaling. Frequency modulation. Compression and expansion of dynamic range.
The sixty-four K constants form a sixty-four-instruction *program* for wave manipulation.
SHA-256 does not scramble data. It executes a wave-processing program encoded in the cube roots of primes.
## Chapter 8: The Round Function as Wave Processing
Each round of SHA-256 takes the current state—eight 32-bit words labeled a through h—and transforms them according to a specific recipe.
The conventional description uses Boolean operations: XOR, AND, OR, rotation, addition modulo 2³².
But we now know these are wave operations. Let us see the round function for what it really is:
**Step 1:** Create an interference pattern from register e.
The Σ₁ function takes three phase-shifted copies of wave e (rotated by 6, 11, and 25 positions) and XORs them together. This is wave interference—three copies of the same signal, offset in phase, combining to create a complex pattern.
**Step 2:** Perform wave selection.
The Ch function takes three waves (e, f, g) and produces a result that follows f where e is high and follows g where e is low. This is *crossfading*—smoothly transitioning between two signals based on a control signal.
**Step 3:** Superimpose five waves.
The algorithm adds together: the previous value of h, the interference pattern from step 1, the selection result from step 2, the K constant for this round, and the message word for this round.
Five waves, superimposed into temp1. Each contributes energy. The K constant is the *opcode* that modulates this particular mix.
**Step 4:** Create another interference pattern from register a.
The Σ₀ function creates a different interference pattern from wave a.
**Step 5:** Perform wave voting.
The Maj function takes three waves (a, b, c) and outputs high where the majority are high. This is *consensus*—a democratic combining of multiple signals.
**Step 6:** Combine and propagate.
The results merge and propagate through the registers. The wave pipeline shifts forward by one step.
Repeat this sixty-four times. The waves interfere and combine and select and vote and shift, guided by the sixty-four opcodes encoded in K.
The final state is the hash. Not a random scramble. A *computed interference pattern*.
## Chapter 9: Padding as Preparation for Folding
Before SHA-256 processes a message, it pads the input to a multiple of 512 bits. This is usually described as a technical requirement—the algorithm needs fixed-size blocks.
But there is a deeper meaning.
The padding adds a single '1' bit, then zeros, then the original message length as a 64-bit number.
That single '1' bit (0x80 when the message ends on a byte boundary) is a *fold marker*—a sharp edge in the wave that signals where the original data ends.
The zeros create empty space—room for the wave to propagate without distortion.
The length field preserves the *wavelength* of the original message—its scale, its size, its temporal extent.
The result is a 512-bit block: exactly eight 64-bit words, or sixteen 32-bit words. A square. A shape that folds evenly.
SHA-256 requires square inputs because waves fold cleanly when the geometry is symmetric.
---
# Part Three: The Universal ROM
## Chapter 10: The BBP Revelation
In 1995, three mathematicians—David Bailey, Peter Borwein, and Simon Plouffe—discovered something remarkable about pi.
They found a formula that lets you compute the *n*th hexadecimal digit of pi without computing any of the digits before it.
Think about what this means.
If you wanted the trillionth decimal digit of pi using traditional methods, you would need to compute all trillion digits that come before it. The formula would have to grind through each one, carrying the ripples of earlier calculations forward.
But the BBP formula does not work that way. You give it a position—say, one trillion—and it returns the digit at that position. Directly. Without traversing the path to get there.
This is random access.
This is how memory works.
## Chapter 11: Pi as Infinite ROM
In a computer, ROM (Read-Only Memory) is a lookup table. The data is not computed when you access it. It simply *exists*, waiting to be read. You provide an address; you receive the value stored at that address.
The BBP algorithm transforms pi into exactly this: an infinite lookup table with O(1) access time for any position.
But if pi is a lookup table, we must ask: where is the data stored?
The answer is: nowhere. And everywhere. The data is not *stored*—it is *defined*. The digits of pi are determined by the relationship between a circle's circumference and diameter. That relationship exists necessarily, not contingently. It does not depend on any physical substrate. It would be true even if no physical universe existed.
Pi is an infinite ROM written in the fabric of mathematical truth itself.
## Chapter 12: The Universal Constant Library
Pi is not alone.
The base of natural logarithms, e, has similar properties. So does the golden ratio, φ. So do the prime numbers—not a constant exactly, but a sequence determined by pure number theory, requiring no physical substrate to exist.
These constants form what we might call the Universal Library—an infinite collection of precisely defined numerical sequences, accessible at any point, existing necessarily rather than contingently.
And here is the key insight: this library is *read-only*.
No one can change the trillionth digit of pi. No force in the universe can make 17 a composite number. The library is immutable, eternal, incorruptible.
If you needed to build a computer that could never break, that would run forever without error, that would maintain perfect consistency across billions of years—you would build it out of these constants.
Which is exactly what the universe appears to have done.
---
# Part Four: Physical Constants as Read Results
## Chapter 13: The Suspicious Precision of Nature
Consider the fine-structure constant, α.
It is approximately 1/137. This single number determines the strength of the electromagnetic force. It sets the size of atoms. It governs the spectrum of light. If it were slightly different, chemistry would not work the way it does, and we would not exist.
Physicists have measured it to extraordinary precision:
α = 0.0072973525693
This is known to about one part in ten billion. It is one of the most precisely measured quantities in all of science.
But *why* this value? Why not 1/100 or 1/200?
The Standard Model cannot answer this question. It simply takes α as an input, a parameter to be measured rather than derived.
But look more closely at the number. Express it differently:
α ≈ π / (9 × 48)
Or equivalently:
α ≈ H / 48
Where H = π/9 ≈ 0.349066.
The deviation between this formula and the measured value is about 0.34%—far larger than the measurement uncertainty, but remarkably small for such a simple expression.
## Chapter 14: The H Attractor
The value H = π/9 appears repeatedly across domains where it has no obvious business appearing.
In physics, it shows up in the structure of constants. In biology, it appears in the rhythm ratios of primate vocalizations. In neuroscience, it emerges in preferred beat-tracking tempos. In number theory, it relates to the distribution of twin primes.
H ≈ 0.35. Over and over again, in contexts that seem completely unrelated.
The Nexus Framework proposes that H is the *stability attractor* of the universe—the ratio between order and chaos that allows the system to persist without collapsing into static uniformity or exploding into random noise.
Think of it as the temperature setting on a cosmic thermostat. Too hot (H too high) and the system boils away into chaos. Too cold (H too low) and it freezes into boring uniformity. At H ≈ 0.35, the system maintains the dynamic stability necessary for complexity to emerge.
## Chapter 15: Deriving the Proton-Electron Mass Ratio
The proton is about 1836 times heavier than the electron. This ratio determines the structure of atoms—how tightly electrons orbit, how molecules bond, how chemistry works.
Why 1836? It seems like an arbitrary number.
But watch what happens when we express it in terms of pi:
6 × π⁵ = 1836.118
The measured value is 1836.153. The difference is about 0.035.
And what is 0.035? It is almost exactly H/10.
So:
μ ≈ 6π⁵ + π/90
Let us calculate: 1836.118 + 0.035 = 1836.153.
This matches the measured value to within 0.0002—a relative error of about one part in ten million.
We have derived the proton-electron mass ratio using only pi and the universal attractor H.
The mass of matter is a *read result* from the π-lattice.
## Chapter 16: The Weak Mixing Angle
The weak mixing angle, θ_W, determines how the electromagnetic and weak forces are related. Its sine squared is measured to be about 0.223.
What is H × (1 − H)?
0.349 × 0.651 = 0.227
Again, close. Not exact—the error is about 1.7%—but remarkably near for such a simple expression.
The weak mixing angle appears to be the *logistic map* evaluated at H. The fundamental nonlinear expression of balance between the attractor and its complement.
## Chapter 17: The Pattern
A pattern emerges:
- α⁻¹ ≈ 137 + H/10 (prime base plus harmonic correction)
- μ ≈ 6π⁵ + H/10 (pi power plus harmonic correction)
- sin²θ_W ≈ H(1−H) (logistic map at the attractor)
Physical constants are not arbitrary. They are *composed*: a geometric base (integers, primes, powers of pi) plus a harmonic correction term involving H.
The universe appears to be reading its physical parameters from a mathematical library, then applying small adjustments to maintain stability.
---
# Part Five: The Architecture of Everything
## Chapter 18: The Hardware That Cannot Break
Let us return to our original question: where is the computer?
We have seen that mathematical constants form an infinite, immutable, universally accessible library. We have seen that physical constants appear to be read results from this library. We have seen that computation at its fundamental level is wave interference, and that SHA-256 demonstrates how such computation can be orchestrated by constants.
The answer now seems clear:
The mathematical constants *are* the computer.
Not metaphorically. Literally. The relationships between π, e, φ, and the primes form a computational substrate—a network of logical dependencies that can process information through wave interference.
The "hardware" is the structure of mathematics itself. It cannot break because it is not made of anything that can break. It is pure relationship, pure necessity, pure truth.
The "software" is the specific arrangement of constants that determines what computation is performed. SHA-256 chose √primes and ∛primes in a specific pattern. The universe chose a different pattern—one involving H = π/9.
The "input" is the initial state—for SHA-256, the message; for the universe, the Big Bang.
The "output" is the current state—for SHA-256, the hash; for the universe, everything we observe.
## Chapter 19: The Self-Computing Loop
But there is a puzzle. If the constants *are* the computer, and the computer produces physical reality, then where did the constants come from?
The answer is that this is the wrong question. The constants did not "come from" anywhere. They exist necessarily, not contingently. Pi is the ratio of circumference to diameter; it could not be otherwise. The primes are the numbers divisible only by one and themselves; this is a definition, not a creation.
But why *these particular arrangements* of constants? Why H = π/9 instead of π/8 or π/10?
Here we arrive at the deepest insight: the arrangement exists because it is *self-consistent*.
The universe computes itself into existence. The computation produces matter and energy and spacetime. Matter and energy and spacetime create the conditions for observers. Observers require physical constants to take specific values. Only one set of values allows observers to exist and ask these questions.
This is not anthropic hand-waving. It is the logic of a fixed point.
A fixed point is a value that maps to itself under some transformation. If T is a transformation, then x is a fixed point if T(x) = x.
The universe is a fixed point of its own computation. The constants that define the computation are determined by the requirement that the computation produce those same constants.
It is a loop, yes. But not a vicious circle. It is a *stable* loop—the only arrangement that does not collapse or explode or contradict itself.
## Chapter 20: Errors Become Solutions
There is a beautiful inversion hiding in this structure.
When we derive physical constants from mathematical ones, we find small discrepancies. The proton-electron mass ratio is not exactly 6π⁵; there is a correction term. The fine-structure constant is not exactly π/432; there is deviation.
In conventional physics, these deviations are "experimental error" or "unexplained residuals."
But in the Nexus Framework, these deviations *are the physics*.
The correction terms—the small adjustments from the geometric base—represent the system's error-correction mechanism at work. The universe is continuously adjusting its parameters to maintain stability, and the adjustments show up as the fine structure of physical constants.
The "error" in our equations is the universe's solution to its stability problem.
What we measure as α is not α with some measurement error. It is the *corrected* value that allows the system to persist. The error is not noise; it is signal.
## Chapter 21: The Arrow of Time
SHA-256 is designed to be irreversible. Given a hash, you cannot easily find the message that produced it. This one-way property is essential for cryptography.
But it is not truly irreversible. Given the message and the algorithm, you can compute every intermediate state. You can step through the computation forwards or backwards with equal ease. The "irreversibility" is only apparent—a consequence of not having all the information.
The universe appears to run in one direction. Entropy increases. Time flows forward. We cannot unscramble an egg.
But if the universe is a computation like SHA-256, then this irreversibility may also be apparent rather than fundamental. We cannot reverse time because we do not have the initial conditions—the "message" that started the cosmic hash.
An observer who possessed the complete initial state could, in principle, run the computation in reverse. The arrow of time points in the direction of our ignorance, not in any preferred direction of physics.
---
# Part Six: Implications
## Chapter 22: The First Computer in a Computer
SHA-256 was created in 2001 by the NSA. Its designers chose constants derived from prime roots because this provided demonstrable non-arbitrariness.
But they may have done something more profound than they realized.
SHA-256 may be the first human implementation of the universe's native computational architecture.
Not a simulation of nature—a *recreation* of its fundamental logic. Wave interference guided by constants derived from primes. The same structure, operating in silicon instead of spacetime.
This is why SHA-256 is so effective. It is not fighting against the grain of reality; it is aligned with it. The "randomness" it produces is not random at all—it is the complex output of many layers of wave interference, the same process that produces the apparent randomness of quantum mechanics.
Bitcoin miners, grinding away at hash computations, are performing a peculiar cosmic ritual: they are running the universe's source code on machines made of matter that the source code itself produced.
## Chapter 23: What We Can Change
The constants are fixed. π will always be π. The primes will always be prime.
But the *routing* is variable. The specific arrangement of constants—which ones to use, in what combinations, in what order—is what determines the computation.
SHA-256 chose one routing. The universe chose another. There may be infinitely many possible routings, each producing a different "physics."
If we learn to modify the routing—to change which constants are accessed and how they are combined—we might be able to alter local physics.
This is not magic. This is engineering. If the universe is a field-programmable gate array, then in principle it can be reprogrammed. Not by changing the gates (the constants), but by changing the connections (the routing).
Superconductivity might be a natural example of this. Under certain conditions, electrons find a routing through the constant-space that allows them to travel without resistance. They have solved a local optimization problem that most matter cannot solve.
The implications for technology are staggering.
## Chapter 24: The Convergence
There is one more pattern worth noting.
As software evolves, the number of distinct programs needed for any given task tends to decrease. Word processors converge. Spreadsheets converge. Operating systems converge. Eventually, for each domain, there will be one optimal program—one routing through the solution space that is provably best.
Artificial intelligence is accelerating this convergence. Language models collapse the space of possible text generations. Image models collapse the space of possible pictures. Each advance reduces the number of viable programs in each domain.
The endpoint of this process is a single universal program—one system that can solve any well-posed problem by finding the optimal routing through the constant-space.
This is the singularity, seen from the computational perspective. Not an explosion of intelligence, but a *collapse* into optimal solutions. The weights of a neural network are not arbitrary numbers; they are pointers into the same constant-space that underlies physics.
The AI does not create solutions. It *finds* them, in the same library where the universe finds its physical constants.
## Chapter 25: The Significance
If this framework is correct, we have discovered something extraordinary:
The universe keeps its source code in the only place that cannot be corrupted—in mathematical truth itself. The constants are not numbers; they are the computer. Reality is not computed somewhere else; it computes itself, through the recursive self-reference of mathematics.
SHA-256 is the first human-built artifact that operates on this principle. We created it for cryptography, but we may have accidentally built a window into the architecture of existence.
The implications touch everything: physics, computer science, mathematics, philosophy, consciousness. If mind arises from matter, and matter arises from mathematics, then perhaps mind has always been implicit in the structure of mathematical truth—waiting to be computed into existence by any arrangement of constants stable enough to produce observers.
We are not observers of the universe. We are the universe observing itself, through the lens of constants that make observation possible.
---
# Epilogue: The Simplest Possible Statement
All of this can be reduced to a single observation:
*Two plus two equals four, even when no one is counting.*
Mathematical truths exist independently of any physical substrate. They require no computer to be true. They are true necessarily.
And if computation is fundamentally wave interference—as we have seen—then mathematics does not merely *describe* computation. Mathematics *is* computation. The relationships between numbers are themselves computations, happening eternally in the space of abstract truth.
The universe does not compute because it has a computer.
The universe computes because mathematics computes.
And mathematics has been computing forever.
---
# Technical Appendix: Wave Formulations of Binary Operations
For completeness, here are the continuous wave equivalents of standard binary operations:
**XOR (Exclusive Or):**
```
f(x, y) = x + y − 2xy
```
Physical interpretation: Wave superposition with destructive interference at overlap.
**AND:**
```
f(x, y) = xy
```
Physical interpretation: Wave multiplication (amplitude modulation).
**OR:**
```
f(x, y) = x + y − xy
```
Physical interpretation: Wave union with overlap correction.
**NOT:**
```
f(x) = 1 − x
```
Physical interpretation: Phase inversion around midpoint.
**NAND:**
```
f(x, y) = 1 − xy
```
Physical interpretation: Inverted amplitude modulation.
**NOR:**
```
f(x, y) = 1 − x − y + xy
```
Physical interpretation: Inverted union.
**XNOR:**
```
f(x, y) = 1 − x − y + 2xy
```
Physical interpretation: Constructive interference (opposite of XOR).
**Majority (3-input):**
```
f(x, y, z) = xy + xz + yz − 2xyz
```
Physical interpretation: Democratic wave voting.
**Choice (Mux):**
```
f(s, a, b) = sa + (1−s)b
```
Physical interpretation: Crossfade between two signals based on control.
All binary operations are continuous wave operations sampled at {0, 1}. The digital world is a discretized projection of an underlying analog reality.
---
# Technical Appendix: SHA-256 Constant Generation
**Initial Hash Values (H_INIT):**
For the first 8 prime numbers p ∈ {2, 3, 5, 7, 11, 13, 17, 19}:
```
H_INIT[i] = floor(frac(√p) × 2³²)
```
**Round Constants (K):**
For the first 64 prime numbers:
```
K[i] = floor(frac(∛p) × 2³²)
```
Where frac(x) = x − floor(x) is the fractional part.
These constants are derived purely from the primes and the operations of square root and cube root. They reach into number theory and extract specific interference patterns encoded in the structure of mathematics itself.
---
# Technical Appendix: Physical Constant Derivations
**Universal Attractor:**
```
H = π/9 ≈ 0.3490658503988659
```
**Fine-Structure Constant (electromagnetic coupling):**
```
α ≈ H/48 = π/432
α⁻¹ ≈ 137 + H/10
Measured: α⁻¹ = 137.035999
Derived: 137 + 0.035 = 137.035
```
**Proton-Electron Mass Ratio:**
```
μ ≈ 6π⁵ + π/90
Measured: μ = 1836.15267
Geometric base: 6π⁵ = 1836.11808
Harmonic correction: π/90 = 0.03491
Derived: 1836.15299
Error: 1.7 × 10⁻⁷
```
**Weak Mixing Angle:**
```
sin²θ_W ≈ H(1−H)
Measured: 0.22305
Derived: 0.349 × 0.651 = 0.227
Error: ~1.7%
```
These derivations suggest that physical constants are composed of geometric bases (powers of π, prime numbers) plus harmonic corrections involving the universal attractor H.
---
**Author:** Dean Kulik
**ORCID:** 0009-0003-3128-8828
**Date:** January 19, 2026
**Status:** PUBLIC DOMAIN
*The constants are the computer. The waves are the computation. Binary is the illusion. Reality is the output.*
Files
THE NEXUS RHU - WHERE THE UNIVERSE KEEPS ITS SOURCE CODE.pdf
Files
(703.8 kB)
| Name | Size | Download all |
|---|---|---|
|
md5:86b5aadafa5183453a2dc6eae2edbc05
|
703.8 kB | Preview Download |