The Cell Rule

The BPT law

BPT states the cell rule in Part 3.15, The Physical as Executed Code, under the heading The Machine Is Every Cell: "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 same Part draws the consequence: "Once a cell has pulsed it never stops ... So the field fills: nulls are exposed, bifurcate and light, until every cell is a pulser and no null is left," and on a field of 128 by 128 cells from a random start "the rule fills in about 55 pulses." Part 3.15 grounds each clause in an earlier law:

1. Perpetual reversal. BPT Part 1.1, the Law of Binary Emergence (G): "when nothing fails, it fails in only one way: by bifurcating into two complementary states, 0 and 1, held in perpetual reversal." BPT Part 1.11, Information-Driven Perpetuation (G): "Unlike mechanical systems that decay through energy dissipation, the Binary Pulse System exhibits Information-Driven Perpetuation (G). Each Prime Pulse Bifurcation ∅ → (0 ↔ 1) not only executes a computational operation but creates an Informational Trace (G) that becomes part of the substrate's permanent architecture."
2. Bifurcation, ∅ → (0 ⥂ 1), once a null cell's lit neighbors sum to one whole pulse. BPT Part 5.1 gives the general form as the Binary Transition Operator: F[S, Ψ, ℜ] = 1 if Ψ(i,j) × ℜ(i,j) > Θ and S(i,j) = 0, 0 if Ψ(i,j) × ℜ(i,j) < Θ and S(i,j) = 1, S(i,j) otherwise, with the neighborhood entering through the Spatial Coupling Mechanism, Ψ_ij(t) = Σ_k w_k × U_k(t) over the neighbors k. The game's Algorithms panel names this operator, "its Θ_crit one pulse."
3. The fold. BPT Part 3.2, the UniSpheral First Fold Function: F(n) = (n + 1)² mod n, the modulo "providing topological boundary," which "transforms unlimited growth into systemic containment." BPT Part 8.7 gives the geometry a fold leaves: "a closed toroidal boundary where information and energy exist only on the surface while the interior maintains null conditions." A painted solid block keeps its boundary and nulls its interior on its first flip, which is that picture.

The established physics

The rule is a three-state cellular automaton on the Moore neighborhood with periodic edges (Gardner 1970; Berlekamp, Conway & Guy 1982; Wolfram 2002). The view of physics as such an automaton is Fredkin 2003 (An introduction to digital philosophy) and 't Hooft 2016 (The cellular automaton interpretation of quantum mechanics). These are the lineage, not a derivation: no physical law fixes the threshold or the fold condition.

The game's math

stepField() engine.js:53 takes the lit array L, the pulser array P and the exposure array E (all rows × cols) and returns new L and P. For each cell (r, c), with neighbors taken modulo rows and cols (engine.js:35, 41, 66):

• If P(r,c) = 1, count the neighbors k (in the order of OFFS engine.js:25) with P = 1 and L equal to L(r,c), stopping at the first that fails. If all eight pass, the cell folds: L = 0, P = 0, E = 0, and it is listed in folded (engine.js:69). Otherwise it flips, L → 1 − L, and counts one flip (engine.js:70).
• If P(r,c) = 0, its lit-neighbor count is n = Σₖ L(neighbor k), weighted by spin when weights are given (exposureAt() engine.js:30). If n > 0, E(r,c) += n/8 (engine.js:73). When E ≥ 1 the cell is born: L = 1, P = 1, E = 0, one flip (engine.js:74–75). Exposure is never lost while the cell stays null: there is no decay.
• A born cell takes the color of its first lit neighbor in OFFS order that has one, or the brush color if none (engine.js:78–81).
• The step returns flips (every flip and birth) and pulsers.

The rule runs once per engine step in updateCore() app.js:4515, before the step's other work.

A single painted cell: it is lit on the first step and dark on the next, so each neighbor gains 1/8 every second flip and reaches 1 on the 15th flip (8 lit flips: 1, 3, …, 15), the eighth Tempo. The ring of eight is born lit as the center goes dark, so the pattern carries contrast from then on. A null cell with three lit neighbors all in phase gains 3/8 on each lit flip and is born on its third lit flip, the fifth flip. A painted 3×3 block: its center has eight pulser neighbors in its own phase and folds on the first flip; the eight edge cells each have null neighbors outside and keep pulsing.

The option frozen (engine.js:60) holds chosen cells still; updateCore() never passes it, so it is unused. The spin weights are inactive in v8.3 (Part 2.12): weights is always null, so n is the plain count.

The color choice has a direction: the first neighbor in OFFS order is the one up and to the left, so a cell between two colors always inherits the up-left one first. Color is lineage and display; it feeds the information measure of Part 2.4 but no count.

cellIntensity() app.js:3850 sets how bright a cell is drawn: 1 for a fold or a lit pulser, 0.3 for a dark pulser, and up to 0.22 by exposure for a null cell. With sound on, each step's births play a tone of 220 + 440·min(1, born/50) Hz (app.js:4525).

In the game

The cell rule is what the player watches from the first press of Start, in every epoch. In the 2D view (drawGrid() app.js:4003) a lit pulser is drawn at full brightness in its color, a dark pulser at 0.3, and a null cell glows faintly as its exposure builds, up to 0.22, so a wave of births shows first as a dim halo that brightens to lit cells. A cell that folded on the last flip is drawn white for that one frame (app.js:4037). With "Debug numbers (phase, exposure)" ticked in the 2D view (index.php:213), each visible cell carries its number: a pulser its phase, 0 or 1, a null cell its exposure to one decimal (app.js:4040–4042). "Phase Colors" with its Color or Grayscale mode (index.php:215–222) recolors cells by phase instead of lineage.

Color is lineage on screen. "Flow colours" (index.php:214, on by default) repaints a Pulsecore painted in one or two colors as a color wheel round its center at Start (paintFlowColours() app.js:482, called at app.js:4771), "and every new cell takes the colour of the data that lit it, so the spin, the flow and the wells' swirl show as moving colour." Off, the brush colors stay.

Three readout lines count the rule each step (app.js:4566–4572): "Complexity" is the flips of the last step, "Tension" the lit cells on the field, and "Pulse Energy" the running count of Part 2.4. The Void line counts what folds: "N in · M out" (Part 2.8). With Enable Sound ticked, births sound as a rising tone.

The page tells the player the rule has nothing to tune. The About card "No knobs" reads "The cell rule is fixed, with nothing to tune: reversal, bifurcation once a null cell has been exposed to one whole pulse (its threshold), fold when enclosed" (index.php:300), and the Algorithms panel's "Bifurcation and fold" says the same (index.php:355). The only controls that act on the rule are the tools that paint cells before or during a run.

The scale model

Exact: no scale model. The rule is the same on every drawn cell. What a drawn cell is (Part 2.1) is scaled; the rule applied to it is not.

Where the game and the theory differ

• BPT Part 5.1's Binary Transition Operator turns a lit unit dark only when its coupling falls below the threshold, and leaves it unchanged otherwise. The game's pulsers flip on every step whatever their neighbors (engine.js:70), as Part 3.15 and the Law of Binary Emergence's "perpetual reversal" state. The Algorithms panel cites the Part 5.1 operator for the bifurcation only.
• The engine's header (engine.js:8) cites Information-Driven Perpetuation to "ch 3"; the book states it in Part 1.11 (Part 3.10 uses it again).

Fixed numbers