The Physical as Executed Code

A computer keeps its program and its data in the same memory, as the same bits. Nothing in a bit says whether it is an instruction or a number; what makes a stretch of memory code is that the machine runs it. That is the stored-program design von Neumann wrote down in 1945 (von Neumann, 1945), and every computer since is built on it. Binary Pulse Theory reads the physical universe the same way. The data layer is the memory. The physical is what runs.

The Machine Is Every Cell

A desktop computer has one instruction pointer stepping through memory. The Pulsecore does not work like that. Every cell updates on every pulse, all at once, under one rule: a pulser flips, a null cell bifurcates once its lit neighbours sum to one whole pulse, and a pulser whose eight neighbours all share its phase folds back to null (the Law of Binary Emergence, Part 1.1; Information-Driven Perpetuation, Part 1.11; the First Fold, Part 3.2). A machine of this kind is a cellular automaton, the computing universe Zuse proposed (Zuse, 1969) and Fredkin and Wolfram developed (Fredkin, 2003; Wolfram, 2002).

In such a machine, running code means something particular. Conway's Game of Life is the clean example: one rule, every cell, every tick (Gardner, 1970), and it can compute anything a computer can (Berlekamp, Conway & Guy, 1982). Its gliders move and carry signals; that is code running. Its still lifes sit where they formed, take up room and never do anything; that is data that does not run. Binary Pulse Theory reads ordinary matter as the first and Data Matter (Part 3.13) as the second: present and weighing, never radiating.

Written Once, Then Read

The Cell Rule has a consequence worth stating plainly, because it was found by running the rule rather than assumed. Once a cell has pulsed it never stops (Information-Driven Perpetuation, Part 1.11). So the field fills: nulls are exposed, bifurcate and light, until every cell is a pulser and no null is left. From then on nothing new is written; the field flips between two frames for the rest of the life. On a field of 128 by 128 cells from a random start the rule fills in about 55 pulses; in the game the writing runs while the Pulsecore fills and ends when it is full.

So the data layer is written once and then read. Binary Pulse Theory calls the written field the Pulsecore Drive: the data as written, which stays, while the physical is the copy that runs from it. Two readings follow, both offered as readings. First, information that falls into a well is not destroyed, the worry of Hawking's information paradox (Hawking, 1976): the running copy ends, and what it was read from never left the drive. Second, the drive is read through a boundary, so how much a region can hold is set by its surface, as the holographic bound says (Bekenstein, 1973; 't Hooft, 1993; Susskind, 1995) and as the Pixel Bound of Part 1.9 already counts.

What Runs and What Does Not

Part 3.13 counts Data Matter against ordinary matter, 27 to 5. Read as memory, that count says how much of a universe's loaded data runs.

Executed Share G

x_run = 1 / (1 + N◍ / N_b)

Dimensional analysis:
Where (from the book): x_run [∅], N◍ [∅], N_b [∅]
[∅]
[∅] ÷ ([∅] + [∅] ÷ [∅]) = [∅] ÷ ([∅] + [∅]) = [∅] ÷ [∅] = [∅]
[∅] = [∅] ✓ Valid PulseCore Verified ✓

Of the data a universe loads, the share that runs

Where:

• x_run [∅] — the share of the loaded data that runs as ordinary matter
• N◍ [∅] — the count of Data Matter (Part 3.13)
• N_b [∅] — the count of ordinary matter

➢ With the Data Matter Count, N◍ / N_b = 27/5, the executed share is 5/32 ≈ 0.156: about one part in six of what a universe loads runs as stars, gas and planets; the rest is loaded and weighs, and does not run.

What decides which data runs is the compiler. The Dimensional Failure Law (Part 3.9) gives it a mechanism when read this way. Let each of a universe's D fundamental harmonics (Part 4.8) be a channel on which a Proto Well's data either locks to the pulse or does not, at even odds. The well compiles if it locks on at least one channel, and fails only by missing all D: one chance in 2^D, the law's own P⦰ = 2^(−D). This is a reading of a law already derived, not new evidence for it; what it adds is the picture of the compiler as phase lock to the Prime Pulse across the fundamental harmonics.

The Laws as an Instruction Set

In this reading the constants of a universe are the values compiled into its program, and its laws are its instruction set. Some are branches. The Star Existence Condition (Part 2.10) is the plainest: where the Planck-to-proton mass ratio clears α^(−1/2) the star routine runs, and where it does not the routine is skipped. A level-22 universe still holds matter, light and wells; its language has no word for a star.

The Game's Reading

PulseCore 8.3 lists, for each universe, every routine its engine ran in that life, and every one it skipped with the law that skipped it: data novas, the physical, wells, failed Proto Wells, stars, giants, supernovae, white dwarfs, neutron stars and pulsars, stellar wells, Seyferts, quasars, the galaxy types, and child universes. The list is printed in the universe's Language Block (Part 4.10), each routine marked as inherited from its parent, new in this generation, or lost.

Links to Binary Pulse Theory

• Chapter 1: the Binary Pulse and the cells it writes.
• Part 1.9: the Pixel Bound, the drive read through a boundary.
• Part 2.10: the Star Existence Condition, a branch of the instruction set.
• Part 3.9: the Dimensional Failure Law, read as the compiler.
• Part 3.13: the Data Matter Count, loaded data that does not run.
• Part 3.16: the compiler a child inherits.
• Part 4.10: the language the drive is written in.