igneum/docs/analysis/cryptanalysis/report-acceptance-rule-3.md

# Report: exhaustion and steering of the program draw (lane adv-accept-3)

internal adversarial pass, not an independent review

- Target commit: 017e70376489251e18564c0abce7e466e606c8b3 (class v4 sub-version 3, object byte 7). Worktree HEAD 45845b09 at the start (build/master, 19:51 BST); `git diff --quiet 017e7037 HEAD -- igneum-pow` prints IDENTICAL.
- Harness: tools/attack/adv-accept-3 (crate adv-accept-3, bin `adv3`), igneum-pow by path, nothing in the library modified. Binaries built on build-2 through tools/build-remote.sh: 35336b84039b76538916c5c2a715aefd06ecc5b215d100bedfa9215b750eaa5b (first build, 20:05 BST: idcheck, margins, exhaust-mirror, ids, the first static sweep, the plant run), 928272e0a4f426a33380612bbcf5cde52017765f5185fc73a4396d5581105785 (20:09 BST, generator 4 stamped on every candidate: every queued sweep), 60613d0c4412401d1bed6dd55a831eb42ffc6b1524c36d79500766b7515ef212 (20:13 BST, the multiply columns: the static sweep v2). Pinned copies under /srv/builds/_adv-accept-3/bin/ on both boxes.
- Boxes: build-1 and build-2, nice 10, cores 8 to 95, one sweep per box under `flock /srv/builds/_adv/locks/sweep.lock` (the coordinator's rule of 19:55 BST). Load 430 to 560 on 96 threads throughout. No GPU: the live-hash-rate confirmation of any gain is BLOCKED and the gain is priced from read counts, as chip-model-v3.md section 5 prices it.
- Logs: /srv/builds/_adv-accept-3/ on each box; copies in docs/analysis/cryptanalysis/logs/adv-accept-3/ on this branch.
- Seed space: `seed_words_from_bytes("igneum-adv-accept-3/steer/<i>")` as 32 little-endian bytes (chain-shaped epoch seeds), era fixed to the Devnet 3 era bytes 4020cb43...b925 (the era is a 180-day constant the epoch attacker does not re-roll). Every program is drawn through the library's own attempt loop and rule.
- Queue: 90 (exhaustion census) was claimed by lane adv-accept before this lane started; its row is cited, not repeated. 91 and 92 claimed at 19:5x BST; 93 to 99 written, claimed and queued (section 9).
- Box-hours spent at 20:20 BST: about 0.15 (three builds under a minute each; idcheck 5 s, margins 1 min, exhaust-mirror 10 s, ids 3 s, two static sweeps of 1 min, the 48-seed plant run at 48 threads 1 min). Queued sweeps had not yet taken a lock at 20:20 BST.

## Draw-path validation (passed before any claim)

`adv3 idcheck` (box 2, 20:06 BST, log logs/adv-accept-3/idcheck.log): the Devnet 3 epoch-0 seed drawn through `Epoch::chain_program(ProgramClass::V4)` gives attempt 0, id fce15bf61030be57, class mx8-eraaf3a9139+sh256x27 (MATCH with the pack, sha256 e025750f... verified on build-1); the kit's shared devnet epoch-0 seed gives attempt 1, id a785001687d8688a (MATCH). So the harness draws what the chain draws.

## Status board

| Q | Question | Method | Known-failed shape (must fire) | Gate | Result | Status |
|---|---|---|---|---|---|---|
| Q1 | Exhaustion: P(a seed exhausts 256 attempts), per-part rejection rates, attempt distribution | Cite row 90 (lane adv-accept, 16,337 seeds); add this lane's static per-part rates over 3,009,928 candidates of 10^6 seeds and the geometric fit | the reject-everything mirror of Q1b | P(exhaust) bounded with its count | per attempt: accept 0.323, reject 0.677 ((a') 0.568, (a) 0.079, (b) 0.022, dynamic parts about 0.009); histogram geometric (bin ratios 0.65 to 0.71); P(exhaust) = 0.677^256 = 4.6 x 10^-44; 0 of 16,337 seeds reached the cap | BOUND |
| Q1b | The last-resort program: weak, constant, predictable | `last_resort_v4(candidate(b, 256))` through the library on 3,000 seeds, the REAL rule run on each | `adv3 exhaust-mirror`: a reject-everything loop must hit the cap and print the last resort | last resort characterised; no predictable or weak accepted program | mirror fired: cap 256 reached, program byte-identical to the library's, the real rule ACCEPTS it (distinct 128.000, saturated 0, bias max 55); seed 0's last resort has 0 lossy ops (or, mul, mulhi all xor), 3 mad kept; 3,000-seed sweep queued | RUNNING (sweep 95) |
| Q2 | Steering with the full rule: tries per quantile of each property | `adv3 steer`, the real draw per seed, min per-site ratio at 256 units plus static properties; 2 x 10^4 seeds queued | `--plant hot`: two `or` writers before a load's source must put the planted set in the lowest quantile | tabulated; no property reaches a 1.1x chip gain under 10^5 tries | plant: 45 of 48 planted rows at ratio 0.207 to 0.993 against a population minimum of 0.999 at 256 units (3 did not fire: the scan found no ALU writer to change); the real rule rejects every effective plant by (a') | RUNNING (sweeps 93, 96) |
| Q2b | Static steering at 10^6 seeds | `adv3 static`: the first candidate passing (a), (b), (a') per seed, static properties, quantiles to 10^-6 | the plant of Q2 (the same property code) | the 10^-5 and 10^-6 quantiles of each property, priced | DONE: table in section 3; the best property at 1 in 10^6 tries is a shadow block with 38 multiplies of 256 (mean 74), worth about 2 to 3 percent of the f = 1 chip's energy per hash (approximate); the load critical path at 40 of 128 (median 72) is worth nothing at the memory activate ceiling | BOUND |
| Q2c | Live hot set of the lowest-ratio steered seeds | f8 `warps` on the lowest-ratio seeds of Q2 | f8's own const-item plant | the worst steered seed's gain priced | not started; lane adv-accept's live rows on its five lowest of 4,600 price the selector at 1.002x | PENDING |
| Q3 | Program id: collisions and derivation agreement | `adv3 ids` over 10^7 (seed, attempt) pairs; `adv3 idcheck` by three derivations | low-32 collision counts must match the birthday expectation; one attempt bit flipped must change the id | 0 collisions; the derivation that matches the packs named | 0 id collisions, 0 program-stream state collisions, 0 seed-word collisions over 10^7 pairs (control: 11,759 low-32 id collisions against 11,641 expected); FINDING: program.json's `program_id_derivation` string and spec 1.4.6 state a derivation WITHOUT the `"sub/" || 3_le16` suffix the code appends for generator 4; an implementation written from the text computes 30956569d8f3d8d7 for Devnet 3 where the pack carries fce15bf61030be57 | FINDING (interoperability, not consensus) |
| Q4 | Determinism traps | `adv3 margins`; a second interpretation of the rule (`adv3 verdicts`, 2,000 seeds, every attempt); a spec-1.4.6-only interpretation (400 seeds); the read list | `--variant floor97` must change at least one verdict | 0 disagreements between code and the faithful second interpretation; the spec-only disagreement rate measured; every divergence listed | margins: the f64 ratio compare of (c'') never disagrees with the integer rule `50 d >= 49 E` on any of the 2^20 + 1 values of d for any window (margins 0.32 to 0.44 counts); read list in section 6 (the spec text is behind the code on six points; the CLI `accept` command caps at 32 with no last resort) | RUNNING (sweeps 94, 97, 98) |
| Q5 | Era steering | `adv3 era-steer` over 400 era seeds: stride, interleave, epoch 0's min ratio | none needed (a listing) | noted | queued | RUNNING (sweep 99) |

## 1. Q1: exhaustion (row 90, owner adv-accept, cited; this lane's static rates added)

Lane adv-accept's census (its report at build/adv-accept d9638927, "The selector's base rate", 16,337 accepted programs of the F8 label space, read 20:12 BST): accepted at attempt 0..11: 5,271, 3,602, 2,434, 1,585, 1,110, 740, 521, 368, 211, 166, 100, 72; max 26; mean 2.097; last-resort programs 0. Its forced-exhaust plant hit the cap and printed the last resort, which the real rule accepted (op mix xor 17 to 19, 0 lossy ops).

This lane's static sweep (`adv3 static --from 0 --count 1000000 --threads 8`, box 1, 20:14 BST, 61 s, log logs/adv-accept-3/static-1e6-v2.tsv): 10^6 seeds, 3,009,928 candidates drawn until the first that passes the static rule.

| Quantity | Value |
|---|---|
| Candidates per seed to the first static pass | 3.010 |
| Static rejection per candidate | 0.6678 |
| (a') dataflow freshness | 1,708,418 of 3,009,928 = 0.5676 |
| (a) cyclic stale load | 236,693 = 0.0786 |
| (b) no injecting write | 64,817 = 0.0215 |
| Dynamic parts (c), (c'), (c'') on a static pass (from the full-rule accept rate 0.323 against the static pass rate 0.332) | about 0.027 of static passes, 0.009 of candidates |
| Seeds reaching 256 static rejections | 0 of 10^6 (max first-static-pass attempt 33) |
| Static attempt histogram 0..11 | 332,037, 222,134, 148,201, 98,797, 66,094, 44,000, 29,246, 19,867, 13,210, 8,916, 5,790, 3,895 |

The histogram is geometric: successive bin ratios 0.669, 0.667, 0.667, 0.669, 0.666, 0.665, 0.679, 0.665, 0.675 (static), and 0.683, 0.676, 0.651, 0.700, 0.667, 0.704, 0.706, 0.573, 0.787 on the sibling's 16,337 full-rule seeds. Attempt k's words are `seed_words_from_bytes(b || k_le32)`, an FNV-1a prefix state shared across attempts and finalised by the murmur mix; the bins show no correlation between attempts at this sample size. With r = 0.677 per attempt, P(exhaust) = r^256 = exp(256 ln 0.677) = 4.6 x 10^-44 per epoch seed. An attacker who re-rolls the epoch seed to reach the last resort needs about 2 x 10^43 tries. No seed class exhausts: the attempts of one seed are 256 independent draws by construction. Bound: 1.016 x 10^6 full-rule seeds (this lane's plant run plus the sibling's) and 10^6 static seeds, 0 at the cap.

## 2. Q1b: the last-resort program

`adv3 exhaust-mirror --seed 0` (box 1, 20:06 BST, log logs/adv-accept-3/exhaust-mirror-0.log). A mirror of `try_generate_class` with the rule replaced by reject-everything tried 256 attempts, reached the cap, and produced `last_resort_v4(candidate(seed, 256))`; the library's own last-resort call on the same seed is byte-identical (`==` on the Program). The real rule, run on that program, ACCEPTS it: distinct mean 128.000, saturated 0, bias max 55. Its base op mix: xor 18, load 16, add 10, shfl 6, rotl 4, rotr 4, mad 3, sub 3 (0 or, 0 mul, 0 mulhi; the 3 `mad` multiplies are kept by the rewrite). Its static properties: 88 loads on the critical path, 18,979 ALU ops on it, 2 predictable sites, chi-square 34.5 against the weights (the rewrite moves every or, mul and mulhi to xor, so its op mix is the one structural tell), 0 lossy ops.

What the last resort is: a deterministic function of the seed (the attempt-256 draw), different for every seed, computable by anyone, reachable only at 4.6 x 10^-44 per seed. Whether it is weak by the rule's own measures over many seeds, and how often the rule would have rejected it, is sweep 95 (3,000 seeds, the real rule on each, queued). What a chip would gain from it: nothing beyond any accepted program's gain; it has no hot set by construction (no lossy op feeds a load) and its only skew is the missing or, mul and mulhi, which a fixed datapath pays for in the shadow block anyway (the shadow's multiplies become xor too, so a last-resort epoch is the cheapest epoch a multiplier-poor chip could see: a 256-instruction shadow with 0 mul and mulhi and only its `mad` multiplies, about 27 of 256). At its probability that epoch never comes.

## 3. Q2b: static steering at 10^6 seeds (DONE)

The property of the first statically accepted candidate of each seed (the dynamic rule then rejects about 2.7 percent of these; the full-rule sweep of section 4 checks that the conditioning does not move the tails). Tries per quantile are 1/q by definition; the table's content is the value a grinder buys at each quantile.

| Property (per hash unless said) | Mean | Min | 10^-1 low / high | 10^-2 | 10^-3 | 10^-4 | 10^-5 | 10^-6 (1 of 10^6) | Max |
|---|---|---|---|---|---|---|---|---|---|
| Loads on the critical path (of 128) | 76.4 | 40 | 64 / 96 | 48 / 104 | 48 / 120 | 40 / 128 | 40 / 128 | 40 / 128 | 128 |
| ALU ops on the critical path (base and shadow, all reps) | 18,326 | 14,008 | 17,001 / 19,808 | 15,937 / 20,952 | 15,273 / 21,992 | 14,664 / 22,835 | 14,251 / 23,506 | 14,033 / 24,410 | 24,593 |
| Load sites of iteration 0 with an init-only address (of 16) | 2.5 | 1 | 1 / 4 | 1 / 6 | 1 / 7 | 1 / 8 | 1 / 9 | 1 / 10 | 10 |
| Chi-square of the 48 non-load ops against the weights | 8.94 | 0.25 | 4.23 / 14.46 | 2.15 / 21.63 | 1.18 / 28.40 | 0.71 / 35.49 | 0.44 / 41.43 | 0.25 / 46.62 | 52.35 |
| Largest single-op share of the 48, percent | 19.0 | 10 | 16 / 25 | 14 / 29 | 12 / 35 | 12 / 37 | 12 / 41 | 10 / 43 | 43 |
| Output registers whose last write is or, mul or mulhi | 1.6 | 0 | 0 / 3 | 0 / 4 | 0 / 5 | 0 / 6 | 0 / 7 | 0 / 7 | 7 |
| or, mul, mulhi in the base program | 11.2 | 0 | 8 / 15 | 5 / 18 | 3 / 21 | 2 / 23 | 1 / 24 | 0 / 25 | 27 |
| Multiplies (mul, mulhi, mad) in the base program (of 48) | 13.9 | 2 | 10 / 18 | 7 / 21 | 5 / 24 | 3 / 26 | 2 / 28 | 2 / 29 | 30 |
| Multiplies in the shadow block (of 256) | 73.9 | 38 | 65 / 83 | 58 / 91 | 52 / 97 | 48 / 101 | 45 / 105 | 40 / 109 | 110 |
| Dependency depth of one shadow pass (of 256) | 84.9 | 64 | 79 / 91 | 74 / 97 | 70 / 102 | 68 / 105 | 67 / 109 | 65 / 112 | 114 |

Priced against chip-model-v3.md section 5:

| Lever a grinder could pull | Best value at 10^-4 (10^4 tries) and 10^-6 | What it buys a chip | Reading |
|---|---|---|---|
| Short load chain (memory-level parallelism) | 40 loads on the critical path against a median of 72: 3.2 independent reads in flight per lane against 1.8 | The f = 1 chip and the card both sit at the memory's activate ceiling (section 5.3: 21.3 G reads/s, the 5090 at 82 percent of it); more reads in flight per lane lowers the lanes needed, not the ceiling; both sides mine the same program | 1.00x |
| Short ALU chain | 14,664 ops at 10^-4, 14,033 at 10^-6, against 18,326: 20 to 23 percent shorter | The ALU chain is 7.6 microseconds per hash at one op per cycle at 2.4 GHz against 128 dependent reads at about 400 ns (51 microseconds): the shadow sits inside the read latency on both sides (section 5.7, the program-length lever); shorter helps the honest card and the chip alike | 1.00x |
| Init-only addresses in iteration 0 | 8 of 16 sites at 10^-4, 10 at 10^-6 (median 2) | Addresses a lane can issue before its first read returns: more parallelism at the start of the hash, the same ceiling; the addresses are nonce-dependent (init words are a hash of header and nonce), not a hot set | 1.00x |
| Fewer multiplies for a multiplier-poor datapath | shadow 48 of 256 at 10^-4, 38 at 10^-6 (mean 74); base 3 at 10^-4 | The shadow is 55,296 ops per hash. At N5 datapath figures (section 5.1: multiply 0.52 pJ, add 0.06, 2x pipeline) the mean shadow pass costs 74 x 0.52 + 182 x 0.06 = 49 pJ, the 10^-6 one 38 x 0.52 + 218 x 0.06 = 33 pJ: 34 percent less shadow ALU energy. The shadow is about 11 to 22 nJ of the f = 1 chip's 470 nJ per hash (approximate), so the saving is 2 to 3 percent of its energy for one epoch in a million tries. The chip still needs multipliers for every other epoch | about 1.02x to 1.03x per joule at 10^-6, approximate; under the 1.1x gate at every quantile |
| Lossy last writes (output bias shape) | 6 of 8 registers at 10^-4, 7 at 10^-6 | A lossy last write narrows an output register's value set; the rule's bias test bounds every output bit to 6 sigma and the final values to under 1 percent saturated; nothing a chip reads faster | 1.00x |

Static steering buys no asymmetric gain: every property a seed grinder can move in the static program helps the honest card by the same amount or not at all, because the rate on both sides is reads per second at the memory ceiling. The one asymmetric lever is a hot set on the live dataset, which is the full-rule sweep's ratio column (section 4) and lane adv-accept's live measurement (its five lowest-ratio seeds of 4,600 all beyond the f8 1.2x gate live, the worst a 1 MB copy serving 0.31 percent of loads, 1.002x; its selector table: ratio under 0.999 at 256 units in 85 of 16,337, one try in 192).

## 4. Q2: steering with the full rule (RUNNING)

Sweeps 93 and 96 (`adv3 steer --from 0 --count 10000 --threads 88 --check-every 50` and `--from 10000`), box 2, queued 20:11 BST behind lane adv-cache-2's census under the sweep lock. Per seed: the real attempt loop and rule, the accepted attempt, the chain id, the minimum per-site distinct-index ratio at 256 units and its site, the (c) report, every rejection reason of the seed's earlier attempts, the static properties of section 3, and every 50th seed re-drawn through `Epoch::chain_program` for equality. Rows land in the log as they finish; the quantile table lands here from the first 10^4 seeds.

Known-failed shape (`adv3 steer --from 900000 --count 48 --threads 48 --plant hot --check-every 1`, box 1, 20:07 to 20:08 BST, binary 35336b84, log logs/adv-accept-3/steer-plant.log): on each accepted program the two ALU instructions that last wrote the source register of one load were rewritten to `or` (the source then saturates toward all ones) and the ratio re-read.

| Rows | Planted ratio at 256 units | Population ratio (the same 48 unplanted) | The real rule on the planted program |
|---|---|---|---|
| 45 of 48 | 0.207 to 0.993 (median about 0.98) | 0.999 on every row | rejected, (a') on every one |
| 3 of 48 | 0.999 (the plant did not fire: the backward scan found loads only before the site and changed nothing) | 0.999 | accepted (unchanged program) |

Every effective plant sits below the population minimum, so the property column separates a forced hot source at once. Rejection reasons over the 48 seeds' 106 rejected attempts: (a') 89, (a) 12, (b) 3, (c'') 2; mean accepted attempt 2.21. Per seed under the box's load: 15 to 57 s at 48 threads (the 2^20 pass of (c'') on every static-passing candidate is the cost), so the two 10^4-seed shards are about 2 box-hours each at 88 threads once they hold the lock. The `chain_eq` column of that run read DIFF on every row because the first binary left generator 2 on the candidates (the id then took the class path); the comparison is meaningful from binary 928272e0 on, which every queued sweep runs.

## 5. Q3: the program id

`adv3 ids --seeds 1000000 --attempts 10 --threads 16` (box 1, 20:09 BST, 3.0 s, log logs/adv-accept-3/ids-1e7.log): 10^7 (seed, attempt) pairs of this lane's seed space.

| Quantity | Count | Expected at random |
|---|---|---|
| Equal program ids (FNV-1a-64 with the generator-4 suffix) | 0 | 2.7 x 10^-6 |
| Equal program-stream states (the 64-bit `lo ^ hi * golden` that fixes the base program and shadow: two seeds with one state draw one program) | 0 | 2.7 x 10^-6 |
| Equal seed-word octets | 0 | about 0 |
| Control: equal low 32 bits of the id / of the state | 11,759 / 11,781 | 11,641 |

The control is the known-failed shape: at 32 bits the counter sees the birthday collisions the model predicts, so a 64-bit collision would have been counted. Bound: 10^7 pairs; the 64-bit birthday bound for the chain's whole life (about 10^5 epochs a decade) is 2.7 x 10^-10 per decade. FNV-1a-64 is not collision-resistant against a chosen input, but the id's preimage is the seed words, themselves the murmur-finalised FNV of the epoch seed, so a chosen-id attack needs a preimage through that step; this lane did not attempt one, and the id is a label, not a commitment.

FINDING (interoperability): `adv3 idcheck` recomputed the two public ids from the seed words three ways. The code's derivation (`"igneum-program/" || 4_le32 || words || attempt_le32 || "sub/" || 3_le16`) reproduces both pack ids. The derivation the pack STATES in its own `program_id_derivation` field ("FNV-1a 64 over 'igneum-program/' || generator_le32 || seed_words as little-endian bytes || attempt_le32") and spec 1.4.6's text at this commit give 30956569d8f3d8d7 for Devnet 3 (pack: fce15bf61030be57) and 8aa9f185d63f269e for the kit's shared devnet pack (pack: a785001687d8688a). A worker or verifier written from the pack's own description computes a different id from the node for every generator-4 program and is refused at the id check (`packcheck.rs`, "a worker MUST refuse a pack whose class or era seed does not match"), or, if it trusts its own id, splits from the node's view of which pack is which. Not a consensus fault (the id does not enter the hash) and not an attack gain; it is a divergence source two conforming-by-the-text implementations hit at once. Fix: the `program_id_derivation` string in program.json and spec 1.4.6 should carry the suffix. Where it lives: `generator.rs` `program_id` (the suffix), `emit.rs` (the string, not read by this lane; the string is quoted from the pack).

## 6. Q4: determinism traps

### 6.1 The f64 in (c'') (`adv3 margins`, box 2, 20:06 BST, log logs/adv-accept-3/margins.log)

`distinct_ratio_pass` computes `ratio = d / (n - n^2 / 2W)` in f64 and compares `ratio < 0.98`, inside the consensus rule, while spec 1.14 item 1 says "no floating point anywhere". At n = 2^20 evaluations and the three windows the expectation E is an integer and 0.98 E is never within 0.32 of an integer:

| Window | E = n - n^2 / 2W | 0.98 E | Nearest integer | Margin (counts) | f64 compare against `50 d >= 49 E`, all 2^20 + 1 values of d | f32 compare |
|---|---|---|---|---|---|---|
| 2^28 words | 1,046,528 | 1,025,597.44 | 1,025,597 | 0.44 | 0 disagreements | 0 |
| 2^27 | 1,044,480 | 1,023,590.40 | 1,023,590 | 0.40 | 0 | 0 |
| 2^26 | 1,040,384 | 1,019,576.32 | 1,019,576 | 0.32 | 0 | 0 |

So no conforming implementation, in f64 or f32 or integers, can flip a (c'') verdict at these constants. The trap is latent: it depends on `ACCEPT_UNITS_DISTINCT_V4` and the floor staying at values where 0.98 E is not near an integer; a floor of 0.9800 at E = 1,046,528 is safe by 0.44 counts, 0.9790 by 0.21, and some floor and unit pairs sit under 0.01. The exact form `50 d >= 49 E` costs nothing and removes the dependence. BOUND.

### 6.2 The spec text against the code (measured by sweep 97)

Spec 01 section 1.4.6 at 017e7037 describes (a), (b), (c), a 5.14 percent rejection rate, a 32-attempt consensus fault and an id without a suffix. The code adds (a') with the shared-operand idiom, (c'), (c'') at 2^20 evaluations, a 256-attempt cap keyed on the class v4 shape, a total draw with the last resort, generator 4, the suffix, and executes the 256-instruction shadow block 27 times per iteration inside the acceptance interpreter (which the spec's section 1.7 does not have). An implementation written from the spec text disagrees with the node on about two thirds of attempt-0 verdicts (the (a') rate of section 1) and so on the epoch program for about two thirds of seeds; sweep 97 (`adv3 verdicts --variant spec`, 400 seeds) measures the attempt-verdict and chosen-program disagreement rates. This is the largest divergence source found and it is documentary: the public spec at the frozen commit does not describe the frozen rule.

### 6.3 Read list

| # | Where | What two implementations could do differently | Verdict |
|---|---|---|---|
| D1 | accept.rs `distinct_ratio_pass`, f64 ratio | section 6.1 | safe at these constants, latent |
| D2 | spec 1.4.6 against accept.rs and generator.rs | section 6.2 | FINDING (documentary), rate from sweep 97 |
| D3 | program.json `program_id_derivation`, spec 1.4.6 id | section 5 | FINDING (interoperability) |
| D4 | generator.rs `attempts_class` (the CLI `igneum-pow accept` command) | loops `0..MAX_ATTEMPTS` (32) and has no last resort, while the chain's `try_generate_class` loops to 256 and falls back; the diagnostic tool and the node disagree on a seed needing more than 32 attempts (0.677^32 = 3.8 x 10^-6 per seed; the code comment names one seen seed) | tool-only, not consensus |
| D5 | accept.rs `run_unit` early return on a lane-constant site; `check_dynamic` order of tests | the verdict is accept iff every test passes, so the order and the early return change only the reported reason | no divergence |
| D6 | `distinct_indices_v4` allocates 16 x 2^20 u32 (64 MiB) and sorts per site | a memory-poor verifier is slower, not different | no divergence |
| D7 | `is_class_v4_shape` keys (a'), (c'), (c''), the cap and the last resort on `shadow.instrs == 256` with the era and the rep count set aside | a rung change (other reps) keeps the rules; a class with a different shadow size silently loses them | by design, noted |
| D8 | `load_index` under an era at the rule's constant D = 28, `window` with k = min(win, 2) | matches spec 1.13.1's formula at D = 28 | no divergence |
| D9 | `below(n)` as `next() % n` | defined by spec 1.3.2 | no divergence |
| D10 | panics: `check_static` on a wrong instruction count; `generate_from_seed_bytes_class` on exhaustion for v2 and v3 | unreachable from the generator; class v4's draw is total | none on the chain path |

### 6.4 The second interpretation (sweeps 94, 98)

`adv3 verdicts --variant faithful` re-implements (a) cyclic, (b), (a') to its fixpoint with the shared-operand idiom, (c), (c') and (c'') as a per-lane scalar interpreter with its own accumulators and an integer ratio compare, from the module table of accept.rs and the spec's instruction semantics (reusing the library's `splitmix32`, `dataset_elem` and `load_index` as primitives), and compares verdict by verdict with `accept::check` on every attempt of 2,000 seeds. `--variant floor97` (300 seeds) is the known-failed shape: the floor at 0.97 must change at least one verdict against the code, or the comparison is not reading the ratio. Numbers land here.

## 7. Q5: era steering (sweep 99)

`adv3 era-steer --from 0 --count 400` lists, per era seed of this lane's label space, the stride multiplier (its popcount and NAF weight), the rotation, the interleave, and epoch 0's accepted attempt and minimum ratio under that era. The era attacker re-rolls one 32-byte value per 180 days; the stride is an odd 32-bit multiplier and the interleave four positions of 16, so the properties a chip wants (a weak stride: popcount 1, NAF weight 1 or 2) are at 2^-27 and about 2^-22 per try. Numbers land here.

## 8. Box-hours and what a longer pass would add

Spent at 20:20 BST: about 0.15 box-hours (section header). Queued: sweeps 93 and 96 (about 2 box-hours each), 94 (about 1), 95 (about 1), 97, 98, 99 (under 0.5 together). A longer pass would run the full-rule steering sweep to 10^5 seeds (10 box-hours at the lock's rate) to read the ratio tail at 10^-5 with the live f8 census on the lowest ten, and a chosen-id preimage attempt through `seed_words_from_bytes` (a 2^32-class meet in the middle on FNV-1a-64 is the published shape; the murmur finaliser is the obstacle).

## 9. Queue files (all on build-2 under /srv/builds/_adv/accept/queue/, claimed under claims/)

| File | Box | Command | State at 20:20 BST |
|---|---|---|---|
| 91-adv-accept-3-seed-steering.sh (definition) | | implemented as 93 and 96 | claimed |
| 92-adv-accept-3-program-id-determinism.sh (definition) | | implemented as `ids`, `idcheck`, `margins`, 94, 97, 98 | claimed; ids, idcheck, margins done |
| 93-adv-accept-3-steer-s00.sh | 2 | steer 0..10000 | queued (lock held by adv-cache-2) |
| 94-adv-accept-3-verdicts-faithful.sh | 1 | verdicts faithful 0..2000 | queued (lock held by adv-mixer-3) |
| 95-adv-accept-3-lastresort.sh | 1 | lastresort 0..3000 | queued |
| 96-adv-accept-3-steer-s01.sh | 2 | steer 10000..20000 | queued |
| 97-adv-accept-3-verdicts-spec.sh | 1 | verdicts spec 0..400 | queued |
| 98-adv-accept-3-verdicts-knownfailed.sh | 1 | verdicts floor97 0..300 | queued |
| 99-adv-accept-3-era-steer.sh | 1 | era-steer 0..400 | queued |