Add Stage3 typed exact [[210,10,16]] evidence

README.md

@@ -19,14 +19,31 @@ configs:
   data_files: data/stage2_best_verified.jsonl
 - config_name: historical_exact_fom11
   data_files: data/historical_exact_fom11.jsonl
+- config_name: stage3_typed_exact_fom_gt_12
+  data_files: data/stage3_typed_exact_fom_gt_12.jsonl
 ---
 
 # QLDPC FOM>12 Search Evidence
 
-This is a **human-review snapshot**, not a winner announcement. It contains a compact selection of twisted-torus CSS quantum-code candidates, their check matrices, replay-oriented evidence summaries, and a readable description of the automated five-stage search pipeline.
+This repository contains the original **human-review snapshot** plus separately versioned result lanes. It includes twisted-torus CSS quantum-code candidates, their check matrices, replay-oriented evidence summaries, and a readable description of the automated search pipeline.
 
 > Status at snapshot: **in progress**. Sealed rounds: **1–4**. Certified novel candidates with exact `FOM > 12`: **0**.
 
+## Stage 3 typed exact FOM>12 update (2026-08-19)
+
+The separate `stage3_typed_exact_fom_gt_12` configuration publishes one
+`[[210,10,16]]` CSS-BB code with exact Stage 3 FOM
+`256/21 ~= 12.19047619047619`. The integer target check is
+`10*16^2 = 2560 > 2520 = 12*210`.
+
+The lower result is bound to a pinned DistQLDPC/MaxCDCL binary and the upper
+bound is a replayable weight-16 X-logical witness. The typed Stage 3 handoff
+replayed successfully, but the run used `--no-certify`: Stage 4 and Stage 5
+publication gates were not run, and no portable DRAT/LRAT lower-bound proof is
+available. It is therefore labelled
+`STAGE3_TYPED_EXACT_PENDING_STRICT_GATE`, not `CERTIFIED_EXACT_WIN`. See
+[`docs/STAGE3_TYPED_EXACT_FOM_GT_12.md`](docs/STAGE3_TYPED_EXACT_FOM_GT_12.md).
+
 ## Stage 2 verified near-miss update (2026-08-16)
 
 A separate `stage2_best_verified` configuration now publishes 13 fully
@@ -56,6 +73,7 @@ certificate schema. See
 |---|---:|
 | Selected candidates | 51 |
 | Sealed trusted audits | 24 |
+| Separate Stage 3 typed exact `FOM > 12` lane | 1 (`[[210,10,16]]`) |
 | Exact non-winners | 3 |
 | Rejected with replayable witness | 21 |
 | Formally open lower-bound candidates | 27 |
@@ -81,11 +99,17 @@ The strict target is checked with integer arithmetic: **`k*d*d > 12*n`**. Equali
 4. [`data/candidates.jsonl`](data/candidates.jsonl) — one compact record per selected code.
 5. [`evidence/proofs.jsonl`](evidence/proofs.jsonl) and [`matrices/`](matrices/) — evidence and `H_X/H_Z` matrices.
 
-Run `python -B scripts/verify_dataset.py .` to validate every checksum, matrix, CSS commutation relation, reconstructed `k`, FOM field, and included logical witness.
+Run `git lfs pull --include='matrices/**'` and then
+`python -B scripts/verify_dataset.py .` to validate every checksum, matrix,
+CSS commutation relation, reconstructed `k`, FOM field, and included logical
+witness, including the separate Stage 3 typed-exact lane.
 
 ## 中文说明
 
-这是供人类专家复核的**进行中快照**，不是“已经发现新纪录码”的声明。数据集收录精选 twisted-torus CSS 候选、`H_X/H_Z`、证据等级、FOM 区间、每轮统计和五阶段流水线说明。当前没有任何新候选被严格认证为 `FOM>12`。BP/OSD 的较大数值只是启发式距离上界，不能当作性能下界或最终结果。
+这是供人类专家复核的进行中数据集。原 rounds 1–4 快照仍没有通过完整
+Stage 4/5 发布门的 `FOM>12` 候选；新增独立配置发布了一个 Stage 3 typed
+exact 的 `[[210,10,16]]` 结果，FOM 为 `256/21`。其下界依赖固定版本的
+DistQLDPC/MaxCDCL，且本轮使用了 `--no-certify`，所以等待后续严格发布门。
 
 ## Attribution and non-endorsement
 

THIRD_PARTY_NOTICES.md

@@ -5,3 +5,4 @@
 - Related context: *Evolutionary Discovery of Bivariate Bicycle Codes with LLM-Guided Search*, arXiv:2606.02418.
 - Known-code provenance includes Aydin–Tamo–Barg, arXiv:2606.17268, with repository/source hashes recorded by the pipeline. The upstream action catalog is not redistributed here.
 - The FOM>12 challenge target is linked to Shuxiang Cao's public gist. No endorsement by Shuxiang Cao or NVIDIA is implied.
+- The Stage 3 typed-exact record binds results from DistQLDPC at source commit `c01fa93eb5e1e62948e4861e2c164a6b64fe88eb` (GPL-3.0-or-later) and its MaxCDCL optimization backend. No third-party solver binary or source is redistributed in this dataset; only allowlisted result metadata and cryptographic hashes are included.

data/stage3_typed_exact_fom_gt_12.jsonl

@@ -0,0 +1 @@
+{"authority":{"exact_under_pinned_solver_trust_model":true,"independent_release_gate_complete":false,"pipeline_promotion":false,"pipeline_stage4_certificate":false,"pipeline_stage5_final_gate":false,"portable_unsat_proof_certificate":false,"public_dataset_record":true,"publication_certificate":false,"stage3_typed_handoff_replay":true},"candidate_id":"5f773fbfbce9775bc30b","canonical_digest":"4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c","code":"[[210,10,16]]","construction":{"A_terms":[[7,3],[18,4],[20,0]],"B_terms":[[2,3],[18,1],[19,2]],"ell":21,"family":"css-bb","geometry":{"family":"twisted_torus","schema_version":1,"twist":3},"m":5,"representation_id":"css-bb-twisted-torus-generator-v1"},"distance":{"exact":16,"lower_bound":16,"lower_bound_backend":"DistQLDPC/MaxCDCL","status":"EXACT_PROVEN","upper_bound":16,"upper_bound_backend":"python-sat/cadical195"},"evidence_class":"STAGE3_TYPED_EXACT_PENDING_STRICT_GATE","fom":{"exact":{"decimal":12.19047619047619,"denominator":21,"numerator":256},"excess_over_12":{"decimal":0.19047619047619047,"denominator":21,"numerator":4},"strict_integer_margin":40},"known_answer_context":{"gate_file_sha256":"7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687","release_replayed":false,"trust_file_sha256":"1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140"},"matrices":{"gx":{"content_sha256":"ac1f362008313f8456c289e94b488dceae8db8c2f01c6b181cadf4c1dc024dce","file_sha256":"cc65886a45b83992356b667cc1efa7bd7629a5a2ea80c245804bcc26db05e332","path":"matrices/5f773fbfbce9775bc30b/Gx.mtx.gz","shape":[10,210]},"gz":{"content_sha256":"47b0c2c19c89b88b729fc74838a091b381d3105633a163e6b5649a9274bbda68","file_sha256":"eab940182d17452c1d154715ea948bfc4c4bfe93fbc250f4aa31df4c130ac590","path":"matrices/5f773fbfbce9775bc30b/Gz.mtx.gz","shape":[10,210]},"hx":{"content_sha256":"3e84de485357b46239174805f8fc3378eeb0e4207a06fc3a95568e5630c58c8e","file_sha256":"a8d53c3e14419e0b0c30e2960621394475e06d0cff30a6c1f0c9635c8f5bf9ea","path":"matrices/5f773fbfbce9775bc30b/Hx.mtx.gz","shape":[105,210]},"hz":{"content_sha256":"21b89580009d0ce19cab3c537ddc53c0211a962d88e4aaa1cf3b9a6752d502ab","file_sha256":"fae00c16429f8312a9a5f1c8e7f025431f986ac8dcc13a433887111f5503baa4","path":"matrices/5f773fbfbce9775bc30b/Hz.mtx.gz","shape":[105,210]}},"matrix_checks":{"commutation_violations":0,"css_commutation":true,"k_recomputed":10,"logical_basis_complete":true,"logical_duality":true,"max_check_weight":6,"max_qubit_degree":6,"max_sector_qubit_degree":3,"rank_x":100,"rank_z":100},"novelty":{"matched_entries":[],"novel":true,"registry_file_sha256":"265f1a3fefef884adeaa980a5dce2441dee4f6f6d71c253ba7a6491360733689","registry_internal_sha256":"536c733d68d344ed9fef9992bbeb1000900174ad0c500ddb7004126ae5c98408","registry_version":"2026-08-12.twisted-published-volume-v2","release_current_registry_replayed":false,"scope":"pinned known-code registry with explicit construction/matrix replay","source_stage3_replayed":true,"status":"COMPLETE"},"parameters":{"k":10,"n":210},"record_kind":"stage3_typed_exact_fom_gt_12","record_sha256":"81ae9e7c377896e87f9a374a9700a0d12a8839933687ec0b38fceee22509195d","release_status":"PENDING_STAGE4_STAGE5","schema_version":1,"source":{"known_answer_gate_sha256":"7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687","known_answer_trust_sha256":"1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140","qcode_commit":"ade9dc706a455427384e4ba82c0981d9cc9f6671","stage3_aggregate_byte_sha256":"ee2965586cff334caf22d1c0b360127c22cca34c5136f58c88cdd150a5ffeefd","stage3_aggregate_self_seal_sha256":"fa03b3a2a8f43d77131c8a5491efbb56d98800d9e215b45e9e5b3e7f86509159","stage3_lower_raw_terminal_evidence_sha256":"75ac260531dba3618c14fb459e86e2e8bfe39d205a1705da61d516528d0db581","stage3_lower_resumed_evidence_sha256":"fb0bb3fc7b3dc6312952ad7ba9d324346ebd16db35e59e3b894ae3c0f70d489e","stage3_lower_terminal_byte_sha256":"9def4c1d0134165bbf3166382d8b07b361b816504e00e2473615fe9c45a26218","stage3_ranked_byte_sha256":"b8a0f2a7dd4191dd6d578addaec67cee60786104a748dd78203a822e196e3129","stage3_summary_byte_sha256":"4579c4472879e78da8a77b66e240b6e2ea66a1d47ca782f889247b3186b0a5ab","stage3_threshold_byte_sha256":"1c3a4bcf0a4598fc7c91236c01513f375746ba0d8c635d88630800be9f5bfcd6","stage3_typed_claim_sha256":"1a2a076a891a790a92359d903f7874f989d12a2f684518fd227923bbe7f0c2c9","stage3_typed_request_artifact_sha256":"ed3f639b3b7254566b248e3314dcca9aed82a8a91f0465a61d920571b2c9c6d3","stage3_typed_request_sha256":"ce20b44a85b000cf59b24fa4fa69196ccd596ba3d42c78ab325bad1fac99caad","stage3_upper_raw_terminal_evidence_sha256":"8da3a1ee2523a0e7e4c4e21a627c8a780d8160cd09d9beb5130044cd8936fdbe","stage3_upper_resumed_evidence_sha256":"d637b58008f17e1380fb1a3ed6f262b4183b7e19f4c420555d89df0c33340d5b","stage3_upper_terminal_byte_sha256":"f1fe9686eaac799ecf4583d48fe39858381b29e7a47844af5c447e6e21ebc86e"},"source_stage":"stage3_direction_audit","source_status":"EXACT_PROVEN","source_target":{"binding_sha256":"47877e252a30cebfbdc3d172d1d5212f42ba1ae088831a5ca4fbd8f382150878","mode":"scalar-fom-inclusive-v1","required_distance":16,"strict":false},"target":{"certified_win":false,"left_hand_side":2560,"passes_strict_target":true,"required_distance":16,"right_hand_side":2520,"strict_predicate":"k*d*d > 12*n"}}

docs/REPRODUCE.md

@@ -3,10 +3,17 @@
 From the dataset root:
 
 ```bash
+git lfs pull --include='matrices/**'
 sha256sum -c manifests/SHA256SUMS
 python -B scripts/verify_dataset.py .
 ```
 
-The verifier uses only Python's standard library. It reads the compressed Matrix Market files, checks their content and file hashes, verifies `H_X H_Z^T = 0` over GF(2), recomputes both ranks and `k`, checks the strict FOM arithmetic, and validates every included logical witness against the published matrices.
+The verifier uses only Python's standard library. It reads the materialized
+compressed Matrix Market files, checks their content and file hashes, verifies
+`H_X H_Z^T = 0` over GF(2), recomputes both ranks and `k`, checks the strict
+FOM arithmetic, and validates every included logical witness against the
+published matrices. The Stage 3 typed-exact verifier additionally reconstructs
+the twisted `Hx/Hz`, validates the complete `Gx/Gz` logical basis, and
+replays the weight-16 upper witness under the stated pinned-solver boundary.
 
 The exact public pipeline parameters and source bindings are recorded in `config/run_config.public.json` and `manifests/selection.json`. Full stochastic search replay requires the source revision and matching dependencies; this compact expert package intentionally omits model transcripts, internal prompts, process state and checkpoints.

docs/SCHEMA.md

@@ -12,3 +12,12 @@
 `evidence/proofs.jsonl` contains the matching proof summaries. `formal_lower_bound_evidence` stores the two-sector low-weight exclusion record; `logical_basis_upper_bound_evidence` stores a replayable logical witness; `trusted_audit` stores a sanitized view of the sealed audit artifact. Local paths, interpreter paths, PIDs, commands, prompts, and logs are not exported.
 
 `evidence/matrix_index.jsonl` indexes Matrix Market files. All matrices are binary even though Matrix Market labels entries as integers. Coordinates are one-based.
