From 16d8493e0cff2af23649529fc64ed99e6b23a09c Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Tue, 22 Sep 2026 01:53:41 +0200 Subject: [PATCH] Cut 9 map: the die is not a die A Soul pass measured the thing three cuts assumed. FireControl's per-shot seed feeds CultMath's xorshift32, whose NextFloat returns the top 24 bits of the FIRST round -- and one round cannot carry ShotId's low-bit variation into the high bits. Every zone's hit roll spans 0.1249. A shot is a step function whose threshold is fixed when the zone is created: below the band it never hits, above it always does. An unaided shooter hit 0 of 18,926 shots. That is the operator's "no hits registering," and being stable per zone is why it came and went. It is this map's own prescription, written by Self in Cut 6b, and the reason it survived is that no test in the campaign measures a distribution -- every fixture uses accuracy 1 or 0, and a constant satisfies a determinism test perfectly. Also takes pOnHull collapsing to zero above Precision ~4 (no shipped hull's centre of mass is integral, so a tight sigma underflows every cell weight), and the LockWeapon crash Cut 8 did not actually fix -- that code only runs on an active entity, so the _active guard was never what would prevent it. Docking still reaches it. Co-Authored-By: Claude Opus 5 --- docs/fire-control-cut.md | 131 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 131 insertions(+) diff --git a/docs/fire-control-cut.md b/docs/fire-control-cut.md index 0dfe2f391..f1e4a3577 100644 --- a/docs/fire-control-cut.md +++ b/docs/fire-control-cut.md @@ -1566,3 +1566,134 @@ nothing leaked, but a harness whose control cannot run is defending nothing. operator check, named as such rather than assumed. - All seven harnesses clean with tree-clean PASS, controls included. - 222 tests plus the new ones; catalog reads; Unity batchmode exit 0. + +--- + +## Cut 9: the die is not a die + +Date: 2026-09-22. Branch `codex/fire-control-9` off `dcb8c448`. + +Soul pass over `ca57819d..dcb8c448` (2026-09-22). Ten findings; this cut takes the +three that block play. The rest are Cut 10. + +### 9.1 The hit roll has a range of 0.125 (Soul C1). **Blocking.** + +`FireControl.cs:356`: + + var random = new Random((zone.CombatSeed * 2654435761u) ^ (uint) shot.ShotId | 1u); + ... + var hit = p > 0f && random.NextFloat() < p; + +`CultMath.Random` is xorshift32 and `NextFloat()` returns the top 24 bits of the +**first** round (`Random.cs:22-42`). One round does not carry a low-bit seed +difference into the high bits. `ShotId` varies only in the low bits, so the top +three bits of the first draw are fixed by the zone seed alone. + +Measured, 2000 shot ids per zone: **every zone's roll spans 0.1249**. Reproduced +independently with a different hash function — the span is structural, not a +property of `StableHash`. The consequence is that a shot is a step function of +`p` whose threshold is fixed when the zone is created: below the band it never +hits, above it always does. An unaided shooter hit 0 of 18,926 shots against the +shipped catalog. Roughly one zone in eight cannot land a fully aided shot at +p = .74. + +This is the operator's "I can target and fire with no hits registering at all," +and it is stable per zone, which is why it came and went. + +It is also this map's own prescription (Cut 6b, §6.1), written by Self, shipped +through three cuts, and never once measured. + +**The rule:** the roll must be uniform on [0,1). Not merely deterministic — +determinism is what a constant already gives, and is exactly why three +determinism tests passed over it. + +- Mix the seed before the first draw, with a standard 32-bit finalizer + (`fmix32`/`splitmix32`: xor-shift, multiply, xor-shift, multiply, xor-shift). + The per-shot seed derivation is unchanged; only its diffusion into the first + output changes. Determinism, the `(zone, shot id)` purity and the freeze + discipline all survive untouched. +- **This is a caller's obligation, not a CultMath defect.** Seeding xorshift with + a structured value and drawing once is the documented way to get a correlated + first output. Record a follow-up to give `CultMath.Random` a mixed-seed entry + point so no other GameCult consumer re-derives this the hard way — that is a + CultLib cut with its own release, not this one. + +**Verification, and the test whose absence caused this:** + +- `TheDieIsUniform`: fire many shots across several zone seeds at an + intermediate `p` (say .3 and .6) and assert the observed hit fraction is near + `p`, and that the observed rolls span substantially more than 0.2. Mutation: + remove the finalizer. Must die. +- No test anywhere in this campaign measures a distribution. Every behavioural + fixture uses `accuracy: 1` or `accuracy: 0`, which is why a die stuck on one + face satisfied all of them. That gap is the finding, not the line of code. + +### 9.2 `pOnHull` collapses to zero above Precision ~4 (Soul C2). **Blocking.** + +`FireControl.cs:497-516`. `Sigma = 1/Precision`, and once sigma falls below about +half a cell every `exp(-d²/2σ²)` underflows against an aim point that is not +exactly on a cell centre — which is **every shipped hull**, since no centre of +mass is integral (LonginusX 2.5/6.697, Zenith 5.5/5.5, Turret 3.5/3.5). Measured +`pOnHull` on LonginusX: `.516` at Precision .3, `1.000` at 1.19, `.112` at 5, +`.000` at 10 and beyond. + +So a better targeting system makes you miss, and past Precision ≈ 5 the weapon +cannot hit anything. Authored content sits at .5-1.3, just under the cliff, with +a margin of about 4x — and the operator is about to tune this number. + +- Clamp sigma at a floor of about half a cell, or normalize by the discrete sum + rather than the continuous 2πσ². Either makes `pOnHull` monotonic in Precision + over the whole domain instead of only below the cliff. +- `WeightedPick` (`:535-545`) carries a comment claiming it "can never fall + through." It can, whenever `totalWeight == 0`, returning a fixed corner cell. + It is unreachable today only because `pOnHull == 0` forces `PBase == 0` first. + Fix the cause and delete the false comment. +- Cut 6d's map section claims to name its consequences; it does not name this. + Add it. + +### 9.3 The LockWeapon crash is still reachable (Soul C3). **High.** + +Cut 8 fixed a real liveness defect and did **not** fix the operator's crash. +`LockWeapon.cs:98` only runs on an *active* entity, so 8.2's `!_active` guard +cannot be what prevents it — `tests/mutation_tests_fire_control_cut8.sh:17-19` +says as much outright, and I merged it anyway. + +The live precondition is `Target.Value` set but absent from `EntityInfoGathered` +on an active entity, and docking still reaches it: `Deactivate` (`Entity.cs:445`) +disposes the `Entities.ObserveRemove` subscription that is the only thing nulling +a stale `Target`, and nulls nothing itself; `Activate` (`Entity.cs:167`) reseeds +`EntityInfoGathered` and likewise leaves `Target` alone. Dock, let the target die +or leave, undock, and the first frame throws. + +- `Deactivate` nulls `Target` (and `TargetItem`), or `Activate` reconciles it + against the reseeded `EntityInfoGathered`. One of the two owns it; say which. +- Still not a `TryGetValue` in `LockWeapon`. The invariant is that an active + entity's `Target` is always a live entity it has info on. +- Pin it with the dock/die/undock sequence, not with a unit test on the guard. + +### Verification + +- The three tests above, each dying under its own mutation, in a committed + `tests/mutation_tests_fire_control_cut9.sh` with a no-op control, byte-exact + I/O, sha256-verified restore and an explicit tree-clean verdict. +- All nine harnesses sequentially, one at a time, all clean. +- 226 tests plus the new ones; catalog reads; `dangling` 0. +- After 9.1 lands, re-measure the fight: Soul's probe, run with a corrected die, + gave 60.8% hit rate and a 4.3 s median time to kill for an aided shooter, 2.6% + unaided. Confirm the shipped build now reproduces that, because those are the + numbers the operator will tune against. + +### Recorded for Cut 10, not fixed here + +Soul C4 (a committed hit on a target that dies mid-flight publishes as a hit), +C5 (`Inspect` is numerically exact but costs 9.87 µs and 448 B per call on paths +that used to bail — the operator's own comment on the hot path looking like a +diagnostic one has an empirical answer now), C6 (`RollsAreSeeded` is obsolete — +Cut 7 retired one such test and missed this one), C7 (`FireControlCut6cTests` +authors `Precision = 0`, making six of seven checks vacuous), C8 (`Precision = +1000` fixtures make several kernel-shape mutants unkillable, and `pOnHull`'s +deletion is caught by exactly one test), C9 (`EveryHitLandsOnMetal` runs one +configuration, not the range it claims), plus the harness-audit items: the +tree-clean verdict restores before it measures, a red result cannot distinguish a +killed mutant from a compile failure, and the no-op control covers only one file +per harness.