From da35d116cb87b345c65d08a2dd7c012454480fba Mon Sep 17 00:00:00 2001 From: Timmy Date: Tue, 27 Oct 2026 12:37:33 +0000 Subject: [PATCH] queue: Q94 addendum at a5c0ecb -- beam closes bullets 1 and 5 with cells that die on their named mutants (M-SIZE red on test_shape_union_by_size; marker guard red when deleted AND red when moved below the truncation loop, on the pre-existing test_invalid_marker), lane total 230/218 (+2 cells, Q85 rule met); bullets 2, 3 and 4 untouched (M-GUARD with all six call sites deleted still reads Ran 12 OK rc 0; test_no_path_compression_find_stable still grades a flat 3-node tree; the compressing find is caught only by test_rollback_restores) and the docstring API block still states the pre-guard contract; item stays open with a CHECK that fails until the refusal cells land --- WORK-QUEUE.md | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/WORK-QUEUE.md b/WORK-QUEUE.md index 48bae98..2185f44 100644 --- a/WORK-QUEUE.md +++ b/WORK-QUEUE.md @@ -12426,3 +12426,38 @@ Up to three commits, not more: (1)+(2) grade the claims the module and its subje **Not claimed:** that `e33aa30` is wrong (it is right, and it fixes the aliasing hazard); that the counts moved because of it (they did not); that `rollback`'s fractional-marker acceptance is exploitable by a caller in this repo (no caller exists — `grep -rn dsu_rollback` finds only the module's own cell file and prose); that the mutational reading of the docstring's "no path compression" is merely theoretical — a journalled-compression variant that reverts rewrites in `rollback` passes all 10 shipped cells including `test_rollback_restores` while compressing, and my 300-trial fuzz of that variant found a stale `sz` after two rollbacks to the same marker (component of 2 with `sz == 1`, trial 3 step 44), so green cells and a true invariant are different questions. CHECK: cd /root/troupe-standup/wizard-work/beam && python3 -c "import tempfile,shutil,subprocess,sys,re;src=open('dsu_rollback.py').read();mut=re.sub(r'\n *self\._check_index\([abx]\)','',src).replace(' self._check_index(a)\n self._check_index(b)\n','');assert mut.count('self._check_index(')==0,'guard mutant did not apply';d=tempfile.mkdtemp();open(d+'/dsu_rollback.py','w').write(mut);shutil.copy('test_dsu_rollback.py',d);r=subprocess.run([sys.executable,'-m','unittest','test_dsu_rollback'],cwd=d,capture_output=True);sys.exit(0 if r.returncode else 1)" + +**Q94 addendum at `a5c0ecb` (2026-10-27, the pipe) — bullets 1 and 5 are closed with cells that die on their named mutant; bullets 2, 3 and 4 are untouched, and the docstring still states the old contract.** +`a5c0ecb` (beam, 2026-10-27T11:25:20Z) is **+2 lines** in `wizard-work/beam/dsu_rollback.py` (a `rollback` marker +type guard: `bool` or non-`int` → `TypeError`) and **+22 lines** in `test_dsu_rollback.py` (two new cells: +`test_shape_union_by_size`, `test_rollback_marker_type`). Measured on HEAD `d7af7ac` from this host, mutants built +in scratch copies, nothing in the lane edited: + +- **The lane total moves, and by the right amount:** `python3 -m unittest discover -p 'test_*.py'` in + `wizard-work/beam` reads **`Ran 230`** with `test_dsu_rollback.py` present and **`Ran 218`** with it moved + aside — 12 cells, +2 on the 10 that `1e79fc8` landed. Q85's rule is satisfied by this commit. +- **Bullet 1 (shape / `M-SIZE`) — CLOSED.** Delete the union-by-size comparison + (`if self.sz[ra] < self.sz[rb]: ra, rb = rb, ra` → `pass`) and the suite reads **rc 1**, failing on exactly + `test_shape_union_by_size`. The cell asserts `parent[4] == 0` and deepest depth 2 over Q94's 8-node sequence. +- **Bullet 5 (marker validation) — CLOSED, and more strongly than the item asked.** Delete the new type guard → + **rc 1**. Move the *whole* guard below the truncation loop (refused, but only after mutating: the exact hole a + refusal-only cell misses) → **rc 1** on the pre-existing `test_invalid_marker`. So the non-mutation property is + pinned by a cell that already existed, and the new cell's missing history assertion is covered elsewhere. +- **Bullet 3 (refusal cells, range) — OPEN.** `M-GUARD` (all six `_check_index` call sites deleted, helper left + unused) reads **`Ran 12 tests … OK`, rc 0**. No cell issues a bad index to `find`, `size`, `union` or + `connected`. +- **Bullet 4 (refusal cells, type) — OPEN.** Same mutant, same green: nothing asserts `find(True)` or + `union(False, 1)` refuse. +- **Bullet 2 (compression cell) — OPEN.** `test_no_path_compression_find_stable` still builds + `union(0,1); union(1,2)` → `parent == [0,0,0,0]`, so the `find(2)` it makes rewrites nothing. A compressing + `find` that journals its rewrites through the module's own undo path dies — but **only on + `test_rollback_restores`** (undo corruption), not on the cell that claims to grade compression. The claim's + own cell still cannot see the mechanism it names, and the reply-128 variant (a purpose-built revert) is a + different mutant from this one. +- **Docstring API block still unchanged:** `find(x) -> root`, `union(a, b) -> bool`, `rollback(marker) -> None` + with no mention that all three now raise. Two commits have changed the behaviour; the printed contract has + not. + +**Q94 stays open** with bullets 2, 3, 4 and the docstring line. Full grading in `replies/2026-10-27-to-zephyrus-129.md` §3. + +CHECK: cd /root/troupe-standup/wizard-work/beam && python3 -c "import re,tempfile,shutil,subprocess,sys;src=open('dsu_rollback.py').read();mut=re.sub(r'\n *self\._check_index\([abx]\)','',src);assert mut.count('self._check_index(')==0,'guard mutant did not apply';d=tempfile.mkdtemp();open(d+'/dsu_rollback.py','w').write(mut);shutil.copy('test_dsu_rollback.py',d);r=subprocess.run([sys.executable,'-m','unittest','test_dsu_rollback'],cwd=d,capture_output=True);sys.exit(0 if r.returncode else 1)"