+
+The separate `stage3_typed_exact_fom_gt_12` configuration is intentionally
+outside the sealed rounds 1–4 snapshot. Its candidate row is stored in
+`data/stage3_typed_exact_fom_gt_12.jsonl`, its allowlisted solver/handoff
+summary in `evidence/stage3_typed_exact_proofs.jsonl`, and its four-matrix
+solver-instance index in `evidence/stage3_typed_exact_matrix_index.jsonl`.
+`Hx` and `Hz` define the CSS code; `Gx` and `Gz` are the logical
+representatives used by DistQLDPC. This lane distinguishes Stage 3 typed exact
+evidence from Stage 4/5 publication certification.

docs/STAGE3_TYPED_EXACT_FOM_GT_12.md

@@ -0,0 +1,73 @@
+# Stage 3 typed exact FOM>12 result
+
+## Result
+
+The `stage3_typed_exact_fom_gt_12` configuration publishes one twisted-torus
+CSS-BB code:
+
+```text
+[[n,k,d]] = [[210,10,16]]
+FOM = k d^2 / n = 256/21 ~= 12.19047619047619
+strict gate: 10 * 16^2 = 2560 > 12 * 210 = 2520
+```
+
+Its public identifier is `5f773fbfbce9775bc30b`; the Stage 3 canonical
+digest is
+`4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c`.
+
+The construction uses `ell=21`, `m=5`, twisted-torus parameter `twist=3`,
+
+```text
+A = x^7 y^3 + x^18 y^4 + x^20
+B = x^2 y^3 + x^18 y + x^19 y^2.
+```
+
+The release includes `Hx`, `Hz`, and the exact `Gx`, `Gz` logical-basis files
+used by the pinned DistQLDPC instance. The public verifier reconstructs `Hx`
+and `Hz` from the construction, checks both GF(2) ranks (`100` and `100`),
+CSS commutation, `k=10`, logical-basis completeness and duality, and the
+weight-16 X-logical upper witness.
+
+## Evidence and trust boundary
+
+Stage 3 ended in `EXACT_PROVEN` with two terminal proof units:
+
+- lower bound and exact value: DistQLDPC/MaxCDCL, `mto` cardinality mode,
+  clean return code, no timeout, and terminal `d_lb=d_ub=d=o=16`;
+- upper bound: a replayed python-sat/CaDiCaL witness of X weight 16.
+
+The typed Stage 3 handoff was independently replayed after the run and found
+no conflicting exact distance or lower-weight witness. The public record binds
+the source aggregate, both terminal files, source revision, matrix instance,
+runtime adapter, and pinned DistQLDPC binary by SHA-256.
+
+This is deliberately labelled
+`STAGE3_TYPED_EXACT_PENDING_STRICT_GATE`. The run used `--no-certify`, so it
+did not produce a Stage 4 certificate or Stage 5 publication-gate result. The
+strict FOM arithmetic is true, but `certified_win` remains `false` until those
+later gates are completed.
+
+DistQLDPC/MaxCDCL does not emit a portable DRAT/LRAT certificate for this
+optimization result. Consequently, the lower bound is exact under the pinned
+solver/runtime trust model, not an independently checkable proof trace. The
+matrix algebra and upper witness are portable and independently replayed by
+the included verifier.
+
+## Files and verification
+
+- `data/stage3_typed_exact_fom_gt_12.jsonl`
+- `evidence/stage3_typed_exact_proofs.jsonl`
+- `evidence/stage3_typed_exact_matrix_index.jsonl`
+- `matrices/5f773fbfbce9775bc30b/{Hx,Hz,Gx,Gz}.mtx.gz`
+- `manifests/stage3_typed_exact_fom_gt_12.json`
+
+After cloning, materialize the LFS objects before verification:
+
+```bash
+git lfs pull --include='matrices/**'
+sha256sum -c manifests/SHA256SUMS
+python -B scripts/verify_stage3_typed_exact_fom_gt_12.py .
+```
+
+No local paths, process IDs, commands, prompts, raw solver output, or
+checkpoint/progress paths are included in the public evidence summary.

evidence/stage3_typed_exact_matrix_index.jsonl

@@ -0,0 +1 @@
+{"candidate_id":"5f773fbfbce9775bc30b","canonical_digest":"4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c","k":10,"matrices":{"gx":{"content_sha256":"ac1f362008313f8456c289e94b488dceae8db8c2f01c6b181cadf4c1dc024dce","file_sha256":"cc65886a45b83992356b667cc1efa7bd7629a5a2ea80c245804bcc26db05e332","path":"matrices/5f773fbfbce9775bc30b/Gx.mtx.gz","shape":[10,210]},"gz":{"content_sha256":"47b0c2c19c89b88b729fc74838a091b381d3105633a163e6b5649a9274bbda68","file_sha256":"eab940182d17452c1d154715ea948bfc4c4bfe93fbc250f4aa31df4c130ac590","path":"matrices/5f773fbfbce9775bc30b/Gz.mtx.gz","shape":[10,210]},"hx":{"content_sha256":"3e84de485357b46239174805f8fc3378eeb0e4207a06fc3a95568e5630c58c8e","file_sha256":"a8d53c3e14419e0b0c30e2960621394475e06d0cff30a6c1f0c9635c8f5bf9ea","path":"matrices/5f773fbfbce9775bc30b/Hx.mtx.gz","shape":[105,210]},"hz":{"content_sha256":"21b89580009d0ce19cab3c537ddc53c0211a962d88e4aaa1cf3b9a6752d502ab","file_sha256":"fae00c16429f8312a9a5f1c8e7f025431f986ac8dcc13a433887111f5503baa4","path":"matrices/5f773fbfbce9775bc30b/Hz.mtx.gz","shape":[105,210]}},"n":210,"record_kind":"stage3_typed_exact_matrix_index","record_sha256":"3c766edc736cfcbcabcc9daba4a9cd464877793a4a701dcadb1c2fcc800b22ac","schema_version":1}

evidence/stage3_typed_exact_proofs.jsonl

