Add certified exact [[254,14,16]] Stage 5 evidence

STAGE5_CERTIFIED_EXACT_FOM_GE_13.md

@@ -0,0 +1,30 @@
+# Certified `[[254,14,16]]` quantum code
+
+This dataset now includes a standalone certified Stage 5 lane for one
+twisted-torus CSS-BB quantum code:
+
+```text
+[[254,14,16]]
+FOM = 14 * 16^2 / 254 = 1792/127 ~= 14.11023622047244
+```
+
+The Stage 4 certificate, independent certificate-bound DistQLDPC replay,
+Stage 5 final gate, known-answer gate, admissibility checks, and novelty replay
+all passed. The public candidate ID is `503600e431e223bb2efe`.
+
+Start with [`docs/STAGE5_CERTIFIED_EXACT_FOM_GE_13.md`](docs/STAGE5_CERTIFIED_EXACT_FOM_GE_13.md).
+The machine-readable row is in
+[`data/stage5_certified_exact_fom_ge_13.jsonl`](data/stage5_certified_exact_fom_ge_13.jsonl).
+
+After materializing Git LFS objects, verify the complete dataset plus this
+new certified lane with:
+
+```bash
+git lfs pull --include='matrices/**'
+sha256sum -c manifests/STAGE5_SHA256SUMS
+python -B scripts/verify_dataset_stage5.py .
+```
+
+The public verifier is solver-free. It checks the portable matrix algebra and
+upper witness and validates the sanitized cryptographic bindings to both exact
+DistQLDPC runs. No portable DRAT/LRAT lower-bound proof is claimed.

data/stage5_certified_exact_fom_ge_13.jsonl

