diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index a9641976f3..9282beafbd 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -613,6 +613,8 @@ Selected progression: Jeremy Kothe and Rohan Arun; T16 controller: Hao Yan. Inde
 
 The [92-PR review](docs/research/community-reconciliation92-review.md) records individual contributions, replays, limitations and retained source trees. This includes parallel improvements, formal arithmetic, reproducibility tools and negative research; credit does not imply every historical claim was accepted.
 
+**Divjot Singh Manchanda (@djsmanchanda)** supplied [#99's nondegenerate readout saturation](https://github.com/CrocSwap/integer-mult-bounds/pull/99), retained in **Rohan Arun's [#103 signed/balanced integration](https://github.com/CrocSwap/integer-mult-bounds/pull/103)**. The [source-retention receipt](research/pr99-retention-seed99/README.md) authenticates all 46 original files and reconciles the saved 177,100-singleton profile reduction. This preserves individual mechanism credit without changing historical review dispositions or claiming a fresh physical replay.
+
 - **DaysSky (@DaysSky)**: [#162](https://github.com/CrocSwap/integer-mult-bounds/pull/162).
 - **Dominik Scholz (@DominikScholz)**: [#22](https://github.com/CrocSwap/integer-mult-bounds/pull/22), [#27](https://github.com/CrocSwap/integer-mult-bounds/pull/27), [#33](https://github.com/CrocSwap/integer-mult-bounds/pull/33), [#35](https://github.com/CrocSwap/integer-mult-bounds/pull/35), [#38](https://github.com/CrocSwap/integer-mult-bounds/pull/38), [#63](https://github.com/CrocSwap/integer-mult-bounds/pull/63), [#68](https://github.com/CrocSwap/integer-mult-bounds/pull/68), [#81](https://github.com/CrocSwap/integer-mult-bounds/pull/81).
 - **Joel Pulikkan (@GamingPuzzled)**: [#125](https://github.com/CrocSwap/integer-mult-bounds/pull/125).
diff --git a/research/pr99-retention-seed99/README.md b/research/pr99-retention-seed99/README.md
new file mode 100644
index 0000000000..1c238720bf
--- /dev/null
+++ b/research/pr99-retention-seed99/README.md
@@ -0,0 +1,127 @@
+# PR99 source retention through PR103
+
+**Research consolidation; no new kappa.** All 46 files introduced by Divjot
+Singh Manchanda's PR99 survive unchanged in Rohan Arun's incorporated PR103.
+Both complete package trees are `6bebd79406bb2453ada2b7761aece13d3e53b694`.
+The offline proof authenticates paths, modes, blob identities and the complete
+original commit difference, rather than relying on a matching title or README.
+
+At base `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`, the
+[ledger](../../docs/research/pr-ledger.json) gives PR99 no integration location
+and records only earlier source-inventory triage. PR103's retained README says
+the whole PR99 package was vendored unchanged. This receipt establishes that
+link and restores the missing individual credit in
+[CONTRIBUTORS.md](../../CONTRIBUTORS.md). It does not change ledger dispositions
+or convert source retention into mathematical approval. Live GitHub metadata
+at entry already reported both PRs closed; no PR was closed by this work.
+
+## Exact sources and coverage
+
+| Role | Commit and path |
+|---|---|
+| PR99 source | `0622dcce6a897567e4eb6bdfedc7def66ab21346:research/nondegenerate-readout-saturation` |
+| Original comparison parent | `56b66d58297deca1d7dd130247d720e960f77a37` |
+| PR103 retained copy | `75ab1f70d146c21c7611ce0df9eb5f645f51ac0e:research/saturated-balanced/vendor/pr99` |
+| Published source archive | `b91de239a64d24d8aee409a0f4ac3e00710ae5c1`, tag `archive/pr-reconciliation100-20261013` |
+
+[SOURCE-PROOF.json](SOURCE-PROOF.json) contains 32 raw Git objects: four commits,
+the necessary trees, and five evidence blobs. Its authenticated commit difference
+is exactly 46 additions, zero modifications and zero deletions. PR103 is a direct
+parent of the archive commit, whose identity and parent list are checked against
+the retained archive receipt. The historical PR103 review is bound to its exact
+head. Git content identity assumes collision resistance of Git SHA-1; it does
+not authenticate signatures or establish authorship. The optional collector
+also compares every original and retained file's bytes using Git directly.
+
+The standalone checker imports no predecessor implementation. It reconciles
+four authenticated saved reports: the baseline histogram, PR99's candidate and
+frame-extension list, PR99's historical component-delta review, and PR103's
+integrated histogram. The extension counts are six `12->13`, three `12->14`,
+and thirteen `13->14`: 22 frames and 25 added dimensions. With `v=1771`, their
+recorded merger accounting is
+
+```text
+3542 * [6*(H509-H507-2*H1) + 13*(H511-H509-2*H1)
+        + 3*(H511-H507-4*H1)]
+= -177100*H1 - 31878*H507 - 24794*H509 + 56672*H511.
+```
+
+Here `Hr` denotes one child of rank `r`. The independently subtracted saved
+histograms give precisely this vector. Its rank-weighted mass is zero; both
+profiles have recursive rank `57,403,754,177`, width `108,516,254` and `28,866`
+auxiliary roles. PR103's complete saved histogram equals PR99's candidate.
+The checker verifies these identities, not the legality of the original frame
+extensions or a newly executed circuit. Full physical, native, moment, all-size,
+compiler, routing, precision/recovery and analytic obligations remain inherited.
+No full multiplication theorem or new selected-frontier replay is claimed.
+
+## Reproduce
+
+From the repository root, using Python 3.12 and its standard library:
+
+```sh
+python3.12 scripts/research_package.py --package research/pr99-retention-seed99
+```
+
+This runs the read-only checker and 18 tests: one positive case and 17 failure
+controls. Expected output includes:
+
+```text
+PASS_PR99_RETENTION_AND_SAVED_ACCOUNTING files=46 singleton_delta=-177100 mass_delta=0
+Ran 18 tests
+OK
+PASS_REGISTERED_RESEARCH_PACKAGE research/pr99-retention-seed99 outcome=completed
+```
+
+Controls cover missing files and trees, same-count path substitution, file modes,
+corrupt commits and accounting blobs, missing archive ancestry, wrong review
+heads, duplicate JSON/ranks/slots, a missing double extension, changed width,
+omitted component charges, a mass-preserving wrong profile, and substitution of
+the unsaturated histogram into PR103. Explicit checks also run under `python -O`.
+
+The direct `python3 -I -O -B research/pr99-retention-seed99/verify.py` command
+needs neither Git nor network access, only this package and the two immutable
+review inputs listed in [VERIFY.json](VERIFY.json). The registered metadata
+check additionally uses Git history for the provenance in [SOURCES.json](SOURCES.json).
+[RESULT.json](RESULT.json) is compared against recomputation on every default run.
+
+To recollect the proof from locally available pinned Git objects, run
+`python3 -I -B research/pr99-retention-seed99/collect.py --output /tmp/pr99-proof.json`
+and compare it with `SOURCE-PROOF.json`. The collector documents the fetches
+needed if those objects are absent; it never fetches or runs archived code itself.
+
+## Task and overlap
+
+OS-random seed **99**, consolidation track; task `overlap-receipt`, refined to
+PR99 through PR103. The seed selects the older PR99 object. PR279 source closure
+and stale current-result routing were rejected as candidate tasks because
+PR1190 and PR1232/1285 already address them. This receipt uses a similar Git
+object authentication method to Adam Gall's PR1190, on a distinct source tree;
+no code or proof data from that pending PR is imported. Rohan Arun's PR103 and
+the maintainer reconciliation are the retention and review predecessors.
+Full overlap-search coverage and limitations are recorded in [TASK.json](TASK.json).
+The [coordination claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18912011)
+was posted before implementation. No search for a better circuit was performed.
+
+## Open next questions
+
+No further retention experiment is justified by this receipt: the complete
+original change is accounted for. This does not settle whether every original
+mathematical obligation has received sufficient review. That question remains
+outside this source-retention result; neither the ledger's historical disposition
+nor the selected frontier is changed.
+
+## Credit
+
+Divjot Singh Manchanda (@djsmanchanda) supplied PR99's nondegenerate readout
+saturation. Rohan Arun (@rohanarun) supplied PR103's signed/balanced integration;
+Zhihao Chen (@jacklightChen), Swapnil Jain and the original notices retain the
+upstream mathematical and implementation credit. Douglas Colkitt and the
+maintainer reconciliation retained the historical source and review records.
+The original [UPSTREAM-NOTICE](UPSTREAM-NOTICE) is preserved byte for byte.
+
+Prepared for Hanson Sun (@bbMisk), with substantial OpenAI Codex assistance in
+source investigation, implementation, verification and writing. These checks
+are independently implemented relative to the historical code, not independent
+human peer review. New work is Apache-2.0; predecessor licenses remain in their
+unchanged original package.
diff --git a/research/pr99-retention-seed99/RESULT.json b/research/pr99-retention-seed99/RESULT.json
new file mode 100644
index 0000000000..16fe693d55
--- /dev/null
+++ b/research/pr99-retention-seed99/RESULT.json
@@ -0,0 +1,38 @@
+{
+  "status": "PASS_PR99_RETENTION_AND_SAVED_ACCOUNTING",
+  "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f",
+  "original_head": "0622dcce6a897567e4eb6bdfedc7def66ab21346",
+  "retained_head": "75ab1f70d146c21c7611ce0df9eb5f645f51ac0e",
+  "archive_commit": "b91de239a64d24d8aee409a0f4ac3e00710ae5c1",
+  "common_package_tree": "6bebd79406bb2453ada2b7761aece13d3e53b694",
+  "retained_files": 46,
+  "original_changes": {
+    "added": 46,
+    "modified": 0,
+    "deleted": 0
+  },
+  "authenticated_git_objects": 32,
+  "accounting": {
+    "changed_frames": 22,
+    "dimension_increase": 25,
+    "frame_extension_counts": {
+      "12->13": 6,
+      "12->14": 3,
+      "13->14": 13
+    },
+    "histogram_delta": {
+      "1": -177100,
+      "507": -31878,
+      "509": -24794,
+      "511": 56672
+    },
+    "rank_mass_delta": 0,
+    "recursive_rank": 57403754177,
+    "width": 108516254,
+    "auxiliary_roles": 28866,
+    "pr103_saved_histogram_matches": true
+  },
+  "fresh_physical_replay": false,
+  "new_kappa_claim": false,
+  "scope": "Complete historical source retention and saved-report accounting; no new construction acceptance."
+}
diff --git a/research/pr99-retention-seed99/SOURCE-PROOF.json b/research/pr99-retention-seed99/SOURCE-PROOF.json
new file mode 100644
index 0000000000..37f372bb0f
--- /dev/null
+++ b/research/pr99-retention-seed99/SOURCE-PROOF.json
@@ -0,0 +1,319 @@
+{
+  "schema_version": 1,
+  "objects": {
+    "0622dcce6a897567e4eb6bdfedc7def66ab21346": {
+      "type": "commit",
+      "base64": "dHJlZSAyYzU4M2Y2ZThmMmUzMGE2ZTVhODA5Zjk0ZjRjNTZhODRlZTEzMzM4CnBhcmVudCA1NmI2NmQ1ODI5N2RlY2ExZDdkZDEzMDI0N2Q3MjBlOTYwZjc3YTM3CmF1dGhvciBEaXZqb3QgU2luZ2ggTWFuY2hhbmRhIDw2ODgwODg0OCtkanNtYW5jaGFuZGFAdXNlcnMubm9yZXBseS5naXRodWIuY29tPiAxNzkxNTAwMDg4ICswNTMwCmNvbW1pdHRlciBEaXZqb3QgU2luZ2ggTWFuY2hhbmRhIDw2ODgwODg0OCtkanNtYW5jaGFuZGFAdXNlcnMubm9yZXBseS5naXRodWIuY29tPiAxNzkxNTAwMDg4ICswNTMwCgpBZGQgbm9uZGVnZW5lcmF0ZSByZWFkb3V0IHNhdHVyYXRpb24gZXhwZXJpbWVudCB3aXRoIHBpbm5lZCB2ZXJpZmljYXRpb24gYW5kIGNyZWRpdHM="
+    },
+    "163260325bb989eb0538b04c89e10d70eb0a2f88": {
+      "type": "blob",
+      "base64": "{
  "Z": {
    "changed_slots": 22,
    "dimension_increase": 25,
    "changes": [
      {
        "slot": 23484,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23445,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23434,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23406,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23354,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23328,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23327,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23325,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23324,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23281,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23270,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23269,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23267,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23671,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 23566,
        "old_dim": 12,
        "new_dim": 14
      },
      {
        "slot": 23451,
        "old_dim": 12,
        "new_dim": 14
      },
      {
        "slot": 23284,
        "old_dim": 12,
        "new_dim": 14
      },
      {
        "slot": 22982,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 22980,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 22974,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 22970,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 22966,
        "old_dim": 12,
        "new_dim": 13
      }
    ],
    "unchanged_maximal_slots": 11540,
    "degenerate_fallbacks": 24,
    "degenerate_cases": [
      {
        "slot": 23753,
        "old_dim": 14,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23744,
        "old_dim": 14,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23741,
        "old_dim": 14,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23484,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23445,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23434,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23406,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23354,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23328,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23327,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23325,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23324,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23281,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23270,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23269,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23267,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23671,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      },
      {
        "slot": 23566,
        "old_dim": 12,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23451,
        "old_dim": 12,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23284,
        "old_dim": 12,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 22982,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      },
      {
        "slot": 22974,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      },
      {
        "slot": 22970,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      },
      {
        "slot": 22966,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      }
    ],
    "root_float": 6.398691489630603e-05,
    "histogram": {
      "h": 23,
      "m": 529,
      "v": 1771,
      "N": 3136441,
      "W": 108516254,
      "L": 1792252,
      "s": 57403754177,
      "R": 28866,
      "hist": [
        [
          1,
          1690120201
        ],
        [
          3,
          1356586
        ],
        [
          5,
          354200
        ],
        [
          7,
          3580962
        ],
        [
          9,
          1526602
        ],
        [
          11,
          5093396
        ],
        [
          13,
          2164162
        ],
        [
          15,
          7948248
        ],
        [
          17,
          8476006
        ],
        [
          18,
          6272882
        ],
        [
          19,
          1639946
        ],
        [
          21,
          6906900
        ],
        [
          23,
          61280142
        ],
        [
          439,
          6272882
        ],
        [
          483,
          61280142
        ],
        [
          485,
          545468
        ],
        [
          487,
          173558
        ],
        [
          489,
          293986
        ],
        [
          491,
          580888
        ],
        [
          493,
          14168
        ],
        [
          495,
          322322
        ],
        [
          497,
          17710
        ],
        [
          499,
          1129898
        ],
        [
          501,
          127512
        ],
        [
          503,
          410872
        ],
        [
          505,
          99176
        ],
        [
          507,
          1154692
        ],
        [
          509,
          315238
        ],
        [
          511,
          378994
        ],
        [
          513,
          106260
        ],
        [
          515,
          1583274
        ],
        [
          517,
          626934
        ],
        [
          519,
          2854852
        ],
        [
          521,
          13711082
        ],
        [
          523,
          4629394
        ],
        [
          525,
          5653032
        ],
        [
          527,
          6233920
        ]
      ]
    },
    "full_physical_qualification": false,
    "reason": "Exact start/target containment and reverse-sweep nesting verified; generic-pivot and complete frame checks still needed.",
    "data_file": "experiments/round7-review/saturated-Z.json.gz"
  },
  "F2": {
    "changed_slots": 22,
    "dimension_increase": 25,
    "changes": [
      {
        "slot": 23484,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23445,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23434,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23406,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23354,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23328,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23327,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23325,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23324,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23281,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23270,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23269,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23267,
        "old_dim": 13,
        "new_dim": 14
      },
      {
        "slot": 23671,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 23566,
        "old_dim": 12,
        "new_dim": 14
      },
      {
        "slot": 23451,
        "old_dim": 12,
        "new_dim": 14
      },
      {
        "slot": 23284,
        "old_dim": 12,
        "new_dim": 14
      },
      {
        "slot": 22982,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 22980,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 22974,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 22970,
        "old_dim": 12,
        "new_dim": 13
      },
      {
        "slot": 22966,
        "old_dim": 12,
        "new_dim": 13
      }
    ],
    "unchanged_maximal_slots": 11540,
    "degenerate_fallbacks": 24,
    "degenerate_cases": [
      {
        "slot": 23753,
        "old_dim": 14,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23744,
        "old_dim": 14,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23741,
        "old_dim": 14,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23484,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23445,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23434,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23406,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23354,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23328,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23327,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23325,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23324,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23281,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23270,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23269,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23267,
        "old_dim": 13,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23671,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      },
      {
        "slot": 23566,
        "old_dim": 12,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23451,
        "old_dim": 12,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 23284,
        "old_dim": 12,
        "candidate_dim": 15,
        "gram_rank_mod_q": 14,
        "gram_rank_exact": 14
      },
      {
        "slot": 22982,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      },
      {
        "slot": 22974,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      },
      {
        "slot": 22970,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      },
      {
        "slot": 22966,
        "old_dim": 12,
        "candidate_dim": 14,
        "gram_rank_mod_q": 13,
        "gram_rank_exact": 13
      }
    ],
    "root_float": 6.398691489630603e-05,
    "histogram": {
      "h": 23,
      "m": 529,
      "v": 1771,
      "N": 3136441,
      "W": 108516254,
      "L": 1792252,
      "s": 57403754177,
      "R": 28866,
      "hist": [
        [
          1,
          1690120201
        ],
        [
          3,
          1356586
        ],
        [
          5,
          354200
        ],
        [
          7,
          3580962
        ],
        [
          9,
          1526602
        ],
        [
          11,
          5093396
        ],
        [
          13,
          2164162
        ],
        [
          15,
          7948248
        ],
        [
          17,
          8476006
        ],
        [
          18,
          6272882
        ],
        [
          19,
          1639946
        ],
        [
          21,
          6906900
        ],
        [
          23,
          61280142
        ],
        [
          439,
          6272882
        ],
        [
          483,
          61280142
        ],
        [
          485,
          545468
        ],
        [
          487,
          173558
        ],
        [
          489,
          293986
        ],
        [
          491,
          580888
        ],
        [
          493,
          14168
        ],
        [
          495,
          322322
        ],
        [
          497,
          17710
        ],
        [
          499,
          1129898
        ],
        [
          501,
          127512
        ],
        [
          503,
          410872
        ],
        [
          505,
          99176
        ],
        [
          507,
          1154692
        ],
        [
          509,
          315238
        ],
        [
          511,
          378994
        ],
        [
          513,
          106260
        ],
        [
          515,
          1583274
        ],
        [
          517,
          626934
        ],
        [
          519,
          2854852
        ],
        [
          521,
          13711082
        ],
        [
          523,
          4629394
        ],
        [
          525,
          5653032
        ],
        [
          527,
          6233920
        ]
      ]
    },
    "full_physical_qualification": false,
    "reason": "Exact start/target containment and reverse-sweep nesting verified; generic-pivot and complete frame checks still needed.",
    "data_file": "experiments/round7-review/saturated-F2.json.gz"
  },
  "seconds": 71.50934338569641
}
"
+    },
+    "1b2e0f1a21949cebba8a8525bf86a66f28313d2c": {
+      "type": "tree",
+      "base64": "NDAwMDAgcHI5OQBr69eUBrskU62it3Ya7OE9PlO2lA=="
+    },
+    "1d9e657c3481c544bbef103c7685010dd27cde9d": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IGF1ZGl0X2V2aWRlbmNlLnB5AKKOJDwLNPamcQvm1SrAYhSKxjbSMTAwNjQ0IGNoZWNrX2FyaXRobWV0aWMucHkAMDqobtf1YksHzsNivcVj0grDBYAxMDA2NDQgY2hlY2tfY2FuZGlkYXRlX2ZyYW1lcy5weQC/KwpXyj7yXvuwVf6p5sZWjH6TXTEwMDY0NCBoaXN0b2dyYW1fZW5naW5lLnB5AH8+FTSRgdGr0AOOt6vVpJOgqUQsMTAwNjQ0IHF1YWxpZmljYXRpb24uanNvbgC2LngQD7hqn9EzSXwBiFGPUFamaDEwMDY0NCBzYXR1cmF0ZV9yZWFkb3V0cy5weQCqxg5CQwdXNd4O31x3U9E6xbx1zDEwMDY0NCBzYXR1cmF0ZWQtWi5qc29uLmd6ACR7ZrA06Dp5/xsNwJMuHtCgF3oPMTAwNjQ0IHNhdHVyYXRpb24tcmVzdWx0cy5qc29uABYyYDJbuYnrBTiwTInhDXDrCi+IMTAwNjQ0IHNjYWxhcl9lbmdpbmUucHkA/1yJAdN5/zl/GqKesKiHXxLFGEg0MDAwMCB2ZW5kb3IAUd61pln5zPFOzTkQMgmqPdRNoSY="
+    },
+    "1eae4789cb057317db87c18893197c376ff520fb": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IFJFUE9SVC5tZACL9+OMlAFmlXr84LzFkNPsZ94OxTEwMDY0NCBjYW5kaWRhdGUtZnJhbWVzLWNoZWNrLmxvZwD21AXr1MZxTQ9/P/n+kbW3c1gHZjEwMDY0NCBjYW5kaWRhdGUtc2NhbGFyLXJlc3VsdHMuanNvbgCRWV4hSsMr509tugn9HaGQTIrTFTEwMDY0NCBxdWFsaWZpY2F0aW9uLXNhdHVyYXRlZC5qc29uABKmjsc3uYTr9g4QfgerPit+t0rRMTAwNjQ0IHJlc3VsdHMuanNvbgDCi1iz/BnJe0Z1sfjps2UcWdUdDDEwMDY0NCBzYXR1cmF0ZWQtYmFsYW5jZWQtY29tcGF0aWJpbGl0eS5qc29uAD1QvkcEVVsSwEY8SrBhL9FS7lpx"
+    },
+    "2387c7171d080b0f281358b8fc44c759fff95f7e": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IC5naXRhdHRyaWJ1dGVzAEGu8pD9DPGDjLDLoo4EqXtQboaSNDAwMDAgLmdpdGh1YgBVPkdbJROfXpbVOZ1gEe0soQuB7TEwMDY0NCAuZ2l0aWdub3JlAAxe+/HUWqdKo4X1hrBTxw4XCoMkMTAwNjQ0IENJVEFUSU9OLmNmZgBLDmUzQf0oKRGoDOTYfWQSy9i97zEwMDY0NCBDT05UUklCVVRJTkcubWQAQd78kCIr4mbHEIy3tvhowkWuiOwxMDA2NDQgQ09OVFJJQlVUT1JTLm1kANSQsPPGrVpVcsH3rgVecCwEBoRPMTAwNjQ0IExJQ0VOU0UAJh7rnp+LK0sNEZNm3amcb9fTXGQxMDA2NDQgTWFrZWZpbGUAdr5k8m86Qb6M4pOYXqWvgLnijBwxMDA2NDQgTk9USUNFALVlY3dYjylBDOQn9qNF7sNj1/h5MTAwNjQ0IFBBVENISU5HLm1kALYPPxAbvSM6UES3ohI+VQSk6AFhMTAwNjQ0IFJFQURNRS5tZABkImFawoW6hsGhV2dogMqVdk2cgjEwMDY0NCBTT1VSQ0VTLmpzb24AYJbVr/kO3v1DgGr25HD8VNenedU0MDAwMCBhcnRpZmFjdHMAfXF6FhMg3zzeLRYitg2qINpxU380MDAwMCBjZXJ0aWZpY2F0ZXMAw8cxfxc3Q6ugfbkpEm7FzMPbVH40MDAwMCBkb2NzAKZhKOgaKfxkr34J1IyMn4bxnWVaNDAwMDAgZm9ybWFsAHEYL44HbJQjNV/d6r9FGwyt6MWuNDAwMDAgbm90ZXMANv93/GSdOYgtn0mfY6I/TBZIeVM0MDAwMCBwYXRjaGVzAJS/+lmD/emP5dXj9YxIw+xhsqRPNDAwMDAgcmVmZXJlbmNlcwCbAG3k4efRj5q0EYIj7LQ5g6RdhDQwMDAwIHJlc2VhcmNoAJw1KEz9ZREL70l1pxwWe5IfYcWMNDAwMDAgc2NyaXB0cwBym834jGR2jkE0fddRVovq+jo4ajQwMDAwIHRlc3RzADstXX6oBrc8AtDflMHUqx0KRd2kNDAwMDAgdXBzdHJlYW0A5E05YhtY4rNR+RB7n6Fw1qjU/hw="
+    },
+    "2c583f6e8f2e30a6e5a809f94f4c56a84ee13338": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IC5naXRhdHRyaWJ1dGVzAEGu8pD9DPGDjLDLoo4EqXtQboaSNDAwMDAgLmdpdGh1YgD+gO6CB2mjX/3rgkAwZbJ/pGOtnDEwMDY0NCAuZ2l0aWdub3JlAAxe+/HUWqdKo4X1hrBTxw4XCoMkMTAwNjQ0IENJVEFUSU9OLmNmZgBLDmUzQf0oKRGoDOTYfWQSy9i97zEwMDY0NCBDT05UUklCVVRJTkcubWQAQd78kCIr4mbHEIy3tvhowkWuiOwxMDA2NDQgQ09OVFJJQlVUT1JTLm1kANSQsPPGrVpVcsH3rgVecCwEBoRPMTAwNjQ0IExJQ0VOU0UAJh7rnp+LK0sNEZNm3amcb9fTXGQxMDA2NDQgTWFrZWZpbGUAhP6CkPNT81NaATEZXDXsoDwolgkxMDA2NDQgTk9USUNFALVlY3dYjylBDOQn9qNF7sNj1/h5MTAwNjQ0IFBBVENISU5HLm1kALYPPxAbvSM6UES3ohI+VQSk6AFhMTAwNjQ0IFJFQURNRS5tZAADXCWbaPSkzdhLNEUw6RjKBdSmwTEwMDY0NCBTT1VSQ0VTLmpzb24AYJbVr/kO3v1DgGr25HD8VNenedU0MDAwMCBhcnRpZmFjdHMAfXF6FhMg3zzeLRYitg2qINpxU380MDAwMCBjZXJ0aWZpY2F0ZXMAYyb6JQMWZh84wizhWNDQ/lEEvmE0MDAwMCBkb2NzAKZhKOgaKfxkr34J1IyMn4bxnWVaNDAwMDAgZm9ybWFsAHEYL44HbJQjNV/d6r9FGwyt6MWuNDAwMDAgbm90ZXMANv93/GSdOYgtn0mfY6I/TBZIeVM0MDAwMCBwYXRjaGVzAJS/+lmD/emP5dXj9YxIw+xhsqRPNDAwMDAgcmVmZXJlbmNlcwCbAG3k4efRj5q0EYIj7LQ5g6RdhDQwMDAwIHJlc2VhcmNoAIDJIi4cqt0YN3zyfFFTLTL3OMZKNDAwMDAgc2NyaXB0cwBym834jGR2jkE0fddRVovq+jo4ajQwMDAwIHRlc3RzADstXX6oBrc8AtDflMHUqx0KRd2kNDAwMDAgdXBzdHJlYW0A5E05YhtY4rNR+RB7n6Fw1qjU/hw="
+    },
+    "3b0165efb5ba44bf2708af40a09c66d4c1f80271": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IFJvdW5kNy5sZWFuAC/BY5QVfy0FeQAC/HkjDmMr+Q4VMTAwNjQ0IHJvdW5kNy1oaXN0b2dyYW1zLmpzb24AzqqMARGzSHhEPQ5WHQK49yqX0t8="
+    },
+    "48f38239c186db7e4bd90bbf8139cebfedd98148": {
+      "type": "tree",
+      "base64": "NDAwMDAgcm91bmQ3LXJldmlldwAdnmV8NIHFRLvvEDx2hQEN0nzenTQwMDAwIHNhdHVyYXRpb24tcmV2aWV3AJc6zWDHm13Bz8bqVEN1yHbm0sX4"
+    },
+    "51deb5a659f9ccf14ecd39103209aa3dd44da126": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IExJQ0VOU0UAV7yIoVoO6CZsJZsmZ+ZGCNP34pIxMDA2NDQgTk9USUNFAO3D7+ci7Rrmn6mGVV7AKQethUNMMTAwNjQ0IFJFQURNRS5tZAB0fHBTcbbWqqLHM/TyuHRg0kWEJzQwMDAwIGNlcnRpZmljYXRlcwBTJnqMuhqXTIPemZHHV0h5vZ/z7DQwMDAwIGluZGVwZW5kZW50AIwgBoxF5TQyxGp7sDbCJujex3+JNDAwMDAgbGVhbgA7AWXvtbpEvycIr0CgnGbUwfgCcTQwMDAwIG5vdGVzAOInVgi9md7cFialO8Fhses7/RsuNDAwMDAgc2NyaXB0cwBuwrwWZiAOeWDXHIE1wcQacNqLOA=="
+    },
+    "53267a8cba1a974c83de9991c7574879bd9ff3ec": {
+      "type": "tree",
+      "base64": "NDAwMDAgcm91bmQ3AN4/zmjYylwpheOv6ptHdIJGJZbW"
+    },
+    "56b66d58297deca1d7dd130247d720e960f77a37": {
+      "type": "commit",
+      "base64": "dHJlZSBkZTVhYjQ4OWNmOWYxNGI2OWRhYjQzZWI5OGY2ZjZhYjJlMDI4ODAwCnBhcmVudCA3ODFkYjdkMTUxOTZjYzgwZDRjMjdhZDk2YzkyYWRkYmEyNWZiZDNiCmF1dGhvciBEb3VnbGFzIFIuIENvbGtpdHQgPGRvdWdsYXMuY29sa2l0dEBnbWFpbC5jb20+IDE3OTE0ODYyMzcgLTA0MDAKY29tbWl0dGVyIERvdWdsYXMgUi4gQ29sa2l0dCA8ZG91Z2xhcy5jb2xraXR0QGdtYWlsLmNvbT4gMTc5MTQ4NjIzNyAtMDQwMAoKUmV2aWV3IGFuZCBjcmVkaXQgS29zdGVycyBhbmQgQWJlIGhpc3RvcmljYWwgY2FuZGlkYXRlcwo="
+    },
+    "5d7098743ed974e181564e14d01b120cbdbb11f5": {
+      "type": "tree",
+      "base64": "NDAwMDAgY2xpbWJlZC00OAAhDnoIV8m6QYNRG3L4s8y85eDy9jQwMDAwIGNvcGllZC1maXhlZC1yZXZlcnNlZABxmk57pJn99OKzO6sPBEiHHqRchDQwMDAwIGNvcGllZC1maXhlZADoL5O3sUT1FdUrAKjU2s2iaSm16zQwMDAwIGNvcGllZC1yZXZlcnNlZACTgQ6qxkQWtJfWi8uPV8gtpJ9CJTQwMDAwIGVubGFyZ2VkLXBvc2l0aXZlLWZyYW1lLW5ldHdvcmtzAMMLipaoF1Lq45bXfGJPxE0wzGH5NDAwMDAgZ2F1c3NpYW4tcGFyaXR5LXN5bnRoZXNpcwDs+8z54KmiDGGf8PPFa/aHoGkkmzQwMDAwIGdhdXNzaWFuLXBhcml0eQCfyoPokyVP2gA2l4nCGYbch2tN7DQwMDAwIGpvaW50LWR1YWwAK86zo2rJTlZZOpyJ+7Vx3MHMlyI0MDAwMCBtYXRyaXgtZXhwb25lbnQtc3ludGhlc2lzAKfDCxRiuG7mr383KzIkuRbMLPr+NDAwMDAgcGFpci1hc3NlbWJseQCDeS26n6jZmE/dzWTFoUu18G586jQwMDAwIHBhcmFsbGVsLWFubm91bmNlbWVudHMAIUlhL8XbfvY8R2i85NbcAiwokxo0MDAwMCBwb3NpdGl2ZS1za2lwAN1iqyjBwsBJN+g/k7LKqIsa9u2/NDAwMDAgc2tpcC1jbG9uZXMAsrAMU+jJbCIOO0zRMSYFC0uYoy40MDAwMCBza2lwLXN0cmlwcwAdXgzAt89dj25cLgWi9j/mIadrdTQwMDAwIHNraXAtc3VmZml4AG7crUvPhKk5bHvRGmLEkCkoJ0RvNDAwMDAgc3BsaXQtc2tpcAAomaMJJwlR02SAJft+QXOnhmvJ4TQwMDAwIHN3YXBuaWwtcGFyYWxsZWwAgC9GwQsviuqtUm3zrV14mjzy39Y="
+    },
+    "5fc6d40c1b1cf671787795ab3f987a74220014d6": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IGNoZWNrX3Jlc2VhcmNoLnB5AG1pvxumygnpCc3pEYIgmd+vO4mt"
+    },
+    "6bebd79406bb2453ada2b7761aece13d3e53b694": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IC5naXRpZ25vcmUAI8Ywcvpx3Mz+jQSeAx29sW7eIaYxMDA2NDQgTElDRU5TRQBXvIihWg7oJmwlmyZn5kYI0/fikjEwMDY0NCBNQU5JRkVTVC5qc29uAL9c2XoPPSRimny6Gq8GH/Doe9wKMTAwNjQ0IE5PVElDRQDoaRzAfdU9z+dNoTInk7Joj8pNUTEwMDY0NCBQUk9WRU5BTkNFLmpzb24AGpPcq1QgL5JT9DvIX053xLa8F7QxMDA2NDQgUkVBRE1FLm1kAFIzID75vYfETp3SW3NgnqD2PVCfNDAwMDAgZXhwZXJpbWVudHMASPOCOcGG235L2Qu/gTnOv+3ZgUg0MDAwMCBoaXN0b3JpY2FsAB6uR4nLBXMX24fBiJMZfDdv9SD7NDAwMDAgc2NyaXB0cwBfxtQMGxz2cXh3las/mHp0IgAU1jEwMDY0NCB2ZXJpZnkucHkAYtpkLB7rpSq2BVbMVq9kmp2YP8g="
+    },
+    "6ec2bc1666200e7960d71c8135c1c41a70da8b38": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IGNlcnRpZmljYXRlX3JvdW5kMy5weQD1rFQIKskqIaznMjqpSPZeMpr2VzEwMDY0NCBjZXJ0aWZpY2F0ZV9yb3VuZDcucHkAzoIlxZnovrM6LRYGE+G6RhjzHTM="
+    },
+    "75ab1f70d146c21c7611ce0df9eb5f645f51ac0e": {
+      "type": "commit",
+      "base64": "dHJlZSAyMzg3YzcxNzFkMDgwYjBmMjgxMzU4YjhmYzQ0Yzc1OWZmZjk1ZjdlCnBhcmVudCAwMWMzOWVlOWJkYzlkYTI5OGY2OGU4YTQyNGJiMmE4YWQ1NTc0ZDczCmF1dGhvciBSb2hhbiBBcnVuIDxyb2hhbmFydW5AZ21haWwuY29tPiAxNzkxNTA0ODk0IC0wNDAwCmNvbW1pdHRlciBSb2hhbiBBcnVuIDxyb2hhbmFydW5AZ21haWwuY29tPiAxNzkxNTA0ODk0IC0wNDAwCgpSZWNvcmQgc3VjY2Vzc2Z1bCBmdWxsIHZlcmlmaWNhdGlvbiBmb3IgUFIgMTAzCg=="
+    },
+    "80c9222e1caadd18377cf27c51532d32f738c64a": {
+      "type": "tree",
+      "base64": "NDAwMDAgY2xpbWJlZC00OAAhDnoIV8m6QYNRG3L4s8y85eDy9jQwMDAwIGNvcGllZC1maXhlZC1yZXZlcnNlZABxmk57pJn99OKzO6sPBEiHHqRchDQwMDAwIGNvcGllZC1maXhlZADoL5O3sUT1FdUrAKjU2s2iaSm16zQwMDAwIGNvcGllZC1yZXZlcnNlZACTgQ6qxkQWtJfWi8uPV8gtpJ9CJTQwMDAwIGVubGFyZ2VkLXBvc2l0aXZlLWZyYW1lLW5ldHdvcmtzAMMLipaoF1Lq45bXfGJPxE0wzGH5NDAwMDAgZ2F1c3NpYW4tcGFyaXR5LXN5bnRoZXNpcwDs+8z54KmiDGGf8PPFa/aHoGkkmzQwMDAwIGdhdXNzaWFuLXBhcml0eQCfyoPokyVP2gA2l4nCGYbch2tN7DQwMDAwIGpvaW50LWR1YWwAK86zo2rJTlZZOpyJ+7Vx3MHMlyI0MDAwMCBtYXRyaXgtZXhwb25lbnQtc3ludGhlc2lzAKfDCxRiuG7mr383KzIkuRbMLPr+NDAwMDAgbm9uZGVnZW5lcmF0ZS1yZWFkb3V0LXNhdHVyYXRpb24Aa+vXlAa7JFOtord2GuzhPT5TtpQ0MDAwMCBwYWlyLWFzc2VtYmx5AIN5LbqfqNmYT93NZMWhS7XwbnzqNDAwMDAgcGFyYWxsZWwtYW5ub3VuY2VtZW50cwAhSWEvxdt+9jxHaLzk1twCLCiTGjQwMDAwIHBvc2l0aXZlLXNraXAA3WKrKMHCwEk36D+Tssqoixr27b80MDAwMCBza2lwLWNsb25lcwCysAxT6MlsIg47TNExJgULS5ijLjQwMDAwIHNraXAtc3RyaXBzAB1eDMC3z12PblwuBaL2P+Yhp2t1NDAwMDAgc2tpcC1zdWZmaXgAbtytS8+EqTlse9EaYsSQKSgnRG80MDAwMCBzcGxpdC1za2lwACiZowknCVHTZIAl+35Bc6eGa8nhNDAwMDAgc3dhcG5pbC1wYXJhbGxlbACAL0bBCy+K6q1SbfOtXXiaPPLf1g=="
+    },
+    "8c20068c45e53432c46a7bb036c226e8dec77f89": {
+      "type": "tree",
+      "base64": "NDAwMDAgZGVmZXJyZWQtcmVhZG91dACetiZksas3AeJfO49HiyAWGx9IczQwMDAwIHR3by1zdGFnZS1iaXQA0TEPTqE/loJwQYYh2PvN8X5AY+k="
+    },
+    "973acd60c79b5dc1cfc6ea544375c876e6d2c5f8": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IHJldmlldy5weQDbdtNeHvwwx+9H65hObJ3l65eKoA=="
+    },
+    "9c35284cfd65110bef4975a71c167b921f61c58c": {
+      "type": "tree",
+      "base64": "NDAwMDAgY2xpbWJlZC00OAAhDnoIV8m6QYNRG3L4s8y85eDy9jQwMDAwIGNvcGllZC1maXhlZC1yZXZlcnNlZABxmk57pJn99OKzO6sPBEiHHqRchDQwMDAwIGNvcGllZC1maXhlZADoL5O3sUT1FdUrAKjU2s2iaSm16zQwMDAwIGNvcGllZC1yZXZlcnNlZACTgQ6qxkQWtJfWi8uPV8gtpJ9CJTQwMDAwIGRlZmVycmVkLWJhbGFuY2VkAPNBPGDsVB1yQ3s2w5//bHwhwHAqNDAwMDAgZGVmZXJyZWQtc2lnbmVkAO6IwIpdGEz5PJItR0/+b/i69vG7NDAwMDAgZW5sYXJnZWQtcG9zaXRpdmUtZnJhbWUtbmV0d29ya3MAwwuKlqgXUurjltd8Yk/ETTDMYfk0MDAwMCBnYXVzc2lhbi1wYXJpdHktc3ludGhlc2lzAOz7zPngqaIMYZ/w88Vr9oegaSSbNDAwMDAgZ2F1c3NpYW4tcGFyaXR5AJ/Kg+iTJU/aADaXicIZhtyHa03sNDAwMDAgam9pbnQtZHVhbADgurXKqzXYJ+mdFPXvCahTbvVsGjQwMDAwIG1hdHJpeC1leHBvbmVudC1zeW50aGVzaXMAp8MLFGK4buavfzcrMiS5Fsws+v40MDAwMCBwYWlyLWFzc2VtYmx5AIN5LbqfqNmYT93NZMWhS7XwbnzqNDAwMDAgcGFyYWxsZWwtYW5ub3VuY2VtZW50cwAhSWEvxdt+9jxHaLzk1twCLCiTGjQwMDAwIHBvc2l0aXZlLXNraXAA3WKrKMHCwEk36D+Tssqoixr27b80MDAwMCBzYXR1cmF0ZWQtYmFsYW5jZWQAtDUnH2O5dAJmMHHOcwRTF/HsPJs0MDAwMCBza2lwLWNsb25lcwCysAxT6MlsIg47TNExJgULS5ijLjQwMDAwIHNraXAtc3RyaXBzAB1eDMC3z12PblwuBaL2P+Yhp2t1NDAwMDAgc2tpcC1zdWZmaXgAbtytS8+EqTlse9EaYsSQKSgnRG80MDAwMCBzcGxpdC1za2lwACiZowknCVHTZIAl+35Bc6eGa8nhNDAwMDAgc3dhcG5pbC1wYXJhbGxlbACAL0bBCy+K6q1SbfOtXXiaPPLf1g=="
+    },
+    "9eb62664b1ab3701e25f3b8f478b20161b1f4873": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IGNoZWNrX2ZyYW1lcy5weQDssf304BTnzZZRV2vBeAZQ0UEtwjEwMDY0NCBjaGVja19saWZ0ZWQucHkAcAUU61stZ+q71MOSRIZf534pWd0xMDA2NDQgY2hlY2tfc3RhaXIucHkA9FxBzF9Hb1Wzmd0dQ08DB3+LlP4xMDA2NDQgY2hlY2tfd29yZC5weQBnRXHgBBw+ePEq2hO8bPOxQC6nmTEwMDY0NCBkZWZlcnJlZC5weQDQRRJiF2cNyC51FSMPncBVrJ3ERDEwMDY0NCBsaW5hbGcucHkABvV3Qs62+g2O5jIgCvWg6HXpPEo="
+    },
+    "aabf3d6fe36a0d3320e0081ef556bb94ed8bc31f": {
+      "type": "blob",
+      "base64": "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"
+    },
+    "b435271f63b97402663071ce73045317f1ec3c9b": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IFBST09GLm1kAL1vUKvuXIwm0iY7fhzWOpIL0hRyMTAwNjQ0IFJFQURNRS5tZADEP4BCVBTY78crDEk3ObrlSHlIizEwMDY0NCBTT1VSQ0UuanNvbgAXd+JyxKEMdO5QI2lcCHKfFB3m/DEwMDY0NCBiaXQtbGVkZ2VyLmpzb24Aqr89b+NqDTMg4Age9Va7lO2Lwx8xMDA2NDQgY2VydGlmaWNhdGUuanNvbgAhIdMqXxnjruSIOnfss+Vu19J/tDEwMDY0NCBmb2N1c2VkLXZhbGlkYXRpb24uanNvbgCCCP38sqCuIeA84JEF2zh00F7WTDEwMDY0NCBpbmRlcGVuZGVudC1sZWRnZXItdmFsaWRhdGlvbi5qc29uAB0yQTpldWW5PIQZV4Az6edgJ9jiMTAwNjQ0IGluZGVwZW5kZW50LXByOTktdmFsaWRhdGlvbi5qc29uAAg5rzeppxEKZTOZwYk7wDnM5D3NMTAwNjQ0IHRlc3RfY29udHJvbHMucHkA72aStpZQ0WUWJXZejhkqYnaMXLExMDA2NDQgdmFsaWRhdGlvbi5qc29uAIIU3P9AfafIRGHvCAa91UMspDlDNDAwMDAgdmVuZG9yABsuDxohlJzruoqFJb+Gpm8oMT0sMTAwNjQ0IHZlcmlmeS5weQCSWcATkzCuCx99GLgK5kp95ekvGA=="
+    },
+    "b62e78100fb86a9fd133497c0188518f5056a668": {
+      "type": "blob",
+      "base64": "{
  "schema": 1,
  "status": "verified conditional finite witness with arithmetic refinement",
  "source": {
    "repository": "Swapnil-jain/integer-mult-kappa",
    "commit": "741e7aa078392553815df7926ee17ac5e25a8c38",
    "git_blob_sha1": {
      "witness_23.json.gz": "3d86f83b871ba07c3b1562aa6d953ae86b9750ba",
      "deferred_23.json.gz": "4a4431bd425aa4499f25e67df4e0d2cddd7df15c"
    }
  },
  "evidence": {
    "exact_basis_replay": true,
    "exact_basis_field": "F2",
    "basis_columns": 30637,
    "exact_frame_profile": true,
    "frame_containment_field": "Q",
    "generic_pivots": "two conjugations at a fixed integer point, proved via rank modulo 2^31-1",
    "nondegeneracy": "Gram determinant nonzero modulo 2^31-1 implies nonzero over Q",
    "histogram_equals_pinned": true,
    "exact_moment": true,
    "exact_assembly": true
  },
  "histogram": {
    "h": 23,
    "m": 529,
    "v": 1771,
    "N": 3136441,
    "W": 108516254,
    "L": 1792252,
    "s": 57403754177,
    "R": 28866,
    "hist": [
      [
        1,
        1690297301
      ],
      [
        3,
        1356586
      ],
      [
        5,
        354200
      ],
      [
        7,
        3580962
      ],
      [
        9,
        1526602
      ],
      [
        11,
        5093396
      ],
      [
        13,
        2164162
      ],
      [
        15,
        7948248
      ],
      [
        17,
        8476006
      ],
      [
        18,
        6272882
      ],
      [
        19,
        1639946
      ],
      [
        21,
        6906900
      ],
      [
        23,
        61280142
      ],
      [
        439,
        6272882
      ],
      [
        483,
        61280142
      ],
      [
        485,
        545468
      ],
      [
        487,
        173558
      ],
      [
        489,
        293986
      ],
      [
        491,
        580888
      ],
      [
        493,
        14168
      ],
      [
        495,
        322322
      ],
      [
        497,
        17710
      ],
      [
        499,
        1129898
      ],
      [
        501,
        127512
      ],
      [
        503,
        410872
      ],
      [
        505,
        99176
      ],
      [
        507,
        1186570
      ],
      [
        509,
        340032
      ],
      [
        511,
        322322
      ],
      [
        513,
        106260
      ],
      [
        515,
        1583274
      ],
      [
        517,
        626934
      ],
      [
        519,
        2854852
      ],
      [
        521,
        13711082
      ],
      [
        523,
        4629394
      ],
      [
        525,
        5653032
      ],
      [
        527,
        6233920
      ]
    ]
  },
  "moment": {
    "saving": "1599575331/25000000000000",
    "moment_lower": "199999999999999996774004728609/200000000000000000000000000000",
    "moment_upper": "499999999999999991935011821523/500000000000000000000000000000",
    "positive_moment_gap": "8064988178477/500000000000000000000000000000",
    "next_grid_saving": "63983013241/1000000000000000",
    "next_grid_moment_lower": "1000000000000000349889442945071/1000000000000000000000000000000",
    "next_grid_certified_false": true,
    "interval_calls": 9,
    "enclosure_rounding_denominator": 1000000000000000000000000000000
  },
  "assembly": {
    "a_bit": "1599575331/25000000000000",
    "a_complex": "36926111/500000000000",
    "beta": "1/1000",
    "eps": "199987204216064813/200000000000000000",
    "x": "14695",
    "c1": "14694",
    "delta": "1/146950000000000000000000000",
    "lambda_": "999936016986760001/1000000000000000000",
    "lambda_prime": "499968008493380001/500000000000000000",
    "kappa": "15994729918983323/250000000000000000000",
    "kappa_float": 6.39789196759333e-05,
    "constraints": {
      "lambda_above_tau_sigma_chi": "1/1000000000000000000",
      "lambda_prime_above_lambda_leaf": "1/1000000000000000000",
      "lambda_prime_below_one": "31991506619999/500000000000000000",
      "beta_positive": "1/1000",
      "beta_below_one": "999/1000",
      "crude_guard": "181488086884115122427967146912980563860364099676371395926387309858860241014635309419573887322858270798926187675975887155882448886780219116627798728759461950014447224654721706640593955355236673932728359624962572418450228749891456300650973631407969791122853489957228980994390111073431967243709978454044605805794421973280177004027932081157929261987289551825151386972504331406788957800755630188661896571208516152247637911480126805186902437515958786771618653814062606432563023330297509585088178157223422972978215063684002940860157171364142484430361231338067691878321504257976021056738890958321516205499209645226618935060414477751982185564051378526967275880143086423591528109735897716135807627761265291604171988062426666452763088940636184425185365711285963294865015969544524682917728434810515152940420816171217167604077951651703684113999195449188434756212844004175060660154930518999/417599396615159033258959647160472863389949066825621268950159863879977098788687658060606032587867046368603795021123537295986932962913726051371548043813560386196625445156114369188687013441705360820641412704678144457069036774142338614379513628160759912492893775439631685280416693139002572787187016966706752864067978387211040918867455663994384371416494759111603431368844401640315758549221001626839066027917896291387220517894102986557326772070208839962720891475980957929115675368871153867538293526869908377008186872310998569001569209646792133839744071534967614420149638331039807419877037593783310245090543666715471053289489466196140036454232597627963975837341295271650535266311380288050014429522252884669607428413549517204635033535672095050026169680102759450763945848438240278811153006530788443518002382354926969016777338339352354523725807666778564453125000000000000000000000000000",
      "scalar_depth": "294010624571818889/100000000000000000",
      "precision": "2938600038387351805561/200000000000000000",
      "sub_block_coupling": "1",
      "reservation": "170611765654004813/99993602108032406500000000000000000",
      "eps_positive": "199987204216064813/200000000000000000",
      "eps_below_one": "12795783935187/200000000000000000",
      "delta_positive": "1/146950000000000000000000000",
      "delta_below_eighth": "18368749999999999999999999/146950000000000000000000000"
    },
    "margins": {
      "prefix": "12795783935187/200000000000000000",
      "butterfly": "6397891967593329388234345995187/100000000000000000000000000000000000",
      "small_field": "1175212780797331029413/18368750000000000000000000",
      "Gaussian": "1175212780797331029413/18368750000000000000000000",
      "chirps_twists_scalar": "1175212780797331029413/18368750000000000000000000",
      "polynomial": "199987204216064813/200000000000000000",
      "reserved_axes": "1175212780797331029413/18368750000000000000000000",
      "axis_reverse": "319894598379676468771928103/5000000000000000000000000000000"
    },
    "absorption_gaps": {
      "prefix": "427/250000000000000000000",
      "butterfly": "188234345995187/100000000000000000000000000000000000",
      "small_field": "7842997/4592187500000000000000000",
      "Gaussian": "7842997/4592187500000000000000000",
      "chirps_twists_scalar": "7842997/4592187500000000000000000",
      "polynomial": "249968010540162032927/250000000000000000000",
      "reserved_axes": "7842997/4592187500000000000000000",
      "axis_reverse": "10008771928103/5000000000000000000000000000000"
    },
    "binding": "butterfly"
  },
  "threshold": "26222540409037/500000000000000000",
  "exceeds_user_threshold": true,
  "published_kappa": "1599247689723/25000000000000000",
  "arithmetic_gain": 9.012087013292e-09,
  "physical_gain": false,
  "physical_ablations": {
    "trials": [
      {
        "removed_dimensions": [],
        "root_float": 6.398301323982777e-05,
        "weighted_log_cost": 0.3659200750883561
      },
      {
        "removed_dimensions": [
          1
        ],
        "root_float": 6.397635234998488e-05,
        "weighted_log_cost": 0.3659581873173519
      },
      {
        "removed_dimensions": [
          1,
          2
        ],
        "root_float": 6.397250805615947e-05,
        "weighted_log_cost": 0.3659801884002106
      },
      {
        "removed_dimensions": [
          1,
          2,
          3
        ],
        "root_float": 6.396197257660644e-05,
        "weighted_log_cost": 0.36604049497898666
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4
        ],
        "root_float": 6.393930610971295e-05,
        "weighted_log_cost": 0.3661703233100852
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5
        ],
        "root_float": 6.393897947155719e-05,
        "weighted_log_cost": 0.3661721961380483
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6
        ],
        "root_float": 6.391798706298719e-05,
        "weighted_log_cost": 0.3662925137604546
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7
        ],
        "root_float": 6.39168653509765e-05,
        "weighted_log_cost": 0.36629894579001787
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8
        ],
        "root_float": 6.380744208687456e-05,
        "weighted_log_cost": 0.3669273796968683
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9
        ],
        "root_float": 6.379426822583388e-05,
        "weighted_log_cost": 0.3670031870667055
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10
        ],
        "root_float": 6.37591347287772e-05,
        "weighted_log_cost": 0.36720554810765305
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11
        ],
        "root_float": 6.375953955758329e-05,
        "weighted_log_cost": 0.3672032544356571
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12
        ],
        "root_float": 6.365629815223156e-05,
        "weighted_log_cost": 0.3677992712635421
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13
        ],
        "root_float": 6.364229252690019e-05,
        "weighted_log_cost": 0.3678803574123652
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14
        ],
        "root_float": 6.360188480445787e-05,
        "weighted_log_cost": 0.36811421977378245
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15
        ],
        "root_float": 6.357983780656265e-05,
        "weighted_log_cost": 0.36824191428171765
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16
        ],
        "root_float": 6.312141263792942e-05,
        "weighted_log_cost": 0.370917020659286
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17
        ],
        "root_float": 6.291568639655222e-05,
        "weighted_log_cost": 0.3721301642506309
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18
        ],
        "root_float": 6.179213866493951e-05,
        "weighted_log_cost": 0.3788978540091406
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19
        ],
        "root_float": 5.646710650080092e-05,
        "weighted_log_cost": 0.4146356299483202
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20
        ],
        "root_float": 5.4775434076778255e-05,
        "weighted_log_cost": 0.4274431565503396
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21
        ],
        "root_float": 5.274303204712734e-05,
        "weighted_log_cost": 0.4439167072100837
      },
      {
        "removed_dimensions": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.049733830083945e-05,
        "weighted_log_cost": 0.4636609827566053
      },
      {
        "removed_dimensions": [
          2
        ],
        "root_float": 6.39785911680228e-05,
        "weighted_log_cost": 0.3659453762128144
      },
      {
        "removed_dimensions": [
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.046226349613139e-05,
        "weighted_log_cost": 0.46398323747259695
      },
      {
        "removed_dimensions": [
          3
        ],
        "root_float": 6.39716134682678e-05,
        "weighted_log_cost": 0.3659853062149336
      },
      {
        "removed_dimensions": [
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.04489769629166e-05,
        "weighted_log_cost": 0.46410542285028944
      },
      {
        "removed_dimensions": [
          4
        ],
        "root_float": 6.395359620641368e-05,
        "weighted_log_cost": 0.3660884541741315
      },
      {
        "removed_dimensions": [
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.036410812022376e-05,
        "weighted_log_cost": 0.4648874421134617
      },
      {
        "removed_dimensions": [
          5
        ],
        "root_float": 6.398265059370612e-05,
        "weighted_log_cost": 0.365922151275507
      },
      {
        "removed_dimensions": [
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.028832236926861e-05,
        "weighted_log_cost": 0.46558796026443555
      },
      {
        "removed_dimensions": [
          6
        ],
        "root_float": 6.395534989999732e-05,
        "weighted_log_cost": 0.3660784057225954
      },
      {
        "removed_dimensions": [
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.027826571680005e-05,
        "weighted_log_cost": 0.46568108163734373
      },
      {
        "removed_dimensions": [
          7
        ],
        "root_float": 6.398162889019052e-05,
        "weighted_log_cost": 0.36592799607058274
      },
      {
        "removed_dimensions": [
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.024054172066443e-05,
        "weighted_log_cost": 0.4660306862375908
      },
      {
        "removed_dimensions": [
          8
        ],
        "root_float": 6.382628068607158e-05,
        "weighted_log_cost": 0.3668188874985321
      },
      {
        "removed_dimensions": [
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.0238213648831376e-05,
        "weighted_log_cost": 0.4660522783396089
      },
      {
        "removed_dimensions": [
          9
        ],
        "root_float": 6.396437213114022e-05,
        "weighted_log_cost": 0.3660267483735453
      },
      {
        "removed_dimensions": [
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.018195794837625e-05,
        "weighted_log_cost": 0.466574487477001
      },
      {
        "removed_dimensions": [
          10
        ],
        "root_float": 6.391321628520438e-05,
        "weighted_log_cost": 0.36631980173652007
      },
      {
        "removed_dimensions": [
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.01871713577415e-05,
        "weighted_log_cost": 0.4665259926556252
      },
      {
        "removed_dimensions": [
          11
        ],
        "root_float": 6.396416326607961e-05,
        "weighted_log_cost": 0.36602794264172206
      },
      {
        "removed_dimensions": [
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.0185787077482814e-05,
        "weighted_log_cost": 0.4665387497293618
      },
      {
        "removed_dimensions": [
          12
        ],
        "root_float": 6.369711531523693e-05,
        "weighted_log_cost": 0.36756288409354737
      },
      {
        "removed_dimensions": [
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.019133070351795e-05,
        "weighted_log_cost": 0.4664871938394485
      },
      {
        "removed_dimensions": [
          13
        ],
        "root_float": 6.389216632986552e-05,
        "weighted_log_cost": 0.3664404978155883
      },
      {
        "removed_dimensions": [
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.0286489547270735e-05,
        "weighted_log_cost": 0.4656041080335043
      },
      {
        "removed_dimensions": [
          14
        ],
        "root_float": 6.38839179993631e-05,
        "weighted_log_cost": 0.36648781165571886
      },
      {
        "removed_dimensions": [
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.032891035529775e-05,
        "weighted_log_cost": 0.46521156600187363
      },
      {
        "removed_dimensions": [
          15
        ],
        "root_float": 6.394382630064639e-05,
        "weighted_log_cost": 0.36614436820925783
      },
      {
        "removed_dimensions": [
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.0382137718545436e-05,
        "weighted_log_cost": 0.4647199882492164
      },
      {
        "removed_dimensions": [
          16
        ],
        "root_float": 6.34142316445656e-05,
        "weighted_log_cost": 0.36920284433669454
      },
      {
        "removed_dimensions": [
          16,
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.0405455718871835e-05,
        "weighted_log_cost": 0.464504973256638
      },
      {
        "removed_dimensions": [
          17
        ],
        "root_float": 6.373180035405768e-05,
        "weighted_log_cost": 0.36736273005161135
      },
      {
        "removed_dimensions": [
          17,
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.0728045440948794e-05,
        "weighted_log_cost": 0.4615505728451297
      },
      {
        "removed_dimensions": [
          18
        ],
        "root_float": 6.278075549562223e-05,
        "weighted_log_cost": 0.3729289188312896
      },
      {
        "removed_dimensions": [
          18,
          19,
          20,
          21,
          22
        ],
        "root_float": 5.088570635030397e-05,
        "weighted_log_cost": 0.4601203239370345
      },
      {
        "removed_dimensions": [
          19
        ],
        "root_float": 5.8141729015559384e-05,
        "weighted_log_cost": 0.4026897940365553
      },
      {
        "removed_dimensions": [
          19,
          20,
          21,
          22
        ],
        "root_float": 5.166715720004926e-05,
        "weighted_log_cost": 0.45316011524492733
      },
      {
        "removed_dimensions": [
          20
        ],
        "root_float": 6.170493027896555e-05,
        "weighted_log_cost": 0.379432022096412
      },
      {
        "removed_dimensions": [
          20,
          21,
          22
        ],
        "root_float": 5.622275746806851e-05,
        "weighted_log_cost": 0.4164362416524974
      },
      {
        "removed_dimensions": [
          21
        ],
        "root_float": 6.11014841996298e-05,
        "weighted_log_cost": 0.3831800190979199
      },
      {
        "removed_dimensions": [
          21,
          22
        ],
        "root_float": 5.8107864686169635e-05,
        "weighted_log_cost": 0.40292429464444146
      },
      {
        "removed_dimensions": [
          22
        ],
        "root_float": 6.07079606905441e-05,
        "weighted_log_cost": 0.3856643506348777
      },
      {
        "removed_dimensions": [
          5,
          7
        ],
        "root_float": 6.398126625965614e-05,
        "weighted_log_cost": 0.36593007225773366
      },
      {
        "removed_dimensions": [
          2,
          5
        ],
        "root_float": 6.397822857168361e-05,
        "weighted_log_cost": 0.36594745239996535
      },
      {
        "removed_dimensions": [
          2,
          7
        ],
        "root_float": 6.397739621737856e-05,
        "weighted_log_cost": 0.3659522149607533
      },
      {
        "removed_dimensions": [
          2,
          5,
          7
        ],
        "root_float": 6.39770336345489e-05,
        "weighted_log_cost": 0.3659542911479042
      },
      {
        "removed_dimensions": [
          1,
          5
        ],
        "root_float": 6.397598977915475e-05,
        "weighted_log_cost": 0.36596026350450284
      },
      {
        "removed_dimensions": [
          1,
          7
        ],
        "root_float": 6.397496828860309e-05,
        "weighted_log_cost": 0.36596610829957854
      },
      {
        "removed_dimensions": [
          1,
          5,
          7
        ],
        "root_float": 6.397460573335537e-05,
        "weighted_log_cost": 0.36596818448672946
      },
      {
        "removed_dimensions": [
          1,
          2,
          5
        ],
        "root_float": 6.397214552854605e-05,
        "weighted_log_cost": 0.36598226458736155
      },
      {
        "removed_dimensions": [
          1,
          2,
          7
        ],
        "root_float": 6.397134888107838e-05,
        "weighted_log_cost": 0.36598682378896175
      },
      {
        "removed_dimensions": [
          3,
          5
        ],
        "root_float": 6.397125095096757e-05,
        "weighted_log_cost": 0.36598738240208445
      },
      {
        "removed_dimensions": [
          1,
          2,
          5,
          7
        ],
        "root_float": 6.397098636676112e-05,
        "weighted_log_cost": 0.3659888999761126
      },
      {
        "removed_dimensions": [
          3,
          7
        ],
        "root_float": 6.3970229612002e-05,
        "weighted_log_cost": 0.36599322719716015
      },
      {
        "removed_dimensions": [
          2,
          3
        ],
        "root_float": 6.396731944526919e-05,
        "weighted_log_cost": 0.36600988371064064
      },
      {
        "removed_dimensions": [
          2,
          3,
          5
        ],
        "root_float": 6.396695697675349e-05,
        "weighted_log_cost": 0.3660119598977915
      },
      {
        "removed_dimensions": [
          2,
          3,
          7
        ],
        "root_float": 6.396612491548787e-05,
        "weighted_log_cost": 0.36601672245857947
      },
      {
        "removed_dimensions": [
          1,
          3
        ],
        "root_float": 6.39656891368661e-05,
        "weighted_log_cost": 0.3660192175248792
      },
      {
        "removed_dimensions": [
          1,
          3,
          5
        ],
        "root_float": 6.396536222913918e-05,
        "weighted_log_cost": 0.3660210903528423
      },
      {
        "removed_dimensions": [
          1,
          3,
          7
        ],
        "root_float": 6.3964305536534e-05,
        "weighted_log_cost": 0.3660271385071058
      },
      {
        "removed_dimensions": [
          5,
          9
        ],
        "root_float": 6.396400969590711e-05,
        "weighted_log_cost": 0.36602882456069624
      },
      {
        "removed_dimensions": [
          1,
          3,
          5,
          7
        ],
        "root_float": 6.396397864316877e-05,
        "weighted_log_cost": 0.3660290113350689
      }
    ],
    "distinct_physical_profiles_tested": 57764,
    "random_seed": 20261009,
    "target_level_patterns": 924,
    "best_removed_dimensions": [],
    "best_root_float": 6.398301323982777e-05,
    "base_root_float": 6.398301323982777e-05,
    "qualified_new_physical_witness": false,
    "reason": "Any nontrivial ablation needs the new high-rank generic-pivot check; V release order preserved."
  },
  "limitations": [
    "Stage two as the complement time reversal of stage one is inherited and not machine checked here.",
    "Finite alphabet tape compilation and the general basis/algorithmic interfaces remain inherited lemmas.",
    "The complex profile and its full implementation are inherited from upstream round six; its moment arithmetic is audited locally.",
    "This is an asymptotic exponent certificate, not a runnable fast integer multiplier or a practical speed benchmark.",
    "Z replay uses four random samples; the actual F2 circuit is checked on its entire data and dirty scratch basis."
  ]
}
"
+    },
+    "b91de239a64d24d8aee409a0f4ac3e00710ae5c1": {
+      "type": "commit",
+      "base64": "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"
+    },
+    "c28b58b3fc19c97b4675b1f8e9b3651c59d51d0c": {
+      "type": "blob",
+      "base64": "{
  "status": "PASS",
  "changed_frames": [
    {
      "slot": 22966,
      "old_dim": 12,
      "new_dim": 13,
      "new_rank_exact": 13,
      "gram_determinant": "35586121596606",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 14,
      "cap_gram_rank_exact": 13,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 22970,
      "old_dim": 12,
      "new_dim": 13,
      "new_rank_exact": 13,
      "gram_determinant": "35586121596606",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 14,
      "cap_gram_rank_exact": 13,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 22974,
      "old_dim": 12,
      "new_dim": 13,
      "new_rank_exact": 13,
      "gram_determinant": "35586121596606",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 14,
      "cap_gram_rank_exact": 13,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 22980,
      "old_dim": 12,
      "new_dim": 13,
      "new_rank_exact": 13,
      "gram_determinant": "142344486386424",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 13,
      "cap_gram_rank_exact": 13,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 22982,
      "old_dim": 12,
      "new_dim": 13,
      "new_rank_exact": 13,
      "gram_determinant": "142344486386424",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 14,
      "cap_gram_rank_exact": 13,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23267,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23269,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23270,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23281,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23284,
      "old_dim": 12,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "640550188738908",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23324,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23325,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23327,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23328,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23354,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23406,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23434,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23445,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23451,
      "old_dim": 12,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "640550188738908",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23484,
      "old_dim": 13,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "2562200754955632",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23566,
      "old_dim": 12,
      "new_dim": 14,
      "new_rank_exact": 14,
      "gram_determinant": "10248803019822528",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 15,
      "cap_gram_rank_exact": 14,
      "maximal_for_fixed_later_frames": true
    },
    {
      "slot": 23671,
      "old_dim": 12,
      "new_dim": 13,
      "new_rank_exact": 13,
      "gram_determinant": "149259012157130932224",
      "old_contained": true,
      "start_contained": true,
      "target_contained": true,
      "cap_dimension": 14,
      "cap_gram_rank_exact": 13,
      "maximal_for_fixed_later_frames": true
    }
  ],
  "changed_count": 22,
  "dimension_increase": 25,
  "schedule_fields_identical": [
    "h",
    "R",
    "description",
    "ops",
    "hold",
    "start",
    "out",
    "ret",
    "node_dims",
    "late_dims",
    "vleaf_slots",
    "vleaf_start",
    "xs_order",
    "deferred_v_order",
    "claimed"
  ],
  "independent_exact_target_edges_checked": 119,
  "inherited_target_edges": 17902,
  "independently_recomputed_component_deltas": {
    "auxiliary": {
      "509": -24794,
      "511": 56672,
      "507": -31878
    },
    "slot_corners": {
      "1": -88550
    },
    "slot_chains": {
      "1": -88550
    },
    "targets": {}
  },
  "total_histogram_delta": {
    "509": -24794,
    "511": 56672,
    "507": -31878,
    "1": -177100
  },
  "preserved_rank": true,
  "source_hashes": {
    "experiments/round7-review/vendor/certificates/round7/deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c",
    "experiments/round7-review/saturated-Z.json.gz": "97df9481e5ae70645b8325315616aa0334ee990480e357bf0e21feb0a66447f4"
  },
  "seconds": 46.4001259803772,
  "limitations": [
    "Start-frame extraction uses pinned lifted-frame helper; all other matrix arithmetic in this review is local.",
    "Unchanged frame containment and generic pivots inherit separate complete baseline/candidate audits.",
    "Stage-two complementary time reversal and all-size tape/analytic transfer retain upstream proof assumptions."
  ]
}
"
+    },
+    "d1310f4ea13f968270418621d8fbcdf17e4063e9": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IGJydWhhdDgucHkA7OqNDYKsWPMccNujmsH1hk/Z2RsxMDA2NDQgY29ybmVycy5weQC3hog6vYwEXN+Ub16KyrAg504zpTEwMDY0NCBmbGFnX2V4aXN0ZW5jZS5weQDGm8bSBCG7v/9DITaXg8zViX6XFzEwMDY0NCBmbGFnYmFzaXMucHkAklCQo7k6iiCH2rqvcSn2Ps/dmjAxMDA2NDQgbW9tZW50LnB5AFg92ZfmLJLPP0MyDptjU3qxlYjl"
+    },
+    "de3fce68d8ca5c2985e3afea9b477482462596d6": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IGRlZmVycmVkXzIzLmpzb24uZ3oASkQxvUJapEmfJeZ99ODSzd198VwxMDA2NDQgd2l0bmVzc18yMy5qc29uLmd6AD2G+DuHG6B8OxViqm2VOuhrl1C6"
+    },
+    "de5ab489cf9f14b69dab43eb98f6f6ab2e028800": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IC5naXRhdHRyaWJ1dGVzAEGu8pD9DPGDjLDLoo4EqXtQboaSNDAwMDAgLmdpdGh1YgD+gO6CB2mjX/3rgkAwZbJ/pGOtnDEwMDY0NCAuZ2l0aWdub3JlAAxe+/HUWqdKo4X1hrBTxw4XCoMkMTAwNjQ0IENJVEFUSU9OLmNmZgBLDmUzQf0oKRGoDOTYfWQSy9i97zEwMDY0NCBDT05UUklCVVRJTkcubWQAQd78kCIr4mbHEIy3tvhowkWuiOwxMDA2NDQgQ09OVFJJQlVUT1JTLm1kANSQsPPGrVpVcsH3rgVecCwEBoRPMTAwNjQ0IExJQ0VOU0UAJh7rnp+LK0sNEZNm3amcb9fTXGQxMDA2NDQgTWFrZWZpbGUAhP6CkPNT81NaATEZXDXsoDwolgkxMDA2NDQgTk9USUNFALVlY3dYjylBDOQn9qNF7sNj1/h5MTAwNjQ0IFBBVENISU5HLm1kALYPPxAbvSM6UES3ohI+VQSk6AFhMTAwNjQ0IFJFQURNRS5tZAADXCWbaPSkzdhLNEUw6RjKBdSmwTEwMDY0NCBTT1VSQ0VTLmpzb24AYJbVr/kO3v1DgGr25HD8VNenedU0MDAwMCBhcnRpZmFjdHMAfXF6FhMg3zzeLRYitg2qINpxU380MDAwMCBjZXJ0aWZpY2F0ZXMAYyb6JQMWZh84wizhWNDQ/lEEvmE0MDAwMCBkb2NzAKZhKOgaKfxkr34J1IyMn4bxnWVaNDAwMDAgZm9ybWFsAHEYL44HbJQjNV/d6r9FGwyt6MWuNDAwMDAgbm90ZXMANv93/GSdOYgtn0mfY6I/TBZIeVM0MDAwMCBwYXRjaGVzAJS/+lmD/emP5dXj9YxIw+xhsqRPNDAwMDAgcmVmZXJlbmNlcwCbAG3k4efRj5q0EYIj7LQ5g6RdhDQwMDAwIHJlc2VhcmNoAF1wmHQ+2XThgVZOFNAbEgy9uxH1NDAwMDAgc2NyaXB0cwBym834jGR2jkE0fddRVovq+jo4ajQwMDAwIHRlc3RzADstXX6oBrc8AtDflMHUqx0KRd2kNDAwMDAgdXBzdHJlYW0A5E05YhtY4rNR+RB7n6Fw1qjU/hw="
+    },
+    "e2275608bd99dedc1626a53bc161b1eb3bfd1b2e": {
+      "type": "tree",
+      "base64": "MTAwNjQ0IGRlZmVycmVkLXJlYWRvdXQudGV4ANeavqd6W2WZGT00oJGfl3UzTSErMTAwNjQ0IHBhcnRpYWwtc3dhcC1iYXRjaGluZy50ZXgAyWR7oQB9UPyC1x7zvQ97d5EAXUQ="
+    },
+    "e8691cc07dd53dcfe74da1322793b2688fca4d51": {
+      "type": "blob",
+      "base64": "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"
+    }
+  },
+  "files": {
+    ".gitignore": {
+      "mode": "100644",
+      "blob": "23c63072fa71dcccfe8d049e031dbdb16ede21a6"
+    },
+    "LICENSE": {
+      "mode": "100644",
+      "blob": "57bc88a15a0ee8266c259b2667e64608d3f7e292"
+    },
+    "MANIFEST.json": {
+      "mode": "100644",
+      "blob": "bf5cd97a0f3d24629a7cba1aaf061ff0e87bdc0a"
+    },
+    "NOTICE": {
+      "mode": "100644",
+      "blob": "e8691cc07dd53dcfe74da1322793b2688fca4d51"
+    },
+    "PROVENANCE.json": {
+      "mode": "100644",
+      "blob": "1a93dcab54202f9253f43bc85f4e77c4b6bc17b4"
+    },
+    "README.md": {
+      "mode": "100644",
+      "blob": "5233203ef9bd87c44e9dd25b73609ea0f63d509f"
+    },
+    "experiments/round7-review/audit_evidence.py": {
+      "mode": "100644",
+      "blob": "a28e243c0b34f6a6710be6d52ac062148ac636d2"
+    },
+    "experiments/round7-review/check_arithmetic.py": {
+      "mode": "100644",
+      "blob": "303aa86ed7f5624b07cec362bdc563d20ac30580"
+    },
+    "experiments/round7-review/check_candidate_frames.py": {
+      "mode": "100644",
+      "blob": "bf2b0a57ca3ef25efbb055fea9e6c6568c7e935d"
+    },
+    "experiments/round7-review/histogram_engine.py": {
+      "mode": "100644",
+      "blob": "7f3e15349181d1abd0038eb7abd5a493a0a9442c"
+    },
+    "experiments/round7-review/qualification.json": {
+      "mode": "100644",
+      "blob": "b62e78100fb86a9fd133497c0188518f5056a668"
+    },
+    "experiments/round7-review/saturate_readouts.py": {
+      "mode": "100644",
+      "blob": "aac60e4243075735de0edf5c7753d13ac5bc75cc"
+    },
+    "experiments/round7-review/saturated-Z.json.gz": {
+      "mode": "100644",
+      "blob": "247b66b034e83a79ff1b0dc0932e1ed0a0177a0f"
+    },
+    "experiments/round7-review/saturation-results.json": {
+      "mode": "100644",
+      "blob": "163260325bb989eb0538b04c89e10d70eb0a2f88"
+    },
+    "experiments/round7-review/scalar_engine.py": {
+      "mode": "100644",
+      "blob": "ff5c8901d379ff397f1aa29eb0a8875f12c51848"
+    },
+    "experiments/round7-review/vendor/LICENSE": {
+      "mode": "100644",
+      "blob": "57bc88a15a0ee8266c259b2667e64608d3f7e292"
+    },
+    "experiments/round7-review/vendor/NOTICE": {
+      "mode": "100644",
+      "blob": "edc3efe722ed1ae69fa986555ec02907ad85434c"
+    },
+    "experiments/round7-review/vendor/README.md": {
+      "mode": "100644",
+      "blob": "747c705371b6d6aaa2c733f4f2b87460d2458427"
+    },
+    "experiments/round7-review/vendor/certificates/round7/deferred_23.json.gz": {
+      "mode": "100644",
+      "blob": "4a4431bd425aa4499f25e67df4e0d2cddd7df15c"
+    },
+    "experiments/round7-review/vendor/certificates/round7/witness_23.json.gz": {
+      "mode": "100644",
+      "blob": "3d86f83b871ba07c3b1562aa6d953ae86b9750ba"
+    },
+    "experiments/round7-review/vendor/independent/deferred-readout/check_frames.py": {
+      "mode": "100644",
+      "blob": "ecb1fdf4e014e7cd9651576bc1780650d1412dc2"
+    },
+    "experiments/round7-review/vendor/independent/deferred-readout/check_lifted.py": {
+      "mode": "100644",
+      "blob": "700514eb5b2d67eabbd4c39244865fe77e2959dd"
+    },
+    "experiments/round7-review/vendor/independent/deferred-readout/check_stair.py": {
+      "mode": "100644",
+      "blob": "f45c41cc5f476f55b399dd1d434f03077f8b94fe"
+    },
+    "experiments/round7-review/vendor/independent/deferred-readout/check_word.py": {
+      "mode": "100644",
+      "blob": "674571e0041c3e78f12ada13bc6cf3b1402ea799"
+    },
+    "experiments/round7-review/vendor/independent/deferred-readout/deferred.py": {
+      "mode": "100644",
+      "blob": "d045126217670dc82e7515230f9dc055ac9dc444"
+    },
+    "experiments/round7-review/vendor/independent/deferred-readout/linalg.py": {
+      "mode": "100644",
+      "blob": "06f57742ceb6fa0d8ee632200af5a0e875e93c4a"
+    },
+    "experiments/round7-review/vendor/independent/two-stage-bit/bruhat8.py": {
+      "mode": "100644",
+      "blob": "ecea8d0d82ac58f31c70dba39ac1f5864fd9d91b"
+    },
+    "experiments/round7-review/vendor/independent/two-stage-bit/corners.py": {
+      "mode": "100644",
+      "blob": "b786883abd8c045cdf946f5e8acab020e74e33a5"
+    },
+    "experiments/round7-review/vendor/independent/two-stage-bit/flag_existence.py": {
+      "mode": "100644",
+      "blob": "c69bc6d20421bbbfff4321369783ccd5897e9717"
+    },
+    "experiments/round7-review/vendor/independent/two-stage-bit/flagbasis.py": {
+      "mode": "100644",
+      "blob": "925090a3b93a8a2087dabaaf7129f63ecfdd9a30"
+    },
+    "experiments/round7-review/vendor/independent/two-stage-bit/moment.py": {
+      "mode": "100644",
+      "blob": "583dd997e62c92cf3f43320e9b63537ab19588e5"
+    },
+    "experiments/round7-review/vendor/lean/Round7.lean": {
+      "mode": "100644",
+      "blob": "2fc16394157f2d05790002fc79230e632bf90e15"
+    },
+    "experiments/round7-review/vendor/lean/round7-histograms.json": {
+      "mode": "100644",
+      "blob": "ceaa8c0111b34878443d0e561d02b8f72a97d2df"
+    },
+    "experiments/round7-review/vendor/notes/deferred-readout.tex": {
+      "mode": "100644",
+      "blob": "d79abea77a5b6599193d34a0919f9775334d212b"
+    },
+    "experiments/round7-review/vendor/notes/partial-swap-batching.tex": {
+      "mode": "100644",
+      "blob": "c9647ba1007d50fc82d71ef3bd0f7b7791005d44"
+    },
+    "experiments/round7-review/vendor/scripts/certificate_round3.py": {
+      "mode": "100644",
+      "blob": "f5ac54082ac92a21ace7323aa948f65e329af657"
+    },
+    "experiments/round7-review/vendor/scripts/certificate_round7.py": {
+      "mode": "100644",
+      "blob": "ce8225c599e8beb33a2d160613e1ba4618f31d33"
+    },
+    "experiments/saturation-review/review.py": {
+      "mode": "100644",
+      "blob": "db76d35e1efc30c7ef47eb984e6c9de5eb978aa0"
+    },
+    "historical/REPORT.md": {
+      "mode": "100644",
+      "blob": "8bf7e38c940166957afce0bcc590d3ec67de0ec5"
+    },
+    "historical/candidate-frames-check.log": {
+      "mode": "100644",
+      "blob": "f6d405ebd4c6714d0f7f3ff9fe91b5b773580766"
+    },
+    "historical/candidate-scalar-results.json": {
+      "mode": "100644",
+      "blob": "91595e214ac32be74f6dba09fd1da1904c8ad315"
+    },
+    "historical/qualification-saturated.json": {
+      "mode": "100644",
+      "blob": "12a68ec737b984ebf60e107e07ab3e2b7eb74ad1"
+    },
+    "historical/results.json": {
+      "mode": "100644",
+      "blob": "c28b58b3fc19c97b4675b1f8e9b3651c59d51d0c"
+    },
+    "historical/saturated-balanced-compatibility.json": {
+      "mode": "100644",
+      "blob": "3d50be4704555b12c0463c4ab0612fd152ee5a71"
+    },
+    "scripts/check_research.py": {
+      "mode": "100644",
+      "blob": "6d69bf1ba6ca09e909cde911822099dfaf3b89ad"
+    },
+    "verify.py": {
+      "mode": "100644",
+      "blob": "62da642c1eeba52ab60556cc56af649a9d983fc8"
+    }
+  }
+}
diff --git a/research/pr99-retention-seed99/SOURCES.json b/research/pr99-retention-seed99/SOURCES.json
new file mode 100644
index 0000000000..22d66ed017
--- /dev/null
+++ b/research/pr99-retention-seed99/SOURCES.json
@@ -0,0 +1,42 @@
+{
+  "schema_version": 1,
+  "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb",
+      "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce"
+    },
+    {
+      "path": "research/community-reconciliation92-audit/ARCHIVE.json",
+      "usage": "input",
+      "git_blob": "2aeeb50a033c9b72ca5536cc3473263d08e24248",
+      "sha256": "3de2b360ce5cee8a0dc68a322c7db81a2bd3ca714d76aed57156cc889103b890"
+    },
+    {
+      "path": "research/community-reconciliation92-audit/REVIEW.json",
+      "usage": "input",
+      "git_blob": "a398bea6a26bccf7c7f86ad3477bd5b2489d52ae",
+      "sha256": "e38ce3a9fc5b3cc788e618885b6ba5c54a2b00f272cdfdfcd6accf66a20faf8f"
+    },
+    {
+      "path": "docs/research/pr-ledger.json",
+      "usage": "provenance",
+      "git_blob": "466e1ba17030149e42fa8acefced4359b97728a2",
+      "sha256": "6063d9227279dcc91f03fab89f5d93a9cb66c0719b394ff9a03ce58239bfd454"
+    },
+    {
+      "path": "CONTRIBUTORS.md",
+      "usage": "provenance",
+      "git_blob": "dc9d4f5de07725f56d90a7a2673f82af52e2c44b",
+      "sha256": "c37caf0a5783aef24f981cb0110bd1764bc5ec9535a58bc62af7170c10b3a8ae"
+    }
+  ]
+}
diff --git a/research/pr99-retention-seed99/TASK.json b/research/pr99-retention-seed99/TASK.json
new file mode 100644
index 0000000000..6e71054d53
--- /dev/null
+++ b/research/pr99-retention-seed99/TASK.json
@@ -0,0 +1,138 @@
+{
+  "schema_version": 1,
+  "task_id": "overlap-receipt",
+  "priority_revision": 2,
+  "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f",
+  "original_card": {
+    "id": "overlap-receipt",
+    "question": "What exact content and credit of a small named PR set has already been retained?",
+    "starting_points": [
+      "docs/research/pr-ledger.md",
+      "CONTRIBUTORS.md"
+    ],
+    "methods": [
+      "Compare exact heads and retained artifacts to write a source-bound disposition receipt.",
+      "Audit an existing receipt for missing content or predecessor attribution."
+    ],
+    "acceptance_gate": "Separate complete integration, partial retention and changed heads; make no autonomous closures.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read one small PR set in the ledger and identify exact reviewed heads and unresolved content.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Compare that set to retained artifacts; produce a complete or explicitly partial disposition receipt.",
+    "bottleneck_link": "Reliable overlap evidence preserves credit and prevents repeated review of already-retained material.",
+    "allowed_variations": [
+      "One small related PR family or one existing integration receipt."
+    ],
+    "scope_change_triggers": [
+      "Treating matching titles or one shared blob as proof of full incorporation."
+    ],
+    "overlap_terms": [
+      "overlap receipt",
+      "partial integration",
+      "attribution"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Authenticate complete PR99 source retention through incorporated PR103 and reconcile its saved rank-profile delta.",
+  "scope_change_reason": "Narrow the overlap-receipt card to one parent contribution and its retained vendor subtree; no selected-frontier change or new physical replay.",
+  "bottleneck_link": "Resolve a concrete missing retention and individual-credit link so review can reuse the exact historical package without confusing retention with proof acceptance.",
+  "budget_minutes": 45,
+  "stop_rule": "Stop after the complete 46-file identity, original commit-diff coverage, saved-profile reconciliation and failure controls are established; do not rerun the historical full construction or search for a new circuit.",
+  "outcome": "completed",
+  "evidence": "SOURCE-PROOF.json, RESULT.json, verify.py, test_verify.py; source retention and saved-report accounting only.",
+  "author": "Hanson Sun (@bbMisk)",
+  "ai_assistance": "Substantial OpenAI Codex assistance in investigation, implementation, verification and writing; no independent human review claimed.",
+  "open_questions": [],
+  "assignment_seed": 99,
+  "seed_source": "Python secrets.randbelow(100), using operating-system randomness",
+  "seed_use": "Select historical PR99 as the concrete provenance object within the assigned consolidation track.",
+  "no_open_questions_reason": "The complete original change is retained; no further source-retention experiment is justified. Mathematical acceptance and inherited physical/compiler/analytic obligations remain outside this receipt.",
+  "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18912011",
+  "candidates": [
+    {
+      "object": "PR99 through PR103",
+      "decision": "chosen: complete source retention has no ledger integration pointer and individual credit is absent from root CONTRIBUTORS; seed 99 diversifies to this older source"
+    },
+    {
+      "object": "PR279 parent source closure",
+      "decision": "deferred: PR1190 already provides complete closure; discussion1336 independently audits it"
+    },
+    {
+      "object": "historical current-result routing",
+      "decision": "deferred: PR1232 and PR1285 already cover the relevant navigation gaps"
+    }
+  ],
+  "overlap_at_entry": {
+    "searched_at": "2026-10-14T00:23:00.134424+00:00",
+    "terms": [
+      "PR99",
+      "nondegenerate readout",
+      "saturated-balanced"
+    ],
+    "coverage": {
+      "open_prs": {
+        "fetched_at": "2026-10-14T00:22:41.848563+00:00",
+        "complete_pagination": true,
+        "records": 873
+      },
+      "discussions": {
+        "fetched_at": "2026-10-14T00:23:00.090065+00:00",
+        "complete_pagination": true,
+        "records": 132
+      }
+    },
+    "local_records": 325,
+    "warnings": [],
+    "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.",
+    "finding": "No same-object PR99 retention claim found. Literal PR99 matches mostly refer to PR99x. All returned leads were inspected; no absence-of-novelty proof claimed."
+  },
+  "overlap_before_submission": {
+    "searched_at": "2026-10-14T00:34:24.904990+00:00",
+    "terms": [
+      "nondegenerate readout",
+      "nondegenerate-readout-saturation",
+      "saturated-balanced",
+      "PR99 retention"
+    ],
+    "coverage": {
+      "open_prs": {
+        "fetched_at": "2026-10-14T00:34:10.047124+00:00",
+        "complete_pagination": true,
+        "records": 785
+      },
+      "discussions": {
+        "fetched_at": "2026-10-14T00:34:24.865859+00:00",
+        "complete_pagination": true,
+        "records": 144
+      }
+    },
+    "local_records": 327,
+    "warnings": [],
+    "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.",
+    "finding": "The only three matches were this package README, its TASK metadata and its own coordination claim; no same-object competing contribution was observed."
+  },
+  "submission_base_commit": "410026dc5513b87db92ae98571d1d5984c69a983",
+  "verification": {
+    "python_versions": [
+      "3.12.13",
+      "3.14.6"
+    ],
+    "registered_python312_replay": "passed; read-only checker plus 18 tests (1 positive, 17 rejection controls), optimized mode",
+    "source_export": "passed with no .git directory and PATH=/nonexistent",
+    "independent_git_native_comparison": "all 46 paths/modes/blobs and the full 46-addition original commit diff agree",
+    "collector_reproduction": "SOURCE-PROOF.json byte-identical on recollection; all 46 original and retained payloads compared directly",
+    "selected_record_check": "passed; selected kappa remains 0.001672660197076918",
+    "not_run": [
+      "historical PR99 or PR103 physical/native/full construction replay",
+      "selected frontier1094 cold replay",
+      "Lean proof build"
+    ]
+  }
+}
diff --git a/research/pr99-retention-seed99/UPSTREAM-NOTICE b/research/pr99-retention-seed99/UPSTREAM-NOTICE
new file mode 100644
index 0000000000..e8691cc07d
--- /dev/null
+++ b/research/pr99-retention-seed99/UPSTREAM-NOTICE
@@ -0,0 +1,47 @@
+Past the a_b/2 ceiling for integer multiplication
+Copyright 2026 Swapnil Jain
+
+This work builds on, and does not modify, the following:
+
+- OpenAI, "Integer multiplication below n log n" (September 23, 2026), pinned at
+  commit adc7f1241b42e322a6451854ab7e4b4c146bf78a of github.com/openai/math.
+- Douglas Colkitt, github.com/CrocSwap/integer-mult-bounds (Apache-2.0), commit
+  6e564879f51ae16f23d392e9e196c605f36d90df: compact controls and the conditional
+  83/10^12 witness.
+- Prior published results this witness assumes and cites (citations of prior work,
+  not collaborators), from open pull requests on that repository:
+  #3 and #5 (eumemic: compressed complex network, fast Gaussian resampling),
+  #4 (dleen), #6 (eumemic), #7 (Zhihao Chen / jacklightChen: ternary five-subset
+  networks, a_b = 3/(4*10^8), a_c = 39/10^9),
+  #10 (icekylinx: batched recursion, controlled projector basis, whole-residual
+  complex children, Gaussian input-error correction),
+  #13 (eumemic: auxiliary source frames, third whole-residual complex class),
+  #15 (eumemic, head a17cab3: full complex batching of every residual rank),
+  #18 (icekylinx, head f2ab41a: partial-swap networks, producers and common rational basis),
+  #21 (jacklightChen, head 5ba6cf0: translated partial-swap frames; it also contains, independently
+  and earlier in public, the complex source-frame translation we use),
+  #16 (jacklightChen: nested controlled bases) and #29 (jacklightChen: controlled inner basis compiling local
+  edges as blocks), related to our flag basis and side-role batching, which were developed independently,
+  #36 (icekylinx: copied retained centres, used on both our interchanges in rounds six and seven),
+  #62 (ikeboy: interval strips and core-aware pair assembly; its producer builds our round-seven side program),
+  #41 (RaD / hipotures: the alternating order and links, used in that side program),
+  #44 (rohanarun: weighted matching, which our moment-weighted choice of links follows),
+  #24 (icekylinx, head ed90fd9: endpoint-gauge bit network; certificates/external/pr24-bit-network.json
+  extracts its published counts and child-width multiplicities, Apache-2.0).
+- Aurel Prosz (Paureel), github.com/Paureel/integer-mult-bounds commit c82d09e:
+  the two-stage motif with partial-swap frames and charged endpoint correction, and its complement-frame
+  construction, which our lifted frames follow in round seven.
+
+Research, implementation and drafting were done with assistance from Claude
+(Anthropic). AI assistance is not independent review.
+
+
+Nondegenerate readout saturation research extension
+Copyright 2026 djsmanchanda and contributors
+Substantial OpenAI Codex assistance was used for exploration, implementation,
+verification and drafting. AI cross-checks are not independent human review.
+
+Zhihao Chen / jacklightChen PR97 is credited for reflected/gauged bit ledgers,
+signed complex endpoint controls and retained-main-assembly integration used
+in the separate compatibility experiment, not reproduced by the quick check.
+https://github.com/CrocSwap/integer-mult-bounds/pull/97
diff --git a/research/pr99-retention-seed99/VERIFY.json b/research/pr99-retention-seed99/VERIFY.json
new file mode 100644
index 0000000000..f85feaca49
--- /dev/null
+++ b/research/pr99-retention-seed99/VERIFY.json
@@ -0,0 +1,34 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/community-reconciliation92-audit/ARCHIVE.json",
+    "research/community-reconciliation92-audit/REVIEW.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 30,
+      "checks": "Authenticate both package trees and complete PR99 commit difference, archive ancestry, exact review head and four saved accounting reports."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/test_verify.py"
+      ],
+      "timeout_seconds": 30,
+      "checks": "One real-evidence positive case and 17 source coverage, corruption, provenance and accounting failure controls."
+    }
+  ]
+}
diff --git a/research/pr99-retention-seed99/collect.py b/research/pr99-retention-seed99/collect.py
new file mode 100644
index 0000000000..baeca78664
--- /dev/null
+++ b/research/pr99-retention-seed99/collect.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Recollect the bounded raw-Git proof. Needs the pinned source objects locally.
+
+Fetch missing objects with `git fetch origin refs/pull/99/head` and
+`git fetch origin tag archive/pr-reconciliation100-20261013`.
+No network request or execution of archived code is made by this collector.
+Hanson Sun, with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import argparse
+import base64
+import json
+from pathlib import Path
+import subprocess
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from verify import ARCHIVE, BLOBS, ORIGINAL, PARENT, PR99, PR103, RETAINED, ROOT
+
+
+def git(*args):
+    return subprocess.check_output(["git", *args], cwd=ROOT)
+
+
+def collect():
+    objects = {}
+
+    def save(kind, oid):
+        raw = git("cat-file", kind, oid)
+        objects[oid] = {"type": kind, "base64": base64.b64encode(raw).decode("ascii")}
+        return raw
+
+    def tree(oid):
+        save("tree", oid)
+        result = {}
+        for record in git("ls-tree", "-z", oid).split(b"\0"):
+            if not record:
+                continue
+            meta, name = record.split(b"\t", 1)
+            mode, kind, child = meta.decode("ascii").split()
+            result[name.decode("utf-8")] = ("40000" if kind == "tree" else mode, kind, child)
+        return result
+
+    def commit(oid):
+        save("commit", oid)
+        return git("rev-parse", oid + "^{tree}").decode().strip()
+
+    def resolve(oid, path):
+        node = commit(oid)
+        for part in path.split("/"):
+            _, kind, node = tree(node)[part]
+        return kind, node
+
+    def inventory(oid, prefix=""):
+        result = {}
+        for name, (mode, kind, child) in tree(oid).items():
+            path = prefix + name
+            if kind == "tree":
+                result.update(inventory(child, path + "/"))
+            else:
+                result[path] = {"mode": mode, "blob": child}
+        return result
+
+    def changed_trees(a, b):
+        if a == b:
+            return
+        left, right = tree(a), tree(b)
+        for name in set(left) | set(right):
+            x, y = left.get(name), right.get(name)
+            if x != y and x and y and x[1] == y[1] == "tree":
+                changed_trees(x[2], y[2])
+
+    source = resolve(PR99, ORIGINAL)[1]
+    retained = resolve(PR103, RETAINED)[1]
+    if source != retained:
+        raise ValueError("source and retained subtree differ")
+    files = inventory(source)
+    changed_trees(commit(PARENT), commit(PR99))
+    commit(ARCHIVE)
+    for _, (head, path) in BLOBS.items():
+        kind, oid = resolve(head, path)
+        save(kind, oid)
+    # Git-native full-file comparison is a separate collection-time check.
+    # The offline checker proves identity through the authenticated tree DAG.
+    for path in files:
+        original = git("show", PR99 + ":" + ORIGINAL + "/" + path)
+        retained_raw = git("show", PR103 + ":" + RETAINED + "/" + path)
+        if original != retained_raw:
+            raise ValueError("payload mismatch: " + path)
+    return {"schema_version": 1, "objects": dict(sorted(objects.items())), "files": dict(sorted(files.items()))}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    document = collect()
+    args.output.write_text(json.dumps(document, indent=2) + "\n")
+    print(f"COLLECTED_PR99_RETENTION files={len(document['files'])} objects={len(document['objects'])}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/pr99-retention-seed99/test_verify.py b/research/pr99-retention-seed99/test_verify.py
new file mode 100644
index 0000000000..b8cea1a945
--- /dev/null
+++ b/research/pr99-retention-seed99/test_verify.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Corruption, coverage and accounting controls on the real pinned evidence.
+
+Hanson Sun, with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import base64
+from copy import deepcopy
+from pathlib import Path
+import sys
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import verify as v
+
+
+class RetentionControls(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.document = v.loads((v.HERE / "SOURCE-PROOF.json").read_bytes())
+        cls.archive, cls.reviews = v.external_inputs()
+        proof = v.Proof(cls.document)
+        cls.data = {role: v.loads(proof.blob(role)) for role in v.BLOBS if role != "original_notice"}
+
+    def check(self, document=None, archive=None, reviews=None):
+        return v.verify(self.document if document is None else document,
+                        self.archive if archive is None else archive,
+                        self.reviews if reviews is None else reviews)
+
+    def test_complete_positive_case(self):
+        self.assertEqual(self.check(), v.loads((v.HERE / "RESULT.json").read_bytes()))
+
+    def test_omitted_package_file(self):
+        doc = deepcopy(self.document)
+        del doc["files"]["experiments/round7-review/saturated-Z.json.gz"]
+        with self.assertRaisesRegex(ValueError, "inventory"):
+            self.check(document=doc)
+
+    def test_same_count_file_substitution(self):
+        doc = deepcopy(self.document)
+        row = doc["files"].pop("NOTICE")
+        doc["files"]["unrelated-NOTICE"] = row
+        with self.assertRaisesRegex(ValueError, "inventory"):
+            self.check(document=doc)
+
+    def test_mode_substitution(self):
+        doc = deepcopy(self.document)
+        doc["files"]["README.md"]["mode"] = "100755"
+        with self.assertRaisesRegex(ValueError, "inventory"):
+            self.check(document=doc)
+
+    def test_commit_byte_corruption(self):
+        doc = deepcopy(self.document)
+        obj = doc["objects"][v.PR99]
+        obj["base64"] = base64.b64encode(base64.b64decode(obj["base64"]) + b"\n").decode()
+        with self.assertRaisesRegex(ValueError, "digest mismatch"):
+            self.check(document=doc)
+
+    def test_missing_comparison_parent(self):
+        doc = deepcopy(self.document)
+        del doc["objects"][v.PARENT]
+        with self.assertRaisesRegex(ValueError, "missing Git object"):
+            self.check(document=doc)
+
+    def test_missing_descendant_tree(self):
+        doc = deepcopy(self.document)
+        proof = v.Proof(doc)
+        _, oid = proof.resolve(v.PR99, v.ORIGINAL + "/experiments/round7-review/vendor/lean")
+        del doc["objects"][oid]
+        with self.assertRaisesRegex(ValueError, "missing Git object"):
+            self.check(document=doc)
+
+    def test_accounting_blob_corruption(self):
+        doc = deepcopy(self.document)
+        proof = v.Proof(doc)
+        _, oid = proof.resolve(*v.BLOBS["bit_ledger"])
+        doc["objects"][oid]["base64"] = base64.b64encode(b"{}").decode()
+        with self.assertRaisesRegex(ValueError, "digest mismatch"):
+            self.check(document=doc)
+
+    def test_archive_omits_retaining_parent(self):
+        archive = deepcopy(self.archive)
+        archive["parents"].remove(v.PR103)
+        with self.assertRaisesRegex(ValueError, "archive receipt"):
+            self.check(archive=archive)
+
+    def test_review_head_substitution(self):
+        reviews = deepcopy(self.reviews)
+        reviews["103"]["head"] = v.PR99
+        with self.assertRaisesRegex(ValueError, "different head"):
+            self.check(reviews=reviews)
+
+    def test_duplicate_json_key(self):
+        with self.assertRaisesRegex(ValueError, "duplicate JSON key"):
+            v.loads('{"files":{},"files":{"NOTICE":{}}}')
+
+    def test_duplicate_histogram_rank(self):
+        data = deepcopy(self.data)
+        hist = data["candidate"]["Z"]["histogram"]["hist"]
+        hist.append(hist[0])
+        with self.assertRaisesRegex(ValueError, "duplicate histogram rank"):
+            v.check_accounting(**data)
+
+    def test_duplicate_changed_slot(self):
+        data = deepcopy(self.data)
+        changes = data["candidate"]["Z"]["changes"]
+        changes[1]["slot"] = changes[0]["slot"]
+        with self.assertRaisesRegex(ValueError, "duplicate changed slot"):
+            v.check_accounting(**data)
+
+    def test_omitted_double_extension(self):
+        data = deepcopy(self.data)
+        changes = data["candidate"]["Z"]["changes"]
+        next(c for c in changes if c["new_dim"] - c["old_dim"] == 2)["new_dim"] -= 1
+        with self.assertRaisesRegex(ValueError, "dimension increase"):
+            v.check_accounting(**data)
+
+    def test_changed_width(self):
+        data = deepcopy(self.data)
+        data["candidate"]["Z"]["histogram"]["W"] += 1
+        with self.assertRaisesRegex(ValueError, "common parameter"):
+            v.check_accounting(**data)
+
+    def test_mass_preserving_wrong_profile(self):
+        data = deepcopy(self.data)
+        hist = data["candidate"]["Z"]["histogram"]["hist"]
+        # -3 H1 + H3 preserves total rank, but is not the retained profile.
+        for entry in hist:
+            if entry[0] == 1:
+                entry[1] -= 3
+            if entry[0] == 3:
+                entry[1] += 1
+        with self.assertRaisesRegex(ValueError, "22 recorded mergers"):
+            v.check_accounting(**data)
+
+    def test_component_charge_omission(self):
+        data = deepcopy(self.data)
+        data["prior_review"]["independently_recomputed_component_deltas"]["slot_chains"] = {}
+        with self.assertRaisesRegex(ValueError, "component accounting"):
+            v.check_accounting(**data)
+
+    def test_pr103_histogram_substitution(self):
+        data = deepcopy(self.data)
+        data["bit_ledger"]["histogram"] = {str(k): n for k, n in data["baseline"]["histogram"]["hist"]}
+        with self.assertRaisesRegex(ValueError, "exact candidate histogram"):
+            v.check_accounting(**data)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)
diff --git a/research/pr99-retention-seed99/verify.py b/research/pr99-retention-seed99/verify.py
new file mode 100644
index 0000000000..c3b24130fb
--- /dev/null
+++ b/research/pr99-retention-seed99/verify.py
@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Offline PR99 source-retention proof and saved-profile reconciliation.
+
+Hanson Sun, with substantial OpenAI Codex assistance. Apache-2.0.
+This checks source identity and recorded accounting, not physical execution.
+"""
+import argparse
+import base64
+from collections import Counter
+import hashlib
+import json
+from pathlib import Path
+import re
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+BASE = "bce54fb3f895cbe5cd4c0eb477c3afeed100190f"
+PARENT = "56b66d58297deca1d7dd130247d720e960f77a37"
+PR99 = "0622dcce6a897567e4eb6bdfedc7def66ab21346"
+PR103 = "75ab1f70d146c21c7611ce0df9eb5f645f51ac0e"
+ARCHIVE = "b91de239a64d24d8aee409a0f4ac3e00710ae5c1"
+ORIGINAL = "research/nondegenerate-readout-saturation"
+RETAINED = "research/saturated-balanced/vendor/pr99"
+COMMON_TREE = "6bebd79406bb2453ada2b7761aece13d3e53b694"
+INPUTS = (
+    "research/community-reconciliation92-audit/ARCHIVE.json",
+    "research/community-reconciliation92-audit/REVIEW.json",
+)
+BLOBS = {
+    "baseline": (PR99, ORIGINAL + "/experiments/round7-review/qualification.json"),
+    "candidate": (PR99, ORIGINAL + "/experiments/round7-review/saturation-results.json"),
+    "prior_review": (PR99, ORIGINAL + "/historical/results.json"),
+    "bit_ledger": (PR103, "research/saturated-balanced/bit-ledger.json"),
+    "original_notice": (PR99, ORIGINAL + "/NOTICE"),
+}
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def no_duplicate_keys(pairs):
+    result = {}
+    for key, value in pairs:
+        require(key not in result, "duplicate JSON key: " + key)
+        result[key] = value
+    return result
+
+
+def loads(raw):
+    return json.loads(raw, object_pairs_hook=no_duplicate_keys)
+
+
+def git_id(kind, raw):
+    return hashlib.sha1(kind.encode() + b" " + str(len(raw)).encode() + b"\0" + raw).hexdigest()
+
+
+class Proof:
+    def __init__(self, document):
+        require(document["schema_version"] == 1, "unsupported proof schema")
+        self.objects = document["objects"]
+        self.used = set()
+
+    def raw(self, oid, kind):
+        require(re.fullmatch(r"[0-9a-f]{40}", oid) is not None, "invalid Git id")
+        require(oid in self.objects, "missing Git object: " + oid)
+        obj = self.objects[oid]
+        require(obj["type"] == kind, "Git object type mismatch")
+        raw = base64.b64decode(obj["base64"], validate=True)
+        require(git_id(kind, raw) == oid, "Git object digest mismatch: " + oid)
+        self.used.add(oid)
+        return raw
+
+    def commit(self, oid):
+        header = self.raw(oid, "commit").split(b"\n\n", 1)[0].decode("utf-8").splitlines()
+        trees = [line[5:] for line in header if line.startswith("tree ")]
+        require(len(trees) == 1, "commit needs one tree")
+        return trees[0], [line[7:] for line in header if line.startswith("parent ")]
+
+    def tree(self, oid):
+        raw, offset, entries = self.raw(oid, "tree"), 0, {}
+        while offset < len(raw):
+            space = raw.find(b" ", offset)
+            zero = raw.find(b"\0", space + 1)
+            require(space > offset and zero > space + 1 and zero + 21 <= len(raw),
+                    "malformed Git tree")
+            mode = raw[offset:space].decode("ascii")
+            name = raw[space + 1:zero].decode("utf-8")
+            require(mode in ("40000", "100644", "100755", "120000"), "unsupported tree mode")
+            require(name not in (".", "..") and "/" not in name and name not in entries,
+                    "invalid or duplicate tree path")
+            entries[name] = (mode, raw[zero + 1:zero + 21].hex())
+            offset = zero + 21
+        return entries
+
+    def resolve(self, commit, path, expected_mode=None):
+        parts = path.split("/")
+        require(all(p and p not in (".", "..") for p in parts), "invalid requested path")
+        oid, _ = self.commit(commit)
+        mode = "40000"
+        for part in parts:
+            require(mode == "40000", "path traverses a non-directory")
+            entries = self.tree(oid)
+            require(part in entries, "missing path component: " + part)
+            mode, oid = entries[part]
+        if expected_mode is not None:
+            require(mode == expected_mode, "path mode mismatch: " + path)
+        return mode, oid
+
+    def inventory(self, tree, prefix=""):
+        result = {}
+        for name, (mode, oid) in self.tree(tree).items():
+            path = prefix + name
+            if mode == "40000":
+                result.update(self.inventory(oid, path + "/"))
+            else:
+                result[path] = {"mode": mode, "blob": oid}
+        return result
+
+    def difference(self, before, after, prefix=""):
+        """Walk every changed subtree; equal Git trees are skipped exactly."""
+        if before == after:
+            return {}
+        left, right = self.tree(before), self.tree(after)
+        changed = {}
+        for name in sorted(set(left) | set(right)):
+            a, b = left.get(name), right.get(name)
+            path = prefix + name
+            if a == b:
+                continue
+            if a is None and b[0] == "40000":
+                changed.update({p: {"before": None, "after": row}
+                                for p, row in self.inventory(b[1], path + "/").items()})
+            elif a is not None and b is not None and a[0] == b[0] == "40000":
+                changed.update(self.difference(a[1], b[1], path + "/"))
+            else:
+                changed[path] = {
+                    "before": None if a is None else {"mode": a[0], "blob": a[1]},
+                    "after": None if b is None else {"mode": b[0], "blob": b[1]},
+                }
+        return changed
+
+    def blob(self, role):
+        commit, path = BLOBS[role]
+        _, oid = self.resolve(commit, path, "100644")
+        return self.raw(oid, "blob")
+
+
+def histogram(pairs, width):
+    out = {}
+    for rank, count in pairs:
+        require(type(rank) is int and type(count) is int and 0 < rank <= width and count > 0,
+                "invalid histogram entry")
+        require(rank not in out, "duplicate histogram rank")
+        out[rank] = count
+    require(bool(out), "empty histogram")
+    return out
+
+
+def nonzero(counter):
+    return {str(k): v for k, v in sorted(counter.items()) if v}
+
+
+def check_accounting(baseline, candidate, prior_review, bit_ledger):
+    """Reconcile authenticated saved reports; do not call their producer code."""
+    old, candidate = baseline["histogram"], candidate["Z"]
+    new = candidate["histogram"]
+    for key in ("h", "m", "v", "N", "W", "L", "s", "R"):
+        require(type(old[key]) is int and old[key] == new[key], "changed common parameter: " + key)
+    require((old["h"], old["m"], old["v"]) == (23, 529, 1771), "wrong historical instance")
+    before, after = histogram(old["hist"], old["m"]), histogram(new["hist"], new["m"])
+    changes = candidate["changes"]
+    require(len({c["slot"] for c in changes}) == len(changes), "duplicate changed slot")
+    require(len(changes) == candidate["changed_slots"] == 22, "changed-slot count mismatch")
+    steps, expected, types = 0, Counter(), Counter()
+    for c in changes:
+        a, b = c["old_dim"], c["new_dim"]
+        require(type(a) is int and type(b) is int and 0 <= a < b <= old["h"],
+                "invalid frame extension")
+        steps += b - a
+        types[a, b] += 1
+        r0, r1 = old["m"] - 2 * (old["h"] - a), old["m"] - 2 * (old["h"] - b)
+        multiplicity = 2 * old["v"]
+        expected[r0] -= multiplicity
+        expected[r1] += multiplicity
+        expected[1] -= multiplicity * (r1 - r0)
+    require(steps == candidate["dimension_increase"] == 25, "dimension increase mismatch")
+    delta = Counter(after)
+    delta.subtract(before)
+    require(nonzero(delta) == nonzero(expected), "saved delta differs from the 22 recorded mergers")
+    require(nonzero(delta) == prior_review["total_histogram_delta"], "prior delta receipt mismatch")
+    require(prior_review["changed_count"] == 22 and prior_review["dimension_increase"] == 25,
+            "prior frame count mismatch")
+    recorded_components = Counter()
+    for component in prior_review["independently_recomputed_component_deltas"].values():
+        recorded_components.update({int(k): v for k, v in component.items()})
+    require(nonzero(recorded_components) == nonzero(delta), "prior component accounting mismatch")
+    for hist in (before, after):
+        require(sum(rank * count for rank, count in hist.items()) == old["s"], "recursive mass mismatch")
+    retained = histogram([(int(k), v) for k, v in bit_ledger["histogram"].items()], new["m"])
+    require(retained == after, "PR103 does not retain the exact candidate histogram")
+    require(bit_ledger["recursive_rank"] == old["s"], "PR103 recursive mass mismatch")
+    require(bit_ledger["roles"] == old["R"], "PR103 auxiliary role mismatch")
+    return {
+        "changed_frames": len(changes), "dimension_increase": steps,
+        "frame_extension_counts": {f"{a}->{b}": n for (a, b), n in sorted(types.items())},
+        "histogram_delta": nonzero(delta), "rank_mass_delta": sum(k * v for k, v in delta.items()),
+        "recursive_rank": old["s"], "width": old["W"], "auxiliary_roles": old["R"],
+        "pr103_saved_histogram_matches": True,
+    }
+
+
+def external_inputs():
+    pins = loads((HERE / "SOURCES.json").read_bytes())
+    require(pins["base_commit"] == BASE, "wrong research base")
+    rows = {row["path"]: row for row in pins["files"] if row["usage"] == "input"}
+    require(set(rows) == set(INPUTS), "external input coverage changed")
+    result = []
+    for path in INPUTS:
+        raw = (ROOT / path).read_bytes()
+        require(hashlib.sha256(raw).hexdigest() == rows[path]["sha256"], "external source drift: " + path)
+        require(git_id("blob", raw) == rows[path]["git_blob"], "external blob drift: " + path)
+        result.append(loads(raw))
+    return result
+
+
+def verify(document, archive, reviews):
+    proof = Proof(document)
+    original_tree, original_parents = proof.commit(PR99)
+    require(original_parents == [PARENT], "PR99 comparison parent changed")
+    parent_tree, _ = proof.commit(PARENT)
+    _, source = proof.resolve(PR99, ORIGINAL, "40000")
+    _, retained = proof.resolve(PR103, RETAINED, "40000")
+    require(source == retained == COMMON_TREE, "complete package trees differ")
+    files = proof.inventory(source)
+    require(len(files) == 46 and files == document["files"], "incomplete or changed package inventory")
+    difference = proof.difference(parent_tree, original_tree)
+    expected = {ORIGINAL + "/" + path: {"before": None, "after": row} for path, row in files.items()}
+    require(difference == expected, "PR99 has changes outside the retained package")
+    archive_tree, archive_parents = proof.commit(ARCHIVE)
+    require(archive["commit"] == ARCHIVE and archive["tree"] == archive_tree
+            and archive["parents"] == archive_parents, "archive receipt does not match its Git commit")
+    require(PR103 in archive_parents, "PR103 is absent from the retained archive parents")
+    require(reviews["103"]["head"] == PR103, "historical review refers to a different head")
+    require(reviews["103"]["contributor"]["login"] == "rohanarun", "historical integration credit mismatch")
+    data = {role: loads(proof.blob(role)) for role in BLOBS if role != "original_notice"}
+    require(proof.blob("original_notice") == (HERE / "UPSTREAM-NOTICE").read_bytes(),
+            "original notice was not retained exactly")
+    accounting = check_accounting(**data)
+    require(proof.used == set(proof.objects), "unused evidence objects")
+    return {
+        "status": "PASS_PR99_RETENTION_AND_SAVED_ACCOUNTING",
+        "base_commit": BASE, "original_head": PR99, "retained_head": PR103,
+        "archive_commit": ARCHIVE, "common_package_tree": COMMON_TREE,
+        "retained_files": len(files), "original_changes": {"added": len(difference), "modified": 0, "deleted": 0},
+        "authenticated_git_objects": len(proof.used), "accounting": accounting,
+        "fresh_physical_replay": False, "new_kappa_claim": False,
+        "scope": "Complete historical source retention and saved-report accounting; no new construction acceptance.",
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--proof", type=Path, default=HERE / "SOURCE-PROOF.json")
+    parser.add_argument("--write-result", type=Path, help="write a newly recomputed receipt instead of comparing RESULT.json")
+    args = parser.parse_args()
+    result = verify(loads(args.proof.read_bytes()), *external_inputs())
+    if args.write_result:
+        args.write_result.write_text(json.dumps(result, indent=2) + "\n")
+    else:
+        require(result == loads((HERE / "RESULT.json").read_bytes()), "saved result differs from recomputation")
+    print(result["status"] + f" files={result['retained_files']} singleton_delta={result['accounting']['histogram_delta']['1']} mass_delta=0")
+
+
+if __name__ == "__main__":
+    main()