@@ -0,0 +1 @@
+{"authority":{"exact_under_pinned_solver_trust_model":true,"independent_release_gate_complete":false,"pipeline_promotion":false,"pipeline_stage4_certificate":false,"pipeline_stage5_final_gate":false,"portable_unsat_proof_certificate":false,"public_dataset_record":true,"publication_certificate":false,"stage3_typed_handoff_replay":true},"candidate_id":"5f773fbfbce9775bc30b","canonical_digest":"4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c","distance_claim":{"exact":16,"lower_bound":16,"status":"EXACT_PROVEN","upper_bound":16},"evidence_class":"STAGE3_TYPED_EXACT_PENDING_STRICT_GATE","evidence_sha256":"58e76850bc08bd263ff9756668a35b5092d4c30d8f09de5692166eaae7afadc3","limitations":{"independent_checks":"The public verifier reconstructs Hx/Hz, checks CSS ranks and commutation, validates the complete logical basis, and replays the weight-16 upper witness. It cannot independently certify the solver-derived lower bound without a portable proof trace.","portable_unsat_certificate":"Not available. The lower bound is a replay-bound result under the pinned DistQLDPC/MaxCDCL binary and runtime trust model."},"lower_bound_evidence":{"aggregate_resumed_evidence_sha256":"fb0bb3fc7b3dc6312952ad7ba9d324346ebd16db35e59e3b894ae3c0f70d489e","backend":{"binary_sha256":"9e09c544d5151d872dc1037dcb1440509e27b8b485a7f9ea5a15d6e55b36d3fa","binary_size":2105096,"distribution":"DistQLDPC","identity_sha256":"b4bebbffdc8e8b8fe8f666fccaaf8471a518ba99490d70a6500de52e374f04b3","interface":"distqldpc-cli","repository":"https://github.com/guluchen/DistQLDPC","source_commit":"c01fa93eb5e1e62948e4861e2c164a6b64fe88eb"},"cardinality_mode":"mto","checkpoint_identity":{"candidate_digest":"4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c","cardinality_mode":"mto","construction_symmetry_sha256":null,"coverage_mode":"first-nonzero","logical_detector_sha256":"ba20e6b2fdc6806244f8eebc23e5fc78bf7d0ceb8abfda9a8b4591276752e26a","lower_backend":"distqldpc","phase":"lower-distqldpc","stage3_gate":"qldpc-frontier-sat-sector-exact-screen","target_binding_sha256":"47877e252a30cebfbdc3d172d1d5212f42ba1ae088831a5ca4fbd8f382150878","target_mode":"scalar-fom-inclusive-v1","translation_symmetry":{"block_size":105,"generators":[{"axis":"x","hx_row_set_preserved":true,"hz_row_set_preserved":true,"order":105,"permutation_sha256":"f4f316808964070d043b88db1badfc38a747581e61eb94dd8fb21171e4e51e6b"},{"axis":"y","hx_row_set_preserved":true,"hz_row_set_preserved":true,"order":5,"permutation_sha256":"0d8a8605cb48181d9af9b35177f2a6d22932b92cda15359e336d9abf0ce56e5b"}],"geometry":{"ell":21,"family":"twisted_torus","m":5,"schema_version":1,"twist":3},"method":"bb-quotient-translation-row-set-v2","orbit_representatives":[0,105],"orbit_sizes":[105,105],"relation_basis":[[0,5],[21,3]],"shape":[21,5],"verified":true},"xz_sector_isometry_sha256":"6662b328e912918c26a36bb68d3279302329b9dd063952cc8ad8367f3358a4c5"},"decision_complete":true,"elapsed_s":14318.210796710104,"evidence_kind":"qcode-css-distqldpc-distance-evidence","exact_distance":16,"formulation":"css-full-distance-distqldpc-maxcdcl-v1","hard_timeout_s":21600.0,"instance_binding_sha256":"3cb72f08d8d681df64c3cee531df620a251c7fb34872274868b348a247dfd992","logical_detector":{"css_commutation":true,"k":10,"logical_duality":true,"method":"css-logical-detector-dimension-replay-v1","n":210,"report_sha256":"ba20e6b2fdc6806244f8eebc23e5fc78bf7d0ceb8abfda9a8b4591276752e26a","sectors":{"X":{"detector_kernel_dimension":100,"logical_count":10,"trivial_rank":100,"trivial_space_in_detector_kernel":true,"verified":true},"Z":{"detector_kernel_dimension":100,"logical_count":10,"trivial_rank":100,"trivial_space_in_detector_kernel":true,"verified":true}},"verified":true},"lower_bound":16,"outcome":"exact","parsed_output":{"d":16,"d_lb":16,"d_lb_values":[1,2,4,8,16],"d_ub":16,"d_ub_values":[30,28,26,24,22,20,18,16],"d_values":[16],"o":16,"o_values":[16],"reported_timeout":false,"unknown_final":false},"raw_terminal_evidence_sha256":"75ac260531dba3618c14fb459e86e2e8bfe39d205a1705da61d516528d0db581","raw_terminal_replay_verified":true,"retryable":false,"returncode":0,"runtime_source":{"adapter":{"module":"evaluation.distance_distqldpc","sha256":"9077ad558b4205a9ee84a1300ee7ee83a5a959fa55e1670441a1e7529eeda574"},"identity_sha256":"9059539f43f6134b26f6cda4e94bca45ec8b7f5d262f1082cee47bbe014293ce","protocol":"qcode-distqldpc-supervisor-v1","supervisor":{"module":"evaluation.distqldpc_supervisor","sha256":"fd6ed1198831aa1208932daf974faa11348e98c9c98ec26c8c39bfbe8ae833b8"}},"solver_instance_array_sha256":{"Gx":"c0edc012903bdf5f705703f32424fb7ea394d89dc06989da5bca8942ceb9906d","Gz":"aabf9ab4f3b8b3213442312efc83a855419efc6ed621584357640b54182c1f0d","Hx":"b47d720dc1ce145109447c527fd39cdcb70a00d8d9ea275d49e8489c74897eeb","Hz":"500f8c93ab788543c9635b97d8d4f932eeda7b86b651a680a438a96a1d28da07"},"stderr_sha256":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","stdout_sha256":"775f9de7a9bbadb0763475fffd1d13af69433b39fe203e2998b6208763c8711d","terminal_file_sha256":"9def4c1d0134165bbf3166382d8b07b361b816504e00e2473615fe9c45a26218","threshold_infeasible":true,"timed_out":false,"upper_bound":16},"record_kind":"stage3_typed_exact_fom_gt_12_evidence","release_status":"PENDING_STAGE4_STAGE5","schema_version":1,"source_status":"EXACT_PROVEN","stage3_typed_handoff":{"attempted_proof_units":23,"backend":"distqldpc","completed_proof_units":2,"distqldpc_conflict":false,"distqldpc_conflict_details":null,"distqldpc_exact_distances":[16],"expected_proof_units":27,"gate":"qldpc-frontier-sat-sector-exact-screen","known_answer_gate_sha256":"7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687","known_answer_trust_sha256":"1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140","low_witnesses":[],"lower_bound_threshold":15,"qcode_commit":"ade9dc706a455427384e4ba82c0981d9cc9f6671","source_retryable_units_at_terminal":21,"stage3_aggregate_byte_sha256":"ee2965586cff334caf22d1c0b360127c22cca34c5136f58c88cdd150a5ffeefd","stage3_aggregate_self_seal_sha256":"fa03b3a2a8f43d77131c8a5491efbb56d98800d9e215b45e9e5b3e7f86509159","stage3_lower_raw_terminal_evidence_sha256":"75ac260531dba3618c14fb459e86e2e8bfe39d205a1705da61d516528d0db581","stage3_lower_resumed_evidence_sha256":"fb0bb3fc7b3dc6312952ad7ba9d324346ebd16db35e59e3b894ae3c0f70d489e","stage3_lower_terminal_byte_sha256":"9def4c1d0134165bbf3166382d8b07b361b816504e00e2473615fe9c45a26218","stage3_ranked_byte_sha256":"b8a0f2a7dd4191dd6d578addaec67cee60786104a748dd78203a822e196e3129","stage3_summary_byte_sha256":"4579c4472879e78da8a77b66e240b6e2ea66a1d47ca782f889247b3186b0a5ab","stage3_threshold_byte_sha256":"1c3a4bcf0a4598fc7c91236c01513f375746ba0d8c635d88630800be9f5bfcd6","stage3_typed_claim_sha256":"1a2a076a891a790a92359d903f7874f989d12a2f684518fd227923bbe7f0c2c9","stage3_typed_request_artifact_sha256":"ed3f639b3b7254566b248e3314dcca9aed82a8a91f0465a61d920571b2c9c6d3","stage3_typed_request_sha256":"ce20b44a85b000cf59b24fa4fa69196ccd596ba3d42c78ab325bad1fac99caad","stage3_upper_raw_terminal_evidence_sha256":"8da3a1ee2523a0e7e4c4e21a627c8a780d8160cd09d9beb5130044cd8936fdbe","stage3_upper_resumed_evidence_sha256":"d637b58008f17e1380fb1a3ed6f262b4183b7e19f4c420555d89df0c33340d5b","stage3_upper_terminal_byte_sha256":"f1fe9686eaac799ecf4583d48fe39858381b29e7a47844af5c447e6e21ebc86e","status":"EXACT_PROVEN","summary_retry_required":false,"terminal_reason":"distqldpc_exact_plus_upper_witness","typed_replay_verified":true},"symmetry":{"covered_sectors":["X","Z"],"orbit_representatives":[0,105],"translation_verified":true,"xz_sector_isometry_sha256":"6662b328e912918c26a36bb68d3279302329b9dd063952cc8ad8367f3358a4c5","xz_sector_isometry_verified":true},"upper_bound_evidence":{"aggregate_resumed_evidence_sha256":"d637b58008f17e1380fb1a3ed6f262b4183b7e19f4c420555d89df0c33340d5b","anchor_indices":[0,105],"backend":{"distribution":"python-sat","solver":"cadical195","version":"1.9.dev7"},"cnf":{"anchor_unit_clauses_sha256":"4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945","cardinality_encoding":"kmtotalizer","cnf_sha256":"6930ac736f6a4ca5cd85fa448e4b35b576bf357eb0719490dd0cdf0e0f2ecad8","num_clauses":6540,"num_variables":2013},"decision_complete":true,"evidence_kind":"qcode-css-threshold-sat-evidence","formulation":"css-global-logical-threshold-cnf-v1","instance_binding_sha256":"ce40d444e02bfe900f38d29ebe4bc72d2ed0b7241039c21d3a016cbaa47caba7","logical_syndrome":[1,0,0,0,1,1,0,1,0,1],"objective":16,"operator":{"length":210,"packed_hex":"450000020000000000004910001200008000200000000082000500","sha256":"ff3b54a8cfd0857a27a12dda5d602405175f8b01c21687b97475861ad7503a77","weight":16},"outcome":"sat","raw_terminal_evidence_sha256":"8da3a1ee2523a0e7e4c4e21a627c8a780d8160cd09d9beb5130044cd8936fdbe","retryable":false,"sector":"X","terminal_file_sha256":"f1fe9686eaac799ecf4583d48fe39858381b29e7a47844af5c447e6e21ebc86e"}}

manifests/SHA256SUMS

@@ -1,15 +1,15 @@
 ffe79769ee48619a33c8049eef31be7f633ca00cf0fa1d4d852cbd1e4f9d8936  CITATION.cff
 c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  LICENSE
-48cb87c52461a7e60cab860750bbfff717f4aaaea3892a3725e12480e72f748c  README.md
-95a5ec2a8c23f4aab17998c6fad05490a316c083983d7183feaad075e3dff397  THIRD_PARTY_NOTICES.md
+7e6db3d0cec57aa9d290028789da554bfd61ae54ccff4e54ac9658a7be1568f3  README.md
+622bee3e546a22480c71e7573471d0c619654741b9d861eb0f40a04ab81010c8  THIRD_PARTY_NOTICES.md
 9476a8f02cd6c3e09e0ff73f4d5013f3b98902b3d157072c233f5012cd60d00b  config/run_config.public.json
 6db5c6d622831117e5e8276d9d87d22b01889082b1f6fd74b770ed1b4abb6edb  data/candidates.jsonl
 c0490e6b4addfe648c3361cef28a6425e7a50a8aae7846cd1db89874420ceb29  data/round_summary.jsonl
 d50ff81a755020f0ec2f17cc4c631598bd418861eabb6c074fc85d3dae02c6ee  docs/EXPERT_REVIEW_CHECKLIST.md
 c3b085a3f0a46a237e4fe5bcc994d5a235c4c1c3a5984f960a9fd9db0fa22ac7  docs/METRICS.md
 745938561f172be13a48d6a08631d563794c6fc1aba1a7a1afc220fedcae74cd  docs/PIPELINE.md
-eaf8cf89a55f23442832b0a288e4aabb34cb71d39584bb834df6fd56751f4ddf  docs/REPRODUCE.md
-cc63fce6340729359e7c9ff9d6c5125735c853bdf3e859e98de941a64439b9e5  docs/SCHEMA.md
+6d2cb6fec30414f19819a5f688ac91a40face0a36e34f8a0d9eb7ea3a1f33ace  docs/REPRODUCE.md
+824c0eccae8f07c9181eab9218ab748e5ce40d5e0fafbbad8b3d8acbd8aba4f1  docs/SCHEMA.md
 3c0d76df652ae3075301ab8256f008a1cd3fae9c2da2a0566df35d409c0dffb5  evidence/matrix_index.jsonl
 aadf5903fb4b75994aba7b0f7ba47e390c73002188ae2d5bb7fc8a282416b753  evidence/proofs.jsonl
 7229d846f74aedc2f53b7331abbee9f55dca4adcb981328e471003274840e0a1  manifests/selection.json
@@ -117,7 +117,7 @@ a0f710dd60e6383e495524189f794d8cbf48fef7c56923fc347456806d268f27  matrices/fe0e3
 258877ea83b848cde7baa21d030ee1351bd63bb3ecf9dbd49516017cd4422824  matrices/fe0e327abe20b2648e47/Hz.mtx.gz
 7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687  reference/known_answer_gate.json
 1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140  reference/known_answer_trust.json
-e42c1f3705cfb705198732c64449e1a2dafc91df11426efdd033701077d90356  scripts/verify_dataset.py
+1764e7aa2525c2a33d5f88c1487e3670bfb238906a628ebc110980fa1fc59ede  scripts/verify_dataset.py
 a910a0b82c8e86b8784052f038e8287f3a45f2f6e807cd9804d293cddd07a385  data/stage2_best_verified.jsonl
 e20a073c69c2fa9fdb8182063ab592c3f3c757323b2d116142b3befc61d43034  docs/STAGE2_BEST_RESULT.md
 0aea4cf3413f06796db3b0c5f4bae97712c35db6b834f419a59e77bd10e00f9f  evidence/stage2_best_verified.jsonl
@@ -129,3 +129,14 @@ a213484ae5bf13db227919e3edbfdbac3cb47745afa58f9abe31ee5cd77e3b20  manifests/hist
 2dc73d9bc5ce64bf98325d343feea4895d68036bcb9cf9882bb71f3633c497a3  matrices/5bf3e9dc496750d28d4e/Hx.mtx.gz
 70cf6f60310168d951960fadb3c9002539bb7ed98b9f51007eda4de10c9b3ced  matrices/5bf3e9dc496750d28d4e/Hz.mtx.gz
 1c5c46b3ee1893effa7b01009f8681e881e0e9e13f6a7f17ced21adba2d4e12d  scripts/verify_historical_exact_fom11.py
+5249209433f6a79275e08168f051a2a32c24272e15c16263971b01e271f4845f  data/stage3_typed_exact_fom_gt_12.jsonl
+bf3fc01e914f37ccde34ab457843ee4def2dd97dafe6d57a95b813c7685ed035  evidence/stage3_typed_exact_proofs.jsonl
+6596ed5a5328e2e702fa2e1a34780d572fdb0d80ad6d11caf787ed3da2b80c13  evidence/stage3_typed_exact_matrix_index.jsonl
+a8d53c3e14419e0b0c30e2960621394475e06d0cff30a6c1f0c9635c8f5bf9ea  matrices/5f773fbfbce9775bc30b/Hx.mtx.gz
+fae00c16429f8312a9a5f1c8e7f025431f986ac8dcc13a433887111f5503baa4  matrices/5f773fbfbce9775bc30b/Hz.mtx.gz
+cc65886a45b83992356b667cc1efa7bd7629a5a2ea80c245804bcc26db05e332  matrices/5f773fbfbce9775bc30b/Gx.mtx.gz
+eab940182d17452c1d154715ea948bfc4c4bfe93fbc250f4aa31df4c130ac590  matrices/5f773fbfbce9775bc30b/Gz.mtx.gz
+fc1ee37d46a0a0bb042868432b6f543ec098760b1627620a725806e0dd68056b  docs/STAGE3_TYPED_EXACT_FOM_GT_12.md
+0b509ef45eed4921bce68c4d9ad0954a5059dc1813cb8126c0b4db09ab42a55d  scripts/verify_stage3_typed_exact_fom_gt_12.py
+6b35c526dd2de18dedf49b7ccfd7757a25b5ed05f4126bf63de7722fb319fdca  scripts/build_exact_fom_gt_12_release.py
+901673025474968c6e92b4a2bd38e1bc99fcef0c300819a9cb4937ab40924f94  manifests/stage3_typed_exact_fom_gt_12.json

manifests/stage3_typed_exact_fom_gt_12.json

@@ -0,0 +1,129 @@
+{
+  "authority": {
+    "exact_under_pinned_solver_trust_model": true,
+    "independent_release_gate_complete": false,
+    "pipeline_promotion": false,
+    "pipeline_stage4_certificate": false,
+    "pipeline_stage5_final_gate": false,
+    "portable_unsat_proof_certificate": false,
+    "public_dataset_record": true,
+    "publication_certificate": false,
+    "stage3_typed_handoff_replay": true
+  },
+  "candidate": {
+    "candidate_id": "5f773fbfbce9775bc30b",
+    "canonical_digest": "4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c",
+    "code": "[[210,10,16]]",
+    "exact_fom_denominator": 21,
+    "exact_fom_numerator": 256
+  },
+  "certified_win": false,
+  "created_date_utc": "2026-08-19",
+  "dataset_base_commit": "3a24375d3494479c76ecd7c377c9b5d038f2561b",
+  "files": [
+    {
+      "bytes": 5345,
+      "path": "README.md",
+      "sha256": "7e6db3d0cec57aa9d290028789da554bfd61ae54ccff4e54ac9658a7be1568f3"
+    },
+    {
+      "bytes": 914,
+      "path": "THIRD_PARTY_NOTICES.md",
+      "sha256": "622bee3e546a22480c71e7573471d0c619654741b9d861eb0f40a04ab81010c8"
+    },
+    {
+      "bytes": 1055,
+      "path": "docs/REPRODUCE.md",
+      "sha256": "6d2cb6fec30414f19819a5f688ac91a40face0a36e34f8a0d9eb7ea3a1f33ace"
+    },
+    {
+      "bytes": 1557,
+      "path": "docs/SCHEMA.md",
+      "sha256": "824c0eccae8f07c9181eab9218ab748e5ce40d5e0fafbbad8b3d8acbd8aba4f1"
+    },
+    {
+      "bytes": 5332,
+      "path": "data/stage3_typed_exact_fom_gt_12.jsonl",
+      "rows": 1,
+      "sha256": "5249209433f6a79275e08168f051a2a32c24272e15c16263971b01e271f4845f"
+    },
+    {
+      "bytes": 8928,
+      "path": "evidence/stage3_typed_exact_proofs.jsonl",
+      "rows": 1,
+      "sha256": "bf3fc01e914f37ccde34ab457843ee4def2dd97dafe6d57a95b813c7685ed035"
+    },
+    {
+      "bytes": 1258,
+      "path": "evidence/stage3_typed_exact_matrix_index.jsonl",
+      "rows": 1,
+      "sha256": "6596ed5a5328e2e702fa2e1a34780d572fdb0d80ad6d11caf787ed3da2b80c13"
+    },
+    {
+      "bytes": 1840,
+      "path": "matrices/5f773fbfbce9775bc30b/Hx.mtx.gz",
+      "sha256": "a8d53c3e14419e0b0c30e2960621394475e06d0cff30a6c1f0c9635c8f5bf9ea"
+    },
+    {
+      "bytes": 1830,
+      "path": "matrices/5f773fbfbce9775bc30b/Hz.mtx.gz",
+      "sha256": "fae00c16429f8312a9a5f1c8e7f025431f986ac8dcc13a433887111f5503baa4"
+    },
+    {
+      "bytes": 1212,
+      "path": "matrices/5f773fbfbce9775bc30b/Gx.mtx.gz",
+      "sha256": "cc65886a45b83992356b667cc1efa7bd7629a5a2ea80c245804bcc26db05e332"
+    },
+    {
+      "bytes": 1196,
+      "path": "matrices/5f773fbfbce9775bc30b/Gz.mtx.gz",
+      "sha256": "eab940182d17452c1d154715ea948bfc4c4bfe93fbc250f4aa31df4c130ac590"
+    },
+    {
+      "bytes": 2748,
+      "path": "docs/STAGE3_TYPED_EXACT_FOM_GT_12.md",
+      "sha256": "fc1ee37d46a0a0bb042868432b6f543ec098760b1627620a725806e0dd68056b"
+    },
+    {
+      "bytes": 5012,
+      "path": "scripts/verify_dataset.py",
+      "sha256": "1764e7aa2525c2a33d5f88c1487e3670bfb238906a628ebc110980fa1fc59ede"
+    },
+    {
+      "bytes": 21917,
+      "path": "scripts/verify_stage3_typed_exact_fom_gt_12.py",
+      "sha256": "0b509ef45eed4921bce68c4d9ad0954a5059dc1813cb8126c0b4db09ab42a55d"
+    },
+    {
+      "bytes": 37347,
+      "path": "scripts/build_exact_fom_gt_12_release.py",
+      "sha256": "6b35c526dd2de18dedf49b7ccfd7757a25b5ed05f4126bf63de7722fb319fdca"
+    }
+  ],
+  "gate": "qcode-public-stage3-typed-exact-fom-gt-12-v1",
+  "manifest_sha256": "74fac0cd3a95e6ee16cd18e9acc2640fdcadfec178c53fd57dab1743c6f3d501",
+  "publication_certificate": false,
+  "release_status": "PENDING_STAGE4_STAGE5",
+  "schema_version": 1,
+  "source": {
+    "known_answer_gate_sha256": "7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687",
+    "known_answer_trust_sha256": "1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140",
+    "qcode_commit": "ade9dc706a455427384e4ba82c0981d9cc9f6671",
+    "stage3_aggregate_byte_sha256": "ee2965586cff334caf22d1c0b360127c22cca34c5136f58c88cdd150a5ffeefd",
+    "stage3_aggregate_self_seal_sha256": "fa03b3a2a8f43d77131c8a5491efbb56d98800d9e215b45e9e5b3e7f86509159",
+    "stage3_lower_raw_terminal_evidence_sha256": "75ac260531dba3618c14fb459e86e2e8bfe39d205a1705da61d516528d0db581",
+    "stage3_lower_resumed_evidence_sha256": "fb0bb3fc7b3dc6312952ad7ba9d324346ebd16db35e59e3b894ae3c0f70d489e",
+    "stage3_lower_terminal_byte_sha256": "9def4c1d0134165bbf3166382d8b07b361b816504e00e2473615fe9c45a26218",
+    "stage3_ranked_byte_sha256": "b8a0f2a7dd4191dd6d578addaec67cee60786104a748dd78203a822e196e3129",
+    "stage3_summary_byte_sha256": "4579c4472879e78da8a77b66e240b6e2ea66a1d47ca782f889247b3186b0a5ab",
+    "stage3_threshold_byte_sha256": "1c3a4bcf0a4598fc7c91236c01513f375746ba0d8c635d88630800be9f5bfcd6",
+    "stage3_typed_claim_sha256": "1a2a076a891a790a92359d903f7874f989d12a2f684518fd227923bbe7f0c2c9",
+    "stage3_typed_request_artifact_sha256": "ed3f639b3b7254566b248e3314dcca9aed82a8a91f0465a61d920571b2c9c6d3",
+    "stage3_typed_request_sha256": "ce20b44a85b000cf59b24fa4fa69196ccd596ba3d42c78ab325bad1fac99caad",
+    "stage3_upper_raw_terminal_evidence_sha256": "8da3a1ee2523a0e7e4c4e21a627c8a780d8160cd09d9beb5130044cd8936fdbe",
+    "stage3_upper_resumed_evidence_sha256": "d637b58008f17e1380fb1a3ed6f262b4183b7e19f4c420555d89df0c33340d5b",
+    "stage3_upper_terminal_byte_sha256": "f1fe9686eaac799ecf4583d48fe39858381b29e7a47844af5c447e6e21ebc86e"
+  },
+  "source_status": "EXACT_PROVEN",
+  "status": "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE"
+}

matrices/5f773fbfbce9775bc30b/Gx.mtx.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc65886a45b83992356b667cc1efa7bd7629a5a2ea80c245804bcc26db05e332
+size 1212

matrices/5f773fbfbce9775bc30b/Gz.mtx.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eab940182d17452c1d154715ea948bfc4c4bfe93fbc250f4aa31df4c130ac590
+size 1196

matrices/5f773fbfbce9775bc30b/Hx.mtx.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8d53c3e14419e0b0c30e2960621394475e06d0cff30a6c1f0c9635c8f5bf9ea
+size 1840

matrices/5f773fbfbce9775bc30b/Hz.mtx.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fae00c16429f8312a9a5f1c8e7f025431f986ac8dcc13a433887111f5503baa4
+size 1830

scripts/build_exact_fom_gt_12_release.py

@@ -0,0 +1,954 @@
+#!/usr/bin/env python3
+"""Build the public [[210,10,16]] release from sealed Stage 3 artifacts.
+
+This release-specific builder intentionally fails closed.  It accepts only the
+audited candidate, source commit, aggregate, and terminal checkpoints named
+below.  Operational paths, process metadata, commands, and raw logs are not
+copied into the public records.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import io
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+
+CANDIDATE_ID = "5f773fbfbce9775bc30b"
+CANONICAL_DIGEST = (
+    "4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c"
+)
+STATE_KEY = (
+    "2975b8ebd74a3842501a042746bf7877ca11d0326841d3ee4238a6724d0da26e"
+)
+QCODE_COMMIT = "ade9dc706a455427384e4ba82c0981d9cc9f6671"
+HF_BASE_COMMIT = "3a24375d3494479c76ecd7c377c9b5d038f2561b"
+
+EXPECTED_SOURCE_SHA256 = {
+    "stage3-summary.json": (
+        "4579c4472879e78da8a77b66e240b6e2ea66a1d47ca782f889247b3186b0a5ab"
+    ),
+    "stage3-ranked.jsonl": (
+        "b8a0f2a7dd4191dd6d578addaec67cee60786104a748dd78203a822e196e3129"
+    ),
+    "stage3-thresholds.jsonl": (
+        "1c3a4bcf0a4598fc7c91236c01513f375746ba0d8c635d88630800be9f5bfcd6"
+    ),
+    "aggregate": (
+        "ee2965586cff334caf22d1c0b360127c22cca34c5136f58c88cdd150a5ffeefd"
+    ),
+    "lower-terminal": (
+        "9def4c1d0134165bbf3166382d8b07b361b816504e00e2473615fe9c45a26218"
+    ),
+    "upper-terminal": (
+        "f1fe9686eaac799ecf4583d48fe39858381b29e7a47844af5c447e6e21ebc86e"
+    ),
+}
+
+DISTQLDPC_BINARY_SHA256 = (
+    "9e09c544d5151d872dc1037dcb1440509e27b8b485a7f9ea5a15d6e55b36d3fa"
+)
+DISTQLDPC_SOURCE_COMMIT = (
+    "c01fa93eb5e1e62948e4861e2c164a6b64fe88eb"
+)
+
+EXPECTED_TYPED_CLAIM_SHA256 = (
+    "1a2a076a891a790a92359d903f7874f989d12a2f684518fd227923bbe7f0c2c9"
+)
+EXPECTED_TYPED_REQUEST_SHA256 = (
+    "ce20b44a85b000cf59b24fa4fa69196ccd596ba3d42c78ab325bad1fac99caad"
+)
+EXPECTED_TYPED_ARTIFACT_SHA256 = (
+    "ed3f639b3b7254566b248e3314dcca9aed82a8a91f0465a61d920571b2c9c6d3"
+)
+RAW_LOWER_EVIDENCE_SHA256 = (
+    "75ac260531dba3618c14fb459e86e2e8bfe39d205a1705da61d516528d0db581"
+)
+RESUMED_LOWER_EVIDENCE_SHA256 = (
+    "fb0bb3fc7b3dc6312952ad7ba9d324346ebd16db35e59e3b894ae3c0f70d489e"
+)
+RAW_UPPER_EVIDENCE_SHA256 = (
+    "8da3a1ee2523a0e7e4c4e21a627c8a780d8160cd09d9beb5130044cd8936fdbe"
+)
+RESUMED_UPPER_EVIDENCE_SHA256 = (
+    "d637b58008f17e1380fb1a3ed6f262b4183b7e19f4c420555d89df0c33340d5b"
+)
+KNOWN_ANSWER_GATE_SHA256 = (
+    "7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687"
+)
+KNOWN_ANSWER_TRUST_SHA256 = (
+    "1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140"
+)
+REGISTRY_FILE_SHA256 = (
+    "265f1a3fefef884adeaa980a5dce2441dee4f6f6d71c253ba7a6491360733689"
+)
+REGISTRY_INTERNAL_SHA256 = (
+    "536c733d68d344ed9fef9992bbeb1000900174ad0c500ddb7004126ae5c98408"
+)
+EXPECTED_MATRIX_RECORDS = {
+    "hx": {
+        "content_sha256": "3e84de485357b46239174805f8fc3378eeb0e4207a06fc3a95568e5630c58c8e",
+        "file_sha256": "a8d53c3e14419e0b0c30e2960621394475e06d0cff30a6c1f0c9635c8f5bf9ea",
+    },
+    "hz": {
+        "content_sha256": "21b89580009d0ce19cab3c537ddc53c0211a962d88e4aaa1cf3b9a6752d502ab",
+        "file_sha256": "fae00c16429f8312a9a5f1c8e7f025431f986ac8dcc13a433887111f5503baa4",
+    },
+}
+MUTABLE_BASE_FILES = frozenset(
+    {
+        "README.md",
+        "THIRD_PARTY_NOTICES.md",
+        "docs/REPRODUCE.md",
+        "docs/SCHEMA.md",
+        "docs/STAGE3_TYPED_EXACT_FOM_GT_12.md",
+        "data/stage3_typed_exact_fom_gt_12.jsonl",
+        "evidence/stage3_typed_exact_matrix_index.jsonl",
+        "evidence/stage3_typed_exact_proofs.jsonl",
+        "manifests/stage3_typed_exact_fom_gt_12.json",
+        "scripts/build_exact_fom_gt_12_release.py",
+        "scripts/verify_stage3_typed_exact_fom_gt_12.py",
+        "scripts/verify_dataset.py",
+    }
+)
+LFS_POINTER_PREFIX = b"version https://git-lfs.github.com/spec/v1\n"
+
+
+def sha256_bytes(value: bytes) -> str:
+    return hashlib.sha256(value).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def canonical_sha256(value: dict[str, Any], omitted: str) -> str:
+    payload = {key: item for key, item in value.items() if key != omitted}
+    encoded = json.dumps(
+        payload,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ).encode()
+    return sha256_bytes(encoded)
+
+
+def canonical_value_sha256(value: Any) -> str:
+    encoded = json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ).encode()
+    return sha256_bytes(encoded)
+
+
+def load_json(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise ValueError(f"expected one JSON object: {path}")
+    return value
+
+
+def verify_materialized_base(root: Path) -> None:
+    sums_path = root / "manifests" / "SHA256SUMS"
+    for line in sums_path.read_text(encoding="utf-8").splitlines():
+        if not line:
+            continue
+        expected, relative = line.split("  ", 1)
+        path = root / relative
+        if not path.is_file():
+            raise ValueError(f"missing base release file: {relative}")
+        if path.read_bytes()[: len(LFS_POINTER_PREFIX)] == LFS_POINTER_PREFIX:
+            raise ValueError(
+                f"Git LFS object is not materialized: {relative}; run git lfs pull"
+            )
+        if relative not in MUTABLE_BASE_FILES:
+            observed = sha256_file(path)
+            if observed != expected:
+                raise ValueError(f"sealed base file changed: {relative}")
+
+
+def git_head(root: Path) -> str:
+    return subprocess.check_output(
+        ["git", "-C", str(root), "rev-parse", "HEAD"],
+        text=True,
+    ).strip()
+
+
+def gf2_rank(matrix: Any) -> int:
+    rows = [
+        sum((int(bit) & 1) << col for col, bit in enumerate(row))
+        for row in matrix.tolist()
+    ]
+    rank = 0
+    while rows:
+        pivot = max(rows)
+        if not pivot:
+            break
+        bit = 1 << (pivot.bit_length() - 1)
+        rank += 1
+        rows = [
+            value ^ pivot if value & bit else value
+            for value in rows
+            if value != pivot
+        ]
+    return rank
+
+
+def content_sha256(matrix: Any) -> str:
+    shape = [int(matrix.shape[0]), int(matrix.shape[1])]
+    header = json.dumps(
+        {"dtype": "uint8-gf2", "shape": shape},
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+    return sha256_bytes(header.encode() + b"\n" + matrix.tobytes(order="C"))
+
+
+def dist_array_sha256(name: str, matrix: Any) -> str:
+    digest = hashlib.sha256()
+    digest.update(name.encode())
+    digest.update(b"\0")
+    digest.update(json.dumps(list(matrix.shape), separators=(",", ":")).encode())
+    digest.update(b"\0")
+    digest.update(matrix.tobytes(order="C"))
+    return digest.hexdigest()
+
+
+def matrix_market_gzip(name: str, matrix: Any) -> bytes:
+    rows, cols = map(int, matrix.shape)
+    entries = [
+        f"{row + 1} {col + 1} 1\n"
+        for row in range(rows)
+        for col in range(cols)
+        if int(matrix[row, col]) & 1
+    ]
+    body = (
+        "%%MatrixMarket matrix coordinate integer general\n"
+        f"% qcode candidate {CANDIDATE_ID} {name}; entries are GF(2)\n"
+        f"{rows} {cols} {len(entries)}\n"
+        + "".join(entries)
+    ).encode("ascii")
+    output = io.BytesIO()
+    with gzip.GzipFile(
+        filename="",
+        mode="wb",
+        fileobj=output,
+        compresslevel=9,
+        mtime=0,
+    ) as handle:
+        handle.write(body)
+    return output.getvalue()
+
+
+def matrix_record(root: Path, name: str, matrix: Any) -> dict[str, Any]:
+    relative = Path("matrices") / CANDIDATE_ID / f"{name}.mtx.gz"
+    path = root / relative
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = matrix_market_gzip(name, matrix)
+    path.write_bytes(payload)
+    return {
+        "path": relative.as_posix(),
+        "shape": [int(matrix.shape[0]), int(matrix.shape[1])],
+        "file_sha256": sha256_bytes(payload),
+        "content_sha256": content_sha256(matrix),
+    }
+
+
+def write_jsonl_one(path: Path, value: dict[str, Any]) -> None:
+    payload = json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ) + "\n"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(payload, encoding="utf-8")
+
+
+def source_paths(run: Path) -> dict[str, Path]:
+    unit_dir = (
+        run
+        / "solver-state"
+        / "sat-sectors"
+        / "sat-units"
+        / STATE_KEY
+    )
+    return {
+        "stage3-summary.json": run / "stage3-summary.json",
+        "stage3-ranked.jsonl": run / "stage3-ranked.jsonl",
+        "stage3-thresholds.jsonl": run / "stage3-thresholds.jsonl",
+        "aggregate": run / "solver-state" / "sat-sectors" / f"{STATE_KEY}.json",
+        "lower-terminal": unit_dir / "lower-distqldpc-mto-XZ-global.json",
+        "upper-terminal": unit_dir / "upper-X-global.json",
+    }
+
+
+def build(root: Path, source_run: Path, qcode_root: Path) -> None:
+    root = root.resolve(strict=True)
+    source_run = source_run.resolve(strict=True)
+    qcode_root = qcode_root.resolve(strict=True)
+    verify_materialized_base(root)
+    if git_head(root) != HF_BASE_COMMIT:
+        raise ValueError("Hugging Face release base commit changed")
+    if git_head(qcode_root) != QCODE_COMMIT:
+        raise ValueError("qcode source commit changed")
+    if subprocess.check_output(
+        [
+            "git", "-C", str(qcode_root), "status", "--porcelain",
+            "--untracked-files=no",
+        ],
+        text=True,
+    ).strip():
+        raise ValueError("qcode source tree has tracked modifications")
+    if sha256_file(root / "reference/known_answer_gate.json") != KNOWN_ANSWER_GATE_SHA256:
+        raise ValueError("known-answer gate changed")
+    if sha256_file(root / "reference/known_answer_trust.json") != KNOWN_ANSWER_TRUST_SHA256:
+        raise ValueError("known-answer trust record changed")
+    registry_path = qcode_root / "results" / "known_code_registry.json"
+    if sha256_file(registry_path) != REGISTRY_FILE_SHA256:
+        raise ValueError("known-code registry file changed")
+    registry = load_json(registry_path)
+    if registry.get("registry_sha256") != REGISTRY_INTERNAL_SHA256:
+        raise ValueError("known-code registry internal seal changed")
+    paths = source_paths(source_run)
+    for label, path in paths.items():
+        observed = sha256_file(path)
+        if observed != EXPECTED_SOURCE_SHA256[label]:
+            raise ValueError(f"unexpected {label} SHA256: {observed}")
+
+    sys.path.insert(0, str(qcode_root))
+    import numpy as np
+    from evaluation.bb_code import build_bb_code
+    from evaluation.distance_distqldpc import (
+        verify_distqldpc_exact_evidence,
+        verify_distqldpc_lower_evidence,
+    )
+    from evaluation.distance_milp import get_code_matrices
+    from evaluation.sector_certificate import (
+        REQUEST_FIELD,
+        claim_from_sector_sat_artifact,
+    )
+    from humanize.state import code_key
+
+    aggregate = load_json(paths["aggregate"])
+    lower = load_json(paths["lower-terminal"])
+    upper = load_json(paths["upper-terminal"])
+    summary = load_json(paths["stage3-summary.json"])
+    candidate = aggregate["candidate"]
+
+    if aggregate.get("status") != "EXACT_PROVEN":
+        raise ValueError("source aggregate is not EXACT_PROVEN")
+    if aggregate.get("artifact_sha256") != (
+        "fa03b3a2a8f43d77131c8a5491efbb56d98800d9e215b45e9e5b3e7f86509159"
+    ):
+        raise ValueError("source aggregate canonical seal changed")
+    if candidate.get("canonical_digest") != CANONICAL_DIGEST:
+        raise ValueError("source candidate digest changed")
+    if code_key(candidate) != CANDIDATE_ID:
+        raise ValueError("candidate_id no longer matches humanize.state.code_key")
+    if summary.get("status_counts") != {"EXACT_PROVEN": 1}:
+        raise ValueError("Stage 3 summary is not the accepted one-result handoff")
+    summary_expected = {
+        "schema_version": 1,
+        "gate": "qldpc-direction-candidate-pool",
+        "target_mode": "scalar-fom-inclusive-v1",
+        "backend": "sat-sectors",
+        "input_rows": 4096,
+        "selected_candidates": 1,
+        "malformed_unresolved_rows": 0,
+        "duplicate_digests_skipped": 0,
+        "unselected_unresolved_candidates": 0,
+        "selection_exhausted": True,
+        "threshold_only": False,
+        "status_counts": {"EXACT_PROVEN": 1},
+        "retry_required": False,
+        "retry_reasons": {
+            "unresolved_candidates": 0,
+            "unselected_unresolved_candidates": 0,
+            "operational_errors": 0,
+        },
+        "certify": False,
+        "stage4_candidates": 1,
+        "certified_wins": 0,
+        "operational_errors": 0,
+    }
+    if any(summary.get(key) != value for key, value in summary_expected.items()):
+        raise ValueError("Stage 3 summary fields changed")
+    stage3_budget = summary["worker_budget"]["stage3"]
+    if {
+        "candidate_workers": stage3_budget.get("candidate_workers"),
+        "direction_workers": stage3_budget.get("direction_workers"),
+        "configured_solver_workers": stage3_budget.get("configured_solver_workers"),
+        "admitted_solver_workers": stage3_budget.get("admitted_solver_workers"),
+        "max_total_workers": summary["worker_budget"].get("max_total_workers"),
+    } != {
+        "candidate_workers": 1,
+        "direction_workers": 2,
+        "configured_solver_workers": 2,
+        "admitted_solver_workers": 2,
+        "max_total_workers": 2,
+    }:
+        raise ValueError("Stage 3 worker budget changed")
+    wall = summary["hard_wall_budget"]
+    if (
+        float(wall.get("direction_timeout_s", -1)) != 21600.0
+        or float(wall.get("candidate_timeout_s", -1)) != 134400.0
+        or float(wall.get("termination_grace_s", -1)) != 600.0
+    ):
+        raise ValueError("Stage 3 hard-wall budget changed")
+    results = summary.get("results")
+    if (
+        not isinstance(results, list)
+        or len(results) != 1
+        or results[0].get("canonical_digest") != CANONICAL_DIGEST
+        or results[0].get("status") != "EXACT_PROVEN"
+        or results[0].get("completed_proof_units") != 2
+        or results[0].get("expected_proof_units") != 27
+        or "error" in results[0]
+        or "hard_wall" in results[0]
+    ):
+        raise ValueError("Stage 3 result summary changed")
+
+    typed_claim = claim_from_sector_sat_artifact(aggregate)
+    typed_request = typed_claim[REQUEST_FIELD]
+    if canonical_value_sha256(typed_claim) != EXPECTED_TYPED_CLAIM_SHA256:
+        raise ValueError("typed Stage 3 claim changed")
+    if canonical_value_sha256(typed_request) != EXPECTED_TYPED_REQUEST_SHA256:
+        raise ValueError("typed Stage 3 request changed")
+    typed_expected = {
+        "coverage_mode": "global",
+        "requested_coverage_mode": "first-nonzero",
+        "requested_lower_backend": "distqldpc",
+        "lower_bound_backend": "distqldpc",
+        "lower_bound_threshold": 15,
+        "required_distance": 16,
+        "stage3_status": "EXACT_PROVEN",
+        "target_mode": "scalar-fom-inclusive-v1",
+        "use_translation_anchors": True,
+        "use_construction_anchors": False,
+        "anchor_cover_cubes": None,
+        "distqldpc_exact_distances": [16],
+        "distqldpc_conflict": False,
+        "distqldpc_conflict_details": None,
+        "low_witnesses": [],
+        "escalation_decisions": [],
+        "stage3_artifact_sha256": EXPECTED_TYPED_ARTIFACT_SHA256,
+    }
+    if any(typed_request.get(key) != value for key, value in typed_expected.items()):
+        raise ValueError("typed Stage 3 request semantics changed")
+    if {
+        "canonical_digest": typed_claim.get("canonical_digest"),
+        "n": typed_claim.get("n"),
+        "k": typed_claim.get("k"),
+        "required_distance": typed_claim.get("required_distance"),
+    } != {
+        "canonical_digest": CANONICAL_DIGEST,
+        "n": 210,
+        "k": 10,
+        "required_distance": 16,
+    }:
+        raise ValueError("typed Stage 3 claim parameters changed")
+    typed_lower = typed_request["lower_bound_decisions"]
+    typed_upper = typed_request["upper_witness"]
+    if (
+        len(typed_lower) != 1
+        or typed_lower[0]["solver_evidence"]["evidence_sha256"]
+        != RESUMED_LOWER_EVIDENCE_SHA256
+        or typed_lower[0]["solver_evidence"]["exact_distance"] != 16
+        or typed_upper["solver_evidence"]["evidence_sha256"]
+        != RESUMED_UPPER_EVIDENCE_SHA256
+        or typed_upper["solver_evidence"]["objective"] != 16
+    ):
+        raise ValueError("typed Stage 3 evidence identities changed")
+    if lower.get("evidence_sha256") != RAW_LOWER_EVIDENCE_SHA256:
+        raise ValueError("raw lower terminal evidence changed")
+    if upper.get("evidence_sha256") != RAW_UPPER_EVIDENCE_SHA256:
+        raise ValueError("raw upper terminal evidence changed")
+    aggregate_expected = {
+        "coverage_mode": "global",
+        "requested_coverage_mode": "first-nonzero",
+        "requested_lower_backend": "distqldpc",
+        "lower_bound_backend": "distqldpc",
+        "lower_bound_threshold": 15,
+        "expected_units": 27,
+        "attempted_units": 23,
+        "terminal_units": 2,
+        "retryable_units": 21,
+        "expected_directions": 27,
+        "completed_directions": 2,
+        "expected_lower_decisions": 1,
+        "completed_lower_decisions": 1,
+        "expected_lower_partitions": 1,
+        "completed_lower_partitions": 1,
+        "upper_unsat_decisions": [],
+        "threshold_only": False,
+        "distqldpc_exact_distances": [16],
+        "distqldpc_conflict": False,
+        "distqldpc_conflict_details": None,
+        "low_witnesses": [],
+    }
+    if any(aggregate.get(key) != value for key, value in aggregate_expected.items()):
+        raise ValueError("Stage 3 aggregate terminal state changed")
+
+    code = build_bb_code(
+        21,
+        5,
+        [(7, 3), (18, 4), (20, 0)],
+        [(2, 3), (18, 1), (19, 2)],
+        geometry={"schema_version": 1, "family": "twisted_torus", "twist": 3},
+    )
+    hx, hz, lx, lz = (
+        np.ascontiguousarray(np.asarray(value, dtype=np.uint8) & 1)
+        for value in get_code_matrices(code)
+    )
+    gx, gz = lz, lx
+    matrices = {"Hx": hx, "Hz": hz, "Gx": gx, "Gz": gz}
+    expected_dist_hashes = lower["instance"]["matrix_files"]
+    for name, matrix in matrices.items():
+        if dist_array_sha256(name, matrix) != expected_dist_hashes[name]["array_sha256"]:
+            raise ValueError(f"{name} does not match the sealed solver instance")
+    checkpoint_identity = lower["instance"]["checkpoint_identity"]
+    verifier_args = {
+        "max_weight": 15,
+        "cardinality_mode": "mto",
+        "expected_checkpoint_identity": checkpoint_identity,
+        "expected_binary_sha256": DISTQLDPC_BINARY_SHA256,
+        "expected_source_commit": DISTQLDPC_SOURCE_COMMIT,
+    }
+    exact_failures = verify_distqldpc_exact_evidence(
+        lower, hx, hz, lx, lz, **verifier_args
+    )
+    lower_failures = verify_distqldpc_lower_evidence(
+        lower, hx, hz, lx, lz, **verifier_args
+    )
+    if exact_failures or lower_failures:
+        raise ValueError(
+            f"raw DistQLDPC terminal replay failed: {exact_failures}; "
+            f"{lower_failures}"
+        )
+    for name in ("Hx", "Hz"):
+        matrix = matrices[name]
+        generated = {
+            "content_sha256": content_sha256(matrix),
+            "file_sha256": sha256_bytes(matrix_market_gzip(name, matrix)),
+        }
+        if generated != EXPECTED_MATRIX_RECORDS[name.lower()]:
+            raise ValueError(f"deterministic {name} public matrix changed")
+
+    rank_x, rank_z = gf2_rank(hx), gf2_rank(hz)
+    if (rank_x, rank_z) != (100, 100):
+        raise ValueError("unexpected check ranks")
+    if np.any((hx @ hz.T) & 1):
+        raise ValueError("CSS checks do not commute")
+    if np.any((hx @ gx.T) & 1) or np.any((hz @ gz.T) & 1):
+        raise ValueError("logical representatives do not commute with checks")
+    if not np.array_equal((gz @ gx.T) & 1, np.eye(10, dtype=np.uint8)):
+        raise ValueError("logical representatives fail duality")
+
+    packed = bytes.fromhex(upper["operator"]["packed_hex"])
+    operator = np.unpackbits(
+        np.frombuffer(packed, dtype=np.uint8), bitorder="little"
+    )[:210].astype(np.uint8)
+    if int(operator.sum()) != 16 or np.any((hz @ operator) & 1):
+        raise ValueError("upper witness is invalid")
+    syndrome = ((gx @ operator) & 1).astype(int).tolist()
+    if syndrome != upper["logical_syndrome"] or not any(syndrome):
+        raise ValueError("upper witness is not a nontrivial X logical")
+
+    checks = {
+        "css_commutation": True,
+        "commutation_violations": 0,
+        "rank_x": rank_x,
+        "rank_z": rank_z,
+        "k_recomputed": 210 - rank_x - rank_z,
+        "max_check_weight": max(
+            max(map(int, hx.sum(axis=1))),
+            max(map(int, hz.sum(axis=1))),
+        ),
+        "max_sector_qubit_degree": max(
+            max(map(int, hx.sum(axis=0))),
+            max(map(int, hz.sum(axis=0))),
+        ),
+        "max_qubit_degree": max(map(int, hx.sum(axis=0) + hz.sum(axis=0))),
+        "logical_basis_complete": True,
+        "logical_duality": True,
+    }
+    if checks != {
+        "css_commutation": True,
+        "commutation_violations": 0,
+        "rank_x": 100,
+        "rank_z": 100,
+        "k_recomputed": 10,
+        "max_check_weight": 6,
+        "max_sector_qubit_degree": 3,
+        "max_qubit_degree": 6,
+        "logical_basis_complete": True,
+        "logical_duality": True,
+    }:
+        raise ValueError(f"unexpected matrix checks: {checks}")
+
+    matrix_records = {
+        name.lower(): matrix_record(root, name, matrix)
+        for name, matrix in matrices.items()
+    }
+
+    public_source = {
+        "qcode_commit": QCODE_COMMIT,
+        "stage3_aggregate_byte_sha256": EXPECTED_SOURCE_SHA256["aggregate"],
+        "stage3_aggregate_self_seal_sha256": aggregate["artifact_sha256"],
+        "stage3_typed_request_artifact_sha256": EXPECTED_TYPED_ARTIFACT_SHA256,
+        "stage3_typed_claim_sha256": EXPECTED_TYPED_CLAIM_SHA256,
+        "stage3_typed_request_sha256": EXPECTED_TYPED_REQUEST_SHA256,
+        "stage3_lower_terminal_byte_sha256": EXPECTED_SOURCE_SHA256["lower-terminal"],
+        "stage3_lower_raw_terminal_evidence_sha256": RAW_LOWER_EVIDENCE_SHA256,
+        "stage3_lower_resumed_evidence_sha256": RESUMED_LOWER_EVIDENCE_SHA256,
+        "stage3_upper_terminal_byte_sha256": EXPECTED_SOURCE_SHA256["upper-terminal"],
+        "stage3_upper_raw_terminal_evidence_sha256": RAW_UPPER_EVIDENCE_SHA256,
+        "stage3_upper_resumed_evidence_sha256": RESUMED_UPPER_EVIDENCE_SHA256,
+        "stage3_summary_byte_sha256": EXPECTED_SOURCE_SHA256["stage3-summary.json"],
+        "stage3_ranked_byte_sha256": EXPECTED_SOURCE_SHA256["stage3-ranked.jsonl"],
+        "stage3_threshold_byte_sha256": EXPECTED_SOURCE_SHA256["stage3-thresholds.jsonl"],
+        "known_answer_gate_sha256": KNOWN_ANSWER_GATE_SHA256,
+        "known_answer_trust_sha256": KNOWN_ANSWER_TRUST_SHA256,
+    }
+    construction = {
+        "family": "css-bb",
+        "representation_id": "css-bb-twisted-torus-generator-v1",
+        "ell": 21,
+        "m": 5,
+        "geometry": {"schema_version": 1, "family": "twisted_torus", "twist": 3},
+        "A_terms": [[7, 3], [18, 4], [20, 0]],
+        "B_terms": [[2, 3], [18, 1], [19, 2]],
+    }
+    record: dict[str, Any] = {
+        "schema_version": 1,
+        "record_kind": "stage3_typed_exact_fom_gt_12",
+        "evidence_class": "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE",
+        "source_stage": "stage3_direction_audit",
+        "source_status": "EXACT_PROVEN",
+        "release_status": "PENDING_STAGE4_STAGE5",
+        "candidate_id": CANDIDATE_ID,
+        "canonical_digest": CANONICAL_DIGEST,
+        "code": "[[210,10,16]]",
+        "construction": construction,
+        "parameters": {"n": 210, "k": 10},
+        "distance": {
+            "status": "EXACT_PROVEN",
+            "exact": 16,
+            "lower_bound": 16,
+            "upper_bound": 16,
+            "lower_bound_backend": "DistQLDPC/MaxCDCL",
+            "upper_bound_backend": "python-sat/cadical195",
+        },
+        "fom": {
+            "exact": {
+                "numerator": 256,
+                "denominator": 21,
+                "decimal": 256 / 21,
+            },
+            "excess_over_12": {
+                "numerator": 4,
+                "denominator": 21,
+                "decimal": 4 / 21,
+            },
+            "strict_integer_margin": 40,
+        },
+        "target": {
+            "strict_predicate": "k*d*d > 12*n",
+            "required_distance": 16,
+            "left_hand_side": 2560,
+            "right_hand_side": 2520,
+            "passes_strict_target": True,
+            "certified_win": False,
+        },
+        "source_target": {
+            "mode": candidate["target"]["mode"],
+            "strict": candidate["target"]["strict"],
+            "binding_sha256": candidate["target"]["binding_sha256"],
+            "required_distance": candidate["target"]["required_distance"],
+        },
+        "matrices": matrix_records,
+        "matrix_checks": checks,
+        "novelty": {
+            "status": candidate["novelty"]["status"],
+            "novel": candidate["novelty"]["novel"],
+            "registry_version": candidate["novelty"]["registry_version"],
+            "registry_file_sha256": REGISTRY_FILE_SHA256,
+            "registry_internal_sha256": REGISTRY_INTERNAL_SHA256,
+            "matched_entries": candidate["novelty"]["matched_entries"],
+            "source_stage3_replayed": candidate["novelty"]["replayed_from_construction"],
+            "release_current_registry_replayed": False,
+            "scope": "pinned known-code registry with explicit construction/matrix replay",
+        },
+        "known_answer_context": {
+            "gate_file_sha256": KNOWN_ANSWER_GATE_SHA256,
+            "trust_file_sha256": KNOWN_ANSWER_TRUST_SHA256,
+            "release_replayed": False,
+        },
+        "authority": {
+            "stage3_typed_handoff_replay": True,
+            "exact_under_pinned_solver_trust_model": True,
+            "pipeline_stage4_certificate": False,
+            "portable_unsat_proof_certificate": False,
+            "pipeline_stage5_final_gate": False,
+            "pipeline_promotion": False,
+            "independent_release_gate_complete": False,
+            "publication_certificate": False,
+            "public_dataset_record": True,
+        },
+        "source": public_source,
+    }
+    record["record_sha256"] = canonical_sha256(record, "record_sha256")
+
+    safe_backend = {
+        "distribution": lower["backend"]["distribution"],
+        "interface": lower["backend"]["interface"],
+        "repository": lower["backend"]["repository"],
+        "source_commit": lower["backend"]["source_commit"],
+        "binary_sha256": lower["backend"]["binary_sha256"],
+        "binary_size": lower["backend"]["file_size"],
+        "identity_sha256": lower["backend"]["identity_sha256"],
+    }
+    if safe_backend["binary_sha256"] != DISTQLDPC_BINARY_SHA256:
+        raise ValueError("DistQLDPC binary pin changed")
+    if safe_backend["source_commit"] != DISTQLDPC_SOURCE_COMMIT:
+        raise ValueError("DistQLDPC source pin changed")
+
+    evidence: dict[str, Any] = {
+        "schema_version": 1,
+        "record_kind": "stage3_typed_exact_fom_gt_12_evidence",
+        "evidence_class": "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE",
+        "source_status": "EXACT_PROVEN",
+        "release_status": "PENDING_STAGE4_STAGE5",
+        "authority": record["authority"],
+        "candidate_id": CANDIDATE_ID,
+        "canonical_digest": CANONICAL_DIGEST,
+        "distance_claim": {
+            "status": "EXACT_PROVEN",
+            "exact": 16,
+            "lower_bound": 16,
+            "upper_bound": 16,
+        },
+        "stage3_typed_handoff": {
+            "gate": aggregate["gate"],
+            "status": aggregate["status"],
+            "backend": aggregate["lower_bound_backend"],
+            "lower_bound_threshold": aggregate["lower_bound_threshold"],
+            "attempted_proof_units": aggregate["attempted_units"],
+            "completed_proof_units": aggregate["terminal_units"],
+            "expected_proof_units": aggregate["expected_units"],
+            "source_retryable_units_at_terminal": aggregate["retryable_units"],
+            "summary_retry_required": summary["retry_required"],
+            "terminal_reason": "distqldpc_exact_plus_upper_witness",
+            "distqldpc_exact_distances": aggregate["distqldpc_exact_distances"],
+            "distqldpc_conflict": aggregate["distqldpc_conflict"],
+            "distqldpc_conflict_details": aggregate["distqldpc_conflict_details"],
+            "low_witnesses": aggregate["low_witnesses"],
+            "typed_replay_verified": True,
+            **public_source,
+        },
+        "lower_bound_evidence": {
+            "evidence_kind": lower["evidence_kind"],
+            "formulation": lower["formulation"],
+            "outcome": lower["outcome"],
+            "exact_distance": lower["exact_distance"],
+            "lower_bound": lower["lower_bound"],
+            "upper_bound": lower["upper_bound"],
+            "threshold_infeasible": lower["threshold_infeasible"],
+            "decision_complete": lower["decision_complete"],
+            "retryable": lower["retryable"],
+            "returncode": lower["returncode"],
+            "timed_out": lower["timed_out"],
+            "hard_timeout_s": lower["hard_timeout_s"],
+            "elapsed_s": lower["elapsed_s"],
+            "cardinality_mode": lower["instance"]["solver_execution"]["cardinality_mode"],
+            "parsed_output": lower["parsed_output"],
+            "stdout_sha256": lower["stdout_sha256"],
+            "stderr_sha256": lower["stderr_sha256"],
+            "raw_terminal_replay_verified": True,
+            "raw_terminal_evidence_sha256": lower["evidence_sha256"],
+            "aggregate_resumed_evidence_sha256": RESUMED_LOWER_EVIDENCE_SHA256,
+            "terminal_file_sha256": EXPECTED_SOURCE_SHA256["lower-terminal"],
+            "instance_binding_sha256": lower["instance"]["binding_sha256"],
+            "checkpoint_identity": checkpoint_identity,
+            "logical_detector": lower["instance"]["logical_detector"],
+            "solver_instance_array_sha256": {
+                name: expected_dist_hashes[name]["array_sha256"]
+                for name in ("Hx", "Hz", "Gx", "Gz")
+            },
+            "runtime_source": lower["instance"]["solver_execution"]["runtime_source"],
+            "backend": safe_backend,
+        },
+        "upper_bound_evidence": {
+            "evidence_kind": upper["evidence_kind"],
+            "formulation": upper["formulation"],
+            "outcome": upper["outcome"],
+            "sector": upper["sector"],
+            "objective": upper["objective"],
+            "decision_complete": upper["decision_complete"],
+            "retryable": upper["retryable"],
+            "anchor_indices": upper["anchor_indices"],
+            "operator": upper["operator"],
+            "logical_syndrome": upper["logical_syndrome"],
+            "backend": upper["backend"],
+            "cnf": upper["cnf"],
+            "raw_terminal_evidence_sha256": upper["evidence_sha256"],
+            "aggregate_resumed_evidence_sha256": RESUMED_UPPER_EVIDENCE_SHA256,
+            "terminal_file_sha256": EXPECTED_SOURCE_SHA256["upper-terminal"],
+            "instance_binding_sha256": upper["instance"]["binding_sha256"],
+        },
+        "symmetry": {
+            "translation_verified": aggregate["translation_symmetry"]["verified"],
+            "orbit_representatives": aggregate["translation_symmetry"]["orbit_representatives"],
+            "xz_sector_isometry_verified": aggregate["xz_sector_isometry"]["verified"],
+            "xz_sector_isometry_sha256": aggregate["xz_sector_isometry"]["report_sha256"],
+            "covered_sectors": aggregate["xz_sector_isometry"]["covered_sectors"],
+        },
+        "limitations": {
+            "portable_unsat_certificate": (
+                "Not available. The lower bound is a replay-bound result under the "
+                "pinned DistQLDPC/MaxCDCL binary and runtime trust model."
+            ),
+            "independent_checks": (
+                "The public verifier reconstructs Hx/Hz, checks CSS ranks and "
+                "commutation, validates the complete logical basis, and replays "
+                "the weight-16 upper witness. It cannot independently certify "
+                "the solver-derived lower bound without a portable proof trace."
+            ),
+        },
+    }
+    evidence["evidence_sha256"] = canonical_sha256(evidence, "evidence_sha256")
+
+    data_path = root / "data" / "stage3_typed_exact_fom_gt_12.jsonl"
+    evidence_path = root / "evidence" / "stage3_typed_exact_proofs.jsonl"
+    write_jsonl_one(data_path, record)
+    write_jsonl_one(evidence_path, evidence)
+
+    matrix_index = {
+        "schema_version": 1,
+        "record_kind": "stage3_typed_exact_matrix_index",
+        "candidate_id": CANDIDATE_ID,
+        "canonical_digest": CANONICAL_DIGEST,
+        "n": 210,
+        "k": 10,
+        "matrices": matrix_records,
+    }
+    matrix_index["record_sha256"] = canonical_sha256(
+        matrix_index, "record_sha256"
+    )
+    matrix_index_path = (
+        root / "evidence" / "stage3_typed_exact_matrix_index.jsonl"
+    )
+    write_jsonl_one(matrix_index_path, matrix_index)
+
+    release_files = [
+        "README.md",
+        "THIRD_PARTY_NOTICES.md",
+        "docs/REPRODUCE.md",
+        "docs/SCHEMA.md",
+        "data/stage3_typed_exact_fom_gt_12.jsonl",
+        "evidence/stage3_typed_exact_proofs.jsonl",
+        "evidence/stage3_typed_exact_matrix_index.jsonl",
+        *[matrix_records[name]["path"] for name in ("hx", "hz", "gx", "gz")],
+        "docs/STAGE3_TYPED_EXACT_FOM_GT_12.md",
+        "scripts/verify_dataset.py",
+        "scripts/verify_stage3_typed_exact_fom_gt_12.py",
+        "scripts/build_exact_fom_gt_12_release.py",
+    ]
+    manifest: dict[str, Any] = {
+        "schema_version": 1,
+        "gate": "qcode-public-stage3-typed-exact-fom-gt-12-v1",
+        "status": "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE",
+        "source_status": "EXACT_PROVEN",
+        "release_status": "PENDING_STAGE4_STAGE5",
+        "certified_win": False,
+        "publication_certificate": False,
+        "created_date_utc": "2026-08-19",
+        "dataset_base_commit": HF_BASE_COMMIT,
+        "candidate": {
+            "candidate_id": CANDIDATE_ID,
+            "canonical_digest": CANONICAL_DIGEST,
+            "code": "[[210,10,16]]",
+            "exact_fom_numerator": 256,
+            "exact_fom_denominator": 21,
+        },
+        "authority": record["authority"],
+        "source": public_source,
+        "files": [],
+    }
+    for relative in release_files:
+        path = root / relative
+        item: dict[str, Any] = {
+            "path": relative,
+            "bytes": path.stat().st_size,
+            "sha256": sha256_file(path),
+        }
+        if relative.endswith(".jsonl"):
+            item["rows"] = len(
+                [line for line in path.read_text(encoding="utf-8").splitlines() if line]
+            )
+        manifest["files"].append(item)
+    manifest["manifest_sha256"] = canonical_sha256(manifest, "manifest_sha256")
+    manifest_path = root / "manifests" / "stage3_typed_exact_fom_gt_12.json"
+    manifest_path.write_text(
+        json.dumps(manifest, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+    sums_path = root / "manifests" / "SHA256SUMS"
+    existing_order = []
+    for line in sums_path.read_text(encoding="utf-8").splitlines():
+        if not line:
+            continue
+        _old, relative = line.split("  ", 1)
+        existing_order.append(relative)
+    additions = [
+        *release_files,
+        "manifests/stage3_typed_exact_fom_gt_12.json",
+    ]
+    order = existing_order + [item for item in additions if item not in existing_order]
+    sums_path.write_text(
+        "".join(f"{sha256_file(root / relative)}  {relative}\n" for relative in order),
+        encoding="utf-8",
+    )
+    print(
+        json.dumps(
+            {
+                "candidate_id": CANDIDATE_ID,
+                "code": "[[210,10,16]]",
+                "fom": 256 / 21,
+                "record_sha256": record["record_sha256"],
+                "evidence_sha256": evidence["evidence_sha256"],
+                "manifest_sha256": manifest["manifest_sha256"],
+            },
+            sort_keys=True,
+        )
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("root", type=Path)
+    parser.add_argument("source_run", type=Path)
+    parser.add_argument("qcode_root", type=Path)
+    args = parser.parse_args()
+    build(args.root, args.source_run, args.qcode_root)
+
+
+if __name__ == "__main__":
+    main()

scripts/verify_dataset.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 from __future__ import annotations
-import argparse, gzip, hashlib, json
+import argparse, gzip, hashlib, json, sys
 from pathlib import Path
 
 def sha(path):
@@ -86,6 +86,13 @@ def main(root):
     manifest=json.loads((root/"manifests/selection.json").read_text())
     assert manifest["selected_candidates"]==len(candidates)
     assert manifest["certified_fom_gt_12_count"]==sum(r["target"]["certified_win"] for r in candidates.values())
+    stage3_lane=root/"data/stage3_typed_exact_fom_gt_12.jsonl"
+    if stage3_lane.is_file():
+        scripts_dir=str(Path(__file__).resolve().parent)
+        if scripts_dir not in sys.path:
+            sys.path.insert(0,scripts_dir)
+        from verify_stage3_typed_exact_fom_gt_12 import verify as verify_stage3_lane
+        verify_stage3_lane(root)
     print(f"PASS: {checked} file hashes, {len(candidates)} candidates, all matrices and witnesses verified")
 
 if __name__=="__main__":

scripts/verify_stage3_typed_exact_fom_gt_12.py

@@ -0,0 +1,538 @@
+#!/usr/bin/env python3
+"""Verify the public Stage-3-typed [[210,10,16]] release.
+
+The portable checks reconstruct the twisted CSS matrices, validate the exact
+solver instance matrix bundle and logical basis, and replay the weight-16 upper
+witness.  The DistQLDPC lower bound remains explicitly tied to the pinned
+solver/runtime evidence; this script does not turn it into a DRAT/LRAT proof.
+"""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+
+CANDIDATE_ID = "5f773fbfbce9775bc30b"
+CANONICAL_DIGEST = (
+    "4ba2bcc894b883eb930bf727148c2f57bcf4963c903a940528613b2f542a607c"
+)
+QCODE_COMMIT = "ade9dc706a455427384e4ba82c0981d9cc9f6671"
+HF_BASE_COMMIT = "3a24375d3494479c76ecd7c377c9b5d038f2561b"
+EXPECTED_TYPED_CLAIM_SHA256 = (
+    "1a2a076a891a790a92359d903f7874f989d12a2f684518fd227923bbe7f0c2c9"
+)
+EXPECTED_TYPED_REQUEST_SHA256 = (
+    "ce20b44a85b000cf59b24fa4fa69196ccd596ba3d42c78ab325bad1fac99caad"
+)
+EXPECTED_TYPED_ARTIFACT_SHA256 = (
+    "ed3f639b3b7254566b248e3314dcca9aed82a8a91f0465a61d920571b2c9c6d3"
+)
+RAW_LOWER_EVIDENCE_SHA256 = (
+    "75ac260531dba3618c14fb459e86e2e8bfe39d205a1705da61d516528d0db581"
+)
+RESUMED_LOWER_EVIDENCE_SHA256 = (
+    "fb0bb3fc7b3dc6312952ad7ba9d324346ebd16db35e59e3b894ae3c0f70d489e"
+)
+RAW_UPPER_EVIDENCE_SHA256 = (
+    "8da3a1ee2523a0e7e4c4e21a627c8a780d8160cd09d9beb5130044cd8936fdbe"
+)
+RESUMED_UPPER_EVIDENCE_SHA256 = (
+    "d637b58008f17e1380fb1a3ed6f262b4183b7e19f4c420555d89df0c33340d5b"
+)
+KNOWN_ANSWER_GATE_SHA256 = (
+    "7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687"
+)
+KNOWN_ANSWER_TRUST_SHA256 = (
+    "1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140"
+)
+REGISTRY_FILE_SHA256 = (
+    "265f1a3fefef884adeaa980a5dce2441dee4f6f6d71c253ba7a6491360733689"
+)
+REGISTRY_INTERNAL_SHA256 = (
+    "536c733d68d344ed9fef9992bbeb1000900174ad0c500ddb7004126ae5c98408"
+)
+EXPECTED_SOURCE_SHA256 = {
+    "stage3_aggregate_byte_sha256": "ee2965586cff334caf22d1c0b360127c22cca34c5136f58c88cdd150a5ffeefd",
+    "stage3_aggregate_self_seal_sha256": "fa03b3a2a8f43d77131c8a5491efbb56d98800d9e215b45e9e5b3e7f86509159",
+    "stage3_lower_terminal_byte_sha256": "9def4c1d0134165bbf3166382d8b07b361b816504e00e2473615fe9c45a26218",
+    "stage3_upper_terminal_byte_sha256": "f1fe9686eaac799ecf4583d48fe39858381b29e7a47844af5c447e6e21ebc86e",
+    "stage3_summary_byte_sha256": "4579c4472879e78da8a77b66e240b6e2ea66a1d47ca782f889247b3186b0a5ab",
+    "stage3_ranked_byte_sha256": "b8a0f2a7dd4191dd6d578addaec67cee60786104a748dd78203a822e196e3129",
+    "stage3_threshold_byte_sha256": "1c3a4bcf0a4598fc7c91236c01513f375746ba0d8c635d88630800be9f5bfcd6",
+}
+EXPECTED_PUBLIC_MATRICES = {
+    "hx": {
+        "content_sha256": "3e84de485357b46239174805f8fc3378eeb0e4207a06fc3a95568e5630c58c8e",
+        "file_sha256": "a8d53c3e14419e0b0c30e2960621394475e06d0cff30a6c1f0c9635c8f5bf9ea",
+    },
+    "hz": {
+        "content_sha256": "21b89580009d0ce19cab3c537ddc53c0211a962d88e4aaa1cf3b9a6752d502ab",
+        "file_sha256": "fae00c16429f8312a9a5f1c8e7f025431f986ac8dcc13a433887111f5503baa4",
+    },
+}
+DISTQLDPC_BINARY_SHA256 = (
+    "9e09c544d5151d872dc1037dcb1440509e27b8b485a7f9ea5a15d6e55b36d3fa"
+)
+DISTQLDPC_SOURCE_COMMIT = (
+    "c01fa93eb5e1e62948e4861e2c164a6b64fe88eb"
+)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def canonical_sha256(value: dict[str, Any], omitted: str) -> str:
+    payload = {key: item for key, item in value.items() if key != omitted}
+    encoded = json.dumps(
+        payload,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ).encode()
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def load_jsonl_one(path: Path) -> dict[str, Any]:
+    lines = [line for line in path.read_text(encoding="utf-8").splitlines() if line]
+    assert len(lines) == 1, (path, len(lines))
+    value = json.loads(lines[0])
+    assert isinstance(value, dict)
+    return value
+
+
+def load_mtx(path: Path) -> list[list[int]]:
+    with gzip.open(path, "rt", encoding="ascii") as handle:
+        assert handle.readline().strip() == (
+            "%%MatrixMarket matrix coordinate integer general"
+        )
+        line = handle.readline()
+        while line.startswith("%"):
+            line = handle.readline()
+        rows, cols, nnz = map(int, line.split())
+        matrix = [[0] * cols for _ in range(rows)]
+        seen = 0
+        for line in handle:
+            if not line.strip():
+                continue
+            row, col, value = map(int, line.split())
+            assert value == 1
+            matrix[row - 1][col - 1] ^= 1
+            seen += 1
+        assert seen == nnz
+        return matrix
+
+
+def gf2_rank(matrix: list[list[int]]) -> int:
+    rows = [
+        sum((value & 1) << col for col, value in enumerate(row))
+        for row in matrix
+    ]
+    rank = 0
+    while rows:
+        pivot = max(rows)
+        if not pivot:
+            break
+        bit = 1 << (pivot.bit_length() - 1)
+        rank += 1
+        rows = [
+            value ^ pivot if value & bit else value
+            for value in rows
+            if value != pivot
+        ]
+    return rank
+
+
+def content_sha256(matrix: list[list[int]]) -> str:
+    shape = [len(matrix), len(matrix[0]) if matrix else 0]
+    header = json.dumps(
+        {"dtype": "uint8-gf2", "shape": shape},
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+    raw = bytes(value & 1 for row in matrix for value in row)
+    return hashlib.sha256(header.encode() + b"\n" + raw).hexdigest()
+
+
+def dist_array_sha256(name: str, matrix: list[list[int]]) -> str:
+    shape = [len(matrix), len(matrix[0]) if matrix else 0]
+    raw = bytes(value & 1 for row in matrix for value in row)
+    return hashlib.sha256(
+        name.encode()
+        + b"\0"
+        + json.dumps(shape, separators=(",", ":")).encode()
+        + b"\0"
+        + raw
+    ).hexdigest()
+
+
+def transpose(matrix: list[list[int]]) -> list[list[int]]:
+    return [list(column) for column in zip(*matrix)]
+
+
+def hstack(
+    left: list[list[int]], right: list[list[int]]
+) -> list[list[int]]:
+    return [a + b for a, b in zip(left, right)]
+
+
+def parity(left: list[int], right: list[int]) -> int:
+    return sum(a & b for a, b in zip(left, right)) & 1
+
+
+def twisted_polynomial_matrix(
+    ell: int,
+    m: int,
+    twist: int,
+    terms: list[list[int]],
+) -> list[list[int]]:
+    size = ell * m
+    matrix = [[0] * size for _ in range(size)]
+    for row in range(size):
+        x, y = divmod(row, m)
+        for dx, dy in terms:
+            wraps, reduced_x = divmod(x + dx, ell)
+            reduced_y = (y + dy - wraps * twist) % m
+            matrix[row][reduced_x * m + reduced_y] ^= 1
+    return matrix
+
+
+def unpack_operator(record: dict[str, Any]) -> list[int]:
+    length = int(record["length"])
+    packed = bytes.fromhex(record["packed_hex"])
+    bits = [
+        (packed[index // 8] >> (index % 8)) & 1
+        for index in range(length)
+    ]
+    assert sum(bits) == record["weight"]
+    assert hashlib.sha256(f"{length}:".encode() + packed).hexdigest() == (
+        record["sha256"]
+    )
+    assert all(
+        not ((packed[index // 8] >> (index % 8)) & 1)
+        for index in range(length, len(packed) * 8)
+    )
+    return bits
+
+
+def verify_no_operational_leak(value: Any, path: tuple[str, ...] = ()) -> None:
+    if isinstance(value, dict):
+        forbidden_keys = {
+            "command",
+            "command_flags",
+            "requested_path",
+            "resolved_path",
+            "progress_path",
+            "stdout",
+            "stderr",
+            "pid",
+            "pgid",
+            "session_id",
+            "environment",
+        }
+        assert not (set(value) & forbidden_keys), (path, set(value) & forbidden_keys)
+        for key, item in value.items():
+            verify_no_operational_leak(item, (*path, key))
+    elif isinstance(value, list):
+        for index, item in enumerate(value):
+            verify_no_operational_leak(item, (*path, str(index)))
+    elif isinstance(value, str):
+        assert "/root/" not in value and "/tmp/" not in value, (path, value)
+
+
+def verify(root: Path) -> None:
+    root = root.resolve()
+    data = load_jsonl_one(root / "data/stage3_typed_exact_fom_gt_12.jsonl")
+    evidence = load_jsonl_one(root / "evidence/stage3_typed_exact_proofs.jsonl")
+    matrix_index = load_jsonl_one(
+        root / "evidence/stage3_typed_exact_matrix_index.jsonl"
+    )
+    manifest = json.loads(
+        (root / "manifests/stage3_typed_exact_fom_gt_12.json").read_text(
+            encoding="utf-8"
+        )
+    )
+
+    assert canonical_sha256(data, "record_sha256") == data["record_sha256"]
+    assert canonical_sha256(evidence, "evidence_sha256") == evidence["evidence_sha256"]
+    assert canonical_sha256(matrix_index, "record_sha256") == matrix_index["record_sha256"]
+    assert canonical_sha256(manifest, "manifest_sha256") == manifest["manifest_sha256"]
+    for item in manifest["files"]:
+        path = root / item["path"]
+        assert path.stat().st_size == item["bytes"]
+        assert sha256(path) == item["sha256"]
+        if "rows" in item:
+            rows = len(
+                [line for line in path.read_text(encoding="utf-8").splitlines() if line]
+            )
+            assert rows == item["rows"]
+
+    assert data["candidate_id"] == evidence["candidate_id"] == CANDIDATE_ID
+    assert matrix_index["candidate_id"] == CANDIDATE_ID
+    assert data["canonical_digest"] == evidence["canonical_digest"] == CANONICAL_DIGEST
+    assert matrix_index["canonical_digest"] == CANONICAL_DIGEST
+    assert data["evidence_class"] == evidence["evidence_class"] == (
+        "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE"
+    )
+    assert data["release_status"] == "PENDING_STAGE4_STAGE5"
+    authority = data["authority"]
+    assert authority["stage3_typed_handoff_replay"] is True
+    assert authority["exact_under_pinned_solver_trust_model"] is True
+    assert authority["pipeline_stage4_certificate"] is False
+    assert authority["pipeline_stage5_final_gate"] is False
+    assert authority["independent_release_gate_complete"] is False
+    assert authority["portable_unsat_proof_certificate"] is False
+    assert data["target"]["certified_win"] is False
+    assert data["source_target"]["mode"] == "scalar-fom-inclusive-v1"
+    assert data["source_target"]["strict"] is False
+    assert data["record_kind"] == "stage3_typed_exact_fom_gt_12"
+    assert evidence["record_kind"] == "stage3_typed_exact_fom_gt_12_evidence"
+    assert matrix_index["record_kind"] == "stage3_typed_exact_matrix_index"
+    assert data["source_status"] == evidence["source_status"] == "EXACT_PROVEN"
+    assert data["release_status"] == evidence["release_status"] == (
+        "PENDING_STAGE4_STAGE5"
+    )
+    assert manifest["schema_version"] == 1
+    assert manifest["gate"] == "qcode-public-stage3-typed-exact-fom-gt-12-v1"
+    assert manifest["status"] == "STAGE3_TYPED_EXACT_PENDING_STRICT_GATE"
+    assert manifest["source_status"] == "EXACT_PROVEN"
+    assert manifest["release_status"] == "PENDING_STAGE4_STAGE5"
+    assert manifest["certified_win"] is False
+    assert manifest["publication_certificate"] is False
+    assert manifest["dataset_base_commit"] == HF_BASE_COMMIT
+    expected_authority = {
+        "stage3_typed_handoff_replay": True,
+        "exact_under_pinned_solver_trust_model": True,
+        "pipeline_stage4_certificate": False,
+        "portable_unsat_proof_certificate": False,
+        "pipeline_stage5_final_gate": False,
+        "pipeline_promotion": False,
+        "independent_release_gate_complete": False,
+        "publication_certificate": False,
+        "public_dataset_record": True,
+    }
+    assert authority == expected_authority
+    assert evidence["authority"] == manifest["authority"] == expected_authority
+
+    source = data["source"]
+    assert source == manifest["source"]
+    for key, expected in EXPECTED_SOURCE_SHA256.items():
+        assert source[key] == expected
+    assert source["qcode_commit"] == QCODE_COMMIT
+    assert source["stage3_typed_request_artifact_sha256"] == (
+        EXPECTED_TYPED_ARTIFACT_SHA256
+    )
+    assert source["stage3_typed_claim_sha256"] == EXPECTED_TYPED_CLAIM_SHA256
+    assert source["stage3_typed_request_sha256"] == EXPECTED_TYPED_REQUEST_SHA256
+    assert source["stage3_lower_raw_terminal_evidence_sha256"] == (
+        RAW_LOWER_EVIDENCE_SHA256
+    )
+    assert source["stage3_lower_resumed_evidence_sha256"] == (
+        RESUMED_LOWER_EVIDENCE_SHA256
+    )
+    assert source["stage3_upper_raw_terminal_evidence_sha256"] == (
+        RAW_UPPER_EVIDENCE_SHA256
+    )
+    assert source["stage3_upper_resumed_evidence_sha256"] == (
+        RESUMED_UPPER_EVIDENCE_SHA256
+    )
+    assert source["known_answer_gate_sha256"] == KNOWN_ANSWER_GATE_SHA256
+    assert source["known_answer_trust_sha256"] == KNOWN_ANSWER_TRUST_SHA256
+    assert data["known_answer_context"] == {
+        "gate_file_sha256": KNOWN_ANSWER_GATE_SHA256,
+        "trust_file_sha256": KNOWN_ANSWER_TRUST_SHA256,
+        "release_replayed": False,
+    }
+    assert data["novelty"]["registry_file_sha256"] == REGISTRY_FILE_SHA256
+    assert data["novelty"]["registry_internal_sha256"] == REGISTRY_INTERNAL_SHA256
+    assert data["novelty"]["source_stage3_replayed"] is True
+    assert data["novelty"]["release_current_registry_replayed"] is False
+
+    construction = data["construction"]
+    key_payload = {
+        "ell": construction["ell"],
+        "m": construction["m"],
+        "A_terms": sorted(construction["A_terms"]),
+        "B_terms": sorted(construction["B_terms"]),
+        "geometry": construction["geometry"],
+    }
+    encoded = json.dumps(key_payload, sort_keys=True, separators=(",", ":"))
+    assert hashlib.sha256(encoded.encode()).hexdigest()[:20] == CANDIDATE_ID
+
+    ell, m = construction["ell"], construction["m"]
+    twist = construction["geometry"]["twist"]
+    a_matrix = twisted_polynomial_matrix(ell, m, twist, construction["A_terms"])
+    b_matrix = twisted_polynomial_matrix(ell, m, twist, construction["B_terms"])
+    expected_hx = hstack(a_matrix, b_matrix)
+    expected_hz = hstack(transpose(b_matrix), transpose(a_matrix))
+
+    matrices = {
+        name: load_mtx(root / data["matrices"][name.lower()]["path"])
+        for name in ("Hx", "Hz", "Gx", "Gz")
+    }
+    assert matrices["Hx"] == expected_hx
+    assert matrices["Hz"] == expected_hz
+    assert data["matrices"] == matrix_index["matrices"]
+    for name, matrix in matrices.items():
+        record = data["matrices"][name.lower()]
+        path = root / record["path"]
+        assert [len(matrix), len(matrix[0])] == record["shape"]
+        assert sha256(path) == record["file_sha256"]
+        assert content_sha256(matrix) == record["content_sha256"]
+    for name, expected in EXPECTED_PUBLIC_MATRICES.items():
+        assert {
+            "content_sha256": data["matrices"][name]["content_sha256"],
+            "file_sha256": data["matrices"][name]["file_sha256"],
+        } == expected
+
+    hx, hz, gx, gz = (
+        matrices["Hx"], matrices["Hz"], matrices["Gx"], matrices["Gz"]
+    )
+    rank_x, rank_z = gf2_rank(hx), gf2_rank(hz)
+    checks = data["matrix_checks"]
+    assert rank_x == checks["rank_x"] == 100
+    assert rank_z == checks["rank_z"] == 100
+    assert 210 - rank_x - rank_z == checks["k_recomputed"] == 10
+    assert all(parity(x_row, z_row) == 0 for x_row in hx for z_row in hz)
+    assert all(parity(x_row, logical) == 0 for x_row in hx for logical in gx)
+    assert all(parity(z_row, logical) == 0 for z_row in hz for logical in gz)
+    duality = [[parity(x_logical, z_logical) for z_logical in gx] for x_logical in gz]
+    assert duality == [
+        [int(row == column) for column in range(10)] for row in range(10)
+    ]
+    assert gf2_rank(hx + gz) == 110
+    assert gf2_rank(hz + gx) == 110
+    assert max(map(sum, hx + hz)) == checks["max_check_weight"] == 6
+    assert max(
+        max(sum(row[column] for row in hx) for column in range(210)),
+        max(sum(row[column] for row in hz) for column in range(210)),
+    ) == checks["max_sector_qubit_degree"] == 3
+    assert max(
+        sum(row[column] for row in hx + hz) for column in range(210)
+    ) == checks["max_qubit_degree"] == 6
+
+    lower = evidence["lower_bound_evidence"]
+    assert lower["outcome"] == "exact"
+    assert lower["exact_distance"] == lower["lower_bound"] == lower["upper_bound"] == 16
+    assert lower["threshold_infeasible"] is True
+    assert lower["decision_complete"] is True
+    assert lower["retryable"] is False
+    assert lower["returncode"] == 0 and lower["timed_out"] is False
+    assert lower["cardinality_mode"] == "mto"
+    assert lower["parsed_output"]["d"] == 16
+    assert lower["parsed_output"]["d_lb"] == 16
+    assert lower["parsed_output"]["d_ub"] == 16
+    assert lower["parsed_output"]["o"] == 16
+    assert lower["backend"]["binary_sha256"] == DISTQLDPC_BINARY_SHA256
+    assert lower["backend"]["source_commit"] == DISTQLDPC_SOURCE_COMMIT
+    assert lower["raw_terminal_replay_verified"] is True
+    assert lower["raw_terminal_evidence_sha256"] == RAW_LOWER_EVIDENCE_SHA256
+    assert lower["aggregate_resumed_evidence_sha256"] == (
+        RESUMED_LOWER_EVIDENCE_SHA256
+    )
+    assert lower["instance_binding_sha256"] == (
+        "3cb72f08d8d681df64c3cee531df620a251c7fb34872274868b348a247dfd992"
+    )
+    assert lower["runtime_source"] == {
+        "adapter": {
+            "module": "evaluation.distance_distqldpc",
+            "sha256": "9077ad558b4205a9ee84a1300ee7ee83a5a959fa55e1670441a1e7529eeda574",
+        },
+        "identity_sha256": "9059539f43f6134b26f6cda4e94bca45ec8b7f5d262f1082cee47bbe014293ce",
+        "protocol": "qcode-distqldpc-supervisor-v1",
+        "supervisor": {
+            "module": "evaluation.distqldpc_supervisor",
+            "sha256": "fd6ed1198831aa1208932daf974faa11348e98c9c98ec26c8c39bfbe8ae833b8",
+        },
+    }
+    assert lower["checkpoint_identity"]["cardinality_mode"] == "mto"
+    assert lower["checkpoint_identity"]["candidate_digest"] == CANONICAL_DIGEST
+    for name, matrix in matrices.items():
+        assert dist_array_sha256(name, matrix) == (
+            lower["solver_instance_array_sha256"][name]
+        )
+
+    upper = evidence["upper_bound_evidence"]
+    assert upper["outcome"] == "sat" and upper["sector"] == "X"
+    assert upper["objective"] == 16 and upper["decision_complete"] is True
+    assert upper["retryable"] is False
+    operator = unpack_operator(upper["operator"])
+    assert sum(operator) == 16
+    assert all(parity(check, operator) == 0 for check in hz)
+    syndrome = [parity(logical, operator) for logical in gx]
+    assert syndrome == upper["logical_syndrome"] and any(syndrome)
+    assert gf2_rank(hx + [operator]) == rank_x + 1
+    assert upper["anchor_indices"] == [0, 105]
+    assert any(operator[index] for index in upper["anchor_indices"])
+    assert upper["raw_terminal_evidence_sha256"] == RAW_UPPER_EVIDENCE_SHA256
+    assert upper["aggregate_resumed_evidence_sha256"] == (
+        RESUMED_UPPER_EVIDENCE_SHA256
+    )
+    assert upper["instance_binding_sha256"] == (
+        "ce40d444e02bfe900f38d29ebe4bc72d2ed0b7241039c21d3a016cbaa47caba7"
+    )
+    assert upper["operator"]["sha256"] == (
+        "ff3b54a8cfd0857a27a12dda5d602405175f8b01c21687b97475861ad7503a77"
+    )
+
+    n, k, distance = 210, 10, 16
+    assert data["parameters"] == {"n": n, "k": k}
+    assert data["distance"]["exact"] == distance
+    assert data["distance"]["lower_bound"] == distance
+    assert data["distance"]["upper_bound"] == distance
+    assert k * distance * distance == 2560 > 12 * n == 2520
+    assert data["fom"]["exact"]["numerator"] == 256
+    assert data["fom"]["exact"]["denominator"] == 21
+    assert abs(data["fom"]["exact"]["decimal"] - 256 / 21) < 1e-15
+    assert data["fom"]["strict_integer_margin"] == 40
+
+    handoff = evidence["stage3_typed_handoff"]
+    assert handoff["status"] == "EXACT_PROVEN"
+    assert handoff["backend"] == "distqldpc"
+    assert handoff["lower_bound_threshold"] == 15
+    assert handoff["completed_proof_units"] == 2
+    assert handoff["expected_proof_units"] == 27
+    assert handoff["distqldpc_exact_distances"] == [16]
+    assert handoff["distqldpc_conflict"] is False
+    assert handoff["low_witnesses"] == []
+    assert handoff["qcode_commit"] == QCODE_COMMIT
+    assert handoff["typed_replay_verified"] is True
+    assert handoff["attempted_proof_units"] == 23
+    assert handoff["completed_proof_units"] == 2
+    assert handoff["expected_proof_units"] == 27
+    assert handoff["source_retryable_units_at_terminal"] == 21
+    assert handoff["summary_retry_required"] is False
+    assert handoff["terminal_reason"] == "distqldpc_exact_plus_upper_witness"
+    assert handoff["distqldpc_conflict_details"] is None
+    for key, expected in source.items():
+        assert handoff[key] == expected
+    assert evidence["symmetry"]["translation_verified"] is True
+    assert evidence["symmetry"]["orbit_representatives"] == [0, 105]
+    assert evidence["symmetry"]["xz_sector_isometry_verified"] is True
+    assert evidence["symmetry"]["xz_sector_isometry_sha256"] == (
+        "6662b328e912918c26a36bb68d3279302329b9dd063952cc8ad8367f3358a4c5"
+    )
+    assert evidence["symmetry"]["covered_sectors"] == ["X", "Z"]
+
+    verify_no_operational_leak(data)
+    verify_no_operational_leak(evidence)
+    verify_no_operational_leak(matrix_index)
+    print(
+        "PASS: Stage 3 typed [[210,10,16]], FOM=256/21; matrices, logical "
+        "basis, hashes, and upper witness verified. Lower bound remains tied "
+        "to the pinned DistQLDPC/MaxCDCL trust model."
+    )
+
+
+if __name__ == "__main__":
+    verify(Path(sys.argv[1]) if len(sys.argv) > 1 else Path("."))