@@ -0,0 +1 @@
+{"admissibility":{"binding_sha256":"c8b9f4d817ab9e88ec2f396f03a2b0bc163d0761656f7374c7f5880e3402bdb5","matrix_authority":"fresh-rebuild-from-construction","matrix_scope":["H_X","H_Z"],"maximum":6,"mode":"css-stabilizer-check-row-weight-at-most-6-v1","row_reduction_allowed":false,"schema_version":1},"authority":{"exact_under_pinned_solver_trust_model":true,"generic_pipeline_registration":false,"independent_release_gate_complete":true,"pipeline_promotion":false,"pipeline_stage4_certificate":true,"pipeline_stage5_final_gate":true,"portable_unsat_proof_certificate":false,"public_dataset_record":true,"publication_certificate":true,"stage3_typed_handoff_replay":true,"standalone_typed_release":true},"candidate_id":"503600e431e223bb2efe","canonical_digest":"1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6","code":"[[254,14,16]]","construction":{"A_terms":[[0,0],[0,22],[0,96]],"B_terms":[[0,1],[0,14],[0,121]],"ell":1,"family":"css-bb","geometry":{"family":"twisted_torus","schema_version":1,"twist":25},"m":127,"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":"CERTIFIED_EXACT_WIN","fom":{"exact":{"decimal":14.11023622047244,"denominator":127,"numerator":1792},"excess_over_12":{"decimal":2.110236220472441,"denominator":127,"numerator":268},"excess_over_13":{"decimal":1.110236220472441,"denominator":127,"numerator":141},"strict_integer_margin":536},"known_answer_context":{"artifact_sha256":"7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687","integrity_physical_file_sha256":"944ced82bf1f7de269752c316c32541478bb7e8fa4462b44daf2b20b8037b629","passed":true,"release_replayed":true,"semantic_replay_sha256":"a0c103db0a9eb0113a5e2e8fdc9a11e0dd193d14080237c6e3d27cdcf6476502","trust_sha256":"1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140"},"matrices":{"gx":{"array_sha256":"d2b4720434b9b047343545328d823ed22e3c0df7a8d953ae8b6b328c9a26d1a3","bytes":2057,"content_sha256":"89ad8dd9a8af7dc1dfbfa40708aba1d792d2ec75c549b96133159bbad06bf649","file_sha256":"faa9dfd321e1663bcb5538e79878829293605aace895fa58d1ddfba24eedbf53","nnz":912,"path":"matrices/503600e431e223bb2efe/Gx.mtx.gz","shape":[14,254]},"gz":{"array_sha256":"07143f00071d48b2e8c0681b516db3d76bfeb9f0223c54a5d3732199a18b3870","bytes":1972,"content_sha256":"b02f1ba21af93d3c7b2c93397c834a74431f49786873c15e79662ef57ab50534","file_sha256":"16405b89007fcccef60268d473a7fa3dd73a0ff9079b0dd8bf704822ba9c7557","nnz":846,"path":"matrices/503600e431e223bb2efe/Gz.mtx.gz","shape":[14,254]},"hx":{"array_sha256":"5d7d4d7ded8703a43deda393a870136305628b8b8d7714de58f050ccee3f6b1c","bytes":2226,"content_sha256":"0d3ee06bc862d2ab61e893aaaeef3fde5b4bfc643251aaf806a1a32a7093eba8","file_sha256":"9563d6958e7ffc13c1f616192cce41cf148d97db73b41e2eaa6af1c203bfe64a","nnz":762,"path":"matrices/503600e431e223bb2efe/Hx.mtx.gz","shape":[127,254]},"hz":{"array_sha256":"a80232c74b59c4b5ee20163f9badca65c1a1a84bdfb12b8aab3a04c622e93613","bytes":2175,"content_sha256":"eddac2800fc08955c7805b0880438f1c0e047c79fc2f1365b89f8b34ff3d4883","file_sha256":"90471fbfcf70f0147dc799df79f7e34d0552cdb3b28fef4bf8290372bfb25ef3","nnz":762,"path":"matrices/503600e431e223bb2efe/Hz.mtx.gz","shape":[127,254]}},"matrix_checks":{"commutation_violations":0,"css_commutation":true,"k_recomputed":14,"logical_basis_complete":true,"logical_duality":true,"max_check_weight":6,"max_qubit_degree":6,"max_sector_qubit_degree":3,"rank_x":120,"rank_z":120,"tanner_components":1},"novelty":{"canonical_digest":"1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6","checked":true,"matched_entries":[],"novel":true,"registry_internal_sha256":"536c733d68d344ed9fef9992bbeb1000900174ad0c500ddb7004126ae5c98408","status":"COMPLETE"},"parameters":{"k":14,"n":254},"record_kind":"stage5_certified_exact_fom_ge_13","record_sha256":"7ff6cf746934b791a09ad527687fc18643a234cfaa8e56bc28e606bbdb8b42b6","release_status":"CERTIFIED_STAGE5_TYPED_DISTQLDPC","schema_version":1,"source":{"loaded_source_fingerprint_sha256":"a817f77ddd961e895e8694112dd399daed6dd12cf4aff572d1f5e1d7f06e10c8","qcode_commit":"be725d40c96b49fbd7baa62257fcc2556f3bcd2a","release_manifest_physical_file_sha256":"cd12992dfe5ece37987ec8b343603db9f69330796b55d8494dbad5b758f2f589","release_manifest_semantic_sha256":"5f81c636c6e84b79054691b7d0412c9ec08368c7c694ae62cb94b236440931d5","stage3_handoff_artifact_sha256":"3a3fdbd8bf576cc728868db56621333a799b3e676a9bd148f7c14dcc9295d505","stage3_handoff_claim_sha256":"8c0150034c88e627ef02803afd1f301bbd385e1df4868f8eb9fb19134d6c6dbd","stage3_internal_artifact_sha256":"0367e0d6a138937b32bfd16954f041092944abaefa812177c017b75cc5600a0a","stage3_physical_file_sha256":"dbc31816793c86a2dfd06e380461f06bc5481e817495e589c054789e71934b60","stage4_certificate_payload_sha256":"543ebf6dda568e407ba560879fe5a316fc57badf1b641e8f9d5b380abcf6033e","stage4_certificate_physical_file_sha256":"e7e262988f1ee1dd5f40627a5b5ec908d68f655806b40c8ff9f21c4c60767c3f","stage4_certificate_semantic_sha256":"e77fbf5bc32f174386f349fdf9e29a72910db50a2c71937168cec2adfc83c7f3","stage5_fresh_solver_evidence_sha256":"59c3dd3bdf849b1336f43f407ec8814d7597c5db1d2a7e720d4fc55c58b84d04","stage5_verification_payload_sha256":"9d0a0bd40b13b6fc99d5347fd48a6b18686c0ecb62c692872a30573c18ab2d06","stage5_verification_physical_file_sha256":"26b2daa907580a0d09412c4480f2b7c2a5ae6d99ad43702abf24df968af52c5d"},"source_stage":"stage5_typed_distqldpc_release","source_status":"EXACT_PROVEN","source_target":{"binding_sha256":"5bdc62da94468e4a14dd2f73ac0654e28af7dcffea3b0e23d5d85ad8dff1f066","left_hand_side":3584,"mode":"scalar-fom-13-inclusive-v1","passed":true,"required_distance":16,"right_hand_side":3302,"strict":false},"target":{"certified_win":true,"left_hand_side":3584,"mode":"strict-fom-gt-12-v1","passes_strict_target":true,"required_distance":15,"right_hand_side":3048,"strict_integer_margin":536,"strict_predicate":"k*d*d > 12*n"}}

docs/STAGE5_CERTIFIED_EXACT_FOM_GE_13.md

@@ -0,0 +1,80 @@
+# Stage 5 certified exact FOM>=13 result
+
+## Result
+
+The `stage5_certified_exact_fom_ge_13` lane publishes one twisted-torus
+CSS-BB quantum code:
+
+```text
+[[n,k,d]] = [[254,14,16]]
+FOM = k d^2 / n = 1792/127 ~= 14.11023622047244
+dataset gate: 14 * 16^2 = 3584 > 12 * 254 = 3048
+source gate:  14 * 16^2 = 3584 >= 13 * 254 = 3302
+```
+
+The public candidate ID is `503600e431e223bb2efe`, derived from the
+construction key. Its independently canonicalized Stage 3 digest is
+`1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6`.
+
+The construction uses `ell=1`, `m=127`, twisted-torus parameter `twist=25`,
+
+```text
+A = 1 + y^22 + y^96
+B = y + y^14 + y^121.
+```
+
+The public bundle contains `Hx`, `Hz`, and the exact `Gx`, `Gz` logical
+basis used by the DistQLDPC instance. The solver-free verifier reconstructs
+the checks from the construction and verifies ranks `120/120`, `k=14`, CSS
+commutation, logical-basis completeness and duality, Tanner connectivity,
+row weight at most 6, sector degree 3, combined degree 6, and the weight-16
+X-logical upper witness.
+
+## Certification chain
+
+The lower and upper bounds meet at 16:
+
+- a pinned DistQLDPC/MaxCDCL `mto` run completed with
+  `d_lb=d_ub=d=o=16`;
+- Stage 3 produced and replayed an `EXACT_PROVEN` typed handoff;
+- Stage 4 built a source-bound typed DistQLDPC certificate;
+- Stage 5 independently reran DistQLDPC under a new certificate-bound
+  checkpoint identity and again obtained exact distance 16;
+- the known-answer, structural, novelty, target, and final publication gates
+  all passed.
+
+The public evidence file is a sanitized allowlist of scientific hashes and
+outcomes. It deliberately excludes local paths, commands, process IDs,
+prompts, raw logs, progress files, and runtime filesystem metadata.
+
+## Trust boundary
+
+The matrices and the weight-16 upper witness are portable and independently
+checked by the included standard-library verifier. The lower bound is exact
+under the pinned DistQLDPC/MaxCDCL binary and runtime and was independently
+rerun. DistQLDPC did not produce a portable DRAT/LRAT proof object, so the
+dataset does not claim one.
+
+This is a standalone typed release. The Stage 4 and Stage 5 checks passed,
+but the specialized proof type is not registered in the generic pipeline
+dispatcher; therefore `generic_pipeline_registration` and
+`pipeline_promotion` remain false while `publication_certificate` is true.
+
+## Files and verification
+
+- `data/stage5_certified_exact_fom_ge_13.jsonl`
+- `evidence/stage5_certified_exact_proofs.jsonl`
+- `evidence/stage5_certified_exact_matrix_index.jsonl`
+- `matrices/503600e431e223bb2efe/{Hx,Hz,Gx,Gz}.mtx.gz`
+- `manifests/stage5_certified_exact_fom_ge_13.json`
+
+After materializing Git LFS objects, run:
+
+```bash
+git lfs pull --include='matrices/**'
+python -B scripts/verify_stage5_certified_exact_fom_ge_13.py .
+```
+
+The verifier invokes no distance solver. It validates the released algebra,
+witness, self-hashes, physical file hashes, and the two independent exact-run
+bindings recorded by the certified chain.

evidence/stage5_certified_exact_matrix_index.jsonl

@@ -0,0 +1 @@
+{"candidate_id":"503600e431e223bb2efe","canonical_digest":"1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6","k":14,"matrices":{"gx":{"array_sha256":"d2b4720434b9b047343545328d823ed22e3c0df7a8d953ae8b6b328c9a26d1a3","bytes":2057,"content_sha256":"89ad8dd9a8af7dc1dfbfa40708aba1d792d2ec75c549b96133159bbad06bf649","file_sha256":"faa9dfd321e1663bcb5538e79878829293605aace895fa58d1ddfba24eedbf53","nnz":912,"path":"matrices/503600e431e223bb2efe/Gx.mtx.gz","shape":[14,254]},"gz":{"array_sha256":"07143f00071d48b2e8c0681b516db3d76bfeb9f0223c54a5d3732199a18b3870","bytes":1972,"content_sha256":"b02f1ba21af93d3c7b2c93397c834a74431f49786873c15e79662ef57ab50534","file_sha256":"16405b89007fcccef60268d473a7fa3dd73a0ff9079b0dd8bf704822ba9c7557","nnz":846,"path":"matrices/503600e431e223bb2efe/Gz.mtx.gz","shape":[14,254]},"hx":{"array_sha256":"5d7d4d7ded8703a43deda393a870136305628b8b8d7714de58f050ccee3f6b1c","bytes":2226,"content_sha256":"0d3ee06bc862d2ab61e893aaaeef3fde5b4bfc643251aaf806a1a32a7093eba8","file_sha256":"9563d6958e7ffc13c1f616192cce41cf148d97db73b41e2eaa6af1c203bfe64a","nnz":762,"path":"matrices/503600e431e223bb2efe/Hx.mtx.gz","shape":[127,254]},"hz":{"array_sha256":"a80232c74b59c4b5ee20163f9badca65c1a1a84bdfb12b8aab3a04c622e93613","bytes":2175,"content_sha256":"eddac2800fc08955c7805b0880438f1c0e047c79fc2f1365b89f8b34ff3d4883","file_sha256":"90471fbfcf70f0147dc799df79f7e34d0552cdb3b28fef4bf8290372bfb25ef3","nnz":762,"path":"matrices/503600e431e223bb2efe/Hz.mtx.gz","shape":[127,254]}},"n":254,"record_kind":"stage5_certified_exact_matrix_index","record_sha256":"e2ed09a7d99846561de4a35b6041347e59104e09f21ccc5ece887183914c7313","schema_version":1}

evidence/stage5_certified_exact_proofs.jsonl

@@ -0,0 +1 @@
+{"admissibility":{"matrix_sha256":{"H_X":"30dc7d62ec17810d85cd4aefef3a18d3034a5e07e8e293c8b8bba8f1c96d201a","H_Z":"c17ff5e7e5e4235dea79a042332e55a0cff5667459fcf927bff87d423a45fa2f"},"max_check_row_weight":6,"passed":true,"policy_binding_sha256":"c8b9f4d817ab9e88ec2f396f03a2b0bc163d0761656f7374c7f5880e3402bdb5","report_sha256":"ab68dceda43b5282d8b74fa4aaa7706a8b422070071bc8c9b54580f80a271c79"},"authority":{"exact_under_pinned_solver_trust_model":true,"generic_pipeline_registration":false,"independent_release_gate_complete":true,"pipeline_promotion":false,"pipeline_stage4_certificate":true,"pipeline_stage5_final_gate":true,"portable_unsat_proof_certificate":false,"public_dataset_record":true,"publication_certificate":true,"stage3_typed_handoff_replay":true,"standalone_typed_release":true},"candidate_id":"503600e431e223bb2efe","canonical_digest":"1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6","distance_claim":{"exact":16,"lower_bound":16,"status":"EXACT_PROVEN","upper_bound":16},"evidence_class":"CERTIFIED_EXACT_WIN","evidence_sha256":"52a7f4a62c28375645712db1c6a227c22544a25d01b6de90e9f5800ceae06716","known_answer":{"artifact_sha256":"7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687","integrity_physical_file_sha256":"944ced82bf1f7de269752c316c32541478bb7e8fa4462b44daf2b20b8037b629","passed":true,"release_replayed":true,"semantic_replay_sha256":"a0c103db0a9eb0113a5e2e8fdc9a11e0dd193d14080237c6e3d27cdcf6476502","trust_sha256":"1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140"},"limitations":{"lower_bound_trust_model":"pinned-distqldpc-maxcdcl-runtime","portable_unsat_certificate":false,"solver_invoked_by_public_verifier":false},"lower_bound_evidence":{"backend":{"algorithm":"MaxCDCL","binary_sha256":"9e09c544d5151d872dc1037dcb1440509e27b8b485a7f9ea5a15d6e55b36d3fa","distribution":"DistQLDPC","interface":"distqldpc-cli","source_commit":"c01fa93eb5e1e62948e4861e2c164a6b64fe88eb"},"cardinality_mode":"mto","decision_complete":true,"distqldpc_decisions_total":1,"distqldpc_decisions_verified":1,"exact_distance":16,"logical_detector_sha256":"5771b8c9daaf5fe00acae6f00482c9f802bb020bf5ae70ebfd1234c1dccecd37","logical_partitions_total":1,"logical_partitions_verified":1,"lower_bound":16,"outcome":"exact","portable_unsat_proof_certificate":false,"retryable":false,"solver_instance_array_sha256":{"Gx":"d2b4720434b9b047343545328d823ed22e3c0df7a8d953ae8b6b328c9a26d1a3","Gz":"07143f00071d48b2e8c0681b516db3d76bfeb9f0223c54a5d3732199a18b3870","Hx":"5d7d4d7ded8703a43deda393a870136305628b8b8d7714de58f050ccee3f6b1c","Hz":"a80232c74b59c4b5ee20163f9badca65c1a1a84bdfb12b8aab3a04c622e93613"},"stage3_exact":{"checkpoint_identity_sha256":"a0436039ddc6e08ffd7e6da3e923404c4c4802aa9055c19c807205fcb2800932","decision_complete":true,"elapsed_s":21513.579824514687,"evidence_sha256":"c41dbaf43b49955a7cf77851fcc00388eaa41daf5620b7012af980c4f49f8fe5","exact_distance":16,"instance_binding_sha256":"7c6fbd48ca92b696590cea37e5fbfcbdf8bebc85e436e59ccc6e074129bbeafe","lower_bound":16,"outcome":"exact","stdout_sha256":"e64418fb577e5021b7ec7693f195ed93d6732572a22a1751514d4aa46fa85227","terminal_file_sha256":"d336055574bec4076e3abd6c37cd3b839c000f89a241631f47c8cf0fd9bc5022","threshold_infeasible":true,"upper_bound":16},"stage5_independent_rerun":{"checkpoint_identity_sha256":"3a22d9205a4280161ea68b6ecf03c065bfaa1b042401476d04a67e17bfe13013","decision_complete":true,"elapsed_s":19798.601512420923,"evidence_sha256":"59c3dd3bdf849b1336f43f407ec8814d7597c5db1d2a7e720d4fc55c58b84d04","exact_distance":16,"instance_binding_sha256":"696c0a34a10d6bf207a94e86be56049a5f7f26ca10f8e7c9361ebc14abca9254","lower_bound":16,"outcome":"exact","stdout_sha256":"e64418fb577e5021b7ec7693f195ed93d6732572a22a1751514d4aa46fa85227","upper_bound":16,"verification_physical_file_sha256":"26b2daa907580a0d09412c4480f2b7c2a5ae6d99ad43702abf24df968af52c5d","verified":true},"threshold_infeasible":true,"upper_bound":16},"novelty":{"canonical_digest":"1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6","checked":true,"matched_entries":[],"novel":true,"registry_internal_sha256":"536c733d68d344ed9fef9992bbeb1000900174ad0c500ddb7004126ae5c98408","status":"COMPLETE"},"record_kind":"stage5_certified_exact_fom_ge_13_evidence","release_status":"CERTIFIED_STAGE5_TYPED_DISTQLDPC","schema_version":1,"source_status":"EXACT_PROVEN","stage3_typed_handoff":{"backend":"distqldpc","completed_lower_decisions":1,"completed_lower_partitions":1,"distqldpc_exact_distances":[16],"expected_lower_decisions":1,"expected_lower_partitions":1,"handoff_artifact_sha256":"3a3fdbd8bf576cc728868db56621333a799b3e676a9bd148f7c14dcc9295d505","handoff_claim_sha256":"8c0150034c88e627ef02803afd1f301bbd385e1df4868f8eb9fb19134d6c6dbd","internal_artifact_sha256":"0367e0d6a138937b32bfd16954f041092944abaefa812177c017b75cc5600a0a","lower_bound_threshold":15,"physical_file_sha256":"dbc31816793c86a2dfd06e380461f06bc5481e817495e589c054789e71934b60","qcode_commit":"be725d40c96b49fbd7baa62257fcc2556f3bcd2a","required_distance":16,"status":"EXACT_PROVEN","typed_replay_verified":true},"stage4_certificate":{"certificate_payload_sha256":"543ebf6dda568e407ba560879fe5a316fc57badf1b641e8f9d5b380abcf6033e","certificate_physical_file_sha256":"e7e262988f1ee1dd5f40627a5b5ec908d68f655806b40c8ff9f21c4c60767c3f","certificate_semantic_sha256":"e77fbf5bc32f174386f349fdf9e29a72910db50a2c71937168cec2adfc83c7f3","certificate_type":"qldpc-css-bb-sector-distqldpc-exact","exact_distance":16,"passed":true,"source_stage3_artifact_sha256":"3a3fdbd8bf576cc728868db56621333a799b3e676a9bd148f7c14dcc9295d505","source_stage3_checkpoint_identity_sha256":"a0436039ddc6e08ffd7e6da3e923404c4c4802aa9055c19c807205fcb2800932","target_binding_sha256":"5bdc62da94468e4a14dd2f73ac0654e28af7dcffea3b0e23d5d85ad8dff1f066"},"stage5_verification":{"distqldpc_decisions_total":1,"distqldpc_decisions_verified":1,"final_gate_accepted":true,"fom_target":true,"fresh_solver_evidence_sha256":"59c3dd3bdf849b1336f43f407ec8814d7597c5db1d2a7e720d4fc55c58b84d04","generic_pipeline_registration":false,"loaded_source_fingerprint_sha256":"a817f77ddd961e895e8694112dd399daed6dd12cf4aff572d1f5e1d7f06e10c8","logical_partitions_total":1,"logical_partitions_verified":1,"novelty":true,"passed":true,"release_manifest_physical_file_sha256":"cd12992dfe5ece37987ec8b343603db9f69330796b55d8494dbad5b758f2f589","release_manifest_semantic_sha256":"5f81c636c6e84b79054691b7d0412c9ec08368c7c694ae62cb94b236440931d5","replay_complete":true,"standalone_typed_release":true,"typed_lower":true,"upper":true,"verification_payload_sha256":"9d0a0bd40b13b6fc99d5347fd48a6b18686c0ecb62c692872a30573c18ab2d06","verification_physical_file_sha256":"26b2daa907580a0d09412c4480f2b7c2a5ae6d99ad43702abf24df968af52c5d"},"symmetry":{"covered_sectors":["X","Z"],"orbit_representatives":[0,127],"orbit_sizes":[127,127],"translation_symmetry_sha256":"a306a31866a4607586679680f14249f2a4eb6fc1a715a9e65a91c711c8758466","translation_verified":true,"weight_preserving":true,"xz_sector_isometry_sha256":"40b86f90a7dcb9509e8314a587284142c87989e282dc1ce2402c8a77705199b7","xz_sector_isometry_verified":true},"upper_bound_evidence":{"anchor_indices":[0,127],"backend":{"distribution":"python-sat","solver":"cadical195","version":"1.9.dev7"},"cnf":{"cardinality_encoding":"kmtotalizer","cnf_sha256":"0134860ae58624e9a1e4490388cb3d74c41cdc0bbe5a125f83aca8014a5abdaa"},"decision_complete":true,"evidence_sha256":"6630a19b00daacf9a5e96a93eedea288a26d8ca964f2cd73005ebd57a74cd178","formulation":"css-global-logical-threshold-cnf-v1","instance_binding_sha256":"8b89c49257fceb13404e2de33abd651d58f27057f271d56f282e7723c88fc31d","logical_syndrome":[1,1,1,1,1,0,0,1,1,0,0,0,0,1],"objective":16,"operator":{"length":254,"packed_hex":"0100000000000000000000040240140800200000002000000410000006088400","sha256":"f3c15e976dbc838d3aeb351747544e6f6c3a9d1e18a24fedd8833a99ba4838b8","weight":16},"outcome":"sat","retryable":false,"sector":"X"}}

manifests/STAGE5_SHA256SUMS

@@ -0,0 +1,13 @@
+9438276a3d6d3d69c43e20605c064fb13463abf99e3d9e463e02442faba073de  STAGE5_CERTIFIED_EXACT_FOM_GE_13.md
+7aa8ec61be1f38190dc811c01a2f15620f76f9f0378e5d1731213dddba897515  data/stage5_certified_exact_fom_ge_13.jsonl
+9b1cde0c665552e8656fae681e23ee9727410be1296dfbda2647d2957fd135f2  docs/STAGE5_CERTIFIED_EXACT_FOM_GE_13.md
+1a61d51a774694c7c93f8524226b30b1258dc63c64c6489f6d0e777cf184f20a  evidence/stage5_certified_exact_matrix_index.jsonl
+33823e8112bc52b86713119d4b20feccd176fd952ec318d7957f83e747845422  evidence/stage5_certified_exact_proofs.jsonl
+bd80fd90333a23d6630de3ccaccede2c9d211dced99ac6ad8668609e72d24b5a  manifests/stage5_certified_exact_fom_ge_13.json
+faa9dfd321e1663bcb5538e79878829293605aace895fa58d1ddfba24eedbf53  matrices/503600e431e223bb2efe/Gx.mtx.gz
+16405b89007fcccef60268d473a7fa3dd73a0ff9079b0dd8bf704822ba9c7557  matrices/503600e431e223bb2efe/Gz.mtx.gz
+9563d6958e7ffc13c1f616192cce41cf148d97db73b41e2eaa6af1c203bfe64a  matrices/503600e431e223bb2efe/Hx.mtx.gz
+90471fbfcf70f0147dc799df79f7e34d0552cdb3b28fef4bf8290372bfb25ef3  matrices/503600e431e223bb2efe/Hz.mtx.gz
+0b7c7401c341cc2b8a6c90ddbeb3d7e7c46ab329b8eb396f9634b7f70cd0cc0b  scripts/build_stage5_certified_exact_fom_ge_13.py
+b2c1c72407c74867823e5f96c684fa87e279cfe0b81d41d842a61fe3336e1473  scripts/verify_dataset_stage5.py
+2cf2785f85790bd919317eeacdfe0bc6a32bd28c9ae2c6093a25503dcf228efc  scripts/verify_stage5_certified_exact_fom_ge_13.py

manifests/stage5_certified_exact_fom_ge_13.json

@@ -0,0 +1,92 @@
+{
+  "authority": {
+    "exact_under_pinned_solver_trust_model": true,
+    "generic_pipeline_registration": false,
+    "independent_release_gate_complete": true,
+    "pipeline_promotion": false,
+    "pipeline_stage4_certificate": true,
+    "pipeline_stage5_final_gate": true,
+    "portable_unsat_proof_certificate": false,
+    "public_dataset_record": true,
+    "publication_certificate": true,
+    "stage3_typed_handoff_replay": true,
+    "standalone_typed_release": true
+  },
+  "candidate": {
+    "candidate_id": "503600e431e223bb2efe",
+    "canonical_digest": "1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6",
+    "code": "[[254,14,16]]",
+    "exact_fom_denominator": 127,
+    "exact_fom_numerator": 1792
+  },
+  "certified_win": true,
+  "dataset_base_commit": "f7129caeab7fe78943e504dfc48e268e23ee13fe",
+  "files": [
+    {
+      "bytes": 6073,
+      "path": "data/stage5_certified_exact_fom_ge_13.jsonl",
+      "rows": 1,
+      "sha256": "7aa8ec61be1f38190dc811c01a2f15620f76f9f0378e5d1731213dddba897515"
+    },
+    {
+      "bytes": 7968,
+      "path": "evidence/stage5_certified_exact_proofs.jsonl",
+      "rows": 1,
+      "sha256": "33823e8112bc52b86713119d4b20feccd176fd952ec318d7957f83e747845422"
+    },
+    {
+      "bytes": 1682,
+      "path": "evidence/stage5_certified_exact_matrix_index.jsonl",
+      "rows": 1,
+      "sha256": "1a61d51a774694c7c93f8524226b30b1258dc63c64c6489f6d0e777cf184f20a"
+    },
+    {
+      "bytes": 35746,
+      "path": "scripts/verify_stage5_certified_exact_fom_ge_13.py",
+      "sha256": "2cf2785f85790bd919317eeacdfe0bc6a32bd28c9ae2c6093a25503dcf228efc"
+    },
+    {
+      "bytes": 2226,
+      "path": "matrices/503600e431e223bb2efe/Hx.mtx.gz",
+      "sha256": "9563d6958e7ffc13c1f616192cce41cf148d97db73b41e2eaa6af1c203bfe64a"
+    },
+    {
+      "bytes": 2175,
+      "path": "matrices/503600e431e223bb2efe/Hz.mtx.gz",
+      "sha256": "90471fbfcf70f0147dc799df79f7e34d0552cdb3b28fef4bf8290372bfb25ef3"
+    },
+    {
+      "bytes": 2057,
+      "path": "matrices/503600e431e223bb2efe/Gx.mtx.gz",
+      "sha256": "faa9dfd321e1663bcb5538e79878829293605aace895fa58d1ddfba24eedbf53"
+    },
+    {
+      "bytes": 1972,
+      "path": "matrices/503600e431e223bb2efe/Gz.mtx.gz",
+      "sha256": "16405b89007fcccef60268d473a7fa3dd73a0ff9079b0dd8bf704822ba9c7557"
+    }
+  ],
+  "gate": "qcode-public-stage5-certified-exact-fom-ge-13-v1",
+  "manifest_sha256": "4b7afc66d251e9c89b9aba2f0550073644f20fc938bcb1e23ed7b5aee339f545",
+  "publication_certificate": true,
+  "release_status": "CERTIFIED_STAGE5_TYPED_DISTQLDPC",
+  "schema_version": 1,
+  "source": {
+    "loaded_source_fingerprint_sha256": "a817f77ddd961e895e8694112dd399daed6dd12cf4aff572d1f5e1d7f06e10c8",
+    "qcode_commit": "be725d40c96b49fbd7baa62257fcc2556f3bcd2a",
+    "release_manifest_physical_file_sha256": "cd12992dfe5ece37987ec8b343603db9f69330796b55d8494dbad5b758f2f589",
+    "release_manifest_semantic_sha256": "5f81c636c6e84b79054691b7d0412c9ec08368c7c694ae62cb94b236440931d5",
+    "stage3_handoff_artifact_sha256": "3a3fdbd8bf576cc728868db56621333a799b3e676a9bd148f7c14dcc9295d505",
+    "stage3_handoff_claim_sha256": "8c0150034c88e627ef02803afd1f301bbd385e1df4868f8eb9fb19134d6c6dbd",
+    "stage3_internal_artifact_sha256": "0367e0d6a138937b32bfd16954f041092944abaefa812177c017b75cc5600a0a",
+    "stage3_physical_file_sha256": "dbc31816793c86a2dfd06e380461f06bc5481e817495e589c054789e71934b60",
+    "stage4_certificate_payload_sha256": "543ebf6dda568e407ba560879fe5a316fc57badf1b641e8f9d5b380abcf6033e",
+    "stage4_certificate_physical_file_sha256": "e7e262988f1ee1dd5f40627a5b5ec908d68f655806b40c8ff9f21c4c60767c3f",
+    "stage4_certificate_semantic_sha256": "e77fbf5bc32f174386f349fdf9e29a72910db50a2c71937168cec2adfc83c7f3",
+    "stage5_fresh_solver_evidence_sha256": "59c3dd3bdf849b1336f43f407ec8814d7597c5db1d2a7e720d4fc55c58b84d04",
+    "stage5_verification_payload_sha256": "9d0a0bd40b13b6fc99d5347fd48a6b18686c0ecb62c692872a30573c18ab2d06",
+    "stage5_verification_physical_file_sha256": "26b2daa907580a0d09412c4480f2b7c2a5ae6d99ad43702abf24df968af52c5d"
+  },
+  "source_status": "EXACT_PROVEN",
+  "status": "CERTIFIED_EXACT_WIN"
+}

matrices/503600e431e223bb2efe/Gx.mtx.gz

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

matrices/503600e431e223bb2efe/Gz.mtx.gz

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

matrices/503600e431e223bb2efe/Hx.mtx.gz

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

matrices/503600e431e223bb2efe/Hz.mtx.gz

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

scripts/build_stage5_certified_exact_fom_ge_13.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Rebuild the public matrix bundle for the certified [[254,14,16]] code."""
+
+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 = "503600e431e223bb2efe"
+CANONICAL_DIGEST = "1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6"
+QCODE_COMMIT = "be725d40c96b49fbd7baa62257fcc2556f3bcd2a"
+EXPECTED_ARRAY_SHA256 = {
+    "Hx": "5d7d4d7ded8703a43deda393a870136305628b8b8d7714de58f050ccee3f6b1c",
+    "Hz": "a80232c74b59c4b5ee20163f9badca65c1a1a84bdfb12b8aab3a04c622e93613",
+    "Gx": "d2b4720434b9b047343545328d823ed22e3c0df7a8d953ae8b6b328c9a26d1a3",
+    "Gz": "07143f00071d48b2e8c0681b516db3d76bfeb9f0223c54a5d3732199a18b3870",
+}
+EXPECTED_SHAPES = {
+    "Hx": [127, 254], "Hz": [127, 254], "Gx": [14, 254], "Gz": [14, 254]
+}
+CLAIM = {
+    "ell": 1,
+    "m": 127,
+    "A_terms": [[0, 0], [0, 22], [0, 96]],
+    "B_terms": [[0, 1], [0, 14], [0, 121]],
+    "geometry": {"family": "twisted_torus", "schema_version": 1, "twist": 25},
+}
+
+
+def sha256_bytes(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def 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 content_sha256(matrix: Any) -> str:
+    header = json.dumps(
+        {"dtype": "uint8-gf2", "shape": list(matrix.shape)},
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+    return sha256_bytes(header.encode() + b"\n" + matrix.tobytes(order="C"))
+
+
+def matrix_market_gzip(name: str, matrix: Any) -> bytes:
+    rows, columns = map(int, matrix.shape)
+    entries = [
+        f"{row + 1} {column + 1} 1\n"
+        for row in range(rows)
+        for column in range(columns)
+        if int(matrix[row, column]) & 1
+    ]
+    body = (
+        "%%MatrixMarket matrix coordinate integer general\n"
+        f"% qcode candidate {CANDIDATE_ID} {name}; entries are GF(2)\n"
+        f"{rows} {columns} {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 source_commit(repo: Path) -> str:
+    process = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=repo, check=True,
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
+    )
+    return process.stdout.strip()
+
+
+def build(qcode_repo: Path) -> dict[str, Any]:
+    qcode_repo = qcode_repo.resolve(strict=True)
+    if source_commit(qcode_repo) != QCODE_COMMIT:
+        raise ValueError("qcode repository is not pinned to the release commit")
+    sys.path.insert(0, str(qcode_repo))
+    from evaluation.distance_distqldpc import distqldpc_matrix_bundle
+    from evaluation.sector_certificate import _matrices
+
+    _, hx, hz, lx, lz = _matrices(CLAIM)
+    matrices = distqldpc_matrix_bundle(hx, hz, lx, lz)
+    for name, matrix in matrices.items():
+        if list(matrix.shape) != EXPECTED_SHAPES[name]:
+            raise ValueError(f"{name} shape mismatch")
+        if array_sha256(name, matrix) != EXPECTED_ARRAY_SHA256[name]:
+            raise ValueError(f"{name} sealed array hash mismatch")
+    return matrices
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--qcode-repo", required=True, type=Path)
+    parser.add_argument("--output-root", type=Path, default=Path("."))
+    arguments = parser.parse_args()
+    matrices = build(arguments.qcode_repo)
+    output = arguments.output_root.resolve() / "matrices" / CANDIDATE_ID
+    output.mkdir(parents=True, exist_ok=True)
+    report: dict[str, Any] = {
+        "candidate_id": CANDIDATE_ID,
+        "canonical_digest": CANONICAL_DIGEST,
+        "qcode_commit": QCODE_COMMIT,
+        "matrices": {},
+    }
+    for name, matrix in matrices.items():
+        path = output / f"{name}.mtx.gz"
+        payload = matrix_market_gzip(name, matrix)
+        with path.open("xb") as handle:
+            handle.write(payload)
+            handle.flush()
+        report["matrices"][name.lower()] = {
+            "path": path.relative_to(arguments.output_root.resolve()).as_posix(),
+            "shape": list(matrix.shape),
+            "array_sha256": array_sha256(name, matrix),
+            "content_sha256": content_sha256(matrix),
+            "file_sha256": sha256_bytes(payload),
+            "bytes": len(payload),
+        }
+    print(json.dumps(report, sort_keys=True, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/verify_dataset_stage5.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""Verify the original dataset snapshot and the certified Stage 5 lane."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def main(root: Path) -> None:
+    scripts = str(Path(__file__).resolve().parent)
+    if scripts not in sys.path:
+        sys.path.insert(0, scripts)
+    from verify_dataset import main as verify_original_dataset
+    from verify_stage5_certified_exact_fom_ge_13 import verify as verify_stage5
+
+    root = root.resolve()
+    verify_original_dataset(root)
+    verify_stage5(root)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("root", type=Path, nargs="?", default=Path("."))
+    arguments = parser.parse_args()
+    main(arguments.root)

scripts/verify_stage5_certified_exact_fom_ge_13.py

@@ -0,0 +1,854 @@
+#!/usr/bin/env python3
+"""Verify the public certified [[254,14,16]] typed DistQLDPC release.
+
+This verifier is intentionally solver-free.  It reconstructs the CSS check
+matrices, verifies the four published matrices and complete logical basis,
+replays the weight-16 logical witness, and checks the sanitized bindings to
+two completed DistQLDPC exact-distance runs and the Stage 3/4/5 release chain.
+
+The distance lower bound remains a result under the pinned
+DistQLDPC/MaxCDCL binary and runtime trust model.  No portable DRAT/LRAT-style
+UNSAT certificate is claimed by this dataset lane.
+"""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+import sys
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+
+CANDIDATE_ID = "503600e431e223bb2efe"
+CONSTRUCTION_KEY_SHA256 = (
+    "503600e431e223bb2efe406df1f23ea6698d5451ed1ef6a176566cb828c8f29f"
+)
+CANONICAL_DIGEST = (
+    "1371fca099ef89ec013bc597207ef11af18b57eb34b2ad6480b7fa3801a750c6"
+)
+QCODE_COMMIT = "be725d40c96b49fbd7baa62257fcc2556f3bcd2a"
+HF_BASE_COMMIT = "f7129caeab7fe78943e504dfc48e268e23ee13fe"
+
+DISTQLDPC_BINARY_SHA256 = (
+    "9e09c544d5151d872dc1037dcb1440509e27b8b485a7f9ea5a15d6e55b36d3fa"
+)
+DISTQLDPC_SOURCE_COMMIT = "c01fa93eb5e1e62948e4861e2c164a6b64fe88eb"
+LOGICAL_DETECTOR_SHA256 = (
+    "5771b8c9daaf5fe00acae6f00482c9f802bb020bf5ae70ebfd1234c1dccecd37"
+)
+TARGET_BINDING_SHA256 = (
+    "5bdc62da94468e4a14dd2f73ac0654e28af7dcffea3b0e23d5d85ad8dff1f066"
+)
+ADMISSIBILITY_BINDING_SHA256 = (
+    "c8b9f4d817ab9e88ec2f396f03a2b0bc163d0761656f7374c7f5880e3402bdb5"
+)
+ADMISSIBILITY_REPORT_SHA256 = (
+    "ab68dceda43b5282d8b74fa4aaa7706a8b422070071bc8c9b54580f80a271c79"
+)
+CERTIFICATE_MATRIX_SHA256 = {
+    "H_X": "30dc7d62ec17810d85cd4aefef3a18d3034a5e07e8e293c8b8bba8f1c96d201a",
+    "H_Z": "c17ff5e7e5e4235dea79a042332e55a0cff5667459fcf927bff87d423a45fa2f",
+}
+
+STAGE3_PHYSICAL_FILE_SHA256 = (
+    "dbc31816793c86a2dfd06e380461f06bc5481e817495e589c054789e71934b60"
+)
+STAGE3_INTERNAL_ARTIFACT_SHA256 = (
+    "0367e0d6a138937b32bfd16954f041092944abaefa812177c017b75cc5600a0a"
+)
+STAGE3_HANDOFF_ARTIFACT_SHA256 = (
+    "3a3fdbd8bf576cc728868db56621333a799b3e676a9bd148f7c14dcc9295d505"
+)
+STAGE3_HANDOFF_CLAIM_SHA256 = (
+    "8c0150034c88e627ef02803afd1f301bbd385e1df4868f8eb9fb19134d6c6dbd"
+)
+STAGE4_CERTIFICATE_SEMANTIC_SHA256 = (
+    "e77fbf5bc32f174386f349fdf9e29a72910db50a2c71937168cec2adfc83c7f3"
+)
+STAGE4_CERTIFICATE_PAYLOAD_SHA256 = (
+    "543ebf6dda568e407ba560879fe5a316fc57badf1b641e8f9d5b380abcf6033e"
+)
+STAGE4_CERTIFICATE_PHYSICAL_FILE_SHA256 = (
+    "e7e262988f1ee1dd5f40627a5b5ec908d68f655806b40c8ff9f21c4c60767c3f"
+)
+STAGE5_VERIFICATION_PAYLOAD_SHA256 = (
+    "9d0a0bd40b13b6fc99d5347fd48a6b18686c0ecb62c692872a30573c18ab2d06"
+)
+STAGE5_VERIFICATION_PHYSICAL_FILE_SHA256 = (
+    "26b2daa907580a0d09412c4480f2b7c2a5ae6d99ad43702abf24df968af52c5d"
+)
+RELEASE_MANIFEST_SEMANTIC_SHA256 = (
+    "5f81c636c6e84b79054691b7d0412c9ec08368c7c694ae62cb94b236440931d5"
+)
+RELEASE_MANIFEST_PHYSICAL_FILE_SHA256 = (
+    "cd12992dfe5ece37987ec8b343603db9f69330796b55d8494dbad5b758f2f589"
+)
+LOADED_SOURCE_FINGERPRINT_SHA256 = (
+    "a817f77ddd961e895e8694112dd399daed6dd12cf4aff572d1f5e1d7f06e10c8"
+)
+
+KNOWN_ANSWER_ARTIFACT_SHA256 = (
+    "7adf6f4a93cb321fa0501cbb62723370cdbc3a85db7d9e2565cc086ea6a00687"
+)
+KNOWN_ANSWER_TRUST_SHA256 = (
+    "1e67120095a358bbcb2166a6804479655dc3bdd8b36c4d12bc56f73d5e741140"
+)
+KNOWN_ANSWER_INTEGRITY_PHYSICAL_FILE_SHA256 = (
+    "944ced82bf1f7de269752c316c32541478bb7e8fa4462b44daf2b20b8037b629"
+)
+KNOWN_ANSWER_SEMANTIC_REPLAY_SHA256 = (
+    "a0c103db0a9eb0113a5e2e8fdc9a11e0dd193d14080237c6e3d27cdcf6476502"
+)
+NOVELTY_REGISTRY_INTERNAL_SHA256 = (
+    "536c733d68d344ed9fef9992bbeb1000900174ad0c500ddb7004126ae5c98408"
+)
+
+PRIMARY_EXACT_EVIDENCE_SHA256 = (
+    "c41dbaf43b49955a7cf77851fcc00388eaa41daf5620b7012af980c4f49f8fe5"
+)
+PRIMARY_EXACT_TERMINAL_FILE_SHA256 = (
+    "d336055574bec4076e3abd6c37cd3b839c000f89a241631f47c8cf0fd9bc5022"
+)
+PRIMARY_EXACT_INSTANCE_BINDING_SHA256 = (
+    "7c6fbd48ca92b696590cea37e5fbfcbdf8bebc85e436e59ccc6e074129bbeafe"
+)
+PRIMARY_EXACT_CHECKPOINT_IDENTITY_SHA256 = (
+    "a0436039ddc6e08ffd7e6da3e923404c4c4802aa9055c19c807205fcb2800932"
+)
+EXACT_STDOUT_SHA256 = (
+    "e64418fb577e5021b7ec7693f195ed93d6732572a22a1751514d4aa46fa85227"
+)
+INDEPENDENT_EXACT_EVIDENCE_SHA256 = (
+    "59c3dd3bdf849b1336f43f407ec8814d7597c5db1d2a7e720d4fc55c58b84d04"
+)
+INDEPENDENT_EXACT_INSTANCE_BINDING_SHA256 = (
+    "696c0a34a10d6bf207a94e86be56049a5f7f26ca10f8e7c9361ebc14abca9254"
+)
+INDEPENDENT_EXACT_CHECKPOINT_IDENTITY_SHA256 = (
+    "3a22d9205a4280161ea68b6ecf03c065bfaa1b042401476d04a67e17bfe13013"
+)
+
+UPPER_EVIDENCE_SHA256 = (
+    "6630a19b00daacf9a5e96a93eedea288a26d8ca964f2cd73005ebd57a74cd178"
+)
+UPPER_CNF_SHA256 = (
+    "0134860ae58624e9a1e4490388cb3d74c41cdc0bbe5a125f83aca8014a5abdaa"
+)
+UPPER_INSTANCE_BINDING_SHA256 = (
+    "8b89c49257fceb13404e2de33abd651d58f27057f271d56f282e7723c88fc31d"
+)
+UPPER_OPERATOR_SHA256 = (
+    "f3c15e976dbc838d3aeb351747544e6f6c3a9d1e18a24fedd8833a99ba4838b8"
+)
+UPPER_OPERATOR_PACKED_HEX = (
+    "0100000000000000000000040240140800200000002000000410000006088400"
+)
+UPPER_LOGICAL_SYNDROME = [1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
+
+XZ_SECTOR_ISOMETRY_SHA256 = (
+    "40b86f90a7dcb9509e8314a587284142c87989e282dc1ce2402c8a77705199b7"
+)
+
+EXPECTED_MATRICES = {
+    "hx": {
+        "path": f"matrices/{CANDIDATE_ID}/Hx.mtx.gz",
+        "shape": [127, 254],
+        "nnz": 762,
+        "array_sha256": "5d7d4d7ded8703a43deda393a870136305628b8b8d7714de58f050ccee3f6b1c",
+        "content_sha256": "0d3ee06bc862d2ab61e893aaaeef3fde5b4bfc643251aaf806a1a32a7093eba8",
+        "file_sha256": "9563d6958e7ffc13c1f616192cce41cf148d97db73b41e2eaa6af1c203bfe64a",
+        "bytes": 2226,
+    },
+    "hz": {
+        "path": f"matrices/{CANDIDATE_ID}/Hz.mtx.gz",
+        "shape": [127, 254],
+        "nnz": 762,
+        "array_sha256": "a80232c74b59c4b5ee20163f9badca65c1a1a84bdfb12b8aab3a04c622e93613",
+        "content_sha256": "eddac2800fc08955c7805b0880438f1c0e047c79fc2f1365b89f8b34ff3d4883",
+        "file_sha256": "90471fbfcf70f0147dc799df79f7e34d0552cdb3b28fef4bf8290372bfb25ef3",
+        "bytes": 2175,
+    },
+    "gx": {
+        "path": f"matrices/{CANDIDATE_ID}/Gx.mtx.gz",
+        "shape": [14, 254],
+        "nnz": 912,
+        "array_sha256": "d2b4720434b9b047343545328d823ed22e3c0df7a8d953ae8b6b328c9a26d1a3",
+        "content_sha256": "89ad8dd9a8af7dc1dfbfa40708aba1d792d2ec75c549b96133159bbad06bf649",
+        "file_sha256": "faa9dfd321e1663bcb5538e79878829293605aace895fa58d1ddfba24eedbf53",
+        "bytes": 2057,
+    },
+    "gz": {
+        "path": f"matrices/{CANDIDATE_ID}/Gz.mtx.gz",
+        "shape": [14, 254],
+        "nnz": 846,
+        "array_sha256": "07143f00071d48b2e8c0681b516db3d76bfeb9f0223c54a5d3732199a18b3870",
+        "content_sha256": "b02f1ba21af93d3c7b2c93397c834a74431f49786873c15e79662ef57ab50534",
+        "file_sha256": "16405b89007fcccef60268d473a7fa3dd73a0ff9079b0dd8bf704822ba9c7557",
+        "bytes": 1972,
+    },
+}
+
+EXPECTED_AUTHORITY = {
+    "stage3_typed_handoff_replay": True,
+    "exact_under_pinned_solver_trust_model": True,
+    "pipeline_stage4_certificate": True,
+    "pipeline_stage5_final_gate": True,
+    "independent_release_gate_complete": True,
+    "standalone_typed_release": True,
+    "generic_pipeline_registration": False,
+    "pipeline_promotion": False,
+    "portable_unsat_proof_certificate": False,
+    "publication_certificate": True,
+    "public_dataset_record": True,
+}
+
+REQUIRED_MANIFEST_PATHS = {
+    "data/stage5_certified_exact_fom_ge_13.jsonl",
+    "evidence/stage5_certified_exact_proofs.jsonl",
+    "evidence/stage5_certified_exact_matrix_index.jsonl",
+    "scripts/verify_stage5_certified_exact_fom_ge_13.py",
+    *(record["path"] for record in EXPECTED_MATRICES.values()),
+}
+
+
+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, "expected exactly one nonempty row", len(lines))
+    value = json.loads(lines[0])
+    assert isinstance(value, dict), path
+    return value
+
+
+def safe_public_path(root: Path, value: str) -> Path:
+    assert isinstance(value, str) and value, value
+    pure = PurePosixPath(value)
+    assert not pure.is_absolute() and ".." not in pure.parts, value
+    assert "\\" not in value, value
+    path = root.joinpath(*pure.parts)
+    assert path.resolve().is_relative_to(root), value
+    assert path.is_file() and not path.is_symlink(), value
+    return path
+
+
+def load_mtx(path: Path) -> tuple[list[list[int]], int]:
+    with gzip.open(path, "rt", encoding="ascii", newline="") as handle:
+        assert handle.readline().strip() == (
+            "%%MatrixMarket matrix coordinate integer general"
+        ), path
+        line = handle.readline()
+        while line.startswith("%"):
+            line = handle.readline()
+        rows, columns, declared_nnz = map(int, line.split())
+        assert rows > 0 and columns > 0 and declared_nnz >= 0
+        matrix = [[0] * columns for _ in range(rows)]
+        coordinates: set[tuple[int, int]] = set()
+        for line in handle:
+            if not line.strip():
+                continue
+            row, column, value = map(int, line.split())
+            assert value == 1
+            coordinate = (row - 1, column - 1)
+            assert 0 <= coordinate[0] < rows and 0 <= coordinate[1] < columns
+            assert coordinate not in coordinates, (path, coordinate)
+            coordinates.add(coordinate)
+            matrix[coordinate[0]][coordinate[1]] = 1
+        assert len(coordinates) == declared_nnz
+        return matrix, declared_nnz
+
+
+def gf2_rank(matrix: list[list[int]]) -> int:
+    rows = [sum((value & 1) << column for column, 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 certificate_matrix_sha256(matrix: list[list[int]]) -> str:
+    rows = len(matrix)
+    columns = len(matrix[0]) if matrix else 0
+    flattened = [value & 1 for row in matrix for value in row]
+    packed = bytearray((len(flattened) + 7) // 8)
+    for index, value in enumerate(flattened):
+        packed[index // 8] |= value << (index % 8)
+    return hashlib.sha256(f"{rows}x{columns}:".encode() + packed).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]]:
+    assert len(left) == len(right)
+    return [a + b for a, b in zip(left, right)]
+
+
+def parity(left: list[int], right: list[int]) -> int:
+    assert len(left) == len(right)
+    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 tanner_component_count(checks: list[list[int]]) -> int:
+    check_count = len(checks)
+    qubit_count = len(checks[0]) if checks else 0
+    adjacency = [[] for _ in range(check_count + qubit_count)]
+    for check, row in enumerate(checks):
+        for qubit, value in enumerate(row):
+            if value & 1:
+                adjacency[check].append(check_count + qubit)
+                adjacency[check_count + qubit].append(check)
+    unseen = set(range(len(adjacency)))
+    components = 0
+    while unseen:
+        components += 1
+        stack = [unseen.pop()]
+        while stack:
+            node = stack.pop()
+            for neighbor in adjacency[node]:
+                if neighbor in unseen:
+                    unseen.remove(neighbor)
+                    stack.append(neighbor)
+    return components
+
+
+def unpack_operator(record: dict[str, Any]) -> list[int]:
+    length = int(record["length"])
+    packed = bytes.fromhex(record["packed_hex"])
+    assert len(packed) == (length + 7) // 8
+    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, location: tuple[str, ...] = ()) -> None:
+    if isinstance(value, dict):
+        forbidden_keys = {
+            "command",
+            "command_flags",
+            "cwd",
+            "environment",
+            "interpreter_path",
+            "local_path",
+            "native_thread_environment",
+            "pgid",
+            "pid",
+            "progress_checkpoint_path",
+            "progress_path",
+            "prompt",
+            "requested_path",
+            "rerun_command",
+            "rerun_output_tail",
+            "resolved_path",
+            "session_id",
+            "stderr",
+            "stdout",
+            "venv_path",
+            "worktree",
+        }
+        leaked = set(value) & forbidden_keys
+        assert not leaked, (location, leaked)
+        for key, item in value.items():
+            verify_no_operational_leak(item, (*location, key))
+    elif isinstance(value, list):
+        for index, item in enumerate(value):
+            verify_no_operational_leak(item, (*location, str(index)))
+    elif isinstance(value, str):
+        forbidden_fragments = ("/root/", "/tmp/", "/var/tmp/", ".venv/")
+        assert not any(fragment in value for fragment in forbidden_fragments), (
+            location,
+            value,
+        )
+
+
+def assert_source_bindings(source: dict[str, Any]) -> None:
+    expected = {
+        "qcode_commit": QCODE_COMMIT,
+        "stage3_physical_file_sha256": STAGE3_PHYSICAL_FILE_SHA256,
+        "stage3_internal_artifact_sha256": STAGE3_INTERNAL_ARTIFACT_SHA256,
+        "stage3_handoff_artifact_sha256": STAGE3_HANDOFF_ARTIFACT_SHA256,
+        "stage3_handoff_claim_sha256": STAGE3_HANDOFF_CLAIM_SHA256,
+        "stage4_certificate_semantic_sha256": STAGE4_CERTIFICATE_SEMANTIC_SHA256,
+        "stage4_certificate_payload_sha256": STAGE4_CERTIFICATE_PAYLOAD_SHA256,
+        "stage4_certificate_physical_file_sha256": STAGE4_CERTIFICATE_PHYSICAL_FILE_SHA256,
+        "stage5_verification_payload_sha256": STAGE5_VERIFICATION_PAYLOAD_SHA256,
+        "stage5_verification_physical_file_sha256": STAGE5_VERIFICATION_PHYSICAL_FILE_SHA256,
+        "stage5_fresh_solver_evidence_sha256": INDEPENDENT_EXACT_EVIDENCE_SHA256,
+        "release_manifest_semantic_sha256": RELEASE_MANIFEST_SEMANTIC_SHA256,
+        "release_manifest_physical_file_sha256": RELEASE_MANIFEST_PHYSICAL_FILE_SHA256,
+        "loaded_source_fingerprint_sha256": LOADED_SOURCE_FINGERPRINT_SHA256,
+    }
+    for key, expected_value in expected.items():
+        assert source[key] == expected_value, key
+
+
+def verify_manifest(root: Path, manifest: dict[str, Any]) -> None:
+    assert canonical_sha256(manifest, "manifest_sha256") == manifest["manifest_sha256"]
+    assert manifest["schema_version"] == 1
+    assert manifest["gate"] == "qcode-public-stage5-certified-exact-fom-ge-13-v1"
+    assert manifest["status"] == "CERTIFIED_EXACT_WIN"
+    assert manifest["source_status"] == "EXACT_PROVEN"
+    assert manifest["release_status"] == "CERTIFIED_STAGE5_TYPED_DISTQLDPC"
+    assert manifest["certified_win"] is True
+    assert manifest["publication_certificate"] is True
+    assert manifest["dataset_base_commit"] == HF_BASE_COMMIT
+    assert manifest["authority"] == EXPECTED_AUTHORITY
+    assert manifest["candidate"] == {
+        "candidate_id": CANDIDATE_ID,
+        "canonical_digest": CANONICAL_DIGEST,
+        "code": "[[254,14,16]]",
+        "exact_fom_numerator": 1792,
+        "exact_fom_denominator": 127,
+    }
+    assert_source_bindings(manifest["source"])
+
+    seen: set[str] = set()
+    for item in manifest["files"]:
+        relative = item["path"]
+        assert relative not in seen, relative
+        seen.add(relative)
+        path = safe_public_path(root, relative)
+        assert path.stat().st_size == item["bytes"], relative
+        assert sha256(path) == item["sha256"], relative
+        if "rows" in item:
+            rows = len(
+                [line for line in path.read_text(encoding="utf-8").splitlines() if line]
+            )
+            assert rows == item["rows"], relative
+    assert REQUIRED_MANIFEST_PATHS <= seen
+
+
+def verify(root: Path) -> None:
+    root = root.resolve(strict=True)
+    data = load_jsonl_one(root / "data/stage5_certified_exact_fom_ge_13.jsonl")
+    evidence = load_jsonl_one(root / "evidence/stage5_certified_exact_proofs.jsonl")
+    matrix_index = load_jsonl_one(
+        root / "evidence/stage5_certified_exact_matrix_index.jsonl"
+    )
+    manifest = json.loads(
+        (root / "manifests/stage5_certified_exact_fom_ge_13.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    assert isinstance(manifest, dict)
+
+    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"]
+    verify_manifest(root, manifest)
+
+    assert data["schema_version"] == evidence["schema_version"] == 1
+    assert matrix_index["schema_version"] == 1
+    assert data["record_kind"] == "stage5_certified_exact_fom_ge_13"
+    assert evidence["record_kind"] == "stage5_certified_exact_fom_ge_13_evidence"
+    assert matrix_index["record_kind"] == "stage5_certified_exact_matrix_index"
+    assert data["evidence_class"] == evidence["evidence_class"] == "CERTIFIED_EXACT_WIN"
+    assert data["release_status"] == evidence["release_status"] == (
+        "CERTIFIED_STAGE5_TYPED_DISTQLDPC"
+    )
+    assert data["source_status"] == "EXACT_PROVEN"
+    assert data["source_stage"] == "stage5_typed_distqldpc_release"
+
+    for record in (data, evidence, matrix_index):
+        assert record["candidate_id"] == CANDIDATE_ID
+        assert record["canonical_digest"] == CANONICAL_DIGEST
+    assert data["authority"] == evidence["authority"] == EXPECTED_AUTHORITY
+    assert manifest["source"] == data["source"]
+    assert_source_bindings(data["source"])
+
+    construction = data["construction"]
+    assert construction["family"] == "css-bb"
+    assert construction["representation_id"] == "css-bb-twisted-torus-generator-v1"
+    key_payload = {
+        "ell": construction["ell"],
+        "m": construction["m"],
+        "A_terms": sorted(construction["A_terms"]),
+        "B_terms": sorted(construction["B_terms"]),
+        "geometry": construction["geometry"],
+    }
+    encoded_key = json.dumps(key_payload, sort_keys=True, separators=(",", ":"))
+    construction_key_sha256 = hashlib.sha256(encoded_key.encode()).hexdigest()
+    assert construction_key_sha256 == CONSTRUCTION_KEY_SHA256
+    assert construction_key_sha256[:20] == CANDIDATE_ID
+    assert construction["ell"] == 1 and construction["m"] == 127
+    assert construction["geometry"] == {
+        "family": "twisted_torus",
+        "schema_version": 1,
+        "twist": 25,
+    }
+    assert construction["A_terms"] == [[0, 0], [0, 22], [0, 96]]
+    assert construction["B_terms"] == [[0, 1], [0, 14], [0, 121]]
+
+    a_matrix = twisted_polynomial_matrix(
+        construction["ell"],
+        construction["m"],
+        construction["geometry"]["twist"],
+        construction["A_terms"],
+    )
+    b_matrix = twisted_polynomial_matrix(
+        construction["ell"],
+        construction["m"],
+        construction["geometry"]["twist"],
+        construction["B_terms"],
+    )
+    expected_hx = hstack(a_matrix, b_matrix)
+    expected_hz = hstack(transpose(b_matrix), transpose(a_matrix))
+
+    assert data["matrices"] == matrix_index["matrices"]
+    matrices: dict[str, list[list[int]]] = {}
+    for lower_name, expected_record in EXPECTED_MATRICES.items():
+        record = data["matrices"][lower_name]
+        assert record == expected_record
+        path = safe_public_path(root, record["path"])
+        matrix, nnz = load_mtx(path)
+        matrices[lower_name] = matrix
+        assert [len(matrix), len(matrix[0])] == record["shape"]
+        assert nnz == record["nnz"]
+        assert path.stat().st_size == record["bytes"]
+        assert sha256(path) == record["file_sha256"]
+        assert content_sha256(matrix) == record["content_sha256"]
+        assert dist_array_sha256(lower_name.capitalize(), matrix) == record["array_sha256"]
+
+    assert matrix_index["n"] == 254 and matrix_index["k"] == 14
+    assert matrices["hx"] == expected_hx
+    assert matrices["hz"] == expected_hz
+    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"] == 120
+    assert rank_z == checks["rank_z"] == 120
+    assert 254 - rank_x - rank_z == checks["k_recomputed"] == 14
+    assert all(parity(x_check, z_check) == 0 for x_check in hx for z_check in hz)
+    assert checks["css_commutation"] is True
+    assert checks["commutation_violations"] == 0
+
+    assert all(parity(check, logical) == 0 for check in hx for logical in gx)
+    assert all(parity(check, logical) == 0 for check in hz for logical in gz)
+    duality = [[parity(z_logical, x_logical) for x_logical in gx] for z_logical in gz]
+    assert duality == [[int(row == column) for column in range(14)] for row in range(14)]
+    assert gf2_rank(hx + gz) == 134
+    assert gf2_rank(hz + gx) == 134
+    assert checks["logical_basis_complete"] is True
+    assert checks["logical_duality"] is True
+
+    assert max(map(sum, hx + hz)) == checks["max_check_weight"] == 6
+    sector_degree = max(
+        max(sum(row[column] for row in hx) for column in range(254)),
+        max(sum(row[column] for row in hz) for column in range(254)),
+    )
+    combined_degree = max(sum(row[column] for row in hx + hz) for column in range(254))
+    assert sector_degree == checks["max_sector_qubit_degree"] == 3
+    assert combined_degree == checks["max_qubit_degree"] == 6
+    assert tanner_component_count(hx + hz) == checks["tanner_components"] == 1
+
+    assert certificate_matrix_sha256(hx) == CERTIFICATE_MATRIX_SHA256["H_X"]
+    assert certificate_matrix_sha256(hz) == CERTIFICATE_MATRIX_SHA256["H_Z"]
+    admissibility = data["admissibility"]
+    assert admissibility["schema_version"] == 1
+    assert admissibility["mode"] == "css-stabilizer-check-row-weight-at-most-6-v1"
+    assert admissibility["maximum"] == 6
+    assert admissibility["matrix_authority"] == "fresh-rebuild-from-construction"
+    assert admissibility["matrix_scope"] == ["H_X", "H_Z"]
+    assert admissibility["row_reduction_allowed"] is False
+    assert admissibility["binding_sha256"] == ADMISSIBILITY_BINDING_SHA256
+    admissibility_report = evidence["admissibility"]
+    assert admissibility_report["passed"] is True
+    assert admissibility_report["policy_binding_sha256"] == ADMISSIBILITY_BINDING_SHA256
+    assert admissibility_report["report_sha256"] == ADMISSIBILITY_REPORT_SHA256
+    assert admissibility_report["matrix_sha256"] == CERTIFICATE_MATRIX_SHA256
+    assert admissibility_report["max_check_row_weight"] == 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["cardinality_mode"] == "mto"
+    assert lower["portable_unsat_proof_certificate"] is False
+    assert lower["distqldpc_decisions_verified"] == lower["distqldpc_decisions_total"] == 1
+    assert lower["logical_partitions_verified"] == lower["logical_partitions_total"] == 1
+    assert lower["backend"]["binary_sha256"] == DISTQLDPC_BINARY_SHA256
+    assert lower["backend"]["source_commit"] == DISTQLDPC_SOURCE_COMMIT
+    assert lower["logical_detector_sha256"] == LOGICAL_DETECTOR_SHA256
+    assert lower["solver_instance_array_sha256"] == {
+        name.capitalize(): record["array_sha256"]
+        for name, record in EXPECTED_MATRICES.items()
+    }
+
+    primary = lower["stage3_exact"]
+    assert primary["outcome"] == "exact"
+    assert primary["exact_distance"] == primary["lower_bound"] == primary["upper_bound"] == 16
+    assert primary["decision_complete"] is True and primary["threshold_infeasible"] is True
+    assert primary["evidence_sha256"] == PRIMARY_EXACT_EVIDENCE_SHA256
+    assert primary["terminal_file_sha256"] == PRIMARY_EXACT_TERMINAL_FILE_SHA256
+    assert primary["stdout_sha256"] == EXACT_STDOUT_SHA256
+    assert primary["instance_binding_sha256"] == PRIMARY_EXACT_INSTANCE_BINDING_SHA256
+    assert primary["checkpoint_identity_sha256"] == PRIMARY_EXACT_CHECKPOINT_IDENTITY_SHA256
+    assert abs(primary["elapsed_s"] - 21513.579824514687) < 1e-9
+
+    independent = lower["stage5_independent_rerun"]
+    assert independent["outcome"] == "exact"
+    assert independent["exact_distance"] == independent["lower_bound"] == independent["upper_bound"] == 16
+    assert independent["decision_complete"] is True
+    assert independent["verified"] is True
+    assert independent["evidence_sha256"] == INDEPENDENT_EXACT_EVIDENCE_SHA256
+    assert independent["stdout_sha256"] == EXACT_STDOUT_SHA256
+    assert independent["instance_binding_sha256"] == INDEPENDENT_EXACT_INSTANCE_BINDING_SHA256
+    assert independent["checkpoint_identity_sha256"] == INDEPENDENT_EXACT_CHECKPOINT_IDENTITY_SHA256
+    assert independent["verification_physical_file_sha256"] == (
+        STAGE5_VERIFICATION_PHYSICAL_FILE_SHA256
+    )
+    assert abs(independent["elapsed_s"] - 19798.601512420923) < 1e-9
+    assert primary["evidence_sha256"] != independent["evidence_sha256"]
+    assert primary["instance_binding_sha256"] != independent["instance_binding_sha256"]
+    assert primary["checkpoint_identity_sha256"] != independent["checkpoint_identity_sha256"]
+
+    upper = evidence["upper_bound_evidence"]
+    assert upper["outcome"] == "sat" and upper["sector"] == "X"
+    assert upper["objective"] == 16
+    assert upper["decision_complete"] is True and upper["retryable"] is False
+    assert upper["evidence_sha256"] == UPPER_EVIDENCE_SHA256
+    assert upper["instance_binding_sha256"] == UPPER_INSTANCE_BINDING_SHA256
+    assert upper["cnf"]["cnf_sha256"] == UPPER_CNF_SHA256
+    assert upper["cnf"]["cardinality_encoding"] == "kmtotalizer"
+    assert upper["backend"] == {
+        "distribution": "python-sat",
+        "solver": "cadical195",
+        "version": "1.9.dev7",
+    }
+    assert upper["anchor_indices"] == [0, 127]
+    operator_record = upper["operator"]
+    assert operator_record == {
+        "length": 254,
+        "packed_hex": UPPER_OPERATOR_PACKED_HEX,
+        "sha256": UPPER_OPERATOR_SHA256,
+        "weight": 16,
+    }
+    operator = unpack_operator(operator_record)
+    assert all(parity(check, operator) == 0 for check in hz)
+    syndrome = [parity(logical, operator) for logical in gx]
+    assert syndrome == upper["logical_syndrome"] == UPPER_LOGICAL_SYNDROME
+    assert any(syndrome)
+    assert gf2_rank(hx + [operator]) == rank_x + 1
+    assert any(operator[index] for index in upper["anchor_indices"])
+
+    symmetry = evidence["symmetry"]
+    assert symmetry["translation_verified"] is True
+    assert symmetry["orbit_representatives"] == [0, 127]
+    assert symmetry["orbit_sizes"] == [127, 127]
+    assert symmetry["xz_sector_isometry_verified"] is True
+    assert symmetry["xz_sector_isometry_sha256"] == XZ_SECTOR_ISOMETRY_SHA256
+    assert symmetry["covered_sectors"] == ["X", "Z"]
+    assert symmetry["weight_preserving"] is True
+
+    assert data["parameters"] == {"n": 254, "k": 14}
+    assert data["code"] == "[[254,14,16]]"
+    assert data["distance"] == {
+        "status": "EXACT_PROVEN",
+        "exact": 16,
+        "lower_bound": 16,
+        "upper_bound": 16,
+        "lower_bound_backend": "DistQLDPC/MaxCDCL",
+        "upper_bound_backend": "python-sat/cadical195",
+    }
+    assert evidence["distance_claim"] == {
+        "status": "EXACT_PROVEN",
+        "exact": 16,
+        "lower_bound": 16,
+        "upper_bound": 16,
+    }
+
+    fom = data["fom"]
+    assert fom["exact"]["numerator"] == 1792
+    assert fom["exact"]["denominator"] == 127
+    assert abs(fom["exact"]["decimal"] - 1792 / 127) < 1e-15
+    assert fom["excess_over_12"]["numerator"] == 268
+    assert fom["excess_over_12"]["denominator"] == 127
+    assert abs(fom["excess_over_12"]["decimal"] - 268 / 127) < 1e-15
+    assert fom["excess_over_13"]["numerator"] == 141
+    assert fom["excess_over_13"]["denominator"] == 127
+    assert abs(fom["excess_over_13"]["decimal"] - 141 / 127) < 1e-15
+
+    target = data["target"]
+    assert target["strict_predicate"] == "k*d*d > 12*n"
+    assert target["required_distance"] == 15
+    assert target["left_hand_side"] == 14 * 16 * 16 == 3584
+    assert target["right_hand_side"] == 12 * 254 == 3048
+    assert target["passes_strict_target"] is True
+    assert target["certified_win"] is True
+    assert fom["strict_integer_margin"] == 3584 - 3048 == 536
+
+    source_target = data["source_target"]
+    assert source_target == {
+        "mode": "scalar-fom-13-inclusive-v1",
+        "strict": False,
+        "binding_sha256": TARGET_BINDING_SHA256,
+        "required_distance": 16,
+        "left_hand_side": 3584,
+        "right_hand_side": 3302,
+        "passed": True,
+    }
+    assert 3584 >= 13 * 254 == 3302
+
+    novelty = data["novelty"]
+    assert novelty["checked"] is True
+    assert novelty["novel"] is True
+    assert novelty["status"] == "COMPLETE"
+    assert novelty["matched_entries"] == []
+    assert novelty["canonical_digest"] == CANONICAL_DIGEST
+    assert novelty["registry_internal_sha256"] == NOVELTY_REGISTRY_INTERNAL_SHA256
+    assert evidence["novelty"] == novelty
+
+    known_answer = data["known_answer_context"]
+    assert known_answer == evidence["known_answer"]
+    assert known_answer == {
+        "artifact_sha256": KNOWN_ANSWER_ARTIFACT_SHA256,
+        "trust_sha256": KNOWN_ANSWER_TRUST_SHA256,
+        "integrity_physical_file_sha256": KNOWN_ANSWER_INTEGRITY_PHYSICAL_FILE_SHA256,
+        "semantic_replay_sha256": KNOWN_ANSWER_SEMANTIC_REPLAY_SHA256,
+        "release_replayed": True,
+        "passed": True,
+    }
+
+    handoff = evidence["stage3_typed_handoff"]
+    assert handoff["status"] == "EXACT_PROVEN"
+    assert handoff["typed_replay_verified"] is True
+    assert handoff["backend"] == "distqldpc"
+    assert handoff["lower_bound_threshold"] == 15
+    assert handoff["required_distance"] == 16
+    assert handoff["completed_lower_decisions"] == handoff["expected_lower_decisions"] == 1
+    assert handoff["completed_lower_partitions"] == handoff["expected_lower_partitions"] == 1
+    assert handoff["distqldpc_exact_distances"] == [16]
+    assert handoff["physical_file_sha256"] == STAGE3_PHYSICAL_FILE_SHA256
+    assert handoff["internal_artifact_sha256"] == STAGE3_INTERNAL_ARTIFACT_SHA256
+    assert handoff["handoff_artifact_sha256"] == STAGE3_HANDOFF_ARTIFACT_SHA256
+    assert handoff["handoff_claim_sha256"] == STAGE3_HANDOFF_CLAIM_SHA256
+    assert handoff["qcode_commit"] == QCODE_COMMIT
+
+    stage4 = evidence["stage4_certificate"]
+    assert stage4["passed"] is True
+    assert stage4["certificate_type"] == "qldpc-css-bb-sector-distqldpc-exact"
+    assert stage4["certificate_semantic_sha256"] == STAGE4_CERTIFICATE_SEMANTIC_SHA256
+    assert stage4["certificate_payload_sha256"] == STAGE4_CERTIFICATE_PAYLOAD_SHA256
+    assert stage4["certificate_physical_file_sha256"] == (
+        STAGE4_CERTIFICATE_PHYSICAL_FILE_SHA256
+    )
+    assert stage4["source_stage3_artifact_sha256"] == STAGE3_HANDOFF_ARTIFACT_SHA256
+    assert stage4["source_stage3_checkpoint_identity_sha256"] == (
+        PRIMARY_EXACT_CHECKPOINT_IDENTITY_SHA256
+    )
+    assert stage4["target_binding_sha256"] == TARGET_BINDING_SHA256
+    assert stage4["exact_distance"] == 16
+
+    stage5 = evidence["stage5_verification"]
+    assert stage5["passed"] is True
+    assert stage5["replay_complete"] is True
+    assert stage5["final_gate_accepted"] is True
+    assert stage5["typed_lower"] is True and stage5["upper"] is True
+    assert stage5["novelty"] is True and stage5["fom_target"] is True
+    assert stage5["distqldpc_decisions_verified"] == stage5["distqldpc_decisions_total"] == 1
+    assert stage5["logical_partitions_verified"] == stage5["logical_partitions_total"] == 1
+    assert stage5["fresh_solver_evidence_sha256"] == INDEPENDENT_EXACT_EVIDENCE_SHA256
+    assert stage5["verification_payload_sha256"] == STAGE5_VERIFICATION_PAYLOAD_SHA256
+    assert stage5["verification_physical_file_sha256"] == (
+        STAGE5_VERIFICATION_PHYSICAL_FILE_SHA256
+    )
+    assert stage5["release_manifest_semantic_sha256"] == RELEASE_MANIFEST_SEMANTIC_SHA256
+    assert stage5["release_manifest_physical_file_sha256"] == (
+        RELEASE_MANIFEST_PHYSICAL_FILE_SHA256
+    )
+    assert stage5["loaded_source_fingerprint_sha256"] == LOADED_SOURCE_FINGERPRINT_SHA256
+    assert stage5["standalone_typed_release"] is True
+    assert stage5["generic_pipeline_registration"] is False
+
+    limitations = evidence["limitations"]
+    assert limitations["portable_unsat_certificate"] is False
+    assert limitations["lower_bound_trust_model"] == "pinned-distqldpc-maxcdcl-runtime"
+    assert limitations["solver_invoked_by_public_verifier"] is False
+
+    for record in (data, evidence, matrix_index, manifest):
+        verify_no_operational_leak(record)
+
+    print(
+        "PASS: certified [[254,14,16]], FOM=1792/127; construction, four "
+        "matrices, logical basis, witness, two exact-run bindings, and Stage "
+        "3/4/5 publication chain 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("."))