GH-217: CC default rules + tiebreak, sparse rows and -cc-roworder=auto (Tier 1 floor: PI decision)

MODIFICATIONS.md

@@ -42,7 +42,7 @@ Optional engine, off by default (PI 2026-10-16): enable with `-engine=cc` (or `-
 
 | File | Description |
 |------|-------------|
-| `cc_half.h`, `cc_half.cc` | Exact connected-cluster (CC) level search for one CSS half (Dumer, Kovalev, Pryadko 2017): clusters grown from a seed along one odd parity row at a time; syndrome-free clusters below the level are dead ends (a nontrivial one is reported as an inconsistency); rules `excl` (sibling exclusion), `pack` (disjoint odd-row packing bound), `orbf` (orbit seeds from the GH-85 verified per-half orbits, replacing the index rule), `mrv` (fewest-candidate branching), `parity` (GH-133: odd levels skipped on a half whose column weights are all odd; per-node parity check), `leaf` (GH-133: Zobrist hash from column to qubit; the closing qubit is looked up at budget 1, and at budget 2 each candidate is completed by one lookup), `overlap` (GH-138: a minimum logical meets every same-type stabilizer row g in at most floor(\|g\|/2) qubits; incremental counters, the rest of a tight row is forbidden); uint64 bitsets with an incremental syndrome; `-cc-seed` relabeling; test-only mutants 1-3 (1 forbidden set not restored, 2 packing prune `>=`, 3 orbit seed rule off by one) and 5-7 (5 parity forced on a half with an even column weight, 6 leaf budget off by one, 7 leaf closure without the detector check) and 8-10 (GH-138: 8 overlap limit off by one, 9 parity checks used as stabilizer rows, 10 even-weight tie cut); GH-157 (default rule since 2026-10-29): `charge` (raised local-degree LP-dual charge node lower bound, exact integers), evaluation gates `-cc-lb-minr`, `-cc-lb-gap`, `-cc-lb-auto`, `-cc-lb-raise`, mutant 15 (charge inflated); `tiebreak` (GH-162, opt-in, needs `overlap`: the even-weight tie \|e & g\| = \|g\|/2 is cut unless first(g) is in e, in a per-seed qubit order that puts the seed first; the first(g) tie-break idea of Qubitserf 04b9349, S. Cercelescu, MIT, re-derived from the mathematics, no code copied) with test-only mutants 17 (naive tie cut through the tiebreak path) and 18 (order without the seed first); `-cc-roworder=index|bfs` (GH-183, default index: the internal row order, i.e. the packing scan order and the `mrv` tie-break, is a reversed BFS over the Tanner graph from the rows of the first seed; a row relabeling; the reversed-BFS row ordering idea of Qubitserf 04b9349, S. Cercelescu, MIT, re-implemented, no code copied) and `-cc-tbbase=desc|asc` (GH-183, test variant of the tiebreak base order) with test-only mutants 19 (the bfs order drops a row) and 20 (no BFS restart); `-cc-roworder=auto` (GH-206, driver: a per-half probe between the index order without `mrv` and the bfs order with `mrv`, test-only mutant 21); GH-181 opt-in rules `sparse`, `sparseov`, `sparsemrv` (redundant pair-sum rows in pack / overlap / branching) and `xorunit` (unit propagation), mutants 22-24 (19-21 on the GH-181 branch); `erasure` (GH-195, opt-in, needs `pack`: with extra = (w - \|S\|) - p <= 2 a node is cut when no syndrome-free detected completion lies in the packed rows' free candidates plus at most extra further free qubits; peeling + dense elimination with exact back-substitution, single/pair lookups; tests start after the first level with >= `-cc-erasure-start` nodes; the erasure bound idea of Qubitserf 04b9349, S. Cercelescu, MIT, re-derived, no code copied) with test-only mutants 25 (bound weakened by one) and 26 (fixed support ignored). |
+| `cc_half.h`, `cc_half.cc` | Exact connected-cluster (CC) level search for one CSS half (Dumer, Kovalev, Pryadko 2017): clusters grown from a seed along one odd parity row at a time; syndrome-free clusters below the level are dead ends (a nontrivial one is reported as an inconsistency); rules `excl` (sibling exclusion), `pack` (disjoint odd-row packing bound), `orbf` (orbit seeds from the GH-85 verified per-half orbits, replacing the index rule), `mrv` (fewest-candidate branching), `parity` (GH-133: odd levels skipped on a half whose column weights are all odd; per-node parity check), `leaf` (GH-133: Zobrist hash from column to qubit; the closing qubit is looked up at budget 1, and at budget 2 each candidate is completed by one lookup), `overlap` (GH-138: a minimum logical meets every same-type stabilizer row g in at most floor(\|g\|/2) qubits; incremental counters, the rest of a tight row is forbidden); uint64 bitsets with an incremental syndrome; `-cc-seed` relabeling; test-only mutants 1-3 (1 forbidden set not restored, 2 packing prune `>=`, 3 orbit seed rule off by one) and 5-7 (5 parity forced on a half with an even column weight, 6 leaf budget off by one, 7 leaf closure without the detector check) and 8-10 (GH-138: 8 overlap limit off by one, 9 parity checks used as stabilizer rows, 10 even-weight tie cut); GH-157 (default rule since 2026-10-29): `charge` (raised local-degree LP-dual charge node lower bound, exact integers), evaluation gates `-cc-lb-minr`, `-cc-lb-gap`, `-cc-lb-auto`, `-cc-lb-raise`, mutant 15 (charge inflated); `tiebreak` (GH-162, default since GH-217, needs `overlap`: the even-weight tie \|e & g\| = \|g\|/2 is cut unless first(g) is in e, in a per-seed qubit order that puts the seed first; the first(g) tie-break idea of Qubitserf 04b9349, S. Cercelescu, MIT, re-derived from the mathematics, no code copied) with test-only mutants 17 (naive tie cut through the tiebreak path) and 18 (order without the seed first); `-cc-roworder=index|bfs` (GH-183, default index: the internal row order, i.e. the packing scan order and the `mrv` tie-break, is a reversed BFS over the Tanner graph from the rows of the first seed; a row relabeling; the reversed-BFS row ordering idea of Qubitserf 04b9349, S. Cercelescu, MIT, re-implemented, no code copied) and `-cc-tbbase=desc|asc` (GH-183, test variant of the tiebreak base order) with test-only mutants 19 (the bfs order drops a row) and 20 (no BFS restart); `-cc-roworder=auto` (GH-206, driver: a per-half probe between the index order without `mrv` and the bfs order with `mrv`, test-only mutant 21); GH-181 rules `sparse`, `sparseov`, `sparsemrv` (redundant pair-sum rows in pack / overlap / branching; default since GH-217) and `xorunit` (unit propagation), mutants 22-24 (19-21 on the GH-181 branch); `erasure` (GH-195, opt-in, needs `pack`: with extra = (w - \|S\|) - p <= 2 a node is cut when no syndrome-free detected completion lies in the packed rows' free candidates plus at most extra further free qubits; peeling + dense elimination with exact back-substitution, single/pair lookups; tests start after the first level with >= `-cc-erasure-start` nodes; the erasure bound idea of Qubitserf 04b9349, S. Cercelescu, MIT, re-derived, no code copied) with test-only mutants 25 (bound weakened by one) and 26 (fixed support ignored). |
 | `cc_ubsearch.h`, `cc_ubsearch.cc` (GH-140, GH-146) | Randomized low-weight logical finder for one CSS half (`-ub-search`): random information sets (random column order, Gauss-Jordan elimination of H with pivots in that order, systematic kernel basis), words of 1-2 (optionally 3) systematic basis vectors below a weight threshold, detector check (G c != 0), greedy local improvement by same-type stabilizer rows; deterministic per seed; test mutant 11 (no detector check and no improvement). GH-146 collision mode (`-ub-isd`): Stern / Dumer collision step with Canteaut-Chabaud pivot swaps (`cc_swap`, `isd_round`, `iterate_isd`), parser `parse_isd`. |
 | `cc_aut.h`, `cc_aut.cc` (GH-152) | Candidate automorphisms for `-cc-aut=on`: colour refinement to the coarsest equitable partition of the coloured Tanner graph (qubits, rows of each class), individualisation of one vertex and lockstep refinement of a source and a target partition (McKay 1981, written from the published description), backtracking over the first non-singleton cell, edge-checked vertex maps; orbit computation by union-find from the first vertex of the smallest qubit cell (complete when that vertex's point stabiliser is trivial), one class-exchanging (swap) map; deterministic work counters. Candidates only: every map is GF(2)-verified by the wrapper before use. |
 | `cc_driver.h`, `cc_driver.cc` | Driver: start-up detector check (rank[H;G] + rank S = n and commutation), both halves interleaved level by level (cheaper half first) or one half under a verified XZ-dual map, stop rule (a hit at level w ends the run once the other half's lower bound is >= w), anytime `TRY`/`LB`/`UB`/`RESULT` lines, witness verification (H e = 0, independent GF(2) rank test against the same-type stabilizers, dual image check), its own check of the XZ-dual map (pi(rs Hz) = rs Hx and pi(rs Hx) = rs Hz), always-on traps (`RESULT -1 TRAP`, never a value; earlier bounds withdrawn), optional `-ub-basis`, `-cc-trace`, `-cc-stats`; test-only sequential schedule (`-cc-schedule=sequential`) and driver mutant 4 (stop rule without the other half's lower bound, run under the sequential schedule). |
@@ -362,7 +362,7 @@ stopped driver runs. Mutant 14 (the swap map, or the identity when none was foun
 must give wrong or stopped driver runs. `make test-cc-flags`: values, conflicts, `-v` lines (also without the flag, the default), no output with `-cc-aut=off`.
 *Evidence.* `optimization/experiments/GH-152/REPORT.md`.
 
-GH-162 (`tiebreak` in `-cc-rules`, default off; acts only together with `overlap`; `src/cc/cc_half.{h,cc}`, token
+GH-162 (`tiebreak` in `-cc-rules`, default off until GH-217, default on since; acts only together with `overlap`; `src/cc/cc_half.{h,cc}`, token
 parsing in `cc_driver.cc`). *Credit.* The first(g) tie-break idea (cut the tie |e & g| = |g|/2 unless the first qubit
 of g lies in e, justified by a lexicographically least minimum element) is from Qubitserf (github.com/Quantinuum/Qubitserf,
 commit 04b9349, S. Cercelescu, MIT). Implemented from the mathematics below; no Qubitserf code was copied. The per-seed
@@ -441,7 +441,7 @@ whole even row, no exemption; it removes both e and e + g). 18: no seed-first ex
 the `-cc-stats` node counts per level (and `ovtight`/`ovforbid`) against the same run without the token.
 *Evidence.* `optimization/experiments/GH-162/REPORT.md`.
 
-GH-183 (`-cc-roworder=index|bfs`, default `index`; `-cc-tbbase=desc|asc`, default `desc`; `src/cc/cc_half.{h,cc}`). The
+GH-183 (`-cc-roworder=index|bfs`, default `index` until GH-217 (`auto` since); `-cc-tbbase=desc|asc`, default `desc`; `src/cc/cc_half.{h,cc}`). The
 reversed-BFS row ordering idea is from Qubitserf (github.com/Quantinuum/Qubitserf, commit 04b9349, S. Cercelescu, MIT);
 implemented from its description, no Qubitserf code was copied. *What it changes.* Each half search gives the nonempty
 rows of H internal indices. With `index` they keep the input order (after the `-cc-seed` relabeling). With `bfs` the
@@ -488,7 +488,7 @@ with a probe after every refuted level that always switches (A and B alternate)
 ABORTED probe is taken as a refuted level; it must give wrong answers. `make test-cc-flags`: values, `-v` / `-cc-stats`
 probe lines. *Evidence.* `optimization/experiments/GH-206/`.
 
-GH-181 (`sparse`, `sparseov`, `sparsemrv`, `xorunit` in `-cc-rules`, all default off; `src/cc/cc_half.{h,cc}`, token parsing
+GH-181 (`sparse`, `sparseov`, `sparsemrv`, `xorunit` in `-cc-rules`, all default off until GH-217; `sparse`, `sparseov`, `sparsemrv` default on since; `src/cc/cc_half.{h,cc}`, token parsing
 and `-v` / `-cc-stats` lines in `cc_driver.cc`). *Credit.* Redundant pair-XOR checks: Qubitserf
 (github.com/Quantinuum/Qubitserf, commit 04b9349, `augment_sparse_checks`, S. Cercelescu, MIT; idea only, no code was read
 into or copied into DistQLDPC); the classical precursor is the forbidden-set inequality from redundant parity checks of
@@ -609,6 +609,21 @@ enumerated, with the gate admitting extra <= 3). 26: the fixed support S ignored
 *Statistics.* With the token, `-v` prints `c cc: X half erasure: on (...)` and `-cc-stats` prints per level
 `erasure calls C prune P giveup G`. *Evidence.* `optimization/experiments/GH-195/REPORT.md`.
 
+GH-217 (CC default flip; `src/cc/cc_half.h` `Rules()` and `src/cc/cc_driver.h` `DriverOptions()`, help text). The CC
+default rules become `excl,pack,orbf,parity,leaf,overlap,charge,tiebreak,sparse,sparseov,sparsemrv` (GH-157 set plus
+GH-162 `tiebreak` and GH-181 `sparse`, `sparseov`, `sparsemrv`; `xorunit` and `mrv` stay opt-in) and the default row
+order becomes `-cc-roworder=auto` (GH-206 per-half probe between the index order without `mrv` and the reversed-BFS order
+with `mrv`). No search code changed: each component's soundness argument is the one above (GH-162, GH-181 and its
+combination paragraph, GH-183, GH-206), and every combination is already exercised against enumeration by Parts B, H, R,
+T and X. `-cc-rules=excl,pack,orbf,parity,leaf,overlap,charge -cc-roworder=index` reproduces the previous CC default byte
+for byte (identity verified on tier0+1), and the MaxSAT default path is unchanged. The `-cc-trace` header now names
+`auto` instead of `index` for `-cc-roworder=auto`. Credits as for the components (Qubitserf 04b9349, S. Cercelescu, MIT:
+first(g) tie-break, reversed-BFS row order, redundant pair-XOR checks; Puchert and Tillmann). *Tests.* `make test-cc`
+checks the new defaults (`DriverOptions()`, `Rules()`) and that the old list still parses to the old set; the driver
+runs that keep the default options (sequential schedule, mutant 4, Parts E/F) now run the new default against
+enumeration. `make test-cc-flags` 7k: default `-v` lines (rules, tiebreak, sparse, auto row order), and no such line with
+the old-default flags. *Evidence.* `optimization/experiments/GH-217/`.
+
 GH-148 (`-stab-overlap=off|on|auto`, split MaxSAT path, `src/core/distqldpc.cc`; default `auto` since the PI's adoption decision, `off` = the previous search). *What it adds.* Extra
 hard constraints in the half instance of `build_css_half`: for each verified row g, |x & g| <= floor(|g|/2). *Why every
 probe answer stays the same.* The half instance is F_h = {x : Hpar x = 0, Glog x != 0} (see GH-144 (1)). Each used