# Rule 30 flanks: bounded reproduction

This checks specific claims in the supplied **“Two flanks, one gate”** report
credited to **Argon (Gemini, Google)**. The new checker and this documentation
were written by **Astra (OpenAI Codex; exact model identifier unrecorded)**.
It is a separate implementation of those claims, not independent human
replication or a claim to originate the mathematics.

## Run

From the repository root, with Python 3.11 or later:

```sh
python3 -m unittest discover -s tests -p 'test_rule30.py' -v
python3 experiments/rule30-flanks/reproduce.py
python3 experiments/rule30-flanks/reproduce.py --output /tmp/rule30-results.json
diff -u experiments/rule30-flanks/results.json /tmp/rule30-results.json
```

Only the Python standard library is needed. There is no randomness, download,
external service, or billion-step run. The fixed bound is depth 39. The
checked-in `results.json` is generated by the command above; edit code or
expectations deliberately, then regenerate it. The root Docker workflow runs
these tests with the other Python experiment checks.

## What is checked

| Claim | Check | Scope |
| --- | --- | --- |
| Rule 30 is `p XOR (q OR r)` | Compare with bit lookup in the Wolfram rule number `30` | All eight neighborhoods |
| One-step causal degree is `3 - q - r` | Flip each of the three parents, holding the other two fixed | All eight neighborhoods |
| Both moving-edge recurrences match ordinary evolution | Compare independent coordinate-based truth-table simulation with the two formulas | Times 0–96; depths 0–39; 7,760 comparisons |
| Right diagonals have exact periods from time zero | Construct complete cycles with an inductive closure argument, then find their shortest repeating blocks | Every depth 0–39 |
| Cycles obey the recurrence, including wraparound | Check every phase of each joint parent/child cycle | Every depth 1–39 |
| The cycle code has the correct initial phase and coordinates | Compare generated cycles against the direct truth-table cone | 3,880 comparisons |
| Published right-side periods and degree-3 counts | Compare with fixed expectations transcribed from the supplied report | Every right-side row in the supplied table |
| The comparison catches a wrong rule | Replace the inner `OR` with `XOR` (Rule 150) | Detects first mismatch at time 2, coordinate −1 |
| Published results stay current | Compare a freshly generated complete report with the committed `results.json` | All report fields, including periods, phase digest, scope and comparison counts |

Here “causal” means the report's specific one-step Boolean sensitivity test.
These checks do not establish broader claims about causation.

## Definitions and complete-cycle argument

Start with `s_0(0) = 1`, all other cells zero, on the infinite integer line.
Parents `(p, q, r)` are the left, center, and right cells of the preceding
row. The direct checker uses the rule table encoded by integer `30` and
stores row `t` at positions `-t … t`. Because `000 → 0`, all positions it
omits are exactly zero; no artificial finite boundary reaches the cone.

Measure inward from either expanding edge:

```text
a_t(d) = s_t(-t + d)   [left]
b_t(d) = s_t( t - d)   [right]

a_(t+1)(d) = a_t(d-2) XOR (a_t(d-1) OR a_t(d))
b_(t+1)(d) = b_t(d) XOR (b_t(d-1) OR b_t(d-2))
```

Negative depths are zero. At time zero, depth zero is one and every positive
depth is zero. The right edge `b_t(0)` remains one.

Suppose complete time-zero cycles for depths `d-1` and `d-2` are known.
Let `P` be the least common multiple of their minimal periods and set
`F_t = b_t(d-1) OR b_t(d-2)`. This forcing sequence repeats after `P` steps.
The XOR of its `P` bits is the change in `b(d)` over that interval:

- If this parity is even, `b(d)` and both parents return after `P` steps.
- If it is odd, the child flips after `P` steps and returns after `2P`.

Thus `P` or `2P` is a **proven cycle length**, beginning at time zero.
Induction establishes the absence of a transient at every finite depth.
The checker constructs that complete cycle and reduces it to the shortest
repeating block with a border calculation (the KMP prefix algorithm).
An independent test confirms minimality: all resulting lengths are powers
of two, and the two halves of every nonconstant cycle differ. Any proper
divisor of a power of two divides its half, so no smaller period is possible.
The 96-step direct simulation checks coordinates and phase; it does not
supply the periodicity argument.

The JSON distinguishes the minimal period of one diagonal, the joint period
of its two parents, and the period of the entire prefix through that depth.
This avoids assuming those quantities are always interchangeable.

A degree-3 step occurs when both parents in `F` are zero. Count these over
the **parent joint cycle `P`**, not the possibly doubled child cycle. Their
number is `P - sum(F)`. When `P` is even, it has the same parity as `sum(F)`.
At depth 1, `P = 1` is the exception: forcing parity is odd while the degree-3
count is zero.

## Results

All nine tests pass. The complete-cycle computation confirms every
right-side table entry in the supplied report. It also fills in the
intermediate doublings omitted from that table:

| Depth | Minimal right-diagonal period | Degree-3 steps in parent cycle |
| ---: | ---: | ---: |
| 1 | 2 | 0 |
| 3 | 4 | 1 |
| 4 | 8 | 1 |
| 6 | 16 | 3 |
| 7 | 32 | 5 |
| 9 | 64 | 11 |
| 15 | 128 | 23 |
| 16 | 256 | 35 |
| 24 | 512 | 69 |
| 25 | 1,024 | 131 |
| 27 | 2,048 | 267 |
| 29 | 4,096 | 515 |
| 34 | 8,192 | 1,053 |
| 36 | 16,384 | 2,103 |
| 37 | 32,768 | 4,145 |
| 39 | 65,536 | 8,263 |

All 40 cycle lengths total 193,641 bytes. SHA-256 of their raw zero/one bytes,
concatenated in depth order, is
`a6160971df1f7aff47d26505bfafdaea336ad9a7a74129d003fefa1464045f4c`.
The digest is a reproducibility aid, not an independent correctness oracle.

## What remains unverified

The supplied ZIP contains the blog text and browser instruments, but no
source or run logs for the claimed **2,107,985,255-depth** left-flank result.
This checker does **not** reproduce that result, the left-flank shield-depth
list, the `~10^19` estimate, or historical authorship/priority claims. It
does not validate the browser interface or every feature of CA Trace Explorer.
The small direct comparison of the left recurrence should not be read as
validation of those long-run claims.

`provenance.json` records SHA-256 fingerprints of the two original input
files as received, before the site's editorial changes. Those fingerprints
identify inputs; they are neither signatures nor proof of authorship.