Publish revised BERTose and BERToseBind release

Add the verified versioned scientific release and reader-facing documentation; preserve legacy files and history.

releases/2026-10-02/.gitattributes

@@ -0,0 +1,2 @@
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text

releases/2026-10-02/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+.venv/
+outputs/
+weights/

releases/2026-10-02/LICENSE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

releases/2026-10-02/NOTICE

@@ -0,0 +1,18 @@
+BERTose and BERToseBind
+Copyright 2026 Supantha Dey and contributors.
+
+Original code is licensed under Apache License 2.0. See LICENSE. Existing source notices and attribution are preserved.
+
+The Python dependencies are distributed separately under their own licenses.
+The bundled WURCSFramework and MolWURCS Java archives are third-party software.
+Their bytes, embedded LICENSE/NOTICE files and dependency POMs are preserved;
+the original-code Apache declaration does not replace those terms. Archive
+hashes and embedded notice locations are listed in
+provenance/third_party_archives.json.
+This code license does not grant rights to source databases, spectra, molecular
+structures, simulations, third-party model weights, or ESM-C-derived features.
+Those assets require the terms documented with each separate release.
+
+The preserved implementation files retain their historical filenames and
+internal model identifiers so that source and checkpoint hashes remain traceable.
+Public model names are BERTose and BERToseBind.

releases/2026-10-02/README.md

@@ -0,0 +1,51 @@
+# BERTose workbench
+
+Code for [supanthadey1/bertose-affinose-training-code](https://huggingface.co/supanthadey1/bertose-affinose-training-code), under `releases/2026-10-02/`. The model assets retain their `releases/2026-09-28/` paths.
+
+## Install
+
+Run these commands from the code directory with Python 3.12:
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+python -m pip install -r requirements-workbench.txt
+```
+
+The base requirements use PyTorch 2.9.1 and NumPy 1.26.4. The workbench adds Hugging Face downloads, plotting and a notebook kernel.
+
+## Embed a glycan
+
+```python
+from bertose_workbench import Encoder
+
+encoder = Encoder.from_pretrained(variant="3", device="cpu")
+wurcs = "WURCS=2.0/1,2,1/[a2122h-1a_1-5]/1-1/a4-b1"
+vectors = encoder.encode([wurcs])
+print(vectors.shape)  # (1, 768)
+```
+
+Variant 3 is the BERTose encoder used in the manuscript comparison. The five variants have different pretraining loss weights. Input must be WURCS 2.0 within the trained 256-token limit. Use `encode_with_diagnostics` to inspect tokenizer diagnostics alongside the vectors.
+
+Open [BERTose_workbench.ipynb](notebooks/BERTose_workbench.ipynb) for batch embeddings, similarity searches and PCA plots. [The quickstart](docs/QUICKSTART.md) gives the same examples as scripts, CSV export, downloads and API reuse in a website backend. Embedding similarity and PCA explore the representations; they do not measure chemical validity, binding affinity or completion accuracy.
+
+## Binding and IAR
+
+The package includes the nine fitted BERToseBind models' loader and the fitted iterative ambiguity resolution (IAR) linkage readout. Model checkpoints and feature data are separate downloads.
+
+- Binding prediction accepts pairs represented in the supplied glycan and protein feature cache. It does not generate features for new glycans or proteins. Scores are model regression outputs, not calibrated probabilities or affinity constants.
+- IAR inference runs only the two supplied single-linkage cases with the full reference checkpoint and saved readout. It does not accept arbitrary new masking cases.
+
+[The quickstart](docs/QUICKSTART.md#binding-from-cached-inputs) shows both commands and their required downloads. These interfaces use saved models without training or refitting.
+
+For selective model/data downloads, see [DATA_ACCESS.md](docs/DATA_ACCESS.md). Your website collaborator can follow [WEBSITE_INTEGRATION.md](docs/WEBSITE_INTEGRATION.md) to reuse the Python interface and check the deployed model identity.
+
+## Training and manuscript code
+
+Training, evaluation, structure/MD processing, and analysis and figure sources are included. See [TRAINING.md](docs/TRAINING.md) for the entry points and required inputs, and [reproduction.md](docs/reproduction.md) for the original implementation details. The workbench examples are inference examples, not a rerun of the full training or benchmark campaign.
+
+## Licenses and provenance
+
+Original code uses [Apache-2.0](LICENSE); [NOTICE](NOTICE) records third-party exceptions. Revised model weights use Apache-2.0. Newly generated contributor-owned data use CC-BY-4.0; upstream data and external model assets retain their own terms. ESM-C weights are not bundled.
+
+[The execution summary](provenance/execution_summary.json), [sequence variant records](provenance/sequence_variants.json) and [release manifest](provenance/release_manifest.json) preserve the source and model references. Historical execution paths describe the original runs; follow the quickstart for local paths.

releases/2026-10-02/SHA256SUMS

@@ -0,0 +1,577 @@
+87c07b5f72ac341f0eb42c040e0617c9512c4ec9f89a20790580d01d473f1b99  .gitattributes
+6f8f72cd77c10018fd9f9666bad581556097a04a67d11e3e831ef21bb250f25b  .gitignore
+a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9  LICENSE
+b6c446fc86540a7a2c432368a5987ed15d622820a0b1bdf45c7cd7273b9bcad0  NOTICE
+5b60c2b1da93ffe81348a456f7f43ba0909855355347f1ea18436c8acb613843  README.md
+52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98  affinose/a1111_encoder_adapter.py
+c4bbe5c1a0286b319f0b71c87669b4f9cfe781051019fb02a98b5d7e208b8b2b  affinose/a5_tokenizer_shim.py
+7fa8d6fe95db3ccecefdd396931d6354442800cd5284cabf519e3425cc388883  affinose/bertint_v8.py
+27e7fe6820357551e9e09a135db4a9d2cff5c4382f5396912dced12c54aaa288  affinose/dataset_v8.py
+82d1d55ed231740fff88065cff7eb9bc45907d69f7c96beebf7eb5fa6e1ae52d  affinose/training_v8.py
+8452e3ac521af1d3ea24bb5a99e02a930d913fc96394e5610fe8b86e19ea89ec  benchmark_exclusion/MANIFEST_SHA256.tsv
+96567c3b9c3e254bceb6bd82e43c1f252b987ced58dad41d3b4406b9f58a76ec  benchmark_exclusion/README.md
+3d37d993b1cd4135ca9fe90feca856b73907d725516ea652425ca24060769698  benchmark_exclusion/SHA256SUMS
+e2e0dfa7d133362146de10ba3dd774e9a3e186088f976189b0aae9d26b442bc4  benchmark_exclusion/code_inventory.tsv
+050c0af96f133ded3139baf6dfea594f91c6659f411dc25fc06d5847951b2f0c  benchmark_exclusion/required_successor_inputs.json
+0507537ca8ee05b249f9ab3f3fa09de94b7acc633b91235f2778ae07659096bd  benchmark_exclusion/source_verification.json
+3d598a249db90c928f8a317923ba5d37eebbc1f63383a2c39e0541f20c31ccac  benchmark_exclusion/writing/review/glytoucan/scripts/build_connection_level_support_audit.py
+a9160769759c1df56238caad6a9f4ed6ec68477d44435ebbc81d64bbf541b64c  benchmark_exclusion/writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py
+0f88f53e22d0c068a87a09508a9d286e4982eddcb4e2154e63b2ca25339ece69  benchmark_exclusion/writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py
+2c8821586df1caa53556b4cc14e6cd7507af4830aa8a149657571e0455eb6853  benchmark_exclusion/writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py
+cd86a0a0b228c32e51ec73490711e37da3e6c9fdf9e64e980b7222b5312484aa  benchmark_exclusion/writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py
+966889118fa567729e1959750b1601018ba117aed0bfad3508005ba6b1896a08  benchmark_exclusion/writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py
+92a9fb830e7adfad3d6999bd3b0cd73f2d5414934c65521a3ee7c6f59003a66d  bertose.py
+0bc54399362945601bcfd403441fc80968d173200dd0561f57568b2053a94839  bertose_source/bert_training_v4/downstream_tasks/utils/wurcs_bpe_tokenizer.py
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  bertose_source/bert_training_v4/model/__init__.py
+b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb  bertose_source/bert_training_v4/model/glycan_bert.py
+83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190  bertose_source/bert_training_v4/model/multimodal_glycan_bert_v3.py
+8a7f8569ff3a21513723d3a15e969120f0fdcf352943dbbadfdc54afd382149e  bertose_source/data/bpe_vocabulary.json
+48914855c4e458ff02452ad4db3743a4fbef12221e0313584db4c2b1bd684cd4  bertose_source/data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_authority.json
+53098620a5c22dafdc951ba743515b4b10b1673c02f0aa4d881db669584902fa  bertose_source/data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_independent_certificate.json
+f654177eb6fde7289b6755812c2be298084697cf0d85159b3ec9da310fe3d4b4  bertose_source/data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_receipt.json
+918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b  bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json
+10ca4b121d2f22d7a64208e4f05172e7a756b653d0828c9dcc49dd8ea1a5ad04  bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_sequence_tree_runtime.py
+f48ba266abf30a7a1298dea747676da64d53acef4ef02cba7ac8f16509460fc7  bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_topology.py
+6591b854962c278dc797981c942e114c18a26e97af43029c1d539bae3badb2f4  bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_wurcs_bpe.py
+399df3de2b6c4d5e88aa442c8326214ab9cff2e8f0411e6921762bbade1475ba  bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_sequence_package_receipt.json
+93ed219d807d4a7735be96bf7cf6a59a0bd407619925ee194aed6d473048cdf0  bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_sequence_package_summary.json
+b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb  bertose_source/model/glycan_bert.py
+8e06c32f4e844c3c66f146fd15a075472808a0720c892d0b9683dfd32f15ef0c  bertose_source/model/multimodal_glycan_bert_v3.py
+6591b854962c278dc797981c942e114c18a26e97af43029c1d539bae3badb2f4  bertose_source/training/a5_wurcs_bpe.py
+2a3b28bd980b144eb42f9688f411adfbced054b9e7bad9fac4de37c6180064f8  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_cuda_resume_diagnostic_20260727_r5_submission_readback_11767377/review_a5_native_eight_cuda_resume_diagnostic_r5_11767377_terminal_certification_receipt.json
+6a1bc65c568a17dc45f1102cd122ac43c62a8ee3b28e06ec855577857cc41ce0  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_cuda_resume_diagnostic_20260727_r5_synthetic_device_receipt_fix/review_a5_native_eight_cuda_resume_diagnostic_receipt_r5.json
+9292c31195a7eddfe9f987a8cfe8cda843b283bb10a1bc8fb1b05d88f82a92d9  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_cuda_resume_diagnostic_20260727_r5_synthetic_device_receipt_fix/review_checkpoints_r1/review_checkpoint_index.json
+cacec838740d64a493c2e56fd1efa8a85ba7d11fce3ec26e40905c33db05e58d  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_data_adapter_20260721_r1/review_a5_native_eight_data_adapter_receipt_r1.json
+3b2118e128a5550ba4918b4f4f2c6d8045e319b7cff37b76d74dce6b3220c9f0  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_data_adapter_20260721_r2/review_a5_native_eight_data_adapter_receipt_r2.json
+e29df7a91d0c30238abe9155e600fb1b77b0d3d3481f6599d2ca0d2185371b9f  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_data_adapter_20260721_r3/review_a5_native_eight_data_adapter_receipt_r3.json
+a92f4b951476e84af006015c97698f07d5e03e7a182c54c82b7d7c5c0e68ffb3  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_data_adapter_20260721_r3/review_a5_native_eight_data_adapter_verification_receipt_r1.json
+9aa5860bfc032afd82561a6db6f8df1439245b73aa3f7575b2b88836e384a1f9  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_hotpath_20260726_r4/review_a5_native_eight_hotpath_r4_integrity_receipt.json
+59a2fd53e9e75f6f8ec258d76e103adb61c908ab0ace6718a348739f5b70d8bd  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_hotpath_20260726_r5/review_a5_native_eight_hotpath_r5_integrity_receipt.json
+0c078ce52e2eb6d6feaeb1a1c2af1794ef33aef56aca7959f76a93f39d152692  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_hotpath_20260726_r6/review_a5_native_eight_hotpath_r6_integrity_receipt.json
+912bc1391ff66c3fd704e61266de508adcf9ed587d7e136932508029b77cb956  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_hotpath_20260727_r7_cuda_rng_cpu_normalization/review_a5_native_eight_hotpath_r7_integrity_receipt.json
+d8feaf25a7266a919c42d3a4fd1ad2d105ab088ae79c024edc665dfa29cf758a  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_production_bundle_20260728_r24_stable_null_jobside/review_a5_native_eight_final_binding_r22.json
+30082379d47318f5d9e17fafad4aa018e7e9f0f0bf1aac559178d46784fe4b9f  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_production_bundle_20260728_r24_stable_null_jobside/review_a5_native_eight_launch_config_r22.json
+826f3e8167fdd459cff7677b5b69d0f3caf9dababaaa71d9eded6070aa5d93a7  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_production_bundle_20260728_r24_stable_null_jobside/run_review_a5_native_eight_r22.sbatch
+1238f76e5da5184d16d33077bf3e5342033918fadb4eba84242c47cb1b1322cc  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_scientific_boundary_20260721_r1/review_a5_native_eight_scientific_boundary_child_authority_r1.json
+fb65dddf0bc61b4c73b5dc5ec796967e65263e9d7bdc4882e07684e882280fdb  bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_scientific_boundary_20260721_r1/review_a5_native_eight_scientific_boundary_child_receipt_r1.json
+64eaf9174f523ae909c84987049d071bf3869ca8e83919f14f0572ef77b0530e  bertose_source/writing/review/multimodal/outputs/review_a5_official_ragged_sequence_topology_runtime_20260721_r3/review_a5_topology_loss_v2.py
+654f5b9728c3dfd2588c4b570b0e3a1bcab8feb366af28eeead36f9beb37d921  bertose_source/writing/review/multimodal/outputs/review_a5_official_ragged_sequence_topology_runtime_20260721_r4/review_a5_official_ragged_sequence_topology_runtime_receipt_r4.json
+ccd4b81d3afac8ae789c538e0af332f74f2468d403da1d243fefefd4df013538  bertose_source/writing/review/multimodal/outputs/review_a5_official_ragged_sequence_topology_runtime_20260721_r4/review_a5_official_ragged_sequence_topology_runtime_summary_r4.json
+b10556643abf560b9e8622e8ae67936d2d3ca8867433db485e785f31d049a8fb  bertose_source/writing/review/multimodal/outputs/review_a5_sequence_official_array_train_only_null_20260721_r1/review_a5_official_sequence_train_only_null.json
+f4eb239f56e472d57dd3a3848c1a6c142e193cb326320ac8bf134b96ac35102a  bertose_source/writing/review/multimodal/outputs/review_a5_sequence_official_array_train_only_null_20260721_r1/review_a5_official_sequence_train_only_null_receipt.json
+831bebd2dcf6a8308d01ec62eb6e1132fe7edbbc666c1c83787335acc576b19c  bertose_source/writing/review/multimodal/outputs/review_a5_sequence_official_array_train_only_null_20260721_r1/review_frozen_sequence_masking_runtime.py
+eae6b3772cd08c65cdc26bdf7ec525742452aad4a35b4d5aa9a7a5936dc3bf73  bertose_source/writing/review/multimodal/outputs/review_a5_sequence_topology_bfs_replay_all_20260722_r1/review_a5_sequence_topology_bfs_replay_all_receipt_r1.json
+da7814d20c81c0d072544cfc5761e8fae0292def176d63b863083389c9caa0ff  bertose_source/writing/review/multimodal/outputs/review_a5_sequence_topology_bfs_replay_all_20260722_r1/review_a5_sequence_topology_bfs_replay_all_summary_r1.json
+ba9591529f3747706fbc169fe8262e23ca31a810473d10c284fb01d9190ebe42  bertose_source/writing/review/multimodal/outputs/review_a5_sequence_v4_two_run_reproduction_20260722_r1/review_a5_sequence_v4_two_run_reproduction_receipt.json
+d6b3dad73d8c9cc78a7c721e7969280d0ff6500773402545bc2ff143b125f56c  bertose_source/writing/review/multimodal/outputs/review_a5_sequence_v4_two_run_reproduction_20260722_r1/review_a5_sequence_v4_two_run_reproduction_summary.json
+8ff3181d22567728c0a10580c1e775da0714f17561ace81034fc673813f54af6  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_epoch_boundary_resume_20260725_r1/review_a5_static_v2_epoch_boundary_continuation_11762446_r1.json
+163374c5c6b049908d935f0d92d8f1a1adda761550761db9b2cb423bfb450ee1  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_epoch_boundary_resume_20260725_r1/review_a5_static_v2_epoch_boundary_continuation_11762534_r1.json
+85711141c9d0e84dee228df84d02df7d4693fb4b85b1ae8163466e208f5e9fd6  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_epoch_boundary_resume_20260725_r1/review_a5_static_v2_scheduler_memory_amendment_11762446_r2.json
+0d96b7867eeec85dbf14eb8f55b745b7c354edb5d16ac702d17b97bf850c79af  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_epoch_boundary_resume_20260725_r1/review_a5_static_v2_scheduler_memory_amendment_11762534_r3.json
+f7adbf64e17c3a2afc677b7af9f05e50e37b4d681f38f0fc192634ca0447e4f4  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_epoch_boundary_resume_20260725_r1/review_a5_static_v2_scheduler_memory_rightsizing_applied_11762446_r2.json
+6796f0b163dcf21af5dfe3048b53e8d2660fe10290e22222232a6c7f6668396c  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_epoch_boundary_resume_20260725_r1/review_a5_static_v2_scheduler_memory_rightsizing_applied_11762534_r3.json
+be55a87986dd6d80942dcd0b17dd75994145ff4a383596314d5b4ee51972a443  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_postfit_cpu_finalization_20260728_r21_stable_null_mass_adapter/review_a5_static_v2_postfit_cpu_finalization_execution_r21.json
+77ba176a9fab70e75b3c2c423c857d1e266f2021875aea01e15bac3f11f327d1  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_postfit_direct_publication_20260728_r21_stable_null_mass_adapter/review_a5_static_v2_postfit_publication_receipt_r4.json
+661d04d76fcf36d116feb117154eac01e6569e377d4245c07653b28696e1227b  bertose_source/writing/review/multimodal/outputs/review_a5_static_v2_postfit_direct_publication_20260728_r21_stable_null_mass_adapter/review_a5_static_v2_train_only_null_r4.json
+333ee6f34e69f89e26b810cc565415b89d6874615ea4ac57850371fb159c1b71  bertose_source/writing/review/multimodal/outputs/review_a5_topology_official_ragged_later_role_20260721_r1/review_a5_official_ragged_topology_receipt.json
+a752ffd350fbe38aa0e6f6b42b76137f4f72d76fa9a7f5d3609bc47c65c552de  bertose_source/writing/review/multimodal/outputs/review_a5_topology_official_ragged_train_only_null_20260721_r1/review_a5_official_topology_train_only_null.json
+dace4cb5df71912f5aa7531bb0ce87db3b63d726b2a12aa41facabf9d54b5c35  bertose_source/writing/review/multimodal/outputs/review_a5_topology_official_ragged_train_only_null_20260721_r1/review_a5_official_topology_train_only_null_receipt.json
+68c0d543c5411276ef56c7072bded4ebda886f46b9fa4ebf3c95c1e54c1a08c6  bertose_source/writing/review/multimodal/runtime/a5_ms_acquisition_top30_v3_20260721_r3/review_a5_ms_acquisition_top30_runtime_v3.py
+9f8f167148aa234df413e4c3d4e1846881781c8e5a19bd91b0b178b260a3a537  bertose_source/writing/review/multimodal/runtime/a5_native_eight_data_adapter_20260721_r2/review_a5_native_eight_data_adapter_r2.py
+a76c24cb0a3b904ae95bfda21bdeb2ba96e36293368fe44a218429be2b10d43e  bertose_source/writing/review/multimodal/runtime/a5_native_eight_data_adapter_20260721_r3/review_a5_native_eight_data_adapter_r3.py
+c71ba654568a24993bc1733b26b6863b11e5c198c53871a6183b485ab96540f0  bertose_source/writing/review/multimodal/runtime/a5_native_eight_direct_static_bridge_20260724_r1/review_a5_native_eight_direct_static_bridge_r1.py
+b6266553c075e9b85d221a6278d1ef3ab1d26fbce5de70dbcd4569db42653990  bertose_source/writing/review/multimodal/runtime/a5_native_eight_finalization_controller_20260727_r19_external_release_runtime_binding/review_a5_native_eight_finalization_runtime_r19.py
+28d482fbae230c999d84e64a5abd6a1260ae26fb555c92b7d3176afb37cb260a  bertose_source/writing/review/multimodal/runtime/a5_native_eight_finalization_controller_20260727_r19_external_release_runtime_binding/run_review_a5_native_eight_training_r19.py
+62f5355ef06cdc56f85214ac251bfa0ed4b19b41a19ab6acac51d644678f0a62  bertose_source/writing/review/multimodal/runtime/a5_native_eight_finalization_controller_20260728_r24_stable_null_jobside/review_a5_native_eight_finalization_runtime_r22.py
+cb9a583091912c59f515f46074b04c90dfbe0ebf0fc28d241db980851b180335  bertose_source/writing/review/multimodal/runtime/a5_native_eight_finalization_controller_20260728_r24_stable_null_jobside/run_review_a5_native_eight_training_r22.py
+3b9ada847b1ea3ecf1f12a6566b55fe1a0218b10aed9d5dabf40190cf0e70c4f  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260725_r1/review_a5_native_eight_hotpath_r1.py
+101559df116319422762f0d7293fe55478b56defcbc1724661696163bb4fc9ae  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260725_r2/load_review_a5_native_eight_hotpath_r2.py
+941f08e0db8bbf2fa61852d4fc218f592fdd63c12f2dafdb70ed3b18e6aedf98  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260725_r2/review_a5_native_eight_hotpath_r2.py
+e99f4556a8e3b3721d1f9155738d2bf4e9765e43a0e9f7734259e33533ff4b30  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260726_r3/load_review_a5_native_eight_hotpath_r3.py
+a81dd58c727a28b1a383477338e41922a2d746dac5cb33f351b4501ee8c5d0dd  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260726_r3/review_a5_native_eight_hotpath_r3.py
+662d0766a8d68638480e9c44ca4070387481d43e1c666a20363025cf5b9bc958  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260726_r4/load_review_a5_native_eight_hotpath_r4.py
+600af4b6b0fab63b7780bb1e6be8233eb28bd0808ff390c3096369afec9c6649  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260726_r4/review_a5_native_eight_hotpath_r4.py
+864a05e86c5ea91318b11373d2cdffcdd2ddd0777f141cb7ef0305f779a42ea6  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260726_r5/load_review_a5_native_eight_hotpath_r5.py
+ce4bad9195229341cab0890ed775b78126c17a23d82f2244757f120c12b346c8  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260726_r5/review_a5_native_eight_hotpath_r5.py
+e2496170942db844e4ebe71d4c098b0d0cf99540d3465ed7e8e9a113469cf7d2  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260726_r6/load_review_a5_native_eight_hotpath_r6.py
+73b42e5131c64284c6f748ddf81b4d187dcb57f756c88c22240d189f2afc4cef  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260726_r6/review_a5_native_eight_hotpath_r6.py
+fa9538829ff3ccfaf3d3f4346c7e735c70758661eb6bf3da5eece2e7e96e0fb6  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260727_r7_cuda_rng_cpu_normalization/load_review_a5_native_eight_hotpath_r7.py
+c0cb618f7856daf24666dbec07ff51b86e3fbd52c073c58bd1b7151122714f47  bertose_source/writing/review/multimodal/runtime/a5_native_eight_hotpath_20260727_r7_cuda_rng_cpu_normalization/review_a5_native_eight_hotpath_r7.py
+35c7a13da662f49bec07b63f590c8fb3d9cc4578633a179da42ff2650a2d7865  bertose_source/writing/review/multimodal/runtime/a5_native_eight_submission_20260727_r15_preparation/review_a5_native_eight_submission_contract_r15.py
+34785bf46f38579e48c3be6326f667a04521cb7d95c1f94c5200d84012b577bf  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260722_r1/review_a5_native_eight_training_runner_r1.py
+7e93b13b3212b3c97e30144f3e393a86a13411d5e82fe19bd55d43bc58587e30  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260722_r2/review_a5_native_eight_training_runner_r2.py
+195dbedfde65c061eb0fca5684270ff95a2bec16732683b1df7f40d91909cc7f  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260722_r2/run_review_a5_native_eight_training_r2.py
+550588ca033718273de2e35825b8b9faffe4a5fb747ff8775fe17bb31050d9be  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260722_r3/review_a5_native_eight_training_runner_r3.py
+bba69e736a44fbfa6b380089d50b945e93b45d5202fa265b5869ffd378149040  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260722_r3/run_review_a5_native_eight_training_r3.py
+cbc9fc0179ecb1e7c449fa37a574f38ff3e912e13db5c984d87e05e3e347a0e1  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260724_r8/review_a5_native_eight_training_runner_r8.py
+213afce295408dda11cf3ede98ebff191735a77e1db09b6252cae964caca39e2  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260724_r8/run_review_a5_native_eight_training_r8.py
+4430560565a18da0e68700d60526d3dec15fabd79854111d1e85deb59e2381c8  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260724_r9_isolated_path/review_a5_native_eight_training_runner_r9.py
+b2bae85c879d2d266ac1e39869c661625958e21c1c3b7299713c8a0b46827ec5  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260724_r9_isolated_path/run_review_a5_native_eight_training_r9.py
+ce7626823c2980bc21b46a7eec6c1961a87dc5512525e553c49f2c7d57bf0430  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260725_r11_certification_gate_candidate/review_a5_native_eight_certification_gate_r11.py
+a8cfaca102f7c3d0c7936d244ce1e9ed75099e70c0ca3a27943be7ce5587b6e0  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260725_r12_r11_integrated/review_a5_native_eight_final_bindings_r12.py
+47e973c7c4ed5bc6686e5d7795b00d3eea5c2da8c2a15fc534a7cc24c1744ee1  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260725_r12_r11_integrated/review_a5_native_eight_training_runner_r12.py
+66270933d1ff23ffe50b800267a4705c905fc423e8e2c929bf642cb5c6c37def  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260725_r12_r11_integrated/run_review_a5_native_eight_training_r12.py
+2feb9a90db66ca277fb9e23d079ce8b089a31060e5670961a13b0e5146ed39a8  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260726_r13_final_candidate/review_a5_native_eight_direct_submit_controller_r13.py
+c30b6b03dae852a4b10c6d01596e977d8a071e738dc3074f1ca0592a50778dd3  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260726_r13_final_candidate/review_a5_native_eight_final_bindings_r13.py
+17cf8ab216b354ec1de7574ebebd7bfe02b5935da605b4131e45c7aa13982d5b  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260726_r13_final_candidate/review_a5_native_eight_training_runner_r13.py
+a2a0a0d9056c7cd360913a792ff5e3390a190b692d7663c3a6d48a3ee0f180d5  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260726_r13_final_candidate/run_review_a5_native_eight_training_r13.py
+737b1caa9086f8ac1556c05625d1b5391b8cae58e9d98a7755fa72f44e94c7ba  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260726_r14_r6_strict_candidate/__init__.py
+bd6c704239e2bb4898dddda5c86274f41cd5b304b35d584ddfae3884e8bc8503  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260726_r14_r6_strict_candidate/review_a5_native_eight_final_bindings_r14.py
+eda983e1b0c29357eb1b6e2f555f402a83b7176fb857488e9be5f5faed490b2d  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260726_r14_r6_strict_candidate/review_a5_native_eight_strict_successor_r14.py
+7ef11d9a891d32b0c1bb3ee24016700acd14251ac49448f004a701cdea79ca53  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260727_r15_current_static_terminal_gate_preparation/__init__.py
+1f21427486260e8b56795f7137f0f7322ae768d80645db6636414e5961aa3224  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260727_r15_current_static_terminal_gate_preparation/review_a5_native_eight_current_terminal_bindings_r15.py
+1556d6e2643edfc80b6b6782164ab47560e259ff55791c50dcffdd9b9afc001f  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260727_r15_current_static_terminal_gate_preparation/review_a5_native_eight_current_terminal_gate_r15.py
+1287db8472580db69e38d60be8c13beeddb4fdde7958a5b302d072e1226f4de3  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260727_r16_r7_cuda_terminal_preparation/review_a5_native_eight_final_bindings_r16.py
+689db8aaf51d15288f01b196c5ad2fe8ee3ca8aab3ff525695abaa9f25060ff6  bertose_source/writing/review/multimodal/runtime/a5_native_eight_training_20260727_r16_r7_cuda_terminal_preparation/review_a5_native_eight_release_successor_r16.py
+2c985edfe747bae712c41689da8be2abb5096bd97a8771691b3676d3a8af49fd  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r4/review_a5_native_eight_balanced_planner_r4.py
+52a311636e7631b97711aab63aec28e2ada47a446d1aecc1a47921d584f69f9d  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r4/review_a5_native_eight_composite_r4.py
+1b9b05c812603db7b216aa989214a3c3715f80032b3a8b82577ae2b9e48f048d  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r5/review_a5_native_eight_balanced_planner_r5.py
+24c35257fc61e1c9c77630d2b0075775a7f46b6500ecb5f175ef8f42bd214e0e  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r5/review_a5_native_eight_composite_r5.py
+a482a70a2edcb7c9936b091a86a0f7d98714b5bab09a0bdc80cd927f015a46f2  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r5/review_a5_native_eight_executor_r5.py
+b5fbdff168de23676208484ccccc3cc32f613ea411d193e6d8930456e8edeeef  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r5/review_a5_native_eight_r4_lineage_receipt_r1.json
+e47e6e9810db0e8ec9d37ce5533f762e287b162f811bfadc347666f5ad78db82  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r6/review_a5_native_eight_executor_r6.py
+e068a3c233fc3fd94fe3b8618edb9bd8c87fd81b97dff2666206fb870f0f898a  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r7/review_a5_native_eight_executor_r7.py
+60ab4de6bc1ee151e9da2c312c41079638e11469502e8136ede51be032eac630  bertose_source/writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r8/review_a5_native_eight_executor_r8.py
+ee97bf4e68ddfbf280b7e0f01ce3409c4d4692feafbc9382613bbc5698913fa7  bertose_source/writing/review/multimodal/runtime/a5_static_failure_release_chain_20260727_r1_preparation/review_a5_native_static_failure_release_gate_r1.py
+f420c84258cdf4247fdd766a9e8470bad55bd1f845ebd6640ec70b97b3953e6e  bertose_source/writing/review/multimodal/runtime/a5_static_v2_epoch_boundary_resume_20260725_r1/run_review_a5_static_v2_epoch_boundary_resume_r1_scavenger_v100.sbatch
+f2e558c52bf166d6e7f42ecdd92995f2b70c8a174eab8d6814875399fb69732e  bertose_source/writing/review/multimodal/runtime/a5_static_v2_ops_20260721_r2/review_a5_static_v2_checkpoint_store_r2.py
+8e57c17fd43f3894f94f980cf70a0d6d7f183cf04c26780c3fe30c1932bb7abb  bertose_source/writing/review/multimodal/runtime/a5_static_v2_postfit_direct_publication_20260724_r2/review_a5_static_v2_postfit_direct_publication_r2.py
+c46a7d4644899a5e7551e2dd5eb30666e01e0f36e2f65a2cd821b8c5565258dc  bertose_source/writing/review/multimodal/runtime/a5_static_v2_postfit_direct_publication_20260724_r2/run_review_a5_static_v2_postfit_direct_publication_r2.py
+3b9632e840265e1a5c1d226f3fe7fb8cd4c448f810f3826c59e19c25132dd04f  bertose_source/writing/review/multimodal/runtime/a5_static_v2_postfit_direct_publication_20260725_r4_terminal_certification/review_a5_static_v2_terminal_certification_r4.py
+9429deca8cfb6cb25ef6f79a5b0ee0b91d47657e7f21f61627afd655d08fe7d3  bertose_source/writing/review/multimodal/runtime/a5_static_v2_postfit_direct_publication_20260725_r5_terminal_certification/__init__.py
+04d724ee84f67565e2f0229db99006c8f64d2492564643f6e60af25930cf12a1  bertose_source/writing/review/multimodal/runtime/a5_static_v2_postfit_direct_publication_20260725_r5_terminal_certification/review_a5_static_v2_terminal_certification_r5.py
+bbdce8deb776917ade3704eb5d08b064917f52c76f3f39ee345b3b2938992add  bertose_source/writing/review/multimodal/runtime/a5_static_v2_postfit_direct_publication_20260725_r6_terminal_certification/__init__.py
+195d41bba2282fdfde77a88f8b0a70eb64b0207d1a9efd42ddaeb873f8ccaeed  bertose_source/writing/review/multimodal/runtime/a5_static_v2_postfit_direct_publication_20260725_r6_terminal_certification/review_a5_static_v2_production_module_roster_r6.json
+bdb0fa37804531f6446cee9411c9730fde792eb9674054e56b883156f36da4cb  bertose_source/writing/review/multimodal/runtime/a5_static_v2_postfit_direct_publication_20260725_r6_terminal_certification/review_a5_static_v2_terminal_certification_r6.py
+30b64143eb15688fa1e1c8aeaf3b84eb08a2a65730fa1c996c9ef6f12679d80f  bertose_source/writing/review/multimodal/runtime/a5_wa345_continuation_20260819_r1_preparation/a5_wa345_continuation_manifest_20260819_r1.json
+f517b5c99d93103d1212b2153c26be1cc58267c7b2d9bfa747f6d512f0fdadf2  bertose_source/writing/review/multimodal/runtime/a5_wa345_continuation_20260819_r1_preparation/submit_a5_wa345_continuation_20260819_r1.sbatch
+eeebc9c7e2cfc701f3ad47e62696ae2247c8caec93d8b034d5f573b701eab2a1  bertose_source/writing/review/multimodal/runtime/a5_wa345_pretraining_20260817_r1_preparation/a5_wa345_manifest_20260817_r1.json
+5159414381025cf3e2d5e742422c84c292481168af42801c773df4ba12797fb4  bertose_source/writing/review/multimodal/runtime/a5_wa345_pretraining_20260817_r1_preparation/run_a5_wa345_shim_20260817_r1.py
+a090f111df7cc0db09e61ea0a8067882b7cd9bf21d91c53da4115549560b08e7  bertose_source/writing/review/multimodal/runtime/a5_wa345_pretraining_20260817_r1_preparation/submit_a5_wa345_20260817_r1.sbatch
+600144a7f5b893958d629083a3a9266eec980765218408d2d51db72b73c1e506  bertose_source/writing/review/multimodal/runtime/md_temporal_20x6_a1111_wa2_s424344_20260811_r2_log_route_preparation/review_md_temporal_20x6_a1111_wa2_manifest_20260811_r1.json
+dd74253863f39150af4ddc7e8d48c0a366e1f327c30aa50e0748078330b97b85  bertose_source/writing/review/multimodal/runtime/md_temporal_20x6_a1111_wa2_s424344_20260811_r2_log_route_preparation/run_review_md_temporal_20x6_a1111_wa2_s424344_20260811_r1.py
+6ffd2f97706bdf0001b90ca2f8af7ec565b298cc8585444ba6027194d0e378d2  bertose_source/writing/review/multimodal/runtime/md_temporal_20x6_a1111_wa2_s424344_20260811_r2_log_route_preparation/submit_review_md_temporal_20x6_a1111_wa2_20260811_r1.sbatch
+aa37d1e86bd3a58262f9824ba80993c0f0f280db4d0f4d704ca469dc12ba3df7  bertose_source/writing/review/multimodal/runtime/md_temporal_20x6_end_to_end_20260802_r3_native_intersection/__init__.py
+3e96d8092239c2c21f217ad5bae4ee7e07dbe0f7630b213bad468d6b08d3b1c1  bertose_source/writing/review/multimodal/runtime/md_temporal_20x6_end_to_end_20260802_r3_native_intersection/review_md_temporal_20x6_core_r3.py
+1e446e7e89a39ef01132b9f2a4deb817161f7b376a0fa04c2b11529004f53e8a  bertose_source/writing/review/multimodal/runtime/md_temporal_20x6_end_to_end_20260802_r3_native_intersection/run_review_md_temporal_20x6_training_r3.py
+a6a180ae103eaaf68458b298cd4180920a0e88c1724a6ba9a94ef94559e75c5f  bertose_source/writing/review/multimodal/runtime/md_temporal_20x6_end_to_end_20260805_r4_dev_memory/run_review_md_temporal_20x6_training_r4.py
+32285cc5fedd421032bd98b97214f899ccacda9b211c1b2a97a3fb1513f1ad70  bertose_workbench.py
+3d3077181b519b0106d9201ee8514a41905e32057237d8fdb48343e10cfa97b3  bertosebind_inference/README.md
+81f3da9b814892c3f12b2f7a535284b89f0be07b22bce50a374c8303d6db6c72  bertosebind_inference/__init__.py
+b7cfcdaf1c902664252f3d2022e290a803892a31618c1290c09c174131036541  bertosebind_inference/check_real_examples.py
+07282f0fec34ef2cf9f832c3662227ca89064b52e3fdbe9fd3ad11b5f4e01154  bertosebind_inference/config.json
+d748e004c483597c86cc214ecd43f5c902e3d3ced41d1e9223b555dfa3b9ed58  bertosebind_inference/examples/doubly_cold.csv
+c50e124eba39a8bb5f08e4d75e54b0f168ff74ee886d7f28e3156b3beba6ad96  bertosebind_inference/examples/glycan_cold.csv
+6d70ea272cb716c7bf001675493496bfe7491add0185c010f83417a8ed607784  bertosebind_inference/examples/protein_cold.csv
+3de9b7e6b9c6035c0e07504b1dadb2c1c430151b7c889c33825a437a5c70e659  bertosebind_inference/examples/reference.json
+0c074c3901ac55b737e10a2b316db3c00678e569d151fc3e2192b46bd1662ce6  bertosebind_inference/loader.py
+e06c540874abbfd72b72b6ee41aa2d35a6d35bf11d26e10714f382d031765b3a  bertosebind_inference/local_checks.json
+fe3f559157a6bc3dd4b59803fb010054c8987f402b6790f488e6cce51bc95d4b  bertosebind_inference/predict.py
+b18eed4c3ad4f0cbdd700e41d6ff7af1f520d26386f76f4573e82332f3e1ea28  bertosebind_new_runs/README.md
+fc4ffac8de965da6250297ee24fa801be2619f1afcc29471204c7e5aead03012  bertosebind_new_runs/audit_pretraining_exposure.py
+2b8be4fcd7ebc98f49e9532415644f457930a1e7700d5c17fdc58a0abd0dd271  bertosebind_new_runs/check_package.py
+45a366b40a523671427950b83ac2c8a243c96f1bce8527b0af2337a375ff2b15  bertosebind_new_runs/executed/local/audit_current_pretraining_exposure.py
+bdb19bf323c94eacc1943b4345b5b2485dfa50b7ac00a755e8a1dde2f8a4ed74  bertosebind_new_runs/executed/local/collect_current_glycan_sets.py
+9c9b90f077709c105dd16b706ebcd434dd793177c274eca17b10bc3241f0138b  bertosebind_new_runs/executed/local/dc_anatomy.py
+33d41f680cf7a5ae3b98fef4d1ef604f6e12a6a856ec6e90df8bb5a88f336bbe  bertosebind_new_runs/executed/remote/aff_attribution_motif.py
+2b89020895eebac8c99366036eebb07dd43c687fe47274dcd1de47d1017548ff  bertosebind_new_runs/executed/remote/aff_attribution_motif.sbatch
+d7f21b8037172e6d42fb65c8169d37b19c385d68dc9cbebadbafe9e930843074  bertosebind_new_runs/executed/remote/affinose_gifflar_macro_A_glycan_gifflarESM.json
+eca94bfbe82bfba95c2086c9c4ffe14091d442017356394ec2e75173cb66810f  bertosebind_new_runs/executed/remote/affinose_gifflar_macro_A_glycan_sweetnetESM.json
+529296c1388651b4451f35829d0caa63e692a96fc88b74ee9b8dc8c1d09136da  bertosebind_new_runs/executed/remote/affinose_gifflar_macro_B_protein_gifflarESM.json
+6f0098947aa4c962f991d1e17acc17707d7cb2eb5e9d6338182d6cfa65d28a2d  bertosebind_new_runs/executed/remote/affinose_gifflar_macro_B_protein_sweetnetESM.json
+bf720edacbad09cd04c42df7cf347dd1fe9846a22f307f7be1c38f06e89faa44  bertosebind_new_runs/executed/remote/affinose_gifflar_macro_C_doubly_gifflarESM.json
+1884d744232b56c5edc76e655cf9bd117e43d8d749c98300b528ea6a5e55b75d  bertosebind_new_runs/executed/remote/affinose_gifflar_macro_C_doubly_sweetnetESM.json
+0d4458462cd10dae219a9f15eb6dc8129d200a09891bd0b6bf0297cd85c4dae2  bertosebind_new_runs/executed/remote/affinose_glycan_cold_contamination.json
+61a5ef32482365e37e58bd4aee49ff5dabc2fafa04f4e063f3a0be7c294c84c7  bertosebind_new_runs/executed/remote/b4_baselines_perrow.py
+a381978d36492bb21cdb7c2a3007c51414b7630dd88016c7a74eb19c48080925  bertosebind_new_runs/executed/remote/b4_gif_repeat.sbatch
+7fe6a80de1e7662a916e84b0a679c5579ab7fdcaaace70e1855f7d8face51ca3  bertosebind_new_runs/executed/remote/b4_gif_repeat_compare.py
+1d0433763d7ad49088e396b435a42f2a12141436db05592778a79938c88a953b  bertosebind_new_runs/executed/remote/b4_lo_perrow_ckpt.py
+c82d7fe71d178d78d52ee47d809cd12d0286c48b1375c0c7b8b80fa222858e61  bertosebind_new_runs/executed/remote/b4_step1_structure.py
+ab7560abe237da435464a984a4e23925e7ec48d802949f57ef9600b829e6b37d  bertosebind_new_runs/executed/remote/b4_step3_bootstrap.py
+6dbbbeb14bb860f6344a93bb65754f540dee8da4ceb3fdc526133c7133dd426c  bertosebind_new_runs/executed/remote/b4_step3_bootstrap_r2.py
+50049bf5658f27700205e91d07f40512b8d297a7af11f51fcfbd514df9b59478  bertosebind_new_runs/executed/remote/diagnostics/affinose_b4_gif_repeat_20260927.json
+7f9edc64528d5b43d2c464f8f5d4db91c2a133f54364993c7798a2a606bd3427  bertosebind_new_runs/executed/remote/diagnostics/affinose_b4_step1_structure_20260926.json
+17ab513ec2d9dec6f1e8c9445dfd7500190f99f0e8758b21fbb435b026324f3b  bertosebind_new_runs/executed/remote/diagnostics/affinose_b4_step3_bootstrap_20260926.json
+6a87e6a8abc926f41ca13b1bb6c81cbf9ea1d04b06e8f39bfdaf847ce55ba235  bertosebind_new_runs/executed/remote/diagnostics/affinose_b4_step3_bootstrap_r2_20260927.json
+1ab7793ddb0daa247dc1f75b53356663d2c99e2e279a33207c9dd82f24288d17  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_A_glycan.yaml
+cda3d3e0df11dcbffff287c985039a4abe486a39bb97fe1554851992cbca127e  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_A_glycan_s43_gifflar.yaml
+d11d6ca73935a664a9afe9330d07e51b7e95e89e044a1012065ef1780d820381  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_A_glycan_s43_sweetnet.yaml
+dab891f502cb328f8313a9d2971e5d8134472b059fa776409f97f5f59e5d470b  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_A_glycan_s44_gifflar.yaml
+875883d0ec38fca1a4995ea76c00db81ba84357fb2ed9a7c0921dbb6c7cf6492  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_A_glycan_s44_sweetnet.yaml
+529c3940cfce81ab3d135f25b722d7c302cd83e8540646f041a5d6ba36baebf3  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_B_protein.yaml
+908379483dc5b2d0655aa7b0a13b33c8b70ba0379852ffc2d848e354ebd9945e  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_B_protein_s43_gifflar.yaml
+57cbf88ddf620ffbec7c4a8167a271ec38da0f94b1d3a4e9fe9769a9a19b8eea  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_B_protein_s43_sweetnet.yaml
+5e518f2db88c03663eb263a5e4a44e93a3bc43e51c4af6c626cd0da416a18d81  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_B_protein_s44_gifflar.yaml
+50c68416d3d4d72445e61811474179cb552e60d9f8a87f6cc0ed1da32d8b55e8  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_B_protein_s44_sweetnet.yaml
+034ba8bdefc3410b987d7bc380bd24a469a01c912349fef1e35436df2a24c36e  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_C_doubly.yaml
+ed244565f2f81e6c554613718398af97683ad375eb4debb5a61d25855c444368  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_C_doubly_s43_gifflar.yaml
+d8ba3e8d83871cdd92548bc8bab1493225cdcbd536c0004ff6b40b48e4e62e40  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_C_doubly_s43_sweetnet.yaml
+2faa1986c043cf5d8b869d316afa0a043d071400c4f2018ba83551332a143f25  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_C_doubly_s44_gifflar.yaml
+5fd2cdec3ee4d49f7d7441a037e0a2fbe428b1c0586de88beaf17a2ab67580f1  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_C_doubly_s44_sweetnet.yaml
+e8fafb98627685ededa4392c5310e149a7dbbe907e37b43da7d20d228961b181  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/configs/lgi/ours_C_doubly_sweetonly.yaml
+ab257b93c23a522dcd99f37b2b802e67c8e3b4ba46b938db6229a6311a77cd39  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/gifflar/data/utils.py
+ab79451e7b51e27d985904a4445fc09b756d759413bb2ebaf8755d177bb3e8ad  bertosebind_new_runs/executed/remote/external/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bench/models/GIFFLAR/gifflar/train.py
+56bf1e5b11a386d0920b9f50da6288eff222ee1b7f25d772a8a666a2387b2a9d  bertosebind_new_runs/executed/remote/gif_seeds.sbatch
+241d3ca6045610a70ccad8307448b4d57e47810c945f127fef768357e56cdef2  bertosebind_new_runs/executed/remote/gifflar_launch.py
+e391584ec821c1e86916c6f8c14a6571a550034fd246e1dc0e7d7b3b6d4dbd7e  bertosebind_new_runs/executed/remote/gifflar_lgi_A_glycan/logs_s43_gifflar/LGI_gifflarESM/version_0/hparams.yaml
+35d0ef06a1b9725233ed1e58c74101b7e6a555da48165ed57c9bd71bb5e77315  bertosebind_new_runs/executed/remote/gifflar_lgi_A_glycan/logs_s43_gifflar/LGI_gifflarESM/version_0/metrics.csv
+0dae829566b87d0dd00613343bc5a0c49fb1107c0f4834327d8cca71b8932389  bertosebind_new_runs/executed/remote/gifflar_lgi_A_glycan/logs_s43_sweetnet/LGI_sweetnetESM/version_0/hparams.yaml
+fd6f39dd3bef9326bc1f583bf07a1f9b8f02f846630a0c58c66c7bae70456d59  bertosebind_new_runs/executed/remote/gifflar_lgi_A_glycan/logs_s43_sweetnet/LGI_sweetnetESM/version_0/metrics.csv
+fb07ac7cfcb63c4dd77c7493f4a518e11d268fd5e8d4cf6a849c31552e48369a  bertosebind_new_runs/executed/remote/gifflar_lgi_A_glycan/logs_s44_gifflar/LGI_gifflarESM/version_0/hparams.yaml
+1d9e1b8c6fff12f8603ce8f7e58189da0ae8580e72d3c5bf5ff3893a4f9bce2f  bertosebind_new_runs/executed/remote/gifflar_lgi_A_glycan/logs_s44_gifflar/LGI_gifflarESM/version_0/metrics.csv
+4902e83edaa137f55f5fe4f32f32068e94a3f4832630b284048c22b8a099dca6  bertosebind_new_runs/executed/remote/gifflar_lgi_A_glycan/logs_s44_sweetnet/LGI_sweetnetESM/version_0/hparams.yaml
+b911e06e11968f9d8655ab69619f33a8878759e497eb44498432c341dc6fbdd1  bertosebind_new_runs/executed/remote/gifflar_lgi_A_glycan/logs_s44_sweetnet/LGI_sweetnetESM/version_0/metrics.csv
+75ffe300584ac7f56ecc28e85be309a3f7c9f506a615d1edc8e77aac4f3d4b7b  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_gifflar/LGI_gifflarESM/version_0/hparams.yaml
+346d480fa44e31a5a486bfa99c136cc5ddfee27a197194b7fac289de9ba55665  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_gifflar/LGI_gifflarESM/version_0/metrics.csv
+75ffe300584ac7f56ecc28e85be309a3f7c9f506a615d1edc8e77aac4f3d4b7b  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_gifflar/LGI_gifflarESM/version_1/hparams.yaml
+6a42d5cf20bf64a7b027660beca902ec84a80a1beb73e8aec1e4eb26fbb7c913  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_gifflar/LGI_gifflarESM/version_1/metrics.csv
+75ffe300584ac7f56ecc28e85be309a3f7c9f506a615d1edc8e77aac4f3d4b7b  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_gifflar/LGI_gifflarESM/version_2/hparams.yaml
+a71483c34b9d9cd904a6fe241f88af3e30bb3e100a15d666def5b06e4a5c0431  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_gifflar/LGI_gifflarESM/version_2/metrics.csv
+2213baffb7e7ada5a1f384d75380098d53bc92f2c3134e94d35750ab9e419c16  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_sweetnet/LGI_sweetnetESM/version_0/hparams.yaml
+faee86ceadc7e1dbe6835d44aef8c5d4f810a2cbe224e13202154b52dab92be3  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_sweetnet/LGI_sweetnetESM/version_0/metrics.csv
+2213baffb7e7ada5a1f384d75380098d53bc92f2c3134e94d35750ab9e419c16  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_sweetnet/LGI_sweetnetESM/version_1/hparams.yaml
+ed66bf0654eeaabf3b4f5f92e1295abc53a0155095160092ffb47826ff385d1a  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_sweetnet/LGI_sweetnetESM/version_1/metrics.csv
+2213baffb7e7ada5a1f384d75380098d53bc92f2c3134e94d35750ab9e419c16  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_sweetnet/LGI_sweetnetESM/version_2/hparams.yaml
+127b095cc67faf26378a247dc7345de56d331537dad375990ed319f684fbde27  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_sweetnet/LGI_sweetnetESM/version_2/metrics.csv
+2213baffb7e7ada5a1f384d75380098d53bc92f2c3134e94d35750ab9e419c16  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_sweetnet/LGI_sweetnetESM/version_3/hparams.yaml
+eee99377078178660db1f12c2700b0c46c9d8120db5f445a8d71d3f584cc9fcd  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s43_sweetnet/LGI_sweetnetESM/version_3/metrics.csv
+0c1b007e6c5b0146ed2927ff60720f7c9fba81286f4dc4b866f896e18c878d35  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_gifflar/LGI_gifflarESM/version_0/hparams.yaml
+47b51d96993782f3c9e6117722176941bd2c6d571200d160e28aa654c97c6356  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_gifflar/LGI_gifflarESM/version_0/metrics.csv
+0c1b007e6c5b0146ed2927ff60720f7c9fba81286f4dc4b866f896e18c878d35  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_gifflar/LGI_gifflarESM/version_1/hparams.yaml
+89d056126636c1fd1fa44d27ecfd57040a9bfc9eec2a76104da0ae07d01680b3  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_gifflar/LGI_gifflarESM/version_1/metrics.csv
+0c1b007e6c5b0146ed2927ff60720f7c9fba81286f4dc4b866f896e18c878d35  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_gifflar/LGI_gifflarESM/version_2/hparams.yaml
+c066cdbf7827bdec2f87c15bf95a42e0a23b511bf03338482e4d2b20c149336b  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_gifflar/LGI_gifflarESM/version_2/metrics.csv
+1192dfb103f69ed8970d6bb263fa292648b6c673b3067a33b46d26940d0231ef  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_sweetnet/LGI_sweetnetESM/version_0/hparams.yaml
+fe5d987579ac234e8f21bb70e642177e9eccb69493564b7c5895e6abd51f4dc2  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_sweetnet/LGI_sweetnetESM/version_0/metrics.csv
+1192dfb103f69ed8970d6bb263fa292648b6c673b3067a33b46d26940d0231ef  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_sweetnet/LGI_sweetnetESM/version_1/hparams.yaml
+0ecfee6421a63cee0f0537fdb311e44b87227421f637816a0a3ccfd132763d16  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_sweetnet/LGI_sweetnetESM/version_1/metrics.csv
+1192dfb103f69ed8970d6bb263fa292648b6c673b3067a33b46d26940d0231ef  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_sweetnet/LGI_sweetnetESM/version_2/hparams.yaml
+0d313e8557cb13577b34c8e94e0f2c887c11cfa6da6ca36ab2aa5f9d1cc10f22  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_sweetnet/LGI_sweetnetESM/version_2/metrics.csv
+1192dfb103f69ed8970d6bb263fa292648b6c673b3067a33b46d26940d0231ef  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_sweetnet/LGI_sweetnetESM/version_3/hparams.yaml
+5ef2b9552f452e4218b9728c0ed57f7a14ec5068d065c7223e2c6e566e5dafd2  bertosebind_new_runs/executed/remote/gifflar_lgi_B_protein/logs_s44_sweetnet/LGI_sweetnetESM/version_3/metrics.csv
+781862ff668231f3501e892c7be567e4e3a16709f6b433e97edeadd60ec1e8bf  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s43_gifflar/LGI_gifflarESM/version_0/hparams.yaml
+e92266239d6445a0de886e5081e433632c6719719f6d536ad31e98045160fcea  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s43_gifflar/LGI_gifflarESM/version_0/metrics.csv
+781862ff668231f3501e892c7be567e4e3a16709f6b433e97edeadd60ec1e8bf  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s43_gifflar/LGI_gifflarESM/version_1/hparams.yaml
+929a3396f429527836db8368e7908024bf69766e0567636b1f24df8c1c06ea42  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s43_gifflar/LGI_gifflarESM/version_1/metrics.csv
+f7852d23330d3b55e46eec193b3fe411306ea59349de6fa53273294d893dce1c  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s43_sweetnet/LGI_sweetnetESM/version_0/hparams.yaml
+1e68c5af1f9c7fe0f1c85d9f3d49fa1104bf3d4c768014154316ee27b94a3cc3  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s43_sweetnet/LGI_sweetnetESM/version_0/metrics.csv
+987afb2ba2360ff7f2a5a94943d064a7a3e5c902b53e445bc59bc291241e9d9a  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s44_gifflar/LGI_gifflarESM/version_0/hparams.yaml
+e937607ecc6a7058664faab71728c58ef7a9bba8f6985082bca5d565aef6ec7e  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s44_gifflar/LGI_gifflarESM/version_0/metrics.csv
+987afb2ba2360ff7f2a5a94943d064a7a3e5c902b53e445bc59bc291241e9d9a  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s44_gifflar/LGI_gifflarESM/version_1/hparams.yaml
+eb420f0ea03bce2075ad4eac9237862ccbecb2c37c02d162d860516f4739b280  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s44_gifflar/LGI_gifflarESM/version_1/metrics.csv
+22796804655424d5977b04b0b171d4da9fba18896eb4928842c4fad6bb7911dd  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s44_sweetnet/LGI_sweetnetESM/version_0/hparams.yaml
+30f0105da3f2c579a8261a30ed6c3fcc8308cf9ebc2068f0e71168567e919922  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s44_sweetnet/LGI_sweetnetESM/version_0/metrics.csv
+22796804655424d5977b04b0b171d4da9fba18896eb4928842c4fad6bb7911dd  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s44_sweetnet/LGI_sweetnetESM/version_1/hparams.yaml
+168da3dcbf6ca795bb75ec67b9fc567788637c25875b766cc76b441825e6020c  bertosebind_new_runs/executed/remote/gifflar_lgi_C_doubly/logs_s44_sweetnet/LGI_sweetnetESM/version_1/metrics.csv
+ef833104d5eecd273df7d9f7c39bae4a216b015bde15978ea716f1f864874de4  bertosebind_new_runs/executed/remote/gifflar_score_macro.py
+578635213e1a3eddd61438a6249f14e1a5d2487267286fc459eb77972808e225  bertosebind_new_runs/executed/remote/gifflar_score_macro_seeds.py
+f88bcf303685ea6a075747a12eafa7df041909b9b455d80ea98c2b536aed0de8  bertosebind_new_runs/executed/remote/gifflar_score_perrow.py
+e65e21b8c9c9bd0291a034852f7ab47f826e1f51448d9ea8439b5eb23ed8eb98  bertosebind_new_runs/executed/remote/logs/aff_attr_motif_16596807.out
+dadfe2c408938645b4138bb011719affdaebe7098060f66354df56da71d0a146  bertosebind_new_runs/executed/remote/logs/aff_b4_grep_16604967.out
+79eb29df46c44942a2a6ac4313789ebc29e1672bec4512c4f965be5ebb739cc9  bertosebind_new_runs/executed/remote/logs/aff_b4_s3_16604914.out
+5d93f96fb6e537c9b802fd1b2d9fe25df41a19800f85ea860246274d2e897d71  bertosebind_new_runs/executed/remote/logs/aff_b4_s3r2_16605803.out
+6c486b37a642549a8dcf924eabd52e2660d88a6ada53ba05aecb91937fd98626  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_0.err
+7832596dfd62832aadeed39c1acca59643f00ec8dbe812730b49bd1b2ca5150b  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_0.out
+bf5e3ff79c6b942dca7f35dcb85d0f32081b03875cb4640022fab29dff833b11  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_1.err
+134b045efbf1f560d0d41fa702ff53b6369fd38235fcef55ca8aaa4615698fed  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_1.out
+d911a9619dee68a9fc982bb3db253b8e72f12dc1c06d2bc434556211909b2719  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_10.err
+c079926adcc0d2bce5b591f870208dcd2bef2ea3029aee8950bf0ce44c1105ea  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_10.out
+5024c4160aeeccd212930b0d959ed0bab4dd7bf593b61b26decd78c7513aa638  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_11.err
+4d110e939761ff4d8c7938c754e182d2c09ede84c8360d10ce18a04280dafea6  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_11.out
+d9383fa7e0469a436e08d24f4f9af31c1a6fb9ebb5e115843b53e2b2ded612f1  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_2.err
+0bbeab27824eeffbbfe5cf04317d1795b1f8f02d4c5ad9b7dbc23e159a823940  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_2.out
+735f42f273046b3af0374283927429fa75a1b7a8b66d6b205a20e4e1cfd59eed  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_3.err
+dcdbc088e7945d0f63803ac95aed81f3f8c8d25c97dd760df269921a08bacae7  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_3.out
+98912251710582e65eaed2ba01ee184d957d177ec31e30969939b4ef0962a2bf  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_4.err
+b1febe3591a887bd63d7bb607536ce17bdab51eb9db9a8b8c3d9d5ff77aca1c2  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_4.out
+cbb38c7fc50100cfa44cdf9b64de3df9a002613c62d8489b9d3db301406712c7  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_5.err
+a1b8f17ba63285c54d42ad49ce61bf8356ac4dfe279de8b65f687304783bdf55  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_5.out
+8ec18cd103ee2f80b2bacc8660a53588ed6313dbdc2455fe87fb5cdac6d30ef1  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_6.err
+18050c22347d3a2900b0d15cd7f2b97c1f6028ff27e5e060fc33c8308851b358  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_6.out
+1a1baefb3f9d8bae9c38975310f96004470e75bed27b32b5273b31a9baca05f5  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_7.err
+8869a90d89089a6f26c7d88b1a389630930c35adff10016a015bc5bb331308b7  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_7.out
+01b633582a3ed13728f688fde16693926778896ba0952506cce66072f600f354  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_8.err
+8f468cb20588f01bc0794c43ea69d5fa78627f4e35ef7ecdb7ffbcd3266c78c3  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_8.out
+a3ea46d3bd9191b9bbd49627cbfdac0dee312230e5e1ed93016f98f8786b94ba  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_9.err
+313f8c5e3999dfa75ae508fd57d0d033a00b40cdf2b794cb4c32fb0a901b53bb  bertosebind_new_runs/executed/remote/logs/aff_gseed_16597159_9.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_0.err
+19bb18892da4f9174e308bd42908a6e6d383001edd75c9ad482eef111b5bbb31  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_0.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_1.err
+152af1228aa39534d68470023321d4350bb2ea4b997bfd0bf38efbbeb92bad8b  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_1.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_10.err
+d842f047adc16782a9724406ecab07aa67fe3ad853f5d0c8bee73cb63d129782  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_10.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_11.err
+922dfe72fd457b50a6c468db266827346ab1173381458ad61e21ceb5a0c8736c  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_11.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_2.err
+2b008f6ae0f5554b9841582ded12a01558218558d8b7748899e94a0499d8caaf  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_2.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_3.err
+c1d325125ee0463b230e5ac347c45a117ebc1a1686393d9d7bd63dd7c9a8a8d4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_3.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_4.err
+939f30920d3d4a772d8736c945f6e39dc949cde64cc7b9b9e0116e7b45f4f895  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_4.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_5.err
+7817d9b5c087d542f2c0659726a66532091a24c9b05edb04196a756291dd5784  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_5.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_6.err
+4283aa1d699582d4766ca394cf2d9c4b046ce8247b5cef0f8250c424329138a2  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_6.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_7.err
+eb0257132cbd79d1a3a84bec543183b7bbdaceaaaefc85c988368d70d4146322  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_7.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_8.err
+523b5ac11259832265dab5c4e08d837f3fe7e4780048a5a4af1f513f6b8c3d4a  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_8.out
+53e0d436715c2b2e61c45d8474df7edff033d7693326a363aa202198e7001ff4  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_9.err
+40ef3d8f12ba723cfe0e845ec72a960dbd32c8bc5baa3013f570e1c27a6431b6  bertosebind_new_runs/executed/remote/logs/aff_gsmac_16602170_9.out
+06fbfcd2f820fc4621d35c16dcd6bbece93ea68b96d417d8b7bd2ce3ea104cdb  bertosebind_new_runs/executed/remote/manifest.json
+bf602abb05eeb3b0203766d9d1bc462579c181bc3418d762f6d02d5f36e8a230  bertosebind_new_runs/executed/remote/train_lgi.py
+9d13452309d64f138705657334b74738eaf167c9faff835d024582e0e98c0af8  bertosebind_new_runs/inputs/current_glycan_sets/doubly_cold_exposure_join.csv
+e5eebf2072779d7001dabd3981237025be37eee6f19a5b109b00ce4b3e776e09  bertosebind_new_runs/inputs/current_glycan_sets/doubly_cold_scored_glycans.csv
+4d101cc92685c63ecca99cfad2c1bc46c73c77b1e565bd686bde14ee0d020886  bertosebind_new_runs/inputs/current_glycan_sets/glycan_cold_exposure_join.csv
+0faab973a6ee5e5bf712983d51fad9f746e34edcbe5342574d45933bba62f48a  bertosebind_new_runs/inputs/current_glycan_sets/glycan_cold_scored_glycans.csv
+7655d9d080df7cb5dc748b7d9721037fbec67c04cf837e4724f0afba7e7a4d71  bertosebind_new_runs/inputs/current_glycan_sets/manifest.json
+08ceef347f61012e0baab4daf1472122dc80335c6ea02fe084098c055a3e3e30  bertosebind_new_runs/inputs/current_glycan_sets/protein_cold_exposure_join.csv
+f35d6088903e993f46adee07806e577456599d9814f4f43e40efdf3d8ddf6c46  bertosebind_new_runs/inputs/current_glycan_sets/protein_cold_scored_glycans.csv
+56d04a5a985d2bd96067e5c1a1e7acd67c5f76ae05c17831bc5949cb6bee26ab  bertosebind_new_runs/package_manifest.json
+924765b90a840277c5ed9dd6594a8ded2d5f7add5b138a9af1adf89bbb46cbcc  bertosebind_new_runs/protocol/amendment_excerpts_20260925_26.md
+04dea299feb3ac0840ff5db7471381ad3f1cf531653bf6aeb9825005236d2f0b  bertosebind_new_runs/protocol/original_20260910.md
+11014b5f0972c23b7225c4202f2254b444109b8105563d968e9c8f4534061ff1  bertosebind_new_runs/provenance/bootstrap_anatomy_audit.json
+d2812e72a7befc1bdb08465189d2fed035ae725142c1cf978a578e0add72e94d  bertosebind_new_runs/provenance/bootstrap_code_audit.json
+d6e36605873c587028c6dab2dde8093c6e4e33df53ebc27f1d6e3c6b4de14991  bertosebind_new_runs/provenance/bootstrap_exact_input_manifest.json
+30a70a1703183b50fa1c10986c065471513981fac1e3e69f9c7ad649aeecb16a  bertosebind_new_runs/provenance/current_pretraining_exposure_audit.json
+ff65b38435040ba2f5987e0c78ecc0fafc4604341b9bc094513d47cb343db023  bertosebind_new_runs/provenance/exposure_portability.patch
+6649cef7a00096ba2981c611a4c6432be93300e3bb439cd543a692cbb40a15af  bertosebind_new_runs/provenance/gifflar_scorer_diff.txt
+7d24cac24a37583fddac7d91c73e22ea6d4a022194ac213ab354f9e9831b1084  bertosebind_new_runs/provenance/protein_gifflar_audit.json
+9d2e628a789a46a69333c24550d2a150166aebed382880c2d0a67fbd43124eaa  bertosebind_new_runs/provenance/protein_gifflar_verified_numbers.json
+4b49c6f8f6c9953cee46ff2f6c47e1bb68692c9b58984973b3d8666648999f62  bertosebind_new_runs/reproduce_summary.py
+99acda4c8365d691c16de3e032e225de05cee38cff063a772bf9eaec2067328f  bertosebind_new_runs/requirements.txt
+0dff08537f0cd5a1ad40562537c48546d3d4f3858a75b2ab2d3729b22a5dfe91  bertosebind_new_runs/results/doubly_cold_anatomy.json
+4186c66c13fd05d62d83a10df2a5761b2e29ded502660c12cb450836f9881496  bertosebind_new_runs/results/doubly_cold_per_assay.csv
+2c494ac1351d4ff63828139eac004c0047dc3259d62fd10334d5a740cab9182f  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_A_glycan_gifflarESM_s43.json
+82173016b893cb2913e90e99feea5f6f4ff22cff9e1aff0fe7dc136161c7f627  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_A_glycan_gifflarESM_s44.json
+ac58a83969a0ffb860cf1a33a472f4cb5b3e14f25097c3ba909f7555f65aa589  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_A_glycan_sweetnetESM_s43.json
+d2d2d73c834a2fcca7b8c22fd6ce91907f18866443628c2c54f8b8ec04477803  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_A_glycan_sweetnetESM_s44.json
+7b0a01a1acc7e2ca80a3de9aaab02941942ead519e6661abec6c44c7fa5fd079  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_B_protein_gifflarESM_s43.json
+f2e40d306b767e6949c02304077a08398dc16ac19d08d94937f7dc49abd7cc24  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_B_protein_gifflarESM_s44.json
+e13c8021d6e94b3bd6cb4ef00d7456c182449f57c4b1356256e011805a6efdbf  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_B_protein_sweetnetESM_s43.json
+d274d35c9a0ba25e4597cdb8c01001f4f7ff7760aabfe7c8a00b84a70b74252f  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_B_protein_sweetnetESM_s44.json
+2208056d5303fda27c5b541eed1c6f64cb03de1c10abd2868d4ce55d1bdb475c  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_C_doubly_gifflarESM_s43.json
+c831378d73c3c2c9456be5ff9ff05acc34b64815b056c5df21bef2078a415393  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_C_doubly_gifflarESM_s44.json
+121a30d0de568217e722036cf25ba4ef61128398fde3466fc8b2f60f096722c7  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_C_doubly_sweetnetESM_s43.json
+3d29ac377491db5d952f6066228fe4099f99db0e2fbaa80063ee429fc28e0a28  bertosebind_new_runs/results/gifflar/affinose_gifflar_macro_C_doubly_sweetnetESM_s44.json
+4fd80f7396aa9803602fd62bd82ec3e98e1f937b46e1057cb26ffa56ea6c93f0  bertosebind_new_runs/results/protein_probe.json
+f224aac78366d64d60b86841b11a9694d234e955904112d266de9bbbc4d8af3e  check_release.py
+9acda1420a4df8efc4b73432e517c32a55aa26b4d9c7bb3487e2a565565089e0  code_inventory.tsv
+6d805fd046c5aca89ef531f37950bb73ef15125865c6a841dcc4934ba7932780  docs/DATA_ACCESS.md
+1fa5b83d57f611207e04c88d2190d6cd364833b4c6ec9c0ca35649937ec5f645  docs/QUICKSTART.md
+b5072e437307aedfd1f789b3dc8024498e6c96ffb6f80d06d0f6a08a805d4b00  docs/TRAINING.md
+5f19be94138c38e9f35afa27aeedb514f9421a4e4724ee27c76ec0302487eed3  docs/WEBSITE_INTEGRATION.md
+52263f18a04e465305b49d53a73f9682849fd138fe817d4afb774c48252d869b  docs/reproduction.md
+4008db9ad60a8d97e5bf705cee0da416dd6755eed15ab4882ffa61e04e4299a5  download_assets.py
+b8fe7b4e50ffa4caf7ca9c50742dd279bb4a717b6fad629a24971ceab635b2ab  embed.py
+a46c2c31f02fb0829fbe70a29c4c032b16a1cd5208386c2ecbc9f6c3fc2018bc  examples/glycans.csv
+b4a8c26479a118943646d4baae370c1d0a267fe30c487fbf816a3999b5a4ed03  examples/predictions.csv
+903d14d8bafc9ae2aa968a74ad4b9d31396c598624fe05e2acb1814cb60bd60e  examples/smoke_affinose.py
+ff95ff2a7707940b849a44259cdf356f66dd5b0351faf4e400feac6666afd9af  examples/smoke_models.py
+89b65f9186f2080eab214f1b7389854cd8477124cdc729a428624312fb7a1453  executed/downstream/review_a5_native_checkpoint.py
+1c958427bca7991b8ec091b6f0c8d209fc1ddfaf1aa9e1f96ad22ed5c60b839d  executed/downstream/run_review_native_md_on_terminal4_s42.py
+75d530c95c218fafb25e844865dd3884737d11b23c4cfdc121226549923fecdb  figures/Figure_style.md
+83791502b5e689451ea735a3da108185ad5aed4d861a187b68c622e0b4b3fe69  figures/README.md
+14addd0706d771da818f53b0d17a0248ba496c7e6ceb3850b89cc6573d35ae71  figures/ablation_figure9/README.md
+a2ad6df46618b2e94ecd46fd8a2ca41c8d43556d46f26fd8066a102f42b1404b  figures/ablation_figure9/nature-bpg-palette.json
+179bf3ddb15842c726a90a9cf373c7861409c8f823bae344a0b621fa77ed51f9  figures/ablation_figure9/plot_data.json
+457cfdc37e557c623d23292cfb221b214b9f158ab9ec611576b5553969ce4469  figures/bootstrap_figure13/README.md
+fbddc62114cd214265d12bb11584004988c169731fe66c8faba20d1c871bb876  figures/bootstrap_figure13/build_figure13.py
+6a87e6a8abc926f41ca13b1bb6c81cbf9ea1d04b06e8f39bfdaf847ce55ba235  figures/bootstrap_figure13/inputs/affinose_b4_step3_bootstrap_r2_20260927.json
+a2ad6df46618b2e94ecd46fd8a2ca41c8d43556d46f26fd8066a102f42b1404b  figures/bootstrap_figure13/inputs/nature-bpg-palette.json
+7b14add6ccb6e16d72ab066ae902b77fd15cca4baab69c52015a828c5bc32b35  figures/bootstrap_figure13/inputs/review_affinose_gifflar_seed_welch.csv
+8a5ce609298e83a231895587c64a24bbc535a3887feb157ef2b4934db4355243  figures/bootstrap_figure13/inputs/review_affinose_individual_values.csv
+cd5a299c7b3a21ce8bbd0c445e66b938e497658e9ffe602d562517eb1ce103fd  figures/bootstrap_figure13/inputs/review_affinose_results.csv
+c0957bc56e0694a72289183e7424b49383346e6e55c245b92132c2e77ffc6f9d  figures/bootstrap_figure13/inputs/source_manifest.json
+d734b8076500af5edbd2bedd26f29004fb066725a45c273e35b49a1a711d26b1  figures/build_bpe_figure3.py
+0ceff115647c4921165805fb25fb5ec5451e8ac1264a9140b3db8591f30f66d2  figures/build_corpus_composition_figure.py
+6053ddca0892325752308544a39da61d427de959f6559ab771902b0c30c7c103  figures/build_grey_seal_figure5.py
+90fd5e292872323cf90b2312903f8320731808e382a4798cc033379ebd57e568  figures/build_submission_figures.py
+f112a826a7b210c2700d810c2a62f91d80c0f2e964b141290f0343f648ce8a81  figures/build_supplement_figure1.py
+2b33f563431fc64271f84bebfbf99210e057d4f6d8b4b838316c574aa6bf33b8  figures/build_supplement_presentation.py
+ba1cbfccd6a8f0e029849e9188ae212cfbf9afbc5174d1099970911821c740a1  figures/build_supplementary_figure9.py
+25e648b564e4db77532947bcd432cf82ef15cd08f5676441a21feffadb9eacfa  figures/build_taxonomy_figure11.py
+e964dc2d021382d5950008eceef05d001d640de608b0d86ce37701db5de8379e  figures/build_token_length_figure2.py
+de51e3d170a28a319aed0eaf8f0ee5c1a3b95c59146d0360a3e228c947178a78  figures/build_training_coverage_figure6.py
+dd7f57d15e39df52dfa3a92a1ba3aab7e85c284fabc926cffbcad7876366b852  figures/compact_modalities/README.md
+5d2748b98cf4f4ce9b74b71b8617d98c6d52a7cf3b68b567210727659804b363  figures/compact_modalities/builders/build_figures6_7.py
+000b70258a2b599a326903d9792e11b6bb67adf5ed6730b5fddc416df6cbe7d7  figures/compact_modalities/inputs/figure7_original_provenance.json
+3e96d8092239c2c21f217ad5bae4ee7e07dbe0f7630b213bad468d6b08d3b1c1  figures/compact_modalities/inputs/review_md_temporal_20x6_core_r3.py
+a0096e0a0cd5ac6ade78c6b0ee4b0b0fffc7d2c8969899f26f03134aa63edd8e  figures/compact_modalities/inputs/review_training_modality_coverage.csv
+2373a8e7e2998023e764a4a69dead5f3f3a5cba87743fd8762e31bfb55e03393  figures/contrastive_figure12/README.md
+ed7446d8ab3b4a0258cc031361b93e1613fab438786a81fc1a775b88f6ae3c67  figures/contrastive_figure12/build_figure12.py
+a2ad6df46618b2e94ecd46fd8a2ca41c8d43556d46f26fd8066a102f42b1404b  figures/contrastive_figure12/inputs/nature-bpg-palette.json
+d732e76c28cd3d741fad99636a8937b464f1efa190d26e7005146e6c88b1feb3  figures/contrastive_figure12/inputs/review_contrastive_fit_values.csv
+5bfd6352e60158fe3a09c2a3228a7fffc4926780aa320b5e205ef276db3e4113  figures/contrastive_figure12/inputs/review_contrastive_paired_summary.csv
+dc90a817bc54ac310a73298f60d03fc30eaccd724f4676eb826301dd85470acc  figures/contrastive_figure12/inputs/review_contrastive_taxonomy_summary.csv
+a2ad6df46618b2e94ecd46fd8a2ca41c8d43556d46f26fd8066a102f42b1404b  figures/figure3_inputs/nature-bpg-palette.json
+bd530abacb61f3d6cffda8d1e7e6112f9261fd0a761e594fddceb5c615b9497b  figures/figure3_inputs/partition_count_flow.csv
+918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b  figures/figure3_inputs/review_bpe_vocabulary.json
+c885944b4ebce9b08c99318ce51c81b7648309c49ba5244ad0345b794429f151  figures/figure3_inputs/source_example.json
+8bed92feb2c7ff8f8759e4fa287470336e364764ac7b6fead456840b92b5a5db  figures/final_iar/README.md
+014b0949823ae8691f09efccab38919400282c33e0fd9b6994b39a6fb4ad78dd  figures/final_iar/build_final_iar_figures.py
+259fdc68a39b415c4ec114fbd6872ceaccaf09327d1fde958390071a5a94af2a  figures/final_iar/inputs/baselines_same_cases.csv
+d5b7fd634677ea22ea27670649ea30636ef6c98daedc8592cd3f5d7b56beb9c0  figures/final_iar/inputs/final_iar_summary.json
+50906ea3964a4a7c9744d224c8ffe2d356738d83bc0f5ead05b04ae6c558a64a  figures/final_iar/inputs/iar_recount_and_wilson_intervals.csv
+a2ad6df46618b2e94ecd46fd8a2ca41c8d43556d46f26fd8066a102f42b1404b  figures/final_iar/inputs/nature-bpg-palette.json
+0aa0dc0fb74388a72750578acdf9beafba917a1976059c813157a90eceae3419  figures/final_iar/inputs/run_manifest.json
+61136a3d00e0184db8fbf4db47fa480766e7dadbb4f81d278df27b1fd0a0613c  figures/model_variants_figure10/README.md
+d88d4db86071e94d9012f0062696920c2c44a9a15a66e3f152826943234aac0c  figures/model_variants_figure10/build_model_variants_figure10.py
+53fdfc11a75e3aaf39b78a9c59d90e206b0726579440d03df2d5cb5708249ebf  figures/model_variants_figure10/inputs/review_weight_policy_ranks.csv
+9b35cb9ab5056c0548eea944f8472906a8cb36e2a7adf5cf3135268c675619b7  figures/model_variants_figure10/inputs/review_weight_policy_sensitivity.csv
+dd96f6ec2247a918a89873dd031be5f738bcd870056e9b98cb7a1e2c85e158e8  figures/taxonomy_figure11/README.md
+a2ad6df46618b2e94ecd46fd8a2ca41c8d43556d46f26fd8066a102f42b1404b  figures/taxonomy_figure11/nature-bpg-palette.json
+04670f06e3459608d7a43da767531544421d4da1a6125376edc3939dba951d1f  iar_completion/README.md
+8f7e1027e67222d49eb9e3c12fcdff083005d182583990c08c54b7ac3c11040e  iar_completion/SHA256SUMS
+a03990a02a1737de05a7fa1739164e84fa6a0a4170ebaa65317a9f3c2f16c0b0  iar_completion/assets/linkage_readout.pt
+37514cb79322719772b5c14a5795f00a78f3275f3315d5b3b674ee97127ca953  iar_completion/check_package.py
+bbf016ce2f1a7dc82940be28397cbe8083da7ad0f5f525b1cf7345fd42a5758d  iar_completion/model_metadata.json
+d406620e3b0c070dff4d6fb6e0c57effce848a9ca5b3dc3de705d65c49ac0961  iar_completion/originals/run_all_training.sbatch
+5acafc45244a0bf9a8489794f8a39f956622cf50594d87eb2eaa04502589fcb5  iar_completion/originals/wa3_final_iar_readout.py
+72f8583bf32799ba29c09829d138900c0cbb589f73bd278f389da6fa8a786730  iar_completion/originals/wa3_final_iar_readout_all.py
+679499406106611dc2c70240a3c14c9b94311bc03a7811d3dae807c58aef4ef8  iar_completion/originals/wa3_linkage_diagnosis.py
+0ebc629778c854621f485ceb4f5f11090e84ac9171d52270fcc90b6b07d6fe7f  iar_completion/originals/wa3_linkage_probe.py
+0da5f24799afc8978b88c85ea7856deb8c641ebae319760e88539c93a4eb3a86  iar_completion/originals/wa3_same_test.py
+c6e9506dbf97752aa248e325e75acf3abf63495054bcac68d48602967379531d  iar_completion/originals/wa3_typed_strict_test.py
+1341b0051fefaf54b4113d7dda5e408540844d12a9275f9a73607c416f35928d  iar_completion/originals/wa3_typed_test.py
+259fdc68a39b415c4ec114fbd6872ceaccaf09327d1fde958390071a5a94af2a  iar_completion/provenance/final_run/baselines_same_cases.csv
+d5b7fd634677ea22ea27670649ea30636ef6c98daedc8592cd3f5d7b56beb9c0  iar_completion/provenance/final_run/final_iar_summary.json
+0aa0dc0fb74388a72750578acdf9beafba917a1976059c813157a90eceae3419  iar_completion/provenance/final_run/run_manifest.json
+a615d9a889c7a62c19d05a4d07d66d9e743fbfb9e37e4d646c889490d297e492  iar_completion/provenance/heldout_masking_wa3_final_iar_readout_20260926_run_manifest.json
+0aa0dc0fb74388a72750578acdf9beafba917a1976059c813157a90eceae3419  iar_completion/provenance/heldout_masking_wa3_final_iar_readout_all_20260927_run_manifest.json
+933ef4d07c380bd4322814acff135e207e00db36197c3dc543214b24cb5d554e  iar_completion/provenance/heldout_masking_wa3_linkage_diagnosis_20260925_run_manifest.json
+3f713f4e074cbb068264173a8fb0ec99813665ad1b23fdea507f7389071cb04b  iar_completion/provenance/heldout_masking_wa3_same_test_run_manifest.json
+b3cf90dc772f206dc386a3a92d96e43d7a6c1de4147bc7cc501599730d31807f  iar_completion/provenance/heldout_masking_wa3_typed_20260924_run_manifest.json
+4a13b9faecc329257c2aa08fd6734a8b6c02837d0b230b0f659fd00602832c75  iar_completion/provenance/heldout_masking_wa3_typed_strict_20260925_run_manifest.json
+9c957fe6b76da503c909ac4e3a0d70cf4ea1fd6da34a3aa6573bac4722d4c62d  iar_completion/provenance/local_checks.json
+8af8ed8b6124f26072d6041deb0e6966c13c149926f5bd720b714884cba6801e  iar_completion/provenance/required_input_hashes.json
+2cb3a3f4e8b1d37dd3ad0234996d546f34ab48231bf69247ffb6ace0651a4a69  iar_completion/provenance/source_inventory.json
+42464d76c743a302bae79ced6b09af9657444c6f977535b5de49dcf59a5a8a90  iar_completion/readout.py
+9ef74c17ef3ffacde3f0fc862f9844757bacfffa55b3ac9e7e6a6cca43f5843c  iar_completion/requirements.txt
+3392850a98f1739e3eec8434f42c26f3fad2d3da9fc815a17dd2790aa3b0ff98  iar_completion/runtime_dependencies.json
+a791b8f4bbda75317f41afb34d62fe518448f4d5d90db0b852e2b0d0af5e83a6  iar_completion/runtime_snapshot/java/review_A5WurcsArrayTreeAudit.java
+bc38e44e66daed7ec04f7c7907a13509aac125a8a09c97d9972725ab4278edaf  iar_completion/runtime_snapshot/java/review_MolWURCS.jar
+5449f9276a7b952adf087468c874bb13c7295062cce7d1afb13fdea78ace7f37  iar_completion/runtime_snapshot/java/review_wurcsframework-1.3.1.jar
+0bc54399362945601bcfd403441fc80968d173200dd0561f57568b2053a94839  iar_completion/runtime_snapshot/project/bert_training_v4/downstream_tasks/utils/wurcs_bpe_tokenizer.py
+c68cd003370b2dcdb162f848f766e4e62f2653c6c38d205f8cbe53a9aabe2d74  iar_completion/runtime_snapshot/project/data/bpe_ambiguity_tokens.json
+6a572afdf53f1494ab96c896876b824ca7ea749777352606aa9f96bf270ceecc  iar_completion/runtime_snapshot/project/data/bpe_vocabulary_clean.json
+22d2aad45b978988c9e26bc9400016014ee825cc6207377385a8cd74f3c88f2b  iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_ambiguity_tokens.json
+918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b  iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json
+10ca4b121d2f22d7a64208e4f05172e7a756b653d0828c9dcc49dd8ea1a5ad04  iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_sequence_tree_runtime.py
+f48ba266abf30a7a1298dea747676da64d53acef4ef02cba7ac8f16509460fc7  iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_topology.py
+6591b854962c278dc797981c942e114c18a26e97af43029c1d539bae3badb2f4  iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_wurcs_bpe.py
+de8c3237b858b640ee9fbf4dac34864c54b6dac80bc89f346a44c774254289a4  iar_completion/runtime_snapshot/project/writing/cluster/nature_submission/code/model/__init__.py
+b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb  iar_completion/runtime_snapshot/project/writing/cluster/nature_submission/code/model/glycan_bert.py
+8e06c32f4e844c3c66f146fd15a075472808a0720c892d0b9683dfd32f15ef0c  iar_completion/runtime_snapshot/project/writing/cluster/nature_submission/code/model/multimodal_glycan_bert_v3.py
+f0c8efda7a12942b4c6359792d6ee9417e6a9ec0eb04623ad17b4772430270b5  iar_completion/runtime_snapshot/project/writing/cluster/nature_submission/code/training/ipa_bpe_distillation.py
+8d05a4048e200625694ff9a36f50af89b845fd0d38ba8034a97a710e7ad3dce2  iar_completion/runtime_snapshot/project/writing/glycangt_heldout_ipa_validation/cluster/heldout_ipa_eval.py
+cfce20d28291c8b5868d35386990037415090202dd823bdfd73038456cc65557  iar_completion/runtime_snapshot/schema/classify.py
+704ed130bdcce94a7af7ce3e37654705f709b8526f632907ef794451c6ef7f30  iar_completion/runtime_snapshot/schema/pipelib.py
+be4b51d806c364f6aa88119d17d71674b8313dde8a35c82099ca755a5c46e0b6  iar_inference/README.md
+1d21cb72f1cc7d5a094a5fb5f0ec11a6072df996f0975cc39569ed9964daee1c  iar_inference/SHA256SUMS
+043a38744f9fd832181d822ae8481488d954604bf615b2eb05c4c8ad29794325  iar_inference/config.json
+a212cfbd49ec2f951e942c92caaac63260687a626eca588cb692d86bb1e52198  iar_inference/fixtures/case0_pre_sequence_head.npy
+6ffca438526432a33168a85a0fee1158fd2a9c9f23ecb97f587235f204ae50b3  iar_inference/fixtures/case1_pre_sequence_head.npy
+60ac0c0fd1b6e0ada2d847d1fccff4f6fe7c085aab3146247dc5d7bfebbabc27  iar_inference/fixtures/rebuilt_two_case_inputs.json
+60dcdb6262457962da84c7b239c194fac343bd8d27db0e05f15906acb9bf5f4b  iar_inference/fixtures/reference_smoke_report.json
+9237b349668ea3fb5266f4696169fd958e9f997e5064ede0ab06e41859b17361  iar_inference/infer.py
+87fa484e1f6105fa476dff4cf8c7e6aea71a2aac537796131a4858632f54b906  iar_inference/original_inference_helpers.py
+4e36f9237dc494eb47898ff3ab9a5b1a483f5004aa933a5294af794edd0757ce  iar_inference/preparation_validation.json
+16e89b25a13eabc8586ba2a8ec32890ecf321f652b03f7548c63112d13cb2e62  iar_inference/requirements.txt
+144e09f44c6cc2c09df0fafefb2c3975c590ae684756500fae9b6a589767574c  notebooks/BERTose_workbench.ipynb
+a4b66d2ed429ad6516646256a84173082b2fca6b779baa6e4ff93586a81a5c2b  provenance/WA3_checkpoint_index.json
+b8b05510e97f6b94ca5e0d1465eba034724d7ddcc405aa405db09c4c29fc768b  provenance/WA3_final_receipt.json
+670cfcbcfe89e0729bb75f122cff8c7100c24d39ef775c69421d4bb820654056  provenance/affinose_arms_on_test_20260909.json
+a291a8e8f2b77c7955b5346aa52289afc520a0b5181d62eb0dfa2c096bd6bbb8  provenance/affinose_cells/affinose_mo_20260908_mo_A_glycan_s42/receipt.json
+fdd520b70e38d0e6bc112118adad89cf209278614645b47e219341736bf99599  provenance/affinose_cells/affinose_mo_20260908_mo_A_glycan_s42/results.json
+29b68fb30127700fa55942d5cc4c237f8bf15c2d0c883192b62698d811e71c51  provenance/affinose_cells/affinose_mo_20260908_mo_C_doubly_s42/receipt.json
+54918a535b86b01590bab11c78ff4c354c106ca78a384446eb79038b0df666af  provenance/affinose_cells/affinose_mo_20260908_mo_C_doubly_s42/results.json
+a380534df6f877c212a2c7dbce577511e282537bbff9ad5d7ac3e186f1cc5633  provenance/affinose_cells/affinose_mof_20260909_mof_B_protein_s43/receipt.json
+a732a56ddc81fc41b02dde8f56d852929ec8eefa12524ed9410a09361f267544  provenance/affinose_cells/affinose_mof_20260909_mof_B_protein_s43/results.json
+9344a727416db1368c45a0ddad962a12130e10f03944a5142874f72ba5311297  provenance/affinose_cells/affinose_mof_20260909_mof_B_protein_s44/receipt.json
+a530b2fac81a72d99674906253897a1e3eecca4ee17e83c3a27ed409a3411877  provenance/affinose_cells/affinose_mof_20260909_mof_B_protein_s44/results.json
+068bb72cc2fc0231f3a9f729ac78f1a6340a7088ea86a60449ebe63dcfbd794d  provenance/affinose_cells/affinose_mof_20260909_mof_C_doubly_s43/receipt.json
+a21307bb48db62270792f990541bac1c2728feb34063f4b2009e2f6c7d8a7e4c  provenance/affinose_cells/affinose_mof_20260909_mof_C_doubly_s43/results.json
+3044b56619b1bb83063070624b02bfaa64c952c1da76a80051bb62bb26098395  provenance/affinose_cells/affinose_mof_20260909_mof_C_doubly_s44/receipt.json
+42ffeb2f81acbae80df3284300d0213b52918b90d3b186dbbd1f074800af75f0  provenance/affinose_cells/affinose_mof_20260909_mof_C_doubly_s44/results.json
+07a919272c928f9630f4d70a73cf1aa91a327e2c9597cf582814c5386b6f24cc  provenance/affinose_cells/affinose_sa_20260908_mo_B_protein_s42/receipt.json
+ef5a0b42f15f23a473d46198bd39dc17176add75a1bf76cd708d5b595d552b6e  provenance/affinose_cells/affinose_sa_20260908_mo_B_protein_s42/results.json
+c3e3028a05cf7f5b58883d9485bcd7a7e0ba5d05265f4503b8bad09e307c1480  provenance/affinose_cells/affinose_sa_20260908_moc_A_glycan_s43/receipt.json
+f62ddffaffae54f91e4f921fa235741df4023e94b47c2c90f3e158b7c4cd9858  provenance/affinose_cells/affinose_sa_20260908_moc_A_glycan_s43/results.json
+6f5cbc9e19a45b4e9c8d33e7f4a82e41ef610b5040175852d3c05ea172995d4f  provenance/affinose_cells/affinose_sa_20260908_moc_A_glycan_s44/receipt.json
+9f0a6dc5b89f58603fb368e754da90001a987016ed4d9ab425420703aeb44d9e  provenance/affinose_cells/affinose_sa_20260908_moc_A_glycan_s44/results.json
+f4fb099a7dbe229450d2ca337d213555203dc69dd67f1e4b2cca227baca3d701  provenance/affinose_input_hashes_moA_glycan_20260908.json
+00c53175abc949336bf495c796dc9c779af2109227bc6f351433356129d85663  provenance/affinose_input_hashes_moB_protein_20260908.json
+3d3c6fd5c39fe2f1ce37ce5ba47b842fa193b716c08227678d68cdcc7e996c4e  provenance/affinose_input_hashes_moC_doubly_20260908.json
+ebf5e35b60640944bf3d03955f10da2c40cd5075a85bf0e3a4c6210f97ed85a6  provenance/affinose_recipe.json
+9c14d2981a11bef92ef230e9848f9876d941b290f2c70848e739a2795bb6feea  provenance/artifact_locations.tsv
+4dfa51299e99a23add6cdfe5380403d4504a207e2b6522ea86cc50ba1cd2cb74  provenance/candidate_affinose_input_hashes_moA_glycan_20260908.json
+48768c773a262864e7a5104732d1e37971be2581058dec7e6f8778d05483965c  provenance/candidate_affinose_input_hashes_moB_protein_20260908.json
+efbfbea3df98ff7b20dadae530aaf5e3cdadc7216a60a97495b4344e39ef1934  provenance/candidate_affinose_input_hashes_moC_doubly_20260908.json
+2ce6f4a60fdb0bc87d69e270bd724fbccbfae6239579f3c17c0c4d8de05b3d94  provenance/candidate_portability.patch
+16bed602b94a1a3010f07c2feca3e219035160ab5cc05f4ab202faf57ae1c63c  provenance/copied_sources.json
+967d38d95702e0863eec468dac9de27fee7da60312fc53ba0f95c5b88f381595  provenance/execution_summary.json
+f4cd53bb88fb383677e0f85417662c01a351a954db6df93b6162d0aadda495b0  provenance/local_checks.json
+fc689486dc297277e32480d52d9abb69549520c085101bd406ef3ed6c2fad86b  provenance/local_test_environment.json
+7202cdde019556a7babb3459ae04da8ab5ecb5edbdfde2b74c4a675ed1c9ff43  provenance/moconf_cells.tsv
+e6f1be53ab77ad80ea274f80bd11369bb4efe3836b6119c58283ec12af224752  provenance/mofull_cells.tsv
+67b5ade1b857e789173128939c6baa4687354bb1d640d8fd3b40332b5956ec72  provenance/motif_cells.tsv
+fb75dee7521e1ca381d9b1fd5c7054bb7ba6389dfde61259362ae4d082ba9a7e  provenance/portable_execution_20260930/binding_portable_report.json
+24f61f4291610df9d7ad89a0cc8afb6a472e41b2dab3ef1ca73d852076c073da  provenance/portable_execution_20260930/code_snapshot_manifest.json
+07fee191f75e12c5becd19b3dbe627ff3a9dbcfcdeb0aea770126483bfd0cebb  provenance/portable_execution_20260930/execution_receipt.json
+b51a0f8f5c7b5682e4c432587236bce9daa74e6f2389ccba89b34bcc8c0042cd  provenance/portable_execution_20260930/iar_portable_report.json
+7fb7d9274cc72e65b8a8026256841c9fbcdbbdf82747b319b46b008d4ca4700c  provenance/release_manifest.json
+dc42f4cdd76cc2c49fedfe6b8b8ef40b5915ee70803c9cec5ec0b0573256f815  provenance/score_arms_on_test_historical.py
+e2bad73cbdcc16a2a44f2d6e8230bc55b5a8a484d7553af29e379a12f541bba9  provenance/sequence_variants.json
+6fc928f84838ac82af228d744fadb8be670d631afd5ca84ff84d0847b140d8fd  provenance/submission_README.md
+cf0e33d454260a8fa949a9c5fea60bac6291b84c3db573e48fb1735f3a2a2772  provenance/submission_SHA256SUMS
+80aae521be2bdc5ac2337ea733f7a8ade028f788499d7d44ff1b6e7389639c8d  provenance/submission_code_inventory.tsv
+48da67d3a47fb1155389fccdd9022b825b2eeefb60e28260633ec4c2fe00a33f  provenance/submission_requirements.txt
+05832b5f811b977c09418c79545d8e38c689973b4a91e36a96e20389ac3c0e2c  provenance/third_party_archives.json
+b7cb8a39e167f2cc9e35476dcdcad56320b02c1898d13db3236a41bbb2ed4852  provenance/training_v8_before_resume_load_fix.py
+be8f4ae30ae2fbd8f91de0e5db98de3044213e24587717775c31df37e2272dbb  provenance/wa3_config.json
+881354fe1ef1eb6ae73565a42da2b175a0426f41feb6b3a1d8897c4e048fa012  provenance/workbench_assets.json
+fcbf7a31abd2f468c589feca4111a1d5b851e587046aed53ca0196deb3f39e74  requirements-analysis.txt
+2c69dc6c9b8643afe0e9fbd5f2f355662dc55f2b555f2b096b582065baa2db74  requirements-workbench.txt
+1c89cbdda9d2c1fb7a3df6692f93eb2765f59f64dd3392b8799697f3238a8867  requirements.txt
+428d6c855cd9a6a1988581f9d71bd85a130ceb7b803e6190b3590f5e40ef426c  score_predictions.py
+1a8459fea8d7d35948bd4315d840a0ec6f60e4fcb4823e18d903294f2c1c20d5  structure_md_processing/README.md
+d1c48e285928b5b4e2b84f7748bfeb3360f0c98c8d66ac1651927f849e5384f6  structure_md_processing/SHA256SUMS
+39c6691d762b1ac2d0bed3464b1ed31e4fbe72b18e218ba4a553f3f94702a9e2  structure_md_processing/evidence/review_md_parent_temporal_20x6_v2_summary.json
+823f089df162283c6ed2077d7c8af1cfc49d1f814e58a029b64c2c18a0a075d8  structure_md_processing/extension_checks.json
+2e644b90c80388a169da946a22557e0d6d0f37876334fa5d450f27fce41aebe1  structure_md_processing/independent_qa_20260930.json
+1e15e8a160c1af8e31c490fde35e9177fce583d98157751a852846d1390cb43a  structure_md_processing/input_closure_20260930.json
+0f43a293b4b5edaa76da4c4073a7a221582b064c41375a7de982b09dbfe05642  structure_md_processing/prior_snapshot_20260929.json
+0d967082a8225a1eab98315c2fe7916eff0e863ec04287a43351b757e08f5070  structure_md_processing/project/training/__init__.py
+daae9ee3f3c286e36c7fd7ede37f889eca2a6f9956755717a5bf714645ffa4bb  structure_md_processing/project/training/a5_glycam_chemistry.py
+ee6e3d06fce7316b3622f4ad92d900608eb91af09f3872d0200c1b246158605f  structure_md_processing/project/training/a5_static_alignment.py
+f48ba266abf30a7a1298dea747676da64d53acef4ef02cba7ac8f16509460fc7  structure_md_processing/project/training/a5_topology.py
+d08683664ffe28661becd6bdfd5b6b8169bd430800c3e844218969548d3498a2  structure_md_processing/project/training/masking.py
+ca2be55ece9c15271713f553f619bdd42cf4292c6c9d86e19037db9a73168e28  structure_md_processing/project/training/multimodal_dataset.py
+21ae467f964ea98486ed7efa3f7887194e05c326e4fa92f124e8d5f5570f030c  structure_md_processing/project/training/multimodal_masking.py
+2e3b0a72767fa5e7ca950ada7923faac63e58db53f6969a030e01938a81254ad  structure_md_processing/project/writing/review/glycam_structure/configs/review_md_temporal_20x6_v1_20260801.yaml
+4d668c45f1f17f12b1d4af022d2e1849cec815e24664e8ad9183569fae7f764f  structure_md_processing/project/writing/review/glycam_structure/configs/review_md_temporal_20x9_v1_20260731.yaml
+ddabd88756774a9c75ae93709fafb6b7c2d3cdf0c9b7d5b66fd801d8e2388c76  structure_md_processing/project/writing/review/glycam_structure/scripts/audit_review_md_charge_corrected_exact_roster_20260802_r1.py
+131499356bc91f07ebd1f2f40166c9f756d7e64b49a66ee69d1efa0fcecf9843  structure_md_processing/project/writing/review/glycam_structure/scripts/audit_review_md_parent_feature_package.py
+dacc54f37dc4c816fdf2fb801b13eb239cf42444883ace1dfed2a92b6fc798da  structure_md_processing/project/writing/review/glycam_structure/scripts/audit_review_md_temporal_20x6_r2.py
+2df5009bdcefb49ed7742391d7d6f5f73cf1574fc7d17cd46bd2ad3098331a06  structure_md_processing/project/writing/review/glycam_structure/scripts/build_review_md_parent_feature_package.py
+4bad11cfd69c150f2c50b92856a6ab21641772baa2236b45ca505f5637ea5a0b  structure_md_processing/project/writing/review/glycam_structure/scripts/build_review_md_temporal_20x6_r2.py
+2743e322eccd5c0217b44e3eb6c4dc242d35db7eacf91f235d23f7a846b70dbb  structure_md_processing/project/writing/review/glycam_structure/scripts/build_review_md_temporal_20x9.py
+35108afde036b0f1fbf888014a5afebc45568b45dbdea85a5913c2dba8938127  structure_md_processing/project/writing/review/glycam_structure/scripts/freeze_review_md_temporal_feature_layer.py
+102466ed3bf04ef2cf2ab53b04fdbb9c6e6ea1d16061194f97eed5bedc4e2e2d  structure_md_processing/project/writing/review/glycam_structure/scripts/merge_review_md_charge_corrected_temporal_20x9_r1.py
+47c9d9a448325e59742e30a444b636e888df18cf88f010fdad09e0393f5bf9c9  structure_md_processing/project/writing/review/glycam_structure/scripts/prepare_review_md_charge_corrected_feature_overlay_r1.py
+80c1e2cbf2f2bbf7a19564a7e88d65e2d9dd4a190c33e6b5405dd107d6e553fe  structure_md_processing/project/writing/review/glycam_structure/scripts/review_md_all20_charge_corrected_run_state_r6.py
+dfc5670ad8a146af48abfb381198bacd017ad7dbac4a081bc204d5dbf61cb1cb  structure_md_processing/project/writing/review/glycam_structure/scripts/review_md_wiley_pca_corpus.py
+b9f20eef44858866d95338a6f5dedebf253d8e827890d10806ce7d0045b14594  structure_md_processing/project/writing/review/glycam_structure/scripts/review_md_wiley_pca_pilot.py
+39f9ddfd0e91c3afc1c3b6085689f8bed7bf585446128be634ab97369a79869b  structure_md_processing/project/writing/review/glycam_structure/scripts/review_md_wiley_structural_extension.py
+163c93827dc18dd281d8e5a6ceb8b106a02b00e3366442ee09fd0e1b477262e8  structure_md_processing/project/writing/review/glycam_structure/scripts/review_md_wiley_torsion_pca_corpus.py
+3cb1b2ea38fef04ba9ba2b01ef1944f69a48fb5dcfd4d8011684de9ddaa10ca7  structure_md_processing/project/writing/review/glycam_structure/scripts/run_review_md_charge_corrected_feature_stage_20260802_r1.sh
+21ffbc09d34291adc6d2a3535ef142014d1d31ea8a28002fee23af29b88f415a  structure_md_processing/project/writing/review/glycam_structure/scripts/slurm_freeze_review_md_temporal_feature_layer_20260801.sh
+bf3ef76494d936044615b59e0941f3b6fb35a935d6743abb5c035995b61a63d5  structure_md_processing/project/writing/review/glycam_structure/scripts/slurm_review_md_parent_feature_package_20260731.sh
+b8e953947b4ac55e1cd9d509c33e1bddf211f046b9124ddc175166a1a763b31a  structure_md_processing/project/writing/review/multimodal/outputs/p1_a5_static_role_successor_cascade_20260720_r1/review_a5_static_role_successor_cascade_receipt.json
+ffbbe2126eb6131ab8b64ab5809b79b29e5534785cbe6fcfe1bba04b93e06050  structure_md_processing/project/writing/review/multimodal/outputs/review_a5_static_glycam_template_registry_20260721_r2/review_a5_static_glycam_template_registry_r2.json
+6bba07e7da9284af46b97f80c25c7e1dc332facf452e0fd2140a975b7c1e496b  structure_md_processing/project/writing/review/multimodal/outputs/review_a5_static_glycam_template_registry_20260721_r2/review_a5_static_glycam_template_registry_receipt_r2.json
+da8d6dab478ace650fa5af3e99c72dedaf65a6cbc2bf62373fa2082bef748cea  structure_md_processing/project/writing/review/multimodal/runtime/a5_static_v2_20260721_r7/review_a5_static_graph_materializer_r7.py
+12fd869f52759168e0f3ff3243ac7dcdb36c0b067d83e24931c185c67fc80c26  structure_md_processing/project/writing/review/multimodal/scripts/build_review_a5_static_graph_v2_20260721_r7.py
+8da3a60c3d205f9a56f3a97842f3c05e647d3f89ad56c91d431eb75ede49c9ff  structure_md_processing/source_manifest.json
+28c3941d1ae7ebc86296a4ac7117c27a1d4bcaa0ec6c56ea8cfd18fade1bb7a2  test_bertose_workbench.py

releases/2026-10-02/affinose/a1111_encoder_adapter.py

@@ -0,0 +1,144 @@
+"""Load an A1111 / WA-lineage BERTose checkpoint as an Affinose glycan encoder.
+
+The a5/md20x6 lineage (A1111, WA1-WA5) stores its sequence tower under different
+module names and a different vocabulary from the submitted-era v5b checkpoint that
+`bertint_v8.load_bertose_encoder()` expects.  This adapter renames the 209 sequence
+tensors and resizes the two structural embedding tables so the tower loads STRICTLY.
+
+Verified 2026-08-19 against
+  review_md_temporal_20x6_a1111_recovery_20260806_r1/.../A1111_seed43/
+    review_checkpoints/review_md20x6_checkpoint_best.pt
+-> 209 remapped / 209 expected, 0 missing, 0 unexpected, 0 shape mismatch.
+
+WHY STRICT MATTERS.  The submitted Affinose shipped an encoder that was 95% random:
+`bertint_v8.py` assigned the pretrained tower and then called
+`self.apply(self._init_weights)`, which silently reset it.  `load_state_dict(...,
+strict=False)` hid the damage.  Every load here is strict, and
+`assert_pretrained()` is the tensor-level gate that would have caught it.
+
+NAME MAPPING (both levels verified against the checkpoints, not guessed):
+
+  sequence_embeddings.*        -> seq_embeddings.*
+  sequence_layers.*            -> seq_layers.*
+  convolution_projection       -> conv_proj
+  convolutions.N               -> conv_layers.N
+  input_norm    (embeddings)   -> LayerNorm      (pre-conv normalisation)
+  output_norm   (embeddings)   -> conv_norm      (post-conv residual merge)
+  attention_norm (layers)      -> attention_layer_norm
+  output_norm    (layers)      -> output_layer_norm
+
+TRAP: `output_norm` means DIFFERENT things at the two levels — `conv_norm` inside
+the embeddings module, `output_layer_norm` inside a transformer layer.  The remap is
+therefore prefix-scoped.  Mapping it uniformly silently corrupts the encoder.
+
+NOT HANDLED HERE — the caller must supply data tokenized under the A1111 vocabulary
+(2,114 tokens; only the 10 special tokens share IDs with Affinose's 2,090-token
+vocabulary), with branch depths in [0, 203) and linkage types in [0, 10).
+"""
+
+from __future__ import annotations
+
+import math
+import torch
+import torch.nn as nn
+
+A1111_VOCAB_SIZE = 2114
+A1111_MAX_BRANCH_DEPTH = 203
+A1111_NUM_LINKAGE_TYPES = 10
+EXPECTED_ENCODER_TENSORS = 209
+
+
+def remap_key(key: str) -> str | None:
+    """Return the Affinose-side key for an a5-lineage key, or None if not encoder."""
+    if key.startswith("sequence_embeddings."):
+        s = key[len("sequence_embeddings."):]
+        s = s.replace("convolution_projection", "conv_proj")
+        s = s.replace("convolutions.", "conv_layers.")
+        if s.startswith("input_norm"):
+            s = s.replace("input_norm", "LayerNorm", 1)
+        elif s.startswith("output_norm"):
+            s = s.replace("output_norm", "conv_norm", 1)
+        return "seq_embeddings." + s
+    if key.startswith("sequence_layers."):
+        s = key[len("sequence_layers."):]
+        s = s.replace("attention_norm", "attention_layer_norm")
+        s = s.replace(".output_norm", ".output_layer_norm")
+        return "seq_layers." + s
+    return None
+
+
+def assert_pretrained(seq_layers, tol: float = 1e-4) -> None:
+    """Fail loudly if any layer is still at pristine Xavier init.
+
+    An untrained nn.Linear sits EXACTLY at its xavier_uniform bound with a zero
+    bias; a trained one does not.  This is the check that would have caught the
+    original 198-of-209 wipe.
+    """
+    for i, layer in enumerate(seq_layers):
+        w = layer.attention.query.weight.data
+        bound = math.sqrt(6.0 / (w.shape[0] + w.shape[1]))
+        ratio = w.abs().max().item() / bound
+        bias_zero = bool((layer.attention.query.bias.data == 0).all())
+        if abs(ratio - 1.0) < tol and bias_zero:
+            raise RuntimeError(
+                f"seq_layers[{i}] is at pristine Xavier init (max/bound={ratio:.6f}, "
+                "bias all zero) — pretrained weights were NOT loaded or were "
+                "overwritten after loading."
+            )
+
+
+def load_a1111_encoder(checkpoint_path: str, freeze_layers: int = 4):
+    """Return (config, seq_embeddings, seq_layers) from an A1111/WA checkpoint."""
+    from model.multimodal_glycan_bert_v3 import (
+        MultimodalGlycanBERT,
+        MultimodalGlycanBERTConfig,
+    )
+
+    ckpt = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+    state = ckpt.get("model_state", ckpt.get("model_state_dict", ckpt))
+
+    src = {}
+    for k, v in state.items():
+        nk = remap_key(k)
+        if nk is not None:
+            src[nk] = v
+    if len(src) != EXPECTED_ENCODER_TENSORS:
+        raise RuntimeError(
+            f"expected {EXPECTED_ENCODER_TENSORS} encoder tensors, remapped {len(src)}"
+        )
+
+    vocab = src["seq_embeddings.token_embeddings.weight"].shape[0]
+    max_pos = src["seq_embeddings.position_embeddings.weight"].shape[0]
+    config = MultimodalGlycanBERTConfig(
+        seq_vocab_size=vocab, seq_max_length=max_pos, use_cnn_frontend=True
+    )
+    model = MultimodalGlycanBERT(config)
+
+    # MultimodalGlycanBERTConfig.to_seq_config() drops max_branch_depth /
+    # num_linkage_types, so the tables build at the v5b defaults (8, 9).  Resize
+    # them here rather than patching the shared model file, which other lanes use.
+    hidden = model.seq_embeddings.branch_embeddings.weight.shape[1]
+    n_branch = src["seq_embeddings.branch_embeddings.weight"].shape[0]
+    n_link = src["seq_embeddings.linkage_embeddings.weight"].shape[0]
+    model.seq_embeddings.branch_embeddings = nn.Embedding(n_branch, hidden)
+    model.seq_embeddings.linkage_embeddings = nn.Embedding(n_link, hidden)
+
+    model.seq_embeddings.load_state_dict(
+        {k[len("seq_embeddings."):]: v for k, v in src.items()
+         if k.startswith("seq_embeddings.")}, strict=True)
+    model.seq_layers.load_state_dict(
+        {k[len("seq_layers."):]: v for k, v in src.items()
+         if k.startswith("seq_layers.")}, strict=True)
+
+    seq_embeddings, seq_layers = model.seq_embeddings, model.seq_layers
+    assert_pretrained(seq_layers)          # gate BEFORE any freezing
+    print(f"  [A1111] strict-loaded {len(src)}/{EXPECTED_ENCODER_TENSORS} encoder "
+          f"tensors (vocab {vocab}, branch {n_branch}, linkage {n_link})")
+
+    for p in seq_embeddings.parameters():
+        p.requires_grad = False
+    for i in range(min(freeze_layers, len(seq_layers))):
+        for p in seq_layers[i].parameters():
+            p.requires_grad = False
+
+    return config, seq_embeddings, seq_layers

releases/2026-10-02/affinose/a5_tokenizer_shim.py

@@ -0,0 +1,72 @@
+"""Import the frozen a5 BPE tokenizer without editing its sha-bound source files.
+
+The A1111 tokenizer ships as read-only, sha256-pinned source inside the corpus
+package.  Its module names do not match its filenames:
+
+    review_frozen_training_a5_wurcs_bpe.py   ->  training.a5_wurcs_bpe
+    review_frozen_training_a5_topology.py    ->  training.a5_topology
+    review_frozen_sequence_tree_runtime.py   ->  (consumer, imports the two above)
+
+and it imports them as `from .a5_topology import ...` / `from training.a5_topology
+import ...`.  Editing the files is not permitted (read-only, sha-bound), so this
+registers them in sys.modules under the names the frozen code expects.
+
+Nothing is written; the frozen bytes are loaded exactly as-is.
+"""
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+V31_ROOT = Path(__file__).resolve().parents[1] / "bertose_source"
+A5_PKG = V31_ROOT / "data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1"
+
+_FILES = {
+    "a5_topology": "review_frozen_training_a5_topology.py",
+    "a5_wurcs_bpe": "review_frozen_training_a5_wurcs_bpe.py",
+    "sequence_tree_runtime": "review_frozen_sequence_tree_runtime.py",
+}
+
+
+def _load(mod_name: str, path: Path, package: str):
+    spec = importlib.util.spec_from_file_location(mod_name, path)
+    mod = importlib.util.module_from_spec(spec)
+    mod.__package__ = package
+    sys.modules[mod_name] = mod
+    return mod, spec
+
+
+# The frozen BPE module does:
+#     try:    from bert_training_v4.downstream_tasks.utils.wurcs_bpe_tokenizer import ...
+#     except ImportError:  from ..bert_training_v4...  (needs a 2-level parent package)
+# Putting the v3.1 root on sys.path lets the ABSOLUTE first branch resolve, so the
+# awkward relative fallback never executes.
+
+
+
+def install(pkg_dir: Path = A5_PKG):
+    """Register the frozen modules under `training.*` and return the namespace."""
+    if str(V31_ROOT) not in sys.path:
+        sys.path.insert(0, str(V31_ROOT))
+    if "training" not in sys.modules:
+        pkg = types.ModuleType("training")
+        pkg.__path__ = [str(pkg_dir)]
+        sys.modules["training"] = pkg
+    pkg = sys.modules["training"]
+
+    loaded = {}
+    # a5_topology has no intra-package imports, so it must be executed first.
+    for short in ("a5_topology", "a5_wurcs_bpe", "sequence_tree_runtime"):
+        fname = _FILES[short]
+        full = f"training.{short}"
+        if full in sys.modules:
+            loaded[short] = sys.modules[full]
+            continue
+        mod, spec = _load(full, pkg_dir / fname, "training")
+        sys.modules[short] = mod          # satisfy bare `import a5_topology` too
+        spec.loader.exec_module(mod)
+        setattr(pkg, short, mod)
+        loaded[short] = mod
+    return loaded

releases/2026-10-02/affinose/bertint_v8.py

@@ -0,0 +1,969 @@
+"""
+Bertint V8 — Cross-Attention + Live Bertose Finetuning
+
+Architecture:
+  GLYCAN:  WURCS → BPE → Bertose (live, freeze layers 0-3) → [B, Lg, 768]
+                                                                ↓ proj(768→512)
+  PROTEIN: precomputed ESM-C → [B, Lp, 960]                    ↓
+                                 ↓ proj(960→512)                ↓
+           2× CrossAttentionBlock(d=512, 8 heads, FFN=1024)     ↓
+                                 ↓                              ↓
+           SHARED mask-aware SWE(d=512, S=512, R=64)            ↓
+                                 ↓                              ↓
+           [B, 512]              [B, 512]
+                      ↓ element-wise product + sum
+                      [B, 1024]
+                      ↓ MLP → binding score
+
+Key changes from V7:
+  - Per-residue protein embeddings (not mean-pooled) for cross-attention
+  - CrossAttentionBlock: glycan tokens attend to protein residues and vice versa
+  - SWE pooling: variable-length → fixed-length (mask-aware, differentiable)
+  - Product + sum interaction (from Twin Peaks) instead of concat
+
+Key changes from V3:
+  - Live Bertose forward pass (not frozen precomputed embeddings)
+  - ESM-C 300M (960-dim, not ESM-C 600M 1152-dim)
+
+SWE, CrossAttention, and mask handling ported from V3 (Sessions 5-10).
+"""
+
+import sys
+import math
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+# ============================================================================
+# Bertose model imports (same as V7)
+# ============================================================================
+BERTOSE_ROOT = Path(__file__).resolve().parents[1] / "bertose_source"
+
+
+def _ensure_bertose_imports():
+    """Add Bertose source directories to sys.path if not already present."""
+    roots = [
+        str(BERTOSE_ROOT),
+        str(BERTOSE_ROOT / "bert_training_v4"),
+    ]
+    for root in roots:
+        if root not in sys.path:
+            sys.path.insert(0, root)
+
+
+def load_bertose_config():
+    """Create Bertose config matching the V5b checkpoint."""
+    _ensure_bertose_imports()
+    from model.multimodal_glycan_bert_v3 import MultimodalGlycanBERTConfig
+
+    return MultimodalGlycanBERTConfig(
+        seq_vocab_size=2200,
+        use_cnn_frontend=True,
+    )
+
+
+def load_bertose_encoder(
+    checkpoint_path: str, freeze_layers: int = 4
+):
+    """
+    Load Bertose sequence encoder with pretrained weights.
+
+    Args:
+        checkpoint_path: Path to pretrained Bertose checkpoint.
+        freeze_layers: Number of transformer layers to freeze (0-indexed).
+
+    Returns:
+        Tuple of (bertose_config, seq_embeddings, seq_layers).
+    """
+    _ensure_bertose_imports()
+    from model.multimodal_glycan_bert_v3 import (
+        MultimodalGlycanBERT,
+        MultimodalGlycanBERTConfig,
+    )
+
+    # Load checkpoint
+    # A1111 PORT 2026-08-19: the a5/md20x6 lineage stores its sequence tower under
+    # different module names and a 2,114-token vocabulary. Delegate to the adapter,
+    # which renames the 209 tensors and STRICT-loads them. Verified bit-exact against
+    # A1111's native ExactSequenceEmbeddings/EncoderLayer (max|diff| = 0.0).
+    import a5_tokenizer_shim as _shim  # noqa: F401  (registers frozen a5 modules)
+    from a1111_encoder_adapter import load_a1111_encoder as _load_a1111
+    _probe = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
+    if "model_state" in _probe and any(
+        k.startswith("sequence_embeddings.") for k in _probe["model_state"]
+    ):
+        del _probe
+        return _load_a1111(checkpoint_path, freeze_layers=freeze_layers)
+    del _probe
+
+    ckpt = torch.load(checkpoint_path, map_location="cpu")
+    state_dict = ckpt.get("model_state_dict", ckpt)
+
+    # Infer vocab size and max position embeddings from checkpoint
+    vocab_size = state_dict["seq_embeddings.token_embeddings.weight"].shape[0]
+    max_pos = state_dict["seq_embeddings.position_embeddings.weight"].shape[0]
+    config = MultimodalGlycanBERTConfig(
+        seq_vocab_size=vocab_size,
+        seq_max_length=max_pos,
+        use_cnn_frontend=True,
+    )
+
+    # Instantiate full model, then extract sequence encoder
+    model = MultimodalGlycanBERT(config)
+    missing, unexpected = model.load_state_dict(state_dict, strict=False)
+    loaded = len(state_dict) - len(unexpected)
+    print(f"  Loaded {loaded}/{len(state_dict)} pretrained weight tensors")
+    print(f"  ({len(missing)} missing in checkpoint, {len(unexpected)} unexpected)")
+
+    seq_embeddings = model.seq_embeddings
+    seq_layers = model.seq_layers
+
+    # Freeze embedding layer + first N transformer layers
+    for param in seq_embeddings.parameters():
+        param.requires_grad = False
+    for i in range(min(freeze_layers, len(seq_layers))):
+        for param in seq_layers[i].parameters():
+            param.requires_grad = False
+
+    trainable = sum(
+        p.numel() for p in seq_embeddings.parameters() if p.requires_grad
+    )
+    trainable += sum(
+        p.numel()
+        for layer in seq_layers
+        for p in layer.parameters()
+        if p.requires_grad
+    )
+    total = sum(p.numel() for p in seq_embeddings.parameters())
+    total += sum(
+        p.numel() for layer in seq_layers for p in layer.parameters()
+    )
+    print(
+        f"  Bertose encoder: {total:,} params total, "
+        f"{trainable:,} trainable (frozen layers 0-{freeze_layers - 1})"
+    )
+
+    return config, seq_embeddings, seq_layers
+
+
+# ============================================================================
+# Differentiable Interpolation (from V3, Sessions 5-6)
+# ============================================================================
+
+
+def differentiable_interp1d(
+    x: torch.Tensor, y: torch.Tensor, xnew: torch.Tensor
+) -> torch.Tensor:
+    """
+    Fully differentiable 1D linear interpolation.
+
+    Gradients flow through y (values) back to theta projection and
+    earlier layers. The original Interp1d.backward from Twin Peaks
+    only returned gradients for xnew (query coords), NOT for y —
+    killing 83% of gradient flow. Fixed in Session 5.
+
+    Args:
+        x: [B, N] sorted input coordinates (detached)
+        y: [B, N] values at x positions (REQUIRES grad flow!)
+        xnew: [B, R] query coordinates
+
+    Returns:
+        [B, R] interpolated values
+    """
+    n_pts = x.shape[1]
+
+    # Find interpolation indices
+    ind = torch.searchsorted(
+        x.contiguous().detach(), xnew.contiguous().detach()
+    )
+    ind = ind.clamp(1, n_pts - 1)
+
+    # Gather neighbor values — preserves gradient flow through y
+    x_lo = torch.gather(x, 1, ind - 1)
+    x_hi = torch.gather(x, 1, ind)
+    y_lo = torch.gather(y, 1, ind - 1)
+    y_hi = torch.gather(y, 1, ind)
+
+    # Linear interpolation weights
+    denom = (x_hi - x_lo).clamp(min=1e-8)
+    alpha = ((xnew - x_lo) / denom).clamp(0, 1)
+
+    # Interpolated value — fully differentiable w.r.t. y_lo and y_hi
+    return y_lo + alpha * (y_hi - y_lo)
+
+
+# ============================================================================
+# SWE Pooling (from V3, mask-aware fixes from Sessions 6-8)
+# ============================================================================
+
+
+class SWE_Pooling(nn.Module):
+    """
+    Sliced-Wasserstein Embedding pooling.
+    Maps variable-length token embeddings [B, L, d_in] => [B, num_slices].
+
+    From Twin Peaks, with mask-aware sorting (Session 6) and
+    degenerate-sample handling (Session 8).
+    """
+
+    def __init__(
+        self,
+        d_in: int,
+        num_slices: int,
+        num_ref_points: int,
+        freeze_swe: bool = False,
+    ):
+        super().__init__()
+        self.num_slices = num_slices
+        self.num_ref_points = num_ref_points
+
+        # Learnable reference distribution
+        ref = torch.linspace(-1, 1, num_ref_points).unsqueeze(1).repeat(
+            1, num_slices
+        )
+        self.reference = nn.Parameter(ref, requires_grad=not freeze_swe)
+
+        # Projection directions (weight-normalized)
+        self.theta = nn.utils.weight_norm(
+            nn.Linear(d_in, num_slices, bias=False), dim=0
+        )
+        self.theta.weight_g.data = torch.ones_like(self.theta.weight_g.data)
+        self.theta.weight_g.requires_grad = False
+        nn.init.normal_(self.theta.weight_v)
+
+        # Weighted aggregation over reference points
+        self.weight = nn.Linear(num_ref_points, 1, bias=False)
+
+        if freeze_swe:
+            self.theta.weight_v.requires_grad = False
+            self.reference.requires_grad = False
+
+    def forward(
+        self, x: torch.Tensor, mask: Optional[torch.Tensor] = None
+    ) -> torch.Tensor:
+        """
+        Args:
+            x: [B, L, d_in] token embeddings
+            mask: [B, L] attention mask (1=valid, 0=padding)
+
+        Returns:
+            [B, num_slices] fixed-length representation
+        """
+        batch_size, seq_len, _ = x.shape
+        device = x.device
+
+        # Degenerate: single token → just project
+        if seq_len == 1:
+            x_slices = self.theta(x)
+            return x_slices.squeeze(1)
+
+        # Project onto learned directions
+        x_slices = self.theta(x)  # [B, L, num_slices]
+
+        # MASK-AWARE SORTING: set padding → -inf so they sort to bottom
+        if mask is not None:
+            mask_exp = mask.unsqueeze(-1).expand_as(x_slices)
+            x_slices = x_slices.masked_fill(mask_exp == 0, float("-inf"))
+
+        x_sorted, _ = torch.sort(x_slices, dim=1)
+
+        # Strip padding from sorted array
+        if mask is not None:
+            valid_counts = mask.sum(dim=1).long()
+            degenerate_mask = valid_counts < 2
+            safe_counts = valid_counts.clamp(min=2)
+            max_valid = safe_counts.max().item()
+
+            # Vectorized gather: take last safe_count values
+            starts = (seq_len - safe_counts).unsqueeze(1)
+            offsets = torch.arange(max_valid, device=device).unsqueeze(0)
+            raw_idx = starts + offsets
+            gather_idx = raw_idx.clamp(max=seq_len - 1).unsqueeze(-1).expand(
+                batch_size, max_valid, self.num_slices
+            )
+            x_sorted = torch.gather(x_sorted, 1, gather_idx)
+
+            # Replace -inf with 0.0 for degenerate samples
+            x_sorted = x_sorted.masked_fill(
+                x_sorted == float("-inf"), 0.0
+            )
+            n_eff = max_valid
+        else:
+            degenerate_mask = None
+            n_eff = seq_len
+
+        # Interpolate to fixed reference grid
+        x_coord = (
+            torch.linspace(0, 1, n_eff, device=device)
+            .unsqueeze(0)
+            .expand(batch_size * self.num_slices, -1)
+        )
+        x_flat = x_sorted.permute(0, 2, 1).reshape(
+            batch_size * self.num_slices, n_eff
+        )
+        xnew = (
+            torch.linspace(0, 1, self.num_ref_points, device=device)
+            .unsqueeze(0)
+            .expand(batch_size * self.num_slices, -1)
+        )
+
+        y_intp = differentiable_interp1d(x_coord, x_flat, xnew)
+        x_interp = y_intp.view(
+            batch_size, self.num_slices, self.num_ref_points
+        ).permute(0, 2, 1)
+
+        # Compare with reference distribution
+        r_expanded = self.reference.expand_as(x_interp)
+        embeddings = (r_expanded - x_interp).permute(0, 2, 1)
+
+        # Weighted aggregation → [B, num_slices]
+        weighted = self.weight(embeddings).sum(dim=-1)
+
+        # Zero out degenerate samples
+        if degenerate_mask is not None and degenerate_mask.any():
+            weighted = weighted.masked_fill(
+                degenerate_mask.unsqueeze(-1), 0.0
+            )
+
+        return weighted
+
+
+# ============================================================================
+# Cross-Attention Block (from V3, NaN guard from Session 9)
+# ============================================================================
+
+
+class PredeclaredAttentivePool(nn.Module):
+    """Attentive pooling over post-cross-attention PROTEIN residues.
+
+    Predeclared in AFFINOSE_PREDECLARATION_ATTENTIVE_POOLING_20260827.md:
+
+        s_j = w^T p_j ;  a_j = softmax_j(s_j) over valid positions ;  p_bar = sum_j a_j p_j
+
+    `w` is a single Linear(dim -> 1, bias=False), ZERO-INITIALISED, and must be exempt from any
+    `_init_weights` pass (Xavier init would destroy the equal-at-init property). +dim parameters.
+
+    At w = 0 every logit is 0, so the masked softmax is uniform over valid positions and p_bar is
+    exactly the masked mean — arm A equals arm M at initialisation. Unlike a gated form, the
+    gradient dL/dw is non-zero there, so A can actually depart from M.
+    """
+
+    def __init__(self, dim: int):
+        super().__init__()
+        self.w = nn.Linear(dim, 1, bias=False)
+        nn.init.zeros_(self.w.weight)
+        self.w._skip_init = True          # honoured by _init_weights guards, if any
+
+    def forward(self, x, mask):
+        s = self.w(x).squeeze(-1).masked_fill(mask <= 0, float("-inf"))
+        a = torch.softmax(s, dim=1)
+        a = torch.nan_to_num(a, nan=0.0).unsqueeze(-1)
+        return (x * a * mask.unsqueeze(-1).to(x.dtype)).sum(1)
+
+
+class CrossAttentionBlock(nn.Module):
+    """
+    Bidirectional cross-attention between glycan and protein tokens.
+
+    Glycan tokens attend to protein residues (Q=glycan, KV=protein)
+    Protein residues attend to glycan tokens (Q=protein, KV=glycan)
+
+    Includes NaN guard for all-masked keys (Session 9 fix) and
+    padding-position zeroing (Session 7 fix).
+    """
+
+    def __init__(
+        self,
+        d_model: int,
+        num_heads: int,
+        ffn_dim: int,
+        dropout: float = 0.1,
+    ):
+        super().__init__()
+
+        # Glycan → Protein cross-attention
+        self.glycan_cross_attn = nn.MultiheadAttention(
+            d_model, num_heads, dropout=dropout, batch_first=True
+        )
+        self.glycan_norm1 = nn.LayerNorm(d_model)
+        self.glycan_ffn = nn.Sequential(
+            nn.Linear(d_model, ffn_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(ffn_dim, d_model),
+            nn.Dropout(dropout),
+        )
+        self.glycan_norm2 = nn.LayerNorm(d_model)
+
+        # Protein → Glycan cross-attention
+        self.protein_cross_attn = nn.MultiheadAttention(
+            d_model, num_heads, dropout=dropout, batch_first=True
+        )
+        self.protein_norm1 = nn.LayerNorm(d_model)
+        self.protein_ffn = nn.Sequential(
+            nn.Linear(d_model, ffn_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(ffn_dim, d_model),
+            nn.Dropout(dropout),
+        )
+        self.protein_norm2 = nn.LayerNorm(d_model)
+
+    def forward(
+        self,
+        glycan: torch.Tensor,
+        protein: torch.Tensor,
+        glycan_mask: Optional[torch.Tensor] = None,
+        protein_mask: Optional[torch.Tensor] = None,
+        return_attention: bool = False,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Returns updated (glycan, protein) enriched with cross-modal info.
+
+        NaN guard: nn.MultiheadAttention produces NaN when ALL keys
+        are masked. We replace NaN→0 so residual preserves query.
+        """
+        # Convert to key_padding_mask (True = padded)
+        g_key_pad = (~glycan_mask.bool()) if glycan_mask is not None else None
+        p_key_pad = (
+            (~protein_mask.bool()) if protein_mask is not None else None
+        )
+
+        # Glycan attends to protein
+        g_cross, g_attn_weights = self.glycan_cross_attn(
+            query=glycan, key=protein, value=protein,
+            key_padding_mask=p_key_pad,
+            need_weights=return_attention,
+            average_attn_weights=False,
+        )
+        g_cross = torch.nan_to_num(g_cross, nan=0.0)
+        glycan = self.glycan_norm1(glycan + g_cross)
+        glycan = self.glycan_norm2(glycan + self.glycan_ffn(glycan))
+        if glycan_mask is not None:
+            glycan = glycan * glycan_mask.unsqueeze(-1)
+
+        # Protein attends to glycan
+        p_cross, p_attn_weights = self.protein_cross_attn(
+            query=protein, key=glycan, value=glycan,
+            key_padding_mask=g_key_pad,
+            need_weights=return_attention,
+            average_attn_weights=False,
+        )
+        p_cross = torch.nan_to_num(p_cross, nan=0.0)
+        protein = self.protein_norm1(protein + p_cross)
+        protein = self.protein_norm2(protein + self.protein_ffn(protein))
+        if protein_mask is not None:
+            protein = protein * protein_mask.unsqueeze(-1)
+
+        if return_attention:
+            attn_dict = {
+                "glycan_to_protein": g_attn_weights,
+                "protein_to_glycan": p_attn_weights,
+            }
+            return glycan, protein, attn_dict
+
+        return glycan, protein
+
+
+# ============================================================================
+# Bertint V8 Model
+# ============================================================================
+
+
+class BertintV8(nn.Module):
+    """
+    Glycan-protein interaction predictor with cross-attention.
+
+    Glycan: Live Bertose (partially frozen) → per-token [B, Lg, 768]
+    Protein: Precomputed ESM-C per-residue [B, Lp, 960]
+    Cross-attention: 2 bidirectional layers in shared 512-dim space
+    SWE: Variable-length → fixed [B, 512] for each side
+    Interaction: product + sum → MLP → scalar
+    """
+
+    def __init__(
+        self,
+        seq_embeddings: nn.Module,
+        seq_layers: nn.ModuleList,
+        glycan_dim: int = 768,
+        protein_dim: int = 960,
+        shared_dim: int = 512,
+        num_cross_layers: int = 2,
+        num_heads: int = 8,
+        ffn_dim: int = 1024,
+        swe_slices: int = 512,
+        swe_ref_points: int = 64,
+        head_hidden: int = 256,
+        dropout: float = 0.1,
+        separate_swe: bool = False,
+        pooling_mode: str = "swe",
+        protein_attentive_pool: bool = False,
+        interaction_mode: str = "product_sum",
+        use_cross_attention: bool = True,
+        glycan_size_channel: bool = False,
+        motif_additive_dim: int = 0,
+        protein_mode: str = "real",
+        protein_tower: bool = True,
+        protein_binding_channel: bool = False,
+    ):
+        """
+        Args:
+            seq_embeddings: Pretrained Bertose embedding layer.
+            seq_layers: Pretrained Bertose transformer layers.
+            glycan_dim: Bertose output dimension (768).
+            protein_dim: ESM-C per-residue dimension (960).
+            shared_dim: Shared space for cross-attention (512).
+            num_cross_layers: Number of cross-attention blocks.
+            num_heads: Attention heads per block.
+            ffn_dim: FFN hidden dim in cross-attention.
+            swe_slices: Number of SWE projection directions.
+            swe_ref_points: Number of SWE reference distribution points.
+            head_hidden: MLP head hidden dimension.
+            dropout: Dropout rate.
+            separate_swe: If True, use independent SWE modules.
+            pooling_mode: 'swe', 'mean', or 'joint_swe'.
+            interaction_mode: 'product_sum' or 'concat'.
+            use_cross_attention: If False, skip cross-attention.
+        """
+        super().__init__()
+
+        self.separate_swe = separate_swe
+        self.pooling_mode = pooling_mode
+        self.protein_attentive_pool = protein_attentive_pool
+        self.interaction_mode = interaction_mode
+        self.use_cross_attention = use_cross_attention
+        self.glycan_size_channel = glycan_size_channel
+        # 'shuffle' is REMOVED, not deprecated: it permuted inside forward(), which also
+        # runs under eval(), so it corrupted validation and test. P is a materialised
+        # dataset now (fit-rows-only donor map, hash-bound), so no model path is needed.
+        if protein_mode == "shuffle":
+            raise ValueError(
+                "protein_mode='shuffle' is withdrawn: it permuted inside forward(), which "
+                "also runs under eval(), so it permuted validation and test. Use the "
+                "materialised P arm (affinose_v2_binding_P_seed*.csv).")
+        assert protein_mode in ("real", "constant")
+        self.protein_mode = protein_mode
+        # G: do not CONSTRUCT the protein pathway at all.
+        self.protein_tower = protein_tower
+        # R2: the last input channel is a per-residue binding probability, not a
+        # feature. It rides along so that padding/masking/collate stay unchanged.
+        self.protein_binding_channel = protein_binding_channel
+        if protein_binding_channel:
+            assert protein_tower, "binding-weighted pooling needs the protein tower"
+            protein_dim = protein_dim - 1      # the channel is a weight, not a feature
+        if not protein_tower:
+            assert protein_mode == "real", (
+                "protein_tower=False already removes the protein pathway; combining it "
+                "with a protein_mode ablation is redundant and ambiguous")
+            use_cross_attention = False
+
+        print(f"  Architecture config:")
+        print(f"    cross_attention={use_cross_attention}")
+        print(f"    pooling_mode={pooling_mode}")
+        print(f"    interaction_mode={interaction_mode}")
+
+        # === Bertose sequence encoder (partially frozen) ===
+        self.seq_embeddings = seq_embeddings
+        self.seq_layers = seq_layers
+
+        # === Projection to shared space ===
+        self.glycan_proj = nn.Sequential(
+            nn.Linear(glycan_dim, shared_dim),
+            nn.LayerNorm(shared_dim),
+        )
+        if protein_tower:
+            self.protein_proj = nn.Sequential(
+                nn.Linear(protein_dim, shared_dim),
+                nn.LayerNorm(shared_dim),
+            )
+
+        # === Cross-attention stack (optional) ===
+        if use_cross_attention:
+            self.cross_attention = nn.ModuleList([
+                CrossAttentionBlock(
+                    d_model=shared_dim,
+                    num_heads=num_heads,
+                    ffn_dim=ffn_dim,
+                    dropout=dropout,
+                )
+                for _ in range(num_cross_layers)
+            ])
+        else:
+            self.cross_attention = nn.ModuleList()
+
+        # === Pooling ===
+        if pooling_mode == "swe":
+            if separate_swe:
+                self.swe_glycan = SWE_Pooling(
+                    d_in=shared_dim, num_slices=swe_slices,
+                    num_ref_points=swe_ref_points,
+                )
+                if protein_tower:
+                    self.swe_protein = SWE_Pooling(
+                        d_in=shared_dim, num_slices=swe_slices,
+                        num_ref_points=swe_ref_points,
+                    )
+                pool_out_dim = swe_slices
+            else:
+                self.swe = SWE_Pooling(
+                    d_in=shared_dim, num_slices=swe_slices,
+                    num_ref_points=swe_ref_points,
+                )
+                pool_out_dim = swe_slices
+        elif pooling_mode == "mean":
+            pool_out_dim = shared_dim
+        elif pooling_mode == "joint_swe":
+            self.swe_joint = SWE_Pooling(
+                d_in=shared_dim, num_slices=swe_slices,
+                num_ref_points=swe_ref_points,
+            )
+            pool_out_dim = swe_slices
+
+        # === Regression head ===
+        if pooling_mode == "joint_swe" or not protein_tower:
+            # glycan-only: the head sees ONE pooled vector, not a concatenated pair
+            head_input_dim = pool_out_dim
+        elif protein_binding_channel:
+            # glycan + global protein + binding-weighted protein
+            head_input_dim = 3 * pool_out_dim
+        else:
+            head_input_dim = 2 * pool_out_dim
+        # Restore the glycan-magnitude signal that masked mean pooling divides out.
+        if glycan_size_channel:
+            head_input_dim += 1
+
+        self.head = nn.Sequential(
+            nn.Linear(head_input_dim, head_hidden),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(head_hidden, head_hidden),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(head_hidden, 1),
+        )
+
+        # Initialize (skip SWE weight-normed params)
+        # ENCODER-INIT FIX 2026-08-17: nn.Module.apply() recurses into the
+        # pretrained BERTose encoder assigned above and _init_weights resets
+        # every nn.Linear / nn.LayerNorm inside it. Snapshot the encoder,
+        # let apply() run unchanged so every OTHER module receives the exact
+        # same init (and consumes the identical RNG stream), then restore.
+        _encfix_emb = {k: v.detach().clone() for k, v in self.seq_embeddings.state_dict().items()}
+        _encfix_lay = {k: v.detach().clone() for k, v in self.seq_layers.state_dict().items()}
+        self.apply(self._init_weights)
+        self.seq_embeddings.load_state_dict(_encfix_emb)
+        self.seq_layers.load_state_dict(_encfix_lay)
+
+        # ── ADDITIVE MOTIF TERM — CONSTRUCTED LAST, ON PURPOSE ──────────────────────────
+        # score += w . motif_features. LAST so it draws from the RNG stream only after every
+        # shared module, otherwise this arm is confounded with a different initialisation.
+        # Zero-init: identical to the reference at init, but dw != 0 so it can depart.
+        self.motif_additive_dim = int(motif_additive_dim)
+        if self.motif_additive_dim > 0:
+            self.motif_head = nn.Linear(self.motif_additive_dim, 1, bias=False)
+            nn.init.zeros_(self.motif_head.weight)
+        print(f"  [ENCFIX] restored {len(_encfix_emb)}+{len(_encfix_lay)} pretrained encoder tensors after init")
+        self._count_params()
+
+        # Constructed LAST on purpose: every shared submodule above draws from the RNG
+        # stream first, so arm A and arm M receive IDENTICAL shared weights under the
+        # same seed. Only this module's draws come afterwards. Without this, the extra
+        # parameters shift the stream and A - M confounds capacity with a different init.
+        if protein_attentive_pool:
+            self.protein_pool = PredeclaredAttentivePool(shared_dim)
+
+    def _init_weights(self, module: nn.Module) -> None:
+        """Xavier init for Linear, skip weight-normed SWE modules."""
+        if isinstance(module, nn.Linear):
+            if hasattr(module, "weight_v"):
+                return  # Preserve SWE initialization
+            nn.init.xavier_uniform_(module.weight)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.LayerNorm):
+            nn.init.ones_(module.weight)
+            nn.init.zeros_(module.bias)
+
+    def _count_params(self) -> None:
+        """Log parameter counts."""
+        total = sum(p.numel() for p in self.parameters())
+        trainable = sum(
+            p.numel() for p in self.parameters() if p.requires_grad
+        )
+        print(f"BertintV8: {total:,} total, {trainable:,} trainable")
+
+    def _masked_mean_pool(self, x, mask):
+        """Masked mean pooling: average valid tokens only."""
+        mask_expanded = mask.unsqueeze(-1)
+        x_masked = x * mask_expanded
+        summed = x_masked.sum(dim=1)
+        counts = mask.sum(dim=1, keepdim=True).clamp(min=1)
+        return summed / counts
+
+    def forward(
+        self,
+        token_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        branch_depths: torch.Tensor,
+        linkage_types: torch.Tensor,
+        protein_emb: torch.Tensor,
+        protein_mask: torch.Tensor,
+        motif_features: Optional[torch.Tensor] = None,
+        log_conc: Optional[torch.Tensor] = None,
+        has_conc: Optional[torch.Tensor] = None,
+        return_attention: bool = False,
+    ) -> torch.Tensor:
+        """
+        Forward pass with cross-attention.
+
+        Args:
+            token_ids: [B, Lg] BPE token IDs.
+            attention_mask: [B, Lg] glycan attention mask (1=valid, 0=pad).
+            branch_depths: [B, Lg] branch depth per token.
+            linkage_types: [B, Lg] linkage type per token.
+            protein_emb: [B, Lp, protein_dim] per-residue ESM-C embeddings.
+            protein_mask: [B, Lp] protein attention mask (1=valid, 0=pad).
+
+        Returns:
+            [B] binding score predictions.
+        """
+        # === 0. Protein-channel ablation (G / P arms) ===
+        # 'constant': zero the protein input, so protein_pooled is identical for every
+        #   example -> the model is effectively GLYCAN-ONLY (Codex's G).
+        # 'shuffle':  permute whole protein tensors + masks together across the batch,
+        #   destroying protein-glycan pairing while preserving the protein marginal
+        #   (an approximation of a label-blind pairing null, Codex's P).
+        if self.protein_mode == "constant":
+            protein_emb = torch.zeros_like(protein_emb)
+            protein_mask = torch.ones_like(protein_mask)
+        elif self.protein_mode == "shuffle":
+            perm = torch.randperm(protein_emb.shape[0], device=protein_emb.device)
+            protein_emb = protein_emb[perm]
+            protein_mask = protein_mask[perm]
+
+        # === 1. Bertose forward: per-token embeddings ===
+        x = self.seq_embeddings(token_ids, branch_depths, linkage_types)
+        for layer in self.seq_layers:
+            x = layer(x, attention_mask)
+        # x: [B, Lg, 768] — all tokens (not just CLS!)
+
+        # Glycan mask: use the attention_mask from BPE tokenizer
+        glycan_mask = attention_mask  # [B, Lg], 1=valid, 0=pad
+
+        # === G arm: glycan-only. The protein tensor and mask are never read. ===
+        if not self.protein_tower:
+            x = self.seq_embeddings(token_ids, branch_depths, linkage_types)
+            for layer in self.seq_layers:
+                x = layer(x, attention_mask)
+            glycan = self.glycan_proj(x) * attention_mask.unsqueeze(-1)
+            if self.pooling_mode == "mean":
+                pooled = self._masked_mean_pool(glycan, attention_mask)
+            else:
+                pooled = self.swe(glycan, attention_mask)
+            if self.glycan_size_channel:
+                n_tok = attention_mask.sum(dim=1, keepdim=True).to(pooled.dtype)
+                pooled = torch.cat([pooled, torch.log1p(n_tok)], dim=-1)
+            return self.head(pooled).squeeze(-1)
+
+        # R2: peel the binding-probability channel off the protein input. Done BEFORE
+        # projection so the projection never sees the weight as a feature.
+        binding_w = None
+        if self.protein_binding_channel:
+            binding_w = protein_emb[..., -1]              # [B, Lp]
+            protein_emb = protein_emb[..., :-1]           # [B, Lp, 960]
+
+        # === 2. Project to shared space ===
+        glycan = self.glycan_proj(x)        # [B, Lg, 512]
+        protein = self.protein_proj(protein_emb)  # [B, Lp, 512]
+
+        # Zero padding positions after projection (Session 7 fix:
+        # LayerNorm bias produces non-trivial values at padding)
+        glycan = glycan * glycan_mask.unsqueeze(-1)
+        protein = protein * protein_mask.unsqueeze(-1)
+
+        # === 3. Cross-attention (optional) ===
+        all_attention_maps = []
+        if self.use_cross_attention:
+            for cross_layer in self.cross_attention:
+                if return_attention:
+                    glycan, protein, attn_dict = cross_layer(
+                        glycan, protein, glycan_mask, protein_mask,
+                        return_attention=True,
+                    )
+                    all_attention_maps.append(attn_dict)
+                else:
+                    glycan, protein = cross_layer(
+                        glycan, protein, glycan_mask, protein_mask
+                    )
+
+        # === 4. Pooling ===
+        if self.pooling_mode == "joint_swe":
+            joint_tokens = torch.cat([glycan, protein], dim=1)
+            joint_mask = torch.cat([glycan_mask, protein_mask], dim=1)
+            pooled = self.swe_joint(joint_tokens, joint_mask)
+            return self.head(pooled).squeeze(-1)
+
+        if self.pooling_mode == "swe":
+            if self.separate_swe:
+                glycan_pooled = self.swe_glycan(glycan, glycan_mask)
+                protein_pooled = self.swe_protein(protein, protein_mask)
+            else:
+                glycan_pooled = self.swe(glycan, glycan_mask)
+                protein_pooled = self.swe(protein, protein_mask)
+        elif self.pooling_mode == "mean":
+            glycan_pooled = self._masked_mean_pool(glycan, glycan_mask)
+            if self.protein_attentive_pool:
+                # arm A: zero-initialised attentive protein pooling. Identical to the mean-pool
+                # arm M at initialisation; A - M therefore measures only the trained use of the
+                # added capacity.
+                protein_pooled = self.protein_pool(protein, protein_mask)
+            else:
+                protein_pooled = self._masked_mean_pool(protein, protein_mask)
+            if binding_w is not None:
+                # w~ = w / sum(w) over VALID positions only; a protein with no
+                # predicted site falls back to the mean rather than dividing by zero
+                w = binding_w * protein_mask
+                denom = w.sum(dim=1, keepdim=True)
+                w = torch.where(denom > 1e-8, w / denom.clamp(min=1e-8),
+                                protein_mask / protein_mask.sum(1, keepdim=True).clamp(min=1))
+                protein_binding = (protein * w.unsqueeze(-1)).sum(1)
+                protein_pooled = torch.cat([protein_pooled, protein_binding], dim=-1)
+
+        # === 5. Interaction ===
+        if self.interaction_mode == "product_sum":
+            interaction = torch.cat([
+                glycan_pooled * protein_pooled,
+                glycan_pooled + protein_pooled,
+            ], dim=-1)
+        elif self.interaction_mode == "concat":
+            interaction = torch.cat([
+                glycan_pooled, protein_pooled,
+            ], dim=-1)
+
+        # Masked mean pooling is invariant to token count, so glycan size is absent
+        # from the pooled vector by construction. Append it back as one scalar.
+        if self.glycan_size_channel:
+            n_tok = glycan_mask.sum(dim=1, keepdim=True).to(interaction.dtype)
+            interaction = torch.cat([interaction, torch.log1p(n_tok)], dim=-1)
+
+        # === 6. Predict binding score ===
+        out = self.head(interaction).squeeze(-1)
+
+        # Additive motif main effect -- the functional form of the ridge that beats us on
+        # doubly-cold (0.2290 vs 0.1444), learned jointly instead of bolted on.
+        if getattr(self, "motif_additive_dim", 0) > 0:
+            # ⛔ FAIL CLOSED. A missed call site must crash here, never train without motifs.
+            if motif_features is None:
+                raise ValueError("motif_additive_dim > 0 but motif_features was not supplied -- "
+                                 "refusing to run a motif arm without motif inputs")
+            out = out + self.motif_head(motif_features.to(out.dtype)).squeeze(-1)
+        if return_attention and all_attention_maps:
+            return out, all_attention_maps
+        return out
+
+
+# ============================================================================
+# Loss (same as V7 — simple MSE)
+# ============================================================================
+
+
+class BertintV8Loss(nn.Module):
+    """MSE loss for regression."""
+
+    def __init__(self):
+        super().__init__()
+        self.mse = nn.MSELoss()
+
+    def forward(
+        self, pred: torch.Tensor, target: torch.Tensor
+    ) -> torch.Tensor:
+        """Compute MSE loss."""
+        return self.mse(pred, target)
+
+
+# ============================================================================
+# Sanity check
+# ============================================================================
+if __name__ == "__main__":
+    print("=" * 60)
+    print("BertintV8 Architecture Sanity Check")
+    print("=" * 60)
+
+    # Mock Bertose encoder (for testing without cluster)
+    class MockEmbeddings(nn.Module):
+        """Mock Bertose embeddings for local testing."""
+
+        def __init__(self, dim: int = 768):
+            super().__init__()
+            self.proj = nn.Linear(64, dim)
+
+        def forward(self, token_ids, branch_depths, linkage_types):
+            """Return random embeddings."""
+            batch_size, seq_len = token_ids.shape
+            return torch.randn(batch_size, seq_len, 768)
+
+    class MockLayer(nn.Module):
+        """Mock transformer layer."""
+
+        def forward(self, x, mask):
+            """Identity."""
+            return x
+
+    seq_emb = MockEmbeddings()
+    seq_layers = nn.ModuleList([MockLayer() for _ in range(12)])
+
+    model = BertintV8(
+        seq_embeddings=seq_emb,
+        seq_layers=seq_layers,
+        glycan_dim=768,
+        protein_dim=960,
+    )
+
+    # Simulate batch
+    batch_size = 4
+    lg = 37   # Glycan: 37 BPE tokens
+    lp = 150  # Protein: 150 residues
+
+    token_ids = torch.randint(0, 100, (batch_size, lg))
+    attention_mask = torch.ones(batch_size, lg).float()
+    branch_depths = torch.zeros(batch_size, lg, dtype=torch.long)
+    linkage_types = torch.zeros(batch_size, lg, dtype=torch.long)
+    protein_emb = torch.randn(batch_size, lp, 960)
+    protein_mask = torch.ones(batch_size, lp).float()
+
+    out = model(
+        token_ids=token_ids,
+        attention_mask=attention_mask,
+        branch_depths=branch_depths,
+        linkage_types=linkage_types,
+        protein_emb=protein_emb,
+        protein_mask=protein_mask,
+    )
+
+    print(f"\nInput shapes:")
+    print(f"  Glycan tokens: {token_ids.shape}")
+    print(f"  Protein emb:   {protein_emb.shape}")
+    print(f"\nOutput shape: {out.shape} — values: {out.detach()}")
+
+    # Test loss
+    loss_fn = BertintV8Loss()
+    target = torch.rand(batch_size)
+    loss = loss_fn(out, target)
+    print(f"\nLoss: {loss.item():.6f}")
+
+    # Test backward
+    loss.backward()
+    grad_count = sum(
+        1 for p in model.parameters() if p.grad is not None and p.requires_grad
+    )
+    total_trainable = sum(
+        1 for p in model.parameters() if p.requires_grad
+    )
+    print(f"Gradients: {grad_count}/{total_trainable} trainable params")
+
+    print(f"\n✅ V8 sanity check passed!")
+"""Bertint V8 model — cross-attention + live Bertose finetuning."""

releases/2026-10-02/affinose/dataset_v8.py

@@ -0,0 +1,351 @@
+"""
+Bertint V8 Dataset — Per-Residue Protein Embeddings for Cross-Attention
+
+Like V7 but keeps per-residue ESM-C embeddings [L, D] instead of
+mean-pooling to [D]. This enables token-level cross-attention between
+glycan tokens and protein residues.
+
+Changes from V7:
+  - protein_emb: [Lp, 960] per-residue (not [960] mean-pooled)
+  - collate_fn: pads protein sequences to max length in batch
+  - Returns protein_mask for cross-attention padding
+"""
+
+import json
+import gzip
+import csv
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import h5py
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import Dataset
+from torch.nn.utils.rnn import pad_sequence
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# BPE Tokenizer Loader (same as V7)
+# ============================================================================
+
+def load_bpe_tokenizer(vocab_path: str):
+    """
+    Load the Bertose BPE tokenizer directly from source.
+
+    Bypasses downstream_tasks package imports. Adds utils
+    directory to sys.path and imports WURCSBPETokenizer directly.
+
+    Args:
+        vocab_path: Path to BPE vocabulary JSON file.
+
+    Returns:
+        WURCSBPETokenizer instance.
+    """
+    import sys
+
+    utils_dir = str(Path(__file__).resolve().parents[1] / "bertose_source" /
+                    "bert_training_v4/downstream_tasks/utils")
+    if utils_dir not in sys.path:
+        sys.path.insert(0, utils_dir)
+
+    # A1111 PORT 2026-08-19: use the frozen a5 tokenizer (2,114-token vocabulary)
+    # instead of the submitted-era 2,090-token one. Only the 10 special tokens
+    # share IDs between the two, so features MUST be regenerated, not reused.
+    # Verified: reproduces A1111's own review_token_ids.npy / review_branch_depths.npy
+    # byte-for-byte on 2,762/2,762 glycans with tree_channels_valid=True.
+    import a5_tokenizer_shim
+    a5_tokenizer_shim.install()
+    # V3 FIX 2026-08-24: the BASE tokenizer's linkage mapping disagrees with the
+    # one the encoder was pretrained under -- (1,2)->0/unknown->8 instead of
+    # LINKAGE_NONE=0/(1,2)->1/unknown->9. linkage_embeddings is (10,768), learned
+    # under V3, so base IDs index the wrong rows. Not fixable by a +1 remap.
+    from training.sequence_tree_runtime import ReviewA5WURCSBPETokenizerV3
+    return ReviewA5WURCSBPETokenizerV3(vocab_path=vocab_path)
+
+
+# ============================================================================
+# Dataset
+# ============================================================================
+
+class BertintV8Dataset(Dataset):
+    """
+    Dataset for glycan-protein interaction with cross-attention support.
+
+    Returns:
+      - BPE-tokenized glycan sequences for live Bertose forward pass
+      - Per-residue ESM-C protein embeddings [Lp, D] (NOT mean-pooled)
+      - Masks for both sides (for cross-attention padding)
+
+    Args:
+        csv_path: Path to binding data CSV.
+        split_path: Path to glycan-cold splits JSON.
+        split: One of 'train', 'val', 'test'.
+        protein_emb_path: Path to ESM-C embeddings HDF5.
+        vocab_path: Path to BPE vocabulary JSON.
+        max_glycan_length: Maximum glycan sequence length.
+        max_protein_length: Maximum protein residues (truncate longer).
+        target_col: Column name for regression target.
+    """
+
+    def __init__(
+        self,
+        csv_path: str,
+        split_path: str,
+        split: str,
+        protein_emb_path: str,
+        vocab_path: str,
+        max_glycan_length: int = 256,
+        max_protein_length: int = 1024,
+        target_col: str = "target_rank",
+        roles_path: str = None,
+        stratum: str = None,
+        features_dir: str = None,
+        expected_rows: int = None,
+    ):
+        logger.info(f"Loading {split} dataset from {csv_path}")
+
+        # ------------------------------------------------------------------
+        # CONTRACT r2 (2026-08-24): partition comes from the A5 role TSV's
+        # evaluation_stratum, not from splits_glycan_cold.json.
+        #
+        # H5-SAFE JOIN. Four CarboGrove protein_id values carry a TRAILING
+        # SPACE in the CSV (Laburnum/Lima Bean/Aspergillus/Limulus, 4,247 rows)
+        # while the role TSV holds the stripped form. Stripping protein_id in
+        # place would fix the stratum join and then silently lose the SAME
+        # 4,247 rows at the H5 lookup, whose keys also keep the space. So we
+        # join on a separate canonical key and never mutate protein_id.
+        # ------------------------------------------------------------------
+        if roles_path is None or stratum is None:
+            raise ValueError("roles_path and stratum are required under contract r2")
+
+        df = pd.read_csv(csv_path, float_precision="round_trip")
+        n_csv = len(df)
+        df["_join_protein"] = df["protein_id"].astype(str).str.strip()
+        df["_join_glycan"] = df["glycan_wurcs"].astype(str).str.strip()
+
+        roles = pd.read_csv(roles_path, sep="\t", compression="gzip",
+                            usecols=["protein_id", "glycan_wurcs", "evaluation_stratum"])
+        roles["_join_protein"] = roles["protein_id"].astype(str).str.strip()
+        roles["_join_glycan"] = roles["glycan_wurcs"].astype(str).str.strip()
+        roles = roles[["_join_protein", "_join_glycan", "evaluation_stratum"]]
+        if roles.duplicated(["_join_protein", "_join_glycan"]).any():
+            raise RuntimeError("role TSV has duplicate (protein, glycan) pairs")
+
+        merged = df.merge(roles, on=["_join_protein", "_join_glycan"],
+                          how="left", validate="many_to_one")
+        if len(merged) != n_csv:
+            raise RuntimeError(f"stratum join changed row count {n_csv} -> {len(merged)}")
+        unmatched = int(merged["evaluation_stratum"].isna().sum())
+        if unmatched:
+            raise RuntimeError(f"{unmatched} CSV rows matched no evaluation_stratum")
+
+        df = merged[merged["evaluation_stratum"] == stratum].copy()
+        df = df.dropna(subset=[target_col])
+        logger.info(f"  stratum {stratum}: {len(df):,} records "
+                    f"(from {n_csv:,} CSV rows, 0 unmatched)")
+
+        self.target_col = target_col
+        self.max_protein_length = max_protein_length
+
+        # ------------------------------------------------------------------
+        # CONTRACT r2: glycan channels come from the SEALED merged feature
+        # table. NO TOKENIZER IS IN THE PRODUCTION PATH. Tier A (2,877) are
+        # the official WURCSArray-derived arrays; tier B (1,048) come from the
+        # sealed WURCSArray extension. Anything the WURCSArray authority marks
+        # tree_channels_valid=False FAILS CLOSED and is excluded.
+        # ------------------------------------------------------------------
+        self.max_glycan_length = max_glycan_length
+        feat = Path(features_dir)
+        chans = ("token_ids", "residue_ids", "branch_depths",
+                 "linkage_types", "attention_mask")
+        arrays = {c: np.load(feat / f"review_{c}.npy") for c in chans}
+        valid = np.load(feat / "review_tree_channels_valid.npy")
+        if arrays["token_ids"].shape[1] != max_glycan_length:
+            raise RuntimeError(
+                f"feature width {arrays['token_ids'].shape[1]} != "
+                f"max_glycan_length {max_glycan_length}")
+        frow, fvalid = {}, {}
+        with gzip.open(feat / "review_affinose_glycan_index.tsv.gz",
+                       "rt", newline="") as fh:
+            for r in csv.DictReader(fh, delimiter="\t"):
+                w = r["canonical_wurcs"].strip()
+                frow[w] = int(r["feature_row"])
+                fvalid[w] = (r["tree_channels_valid"] == "True")
+        logger.info(f"  sealed feature table: {len(frow)} glycans, "
+                    f"{int(valid.sum())} valid / {int((~valid).sum())} fail-closed")
+
+        need = set(df["_join_glycan"].unique())
+        unknown = sorted(w for w in need if w not in frow)
+        if unknown:
+            raise RuntimeError(
+                f"{len(unknown)} glycans absent from the sealed feature table, "
+                f"e.g. {unknown[0][:60]}")
+
+        excluded = sorted(w for w in need if not fvalid[w])
+        if excluded:
+            before = len(df)
+            df = df[~df["_join_glycan"].isin(set(excluded))].copy()
+            logger.info(f"  FAIL-CLOSED: dropped {len(excluded)} glycans "
+                        f"(tree_channels_valid=False), {before - len(df):,} rows")
+        self.excluded_glycans = excluded
+
+        # MOTIF CHANNEL: 165 raw motif counts per glycan, row-aligned to the sealed
+        # feature index; the pinned float32 array contains counts 0-13. Do not binarize.
+        _motif = np.load(feat / "review_motif_features.npy")
+        if _motif.shape[0] != arrays["token_ids"].shape[0]:
+            raise RuntimeError("motif array rows %d != feature rows %d"
+                               % (_motif.shape[0], arrays["token_ids"].shape[0]))
+
+        self.tokenized_cache = {}
+        for w in df["_join_glycan"].unique():
+            i = frow[w]
+            self.tokenized_cache[w] = {
+                "token_ids": torch.tensor(arrays["token_ids"][i], dtype=torch.long),
+                "attention_mask": torch.tensor(arrays["attention_mask"][i], dtype=torch.long),
+                "branch_depths": torch.tensor(arrays["branch_depths"][i], dtype=torch.long),
+                "linkage_types": torch.tensor(arrays["linkage_types"][i], dtype=torch.long),
+                "motif_features": torch.tensor(_motif[i], dtype=torch.float),
+            }
+        logger.info(f"  {len(self.tokenized_cache)} glycans served from sealed arrays")
+
+        self.records = df.reset_index(drop=True)
+
+        # Load protein embeddings — KEEP PER-RESIDUE (not mean-pooled!)
+        logger.info(f"  Loading per-residue protein embeddings...")
+        self.protein_embs: Dict[str, torch.Tensor] = {}
+        with h5py.File(protein_emb_path, "r") as f:
+            for key in f.keys():
+                emb = torch.from_numpy(f[key][:]).float()
+                # emb: [L, D] per-residue
+                if emb.dim() == 1:
+                    # Edge case: single-residue protein
+                    emb = emb.unsqueeze(0)
+                # BOS/EOS FIX 2026-08-19: ESM-C emits L+2 vectors per protein
+                # (verified: every entry in esmc_embeddings.h5 is exactly
+                # len(sequence)+2). The original code truncated but never stripped
+                # them, so position 0 was the BOS token fed to the model as
+                # residue 1 and the whole protein was shifted by one.
+                if emb.shape[0] >= 3:
+                    emb = emb[1:-1]
+                # Truncate very long proteins
+                if emb.shape[0] > max_protein_length:
+                    emb = emb[:max_protein_length]
+                protein_id = key.replace("|", "/")
+                self.protein_embs[protein_id] = emb
+        logger.info(f"    {len(self.protein_embs)} proteins loaded")
+
+        # Log protein length statistics
+        lengths = [v.shape[0] for v in self.protein_embs.values()]
+        logger.info(
+            f"    Protein lengths: min={min(lengths)}, "
+            f"max={max(lengths)}, mean={np.mean(lengths):.0f}"
+        )
+
+        # Filter to records with available embeddings
+        # CONTRACT r2: fail closed. protein_id is used EXACTLY as it appears
+        # in the CSV (trailing spaces included) because the H5 keys keep them.
+        available = set(self.protein_embs.keys())
+        has_protein = self.records["protein_id"].isin(available)
+        if not has_protein.all():
+            missing = int((~has_protein).sum())
+            bad = sorted(self.records.loc[~has_protein, "protein_id"].unique())[:5]
+            raise RuntimeError(
+                f"{missing} records missing protein embeddings "
+                f"({len(bad)} distinct shown): {bad}")
+
+        if expected_rows is not None and len(self.records) != int(expected_rows):
+            raise RuntimeError(
+                f"retained row count {len(self.records)} != manifest "
+                f"expected {expected_rows} for stratum {stratum}")
+        logger.info(f"  Final {split} dataset: {len(self.records):,} records")
+
+    def __len__(self) -> int:
+        return len(self.records)
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        row = self.records.iloc[idx]
+        wurcs = row["glycan_wurcs"]
+        protein_id = row["protein_id"]
+
+        # Glycan tokens (pre-cached, already padded to max_glycan_length)
+        cached = self.tokenized_cache[wurcs]
+
+        # Protein embedding — per-residue [Lp, D]
+        protein_emb = self.protein_embs[protein_id]
+
+        # Target
+        target = torch.tensor(row[self.target_col], dtype=torch.float)
+
+        # Concentration features
+        has_conc = torch.tensor(row.get("has_conc", 0), dtype=torch.float)
+        log_conc = torch.tensor(row.get("log_conc", 0.0), dtype=torch.float)
+
+        return {
+            "token_ids": cached["token_ids"],
+            "attention_mask": cached["attention_mask"],
+            "branch_depths": cached["branch_depths"],
+            "linkage_types": cached["linkage_types"],
+            "motif_features": cached["motif_features"],
+            "protein_emb": protein_emb,        # [Lp, D] variable-length!
+            "protein_length": protein_emb.shape[0],
+            "target": target,
+            "has_conc": has_conc,
+            "log_conc": log_conc,
+        }
+
+
+def collate_fn(
+    batch: List[Dict[str, torch.Tensor]],
+) -> Dict[str, torch.Tensor]:
+    """
+    Collate with variable-length protein padding.
+
+    Glycan sequences are already padded (BPE tokenizer pads to
+    max_glycan_length). Protein sequences need padding to the
+    max length in the batch.
+    """
+    # Glycan: already fixed-length, just stack
+    token_ids = torch.stack([item["token_ids"] for item in batch])
+    attention_mask = torch.stack(
+        [item["attention_mask"] for item in batch]
+    ).float()
+    branch_depths = torch.stack(
+        [item["branch_depths"] for item in batch]
+    )
+    linkage_types = torch.stack(
+        [item["linkage_types"] for item in batch]
+    )
+    motif_features = torch.stack([item["motif_features"] for item in batch])
+
+    # Protein: variable-length → pad to max in batch
+    protein_embs = [item["protein_emb"] for item in batch]
+    protein_padded = pad_sequence(protein_embs, batch_first=True)  # [B, Lp_max, D]
+
+    # Protein mask: 1 for real residues, 0 for padding
+    protein_lengths = [item["protein_length"] for item in batch]
+    max_prot_len = protein_padded.shape[1]
+    protein_mask = torch.zeros(len(batch), max_prot_len)
+    for i, length in enumerate(protein_lengths):
+        protein_mask[i, :length] = 1.0
+
+    # Targets and metadata
+    targets = torch.stack([item["target"] for item in batch])
+    has_conc = torch.stack([item["has_conc"] for item in batch])
+    log_conc = torch.stack([item["log_conc"] for item in batch])
+
+    return {
+        "token_ids": token_ids,
+        "attention_mask": attention_mask,
+        "branch_depths": branch_depths,
+        "linkage_types": linkage_types,
+        "motif_features": motif_features,
+        "protein_emb": protein_padded,    # [B, Lp_max, D]
+        "protein_mask": protein_mask,      # [B, Lp_max]
+        "target": targets,
+        "has_conc": has_conc,
+        "log_conc": log_conc,
+    }

releases/2026-10-02/affinose/training_v8.py

@@ -0,0 +1,1038 @@
+"""
+Bertint V8 Training — Cross-Attention + Live Bertose Finetuning
+
+Based on V7 trainer with changes for V8 architecture:
+  - Per-residue protein embeddings (variable-length, padded in collate)
+  - protein_mask passed to model for cross-attention
+  - AMP (GradScaler + autocast) built in from the start
+  - Regression only (no classification mode — V7 showed regression wins)
+"""
+
+import argparse
+import json
+import logging
+import os
+import hashlib
+import random
+import sys
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from scipy.stats import spearmanr, pearsonr
+from torch.cuda.amp import GradScaler, autocast
+from torch.utils.data import DataLoader
+
+from bertint_v8 import BertintV8, BertintV8Loss, load_bertose_encoder
+from dataset_v8 import BertintV8Dataset, collate_fn
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Reproducibility
+# ============================================================================
+
+
+def set_seed(seed: int = 42) -> None:
+    """Set random seeds for reproducibility."""
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+# ============================================================================
+# Metrics
+# ============================================================================
+
+
+def _atomic_torch_save(obj, path):
+    """Write via a temp file + os.replace so a preemption cannot truncate."""
+    tmp = str(path) + ".tmp"
+    torch.save(obj, tmp)
+    os.replace(tmp, path)
+
+class AssayGroupedBatchSampler(torch.utils.data.Sampler):
+    """Batches of K assays x M rows, emitted as contiguous blocks.
+
+    The block structure is what lets the loss recover the grouping from the batch shape without
+    threading assay ids through collate_fn. Sampling is uniform over ASSAYS, not rows, so the
+    gradient weighting matches the equal-assay macro we actually report.
+    """
+
+    def __init__(self, exp_ids, assays_per_batch, rows_per_assay, seed=42):
+        import collections
+        self.K, self.M = assays_per_batch, rows_per_assay
+        idx = collections.defaultdict(list)
+        for i, e in enumerate(exp_ids):
+            idx[e].append(i)
+        # an assay smaller than M cannot fill a block; excluded and COUNTED, never padded
+        self.groups = [np.asarray(v) for v in idx.values() if len(v) >= self.M]
+        self.excluded_assays = len(idx) - len(self.groups)
+        self.rng = np.random.default_rng(seed)
+        self.n_batches = max(len(self.groups) // self.K, 1)
+        logger.info("  assay-grouped sampler: %d usable assays (%d too small for M=%d), "
+                    "%d batches/epoch of %dx%d",
+                    len(self.groups), self.excluded_assays, self.M,
+                    self.n_batches, self.K, self.M)
+
+    def __iter__(self):
+        order = self.rng.permutation(len(self.groups))
+        for b in range(self.n_batches):
+            batch = []
+            for gi in order[b * self.K:(b + 1) * self.K]:
+                g = self.groups[gi]
+                pick = self.rng.choice(len(g), self.M, replace=False)
+                batch.extend(int(x) for x in g[pick])
+            if len(batch) == self.K * self.M:
+                yield batch
+
+    def __len__(self):
+        return self.n_batches
+
+
+class WithinAssayPairwiseLoss(nn.Module):
+    """RankNet pairwise logistic loss, computed INSIDE each assay block.
+
+    The batch arrives as K contiguous blocks of M rows (see AssayGroupedBatchSampler), so it
+    reshapes to (K, M) and every pair compared is guaranteed to come from the same assay — which
+    is the only comparison the estimand defines.
+    """
+
+    def __init__(self, assays_per_batch, rows_per_assay):
+        super().__init__()
+        self.K, self.M = assays_per_batch, rows_per_assay
+
+    def forward(self, pred, target):
+        if pred.numel() != self.K * self.M:
+            # eval batches are not grouped; fall back so the same object can score them
+            return F.mse_loss(pred, target)
+        p = pred.view(self.K, self.M)
+        y = target.view(self.K, self.M)
+        d = p.unsqueeze(2) - p.unsqueeze(1)                 # (K, M, M) predicted differences
+        s = torch.sign(y.unsqueeze(2) - y.unsqueeze(1))     # (K, M, M) true order, 0 where tied
+        m = s != 0
+        if not m.any():
+            return pred.sum() * 0.0
+        return F.softplus(-s[m] * d[m]).mean()
+
+
+def equal_assay_macro(preds, targets, groups, min_rows=5, min_distinct=2):
+    """Mean per-assay Spearman, equal weight per eligible assay.
+
+    Eligibility mirrors the split's own rule: an assay needs >= min_rows rows and >= min_distinct
+    distinct target values, plus >= min_distinct distinct PREDICTIONS (a constant prediction makes
+    Spearman undefined, and treating that as 0.0 would silently reward degenerate assays).
+    Returns (macro, n_eligible, n_total).
+    """
+    import collections
+    idx = collections.defaultdict(list)
+    for i, g in enumerate(groups):
+        idx[g].append(i)
+    vals = []
+    for g, ii in idx.items():
+        if len(ii) < min_rows:
+            continue
+        t_ = targets[ii]
+        p_ = preds[ii]
+        if len(np.unique(t_)) < min_distinct or len(np.unique(p_)) < min_distinct:
+            continue
+        r, _ = spearmanr(p_, t_)
+        if not np.isnan(r):
+            vals.append(float(r))
+    if not vals:
+        return 0.0, 0, len(idx)
+    return float(np.mean(vals)), len(vals), len(idx)
+
+
+def compute_metrics(
+    preds: np.ndarray, targets: np.ndarray
+) -> Dict[str, float]:
+    """Compute Spearman, Pearson, MSE."""
+    rho, _ = spearmanr(preds, targets)
+    r, _ = pearsonr(preds, targets)
+    mse = np.mean((preds - targets) ** 2)
+    # CONTRACT r2: a NaN correlation means a collapsed model. Coercing it to
+    # 0.0 disguises collapse as merely-bad performance, so fail closed.
+    if np.isnan(rho) or np.isnan(r) or not np.isfinite(mse):
+        raise RuntimeError(
+            "non-finite metric: spearman=%r pearson=%r mse=%r "
+            "(pred std=%r, target std=%r)" % (rho, r, mse,
+             float(np.std(preds)), float(np.std(targets))))
+    return {"spearman": float(rho), "pearson": float(r), "mse": float(mse)}
+
+
+# ============================================================================
+# Trainer
+# ============================================================================
+
+
+class BertintV8Trainer:
+    """
+    Trainer for BertintV8 with cross-attention and AMP.
+
+    Args:
+        model: BertintV8 model.
+        criterion: Loss function.
+        train_loader: Training data loader.
+        val_loader: Validation data loader.
+        test_loader: Test data loader.
+        output_dir: Directory for checkpoints and results.
+        lr_encoder: Learning rate for Bertose encoder layers.
+        lr_head: Learning rate for cross-attention, SWE, and head.
+        weight_decay: Weight decay for AdamW.
+        max_grad_norm: Maximum gradient norm for clipping.
+        epochs: Number of training epochs.
+        patience: Early stopping patience.
+        checkpoint_interval: Save checkpoint every N epochs.
+        resume: Whether to resume from last checkpoint.
+    """
+
+    def __init__(
+        self,
+        model: BertintV8,
+        criterion: nn.Module,
+        train_loader: DataLoader,
+        val_loader: DataLoader,
+        test_loader: DataLoader,
+        output_dir: str,
+        lr_encoder: float = 1e-5,
+        lr_head: float = 1e-4,
+        weight_decay: float = 0.01,
+        max_grad_norm: float = 1.0,
+        epochs: int = 50,
+        patience: int = 15,
+        checkpoint_interval: int = 5,
+        resume: bool = False,
+        fingerprint: str = None,
+        input_hashes: dict = None,
+        warmup_pct: float = 0.0,
+    ):
+        self.model = model
+        self.criterion = criterion
+        self.train_loader = train_loader
+        self.val_loader = val_loader
+        self.test_loader = test_loader
+        self.output_dir = output_dir
+        self.epochs = epochs
+        self.patience = patience
+        self.checkpoint_interval = checkpoint_interval
+        self.resume = resume
+        self.max_grad_norm = max_grad_norm
+
+        os.makedirs(output_dir, exist_ok=True)
+
+        self.device = torch.device(
+            "cuda" if torch.cuda.is_available() else "cpu"
+        )
+        self.model.to(self.device)
+        self.criterion.to(self.device)
+
+        # AMP scaler
+        self.scaler = GradScaler()
+
+        # Separate param groups: encoder (small lr) vs rest (larger lr)
+        encoder_params = []
+        head_params = []
+        for name, param in model.named_parameters():
+            if not param.requires_grad:
+                continue
+            if name.startswith("seq_embeddings") or name.startswith(
+                "seq_layers"
+            ):
+                encoder_params.append(param)
+            else:
+                head_params.append(param)
+
+        logger.info(
+            f"  Param groups: encoder={len(encoder_params)} tensors "
+            f"(lr={lr_encoder}), head={len(head_params)} tensors "
+            f"(lr={lr_head})"
+        )
+
+        self.optimizer = torch.optim.AdamW(
+            [
+                {
+                    "params": encoder_params,
+                    "lr": lr_encoder,
+                    "weight_decay": weight_decay,
+                },
+                {
+                    "params": head_params,
+                    "lr": lr_head,
+                    "weight_decay": weight_decay,
+                },
+            ]
+        )
+
+        # OneCycleLR with per-batch stepping (matches Twin Peaks pattern)
+        # Built-in warmup (pct_start) + cosine annealing
+        total_steps = len(train_loader) * epochs
+        if warmup_pct > 0:
+            pct_start = warmup_pct
+        else:
+            pct_start = 0.3  # Default: 30% warmup
+
+        self.scheduler = torch.optim.lr_scheduler.OneCycleLR(
+            self.optimizer,
+            max_lr=[lr_encoder, lr_head],
+            total_steps=total_steps,
+            pct_start=pct_start,
+            anneal_strategy='cos',
+        )
+        warmup_steps_actual = int(total_steps * pct_start)
+        logger.info(
+            f"  Scheduler: OneCycleLR per-batch stepping"
+        )
+        logger.info(
+            f"    total_steps={total_steps:,}, "
+            f"warmup={warmup_steps_actual:,} steps "
+            f"({pct_start*100:.0f}%), cosine decay"
+        )
+
+        # State
+        self.start_epoch = 0
+        self.best_metric = -float("inf")
+        self.patience_counter = 0
+        self.history: List[Dict] = []
+
+        # CONTRACT r2 FIX: the fingerprint must exist BEFORE resume, which is
+        # the last statement of __init__. Assigning it after construction left
+        # the guard reading None and a foreign checkpoint loaded unchecked.
+        self.fingerprint = fingerprint
+        self.input_hashes = input_hashes or {}
+        self.early_stopped = False
+        self.best_epoch = -1
+        if resume:
+            self._resume_from_checkpoint()
+
+    def train(self) -> Dict:
+        """Full training loop with early stopping."""
+        logger.info(f"\nStarting V8 training for {self.epochs} epochs")
+        logger.info(f"  Device: {self.device}")
+        logger.info(f"  Train batches: {len(self.train_loader)}")
+        logger.info(f"  Val batches: {len(self.val_loader)}")
+        logger.info(f"  AMP: enabled")
+
+        for epoch in range(self.start_epoch, self.epochs):
+            t0 = time.time()
+
+            train_loss = self._train_epoch(epoch)
+            val_loss, val_metrics = self._eval_epoch(self.val_loader)
+
+            elapsed = time.time() - t0
+            rho_pooled = val_metrics["spearman"]
+            rho = val_metrics["macro_spearman"]      # the DECLARED selector
+            r = val_metrics["pearson"]
+
+            logger.info(
+                f"  Epoch {epoch + 1:3d} | Train loss={train_loss:.4f} | "
+                f"Val loss={val_loss:.4f} MACRO={rho:.4f} "
+                f"(pooled={rho_pooled:.4f}, {val_metrics['macro_assays_eligible']}"
+                f"/{val_metrics['macro_assays_total']} assays) r={r:.4f} | "
+                f"{elapsed:.1f}s"
+            )
+
+            # Track best
+            if rho > self.best_metric:
+                self.best_metric = rho
+                self.patience_counter = 0
+                _atomic_torch_save(
+                    self.model.state_dict(),
+                    os.path.join(self.output_dir, "best_model.pt"),
+                )
+                self.best_epoch = epoch
+                logger.info(f"  * New best: {rho:.4f}")
+            else:
+                self.patience_counter += 1
+
+            # History
+            self.history.append(
+                {
+                    "epoch": epoch + 1,
+                    "train_loss": train_loss,
+                    "val_loss": val_loss,
+                    "val_metrics": val_metrics,
+                    "lr_encoder": self.optimizer.param_groups[0]["lr"],
+                    "lr_head": self.optimizer.param_groups[1]["lr"],
+                }
+            )
+
+            # (scheduler.step() is now called per-batch in _train_epoch)
+
+            # Periodic checkpoint
+            if (epoch + 1) % self.checkpoint_interval == 0:
+                self._save_checkpoint(epoch + 1)
+
+            # Early stopping
+            if self.patience_counter >= self.patience:
+                logger.info(
+                    f"  Early stopping at epoch {epoch + 1} "
+                    f"(no improvement for {self.patience} epochs)"
+                )
+                self.early_stopped = True
+                self._save_checkpoint(epoch + 1)
+                break
+
+        # Load best and test
+        logger.info(f"\n{'=' * 60}")
+        logger.info("Loading best model for test evaluation...")
+        best_path = os.path.join(self.output_dir, "best_model.pt")
+        self.model.load_state_dict(
+            torch.load(best_path, map_location=self.device, weights_only=False)
+        )
+
+        test_loss, test_metrics = self._eval_epoch(self.test_loader)
+
+        logger.info(f"\n{'=' * 60}")
+        logger.info("TEST RESULTS:")
+        logger.info(f"  Spearman rho: {test_metrics['spearman']:.4f}")
+        logger.info(f"  Pearson r:    {test_metrics['pearson']:.4f}")
+        logger.info(f"  MSE:          {test_metrics['mse']:.6f}")
+        logger.info(f"{'=' * 60}")
+
+        # Save results
+        # CONTRACT r2: the old label hard-coded "SWE" regardless of what was
+        # actually requested. Describe the configuration that ran.
+        results = {
+            "task_type": "regression",
+            "architecture": getattr(self, "architecture_label",
+                                    "cross-attention + live Bertose"),
+            "best_metric": self.best_metric,
+            "best_metric_is": "validation",
+            "best_epoch": self.best_epoch,
+            "early_stopped": self.early_stopped,
+            "epochs_ran": len(self.history),
+            "test_metrics": test_metrics,
+            "test_loss": test_loss,
+            "history": self.history,
+            "fingerprint": self.fingerprint,
+            "input_hashes": self.input_hashes,
+        }
+        # CONTRACT r2: dump per-record predictions. Without them no
+        # cohort-averaged statistic can be recovered after the fact.
+        try:
+            import numpy as _np
+            _p = getattr(self, "_last_preds", None)
+            _t = getattr(self, "_last_targets", None)
+            if _p is not None and _t is not None:
+                _np.savez_compressed(
+                    os.path.join(self.output_dir, "test_predictions.npz"),
+                    predictions=_np.asarray(_p, dtype=_np.float32),
+                    targets=_np.asarray(_t, dtype=_np.float32))
+                logger.info(f"  [PRED] wrote {len(_p)} test predictions")
+            else:
+                raise RuntimeError("no test predictions captured")
+        except Exception as _e:
+            raise RuntimeError("failed to write test predictions: %s" % _e)
+
+        results_path = os.path.join(self.output_dir, "results.json")
+        with open(results_path, "w") as f:
+            json.dump(results, f, indent=2)
+        logger.info(f"Results saved to {results_path}")
+
+        return results
+
+    def _train_epoch(self, epoch: int) -> float:
+        """Run one training epoch with AMP."""
+        self.model.train()
+        total_loss = 0.0
+        n_batches = len(self.train_loader)
+
+        for batch_idx, batch in enumerate(self.train_loader):
+            # Move to device
+            token_ids = batch["token_ids"].to(self.device)
+            attention_mask = batch["attention_mask"].to(self.device)
+            branch_depths = batch["branch_depths"].to(self.device)
+            linkage_types = batch["linkage_types"].to(self.device)
+            protein_emb = batch["protein_emb"].to(self.device)
+            protein_mask = batch["protein_mask"].to(self.device)
+            target = batch["target"].to(self.device)
+
+            self.optimizer.zero_grad()
+
+            # AMP forward
+            with autocast():
+                pred = self.model(
+                    token_ids=token_ids,
+                    attention_mask=attention_mask,
+                    branch_depths=branch_depths,
+                    linkage_types=linkage_types,
+                    protein_emb=protein_emb,
+                    protein_mask=protein_mask,
+                    motif_features=batch["motif_features"].to(self.device),
+                )
+                loss = self.criterion(pred, target)
+
+            # AMP backward
+            self.scaler.scale(loss).backward()
+            self.scaler.unscale_(self.optimizer)
+            torch.nn.utils.clip_grad_norm_(
+                self.model.parameters(), self.max_grad_norm
+            )
+            self.scaler.step(self.optimizer)
+            self.scaler.update()
+
+            # Per-batch LR scheduling (OneCycleLR)
+            self.scheduler.step()
+
+            total_loss += loss.item()
+
+            # Progress logging
+            if (batch_idx + 1) % 200 == 0:
+                avg = total_loss / (batch_idx + 1)
+                lr_enc = self.optimizer.param_groups[0]["lr"]
+                logger.info(
+                    f"  [E{epoch + 1}][{batch_idx + 1}/{n_batches}] "
+                    f"loss={avg:.4f} lr_enc={lr_enc:.2e}"
+                )
+
+        return total_loss / n_batches
+
+    @torch.no_grad()
+    def _eval_epoch(
+        self, loader: DataLoader
+    ) -> Tuple[float, Dict[str, float]]:
+        """Run evaluation with AMP."""
+        self.model.eval()
+        total_loss = 0.0
+        all_preds = []
+        all_targets = []
+
+        for batch in loader:
+            token_ids = batch["token_ids"].to(self.device)
+            attention_mask = batch["attention_mask"].to(self.device)
+            branch_depths = batch["branch_depths"].to(self.device)
+            linkage_types = batch["linkage_types"].to(self.device)
+            protein_emb = batch["protein_emb"].to(self.device)
+            protein_mask = batch["protein_mask"].to(self.device)
+            target = batch["target"].to(self.device)
+
+            with autocast():
+                pred = self.model(
+                    token_ids=token_ids,
+                    attention_mask=attention_mask,
+                    branch_depths=branch_depths,
+                    linkage_types=linkage_types,
+                    protein_emb=protein_emb,
+                    protein_mask=protein_mask,
+                    motif_features=batch["motif_features"].to(self.device),
+                )
+                loss = self.criterion(pred, target)
+
+            total_loss += loss.item()
+            all_preds.extend(pred.float().cpu().numpy())
+            all_targets.extend(target.cpu().numpy())
+
+        avg_loss = total_loss / len(loader)
+        metrics = compute_metrics(
+            np.array(all_preds), np.array(all_targets)
+        )
+        # ⛔ DECLARED SELECTOR: equal-assay macro, not pooled. Cohort ids come from the dataset's
+        # own row order, which equals evaluation order because val/test loaders use shuffle=False.
+        # Asserted, not assumed — a silent misalignment here would select on scrambled assays.
+        try:
+            recs = loader.dataset.records
+            assert len(recs) == len(all_preds), (
+                "eval row count %d != dataset rows %d; loader order is not dataset order"
+                % (len(all_preds), len(recs)))
+            groups = recs["exp_id"].values
+            macro, n_elig, n_tot = equal_assay_macro(
+                np.array(all_preds), np.array(all_targets), groups)
+            metrics["macro_spearman"] = macro
+            metrics["macro_assays_eligible"] = int(n_elig)
+            metrics["macro_assays_total"] = int(n_tot)
+        except Exception as e:
+            logger.error("FAIL-CLOSED: equal-assay macro unavailable: %s", e)
+            raise
+        self._last_preds = all_preds
+        self._last_targets = all_targets
+        return avg_loss, metrics
+
+    def _save_checkpoint(self, epoch: int) -> None:
+        """Save full training state for resume."""
+        ckpt = {
+            "epoch": epoch,
+            "model_state_dict": self.model.state_dict(),
+            "optimizer_state_dict": self.optimizer.state_dict(),
+            "scheduler_state_dict": self.scheduler.state_dict(),
+            "scaler_state_dict": self.scaler.state_dict(),
+            "best_metric": self.best_metric,
+            "patience_counter": self.patience_counter,
+            "history": self.history,
+            # CONTRACT r2: without RNG state a resumed fit replays the data
+            # order and dropout stream from epoch 0 and is a DIFFERENT
+            # experiment from an uninterrupted fit at the same seed.
+            "py_rng": random.getstate(),
+            "np_rng": np.random.get_state(),
+            "torch_rng": torch.get_rng_state(),
+            "cuda_rng": (torch.cuda.get_rng_state_all()
+                         if torch.cuda.is_available() else None),
+            "best_epoch": getattr(self, "best_epoch", -1),
+            "early_stopped": getattr(self, "early_stopped", False),
+            "fingerprint": getattr(self, "fingerprint", None),
+        }
+        path = os.path.join(self.output_dir, "last_checkpoint.pt")
+        _atomic_torch_save(ckpt, path)
+        logger.info(f"  [CKPT] Saved epoch {epoch}")
+
+    def _resume_from_checkpoint(self) -> None:
+        """Resume training from last checkpoint."""
+        ckpt_path = os.path.join(self.output_dir, "last_checkpoint.pt")
+        if not os.path.exists(ckpt_path):
+            logger.info("  No checkpoint found, starting fresh")
+            return
+
+        ckpt = torch.load(ckpt_path, map_location=self.device, weights_only=False)
+        # CONTRACT r2: every arm/seed/port produces an identically shaped state
+        # dict, so shape is no check at all. Refuse anything whose trajectory
+        # fingerprint differs from this cell's.
+        mine = getattr(self, "fingerprint", None)
+        theirs = ckpt.get("fingerprint")
+        if mine is not None and theirs is not None and mine != theirs:
+            raise RuntimeError(
+                "refusing foreign checkpoint: fingerprint %s != %s"
+                % (theirs, mine))
+        if mine is not None and theirs is None:
+            raise RuntimeError(
+                "refusing unfingerprinted checkpoint (pre-contract-r2 run) "
+                "at %s" % ckpt_path)
+        self.model.load_state_dict(ckpt["model_state_dict"])
+        self.optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+        self.scheduler.load_state_dict(ckpt["scheduler_state_dict"])
+        if "scaler_state_dict" in ckpt:
+            self.scaler.load_state_dict(ckpt["scaler_state_dict"])
+        self.start_epoch = ckpt["epoch"]
+        self.best_metric = ckpt["best_metric"]
+        self.patience_counter = ckpt["patience_counter"]
+        self.history = ckpt["history"]
+        self.best_epoch = ckpt.get("best_epoch", -1)
+        self.early_stopped = ckpt.get("early_stopped", False)
+        if ckpt.get("py_rng") is not None:
+            random.setstate(ckpt["py_rng"])
+            np.random.set_state(ckpt["np_rng"])
+            torch.set_rng_state(ckpt["torch_rng"].cpu()
+                                if hasattr(ckpt["torch_rng"], "cpu")
+                                else ckpt["torch_rng"])
+            if ckpt.get("cuda_rng") is not None and torch.cuda.is_available():
+                # torch.load(map_location=device, weights_only=False) moves these onto the GPU;
+                # set_rng_state_all requires CPU ByteTensors.
+                torch.cuda.set_rng_state_all(
+                    [t.cpu() if hasattr(t, "cpu") else t
+                     for t in ckpt["cuda_rng"]])
+            logger.info("  [RNG] restored python/numpy/torch/cuda state")
+        else:
+            raise RuntimeError("checkpoint carries no RNG state; refusing resume")
+        logger.info(
+            f"  Resumed from epoch {self.start_epoch}, "
+            f"best={self.best_metric:.4f}"
+        )
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+
+def main():
+    """Entry point for V8 training."""
+    parser = argparse.ArgumentParser(description="Bertint V8 Training")
+    parser.add_argument(
+        "--csv_path", required=True, help="Path to binding data CSV"
+    )
+    parser.add_argument(
+        "--split_path", required=True, help="Path to glycan-cold splits JSON"
+    )
+    parser.add_argument(
+        "--protein_emb_path", required=True, help="Path to ESM-C HDF5"
+    )
+    parser.add_argument(
+        "--vocab_path", required=True, help="Path to BPE vocab JSON"
+    )
+    parser.add_argument(
+        "--bertose_checkpoint", required=True, help="Bertose checkpoint"
+    )
+    parser.add_argument("--output_dir", required=True, help="Output dir")
+
+    # Model architecture
+    parser.add_argument(
+        "--freeze_layers", type=int, default=4, help="Layers to freeze"
+    )
+    parser.add_argument(
+        "--shared_dim", type=int, default=512, help="Shared dim"
+    )
+    parser.add_argument(
+        "--num_cross_layers", type=int, default=2, help="Cross-attn layers"
+    )
+    parser.add_argument(
+        "--num_heads", type=int, default=8, help="Attention heads"
+    )
+    parser.add_argument(
+        "--swe_slices", type=int, default=512, help="SWE slices"
+    )
+    parser.add_argument(
+        "--dropout", type=float, default=0.1, help="Dropout rate"
+    )
+    parser.add_argument(
+        "--protein_dim", type=int, default=960, help="ESM-C dim"
+    )
+    parser.add_argument(
+        "--separate_swe", action="store_true",
+        help="Use separate SWE modules for glycan and protein"
+    )
+
+    # Training
+    parser.add_argument(
+        "--lr_encoder", type=float, default=1e-5, help="Encoder LR"
+    )
+    parser.add_argument(
+        "--lr_head", type=float, default=1e-4, help="Head LR"
+    )
+    parser.add_argument(
+        "--weight_decay", type=float, default=0.01, help="Weight decay"
+    )
+    parser.add_argument(
+        "--max_grad_norm", type=float, default=1.0, help="Grad clip"
+    )
+    parser.add_argument(
+        "--batch_size", type=int, default=32, help="Batch size"
+    )
+    parser.add_argument(
+        "--epochs", type=int, default=50, help="Max epochs"
+    )
+    parser.add_argument(
+        "--patience", type=int, default=15, help="Early stopping"
+    )
+    parser.add_argument(
+        "--max_glycan_length", type=int, default=256, help="Max glycan len"
+    )
+    parser.add_argument(
+        "--max_protein_length", type=int, default=1024, help="Max protein len"
+    )
+    parser.add_argument("--protein_mode", default="real",
+                        choices=["real","constant"],
+                        help="real | constant (protein input zeroed; NOT the G arm — the "
+                             "protein pathway still exists. Use --glycan_only for G.)")
+    # G arm: do not construct the protein pathway at all. 'constant' only zeroes the
+    # input; projection, cross-attention and the 2x-width head all remain.
+    parser.add_argument("--ranking_loss", action="store_true",
+                        help="within-assay pairwise ranking loss + assay-grouped batches; "
+                             "aligns the objective with the equal-assay macro estimand")
+    parser.add_argument("--assays_per_batch", type=int, default=4)
+    parser.add_argument("--rows_per_assay", type=int, default=8)
+    parser.add_argument("--protein_binding_channel", action="store_true",
+                        help="R2: last protein channel is a per-residue binding "
+                             "probability; pool globally AND binding-weighted, then "
+                             "concatenate (KinForm Eqs 2-5). Use --protein_dim 961.")
+    parser.add_argument("--glycan_only", action="store_true",
+                        help="protected arm G: no protein tensor, mask, projection or "
+                             "cross-attention; head narrows to the glycan width")
+    parser.add_argument("--protein_attentive_pool", action="store_true",
+                        help="arm A: zero-init attentive protein pooling "
+                             "(identical to mean pooling at init)")
+    parser.add_argument(
+        "--motif_additive_dim", type=int, default=0,
+        help="d>0 adds score += w . motif_features over d raw motif counts (released counts 0-13), zero-initialised")
+    parser.add_argument("--glycan_size_channel", action="store_true",
+                        help="Append log1p(glycan token count) to the head input")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    # ---- contract r2 -----------------------------------------------------
+    parser.add_argument("--roles_tsv", required=True)
+    parser.add_argument("--train_stratum", required=True)
+    parser.add_argument("--val_stratum", required=True)
+    parser.add_argument("--test_stratum", required=True)
+    parser.add_argument("--features_dir", required=True)
+    parser.add_argument("--expected_train_rows", type=int, required=True)
+    parser.add_argument("--expected_val_rows", type=int, required=True)
+    parser.add_argument("--expected_test_rows", type=int, required=True)
+    parser.add_argument("--manifest_sha256", required=True)
+    parser.add_argument("--cell_id", required=True)
+    parser.add_argument("--input_hashes", required=True)
+    parser.add_argument(
+        "--warmup_pct", type=float, default=0.05,
+        help="Fraction of total steps for warmup (0.05=5%%, 0.10=10%%)"
+    )
+    parser.add_argument(
+        "--target_col", default="target_rank", help="Target column"
+    )
+    parser.add_argument(
+        "--checkpoint_interval", type=int, default=5, help="Ckpt every N"
+    )
+    parser.add_argument(
+        "--resume", action="store_true", help="Resume from checkpoint"
+    )
+    # Ablation controls
+    parser.add_argument(
+        "--pooling_mode", default="swe",
+        choices=["swe", "mean", "joint_swe"],
+        help="Pooling strategy: swe (default), mean, or joint_swe"
+    )
+    parser.add_argument(
+        "--interaction_mode", default="product_sum",
+        choices=["product_sum", "concat"],
+        help="Interaction: product_sum (default) or concat"
+    )
+    parser.add_argument(
+        "--no_cross_attention", action="store_true",
+        help="Disable cross-attention blocks (ablation)"
+    )
+
+    args = parser.parse_args()
+
+    set_seed(args.seed)
+    logger.info("Bertint V8 Training — Cross-Attention + Live Bertose")
+    logger.info(f"  freeze_layers={args.freeze_layers}")
+    logger.info(f"  lr_encoder={args.lr_encoder}")
+    logger.info(f"  lr_head={args.lr_head}")
+    logger.info(f"  batch_size={args.batch_size}")
+    logger.info(f"  shared_dim={args.shared_dim}")
+    logger.info(f"  cross_layers={args.num_cross_layers}")
+    logger.info(f"  separate_swe={args.separate_swe}")
+    logger.info(f"  pooling_mode={args.pooling_mode}")
+    logger.info(f"  interaction_mode={args.interaction_mode}")
+    logger.info(f"  cross_attention={not args.no_cross_attention}")
+
+    # Load datasets
+    logger.info("\nLoading datasets...")
+    train_ds = BertintV8Dataset(
+        args.csv_path, args.split_path, "train",
+        args.protein_emb_path, args.vocab_path,
+        max_glycan_length=args.max_glycan_length,
+        max_protein_length=args.max_protein_length,
+        target_col=args.target_col,
+        roles_path=args.roles_tsv,
+        stratum=args.train_stratum,
+        features_dir=args.features_dir,
+        expected_rows=args.expected_train_rows,
+    )
+    val_ds = BertintV8Dataset(
+        args.csv_path, args.split_path, "val",
+        args.protein_emb_path, args.vocab_path,
+        max_glycan_length=args.max_glycan_length,
+        max_protein_length=args.max_protein_length,
+        target_col=args.target_col,
+        roles_path=args.roles_tsv,
+        stratum=args.val_stratum,
+        features_dir=args.features_dir,
+        expected_rows=args.expected_val_rows,
+    )
+    test_ds = BertintV8Dataset(
+        args.csv_path, args.split_path, "test",
+        args.protein_emb_path, args.vocab_path,
+        max_glycan_length=args.max_glycan_length,
+        max_protein_length=args.max_protein_length,
+        target_col=args.target_col,
+        roles_path=args.roles_tsv,
+        stratum=args.test_stratum,
+        features_dir=args.features_dir,
+        expected_rows=args.expected_test_rows,
+    )
+
+    if args.ranking_loss:
+        # ⛔ TRAIN ONLY. val/test keep plain batching + shuffle=False so the macro is computed
+        # exactly as it was for every previously reported arm.
+        _sampler = AssayGroupedBatchSampler(
+            train_ds.records["exp_id"].values,
+            args.assays_per_batch, args.rows_per_assay, seed=args.seed)
+        train_loader = DataLoader(
+            train_ds, batch_sampler=_sampler,
+            num_workers=4, pin_memory=True, collate_fn=collate_fn,
+        )
+    else:
+        train_loader = DataLoader(
+            train_ds, batch_size=args.batch_size, shuffle=True,
+            num_workers=4, pin_memory=True, collate_fn=collate_fn,
+        )
+    val_loader = DataLoader(
+        val_ds, batch_size=args.batch_size, shuffle=False,
+        num_workers=2, pin_memory=True, collate_fn=collate_fn,
+    )
+    test_loader = DataLoader(
+        test_ds, batch_size=args.batch_size, shuffle=False,
+        num_workers=2, pin_memory=True, collate_fn=collate_fn,
+    )
+
+    # Build model
+    logger.info("\nBuilding model...")
+    config, seq_emb, seq_layers = load_bertose_encoder(
+        args.bertose_checkpoint, freeze_layers=args.freeze_layers
+    )
+
+    model = BertintV8(
+        seq_embeddings=seq_emb,
+        seq_layers=seq_layers,
+        glycan_dim=config.seq_hidden_size,
+        protein_dim=args.protein_dim,
+        shared_dim=args.shared_dim,
+        num_cross_layers=args.num_cross_layers,
+        num_heads=args.num_heads,
+        swe_slices=args.swe_slices,
+        dropout=args.dropout,
+        separate_swe=args.separate_swe,
+        pooling_mode=args.pooling_mode,
+        interaction_mode=args.interaction_mode,
+        use_cross_attention=not args.no_cross_attention,
+        glycan_size_channel=args.glycan_size_channel,
+        motif_additive_dim=args.motif_additive_dim,
+        protein_mode=args.protein_mode,
+        protein_attentive_pool=args.protein_attentive_pool,
+        protein_tower=not args.glycan_only,
+        protein_binding_channel=args.protein_binding_channel,
+    )
+
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(
+        p.numel() for p in model.parameters() if p.requires_grad
+    )
+    logger.info(f"  Total params: {total_params:,}")
+    logger.info(f"  Trainable:    {trainable_params:,}")
+
+    # Loss
+    criterion = (WithinAssayPairwiseLoss(args.assays_per_batch, args.rows_per_assay)
+                 if args.ranking_loss else BertintV8Loss())
+    logger.info("  objective: %s", type(criterion).__name__)
+
+    # ---------------- CONTRACT r2: seal inputs, then fingerprint -----------
+    def _sha_file(p):
+        h = hashlib.sha256()
+        with open(p, "rb") as fh:
+            for c in iter(lambda: fh.read(1 << 22), b""):
+                h.update(c)
+        return h.hexdigest()
+
+    _here = os.path.dirname(os.path.abspath(__file__))
+    _feat = args.features_dir
+    _sealed = {
+        "csv": args.csv_path,
+        "roles_tsv": args.roles_tsv,
+        "protein_emb_h5": args.protein_emb_path,
+        "vocabulary": args.vocab_path,
+        "upstream_checkpoint": args.bertose_checkpoint,
+        "dataset_v8.py": os.path.join(_here, "dataset_v8.py"),
+        "training_v8.py": os.path.abspath(__file__),
+        "bertint_v8.py": os.path.join(_here, "bertint_v8.py"),
+        "a1111_encoder_adapter.py": os.path.join(_here, "a1111_encoder_adapter.py"),
+    }
+    for _n in ("token_ids", "branch_depths", "linkage_types", "attention_mask",
+               "tree_channels_valid", "motif_features"):
+        _sealed["feature_" + _n] = os.path.join(_feat, "review_%s.npy" % _n)
+    _sealed["feature_index"] = os.path.join(_feat, "review_affinose_glycan_index.tsv.gz")
+
+    _hashes = {}
+    for _k, _p in _sealed.items():
+        if not os.path.isfile(_p):
+            raise RuntimeError("sealed input missing: %s -> %s" % (_k, _p))
+        _hashes[_k] = _sha_file(_p)
+
+    # every dynamically resolved module under the port tree or bertose root
+    _imports = {}
+    for _m in list(sys.modules.values()):
+        _f = getattr(_m, "__file__", None)
+        if not _f or not os.path.isfile(_f):
+            continue
+        _fa = os.path.abspath(_f)
+        if _fa.startswith(_here) or "/bertose" in _fa or "/glycan-SD-VS/" in _fa:
+            _imports[_fa] = _sha_file(_fa)
+    _hashes["_imported_modules"] = _imports
+    logger.info("  [SEAL] hashed %d artifacts + %d imported modules"
+                % (len(_sealed), len(_imports)))
+
+    # ENFORCE against the pinned expectation file, if supplied
+    if getattr(args, "input_hashes", None):
+        with open(args.input_hashes) as _fh:
+            _exp = json.load(_fh)
+        _bad = []
+        for _k, _v in _exp.items():
+            if _k.startswith("_"):
+                continue
+            if _hashes.get(_k) != _v:
+                _bad.append("%s: got %s expected %s"
+                            % (_k, str(_hashes.get(_k))[:16], str(_v)[:16]))
+        if _bad:
+            raise RuntimeError("SEALED INPUT HASH DRIFT:\n  " + "\n  ".join(_bad))
+        logger.info("  [SEAL] all %d pinned hashes match" % len(
+            [k for k in _exp if not k.startswith("_")]))
+    else:
+        raise RuntimeError("--input_hashes is required under contract r2")
+
+    # roster identity, not just a count
+    _roster = {}
+    for _split, _ds in (("train", train_ds), ("val", val_ds), ("test", test_ds)):
+        _h = hashlib.sha256()
+        _r = _ds.records
+        for _i, _row in enumerate(zip(_r["protein_id"], _r["glycan_wurcs"],
+                                      _r.get("exp_id", _r["protein_id"]))):
+            _h.update(("%d|%s|%s|%s\n" % (_i, _row[0], _row[1], _row[2])).encode())
+        _roster[_split] = _h.hexdigest()
+    _hashes["_roster_digests"] = _roster
+    logger.info("  [SEAL] roster digests train=%s val=%s test=%s"
+                % (_roster["train"][:16], _roster["val"][:16], _roster["test"][:16]))
+
+    _fp = hashlib.sha256("|".join([
+        args.manifest_sha256, args.cell_id, str(args.seed),
+        args.train_stratum, args.val_stratum, args.test_stratum,
+        str(args.expected_train_rows), str(args.expected_val_rows),
+        str(args.expected_test_rows),
+        _hashes["upstream_checkpoint"], _hashes["dataset_v8.py"],
+        _hashes["training_v8.py"], _hashes["bertint_v8.py"],
+        _roster["train"], _roster["val"], _roster["test"],
+        str(args.epochs), str(args.batch_size), str(args.lr_encoder),
+        str(args.lr_head), str(args.freeze_layers), str(args.warmup_pct),
+    ]).encode()).hexdigest()
+    logger.info("  [FINGERPRINT] %s  cell=%s" % (_fp[:16], args.cell_id))
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    with open(os.path.join(args.output_dir, "receipt.json"), "w") as _fh:
+        json.dump({"cell_id": args.cell_id, "fingerprint": _fp,
+                   "manifest_sha256": args.manifest_sha256,
+                   "args": vars(args), "input_hashes": _hashes,
+                   "roster_digests": _roster,
+                   "slurm_job_id": os.environ.get("SLURM_JOB_ID"),
+                   "slurm_array_task_id": os.environ.get("SLURM_ARRAY_TASK_ID"),
+                   "slurm_restart_count": os.environ.get("SLURM_RESTART_COUNT"),
+                   "node": os.environ.get("SLURMD_NODENAME"),
+                   "gpu": (torch.cuda.get_device_name(0)
+                           if torch.cuda.is_available() else None)},
+                  _fh, indent=2, default=str)
+
+    # Train
+    trainer = BertintV8Trainer(
+        model=model,
+        criterion=criterion,
+        train_loader=train_loader,
+        val_loader=val_loader,
+        test_loader=test_loader,
+        output_dir=args.output_dir,
+        lr_encoder=args.lr_encoder,
+        lr_head=args.lr_head,
+        weight_decay=args.weight_decay,
+        max_grad_norm=args.max_grad_norm,
+        epochs=args.epochs,
+        patience=args.patience,
+        checkpoint_interval=args.checkpoint_interval,
+        resume=args.resume,
+        warmup_pct=args.warmup_pct,
+        fingerprint=_fp,
+        input_hashes=_hashes,
+    )
+    trainer.architecture_label = (
+        "cross-attention=%s pooling=%s interaction=%s + live Bertose"
+        % (not args.no_cross_attention if hasattr(args, "no_cross_attention") else True,
+           args.pooling_mode, args.interaction_mode))
+
+    results = trainer.train()
+    logger.info("\nTraining complete!")
+
+
+if __name__ == "__main__":
+    main()

releases/2026-10-02/benchmark_exclusion/MANIFEST_SHA256.tsv

@@ -0,0 +1,11 @@
+sha256	path
+1db45969e1c06f12c1d8d2df35a166cb65c4ce0bf603aabebc2e6689bedc8e72	README.md
+e2e0dfa7d133362146de10ba3dd774e9a3e186088f976189b0aae9d26b442bc4	code_inventory.tsv
+050c0af96f133ded3139baf6dfea594f91c6659f411dc25fc06d5847951b2f0c	required_successor_inputs.json
+0507537ca8ee05b249f9ab3f3fa09de94b7acc633b91235f2778ae07659096bd	source_verification.json
+3d598a249db90c928f8a317923ba5d37eebbc1f63383a2c39e0541f20c31ccac	writing/review/glytoucan/scripts/build_connection_level_support_audit.py
+a9160769759c1df56238caad6a9f4ed6ec68477d44435ebbc81d64bbf541b64c	writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py
+0f88f53e22d0c068a87a09508a9d286e4982eddcb4e2154e63b2ca25339ece69	writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py
+2c8821586df1caa53556b4cc14e6cd7507af4830aa8a149657571e0455eb6853	writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py
+cd86a0a0b228c32e51ec73490711e37da3e6c9fdf9e64e980b7222b5312484aa	writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py
+966889118fa567729e1959750b1601018ba117aed0bfad3508005ba6b1896a08	writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py

releases/2026-10-02/benchmark_exclusion/README.md

@@ -0,0 +1,60 @@
+# Benchmark-identity exclusion and partition code
+
+This folder supplies the five exclusion/partition scripts named in `BENCHMARK_IDENTITY_EXCLUSION_3833_20260922.md`, plus their only imported local helper. These are byte-identical copies of the original sources. This folder is included in the submission code package and reviewer ZIP. The matching exclusion lists and count tables are in `04_source_data/benchmark_exclusion` in the full submission folder.
+
+The fifth requested file is in `multimodal/tests/`, not `multimodal/scripts/`. Relative project structure is preserved below `writing/review/` because the source resolves its inputs and helper imports from its own path. `code_inventory.tsv` records each original path, SHA-256 and copied path.
+
+## What the code does
+
+1. `build_p1_direct_local_neighbor_audit_20260710.py` parses fixed-linkage residue trees and retrieves candidate matches using a three-iteration Weisfeiler–Lehman hash. Graphs contain residue nodes labelled by the complete WURCS residue-definition string and intermediate `BOND` nodes; edges carry the corresponding endpoint position. WL uses SHA-256 label strings, edge positions and a 32-byte digest. Exact NetworkX isomorphism confirms equality of original node `label` and edge `position` attributes. Hash agreement alone is not identity evidence. The script also measures other neighbour relations for separate analyses.
+2. `build_p1_non_iar_exact_graph_authority_20260711.py` excludes sequence parents only by exact canonical WURCS string or confirmed graph identity. It filters out GlyCosmos IAR and grey-seal-only anchor memberships. A glycan also carrying another active endpoint role remains an anchor. One-edit neighbours, motifs and substructures do not cause exclusion.
+3. `repartition_a5_non_iar_80_20_20260712.py` assigns whole precluster blocks, deterministically ordered by a salted hash, using the weighted cumulative midpoint relative to the 80% target. It verifies no retained group crosses training/development for block, raw feature hash or registry family.
+4. `build_review_a5_non_iar_later_role_successor_20260720.py` adds 93 later strict interaction non-fit anchors. It requires 73 newly excluded parents, all exact matches, with no new graph-only aliases; 59 training and 14 development parents change to excluded while every other role is preserved. Its invariants require 3,673 exact matches plus 160 graph-only matches, 3,833 exclusions, 221,899 training parents and 55,476 development parents.
+5. `test_build_review_a5_non_iar_later_role_successor_20260720.py` validates the existing successor outputs and their receipts. It does not build the inputs.
+
+Graph matching covers connected residue trees with fully specified linkage positions, **not necessarily completely specified residue stereochemistry**. Full residue-definition strings must match, including any unresolved residue annotations. Non-fixed structures receive exact-string matching only. Exclusion of matching identities does not establish motif-family or biosynthetic-family novelty.
+
+## Environment and checks
+
+Python 3.10 or newer is needed by the source syntax. The graph verifier imports `networkx`; its local parser helper imports `pandas`. The other four requested files use the standard library. Historical dependency versions are not pinned by these sources; no historical environment is asserted here.
+
+Preparation checked syntax with Python 3.12.14 and verified all six copied files byte for byte. Three standard-library builder `--help` entry points were checked. Local pandas metadata is 2.2.3; NetworkX is unavailable in that interpreter, so the graph module import/self-test was not run. No packages were installed. No exclusion scan, full builder, model inference, training, or payload-based test suite was run.
+
+## Inputs needed for replay
+
+This is a source bundle, not a self-contained data release. Original frozen data remain outside it. Restore the named inputs in the matching project layout before running a builder. Do not replace pinned files with newer files of the same name.
+
+- Initial graph audit: role-complete anchor manifest, frozen motif/fingerprint manifest and objective-eligibility manifest. The anchor-producing and fingerprint-producing pipelines are upstream prerequisites, not imported dependencies bundled here.
+- Initial exclusion authority: role-complete anchor manifest, graph-neighbour edge ledger, and parent-identity manifest.
+- 80/20 partition: the frozen July 11 parent/objective partition precursor plus fingerprints and parent identities. This precursor is a required input; the five scripts are not a continuous from-raw-data pipeline.
+- Successor: the 22 exact path/hash inputs in `required_successor_inputs.json`, plus role CSVs named by the strict classification authority JSON. The source validates their expected hashes before processing. It also records the supplied test source.
+- Tests: the successor output directory and original 80/20 predecessor parent partition.
+
+`required_successor_inputs.json` records the hashes declared by the unchanged source and whether the inputs exist locally; this preparation did not freshly hash or copy the data payloads. Source constants additionally document the first three steps' input paths and, where available, required input hashes.
+
+## Commands
+
+Run from this folder with the required dependencies installed in your selected environment. Help commands do not scan data:
+
+```sh
+python3 writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py --help
+python3 writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py --help
+python3 writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py --help
+python3 writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py --help
+```
+
+The following full replay commands are documented from the CLI/source and were **not executed** during preparation. Run each only after restoring its exact frozen inputs; choose a fresh output directory. Do not overwrite original scientific artifacts.
+
+```sh
+python3 writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py --anchor-manifest writing/review/multimodal/outputs/p1_role_complete_anchor_union_20260711/review_p1_role_complete_anchor_manifest.tsv.gz --final-anchor-authority --output-dir replay/graph_audit
+python3 writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py --output-dir replay/exclusion_authority
+python3 writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py --output-directory replay/partition_80_20
+python3 writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py --output-directory replay/later_role_successor
+REVIEW_A5_NON_IAR_SUCCESSOR_OUTPUT=replay/later_role_successor python3 writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py
+```
+
+These commands use frozen predecessor inputs at their source-declared paths; later steps do not automatically consume preceding `replay/` outputs. The successor has source-bound input hashes and cannot be redirected through arbitrary replacement datasets. Its receipt contains execution paths, so receipt bytes need not match when replayed at a new location even when deterministic payload bytes match.
+
+## Verification boundary
+
+See `source_verification.json` for line anchors, source hashes and preparation checks. The arithmetic is enforced by source invariants and supported by saved artifacts; this candidate preparation is not a fresh numerical reproduction of the 3,833-parent result, a checkpoint certification, or a claim that later AFFINose splits were all represented in these pretraining-time anchors.

releases/2026-10-02/benchmark_exclusion/SHA256SUMS

@@ -0,0 +1,11 @@
+8452e3ac521af1d3ea24bb5a99e02a930d913fc96394e5610fe8b86e19ea89ec  MANIFEST_SHA256.tsv
+96567c3b9c3e254bceb6bd82e43c1f252b987ced58dad41d3b4406b9f58a76ec  README.md
+e2e0dfa7d133362146de10ba3dd774e9a3e186088f976189b0aae9d26b442bc4  code_inventory.tsv
+050c0af96f133ded3139baf6dfea594f91c6659f411dc25fc06d5847951b2f0c  required_successor_inputs.json
+0507537ca8ee05b249f9ab3f3fa09de94b7acc633b91235f2778ae07659096bd  source_verification.json
+3d598a249db90c928f8a317923ba5d37eebbc1f63383a2c39e0541f20c31ccac  writing/review/glytoucan/scripts/build_connection_level_support_audit.py
+a9160769759c1df56238caad6a9f4ed6ec68477d44435ebbc81d64bbf541b64c  writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py
+0f88f53e22d0c068a87a09508a9d286e4982eddcb4e2154e63b2ca25339ece69  writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py
+2c8821586df1caa53556b4cc14e6cd7507af4830aa8a149657571e0455eb6853  writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py
+cd86a0a0b228c32e51ec73490711e37da3e6c9fdf9e64e980b7222b5312484aa  writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py
+966889118fa567729e1959750b1601018ba117aed0bfad3508005ba6b1896a08  writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py

releases/2026-10-02/benchmark_exclusion/code_inventory.tsv

@@ -0,0 +1,7 @@
+original_path	candidate_path	sha256	bytes	unchanged
+/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py	writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py	a9160769759c1df56238caad6a9f4ed6ec68477d44435ebbc81d64bbf541b64c	36975	True
+/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py	writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py	0f88f53e22d0c068a87a09508a9d286e4982eddcb4e2154e63b2ca25339ece69	15043	True
+/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py	writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py	cd86a0a0b228c32e51ec73490711e37da3e6c9fdf9e64e980b7222b5312484aa	14084	True
+/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py	writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py	2c8821586df1caa53556b4cc14e6cd7507af4830aa8a149657571e0455eb6853	38441	True
+/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py	writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py	966889118fa567729e1959750b1601018ba117aed0bfad3508005ba6b1896a08	7856	True
+/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/glytoucan/scripts/build_connection_level_support_audit.py	writing/review/glytoucan/scripts/build_connection_level_support_audit.py	3d598a249db90c928f8a317923ba5d37eebbc1f63383a2c39e0541f20c31ccac	21842	True

releases/2026-10-02/benchmark_exclusion/required_successor_inputs.json

@@ -0,0 +1,203 @@
+{
+  "scope": "Exact source-pinned input list; data hashes are not freshly recomputed here. Strict3 JSON additionally names role CSV files which the builder hashes at runtime. Original dataset payloads are not bundled.",
+  "inputs": [
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p1_non_iar_exact_graph_authority_20260711/review_p1_non_iar_anchor_manifest.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p1_non_iar_exact_graph_authority_20260711/review_p1_non_iar_anchor_manifest.tsv.gz",
+      "expected_sha256_from_successor_source": "048facdfd9a5ff15f1295d28f1d07b4dae2c656ca8714c3ed06df9e284ac199a",
+      "locally_exists": true,
+      "local_bytes": 113824,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p1_non_iar_exact_graph_authority_20260711/review_p1_non_iar_exact_graph_parent_manifest.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p1_non_iar_exact_graph_authority_20260711/review_p1_non_iar_exact_graph_parent_manifest.tsv.gz",
+      "expected_sha256_from_successor_source": "088971d5dbe61f840a45a67a84df39478edd7a80089fd6528fd9fda8063b26b9",
+      "locally_exists": true,
+      "local_bytes": 3857629,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p1_non_iar_pretraining_partition_80_20_20260712/review_p1_non_iar_pretraining_parent_partition.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p1_non_iar_pretraining_partition_80_20_20260712/review_p1_non_iar_pretraining_parent_partition.tsv.gz",
+      "expected_sha256_from_successor_source": "7c4ed33a6cbf50df8d3264421c652c480d3a5eff0eace10c3c958e6dac6b2160",
+      "locally_exists": true,
+      "local_bytes": 12149150,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p1_non_iar_pretraining_partition_80_20_20260712/review_p1_non_iar_pretraining_objective_partition.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p1_non_iar_pretraining_partition_80_20_20260712/review_p1_non_iar_pretraining_objective_partition.tsv.gz",
+      "expected_sha256_from_successor_source": "d09eebb3f7ac47058d2d0cabfd42905f624581bf4c942dceac9cad9c1973e5a0",
+      "locally_exists": true,
+      "local_bytes": 4238642,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p0_p1_freeze_20260710/review_p1_wurcs_motif_fingerprint_manifest.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p0_p1_freeze_20260710/review_p1_wurcs_motif_fingerprint_manifest.tsv.gz",
+      "expected_sha256_from_successor_source": "69994cbc859146e97867e62669fd9f71b8d02140ecd9ae8056375af608afdcab",
+      "locally_exists": true,
+      "local_bytes": 167661349,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p0_p1_freeze_20260710/review_p1_parent_identity_manifest.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p0_p1_freeze_20260710/review_p1_parent_identity_manifest.tsv.gz",
+      "expected_sha256_from_successor_source": "55b830d839370c0cec0aab2b61b4721e6ace9ba3ee49e4c93e7be6e486d1c5c4",
+      "locally_exists": true,
+      "local_bytes": 33418108,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p1_role_complete_direct_local_neighbor_audit_20260711/review_p1_direct_local_neighbor_edges.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p1_role_complete_direct_local_neighbor_audit_20260711/review_p1_direct_local_neighbor_edges.tsv.gz",
+      "expected_sha256_from_successor_source": "e95d8122449f4b91271fd297be41a7912244f2398739e349064fc55b781e3ae0",
+      "locally_exists": true,
+      "local_bytes": 1457038,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py",
+      "candidate_relative_path": "writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py",
+      "expected_sha256_from_successor_source": "a9160769759c1df56238caad6a9f4ed6ec68477d44435ebbc81d64bbf541b64c",
+      "locally_exists": true,
+      "local_bytes": 36975,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/review_a5_downstream_strict3_authority_20260720_r2/review_a5_downstream_strict3_authority.json",
+      "candidate_relative_path": "writing/review/multimodal/outputs/review_a5_downstream_strict3_authority_20260720_r2/review_a5_downstream_strict3_authority.json",
+      "expected_sha256_from_successor_source": "c1bbcfe410c0ee78824657da84a4055e58fdf196624d8981e1aa239ae629f1d8",
+      "locally_exists": true,
+      "local_bytes": 91064,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p1_affinose_motif_scaffold_balanced_k20_20260711/review_p1_affinose_balanced_k20_a5_anchors.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p1_affinose_motif_scaffold_balanced_k20_20260711/review_p1_affinose_balanced_k20_a5_anchors.tsv.gz",
+      "expected_sha256_from_successor_source": "cdeb7b4075f00efc50c0649ac4be11560154e29a6a728c4ddeb54dd6bc26f6c9",
+      "locally_exists": true,
+      "local_bytes": 8489,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/review_a5_affinose_strict_glycan_components_20260720_r1/review_a5_affinose_strict_glycan_nonfit_anchors_20260720.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/review_a5_affinose_strict_glycan_components_20260720_r1/review_a5_affinose_strict_glycan_nonfit_anchors_20260720.tsv.gz",
+      "expected_sha256_from_successor_source": "85c8f760dba0e11a4346cd07bc7eb09f5f31d6bf1b0407658130da4173f8a5f9",
+      "locally_exists": true,
+      "local_bytes": 29453,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/review_a5_affinose_strict_glycan_components_20260720_r1/review_a5_affinose_strict_glycan_candidate_summary_20260720.json",
+      "candidate_relative_path": "writing/review/multimodal/outputs/review_a5_affinose_strict_glycan_components_20260720_r1/review_a5_affinose_strict_glycan_candidate_summary_20260720.json",
+      "expected_sha256_from_successor_source": "d1a56f0bb7f77535c619cc2739933bd751cb5d3e3fcd2e8175fc88671e83e6ee",
+      "locally_exists": true,
+      "local_bytes": 29848,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/review_a5_affinose_strict_glycan_components_20260720_r1/review_a5_affinose_strict_glycan_candidate_verification_receipt_20260720.json",
+      "candidate_relative_path": "writing/review/multimodal/outputs/review_a5_affinose_strict_glycan_components_20260720_r1/review_a5_affinose_strict_glycan_candidate_verification_receipt_20260720.json",
+      "expected_sha256_from_successor_source": "a92f442f2b74e630783b5a0eb6fb16738d6aa4c86f71b28c487cc42622d3eee1",
+      "locally_exists": true,
+      "local_bytes": 5962,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/data/review_sequences_a5_non_iar_80_20_parser_v3_failclosed_20260720_r3/review_sequence_parent_index.tsv.gz",
+      "candidate_relative_path": "data/review_sequences_a5_non_iar_80_20_parser_v3_failclosed_20260720_r3/review_sequence_parent_index.tsv.gz",
+      "expected_sha256_from_successor_source": "c61e766dbffc4a1d88c7c7fb94deb683943c0861403350e79ab09c70b317fa52",
+      "locally_exists": true,
+      "local_bytes": 17392883,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/review_a5_affinose_p6_observation_authority_20260720_r2/review_a5_affinose_p6_failclosed_authority_20260720.json",
+      "candidate_relative_path": "writing/review/multimodal/outputs/review_a5_affinose_p6_observation_authority_20260720_r2/review_a5_affinose_p6_failclosed_authority_20260720.json",
+      "expected_sha256_from_successor_source": "a77e486e200e50e9becb3ad45f70ef97272b5a339267c636d746af8d9bf2b2b5",
+      "locally_exists": true,
+      "local_bytes": 22820,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/review_a5_affinose_p6_observation_authority_20260720_r2/review_a5_affinose_p6_failclosed_receipt_20260720.json",
+      "candidate_relative_path": "writing/review/multimodal/outputs/review_a5_affinose_p6_observation_authority_20260720_r2/review_a5_affinose_p6_failclosed_receipt_20260720.json",
+      "expected_sha256_from_successor_source": "d6fb00bd5a79d5a1caa9d06f440357202d85bb6cb3f33c7732f063b4721cf23f",
+      "locally_exists": true,
+      "local_bytes": 2652,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/P0_P1_non_iar_authority_correction_20260711.md",
+      "candidate_relative_path": "writing/review/multimodal/P0_P1_non_iar_authority_correction_20260711.md",
+      "expected_sha256_from_successor_source": "f7ba54c4ec66b74e0061ffa75bd963af9589f28a7124e95208099f169657936f",
+      "locally_exists": true,
+      "local_bytes": 5448,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/P1_parent_split_refit_contract_20260710.md",
+      "candidate_relative_path": "writing/review/multimodal/P1_parent_split_refit_contract_20260710.md",
+      "expected_sha256_from_successor_source": "2533d651ccbf6d86111709676bf528d7c805d1df214ada62fd45772dda0f388e",
+      "locally_exists": true,
+      "local_bytes": 22645,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/P1_reviewer_complete_generalization_protocol_20260710.md",
+      "candidate_relative_path": "writing/review/multimodal/P1_reviewer_complete_generalization_protocol_20260710.md",
+      "expected_sha256_from_successor_source": "9556f456490bdd7e03926cc78d9c0a73146386a9b7ac7188a556b1bc23c37b4a",
+      "locally_exists": true,
+      "local_bytes": 27011,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/review_a5_interaction_endpoint_adjudication_20260720.md",
+      "candidate_relative_path": "writing/review/multimodal/review_a5_interaction_endpoint_adjudication_20260720.md",
+      "expected_sha256_from_successor_source": "614a4e2144dda63538a26dcbd8fce0a9d604a97c2b4ad07cf80820407ca29fdb",
+      "locally_exists": true,
+      "local_bytes": 24284,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p1_a5_ms_harmonized_identity_repair_20260720_r1/review_a5_ms_repaired_parent_manifest.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p1_a5_ms_harmonized_identity_repair_20260720_r1/review_a5_ms_repaired_parent_manifest.tsv.gz",
+      "expected_sha256_from_successor_source": "f4abd4b186f5f4758918b89f19870bc112a7c6be6085f870208235cd03005e26",
+      "locally_exists": true,
+      "local_bytes": 209281,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/outputs/p1_a5_static_repair_child_authority_20260720_r1/review_a5_static_repair_child_authority.tsv.gz",
+      "candidate_relative_path": "writing/review/multimodal/outputs/p1_a5_static_repair_child_authority_20260720_r1/review_a5_static_repair_child_authority.tsv.gz",
+      "expected_sha256_from_successor_source": "2ca981b78bca56928d449d35467671b03db515496ac61162e68f8a1381a3661f",
+      "locally_exists": true,
+      "local_bytes": 10920113,
+      "payload_copied": false,
+      "hash_freshly_checked": false
+    }
+  ]
+}

releases/2026-10-02/benchmark_exclusion/source_verification.json

@@ -0,0 +1,124 @@
+{
+  "status": "PASS_STATIC_SOURCE_AND_UNCHANGED_CANDIDATE_PREPARATION",
+  "checked_utc": "2026-09-23T00:13:39.128129+00:00",
+  "source_report": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/BENCHMARK_IDENTITY_EXCLUSION_3833_20260922.md",
+  "files": [
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py",
+      "candidate_path": "writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py",
+      "sha256": "a9160769759c1df56238caad6a9f4ed6ec68477d44435ebbc81d64bbf541b64c",
+      "bytes": 36975,
+      "unchanged": true,
+      "role": "requested_script",
+      "present_in_shipped_06_code": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py",
+      "candidate_path": "writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py",
+      "sha256": "0f88f53e22d0c068a87a09508a9d286e4982eddcb4e2154e63b2ca25339ece69",
+      "bytes": 15043,
+      "unchanged": true,
+      "role": "requested_script",
+      "present_in_shipped_06_code": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py",
+      "candidate_path": "writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py",
+      "sha256": "cd86a0a0b228c32e51ec73490711e37da3e6c9fdf9e64e980b7222b5312484aa",
+      "bytes": 14084,
+      "unchanged": true,
+      "role": "requested_script",
+      "present_in_shipped_06_code": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py",
+      "candidate_path": "writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py",
+      "sha256": "2c8821586df1caa53556b4cc14e6cd7507af4830aa8a149657571e0455eb6853",
+      "bytes": 38441,
+      "unchanged": true,
+      "role": "requested_script",
+      "present_in_shipped_06_code": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py",
+      "candidate_path": "writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py",
+      "sha256": "966889118fa567729e1959750b1601018ba117aed0bfad3508005ba6b1896a08",
+      "bytes": 7856,
+      "unchanged": true,
+      "role": "requested_script",
+      "present_in_shipped_06_code": false
+    },
+    {
+      "original_path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/glytoucan/scripts/build_connection_level_support_audit.py",
+      "candidate_path": "writing/review/glytoucan/scripts/build_connection_level_support_audit.py",
+      "sha256": "3d598a249db90c928f8a317923ba5d37eebbc1f63383a2c39e0541f20c31ccac",
+      "bytes": 21842,
+      "unchanged": true,
+      "role": "local_import_helper",
+      "present_in_shipped_06_code": false
+    }
+  ],
+  "python_for_syntax_check": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]",
+  "local_dependency_metadata": {
+    "networkx": "unavailable in this interpreter",
+    "pandas": "2.2.3"
+  },
+  "checks": {
+    "six_python_files_ast_parse": true,
+    "all_copies_byte_identical": true,
+    "all_five_requested_scripts_absent_from_shipped_code": true,
+    "no_science_pipeline_run": true,
+    "shipped_code_and_zip_untouched": true,
+    "cli_help_checks": [
+      {
+        "file": "writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py",
+        "command": "python -B FILE --help",
+        "returncode": 0,
+        "output": "usage: build_p1_non_iar_exact_graph_authority_20260711.py [-h]\n                                                          [--anchor-manifest ANCHOR_MANIFEST]\n                                                          [--graph-edges GRAPH_EDGES]\n                                                          [--parent-manifest PARENT_MANIFEST]\n                                                          [--output-dir OUTPUT_DIR]\n\noptions:\n  -h, --help            show this help message and exit\n  --anchor-manifest ANCHOR_MANIFEST\n  --graph-edges GRAPH_EDGES\n  --parent-manifest PARENT_MANIFEST\n  --output-dir OUTPUT_DIR\n",
+        "stderr": ""
+      },
+      {
+        "file": "writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py",
+        "command": "python -B FILE --help",
+        "returncode": 0,
+        "output": "usage: repartition_a5_non_iar_80_20_20260712.py [-h]\n                                                [--source-parent SOURCE_PARENT]\n                                                [--source-objective SOURCE_OBJECTIVE]\n                                                [--fingerprints FINGERPRINTS]\n                                                [--identity IDENTITY]\n                                                [--output-directory OUTPUT_DIRECTORY]\n\noptions:\n  -h, --help            show this help message and exit\n  --source-parent SOURCE_PARENT\n  --source-objective SOURCE_OBJECTIVE\n  --fingerprints FINGERPRINTS\n  --identity IDENTITY\n  --output-directory OUTPUT_DIRECTORY\n",
+        "stderr": ""
+      },
+      {
+        "file": "writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py",
+        "command": "python -B FILE --help",
+        "returncode": 0,
+        "output": "usage: build_review_a5_non_iar_later_role_successor_20260720.py\n       [-h] [--output-directory OUTPUT_DIRECTORY]\n\noptions:\n  -h, --help            show this help message and exit\n  --output-directory OUTPUT_DIRECTORY\n",
+        "stderr": ""
+      }
+    ]
+  },
+  "findings": [
+    "Graph retrieval uses WL on SHA256 residue-label strings and BOND labels with edge endpoint positions, 3 iterations, digest_size32; exact isomorphism confirms original label and position equality.",
+    "Graph representation is a bipartite residue-bond tree; only fixed_tree_exact_linkage anchors/parents enter graph checks.",
+    "The fixed-tree tier does not require completely specified residue stereochemistry: prefer connected residue trees with fully specified linkages.",
+    "Authority includes exact string OR graph identity only; near neighbours and shared motifs are not exclusion criteria.",
+    "IAR-only GlyCosmos and grey-seal memberships are dropped; a glycan with another active benchmark role remains an anchor.",
+    "Successor checks93 added anchors,73 additional exact parents,0 additional graph-only aliases,59 train+14 dev moves,final3833 exclusions; all other roles are unchanged.",
+    "Fifth named script is under multimodal/tests/, not multimodal/scripts/."
+  ],
+  "limits": [
+    "Counts are checked as source-enforced invariants and previously saved evidence; no new full data recount or science pipeline run.",
+    "Frozen upstream input payloads and parent-partition precursor are required; this is not a self-contained dataset release.",
+    "NetworkX/pandas historical version pins are not established by these scripts.",
+    "The full payload-based successor tests were not rerun; they reopen large existing manifests."
+  ],
+  "line_evidence": {
+    "graph_parser_WL_and_isomorphism": "build_p1_direct_local_neighbor_audit_20260710.py:47-49,111-197,449-452,517-520,576-588,695-734",
+    "IAR_source_filter_and_identity_OR": "build_p1_non_iar_exact_graph_authority_20260711.py:55-59,119-151,226-244",
+    "whole_block_split": "repartition_a5_non_iar_80_20_20260712.py:118-150,220-233",
+    "successor_anchor_and_role_rules": "build_review_a5_non_iar_later_role_successor_20260720.py:294-298,338-359,383-438,447-484",
+    "tier_definition_source_not_copied": "multimodal/scripts/build_p1_wurcs_motif_fingerprints_20260710.py:147-213"
+  },
+  "tier_definition_source": {
+    "path": "/Users/supantha/Documents/esm-g/plan/bert_training_v3/v3.1_cluster_training/writing/review/multimodal/scripts/build_p1_wurcs_motif_fingerprints_20260710.py",
+    "sha256": "b0d2ca8d60722f144d988e59e3281017879890f88f50a3ba93d603f05236401f",
+    "copied": false,
+    "reason": "Source of prerequisite fingerprint tier, not an imported runtime dependency."
+  }
+}

releases/2026-10-02/benchmark_exclusion/writing/review/glytoucan/scripts/build_connection_level_support_audit.py

@@ -0,0 +1,521 @@
+#!/usr/bin/env python3
+"""Audit linkage, edge, and modification support patterns in GlyCorpus rows.
+
+This is a curation audit, not a full WURCS chemical validator. It extracts
+repeatable WURCS/IUPAC connection signatures, assigns conservative support
+tiers, and summarizes unique patterns for review.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import json
+import re
+from collections import Counter
+from pathlib import Path
+
+import pandas as pd
+
+
+ROOT = Path.cwd()
+EXCLUDED_INPUT = (
+    ROOT
+    / "review/glytoucan/outputs/family_publication_context_addendum_20260702/family_context_support_by_row.tsv"
+)
+FULL_INPUT = (
+    ROOT
+    / "review/glytoucan/outputs/final_training_recommendation_v2_20260702/glycorpus_final_training_recommendation_v2.tsv.gz"
+)
+OUTDIR = ROOT / "review/glytoucan/outputs/connection_level_support_audit_20260702"
+
+IUPAC_LINK_RE = re.compile(r"(?P<residue>[A-Za-z?][A-Za-z0-9?/-]*)(?P<link>\([ab?][0-9?]-[0-9?/]+[ab?]?\))")
+EDGE_RE = re.compile(r"(?P<n1>[A-Za-z]+)(?P<p1>[0-9?]+)-(?P<n2>[A-Za-z]+)(?P<p2>[0-9?]+)")
+RESDEF_RE = re.compile(r"\[([^\]]*)\]")
+
+COMMON_ANIMAL_NEU5AC = {
+    "Neu5Ac(a2-3)",
+    "Neu5Ac(a2-6)",
+    "Neu5Ac(a2-8)",
+    "Neu5Ac(a2-9)",
+}
+COMMON_ALPHA_SIALIC_ACCEPTORS = {"3", "6", "8", "9"}
+
+
+def node_label(index: int) -> str:
+    """Return WURCS-style node labels for the first several hundred nodes."""
+    letters = "abcdefghijklmnopqrstuvwxyz"
+    index -= 1
+    label = ""
+    while True:
+        label = letters[index % 26] + label
+        index = index // 26 - 1
+        if index < 0:
+            return label
+
+
+def split_wurcs_sections(body: str) -> list[str]:
+    sections = []
+    current = []
+    bracket_depth = 0
+    for char in body:
+        if char == "[":
+            bracket_depth += 1
+        elif char == "]" and bracket_depth:
+            bracket_depth -= 1
+        if char == "/" and bracket_depth == 0:
+            sections.append("".join(current))
+            current = []
+        else:
+            current.append(char)
+    sections.append("".join(current))
+    return sections
+
+
+def split_wurcs(wurcs: str) -> tuple[list[str], dict[str, str], str]:
+    if not wurcs.startswith("WURCS=2.0/"):
+        return [], {}, ""
+    body = wurcs[len("WURCS=2.0/") :]
+    parts = split_wurcs_sections(body)
+    if len(parts) < 4:
+        return [], {}, ""
+    resdefs = RESDEF_RE.findall(parts[1])
+    seq = parts[2].split("-") if parts[2] else []
+    node_to_resdef = {}
+    for i, value in enumerate(seq, start=1):
+        label = node_label(i)
+        try:
+            resdef = resdefs[int(value) - 1]
+        except (ValueError, IndexError):
+            resdef = ""
+        node_to_resdef[label] = resdef
+    link_section = "/".join(parts[3:])
+    return resdefs, node_to_resdef, link_section
+
+
+def residue_class_from_resdef(resdef: str) -> str:
+    low = resdef.lower()
+    if not resdef:
+        return "unknown_residue"
+    if "aad" in low or "neu" in low or "kdn" in low or "kdo" in low:
+        return "nonulosonic_like"
+    if low.startswith("ha"):
+        return "ketose_fructose_like"
+    if re.search(r"_\d+\*opo|opo/", low):
+        return "phosphate_modified"
+    if re.search(r"_\d+\*oso|oso/", low):
+        return "sulfate_modified"
+    if re.search(r"c{6,}|nccc|occc", low):
+        return "long_substituent_or_lipid_like"
+    if "_2*n" in low or "_5*n" in low or "ncc" in low:
+        return "amino_acetamido_modified"
+    if "x" in low or low.startswith("u"):
+        return "ambiguous_or_unknown"
+    if low.startswith("a") or low.startswith("h"):
+        return "monosaccharide_like"
+    return "other_residue"
+
+
+def modification_classes(text: str) -> list[str]:
+    classes = []
+    low = text.lower()
+    if "opo" in low or re.search(r"\bp-", low) or "phosphate" in low:
+        classes.append("phosphate")
+    if "oso" in low or "sulf" in low:
+        classes.append("sulfate")
+    if re.search(r"c{6,}|nccc|occc|cer|lipid", low):
+        classes.append("long_lipid_like")
+    if "ncc/3=o" in low or "_2*n" in low or "_5*n" in low:
+        classes.append("amino_acetamido")
+    if "_6*oc" in low or "me(" in low or "methyl" in low:
+        classes.append("methyl_or_o_acetyl_like")
+    if "?" in text or "[" in low and ("x" in low or "[u" in low):
+        classes.append("unknown_or_ambiguous")
+    return sorted(set(classes))
+
+
+def iupac_linkages(iupac: str) -> list[str]:
+    links = []
+    for match in IUPAC_LINK_RE.finditer(iupac or ""):
+        residue = match.group("residue")
+        link = match.group("link")
+        links.append(f"{residue}{link}")
+    return links
+
+
+def parse_iupac_link(link: str) -> tuple[str, str, str, str] | None:
+    match = re.match(
+        r"(?P<residue>[A-Za-z?][A-Za-z0-9?/-]*)\((?P<anomer>[ab?])(?P<donor>[0-9?]+)-(?P<acceptor>[0-9?/]+)(?P<acceptor_anomer>[ab?]?)\)",
+        link,
+    )
+    if not match:
+        return None
+    return (
+        match.group("residue"),
+        match.group("anomer"),
+        match.group("donor"),
+        match.group("acceptor"),
+    )
+
+
+def sialic_link_context(iupac_links: list[str]) -> tuple[list[str], list[str]]:
+    unusual = []
+    uncertain = []
+    for link in iupac_links:
+        parsed = parse_iupac_link(link)
+        if not parsed:
+            continue
+        residue, anomer, donor, acceptor = parsed
+        if not (residue.startswith("Neu") or residue.startswith("Kdn")):
+            continue
+        if residue.startswith("Neu5Ac") or residue.startswith("Neu5Gc") or residue == "Neu":
+            if "?" in link:
+                uncertain.append(link)
+            elif "/" in acceptor:
+                uncertain.append(link)
+            elif anomer != "a":
+                unusual.append(link)
+            elif donor == "2" and acceptor not in COMMON_ALPHA_SIALIC_ACCEPTORS:
+                unusual.append(link)
+    return unusual, uncertain
+
+
+def edge_records(wurcs: str) -> tuple[list[dict], list[str], list[str]]:
+    resdefs, node_to_resdef, link_section = split_wurcs(wurcs)
+    edges = []
+    signatures = []
+    flags = []
+    for token in link_section.split("_") if link_section else []:
+        match = EDGE_RE.search(token)
+        if not match:
+            if token:
+                flags.append("unparsed_wurcs_edge_token")
+            continue
+        n1, p1, n2, p2 = match.group("n1"), match.group("p1"), match.group("n2"), match.group("p2")
+        r1 = residue_class_from_resdef(node_to_resdef.get(n1, ""))
+        r2 = residue_class_from_resdef(node_to_resdef.get(n2, ""))
+        mods = modification_classes(token)
+        edge = {
+            "edge_token": token,
+            "endpoint_position_pair": f"{p1}-{p2}",
+            "endpoint_class_pair": f"{r1}--{r2}",
+            "edge_signature": f"{r1}:{p1}-{r2}:{p2}",
+            "edge_modification_classes": "|".join(mods),
+        }
+        edges.append(edge)
+        signatures.append(edge["edge_signature"])
+        pset = {p1, p2}
+        if p1 == "1" and p2 == "1":
+            flags.append("both_anomeric_1_1_edge")
+        if "2" in pset and (r1 == "nonulosonic_like" or r2 == "nonulosonic_like"):
+            flags.append("nonulosonic_position_2_edge")
+        if "2" in pset and (r1 == "ketose_fructose_like" or r2 == "ketose_fructose_like"):
+            flags.append("ketose_fructose_position_2_edge")
+        if "phosphate" in mods:
+            flags.append("phosphate_edge_or_substituent")
+        if "sulfate" in mods:
+            flags.append("sulfate_edge_or_substituent")
+        if "long_lipid_like" in mods or r1 == "long_substituent_or_lipid_like" or r2 == "long_substituent_or_lipid_like":
+            flags.append("long_lipid_like_edge_or_substituent")
+        if "?" in p1 + p2 + token:
+            flags.append("unknown_edge_position_or_substituent")
+    for resdef in resdefs:
+        mods = modification_classes(resdef)
+        for mod in mods:
+            if mod == "phosphate":
+                flags.append("phosphate_residue_modification")
+            elif mod == "sulfate":
+                flags.append("sulfate_residue_modification")
+            elif mod == "long_lipid_like":
+                flags.append("long_lipid_like_residue_modification")
+            elif mod == "unknown_or_ambiguous":
+                flags.append("unknown_residue_or_modification")
+    return edges, sorted(set(signatures)), sorted(set(flags))
+
+
+def connection_support(row: pd.Series, iupac_links: list[str], edge_flags: list[str], edge_signatures: list[str]) -> tuple[str, str, str]:
+    iupac_set = set(iupac_links)
+    unusual_sialic_links, uncertain_sialic_links = sialic_link_context(iupac_links)
+    proposed_use = row.get("proposed_training_use", "")
+    confidence = row.get("family_assignment_confidence", "")
+    family = row.get("primary_context_family", "")
+    support_level = row.get("support_level", "")
+    broad_bucket = row.get("broad_training_bucket_v2", "")
+    exact_csdb = str(row.get("exact_csdb_wurcs_match", row.get("csdb_exact_wurcs_rescue", ""))).lower() in {"true", "yes"}
+
+    if (
+        row.get("confirmed_error_flag", "") == "yes"
+        or proposed_use == "exclude_from_all_clean_training"
+        or broad_bucket == "hard_exclude"
+        or support_level == "confirmed_or_near_confirmed_error"
+    ):
+        return (
+            "specific_connection_entry_concern",
+            "exclude_from_clean_training",
+            "Specific reviewer-like connection concern, usually explicit Neu5Ac(a2-2) or related C2 pattern.",
+        )
+    if exact_csdb:
+        return (
+            "exact_record_external_support",
+            "eligible_for_exact_or_primary_context_depending_on_claim",
+            "Exact CSDB-WURCS support is present; still separate animal/exact-claim context as needed.",
+        )
+    if "Neu5Ac(a2-2)" in iupac_set:
+        return (
+            "specific_connection_unresolved",
+            "manual_recheck_or_exclude_from_clean_training",
+            "Explicit Neu5Ac(a2-2) connection remains unresolved without exact source support.",
+        )
+    if unusual_sialic_links:
+        return (
+            "specific_connection_unresolved",
+            "manual_recheck_before_broad_inclusion",
+            f"Unusual sialic-acid linkage token(s): {'|'.join(unusual_sialic_links[:5])}.",
+        )
+    if uncertain_sialic_links:
+        return (
+            "connection_unresolved_or_ambiguous",
+            "exclude_from_exact_topology_keep_only_labeled_context",
+            f"Uncertain sialic-acid linkage token(s): {'|'.join(uncertain_sialic_links[:5])}.",
+        )
+    if family == "nonulosonic_kdo_neu5ac_kdn" and "nonulosonic_position_2_edge" in edge_flags:
+        return (
+            "context_supported_nonulosonic_connection",
+            "broad_wurcs_or_sensitivity_not_exact_biology",
+            "Kdo/Kdn/nonulosonic C2-link chemistry is supported in bacterial/LPS contexts; exact row remains unproven.",
+        )
+    if "both_anomeric_1_1_edge" in edge_flags:
+        if any(re.match(r"(?:[LD]-)?(?:\\?-)?Glc\([ab?]1-1[ab?]\)", link) for link in iupac_set):
+            return (
+                "connection_pattern_supported",
+                "broad_wurcs_or_sensitivity_not_exact_biology",
+                "Both-anomeric 1-1 chemistry has trehalose-like support, but exact row still lacks exact-record evidence.",
+            )
+        return (
+            "connection_motif_supported_low_confidence",
+            "sensitivity_only_unless_manually_reviewed",
+            "WURCS 1-1 motif maps broadly to known chemistry, but row-level connection context is weak.",
+        )
+    if "ketose_fructose_position_2_edge" in edge_flags:
+        if any(re.search(r"Fru|Fruf", link) for link in iupac_links):
+            return (
+                "connection_pattern_supported",
+                "broad_wurcs_or_sensitivity_not_exact_biology",
+                "Fructan/ketose 2-x chemistry has literature support; exact row remains unverified.",
+            )
+        return (
+            "connection_motif_supported_medium_confidence",
+            "broad_wurcs_sensitivity_not_exact_biology",
+            "WURCS ketose/fructose-like 2-x motif has family support; explicit row context is limited.",
+        )
+    if "phosphate_edge_or_substituent" in edge_flags or "phosphate_residue_modification" in edge_flags:
+        return (
+            "connection_or_modification_pattern_supported",
+            "broad_wurcs_or_sensitivity_not_exact_biology",
+            "Ribitol/phosphate wall-teichoic-like chemistry is supported; exact edge placement is not per-row proven.",
+        )
+    if "sulfate_edge_or_substituent" in edge_flags or "sulfate_residue_modification" in edge_flags:
+        return (
+            "connection_or_modification_pattern_supported",
+            "broad_wurcs_or_sensitivity_not_exact_biology",
+            "Sulfated glycan chemistry is supported; exact modification placement is not per-row proven.",
+        )
+    if "long_lipid_like_edge_or_substituent" in edge_flags or "long_lipid_like_residue_modification" in edge_flags:
+        return (
+            "connection_or_modification_motif_supported_low_confidence",
+            "sensitivity_only_unless_manually_reviewed",
+            "Glycolipid/lipooligosaccharide chemistry exists, but this motif-level assignment needs manual review for exact use.",
+        )
+    if "unknown_edge_position_or_substituent" in edge_flags or "unknown_residue_or_modification" in edge_flags:
+        return (
+            "connection_unresolved_or_ambiguous",
+            "exclude_from_exact_topology_keep_only_labeled_context",
+            "Unknown or ambiguous linkage/residue/modification cannot support exact topology supervision.",
+        )
+    if confidence in {"high", "medium"} and proposed_use.startswith("include"):
+        return (
+            "family_supported_no_specific_connection_alert",
+            "broad_wurcs_not_exact_biology",
+            "No additional high-priority connection alert was found by this audit; support remains family/pattern-level.",
+        )
+    if broad_bucket in {"broad_core", "broad_citation_backed", "csdb_supported_broad_only_rescue"}:
+        return (
+            "no_specific_connection_alert_found",
+            "keep_existing_training_recommendation",
+            "The connection/modification audit did not find a reviewer-like linkage alert in this retained row.",
+        )
+    if broad_bucket in {"broad_labeled_not_exact", "broad_labeled_context"}:
+        return (
+            "labeled_record_no_specific_connection_alert",
+            "keep_as_labeled_database_record_not_exact_topology",
+            "No reviewer-like linkage alert was found, but the row still carries non-exact or context labels.",
+        )
+    if broad_bucket == "sensitivity_or_quarantine":
+        return (
+            "quarantine_record_no_specific_connection_alert",
+            "sensitivity_only_or_release_with_label",
+            "No single reviewer-like linkage alert was found, but the row remains outside clean training for existing curation reasons.",
+        )
+    return (
+        "connection_support_not_assigned",
+        "manual_or_release_only",
+        "No supported connection pattern was assigned in this audit.",
+    )
+
+
+def audit_rows(df: pd.DataFrame, scope: str) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    records = []
+    edge_rows = []
+    for idx, row in df.fillna("").iterrows():
+        wurcs = row.get("canonical_wurcs", "")
+        iupac = row.get("iupac_name", "")
+        edges, signatures, flags = edge_records(wurcs)
+        links = iupac_linkages(iupac)
+        status, action, rationale = connection_support(row, links, flags, signatures)
+        glycorpus_id = row.get("glycorpus_id", "")
+        accession = row.get("primary_accession", "")
+        records.append(
+            {
+                "scope": scope,
+                "glycorpus_id": glycorpus_id,
+                "primary_accession": accession,
+                "iupac_linkages": "|".join(links),
+                "wurcs_edge_signatures": "|".join(signatures),
+                "connection_flags": "|".join(flags),
+                "connection_support_status": status,
+                "connection_training_action": action,
+                "connection_support_rationale": rationale,
+                "edge_count_extracted": len(edges),
+                "family_assignment_confidence": row.get("family_assignment_confidence", ""),
+                "primary_context_family": row.get("primary_context_family", ""),
+                "proposed_training_use": row.get("proposed_training_use", ""),
+                "exclusion_category": row.get("exclusion_category", ""),
+                "support_level": row.get("support_level", ""),
+                "broad_training_bucket_v2": row.get("broad_training_bucket_v2", ""),
+                "canonical_wurcs": wurcs,
+                "iupac_name": iupac,
+            }
+        )
+        for edge in edges:
+            edge_rows.append(
+                {
+                    "scope": scope,
+                    "glycorpus_id": glycorpus_id,
+                    "primary_accession": accession,
+                    **edge,
+                }
+            )
+    row_df = pd.DataFrame(records)
+    edge_df = pd.DataFrame(edge_rows)
+    if edge_df.empty:
+        pattern_df = pd.DataFrame(columns=["edge_signature", "rows", "examples"])
+    else:
+        pattern_df = (
+            edge_df.groupby(["edge_signature", "endpoint_position_pair", "endpoint_class_pair"], dropna=False)
+            .agg(
+                edge_instances=("glycorpus_id", "size"),
+                rows=("glycorpus_id", "nunique"),
+                examples=("primary_accession", lambda s: ";".join(list(dict.fromkeys(s.astype(str)))[:8])),
+            )
+            .reset_index()
+            .sort_values(["rows", "edge_instances"], ascending=False)
+        )
+    return row_df, edge_df, pattern_df
+
+
+def write_table(path: Path, df: pd.DataFrame) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.suffix == ".gz":
+        with gzip.open(path, "wt") as handle:
+            df.to_csv(handle, sep="\t", index=False, lineterminator="\n")
+    else:
+        df.to_csv(path, sep="\t", index=False, lineterminator="\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--skip-full", action="store_true")
+    args = parser.parse_args()
+    OUTDIR.mkdir(parents=True, exist_ok=True)
+
+    excluded = pd.read_csv(EXCLUDED_INPUT, sep="\t", dtype=str).fillna("")
+    excluded_row, excluded_edge, excluded_pattern = audit_rows(excluded, "excluded_primary_3819")
+    write_table(OUTDIR / "connection_row_audit_excluded_primary_3819.tsv", excluded_row)
+    write_table(OUTDIR / "connection_edge_instances_excluded_primary_3819.tsv", excluded_edge)
+    write_table(OUTDIR / "connection_pattern_summary_excluded_primary_3819.tsv", excluded_pattern)
+
+    support_summary = (
+        excluded_row.groupby(["connection_support_status", "connection_training_action"], dropna=False)
+        .size()
+        .reset_index(name="rows")
+        .sort_values("rows", ascending=False)
+    )
+    write_table(OUTDIR / "connection_support_summary_excluded_primary_3819.tsv", support_summary)
+
+    flag_counter: Counter[str] = Counter()
+    for flags in excluded_row["connection_flags"]:
+        for flag in str(flags).split("|"):
+            if flag:
+                flag_counter[flag] += 1
+    flag_summary = pd.DataFrame(
+        [{"connection_flag": flag, "rows": rows} for flag, rows in flag_counter.most_common()]
+    )
+    write_table(OUTDIR / "connection_flag_summary_excluded_primary_3819.tsv", flag_summary)
+
+    meta = {
+        "excluded_primary_rows": int(len(excluded_row)),
+        "excluded_primary_unique_edge_signatures": int(excluded_pattern["edge_signature"].nunique()),
+        "excluded_primary_support_counts": (
+            excluded_row.groupby("connection_support_status", dropna=False)
+            .size()
+            .sort_values(ascending=False)
+            .to_dict()
+        ),
+    }
+
+    if not args.skip_full:
+        full = pd.read_csv(FULL_INPUT, sep="\t", dtype=str).fillna("")
+        full_row, full_edge, full_pattern = audit_rows(full, "full_final_recommendation_260703")
+        # Full row audit is useful but compacted because it is large.
+        full_cols = [
+            "scope",
+            "glycorpus_id",
+            "primary_accession",
+            "iupac_linkages",
+            "wurcs_edge_signatures",
+            "connection_flags",
+            "connection_support_status",
+            "connection_training_action",
+            "edge_count_extracted",
+            "support_level",
+            "broad_training_bucket_v2",
+        ]
+        write_table(OUTDIR / "connection_row_audit_full_260703.tsv.gz", full_row[full_cols])
+        write_table(OUTDIR / "connection_pattern_summary_full_260703.tsv", full_pattern)
+        full_support = (
+            full_row.groupby(["connection_support_status", "connection_training_action"], dropna=False)
+            .size()
+            .reset_index(name="rows")
+            .sort_values("rows", ascending=False)
+        )
+        write_table(OUTDIR / "connection_support_summary_full_260703.tsv", full_support)
+        meta.update(
+            {
+                "full_rows": int(len(full_row)),
+                "full_unique_edge_signatures": int(full_pattern["edge_signature"].nunique()),
+                    "full_support_counts": (
+                        full_row.groupby("connection_support_status", dropna=False)
+                        .size()
+                        .sort_values(ascending=False)
+                        .to_dict()
+                    ),
+            }
+        )
+
+    (OUTDIR / "connection_level_audit_summary.json").write_text(json.dumps(meta, indent=2))
+    print(json.dumps(meta, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

releases/2026-10-02/benchmark_exclusion/writing/review/multimodal/scripts/build_p1_direct_local_neighbor_audit_20260710.py

@@ -0,0 +1,969 @@
+#!/usr/bin/env python3
+"""Build the provisional exact/direct-local-neighbour exclusion audit.
+
+This script is label blind. Hashes retrieve candidate graph pairs, but every
+reported relation is confirmed with exact labelled graph isomorphism. It does
+not authorize A5 training; final motif-cluster and AFFINose roles are still
+open, and non-fixed WURCS tiers receive exact-string handling only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import hashlib
+import io
+import json
+import sys
+from collections import Counter, defaultdict
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, Iterator
+
+import networkx as nx
+
+
+WRITING_ROOT = Path(__file__).resolve().parents[3]
+MM = WRITING_ROOT / "review/multimodal"
+FREEZE = MM / "outputs/p0_p1_freeze_20260710"
+FINGERPRINT = FREEZE / "review_p1_wurcs_motif_fingerprint_manifest.tsv.gz"
+OBJECTIVE = FREEZE / "review_p1_objective_eligibility_manifest.tsv.gz"
+ANCHORS = (
+    MM
+    / "outputs/p1_targeted_similarity_retention_role_aware_20260710/"
+    "review_p1_targeted_anchor_manifest.tsv.gz"
+)
+DEFAULT_OUTPUT_DIR = MM / "outputs/p1_direct_local_neighbor_audit_20260710"
+
+PARSER_SOURCE = (
+    WRITING_ROOT / "review/glytoucan/scripts/build_connection_level_support_audit.py"
+)
+sys.path.insert(0, str(PARSER_SOURCE.parent))
+from build_connection_level_support_audit import EDGE_RE, split_wurcs  # noqa: E402
+
+
+NODE_MATCH = nx.algorithms.isomorphism.categorical_node_match("label", "")
+EDGE_MATCH = nx.algorithms.isomorphism.categorical_edge_match("position", "")
+FIXED_TIER = "fixed_tree_exact_linkage"
+RELATION_ORDER = {
+    "exact_wurcs": 0,
+    "graph_identity": 1,
+    "residue_substitution": 2,
+    "linkage_change": 3,
+    "terminal_insertion_or_deletion": 4,
+    "branch_attachment_relocation": 5,
+}
+
+
+@dataclass(slots=True)
+class AnchorGraph:
+    index: int
+    wurcs: str
+    sources: str
+    tier: str
+    residue_count: int
+    graph: nx.Graph
+    exact_signature: str
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def hash_text(value: str) -> str:
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def as_bool(value: object) -> bool:
+    return str(value).strip().lower() in {"1", "true", "yes"}
+
+
+@contextmanager
+def gzip_tsv_writer(
+    path: Path, fieldnames: list[str]
+) -> Iterator[csv.DictWriter]:
+    with path.open("wb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as zipped:
+            with io.TextIOWrapper(zipped, encoding="utf-8", newline="") as text:
+                writer = csv.DictWriter(
+                    text,
+                    fieldnames=fieldnames,
+                    delimiter="\t",
+                    lineterminator="\n",
+                )
+                writer.writeheader()
+                yield writer
+
+
+def write_gzip_tsv(
+    path: Path, fieldnames: list[str], rows: Iterable[dict[str, object]]
+) -> None:
+    with gzip_tsv_writer(path, fieldnames) as writer:
+        writer.writerows(rows)
+
+
+def parse_fixed_tree(wurcs: str) -> nx.Graph:
+    """Parse a simple exact-linkage WURCS tree into a residue-bond graph."""
+    _, node_to_resdef, link_section = split_wurcs(wurcs)
+    if not node_to_resdef or any(not value for value in node_to_resdef.values()):
+        raise ValueError("missing_or_unmapped_residue")
+
+    graph = nx.Graph()
+    for node_id, residue in node_to_resdef.items():
+        graph.add_node(
+            ("residue", node_id),
+            kind="residue",
+            label=residue,
+            signature_label=hash_text(residue),
+        )
+
+    tokens = [token for token in link_section.split("_") if token]
+    for edge_index, token in enumerate(tokens):
+        match = EDGE_RE.fullmatch(token)
+        if not match:
+            raise ValueError(f"non_simple_edge:{token}")
+        left = ("residue", match.group("n1"))
+        right = ("residue", match.group("n2"))
+        if left not in graph or right not in graph:
+            raise ValueError(f"edge_references_unknown_residue:{token}")
+        left_position = match.group("p1")
+        right_position = match.group("p2")
+        if "?" in left_position + right_position:
+            raise ValueError(f"unknown_linkage:{token}")
+        bond = ("bond", edge_index)
+        graph.add_node(
+            bond,
+            kind="bond",
+            label="BOND",
+            signature_label=hash_text("BOND"),
+        )
+        graph.add_edge(left, bond, position=left_position)
+        graph.add_edge(right, bond, position=right_position)
+
+    residue_count = len(node_to_resdef)
+    if len(tokens) != max(0, residue_count - 1):
+        raise ValueError("not_a_residue_tree")
+    if graph.number_of_nodes() and not nx.is_tree(graph):
+        raise ValueError("parsed_graph_not_tree")
+    graph.graph["residue_count"] = residue_count
+    return graph
+
+
+def residue_nodes(graph: nx.Graph) -> list[object]:
+    return sorted(
+        (node for node, data in graph.nodes(data=True) if data["kind"] == "residue"),
+        key=str,
+    )
+
+
+def bond_nodes(graph: nx.Graph) -> list[object]:
+    return sorted(
+        (node for node, data in graph.nodes(data=True) if data["kind"] == "bond"),
+        key=str,
+    )
+
+
+def signature(graph: nx.Graph) -> str:
+    """Return an isomorphism-invariant candidate key, never final evidence."""
+    if not graph:
+        return "EMPTY"
+    digest = nx.weisfeiler_lehman_graph_hash(
+        graph,
+        node_attr="signature_label",
+        edge_attr="position",
+        iterations=3,
+        digest_size=32,
+    )
+    return f"{graph.number_of_nodes()}:{graph.number_of_edges()}:{digest}"
+
+
+def exact_isomorphic(left: nx.Graph, right: nx.Graph) -> bool:
+    if (
+        left.number_of_nodes() != right.number_of_nodes()
+        or left.number_of_edges() != right.number_of_edges()
+    ):
+        return False
+    return nx.is_isomorphic(
+        left,
+        right,
+        node_match=NODE_MATCH,
+        edge_match=EDGE_MATCH,
+    )
+
+
+def residue_wildcard_signature(graph: nx.Graph, residue: object) -> str:
+    previous = graph.nodes[residue]["label"]
+    previous_signature = graph.nodes[residue]["signature_label"]
+    graph.nodes[residue]["label"] = "RESIDUE_WILDCARD"
+    graph.nodes[residue]["signature_label"] = hash_text("RESIDUE_WILDCARD")
+    try:
+        return signature(graph)
+    finally:
+        graph.nodes[residue]["label"] = previous
+        graph.nodes[residue]["signature_label"] = previous_signature
+
+
+def bond_wildcard_signature(graph: nx.Graph, bond: object) -> str:
+    previous = {
+        neighbor: graph.edges[bond, neighbor]["position"]
+        for neighbor in graph.neighbors(bond)
+    }
+    for neighbor in previous:
+        graph.edges[bond, neighbor]["position"] = "*"
+    try:
+        return signature(graph)
+    finally:
+        for neighbor, value in previous.items():
+            graph.edges[bond, neighbor]["position"] = value
+
+
+def verify_residue_substitution(
+    left: nx.Graph,
+    left_residue: object,
+    right: nx.Graph,
+    right_residue: object,
+) -> bool:
+    if exact_isomorphic(left, right):
+        return False
+    left_copy = left.copy()
+    right_copy = right.copy()
+    left_copy.nodes[left_residue]["label"] = "RESIDUE_WILDCARD"
+    left_copy.nodes[left_residue]["signature_label"] = hash_text(
+        "RESIDUE_WILDCARD"
+    )
+    right_copy.nodes[right_residue]["label"] = "RESIDUE_WILDCARD"
+    right_copy.nodes[right_residue]["signature_label"] = hash_text(
+        "RESIDUE_WILDCARD"
+    )
+    return exact_isomorphic(left_copy, right_copy)
+
+
+def verify_linkage_change(
+    left: nx.Graph,
+    left_bond: object,
+    right: nx.Graph,
+    right_bond: object,
+) -> bool:
+    if exact_isomorphic(left, right):
+        return False
+    left_copy = left.copy()
+    right_copy = right.copy()
+    for graph, bond in ((left_copy, left_bond), (right_copy, right_bond)):
+        for neighbor in graph.neighbors(bond):
+            graph.edges[bond, neighbor]["position"] = "*"
+    return exact_isomorphic(left_copy, right_copy)
+
+
+def terminal_leaf_nodes(graph: nx.Graph) -> list[object]:
+    if int(graph.graph["residue_count"]) <= 1:
+        return []
+    return [node for node in residue_nodes(graph) if graph.degree(node) == 1]
+
+
+def remove_terminal_residue(graph: nx.Graph, residue: object) -> nx.Graph:
+    if residue not in graph or graph.nodes[residue]["kind"] != "residue":
+        raise ValueError("terminal deletion target is not a residue")
+    if graph.degree(residue) != 1:
+        raise ValueError("terminal deletion target is not a leaf")
+    bond = next(iter(graph.neighbors(residue)))
+    if graph.nodes[bond]["kind"] != "bond" or graph.degree(bond) != 2:
+        raise ValueError("terminal residue does not have one simple bond")
+    result = graph.copy()
+    result.remove_nodes_from((residue, bond))
+    result.graph["residue_count"] = int(graph.graph["residue_count"]) - 1
+    return result
+
+
+def verify_terminal_edit(
+    smaller: nx.Graph, larger: nx.Graph, larger_leaf: object
+) -> bool:
+    if int(larger.graph["residue_count"]) != int(smaller.graph["residue_count"]) + 1:
+        return False
+    return exact_isomorphic(smaller, remove_terminal_residue(larger, larger_leaf))
+
+
+def cut_components(
+    graph: nx.Graph, bond: object
+) -> list[tuple[nx.Graph, str]]:
+    neighbors = list(graph.neighbors(bond))
+    if len(neighbors) != 2:
+        raise ValueError("branch cut requires a simple two-ended bond")
+    positions = {
+        neighbor: graph.edges[bond, neighbor]["position"] for neighbor in neighbors
+    }
+    cut = graph.copy()
+    cut.remove_node(bond)
+    components: list[tuple[nx.Graph, str]] = []
+    for neighbor in neighbors:
+        nodes = nx.node_connected_component(cut, neighbor)
+        component = cut.subgraph(nodes).copy()
+        component.graph["residue_count"] = sum(
+            data["kind"] == "residue" for _, data in component.nodes(data=True)
+        )
+        components.append((component, positions[neighbor]))
+    return components
+
+
+def branch_cut_signature(graph: nx.Graph, bond: object) -> str:
+    parts = sorted((signature(component), position) for component, position in cut_components(graph, bond))
+    return hash_text(json.dumps(parts, separators=(",", ":")))
+
+
+def verify_branch_relocation(
+    left: nx.Graph,
+    left_bond: object,
+    right: nx.Graph,
+    right_bond: object,
+) -> bool:
+    if exact_isomorphic(left, right):
+        return False
+    if int(left.graph["residue_count"]) != int(right.graph["residue_count"]):
+        return False
+    left_parts = cut_components(left, left_bond)
+    right_parts = cut_components(right, right_bond)
+    for permutation in ((0, 1), (1, 0)):
+        if all(
+            left_parts[index][1] == right_parts[permutation[index]][1]
+            and exact_isomorphic(
+                left_parts[index][0], right_parts[permutation[index]][0]
+            )
+            for index in (0, 1)
+        ):
+            return True
+    return False
+
+
+def synthetic_graph(
+    labels: list[str], edges: list[tuple[int, int, str, str]]
+) -> nx.Graph:
+    graph = nx.Graph()
+    for index, label in enumerate(labels):
+        graph.add_node(
+            ("residue", index),
+            kind="residue",
+            label=label,
+            signature_label=hash_text(label),
+        )
+    for index, (left, right, left_pos, right_pos) in enumerate(edges):
+        bond = ("bond", index)
+        graph.add_node(
+            bond,
+            kind="bond",
+            label="BOND",
+            signature_label=hash_text("BOND"),
+        )
+        graph.add_edge(("residue", left), bond, position=left_pos)
+        graph.add_edge(("residue", right), bond, position=right_pos)
+    graph.graph["residue_count"] = len(labels)
+    if graph and not nx.is_tree(graph):
+        raise ValueError("synthetic graph is not a tree")
+    return graph
+
+
+def self_test() -> None:
+    anchor = synthetic_graph(
+        ["A", "B", "C"],
+        [(0, 1, "4", "1"), (1, 2, "3", "1")],
+    )
+    substituted = synthetic_graph(
+        ["A", "B", "D"],
+        [(0, 1, "4", "1"), (1, 2, "3", "1")],
+    )
+    assert residue_wildcard_signature(anchor, ("residue", 2)) == residue_wildcard_signature(
+        substituted, ("residue", 2)
+    )
+    assert verify_residue_substitution(
+        anchor, ("residue", 2), substituted, ("residue", 2)
+    )
+
+    relinked = synthetic_graph(
+        ["A", "B", "C"],
+        [(0, 1, "4", "1"), (1, 2, "6", "1")],
+    )
+    assert bond_wildcard_signature(anchor, ("bond", 1)) == bond_wildcard_signature(
+        relinked, ("bond", 1)
+    )
+    assert verify_linkage_change(anchor, ("bond", 1), relinked, ("bond", 1))
+
+    extended = synthetic_graph(
+        ["A", "B", "C", "D"],
+        [
+            (0, 1, "4", "1"),
+            (1, 2, "3", "1"),
+            (2, 3, "2", "1"),
+        ],
+    )
+    assert signature(anchor) == signature(remove_terminal_residue(extended, ("residue", 3)))
+    assert verify_terminal_edit(anchor, extended, ("residue", 3))
+
+    chain = extended
+    relocated = synthetic_graph(
+        ["A", "B", "C", "D"],
+        [
+            (0, 1, "4", "1"),
+            (1, 2, "3", "1"),
+            (1, 3, "2", "1"),
+        ],
+    )
+    assert branch_cut_signature(chain, ("bond", 2)) == branch_cut_signature(
+        relocated, ("bond", 2)
+    )
+    assert verify_branch_relocation(chain, ("bond", 2), relocated, ("bond", 2))
+    assert not exact_isomorphic(anchor, substituted)
+    assert exact_isomorphic(anchor, anchor.copy())
+    unicode_graph = synthetic_graph(["alpha", "beta-\u03b2"], [(0, 1, "4", "1")])
+    assert signature(unicode_graph)
+
+
+def load_anchor_rows(path: Path) -> list[dict[str, str]]:
+    with gzip.open(path, "rt", newline="", encoding="utf-8") as handle:
+        rows = list(csv.DictReader(handle, delimiter="\t"))
+    if not rows or len({row["canonical_wurcs"] for row in rows}) != len(rows):
+        raise RuntimeError("Anchor manifest is empty or has duplicate WURCS")
+    return rows
+
+
+def build_anchor_indices(anchor_rows: list[dict[str, str]]) -> tuple[
+    list[AnchorGraph],
+    dict[str, list[int]],
+    dict[str, list[tuple[int, object]]],
+    dict[str, list[tuple[int, object]]],
+    dict[str, list[tuple[int, object]]],
+    dict[str, list[int]],
+    dict[str, list[tuple[int, object]]],
+]:
+    anchors: list[AnchorGraph] = []
+    exact_index: dict[str, list[int]] = defaultdict(list)
+    residue_index: dict[str, list[tuple[int, object]]] = defaultdict(list)
+    bond_index: dict[str, list[tuple[int, object]]] = defaultdict(list)
+    leaf_deleted_index: dict[str, list[tuple[int, object]]] = defaultdict(list)
+    terminal_extension_anchor_index: dict[str, list[int]] = defaultdict(list)
+    branch_index: dict[str, list[tuple[int, object]]] = defaultdict(list)
+
+    for row in anchor_rows:
+        if row["fingerprint_tier"] != FIXED_TIER:
+            continue
+        graph = parse_fixed_tree(row["canonical_wurcs"])
+        index = len(anchors)
+        anchor = AnchorGraph(
+            index=index,
+            wurcs=row["canonical_wurcs"],
+            sources=row["anchor_sources"],
+            tier=row["fingerprint_tier"],
+            residue_count=int(graph.graph["residue_count"]),
+            graph=graph,
+            exact_signature=signature(graph),
+        )
+        anchors.append(anchor)
+        exact_index[anchor.exact_signature].append(index)
+
+        if anchor.residue_count >= 3:
+            terminal_extension_anchor_index[anchor.exact_signature].append(index)
+            for residue in residue_nodes(graph):
+                residue_index[residue_wildcard_signature(graph, residue)].append(
+                    (index, residue)
+                )
+            for leaf in terminal_leaf_nodes(graph):
+                leaf_deleted_index[signature(remove_terminal_residue(graph, leaf))].append(
+                    (index, leaf)
+                )
+            for bond in bond_nodes(graph):
+                branch_index[branch_cut_signature(graph, bond)].append((index, bond))
+
+        if anchor.residue_count >= 2:
+            for bond in bond_nodes(graph):
+                bond_index[bond_wildcard_signature(graph, bond)].append((index, bond))
+
+    return (
+        anchors,
+        exact_index,
+        residue_index,
+        bond_index,
+        leaf_deleted_index,
+        terminal_extension_anchor_index,
+        branch_index,
+    )
+
+
+def add_relation(
+    relations: dict[tuple[int, str], list[tuple[object, object]]],
+    anchor_index: int,
+    relation: str,
+    anchor_element: object = "",
+    candidate_element: object = "",
+) -> None:
+    pair = (anchor_element, candidate_element)
+    values = relations.setdefault((anchor_index, relation), [])
+    if pair not in values:
+        values.append(pair)
+
+
+def confirmed_relations(
+    graph: nx.Graph,
+    anchors: list[AnchorGraph],
+    exact_index: dict[str, list[int]],
+    residue_index: dict[str, list[tuple[int, object]]],
+    bond_index: dict[str, list[tuple[int, object]]],
+    leaf_deleted_index: dict[str, list[tuple[int, object]]],
+    terminal_extension_anchor_index: dict[str, list[int]],
+    branch_index: dict[str, list[tuple[int, object]]],
+) -> list[tuple[int, str]]:
+    candidates: dict[tuple[int, str], list[tuple[object, object]]] = {}
+    exact_key = signature(graph)
+    for anchor_index in exact_index.get(exact_key, []):
+        add_relation(candidates, anchor_index, "graph_identity")
+
+    residue_count = int(graph.graph["residue_count"])
+    if residue_count >= 3:
+        for residue in residue_nodes(graph):
+            key = residue_wildcard_signature(graph, residue)
+            for anchor_index, anchor_residue in residue_index.get(key, []):
+                add_relation(
+                    candidates,
+                    anchor_index,
+                    "residue_substitution",
+                    anchor_residue,
+                    residue,
+                )
+        for bond in bond_nodes(graph):
+            key = branch_cut_signature(graph, bond)
+            for anchor_index, anchor_bond in branch_index.get(key, []):
+                add_relation(
+                    candidates,
+                    anchor_index,
+                    "branch_attachment_relocation",
+                    anchor_bond,
+                    bond,
+                )
+
+    if residue_count >= 2:
+        for bond in bond_nodes(graph):
+            key = bond_wildcard_signature(graph, bond)
+            for anchor_index, anchor_bond in bond_index.get(key, []):
+                add_relation(
+                    candidates,
+                    anchor_index,
+                    "linkage_change",
+                    anchor_bond,
+                    bond,
+                )
+
+    for anchor_index, anchor_leaf in leaf_deleted_index.get(exact_key, []):
+        add_relation(
+            candidates,
+            anchor_index,
+            "terminal_insertion_or_deletion",
+            anchor_leaf,
+            "",
+        )
+    for candidate_leaf in terminal_leaf_nodes(graph):
+        key = signature(remove_terminal_residue(graph, candidate_leaf))
+        for anchor_index in terminal_extension_anchor_index.get(key, []):
+            add_relation(
+                candidates,
+                anchor_index,
+                "terminal_insertion_or_deletion",
+                "",
+                candidate_leaf,
+            )
+
+    confirmed: list[tuple[int, str]] = []
+    for (anchor_index, relation), element_pairs in sorted(
+        candidates.items(),
+        key=lambda item: (
+            RELATION_ORDER[item[0][1]],
+            anchors[item[0][0]].wurcs,
+        ),
+    ):
+        anchor = anchors[anchor_index]
+        passes = False
+        for anchor_element, candidate_element in element_pairs:
+            if relation == "graph_identity":
+                passes = exact_isomorphic(anchor.graph, graph)
+            elif relation == "residue_substitution":
+                passes = verify_residue_substitution(
+                    anchor.graph, anchor_element, graph, candidate_element
+                )
+            elif relation == "linkage_change":
+                passes = verify_linkage_change(
+                    anchor.graph, anchor_element, graph, candidate_element
+                )
+            elif relation == "terminal_insertion_or_deletion":
+                if anchor_element:
+                    passes = verify_terminal_edit(graph, anchor.graph, anchor_element)
+                else:
+                    passes = verify_terminal_edit(anchor.graph, graph, candidate_element)
+            elif relation == "branch_attachment_relocation":
+                passes = verify_branch_relocation(
+                    anchor.graph, anchor_element, graph, candidate_element
+                )
+            else:
+                raise AssertionError(f"Unknown relation: {relation}")
+            if passes:
+                break
+        if passes:
+            confirmed.append((anchor_index, relation))
+    return confirmed
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    parser.add_argument("--anchor-manifest", type=Path, default=ANCHORS)
+    parser.add_argument(
+        "--anchor-policy",
+        default="role-derived non-fit endpoint union",
+    )
+    parser.add_argument("--final-anchor-authority", action="store_true")
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=0,
+        help="Process only the first N sequence parents for a smoke run; 0 is full.",
+    )
+    parser.add_argument("--self-test-only", action="store_true")
+    args = parser.parse_args()
+
+    self_test()
+    if args.self_test_only:
+        print("self-test: PASS")
+        return
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    anchor_rows = load_anchor_rows(args.anchor_manifest)
+    anchor_wurcs = {row["canonical_wurcs"] for row in anchor_rows}
+    source_by_wurcs = {
+        row["canonical_wurcs"]: row["anchor_sources"] for row in anchor_rows
+    }
+    (
+        fixed_anchors,
+        exact_index,
+        residue_index,
+        bond_index,
+        leaf_deleted_index,
+        terminal_extension_anchor_index,
+        branch_index,
+    ) = build_anchor_indices(anchor_rows)
+
+    parent_fields = [
+        "parent_glycorpus_id",
+        "canonical_wurcs",
+        "fingerprint_tier",
+        "residue_count",
+        "exact_wurcs_anchor",
+        "graph_identity_anchor_count",
+        "direct_local_neighbor_anchor_count",
+        "confirmed_relation_types",
+        "confirmed_anchor_wurcs",
+        "provisional_excluded",
+        "provisional_exclusion_reason",
+        "fixed_anchor_relation_status",
+        "unresolved_reason",
+    ]
+    edge_fields = [
+        "anchor_wurcs",
+        "anchor_sources",
+        "anchor_residue_count",
+        "parent_glycorpus_id",
+        "parent_wurcs",
+        "parent_residue_count",
+        "relation_type",
+        "candidate_generator",
+        "exact_verifier",
+    ]
+    parent_output = args.output_dir / "review_p1_direct_local_neighbor_manifest.tsv.gz"
+    edge_output = args.output_dir / "review_p1_direct_local_neighbor_edges.tsv.gz"
+
+    processed_parent_ids: set[str] = set()
+    excluded_parent_ids: set[str] = set()
+    exact_parent_ids: set[str] = set()
+    graph_identity_parent_ids: set[str] = set()
+    local_neighbor_parent_ids: set[str] = set()
+    parent_status_counts: Counter[str] = Counter()
+    relation_edge_counts: Counter[str] = Counter()
+    tier_counts: Counter[str] = Counter()
+    parse_failures = 0
+
+    with gzip_tsv_writer(parent_output, parent_fields) as parent_writer:
+        with gzip_tsv_writer(edge_output, edge_fields) as edge_writer:
+            with gzip.open(FINGERPRINT, "rt", newline="", encoding="utf-8") as handle:
+                for row in csv.DictReader(handle, delimiter="\t"):
+                    if not (
+                        row["graph_record_role"] == "sequence_eligible_parent"
+                        and as_bool(row["sequence_eligible_parent"])
+                    ):
+                        continue
+                    if args.limit and len(processed_parent_ids) >= args.limit:
+                        break
+
+                    parent_id = row["parent_glycorpus_id"]
+                    wurcs = row["canonical_wurcs"]
+                    tier = row["fingerprint_tier"]
+                    residue_count = int(row["residue_count"])
+                    processed_parent_ids.add(parent_id)
+                    tier_counts[tier] += 1
+                    exact_wurcs = wurcs in anchor_wurcs
+                    relations: list[tuple[int, str]] = []
+                    unresolved_reason = ""
+
+                    if tier == FIXED_TIER:
+                        try:
+                            graph = parse_fixed_tree(wurcs)
+                            relations = confirmed_relations(
+                                graph,
+                                fixed_anchors,
+                                exact_index,
+                                residue_index,
+                                bond_index,
+                                leaf_deleted_index,
+                                terminal_extension_anchor_index,
+                                branch_index,
+                            )
+                        except ValueError as exc:
+                            parse_failures += 1
+                            unresolved_reason = f"fixed_tier_parse_failure:{exc}"
+                    else:
+                        unresolved_reason = (
+                            "nonfixed_wurcs_exact_identity_only_in_this_pass"
+                        )
+
+                    relation_by_anchor: dict[int, set[str]] = defaultdict(set)
+                    for anchor_index, relation in relations:
+                        relation_by_anchor[anchor_index].add(relation)
+
+                    graph_identity_indices = {
+                        index
+                        for index, values in relation_by_anchor.items()
+                        if "graph_identity" in values
+                    }
+                    local_indices = {
+                        index
+                        for index, values in relation_by_anchor.items()
+                        if values
+                        - {"graph_identity"}
+                    }
+                    relation_types = sorted(
+                        {
+                            relation
+                            for values in relation_by_anchor.values()
+                            for relation in values
+                        },
+                        key=lambda value: RELATION_ORDER[value],
+                    )
+                    confirmed_anchor_indices = sorted(
+                        relation_by_anchor,
+                        key=lambda index: fixed_anchors[index].wurcs,
+                    )
+
+                    if exact_wurcs:
+                        exact_parent_ids.add(parent_id)
+                        excluded_parent_ids.add(parent_id)
+                        exclusion_reason = "exact_role_anchor"
+                    elif graph_identity_indices:
+                        graph_identity_parent_ids.add(parent_id)
+                        excluded_parent_ids.add(parent_id)
+                        exclusion_reason = "validated_graph_identity"
+                    elif local_indices:
+                        local_neighbor_parent_ids.add(parent_id)
+                        excluded_parent_ids.add(parent_id)
+                        exclusion_reason = "exact_confirmed_direct_local_neighbor"
+                    else:
+                        exclusion_reason = "retained_in_provisional_direct_rule"
+
+                    if tier != FIXED_TIER:
+                        relation_status = "not_evaluable_nonfixed_except_exact"
+                    elif unresolved_reason:
+                        relation_status = "unresolved_parser_failure"
+                    elif graph_identity_indices or local_indices:
+                        relation_status = "confirmed"
+                    else:
+                        relation_status = "ruled_out_against_fixed_anchor_relations"
+                    parent_status_counts[relation_status] += 1
+
+                    parent_writer.writerow(
+                        {
+                            "parent_glycorpus_id": parent_id,
+                            "canonical_wurcs": wurcs,
+                            "fingerprint_tier": tier,
+                            "residue_count": residue_count,
+                            "exact_wurcs_anchor": exact_wurcs,
+                            "graph_identity_anchor_count": len(graph_identity_indices),
+                            "direct_local_neighbor_anchor_count": len(local_indices),
+                            "confirmed_relation_types": ";".join(relation_types),
+                            "confirmed_anchor_wurcs": ";".join(
+                                fixed_anchors[index].wurcs
+                                for index in confirmed_anchor_indices
+                            ),
+                            "provisional_excluded": parent_id in excluded_parent_ids,
+                            "provisional_exclusion_reason": exclusion_reason,
+                            "fixed_anchor_relation_status": relation_status,
+                            "unresolved_reason": unresolved_reason,
+                        }
+                    )
+
+                    for anchor_index in confirmed_anchor_indices:
+                        anchor = fixed_anchors[anchor_index]
+                        for relation in sorted(
+                            relation_by_anchor[anchor_index],
+                            key=lambda value: RELATION_ORDER[value],
+                        ):
+                            relation_edge_counts[relation] += 1
+                            edge_writer.writerow(
+                                {
+                                    "anchor_wurcs": anchor.wurcs,
+                                    "anchor_sources": source_by_wurcs[anchor.wurcs],
+                                    "anchor_residue_count": anchor.residue_count,
+                                    "parent_glycorpus_id": parent_id,
+                                    "parent_wurcs": wurcs,
+                                    "parent_residue_count": residue_count,
+                                    "relation_type": relation,
+                                    "candidate_generator": (
+                                        "wl_hash_signature_v1_exact_verified"
+                                    ),
+                                    "exact_verifier": (
+                                        "networkx_labelled_isomorphism_v1"
+                                    ),
+                                }
+                            )
+
+    objective_total: Counter[str] = Counter()
+    objective_excluded: Counter[str] = Counter()
+    with gzip.open(OBJECTIVE, "rt", newline="", encoding="utf-8") as handle:
+        for row in csv.DictReader(handle, delimiter="\t"):
+            parent_id = row["parent_glycorpus_id"]
+            if parent_id not in processed_parent_ids or not as_bool(
+                row["eligible_before_partition"]
+            ):
+                continue
+            objective = row["objective"]
+            objective_total[objective] += 1
+            if parent_id in excluded_parent_ids:
+                objective_excluded[objective] += 1
+
+    retention_rows: list[dict[str, object]] = []
+    for objective in ("sequence", "topology", "ms", "static", "md"):
+        eligible = objective_total[objective]
+        excluded = objective_excluded[objective]
+        retained = eligible - excluded
+        retention_rows.append(
+            {
+                "objective": objective,
+                "eligible_in_processed_scope": eligible,
+                "provisional_excluded": excluded,
+                "provisional_retained": retained,
+                "retained_percent": (
+                    f"{100.0 * retained / eligible:.6f}" if eligible else ""
+                ),
+            }
+        )
+    retention_output = args.output_dir / "review_p1_direct_local_neighbor_retention.tsv"
+    with retention_output.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(
+            handle,
+            fieldnames=list(retention_rows[0]),
+            delimiter="\t",
+            lineterminator="\n",
+        )
+        writer.writeheader()
+        writer.writerows(retention_rows)
+
+    fixed_anchor_count = sum(row["fingerprint_tier"] == FIXED_TIER for row in anchor_rows)
+    summary = {
+        "schema": "bertose_p1_direct_local_neighbor_audit_v1",
+        "status": (
+            (
+                "FULL_FINAL_ROLE_UNION_DIAGNOSTIC"
+                if args.final_anchor_authority
+                else "FULL_ROLE_UNION_DIAGNOSTIC"
+            )
+            if not args.limit
+            else "PARTIAL_SMOKE_DIAGNOSTIC"
+        ),
+        "training_authorized": False,
+        "official_submitted_artifacts_modified": False,
+        "anchor_policy": args.anchor_policy,
+        "binary_relation_policy": (
+            "exact WURCS or exact-labelled graph identity; for fixed exact-linkage "
+            "trees only, direct one-residue substitution, one-linkage change, "
+            "one terminal insertion/deletion, or one branch attachment relocation"
+        ),
+        "candidate_hash_is_final_evidence": False,
+        "exact_verifier": "networkx labelled graph isomorphism v1",
+        "transitive_closure_used": False,
+        "numeric_similarity_cutoff_used": False,
+        "anchor_count": len(anchor_rows),
+        "fixed_tree_exact_linkage_anchor_count": fixed_anchor_count,
+        "nonfixed_anchor_count": len(anchor_rows) - fixed_anchor_count,
+        "processed_sequence_parent_count": len(processed_parent_ids),
+        "processed_tier_counts": dict(sorted(tier_counts.items())),
+        "exact_wurcs_parent_count": len(exact_parent_ids),
+        "additional_graph_identity_parent_count": len(
+            graph_identity_parent_ids - exact_parent_ids
+        ),
+        "direct_local_neighbor_parent_count": len(
+            local_neighbor_parent_ids
+            - exact_parent_ids
+            - graph_identity_parent_ids
+        ),
+        "total_provisional_excluded_parent_count": len(excluded_parent_ids),
+        "parent_relation_status_counts": dict(sorted(parent_status_counts.items())),
+        "confirmed_relation_edge_counts": dict(sorted(relation_edge_counts.items())),
+        "fixed_tier_parse_failure_count": parse_failures,
+        "objective_retention": retention_rows,
+        "input_sha256": {
+            "anchor_manifest": sha256(args.anchor_manifest),
+            "fingerprint_manifest": sha256(FINGERPRINT),
+            "objective_manifest": sha256(OBJECTIVE),
+            "parser_source": sha256(PARSER_SOURCE),
+            "script": sha256(Path(__file__).resolve()),
+        },
+        "outputs": {
+            "parent_manifest": parent_output.name,
+            "parent_manifest_sha256": sha256(parent_output),
+            "relation_edges": edge_output.name,
+            "relation_edges_sha256": sha256(edge_output),
+            "retention": retention_output.name,
+            "retention_sha256": sha256(retention_output),
+        },
+        "validation_checks": {
+            "self_test_passed": True,
+            "all_candidate_relations_exact_verified": True,
+            "candidate_hash_used_only_for_retrieval": True,
+            "downstream_labels_or_model_outputs_read": False,
+            "all_exclusions_direct_anchor_to_parent": True,
+            "no_numeric_cutoff": True,
+            "no_transitive_closure": True,
+            "fixed_anchor_count_matches_manifest": fixed_anchor_count
+            == sum(row["fingerprint_tier"] == FIXED_TIER for row in anchor_rows),
+            "processed_parent_count_matches_requested_scope": (
+                len(processed_parent_ids) == args.limit
+                if args.limit
+                else len(processed_parent_ids) == 281208
+            ),
+            "fixed_tier_parse_failures_zero": parse_failures == 0,
+        },
+        "open_gates": ([] if args.final_anchor_authority else [
+            "final role-derived anchor authority",
+        ]) + [
+            "derivative propagation audit",
+            "validated nomenclature-alias authority",
+            "finite-completion handling for resolvable ambiguous WURCS",
+            "independent brute-force candidate-recall audit",
+            "post-implementation independent reviewer sign-off",
+        ],
+    }
+    summary_output = args.output_dir / "review_p1_direct_local_neighbor_summary.json"
+    summary_output.write_text(
+        json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    print(json.dumps(summary, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

releases/2026-10-02/benchmark_exclusion/writing/review/multimodal/scripts/build_p1_non_iar_exact_graph_authority_20260711.py

@@ -0,0 +1,380 @@
+#!/usr/bin/env python3
+"""Build the non-IAR A5 anchor and exact/graph-identity exclusion authority."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import hashlib
+import io
+import json
+from collections import Counter, defaultdict
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Iterator
+
+
+WRITING_ROOT = Path(__file__).resolve().parents[3]
+MM = WRITING_ROOT / "review/multimodal"
+ANCHORS = (
+    MM
+    / "outputs/p1_role_complete_anchor_union_20260711/"
+    "review_p1_role_complete_anchor_manifest.tsv.gz"
+)
+GRAPH_EDGES = (
+    MM
+    / "outputs/p1_role_complete_direct_local_neighbor_audit_20260711/"
+    "review_p1_direct_local_neighbor_edges.tsv.gz"
+)
+PARENTS = (
+    MM
+    / "outputs/p0_p1_freeze_20260710/"
+    "review_p1_parent_identity_manifest.tsv.gz"
+)
+DEFAULT_OUTPUT_DIR = MM / "outputs/p1_non_iar_exact_graph_authority_20260711"
+OBJECTIVES = ("sequence", "topology", "ms", "static", "md")
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def as_bool(value: object) -> bool:
+    return str(value).strip().lower() in {"1", "true", "yes"}
+
+
+def split_sources(value: str) -> tuple[str, ...]:
+    return tuple(source for source in value.split(";") if source)
+
+
+def is_iar_source(source: str) -> bool:
+    return (
+        source.startswith("glycosmos_fully_defined_iar_")
+        or source == "grey_seal_external_iar"
+    )
+
+
+@contextmanager
+def gzip_tsv_writer(path: Path, fieldnames: list[str]) -> Iterator[csv.DictWriter]:
+    with path.open("wb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as zipped:
+            with io.TextIOWrapper(zipped, encoding="utf-8", newline="") as text:
+                writer = csv.DictWriter(
+                    text,
+                    fieldnames=fieldnames,
+                    delimiter="\t",
+                    lineterminator="\n",
+                )
+                writer.writeheader()
+                yield writer
+
+
+def objective_flags(row: dict[str, str]) -> dict[str, bool]:
+    return {
+        objective: as_bool(row[f"{objective}_eligible_before_partition"])
+        for objective in OBJECTIVES
+    }
+
+
+def intersection_flags(flags: dict[str, bool]) -> dict[str, bool]:
+    return {
+        "sequence_ms": flags["sequence"] and flags["ms"],
+        "sequence_static": flags["sequence"] and flags["static"],
+        "sequence_topology": flags["sequence"] and flags["topology"],
+        "ms_static": flags["ms"] and flags["static"],
+        "sequence_ms_static": (
+            flags["sequence"] and flags["ms"] and flags["static"]
+        ),
+        "topology_ms_static": (
+            flags["topology"] and flags["ms"] and flags["static"]
+        ),
+        "topology_ms_static_md": (
+            flags["topology"]
+            and flags["ms"]
+            and flags["static"]
+            and flags["md"]
+        ),
+        "ms_md": flags["ms"] and flags["md"],
+        "static_md": flags["static"] and flags["md"],
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--anchor-manifest", type=Path, default=ANCHORS)
+    parser.add_argument("--graph-edges", type=Path, default=GRAPH_EDGES)
+    parser.add_argument("--parent-manifest", type=Path, default=PARENTS)
+    parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    args = parser.parse_args()
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    active_anchors: dict[str, dict[str, object]] = {}
+    active_source_memberships: Counter[str] = Counter()
+    inactive_source_memberships: Counter[str] = Counter()
+    with gzip.open(
+        args.anchor_manifest, "rt", newline="", encoding="utf-8"
+    ) as handle:
+        for row in csv.DictReader(handle, delimiter="\t"):
+            sources = split_sources(row["anchor_sources"])
+            active_sources = tuple(source for source in sources if not is_iar_source(source))
+            inactive_sources = tuple(source for source in sources if is_iar_source(source))
+            if not active_sources:
+                continue
+            wurcs = row["canonical_wurcs"]
+            if wurcs in active_anchors:
+                raise RuntimeError(f"Duplicate anchor WURCS: {wurcs}")
+            active_source_memberships.update(active_sources)
+            inactive_source_memberships.update(inactive_sources)
+            active_anchors[wurcs] = {
+                "row": row,
+                "active_sources": active_sources,
+                "inactive_sources": inactive_sources,
+            }
+
+    if len(active_anchors) != 4532:
+        raise RuntimeError(
+            f"Expected 4,532 non-IAR anchors, found {len(active_anchors):,}"
+        )
+
+    graph_identity_by_parent: dict[str, set[str]] = defaultdict(set)
+    with gzip.open(args.graph_edges, "rt", newline="", encoding="utf-8") as handle:
+        for row in csv.DictReader(handle, delimiter="\t"):
+            if row["relation_type"] != "graph_identity":
+                continue
+            if row["anchor_wurcs"] not in active_anchors:
+                continue
+            graph_identity_by_parent[row["parent_glycorpus_id"]].add(
+                row["anchor_wurcs"]
+            )
+
+    anchor_output = args.output_dir / "review_p1_non_iar_anchor_manifest.tsv.gz"
+    with gzip_tsv_writer(
+        anchor_output,
+        [
+            "canonical_wurcs",
+            "active_anchor_sources",
+            "active_source_count",
+            "inactive_iar_context_sources",
+            "in_submitted_exact_exclusion_list",
+            "observed_in_frozen_graph",
+            "sequence_parent_id",
+            "review_parent_id",
+            "fingerprint_tier",
+            "registry_family_id",
+        ],
+    ) as writer:
+        for wurcs in sorted(active_anchors):
+            item = active_anchors[wurcs]
+            row = item["row"]
+            active_sources = item["active_sources"]
+            inactive_sources = item["inactive_sources"]
+            writer.writerow(
+                {
+                    "canonical_wurcs": wurcs,
+                    "active_anchor_sources": ";".join(active_sources),
+                    "active_source_count": len(active_sources),
+                    "inactive_iar_context_sources": ";".join(inactive_sources),
+                    "in_submitted_exact_exclusion_list": row[
+                        "in_submitted_exact_exclusion_list"
+                    ],
+                    "observed_in_frozen_graph": row["observed_in_frozen_graph"],
+                    "sequence_parent_id": row["sequence_parent_id"],
+                    "review_parent_id": row["review_parent_id"],
+                    "fingerprint_tier": row["fingerprint_tier"],
+                    "registry_family_id": row["registry_family_id"],
+                }
+            )
+
+    eligible_counts: Counter[str] = Counter()
+    excluded_counts: Counter[str] = Counter()
+    retained_counts: Counter[str] = Counter()
+    raw_intersections: Counter[str] = Counter()
+    retained_intersections: Counter[str] = Counter()
+    sequence_exact_count = 0
+    sequence_graph_count = 0
+    sequence_graph_only_count = 0
+    sequence_excluded_count = 0
+    sequence_parent_count = 0
+
+    parent_output = (
+        args.output_dir / "review_p1_non_iar_exact_graph_parent_manifest.tsv.gz"
+    )
+    with gzip_tsv_writer(
+        parent_output,
+        [
+            "parent_glycorpus_id",
+            "canonical_wurcs",
+            "exact_wurcs_anchor",
+            "graph_identity_anchor_count",
+            "graph_identity_anchor_wurcs",
+            "a5_excluded",
+            "a5_exclusion_reason",
+            "sequence_eligible_before_partition",
+            "topology_eligible_before_partition",
+            "ms_eligible_before_partition",
+            "static_eligible_before_partition",
+            "md_eligible_before_partition",
+        ],
+    ) as writer:
+        with gzip.open(
+            args.parent_manifest, "rt", newline="", encoding="utf-8"
+        ) as handle:
+            for row in csv.DictReader(handle, delimiter="\t"):
+                flags = objective_flags(row)
+                if not flags["sequence"]:
+                    continue
+                sequence_parent_count += 1
+                parent = row["parent_glycorpus_id"]
+                exact = row["canonical_wurcs"] in active_anchors
+                graph_anchors = graph_identity_by_parent.get(parent, set())
+                graph = bool(graph_anchors)
+                excluded = exact or graph
+                if exact:
+                    sequence_exact_count += 1
+                if graph:
+                    sequence_graph_count += 1
+                if graph and not exact:
+                    sequence_graph_only_count += 1
+                if excluded:
+                    sequence_excluded_count += 1
+
+                for objective, eligible in flags.items():
+                    if not eligible:
+                        continue
+                    eligible_counts[objective] += 1
+                    if excluded:
+                        excluded_counts[objective] += 1
+                    else:
+                        retained_counts[objective] += 1
+
+                for name, available in intersection_flags(flags).items():
+                    if not available:
+                        continue
+                    raw_intersections[name] += 1
+                    if not excluded:
+                        retained_intersections[name] += 1
+
+                if exact and graph:
+                    reason = "exact_wurcs_and_verified_graph_identity"
+                elif exact:
+                    reason = "exact_wurcs_anchor"
+                elif graph:
+                    reason = "verified_serialized_graph_identity"
+                else:
+                    reason = "retained_no_exact_or_graph_identity"
+                writer.writerow(
+                    {
+                        "parent_glycorpus_id": parent,
+                        "canonical_wurcs": row["canonical_wurcs"],
+                        "exact_wurcs_anchor": exact,
+                        "graph_identity_anchor_count": len(graph_anchors),
+                        "graph_identity_anchor_wurcs": ";".join(
+                            sorted(graph_anchors)
+                        ),
+                        "a5_excluded": excluded,
+                        "a5_exclusion_reason": reason,
+                        **{
+                            f"{objective}_eligible_before_partition": flags[objective]
+                            for objective in OBJECTIVES
+                        },
+                    }
+                )
+
+    expected_retained = {
+        "sequence": 277448,
+        "topology": 89457,
+        "ms": 5315,
+        "static": 36941,
+        "md": 27719,
+    }
+    if dict(retained_counts) != expected_retained:
+        raise RuntimeError(
+            f"Retention mismatch: expected {expected_retained}, got {dict(retained_counts)}"
+        )
+    if sequence_parent_count != 281208 or sequence_excluded_count != 3760:
+        raise RuntimeError(
+            "Expected 281,208 sequence parents with 3,760 exact/graph exclusions"
+        )
+
+    summary = {
+        "schema": "bertose_p1_non_iar_exact_graph_authority_v1",
+        "status": "FROZEN_REVIEW_CANDIDATE_NOT_TRAINING_AUTHORIZATION",
+        "training_authorized": False,
+        "official_submitted_artifacts_modified": False,
+        "policy": (
+            "Use established GlycanML/interaction/AFFINose non-fit roles plus "
+            "predeclared AFFINose component and motif/scaffold stress roles as "
+            "anchors. Exclude sequence parents only for exact canonical WURCS "
+            "or exact-verified serialized graph identity. IAR roles are not A5 "
+            "pretraining exclusions. One-edit, larger-substructure, motif, and "
+            "nearest-neighbour relations remain analysis strata."
+        ),
+        "non_iar_anchor_count": len(active_anchors),
+        "active_source_memberships": dict(sorted(active_source_memberships.items())),
+        "inactive_iar_context_memberships_on_retained_anchors": dict(
+            sorted(inactive_source_memberships.items())
+        ),
+        "sequence_parent_counts": {
+            "eligible": sequence_parent_count,
+            "exact_wurcs_anchor": sequence_exact_count,
+            "verified_graph_identity": sequence_graph_count,
+            "additional_graph_identity": sequence_graph_only_count,
+            "excluded_union": sequence_excluded_count,
+            "retained": retained_counts["sequence"],
+        },
+        "objective_retention": {
+            objective: {
+                "eligible": eligible_counts[objective],
+                "excluded": excluded_counts[objective],
+                "retained": retained_counts[objective],
+                "retained_percent": round(
+                    100.0 * retained_counts[objective] / eligible_counts[objective], 6
+                ),
+            }
+            for objective in OBJECTIVES
+        },
+        "raw_intersections": dict(sorted(raw_intersections.items())),
+        "retained_intersections": dict(sorted(retained_intersections.items())),
+        "input_sha256": {
+            "role_complete_anchor_manifest": sha256(args.anchor_manifest),
+            "role_complete_graph_identity_edges": sha256(args.graph_edges),
+            "parent_identity_manifest": sha256(args.parent_manifest),
+            "script": sha256(Path(__file__).resolve()),
+        },
+        "outputs": {
+            "anchor_manifest": anchor_output.name,
+            "anchor_manifest_sha256": sha256(anchor_output),
+            "parent_manifest": parent_output.name,
+            "parent_manifest_sha256": sha256(parent_output),
+        },
+        "validation_checks": {
+            "non_iar_anchor_count_is_4532": len(active_anchors) == 4532,
+            "sequence_parent_count_is_281208": sequence_parent_count == 281208,
+            "sequence_excluded_count_is_3760": sequence_excluded_count == 3760,
+            "no_numeric_similarity_threshold_used": True,
+            "no_one_edit_or_substructure_neighbour_excluded": True,
+            "no_downstream_labels_or_model_outputs_read": True,
+            "all_expected_retention_counts_match": dict(retained_counts)
+            == expected_retained,
+        },
+        "claim_boundary": (
+            "This is an exact-glycan/serialized-graph-excluded pretraining "
+            "authority, not a leakage-proof claim. Similarity, motif, family, "
+            "substructure, and nearest-neighbour evidence must be reported as "
+            "separate stress analyses."
+        ),
+    }
+    summary_output = args.output_dir / "review_p1_non_iar_authority_summary.json"
+    summary_output.write_text(
+        json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    print(json.dumps(summary, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

releases/2026-10-02/benchmark_exclusion/writing/review/multimodal/scripts/build_review_a5_non_iar_later_role_successor_20260720.py

@@ -0,0 +1,770 @@
+#!/usr/bin/env python3
+"""Build an audit-only A5 exclusion successor for later downstream roles.
+
+This builder is deliberately no-overwrite and training-disabled.  It preserves
+every unaffected frozen 80/20 parent role, adds current paper-facing non-fit
+glycans to the exact/known-graph anchor union, and propagates newly excluded
+parents into the base objective contributor ledger.  It does not inspect any
+downstream target or model output.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import hashlib
+import importlib.util
+import io
+import json
+import os
+import stat
+import sys
+from collections import Counter, defaultdict
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Iterable, Iterator
+
+
+WRITING_ROOT = Path(__file__).resolve().parents[3]
+PROJECT_ROOT = WRITING_ROOT.parent
+MM = WRITING_ROOT / "review/multimodal"
+
+PREDECESSOR_ANCHORS = (
+    MM / "outputs/p1_non_iar_exact_graph_authority_20260711/"
+    "review_p1_non_iar_anchor_manifest.tsv.gz"
+)
+PREDECESSOR_PARENTS = (
+    MM / "outputs/p1_non_iar_exact_graph_authority_20260711/"
+    "review_p1_non_iar_exact_graph_parent_manifest.tsv.gz"
+)
+PREDECESSOR_PARTITION = (
+    MM / "outputs/p1_non_iar_pretraining_partition_80_20_20260712/"
+    "review_p1_non_iar_pretraining_parent_partition.tsv.gz"
+)
+PREDECESSOR_OBJECTIVES = (
+    MM / "outputs/p1_non_iar_pretraining_partition_80_20_20260712/"
+    "review_p1_non_iar_pretraining_objective_partition.tsv.gz"
+)
+FINGERPRINTS = (
+    MM / "outputs/p0_p1_freeze_20260710/"
+    "review_p1_wurcs_motif_fingerprint_manifest.tsv.gz"
+)
+PARENT_IDENTITIES = (
+    MM / "outputs/p0_p1_freeze_20260710/"
+    "review_p1_parent_identity_manifest.tsv.gz"
+)
+PREDECESSOR_GRAPH_EDGES = (
+    MM / "outputs/p1_role_complete_direct_local_neighbor_audit_20260711/"
+    "review_p1_direct_local_neighbor_edges.tsv.gz"
+)
+GRAPH_VERIFIER = MM / "scripts/build_p1_direct_local_neighbor_audit_20260710.py"
+STRICT3 = (
+    MM / "outputs/review_a5_downstream_strict3_authority_20260720_r2/"
+    "review_a5_downstream_strict3_authority.json"
+)
+K20_ANCHORS = (
+    MM / "outputs/p1_affinose_motif_scaffold_balanced_k20_20260711/"
+    "review_p1_affinose_balanced_k20_a5_anchors.tsv.gz"
+)
+STRICT_ANCHORS = (
+    MM / "outputs/review_a5_affinose_strict_glycan_components_20260720_r1/"
+    "review_a5_affinose_strict_glycan_nonfit_anchors_20260720.tsv.gz"
+)
+STRICT_SUMMARY = (
+    MM / "outputs/review_a5_affinose_strict_glycan_components_20260720_r1/"
+    "review_a5_affinose_strict_glycan_candidate_summary_20260720.json"
+)
+STRICT_RECEIPT = (
+    MM / "outputs/review_a5_affinose_strict_glycan_components_20260720_r1/"
+    "review_a5_affinose_strict_glycan_candidate_verification_receipt_20260720.json"
+)
+SEQUENCE_V3 = (
+    PROJECT_ROOT / "data/"
+    "review_sequences_a5_non_iar_80_20_parser_v3_failclosed_20260720_r3/"
+    "review_sequence_parent_index.tsv.gz"
+)
+P6_AUTHORITY = (
+    MM / "outputs/review_a5_affinose_p6_observation_authority_20260720_r2/"
+    "review_a5_affinose_p6_failclosed_authority_20260720.json"
+)
+P6_RECEIPT = (
+    MM / "outputs/review_a5_affinose_p6_observation_authority_20260720_r2/"
+    "review_a5_affinose_p6_failclosed_receipt_20260720.json"
+)
+CORRECTION = MM / "P0_P1_non_iar_authority_correction_20260711.md"
+REFIT_CONTRACT = MM / "P1_parent_split_refit_contract_20260710.md"
+GENERALIZATION_PROTOCOL = MM / "P1_reviewer_complete_generalization_protocol_20260710.md"
+ENDPOINT_ADJUDICATION = MM / "review_a5_interaction_endpoint_adjudication_20260720.md"
+MS_PARENTS = (
+    MM / "outputs/p1_a5_ms_harmonized_identity_repair_20260720_r1/"
+    "review_a5_ms_repaired_parent_manifest.tsv.gz"
+)
+STATIC_CHILD = (
+    MM / "outputs/p1_a5_static_repair_child_authority_20260720_r1/"
+    "review_a5_static_repair_child_authority.tsv.gz"
+)
+TEST_FILE = (
+    MM
+    / "tests/test_build_review_a5_non_iar_later_role_successor_20260720.py"
+)
+
+DEFAULT_OUTPUT = (
+    MM / "outputs/review_a5_non_iar_later_role_successor_20260720_r1"
+)
+
+EXPECTED_SHA256 = {
+    PREDECESSOR_ANCHORS: "048facdfd9a5ff15f1295d28f1d07b4dae2c656ca8714c3ed06df9e284ac199a",
+    PREDECESSOR_PARENTS: "088971d5dbe61f840a45a67a84df39478edd7a80089fd6528fd9fda8063b26b9",
+    PREDECESSOR_PARTITION: "7c4ed33a6cbf50df8d3264421c652c480d3a5eff0eace10c3c958e6dac6b2160",
+    PREDECESSOR_OBJECTIVES: "d09eebb3f7ac47058d2d0cabfd42905f624581bf4c942dceac9cad9c1973e5a0",
+    FINGERPRINTS: "69994cbc859146e97867e62669fd9f71b8d02140ecd9ae8056375af608afdcab",
+    PARENT_IDENTITIES: "55b830d839370c0cec0aab2b61b4721e6ace9ba3ee49e4c93e7be6e486d1c5c4",
+    PREDECESSOR_GRAPH_EDGES: "e95d8122449f4b91271fd297be41a7912244f2398739e349064fc55b781e3ae0",
+    GRAPH_VERIFIER: "a9160769759c1df56238caad6a9f4ed6ec68477d44435ebbc81d64bbf541b64c",
+    STRICT3: "c1bbcfe410c0ee78824657da84a4055e58fdf196624d8981e1aa239ae629f1d8",
+    K20_ANCHORS: "cdeb7b4075f00efc50c0649ac4be11560154e29a6a728c4ddeb54dd6bc26f6c9",
+    STRICT_ANCHORS: "85c8f760dba0e11a4346cd07bc7eb09f5f31d6bf1b0407658130da4173f8a5f9",
+    STRICT_SUMMARY: "d1a56f0bb7f77535c619cc2739933bd751cb5d3e3fcd2e8175fc88671e83e6ee",
+    STRICT_RECEIPT: "a92f442f2b74e630783b5a0eb6fb16738d6aa4c86f71b28c487cc42622d3eee1",
+    SEQUENCE_V3: "c61e766dbffc4a1d88c7c7fb94deb683943c0861403350e79ab09c70b317fa52",
+    P6_AUTHORITY: "a77e486e200e50e9becb3ad45f70ef97272b5a339267c636d746af8d9bf2b2b5",
+    P6_RECEIPT: "d6fb00bd5a79d5a1caa9d06f440357202d85bb6cb3f33c7732f063b4721cf23f",
+    CORRECTION: "f7ba54c4ec66b74e0061ffa75bd963af9589f28a7124e95208099f169657936f",
+    REFIT_CONTRACT: "2533d651ccbf6d86111709676bf528d7c805d1df214ada62fd45772dda0f388e",
+    GENERALIZATION_PROTOCOL: "9556f456490bdd7e03926cc78d9c0a73146386a9b7ac7188a556b1bc23c37b4a",
+    ENDPOINT_ADJUDICATION: "614a4e2144dda63538a26dcbd8fce0a9d604a97c2b4ad07cf80820407ca29fdb",
+    MS_PARENTS: "f4abd4b186f5f4758918b89f19870bc112a7c6be6085f870208235cd03005e26",
+    STATIC_CHILD: "2ca981b78bca56928d449d35467671b03db515496ac61162e68f8a1381a3661f",
+}
+
+OBJECTIVES = ("sequence", "topology", "ms", "static", "md")
+ACTIVE_ROLES = ("pretraining_train", "pretraining_development")
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise RuntimeError(message)
+
+
+def as_bool(value: object) -> bool:
+    return str(value).strip().lower() in {"1", "true", "yes"}
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def validate_input(path: Path, expected: str) -> dict[str, object]:
+    info = path.lstat()
+    require(stat.S_ISREG(info.st_mode), f"input is not a regular file: {path}")
+    require(not path.is_symlink(), f"input is a symlink: {path}")
+    actual = sha256_file(path)
+    require(actual == expected, f"input SHA-256 changed: {path}: {actual}")
+    return {"name": path.name, "bytes": info.st_size, "sha256": actual}
+
+
+def read_tsv(path: Path) -> tuple[list[str], list[dict[str, str]]]:
+    with gzip.open(path, "rt", newline="", encoding="utf-8") as handle:
+        reader = csv.DictReader(handle, delimiter="\t")
+        return list(reader.fieldnames or []), list(reader)
+
+
+def iter_tsv(path: Path) -> Iterator[dict[str, str]]:
+    with gzip.open(path, "rt", newline="", encoding="utf-8") as handle:
+        yield from csv.DictReader(handle, delimiter="\t")
+
+
+@contextmanager
+def deterministic_tsv(path: Path, fields: list[str]) -> Iterator[csv.DictWriter]:
+    with path.open("wb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as zipped:
+            with io.TextIOWrapper(zipped, encoding="utf-8", newline="") as text:
+                writer = csv.DictWriter(
+                    text, fieldnames=fields, delimiter="\t", lineterminator="\n"
+                )
+                writer.writeheader()
+                yield writer
+
+
+def json_bytes(value: object) -> bytes:
+    return (json.dumps(value, indent=2, sort_keys=True) + "\n").encode("utf-8")
+
+
+def output_identity(path: Path) -> dict[str, object]:
+    return {"name": path.name, "bytes": path.stat().st_size, "sha256": sha256_file(path)}
+
+
+def load_graph_verifier() -> Any:
+    spec = importlib.util.spec_from_file_location(
+        "review_a5_bound_graph_verifier_20260720", GRAPH_VERIFIER
+    )
+    require(spec is not None and spec.loader is not None, "cannot load graph verifier")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def strict3_nonfit_wurcs(authority: dict[str, Any]) -> tuple[set[str], set[str], dict[str, int]]:
+    primary: set[str] = set()
+    secondary: set[str] = set()
+    per_task: dict[str, int] = {}
+    for task in authority["task_authorities"]:
+        task_primary: set[str] = set()
+        task_secondary: set[str] = set()
+        for section, target in (("roles", task_primary), ("secondary_roles", task_secondary)):
+            for role in ("method_development", "locked_confirmation"):
+                item = task[section][role]
+                path = PROJECT_ROOT / item["path"]
+                require(sha256_file(path) == item["sha256"], f"strict3 role changed: {path}")
+                with path.open("rt", newline="", encoding="utf-8") as handle:
+                    for row in csv.DictReader(handle):
+                        wurcs = row["WURCS"]
+                        if wurcs:
+                            target.add(wurcs)
+        require(task_secondary <= task_primary, f"secondary strict3 not subset: {task['task']}")
+        primary.update(task_primary)
+        secondary.update(task_secondary)
+        per_task[task["task"]] = len(task_primary)
+    return primary, secondary, per_task
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-directory", type=Path, default=DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    output_names = (
+        "review_a5_non_iar_successor_anchor_manifest.tsv.gz",
+        "review_a5_non_iar_successor_exact_known_graph_parent_manifest.tsv.gz",
+        "review_a5_non_iar_successor_parent_partition.tsv.gz",
+        "review_a5_non_iar_successor_objective_partition.tsv.gz",
+        "review_a5_non_iar_successor_later_role_gap.tsv.gz",
+        "review_a5_non_iar_successor_changed_parent_roles.tsv.gz",
+        "review_a5_non_iar_successor_summary.json",
+        "review_a5_non_iar_successor_receipt.json",
+    )
+    require(
+        not args.output_directory.exists(),
+        f"refusing to overwrite output directory: {args.output_directory}",
+    )
+
+    input_receipts = {
+        str(path.relative_to(PROJECT_ROOT)): validate_input(path, expected)
+        for path, expected in EXPECTED_SHA256.items()
+    }
+
+    anchor_fields, predecessor_anchor_rows = read_tsv(PREDECESSOR_ANCHORS)
+    parent_fields, predecessor_parent_rows = read_tsv(PREDECESSOR_PARENTS)
+    partition_fields, predecessor_partition_rows = read_tsv(PREDECESSOR_PARTITION)
+    objective_fields, predecessor_objective_rows = read_tsv(PREDECESSOR_OBJECTIVES)
+    require(len(predecessor_anchor_rows) == 4532, "predecessor anchor count changed")
+    require(len(predecessor_parent_rows) == 281208, "predecessor parent count changed")
+    require(len(predecessor_partition_rows) == 281208, "predecessor partition count changed")
+    require(len(predecessor_objective_rows) == 281208 * 5, "objective row count changed")
+
+    predecessor_anchors = {row["canonical_wurcs"]: row for row in predecessor_anchor_rows}
+    require(len(predecessor_anchors) == 4532, "duplicate predecessor anchors")
+    predecessor_parents = {
+        row["parent_glycorpus_id"]: row for row in predecessor_parent_rows
+    }
+    predecessor_partition = {
+        row["parent_glycorpus_id"]: row for row in predecessor_partition_rows
+    }
+    require(len(predecessor_parents) == len(predecessor_partition) == 281208, "duplicate parents")
+
+    strict3_authority = json.loads(STRICT3.read_text(encoding="utf-8"))
+    class_primary, class_secondary, class_per_task = strict3_nonfit_wurcs(strict3_authority)
+    _, k20_rows = read_tsv(K20_ANCHORS)
+    _, strict_rows = read_tsv(STRICT_ANCHORS)
+    k20 = {row["glycan_wurcs"]: row for row in k20_rows}
+    strict = {row["glycan_wurcs"]: row for row in strict_rows}
+    require(len(class_primary) == 1967, "strict3 primary nonfit union changed")
+    require(len(k20) == 704, "K20 nonfit count changed")
+    require(len(strict) == 786, "strict AFFINose nonfit count changed")
+    require(class_primary <= set(predecessor_anchors), "strict3 role absent from predecessor anchors")
+    require(class_secondary <= set(predecessor_anchors), "secondary strict3 role absent from predecessor anchors")
+    require(set(k20) <= set(predecessor_anchors), "K20 role absent from predecessor anchors")
+
+    strict_gap = set(strict) - set(predecessor_anchors)
+    require(len(set(strict) & set(predecessor_anchors)) == 693, "strict overlap changed")
+    require(len(strict_gap) == 93, "strict later-role gap changed")
+    current_nonfit_union = class_primary | set(k20) | set(strict)
+    require(len(current_nonfit_union) == 3341, "current nonfit union changed")
+
+    fingerprint_parent: dict[str, dict[str, str]] = {}
+    fingerprint_rows_by_wurcs: dict[str, list[dict[str, str]]] = defaultdict(list)
+    for row in iter_tsv(FINGERPRINTS):
+        wurcs = row["canonical_wurcs"]
+        if wurcs in strict_gap:
+            fingerprint_rows_by_wurcs[wurcs].append(row)
+        if row["graph_record_role"] == "sequence_eligible_parent" and as_bool(
+            row["sequence_eligible_parent"]
+        ):
+            parent = row["parent_glycorpus_id"]
+            require(parent not in fingerprint_parent, f"duplicate fingerprint parent: {parent}")
+            fingerprint_parent[parent] = {
+                "parent_glycorpus_id": parent,
+                "canonical_wurcs": wurcs,
+                "fingerprint_tier": row["fingerprint_tier"],
+                "raw_feature_sha256": row["raw_feature_sha256"],
+                "precluster_union_block_id": row["precluster_union_block_id"],
+                "registry_family_id": row["registry_family_id"],
+                "exact_benchmark_excluded": row["exact_benchmark_excluded"],
+            }
+    require(len(fingerprint_parent) == 281208, "fingerprint parent coverage changed")
+    require(set(fingerprint_rows_by_wurcs) == strict_gap, "strict gap fingerprint coverage incomplete")
+    require(set(fingerprint_parent) == set(predecessor_parents), "parent/fingerprint mismatch")
+
+    graph_by_parent: dict[str, set[str]] = defaultdict(set)
+    for row in iter_tsv(PREDECESSOR_GRAPH_EDGES):
+        if row["relation_type"] == "graph_identity" and row["anchor_wurcs"] in predecessor_anchors:
+            graph_by_parent[row["parent_glycorpus_id"]].add(row["anchor_wurcs"])
+    for parent, row in predecessor_parents.items():
+        expected_graph = set(filter(None, row["graph_identity_anchor_wurcs"].split(";")))
+        require(expected_graph == graph_by_parent.get(parent, set()), f"predecessor graph mismatch: {parent}")
+        exact = row["canonical_wurcs"] in predecessor_anchors
+        require(exact == as_bool(row["exact_wurcs_anchor"]), f"predecessor exact mismatch: {parent}")
+        require(
+            (exact or bool(expected_graph)) == as_bool(row["a5_excluded"]),
+            f"predecessor exclusion mismatch: {parent}",
+        )
+
+    graph_module = load_graph_verifier()
+    fixed_gap_graphs: dict[str, Any] = {}
+    signatures: dict[str, list[str]] = defaultdict(list)
+    tier_by_gap: dict[str, str] = {}
+    for wurcs in sorted(strict_gap):
+        tiers = {row["fingerprint_tier"] for row in fingerprint_rows_by_wurcs[wurcs]}
+        require(len(tiers) == 1, f"inconsistent fingerprint tier: {wurcs}")
+        tier = next(iter(tiers))
+        tier_by_gap[wurcs] = tier
+        if tier == graph_module.FIXED_TIER:
+            graph = graph_module.parse_fixed_tree(wurcs)
+            fixed_gap_graphs[wurcs] = graph
+            signatures[graph_module.signature(graph)].append(wurcs)
+
+    new_graph_by_parent: dict[str, set[str]] = defaultdict(set)
+    for parent, row in fingerprint_parent.items():
+        if row["fingerprint_tier"] != graph_module.FIXED_TIER:
+            continue
+        graph = graph_module.parse_fixed_tree(row["canonical_wurcs"])
+        for anchor in signatures.get(graph_module.signature(graph), []):
+            if graph_module.exact_isomorphic(fixed_gap_graphs[anchor], graph):
+                new_graph_by_parent[parent].add(anchor)
+
+    successor_anchors = dict(predecessor_anchors)
+    for wurcs in sorted(strict_gap):
+        source = f"affinose_strict_direct_edit_component_{strict[wurcs]['component_role']}_20260720"
+        metadata = fingerprint_rows_by_wurcs[wurcs]
+        sequence_rows = [row for row in metadata if row["graph_record_role"] == "sequence_eligible_parent"]
+        parent_rows = [row for row in metadata if row["parent_glycorpus_id"]]
+        registry_ids = {row["registry_family_id"] for row in metadata if row["registry_family_id"]}
+        require(len(registry_ids) <= 1, f"inconsistent registry family: {wurcs}")
+        successor_anchors[wurcs] = {
+            "canonical_wurcs": wurcs,
+            "active_anchor_sources": source,
+            "active_source_count": "1",
+            "inactive_iar_context_sources": "",
+            "in_submitted_exact_exclusion_list": str(
+                any(as_bool(row["exact_benchmark_excluded"]) for row in metadata)
+            ),
+            "observed_in_frozen_graph": str(bool(parent_rows)),
+            "sequence_parent_id": sequence_rows[0]["parent_glycorpus_id"] if sequence_rows else "",
+            "review_parent_id": parent_rows[0]["parent_glycorpus_id"] if parent_rows else "",
+            "fingerprint_tier": tier_by_gap[wurcs],
+            "registry_family_id": next(iter(registry_ids), ""),
+        }
+    require(len(successor_anchors) == 4625, "successor anchor count changed")
+
+    successor_parent_rows: list[dict[str, str]] = []
+    newly_excluded: set[str] = set()
+    new_exact_parents: set[str] = set()
+    new_graph_alias_parents: set[str] = set()
+    for source in predecessor_parent_rows:
+        parent = source["parent_glycorpus_id"]
+        canonical = source["canonical_wurcs"]
+        exact = canonical in successor_anchors
+        graph_anchors = graph_by_parent.get(parent, set()) | new_graph_by_parent.get(parent, set())
+        graph = bool(graph_anchors)
+        excluded = exact or graph
+        if canonical in strict_gap:
+            new_exact_parents.add(parent)
+        if new_graph_by_parent.get(parent) and canonical not in strict_gap:
+            new_graph_alias_parents.add(parent)
+        if excluded and not as_bool(source["a5_excluded"]):
+            newly_excluded.add(parent)
+        if exact and graph:
+            reason = "exact_wurcs_and_verified_graph_identity"
+        elif exact:
+            reason = "exact_wurcs_anchor"
+        elif graph:
+            reason = "verified_serialized_graph_identity"
+        else:
+            reason = "retained_no_exact_or_graph_identity"
+        row = dict(source)
+        row.update(
+            {
+                "exact_wurcs_anchor": str(exact),
+                "graph_identity_anchor_count": str(len(graph_anchors)),
+                "graph_identity_anchor_wurcs": ";".join(sorted(graph_anchors)),
+                "a5_excluded": str(excluded),
+                "a5_exclusion_reason": reason,
+            }
+        )
+        successor_parent_rows.append(row)
+    require(len(new_exact_parents) == 73, "new exact parent count changed")
+    require(len(new_graph_alias_parents) == 0, "new graph-only alias count changed")
+    require(len(newly_excluded) == 73, "new exclusion union changed")
+    successor_exact_count = sum(
+        as_bool(row["exact_wurcs_anchor"]) for row in successor_parent_rows
+    )
+    successor_graph_count = sum(
+        int(row["graph_identity_anchor_count"]) > 0 for row in successor_parent_rows
+    )
+    successor_graph_only_count = sum(
+        not as_bool(row["exact_wurcs_anchor"])
+        and int(row["graph_identity_anchor_count"]) > 0
+        for row in successor_parent_rows
+    )
+    require(
+        (successor_exact_count, successor_graph_count, successor_graph_only_count)
+        == (3673, 3587, 160),
+        "successor exact/known-graph counts changed",
+    )
+
+    successor_parent_by_id = {
+        row["parent_glycorpus_id"]: row for row in successor_parent_rows
+    }
+    role_by_parent: dict[str, str] = {}
+    successor_partition_rows: list[dict[str, str]] = []
+    role_transitions: Counter[tuple[str, str]] = Counter()
+    for source in predecessor_partition_rows:
+        parent = source["parent_glycorpus_id"]
+        old_role = source["pretraining_partition"]
+        new_role = (
+            "excluded_exact_or_verified_graph_identity"
+            if parent in newly_excluded
+            else old_role
+        )
+        role_by_parent[parent] = new_role
+        role_transitions[(old_role, new_role)] += 1
+        row = dict(source)
+        row["a5_excluded"] = str(new_role not in ACTIVE_ROLES)
+        row["a5_exclusion_reason"] = successor_parent_by_id[parent][
+            "a5_exclusion_reason"
+        ]
+        row["pretraining_partition"] = new_role
+        row["learned_preprocessing_fit_contributor"] = str(new_role == "pretraining_train")
+        row["model_pretraining_contributor"] = str(new_role == "pretraining_train")
+        successor_partition_rows.append(row)
+
+    role_counts = Counter(role_by_parent.values())
+    require(
+        role_counts
+        == {
+            "pretraining_train": 221899,
+            "pretraining_development": 55476,
+            "excluded_exact_or_verified_graph_identity": 3833,
+        },
+        f"successor role counts changed: {role_counts}",
+    )
+    require(
+        role_transitions[("pretraining_train", "excluded_exact_or_verified_graph_identity")] == 59
+        and role_transitions[("pretraining_development", "excluded_exact_or_verified_graph_identity")] == 14,
+        "strict role-transition counts changed",
+    )
+    require(
+        all(old == new or new == "excluded_exact_or_verified_graph_identity" for old, new in role_transitions),
+        "unaffected 80/20 role moved",
+    )
+
+    objective_counts: Counter[tuple[str, str]] = Counter()
+    objective_impacts: Counter[tuple[str, str]] = Counter()
+    successor_objective_rows: list[dict[str, str]] = []
+    flags_by_parent: dict[str, dict[str, bool]] = defaultdict(dict)
+    for source in predecessor_objective_rows:
+        parent = source["parent_glycorpus_id"]
+        objective = source["objective"]
+        eligible = as_bool(source["eligible_before_partition"])
+        old_role = source["pretraining_partition"]
+        new_role = role_by_parent[parent]
+        row = dict(source)
+        row["pretraining_partition"] = new_role
+        row["objective_train_contributor"] = str(eligible and new_role == "pretraining_train")
+        row["objective_development_contributor"] = str(
+            eligible and new_role == "pretraining_development"
+        )
+        successor_objective_rows.append(row)
+        flags_by_parent[parent][objective] = eligible
+        if eligible and new_role in ACTIVE_ROLES:
+            objective_counts[(new_role, objective)] += 1
+        if eligible and parent in newly_excluded:
+            objective_impacts[(old_role, objective)] += 1
+    require(all(set(flags) == set(OBJECTIVES) for flags in flags_by_parent.values()), "objective coverage incomplete")
+
+    registry_by_parent: dict[str, str] = {}
+    for row in iter_tsv(PARENT_IDENTITIES):
+        parent = row["parent_glycorpus_id"]
+        if parent in role_by_parent:
+            registry_by_parent[parent] = row["registry_family_id"]
+    require(set(registry_by_parent) == set(role_by_parent), "registry-family coverage incomplete")
+    crossings: dict[str, int] = {}
+    for name, grouping in (
+        ("precluster_union_block_id", {p: fingerprint_parent[p]["precluster_union_block_id"] for p in role_by_parent}),
+        ("raw_feature_sha256", {p: fingerprint_parent[p]["raw_feature_sha256"] for p in role_by_parent}),
+        ("registry_family_id", registry_by_parent),
+    ):
+        roles_by_group: dict[str, set[str]] = defaultdict(set)
+        for parent, group in grouping.items():
+            role = role_by_parent[parent]
+            if role in ACTIVE_ROLES:
+                roles_by_group[group].add(role)
+        crossings[name] = sum(len(roles) > 1 for roles in roles_by_group.values())
+    require(not any(crossings.values()), f"retained grouping crosses roles: {crossings}")
+
+    sequence_v3 = {row["parent_glycorpus_id"]: row for row in iter_tsv(SEQUENCE_V3)}
+    require(set(sequence_v3) == set(role_by_parent), "sequence-v3 parent coverage changed")
+    strict_sequence_roles = Counter(
+        sequence_v3[parent]["pretraining_partition"] for parent in newly_excluded
+    )
+
+    ms_impacted = [row for row in iter_tsv(MS_PARENTS) if row["parent_glycorpus_id"] in newly_excluded]
+    ms_impacted_roles = Counter(row["pretraining_partition"] for row in ms_impacted)
+    static_impacted = [row for row in iter_tsv(STATIC_CHILD) if row["parent_glycorpus_id"] in newly_excluded]
+    static_active_states = Counter(
+        row["a5_static_partition"] for row in static_impacted if row["a5_static_partition"] in ACTIVE_ROLES
+    )
+    static_active_parents = Counter()
+    static_parent_roles: dict[str, str] = {}
+    for row in static_impacted:
+        if row["a5_static_partition"] in ACTIVE_ROLES:
+            static_parent_roles[row["parent_glycorpus_id"]] = row["a5_static_partition"]
+    static_active_parents.update(static_parent_roles.values())
+
+    gap_fields = [
+        "canonical_wurcs",
+        "strict_component_role",
+        "fingerprint_tier",
+        "fingerprint_graph_record_roles",
+        "sequence_parent_id",
+        "sequence_v3_pretraining_partition",
+        "successor_pretraining_partition",
+        "known_graph_identity_parent_count",
+        "known_graph_only_alias_parent_count",
+        *[f"{objective}_eligible_before_partition" for objective in OBJECTIVES],
+    ]
+    gap_rows: list[dict[str, object]] = []
+    for wurcs in sorted(strict_gap):
+        parent_candidates = [
+            row["parent_glycorpus_id"]
+            for row in fingerprint_rows_by_wurcs[wurcs]
+            if row["graph_record_role"] == "sequence_eligible_parent"
+        ]
+        parent = parent_candidates[0] if parent_candidates else ""
+        identity_parents = sorted(
+            candidate for candidate, anchors in new_graph_by_parent.items() if wurcs in anchors
+        )
+        graph_only = [candidate for candidate in identity_parents if fingerprint_parent[candidate]["canonical_wurcs"] != wurcs]
+        flags = flags_by_parent.get(parent, {})
+        gap_rows.append(
+            {
+                "canonical_wurcs": wurcs,
+                "strict_component_role": strict[wurcs]["component_role"],
+                "fingerprint_tier": tier_by_gap[wurcs],
+                "fingerprint_graph_record_roles": ";".join(
+                    sorted({row["graph_record_role"] for row in fingerprint_rows_by_wurcs[wurcs]})
+                ),
+                "sequence_parent_id": parent,
+                "sequence_v3_pretraining_partition": sequence_v3[parent]["pretraining_partition"] if parent else "absent",
+                "successor_pretraining_partition": role_by_parent[parent] if parent else "absent",
+                "known_graph_identity_parent_count": len(identity_parents),
+                "known_graph_only_alias_parent_count": len(graph_only),
+                **{f"{objective}_eligible_before_partition": str(flags.get(objective, False)) for objective in OBJECTIVES},
+            }
+        )
+
+    changed_fields = [
+        "parent_glycorpus_id",
+        "canonical_wurcs",
+        "predecessor_pretraining_partition",
+        "successor_pretraining_partition",
+        "strict_component_role",
+        "successor_exclusion_reason",
+    ]
+    changed_rows = []
+    for parent in sorted(newly_excluded):
+        canonical = predecessor_parents[parent]["canonical_wurcs"]
+        changed_rows.append(
+            {
+                "parent_glycorpus_id": parent,
+                "canonical_wurcs": canonical,
+                "predecessor_pretraining_partition": predecessor_partition[parent]["pretraining_partition"],
+                "successor_pretraining_partition": role_by_parent[parent],
+                "strict_component_role": strict[canonical]["component_role"],
+                "successor_exclusion_reason": successor_parent_by_id[parent]["a5_exclusion_reason"],
+            }
+        )
+
+    args.output_directory.mkdir(parents=True, exist_ok=False)
+    paths = {name: args.output_directory / name for name in output_names}
+    with deterministic_tsv(paths[output_names[0]], anchor_fields) as writer:
+        writer.writerows(successor_anchors[w] for w in sorted(successor_anchors))
+    with deterministic_tsv(paths[output_names[1]], parent_fields) as writer:
+        writer.writerows(successor_parent_rows)
+    with deterministic_tsv(paths[output_names[2]], partition_fields) as writer:
+        writer.writerows(successor_partition_rows)
+    with deterministic_tsv(paths[output_names[3]], objective_fields) as writer:
+        writer.writerows(successor_objective_rows)
+    with deterministic_tsv(paths[output_names[4]], gap_fields) as writer:
+        writer.writerows(gap_rows)
+    with deterministic_tsv(paths[output_names[5]], changed_fields) as writer:
+        writer.writerows(changed_rows)
+
+    active_total = role_counts["pretraining_train"] + role_counts["pretraining_development"]
+    summary: dict[str, Any] = {
+        "schema": "bertose_a5_non_iar_later_role_successor_v1",
+        "status": "PREPARED_FAIL_CLOSED_REQUIRES_ALL_LEARNED_REFITS_AND_NEW_PRETRAINING",
+        "training_authorized": False,
+        "scientific_launch_authorized": False,
+        "official_submitted_or_predecessor_artifacts_modified": False,
+        "implementation": {
+            "builder": {
+                "name": Path(__file__).name,
+                "bytes": Path(__file__).stat().st_size,
+                "sha256": sha256_file(Path(__file__)),
+            },
+            "bound_graph_verifier": input_receipts[
+                str(GRAPH_VERIFIER.relative_to(PROJECT_ROOT))
+            ],
+            "tests": {
+                "name": TEST_FILE.name,
+                "bytes": TEST_FILE.stat().st_size,
+                "sha256": sha256_file(TEST_FILE),
+            },
+        },
+        "policy": {
+            "source": "P0/P1 exact canonical WURCS or known retrieved and exact-verified serialized graph identity",
+            "later_role_rule": "any later paper-facing endpoint must add non-fit glycans through a versioned authority rebuild",
+            "allocation": "preserve every unaffected frozen 80/20 role; move only newly matched parents to transform-only exclusion",
+            "graph_retrieval_boundary": "fixed-tree exact-linkage WL retrieval plus exact labelled isomorphism; not exhaustive for nonfixed WURCS",
+        },
+        "endpoint_adjudication": {
+            "strict_affinose_status": "selected_primary_interaction_double_cold_endpoint",
+            "corrected_k20_status": "mandatory_companion",
+            "generic_unlabelled_pretraining_overlap_note": "may be acceptable in other protocols, but conflicts with this frozen project-specific exclusion rule",
+            "target_or_outcome_values_read": False,
+        },
+        "current_nonfit_coverage": {
+            "strict3_classification_primary_unique_wurcs": len(class_primary),
+            "strict3_classification_secondary_unique_wurcs": len(class_secondary),
+            "strict3_primary_per_task_unique_wurcs": dict(sorted(class_per_task.items())),
+            "strict3_primary_missing_from_predecessor_4532": len(class_primary - set(predecessor_anchors)),
+            "k20_nonfit_wurcs": len(k20),
+            "k20_missing_from_predecessor_4532": len(set(k20) - set(predecessor_anchors)),
+            "strict_affinose_nonfit_wurcs": len(strict),
+            "strict_affinose_predecessor_overlap": len(set(strict) & set(predecessor_anchors)),
+            "strict_affinose_missing_from_predecessor": len(strict_gap),
+            "all_current_nonfit_unique_wurcs": len(current_nonfit_union),
+        },
+        "successor_anchor_and_parent_counts": {
+            "predecessor_active_anchors": len(predecessor_anchors),
+            "successor_active_anchors": len(successor_anchors),
+            "added_strict_anchors": len(strict_gap),
+            "added_fixed_tree_exact_linkage_anchors": sum(t == graph_module.FIXED_TIER for t in tier_by_gap.values()),
+            "new_exact_sequence_parents": len(new_exact_parents),
+            "new_known_graph_identity_edges": sum(len(v) for v in new_graph_by_parent.values()),
+            "new_known_graph_only_alias_parents": len(new_graph_alias_parents),
+            "new_excluded_parent_union": len(newly_excluded),
+            "successor_exact_wurcs_sequence_parents": successor_exact_count,
+            "successor_known_graph_identity_sequence_parents": successor_graph_count,
+            "successor_additional_known_graph_only_sequence_parents": successor_graph_only_count,
+            "successor_excluded_parent_union": sum(as_bool(row["a5_excluded"]) for row in successor_parent_rows),
+        },
+        "preserved_80_20_partition": {
+            "parent_role_counts": dict(sorted(role_counts.items())),
+            "retained_train_fraction": role_counts["pretraining_train"] / active_total,
+            "retained_development_fraction": role_counts["pretraining_development"] / active_total,
+            "newly_excluded_predecessor_roles": dict(sorted(strict_sequence_roles.items())),
+            "unaffected_train_development_role_moves": 0,
+            "retained_group_crossings": crossings,
+        },
+        "base_objective_successor_counts": {
+            role: {objective: objective_counts[(role, objective)] for objective in OBJECTIVES}
+            for role in ACTIVE_ROLES
+        },
+        "base_objective_removed_counts": {
+            role: {objective: objective_impacts[(role, objective)] for objective in OBJECTIVES}
+            for role in ACTIVE_ROLES
+        },
+        "current_repaired_derivative_snapshot_impact": {
+            "ms_parent_rows_to_move_transform_only": len(ms_impacted),
+            "ms_parent_rows_by_predecessor_role": dict(sorted(ms_impacted_roles.items())),
+            "static_child_active_parent_rows_to_move_transform_only": sum(static_active_parents.values()),
+            "static_child_active_parents_by_predecessor_role": dict(sorted(static_active_parents.items())),
+            "static_child_active_state_rows_to_move_transform_only": sum(static_active_states.values()),
+            "static_child_active_states_by_predecessor_role": dict(sorted(static_active_states.items())),
+            "static_child_snapshot_is_not_final_training_authority": True,
+        },
+        "required_successors_before_any_compute": [
+            "fit-only BPE vocabulary and complete sequence tensor package",
+            "topology-r3 parent/pair authority and train-only null",
+            "repaired no-RT MS roles/tokens and train-only null",
+            "final static graph materializer plus GNN/RVQ/codebooks/tokens and train-only null",
+            "multimodal dataset/planner/masker/sampler manifests",
+            "all enabled-objective null scales and validation selection ledger",
+            "A000, A111, and every other paper-facing A5 factorial pretraining run",
+            "downstream strict/K20 evaluators bound to the resulting frozen A5 exports",
+        ],
+        "reuse_adjudication": {
+            "historical_a000_a111_reusable_for_strict_primary_claim": False,
+            "reason": "59 newly excluded parents influenced fitting and fit-only transforms; 14 influenced development selection; downstream outcomes cannot repair upstream exposure",
+            "exploratory_alternative": "only if strict is demoted from selected primary and exposure is explicitly reported; contradicted by the bound endpoint adjudication",
+        },
+        "input_artifacts": input_receipts,
+        "output_artifacts": {},
+        "validation_checks": {
+            "all_current_strict3_primary_nonfit_wurcs_in_successor": class_primary <= set(successor_anchors),
+            "all_current_strict3_secondary_nonfit_wurcs_in_successor": class_secondary <= set(successor_anchors),
+            "all_current_k20_nonfit_wurcs_in_successor": set(k20) <= set(successor_anchors),
+            "all_current_strict_affinose_nonfit_wurcs_in_successor": set(strict) <= set(successor_anchors),
+            "predecessor_graph_identity_replayed_exactly": True,
+            "new_graph_candidates_exact_isomorphism_verified": True,
+            "all_new_exact_or_known_graph_parents_excluded": len(newly_excluded) == 73,
+            "no_unaffected_80_20_parent_role_changed": True,
+            "no_retained_group_crossing": not any(crossings.values()),
+            "no_downstream_targets_or_model_outputs_read": True,
+            "training_fail_closed": True,
+        },
+    }
+    summary["output_artifacts"] = {
+        name: output_identity(paths[name]) for name in output_names[:6]
+    }
+    paths[output_names[6]].write_bytes(json_bytes(summary))
+    receipt = {
+        "schema": "bertose_a5_non_iar_later_role_successor_receipt_v1",
+        "status": "PASS_AUDIT_ONLY_FAIL_CLOSED",
+        "training_authorized": False,
+        "summary": output_identity(paths[output_names[6]]),
+        "payloads": {name: output_identity(paths[name]) for name in output_names[:6]},
+        "checks": summary["validation_checks"],
+        "determinism_contract": {
+            "gzip_mtime": 0,
+            "json_keys_sorted": True,
+            "absolute_output_paths_embedded": False,
+            "input_hashes_rechecked_after_build": True,
+        },
+    }
+    for path, expected in EXPECTED_SHA256.items():
+        require(sha256_file(path) == expected, f"input changed during build: {path}")
+    paths[output_names[7]].write_bytes(json_bytes(receipt))
+    print(json.dumps({"summary": output_identity(paths[output_names[6]]), "receipt": output_identity(paths[output_names[7]]), "role_counts": dict(role_counts)}, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

releases/2026-10-02/benchmark_exclusion/writing/review/multimodal/scripts/repartition_a5_non_iar_80_20_20260712.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""Reassign the frozen non-IAR A5 authority to a grouped 80/20 split."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import gzip
+import hashlib
+import io
+import json
+from collections import Counter, defaultdict
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Iterator
+
+
+WRITING_ROOT = Path(__file__).resolve().parents[3]
+MM = WRITING_ROOT / "review/multimodal"
+SOURCE = MM / "outputs/p1_non_iar_pretraining_partition_20260711"
+SOURCE_PARENT = SOURCE / "review_p1_non_iar_pretraining_parent_partition.tsv.gz"
+SOURCE_OBJECTIVE = SOURCE / "review_p1_non_iar_pretraining_objective_partition.tsv.gz"
+FINGERPRINTS = (
+    MM
+    / "outputs/p0_p1_freeze_20260710/"
+    "review_p1_wurcs_motif_fingerprint_manifest.tsv.gz"
+)
+IDENTITY = (
+    MM
+    / "outputs/p0_p1_freeze_20260710/"
+    "review_p1_parent_identity_manifest.tsv.gz"
+)
+DEFAULT_OUTPUT = MM / "outputs/p1_non_iar_pretraining_partition_80_20_20260712"
+SOURCE_PARENT_SHA256 = "1bcbd764f0970e664547692a9bb2c39442a9faecd01faa2def4dff7303687fcc"
+SOURCE_OBJECTIVE_SHA256 = "5bf36799bfa96f5a275782d046570bcec54932b0d7aee04693080151e6b1710c"
+TRAIN_FRACTION = 0.80
+SPLIT_SALT = "BERTose-local-split-audit-v2-20260712|block|0.80"
+ACTIVE_ROLES = ("pretraining_train", "pretraining_development")
+OBJECTIVES = ("sequence", "topology", "ms", "static", "md")
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def stable_hash(value: str) -> str:
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def as_bool(value: object) -> bool:
+    return str(value).strip().lower() in {"1", "true", "yes"}
+
+
+def read_tsv(path: Path) -> tuple[list[str], list[dict[str, str]]]:
+    with gzip.open(path, "rt", newline="", encoding="utf-8") as handle:
+        reader = csv.DictReader(handle, delimiter="\t")
+        return list(reader.fieldnames or []), list(reader)
+
+
+@contextmanager
+def deterministic_tsv(path: Path, fields: list[str]) -> Iterator[csv.DictWriter]:
+    with path.open("wb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as zipped:
+            with io.TextIOWrapper(zipped, encoding="utf-8", newline="") as text:
+                writer = csv.DictWriter(
+                    text,
+                    fieldnames=fields,
+                    delimiter="\t",
+                    lineterminator="\n",
+                )
+                writer.writeheader()
+                yield writer
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source-parent", type=Path, default=SOURCE_PARENT)
+    parser.add_argument("--source-objective", type=Path, default=SOURCE_OBJECTIVE)
+    parser.add_argument("--fingerprints", type=Path, default=FINGERPRINTS)
+    parser.add_argument("--identity", type=Path, default=IDENTITY)
+    parser.add_argument("--output-directory", type=Path, default=DEFAULT_OUTPUT)
+    args = parser.parse_args()
+
+    if sha256_file(args.source_parent) != SOURCE_PARENT_SHA256:
+        raise RuntimeError("source A5 parent authority changed")
+    if sha256_file(args.source_objective) != SOURCE_OBJECTIVE_SHA256:
+        raise RuntimeError("source A5 objective authority changed")
+
+    output_parent = (
+        args.output_directory / "review_p1_non_iar_pretraining_parent_partition.tsv.gz"
+    )
+    output_objective = (
+        args.output_directory
+        / "review_p1_non_iar_pretraining_objective_partition.tsv.gz"
+    )
+    output_summary = (
+        args.output_directory / "review_p1_non_iar_partition_summary.json"
+    )
+    outputs = (output_parent, output_objective, output_summary)
+    if any(path.exists() for path in outputs):
+        raise FileExistsError(
+            f"refusing to overwrite existing 80/20 outputs: "
+            f"{[str(path) for path in outputs if path.exists()]}"
+        )
+
+    parent_fields, parent_rows = read_tsv(args.source_parent)
+    objective_fields, objective_rows = read_tsv(args.source_objective)
+    if len(parent_rows) != 281208 or len(objective_rows) != 281208 * 5:
+        raise RuntimeError("source non-IAR authority has unexpected row counts")
+    parents = {row["parent_glycorpus_id"]: row for row in parent_rows}
+    if len(parents) != len(parent_rows):
+        raise RuntimeError("source parent authority repeats a parent")
+
+    retained_by_block: dict[str, list[str]] = defaultdict(list)
+    for parent, row in parents.items():
+        if not as_bool(row["a5_excluded"]):
+            retained_by_block[row["precluster_union_block_id"]].append(parent)
+    retained_count = sum(map(len, retained_by_block.values()))
+    excluded_count = len(parent_rows) - retained_count
+    if (retained_count, excluded_count) != (277448, 3760):
+        raise RuntimeError("source retained/excluded counts changed")
+
+    ordered_blocks = sorted(
+        retained_by_block,
+        key=lambda block: stable_hash(f"{SPLIT_SALT}|{block}"),
+    )
+    target_train_rows = TRAIN_FRACTION * retained_count
+    cumulative = 0
+    role_by_block: dict[str, str] = {}
+    for block in ordered_blocks:
+        block_size = len(retained_by_block[block])
+        midpoint = cumulative + block_size / 2
+        role_by_block[block] = (
+            "pretraining_train"
+            if midpoint < target_train_rows
+            else "pretraining_development"
+        )
+        cumulative += block_size
+
+    role_by_parent = {
+        parent: (
+            "excluded_exact_or_verified_graph_identity"
+            if as_bool(row["a5_excluded"])
+            else role_by_block[row["precluster_union_block_id"]]
+        )
+        for parent, row in parents.items()
+    }
+
+    parent_allowed_changes = {
+        "pretraining_partition",
+        "learned_preprocessing_fit_contributor",
+        "model_pretraining_contributor",
+    }
+    new_parent_rows: list[dict[str, str]] = []
+    for source in parent_rows:
+        row = dict(source)
+        role = role_by_parent[source["parent_glycorpus_id"]]
+        is_train = role == "pretraining_train"
+        row["pretraining_partition"] = role
+        row["learned_preprocessing_fit_contributor"] = str(is_train)
+        row["model_pretraining_contributor"] = str(is_train)
+        changed = {field for field in row if row[field] != source[field]}
+        if not changed <= parent_allowed_changes:
+            raise RuntimeError(f"80/20 repartition changed parent authority fields: {changed}")
+        new_parent_rows.append(row)
+
+    objective_allowed_changes = {
+        "pretraining_partition",
+        "objective_train_contributor",
+        "objective_development_contributor",
+    }
+    new_objective_rows: list[dict[str, str]] = []
+    objective_counts: Counter[tuple[str, str]] = Counter()
+    flags_by_parent: dict[str, dict[str, bool]] = defaultdict(dict)
+    for source in objective_rows:
+        row = dict(source)
+        parent = source["parent_glycorpus_id"]
+        objective = source["objective"]
+        role = role_by_parent[parent]
+        eligible = as_bool(source["eligible_before_partition"])
+        row["pretraining_partition"] = role
+        row["objective_train_contributor"] = str(
+            eligible and role == "pretraining_train"
+        )
+        row["objective_development_contributor"] = str(
+            eligible and role == "pretraining_development"
+        )
+        changed = {field for field in row if row[field] != source[field]}
+        if not changed <= objective_allowed_changes:
+            raise RuntimeError(
+                f"80/20 repartition changed objective authority fields: {changed}"
+            )
+        if role in ACTIVE_ROLES and eligible:
+            objective_counts[(role, objective)] += 1
+        flags_by_parent[parent][objective] = eligible
+        new_objective_rows.append(row)
+
+    if any(set(flags) != set(OBJECTIVES) for flags in flags_by_parent.values()):
+        raise RuntimeError("objective authority is incomplete for at least one parent")
+
+    raw_feature_by_parent: dict[str, str] = {}
+    with gzip.open(args.fingerprints, "rt", newline="", encoding="utf-8") as handle:
+        for row in csv.DictReader(handle, delimiter="\t"):
+            parent = row["parent_glycorpus_id"]
+            if parent in parents and row.get("graph_record_role") == "sequence_eligible_parent":
+                raw_feature_by_parent[parent] = row["raw_feature_sha256"]
+    family_by_parent: dict[str, str] = {}
+    with gzip.open(args.identity, "rt", newline="", encoding="utf-8") as handle:
+        for row in csv.DictReader(handle, delimiter="\t"):
+            parent = row["parent_glycorpus_id"]
+            if parent in parents:
+                family_by_parent[parent] = row["registry_family_id"]
+    if set(raw_feature_by_parent) != set(parents) or set(family_by_parent) != set(parents):
+        raise RuntimeError("grouping authorities do not cover the parent authority")
+
+    crossings: dict[str, int] = {}
+    for name, grouping in (
+        ("precluster_union_block_id", {p: parents[p]["precluster_union_block_id"] for p in parents}),
+        ("raw_feature_sha256", raw_feature_by_parent),
+        ("registry_family_id", family_by_parent),
+    ):
+        roles_by_group: dict[str, set[str]] = defaultdict(set)
+        for parent, group in grouping.items():
+            role = role_by_parent[parent]
+            if role in ACTIVE_ROLES:
+                roles_by_group[group].add(role)
+        crossings[name] = sum(len(roles) > 1 for roles in roles_by_group.values())
+    if any(crossings.values()):
+        raise RuntimeError(f"80/20 grouping authority crosses roles: {crossings}")
+
+    intersection_counts: Counter[tuple[str, str]] = Counter()
+    for parent, flags in flags_by_parent.items():
+        role = role_by_parent[parent]
+        if role not in ACTIVE_ROLES:
+            continue
+        for name, enabled in {
+            "topology_ms": flags["topology"] and flags["ms"],
+            "topology_static": flags["topology"] and flags["static"],
+            "ms_static": flags["ms"] and flags["static"],
+            "topology_ms_static": flags["topology"] and flags["ms"] and flags["static"],
+            "topology_ms_static_md": flags["topology"] and flags["ms"] and flags["static"] and flags["md"],
+        }.items():
+            intersection_counts[(role, name)] += int(enabled)
+
+    args.output_directory.mkdir(parents=True, exist_ok=True)
+    with deterministic_tsv(output_parent, parent_fields) as writer:
+        writer.writerows(new_parent_rows)
+    with deterministic_tsv(output_objective, objective_fields) as writer:
+        writer.writerows(new_objective_rows)
+
+    role_counts = Counter(role_by_parent.values())
+    summary = {
+        "schema": "bertose_p1_non_iar_pretraining_partition_v2",
+        "status": "FROZEN_REVIEW_CANDIDATE_NOT_TRAINING_AUTHORIZATION",
+        "training_authorized": False,
+        "official_submitted_artifacts_modified": False,
+        "change_scope": "role_only_repartition_from_frozen_non_iar_authority",
+        "split_method": "deterministic_whole_precluster_block_weighted_midpoint",
+        "split_salt": SPLIT_SALT,
+        "target_train_fraction": TRAIN_FRACTION,
+        "realized_train_fraction": role_counts["pretraining_train"] / retained_count,
+        "parent_role_counts": dict(sorted(role_counts.items())),
+        "retained_block_count": len(retained_by_block),
+        "largest_retained_block": max(map(len, retained_by_block.values())),
+        "objective_partitions": {
+            role: {
+                objective: objective_counts[(role, objective)]
+                for objective in OBJECTIVES
+            }
+            for role in ACTIVE_ROLES
+        },
+        "intersection_partitions": {
+            role: {
+                name: intersection_counts[(role, name)]
+                for name in (
+                    "topology_ms",
+                    "topology_static",
+                    "ms_static",
+                    "topology_ms_static",
+                    "topology_ms_static_md",
+                )
+            }
+            for role in ACTIVE_ROLES
+        },
+        "group_crossings": crossings,
+        "validation_checks": {
+            "all_281208_parent_rows_preserved": len(new_parent_rows) == 281208,
+            "all_1406040_objective_rows_preserved": len(new_objective_rows) == 1406040,
+            "only_parent_role_fields_changed": True,
+            "only_objective_role_fields_changed": True,
+            "no_declared_group_crosses_train_development": not any(crossings.values()),
+            "no_downstream_outcome_used": True,
+            "submitted_artifacts_left_unchanged": True,
+        },
+        "inputs": {
+            "source_parent_partition": {
+                "path": str(args.source_parent),
+                "sha256": sha256_file(args.source_parent),
+            },
+            "source_objective_partition": {
+                "path": str(args.source_objective),
+                "sha256": sha256_file(args.source_objective),
+            },
+            "fingerprints": {
+                "path": str(args.fingerprints),
+                "sha256": sha256_file(args.fingerprints),
+            },
+            "parent_identity": {
+                "path": str(args.identity),
+                "sha256": sha256_file(args.identity),
+            },
+            "implementation": {
+                "path": str(Path(__file__)),
+                "sha256": sha256_file(Path(__file__)),
+            },
+        },
+        "outputs": {
+            "parent_partition": {
+                "path": str(output_parent),
+                "sha256": sha256_file(output_parent),
+            },
+            "objective_partition": {
+                "path": str(output_objective),
+                "sha256": sha256_file(output_objective),
+            },
+        },
+    }
+    output_summary.write_text(
+        json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    print(json.dumps(summary, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

releases/2026-10-02/benchmark_exclusion/writing/review/multimodal/tests/test_build_review_a5_non_iar_later_role_successor_20260720.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import csv
+import gzip
+import hashlib
+import json
+import os
+import unittest
+from collections import Counter
+from pathlib import Path
+
+
+WRITING_ROOT = Path(__file__).resolve().parents[3]
+OUTPUT = Path(
+    os.environ.get(
+        "REVIEW_A5_NON_IAR_SUCCESSOR_OUTPUT",
+        str(
+            WRITING_ROOT
+            / "review/multimodal/outputs/"
+            "review_a5_non_iar_later_role_successor_20260720_r1"
+        ),
+    )
+)
+PREDECESSOR = (
+    WRITING_ROOT
+    / "review/multimodal/outputs/"
+    "p1_non_iar_pretraining_partition_80_20_20260712/"
+    "review_p1_non_iar_pretraining_parent_partition.tsv.gz"
+)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def read_tsv(path: Path) -> list[dict[str, str]]:
+    with gzip.open(path, "rt", newline="", encoding="utf-8") as handle:
+        return list(csv.DictReader(handle, delimiter="\t"))
+
+
+class LaterRoleSuccessorTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.summary = json.loads(
+            (OUTPUT / "review_a5_non_iar_successor_summary.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        cls.receipt = json.loads(
+            (OUTPUT / "review_a5_non_iar_successor_receipt.json").read_text(
+                encoding="utf-8"
+            )
+        )
+
+    def test_01_fail_closed(self) -> None:
+        self.assertFalse(self.summary["training_authorized"])
+        self.assertFalse(self.summary["scientific_launch_authorized"])
+        self.assertEqual(self.receipt["status"], "PASS_AUDIT_ONLY_FAIL_CLOSED")
+        self.assertFalse(self.receipt["training_authorized"])
+
+    def test_02_receipt_reopens_every_payload(self) -> None:
+        for item in [self.receipt["summary"], *self.receipt["payloads"].values()]:
+            path = OUTPUT / item["name"]
+            self.assertEqual(path.stat().st_size, item["bytes"])
+            self.assertEqual(sha256(path), item["sha256"])
+
+    def test_03_all_outputs_are_review_prefixed_and_deterministic_gzip(self) -> None:
+        for path in OUTPUT.iterdir():
+            self.assertTrue(path.name.startswith("review_"))
+            if path.suffix == ".gz":
+                header = path.read_bytes()[:10]
+                self.assertEqual(header[:2], b"\x1f\x8b")
+                self.assertEqual(header[4:8], b"\x00\x00\x00\x00")
+
+    def test_04_anchor_union(self) -> None:
+        rows = read_tsv(OUTPUT / "review_a5_non_iar_successor_anchor_manifest.tsv.gz")
+        self.assertEqual(len(rows), 4625)
+        self.assertEqual(len({row["canonical_wurcs"] for row in rows}), 4625)
+        coverage = self.summary["current_nonfit_coverage"]
+        self.assertEqual(coverage["strict3_primary_missing_from_predecessor_4532"], 0)
+        self.assertEqual(coverage["k20_missing_from_predecessor_4532"], 0)
+        self.assertEqual(coverage["strict_affinose_missing_from_predecessor"], 93)
+        self.assertTrue(
+            self.summary["validation_checks"][
+                "all_current_strict_affinose_nonfit_wurcs_in_successor"
+            ]
+        )
+
+    def test_05_parent_exact_and_known_graph_counts(self) -> None:
+        rows = read_tsv(
+            OUTPUT
+            / "review_a5_non_iar_successor_exact_known_graph_parent_manifest.tsv.gz"
+        )
+        self.assertEqual(len(rows), 281208)
+        self.assertEqual(len({row["parent_glycorpus_id"] for row in rows}), 281208)
+        exact = sum(row["exact_wurcs_anchor"] == "True" for row in rows)
+        graph = sum(int(row["graph_identity_anchor_count"]) > 0 for row in rows)
+        graph_only = sum(
+            row["exact_wurcs_anchor"] == "False"
+            and int(row["graph_identity_anchor_count"]) > 0
+            for row in rows
+        )
+        excluded = sum(row["a5_excluded"] == "True" for row in rows)
+        self.assertEqual((exact, graph, graph_only, excluded), (3673, 3587, 160, 3833))
+
+    def test_06_only_newly_matched_parents_change_role(self) -> None:
+        old = {row["parent_glycorpus_id"]: row for row in read_tsv(PREDECESSOR)}
+        new = {
+            row["parent_glycorpus_id"]: row
+            for row in read_tsv(
+                OUTPUT / "review_a5_non_iar_successor_parent_partition.tsv.gz"
+            )
+        }
+        self.assertEqual(set(old), set(new))
+        transitions = Counter(
+            (old[parent]["pretraining_partition"], new[parent]["pretraining_partition"])
+            for parent in old
+        )
+        self.assertEqual(
+            transitions[(
+                "pretraining_train",
+                "excluded_exact_or_verified_graph_identity",
+            )],
+            59,
+        )
+        self.assertEqual(
+            transitions[(
+                "pretraining_development",
+                "excluded_exact_or_verified_graph_identity",
+            )],
+            14,
+        )
+        self.assertEqual(
+            sum(count for (before, after), count in transitions.items() if before != after),
+            73,
+        )
+
+    def test_07_successor_role_counts_and_group_guards(self) -> None:
+        expected = {
+            "excluded_exact_or_verified_graph_identity": 3833,
+            "pretraining_development": 55476,
+            "pretraining_train": 221899,
+        }
+        self.assertEqual(self.summary["preserved_80_20_partition"]["parent_role_counts"], expected)
+        self.assertEqual(
+            self.summary["preserved_80_20_partition"]["retained_group_crossings"],
+            {
+                "precluster_union_block_id": 0,
+                "raw_feature_sha256": 0,
+                "registry_family_id": 0,
+            },
+        )
+
+    def test_08_gap_ledger(self) -> None:
+        rows = read_tsv(OUTPUT / "review_a5_non_iar_successor_later_role_gap.tsv.gz")
+        self.assertEqual(len(rows), 93)
+        self.assertEqual(Counter(row["strict_component_role"] for row in rows), {"validation": 62, "test": 31})
+        self.assertEqual(
+            Counter(row["sequence_v3_pretraining_partition"] for row in rows),
+            {"pretraining_train": 59, "pretraining_development": 14, "absent": 20},
+        )
+        self.assertEqual(
+            Counter(row["fingerprint_tier"] for row in rows),
+            {
+                "fixed_tree_exact_linkage": 81,
+                "composition_only": 6,
+                "fixed_tree_unknown_linkage": 3,
+                "partial_or_ambiguous_graph": 3,
+            },
+        )
+        self.assertTrue(all(row["known_graph_only_alias_parent_count"] == "0" for row in rows))
+
+    def test_09_changed_parent_ledger(self) -> None:
+        rows = read_tsv(OUTPUT / "review_a5_non_iar_successor_changed_parent_roles.tsv.gz")
+        self.assertEqual(len(rows), 73)
+        self.assertTrue(
+            all(
+                row["successor_pretraining_partition"]
+                == "excluded_exact_or_verified_graph_identity"
+                for row in rows
+            )
+        )
+
+    def test_10_objective_counts(self) -> None:
+        rows = read_tsv(OUTPUT / "review_a5_non_iar_successor_objective_partition.tsv.gz")
+        self.assertEqual(len(rows), 281208 * 5)
+        observed: Counter[tuple[str, str]] = Counter()
+        for row in rows:
+            if row["eligible_before_partition"] == "True" and row[
+                "pretraining_partition"
+            ] in {"pretraining_train", "pretraining_development"}:
+                observed[(row["pretraining_partition"], row["objective"])] += 1
+        for role, values in self.summary["base_objective_successor_counts"].items():
+            for objective, count in values.items():
+                self.assertEqual(observed[(role, objective)], count)
+
+
+if __name__ == "__main__":
+    unittest.main()

releases/2026-10-02/bertose.py

@@ -0,0 +1,132 @@
+"""Portable loading of the unchanged BERTose sequence encoder and tokenizer.
+
+This is a release adapter, not a new model implementation. The encoder class,
+embedding/layer implementations and tokenizer are imported from preserved source.
+"""
+from pathlib import Path
+import hashlib
+import importlib.util
+import json
+import sys
+
+import torch
+
+ROOT = Path(__file__).resolve().parent
+RUNTIME = ROOT / "bertose_source/writing/review/multimodal/runtime"
+TOKENIZER_DIR = ROOT / "bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1"
+
+
+def sha256_file(path):
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _module(name, path):
+    if name in sys.modules:
+        return sys.modules[name]
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def load_tokenizer():
+    """Load the 2,114-token vocabulary and its frozen tree-channel tokenizer."""
+    vocabulary = TOKENIZER_DIR / "review_bpe_vocabulary.json"
+    manifest = json.loads((ROOT / "provenance/sequence_variants.json").read_text())
+    if sha256_file(vocabulary) != manifest["vocabulary_sha256"]:
+        raise ValueError("Vocabulary differs from the released model vocabulary")
+    shim = _module("_bertose_tokenizer_shim", ROOT / "affinose/a5_tokenizer_shim.py")
+    module = shim.install()["sequence_tree_runtime"]
+    return module.ReviewA5WURCSBPETokenizerV3(vocabulary)
+
+
+def tokenize(wurcs, tokenizer=None):
+    """Encode WURCS 2.0 with the training envelope; reject overlength inputs.
+
+    Unknown characters remain [UNK], as in the frozen tokenizer. The returned
+    diagnostics expose their number and whether exact tree channels are available.
+    """
+    if not isinstance(wurcs, str) or not wurcs.startswith("WURCS=2.0/"):
+        raise ValueError("Provide a WURCS 2.0 string, not an IUPAC name or sequence")
+    tokenizer = tokenizer or load_tokenizer()
+    units = tokenizer.pre_tokenizer.pre_tokenize(wurcs)
+    length = sum(1 if unit["type"] == "special" else len(tokenizer.apply_bpe(unit["text"])) for unit in units)
+    if length > 256:
+        raise ValueError(f"Input has {length} tokens; the trained position limit is 256. No truncation was applied.")
+    result = tokenizer.tokenize_sequence(wurcs, max_length=256)
+    result["unknown_token_count"] = sum(i == tokenizer.token_to_id["[UNK]"] for i in result["token_ids"])
+    return result
+
+
+def load_encoder(checkpoint, variant="3", device="cpu"):
+    """Strictly load a pinned sequence export using the original 209 state keys.
+
+    Returns (encoder, metadata). These exports have no task head or MLM head.
+    """
+    manifest = json.loads((ROOT / "provenance/sequence_variants.json").read_text())
+    variant = str(variant)
+    if variant in {"1", "2", "3", "4", "5"}:
+        variant = "WA" + variant
+    record = next((x for x in manifest["variants"] if x["variant"] == variant), None)
+    if record is None:
+        raise ValueError("variant must be 1, 2, 3, 4 or 5 (legacy WA1-WA5 aliases are also accepted)")
+    checkpoint = Path(checkpoint)
+    if checkpoint.stat().st_size != record["bytes"] or sha256_file(checkpoint) != record["sha256"]:
+        raise ValueError("Checkpoint bytes do not match the selected variant")
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=True)
+    if (payload.get("schema") != "bertose_review_a5_native_md_on_sequence_export_20260808_r1"
+            or payload.get("cell") != "A1111" or payload.get("upstream_seed") != 42
+            or payload.get("selected_epoch") != record["selected_epoch"]):
+        raise ValueError("Unexpected sequence-export identity")
+    state = payload["model_state"]
+    checkpoint_module = _module("_bertose_exact_checkpoint", ROOT / "executed/downstream/review_a5_native_checkpoint.py")
+    checkpoint_module.validate_encoder_schema_fingerprint(state)
+    native = _module("_bertose_native_r4", RUNTIME / "a5_pretraining_failclosed_integration_20260721_r4/review_a5_native_eight_composite_r4.py")
+    config = native.NativeEightConfig(cell_id="A111", seq_vocab_size=2114)
+    # R5 inherits these exact R4 sequence modules. Allocate on meta so there is
+    # no random-initialization pass and no allocation of unused modality heads.
+    with torch.device("meta"):
+        embeddings = native.ExactSequenceEmbeddings(config)
+        layers = torch.nn.ModuleList([
+            native.EncoderLayer(config.seq_hidden_size, config.seq_num_heads,
+                               config.hidden_dropout_prob, config.attention_dropout_prob,
+                               config.layer_norm_eps)
+            for _ in range(config.seq_num_layers)
+        ])
+        encoder = checkpoint_module.ExactNativeSequenceEncoder(embeddings, layers)
+    encoder.load_state_dict(state, strict=True, assign=True)
+    encoder.to(device).eval().requires_grad_(False)
+    metadata = dict(record, state_entries=len(state), vocabulary_sha256=manifest["vocabulary_sha256"],
+                    output="sequence-token states before any task-specific pooling/head")
+    return encoder, metadata
+
+
+@torch.inference_mode()
+def embed(wurcs_strings, encoder, tokenizer=None, pooling="first"):
+    """Return [N,768] embeddings and tokenizer diagnostics.
+
+    `first` uses the START envelope token. `mean` averages all attended tokens,
+    including the START and END envelope. Neither is a fitted benchmark head.
+    """
+    if not wurcs_strings or pooling not in {"first", "mean"}:
+        raise ValueError("Supply at least one WURCS string and pooling first or mean")
+    tokenizer = tokenizer or load_tokenizer()
+    records = [tokenize(text, tokenizer) for text in wurcs_strings]
+    device = next(encoder.parameters()).device
+    tensors = {key: torch.tensor([r[key] for r in records], dtype=torch.long, device=device)
+               for key in ("token_ids", "attention_mask", "branch_depths", "linkage_types")}
+    hidden = encoder(**tensors)
+    if pooling == "first":
+        vectors = hidden[:, 0]
+    else:
+        mask = tensors["attention_mask"].unsqueeze(-1)
+        vectors = (hidden * mask).sum(1) / mask.sum(1)
+    if not torch.isfinite(vectors).all():
+        raise ValueError("Encoder returned nonfinite embeddings")
+    return vectors.cpu().numpy(), [{k: r[k] for k in (
+        "tree_channels_valid", "tree_channel_failure_reason", "unknown_token_count")} for r in records]

releases/2026-10-02/bertose_source/bert_training_v4/downstream_tasks/utils/wurcs_bpe_tokenizer.py

@@ -0,0 +1,740 @@
+#!/usr/bin/env python3
+"""
+WURCS-BPE Tokenizer
+
+A hybrid tokenizer that learns semantic subwords from WURCS while preserving
+the ability to handle rare/novel glycan structures character-by-character.
+
+Key features:
+1. Pre-tokenization: Split WURCS into semantic units (residues, linkages, mods)
+2. BPE: Learn subword merges from corpus
+3. Character fallback: Handle novel structures
+4. Tree embeddings: Preserve branch_depth and linkage_type per token
+
+Usage:
+    # Train BPE on corpus
+    tokenizer = WURCSBPETokenizer.train_from_corpus(
+        wurcs_strings, 
+        num_merges=500,
+        output_path="bpe_vocabulary.json"
+    )
+    
+    # Tokenize
+    result = tokenizer.tokenize(wurcs_string)
+"""
+
+import json
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Set
+import pickle
+
+
+class WURCSPreTokenizer:
+    """
+    Pre-tokenize WURCS into semantic units before BPE.
+    
+    WURCS format: WURCS=2.0/count/[residues]/indices/linkages
+    
+    We split into:
+    - Residues: [a2122h-1b_1-5_2*NCC/3=O] -> one unit per []
+    - Linkages: a4-b1 -> one unit per linkage
+    - Special markers: [BRANCH_OPEN], [BRANCH_CLOSE], etc.
+    """
+    
+    # Residue patterns for common monosaccharides
+    RESIDUE_PATTERN = re.compile(r'\[([^\]]+)\]')
+    LINKAGE_PATTERN = re.compile(r'([a-z])(\d+|\?)-([a-z])(\d+|\?)')
+    
+    def __init__(self):
+        self.special_tokens = {
+            '[PAD]': 0,
+            '[UNK]': 1,
+            '[START]': 2,
+            '[END]': 3,
+            '[MASK]': 4,
+            '[BRANCH_OPEN]': 5,
+            '[BRANCH_CLOSE]': 6,
+            '[LINK]': 7,
+            '[MOD]': 8,
+            '[RESIDUE_ERROR]': 9,
+        }
+    
+    def pre_tokenize(self, wurcs: str) -> List[Dict]:
+        """
+        Pre-tokenize WURCS into semantic units.
+        
+        Returns list of dicts with:
+            - text: The unit text
+            - type: 'special', 'residue', 'linkage', 'mod', 'index'
+            - residue_id: Which residue this belongs to (-1 for special, -2 for linkage)
+            - branch_depth: Tree depth (computed later)
+        """
+        units = []
+        
+        # Add start token
+        units.append({
+            'text': '[START]',
+            'type': 'special',
+            'residue_id': -1,
+            'branch_depth': 0,
+            'linkage_type': 0,
+        })
+        
+        # Parse WURCS sections
+        if not wurcs.startswith('WURCS='):
+            units.append({'text': '[RESIDUE_ERROR]', 'type': 'special', 'residue_id': -1, 'branch_depth': 0, 'linkage_type': 0})
+            units.append({'text': '[END]', 'type': 'special', 'residue_id': -1, 'branch_depth': 0, 'linkage_type': 0})
+            return units
+        
+        try:
+            parts = self._split_wurcs_sections(wurcs)
+            if len(parts) < 4:
+                return [{'text': '[ERROR]', 'type': 'special', 'residue_id': -1, 'branch_depth': 0, 'linkage_type': 0}]
+            
+            # parts: WURCS=2.0/3,3,2/[a2122h-1b_1-5][a2122h-1a_1-5][a1122h-1b_1-5]/1-2-3-1/a4-b1_b3-c1_c4-d1
+            # section 2: residue definitions
+            # section 3: indices
+            # section 4: linkages (optional)
+            
+            version = parts[0]  # WURCS=2.0
+            counts = parts[1]   # residue_count,node_count,link_count
+            residue_defs = parts[2]  # [res1][res2]...
+            indices = parts[3]  # 1-2-3-1
+            linkages = parts[4] if len(parts) > 4 else ""  # a4-b1_b3-c1
+            
+            # Parse residue definitions
+            residue_list = self.RESIDUE_PATTERN.findall(residue_defs)
+            
+            # Parse linkages to compute branch structure
+            linkage_list = linkages.split('_') if linkages else []
+            branch_points, residue_depths, linkage_types_map, adj = self._analyze_tree_structure(linkage_list, num_residues=len(residue_list))
+            
+            # Compute distance matrix and cache it based on the linkage string (structure)
+            # This is the most expensive part, so we cache it
+            if not hasattr(self, '_dist_cache'): self._dist_cache = {}
+            if linkages not in self._dist_cache:
+                self._dist_cache[linkages] = self._compute_distance_matrix(adj, len(residue_list))
+            dist_matrix_raw = self._dist_cache[linkages]
+            
+            # Parse indices to map positions to residue definitions
+            index_list = indices.split('-') if indices else []
+            
+            # Process each residue instance
+            residue_letter = ord('a')
+            for idx, res_idx in enumerate(index_list):
+                current_residue_id = idx
+                res_letter = chr(residue_letter + idx)
+                
+                # Check if this is a branch point - add branch marker before
+                if res_letter in branch_points and branch_points[res_letter] > 0:
+                    for _ in range(branch_points[res_letter]):
+                        units.append({
+                            'text': '[BRANCH_OPEN]',
+                            'type': 'special',
+                            'residue_id': -1,
+                            'branch_depth': residue_depths.get(res_letter, 0),
+                            'linkage_type': 0,
+                        })
+                
+                # Get residue definition
+                try:
+                    res_def_idx = int(res_idx) - 1  # 1-indexed to 0-indexed
+                    res_def = residue_list[res_def_idx] if res_def_idx < len(residue_list) else ""
+                except (ValueError, IndexError):
+                    res_def = ""
+                
+                # Split residue into base and modifications
+                res_parts = res_def.split('_')
+                base = res_parts[0] if res_parts else res_def
+                mods = res_parts[1:] if len(res_parts) > 1 else []
+                
+                # Add residue base as a single unit
+                depth = residue_depths.get(res_letter, 0)
+                units.append({
+                    'text': base,
+                    'type': 'residue',
+                    'residue_id': current_residue_id,
+                    'branch_depth': depth,
+                    'linkage_type': 0,
+                })
+                
+                # Add modifications
+                for mod in mods:
+                    units.append({
+                        'text': mod,
+                        'type': 'mod',
+                        'residue_id': current_residue_id,
+                        'branch_depth': depth,
+                        'linkage_type': 0,
+                    })
+            
+            # Store distance matrix in units for easy access in tokenizer
+            if units:
+                # Find first residue unit or just use START
+                units[0]['distance_matrix'] = dist_matrix_raw
+            
+            # Add linkages
+            for link in linkage_list:
+                if not link:
+                    continue
+                # Parse linkage type
+                lt = self._parse_linkage_type(link)
+                units.append({
+                    'text': link,
+                    'type': 'linkage',
+                    'residue_id': -2,
+                    'branch_depth': 0,
+                    'linkage_type': lt,
+                })
+        except Exception:
+            # Fallback for truly broken WURCS
+            pass
+        
+        # Add end token
+        units.append({
+            'text': '[END]',
+            'type': 'special',
+            'residue_id': -1,
+            'branch_depth': 0,
+            'linkage_type': 0,
+        })
+        
+        return units
+    
+    def _split_wurcs_sections(self, wurcs: str) -> List[str]:
+        """Split WURCS string into sections, handling nested brackets."""
+        # Remove WURCS= prefix
+        if wurcs.startswith('WURCS='):
+            wurcs = wurcs[6:]
+        
+        sections = []
+        current = ""
+        bracket_depth = 0
+        
+        for char in wurcs:
+            if char == '[':
+                bracket_depth += 1
+                current += char
+            elif char == ']':
+                bracket_depth -= 1
+                current += char
+            elif char == '/' and bracket_depth == 0:
+                sections.append(current)
+                current = ""
+            else:
+                current += char
+        
+        if current:
+            sections.append(current)
+        
+        return sections
+    
+    def _analyze_tree_structure(self, linkages: List[str], num_residues: int) -> Tuple[Dict, Dict, Dict, Dict]:
+        """Analyze linkages to compute branch points and residue depths."""
+        branch_points = defaultdict(int)  # residue -> number of children
+        children = defaultdict(list)
+        all_residues = set()
+        linkage_types = {}
+        
+        for link in linkages:
+            match = self.LINKAGE_PATTERN.match(link)
+            if match:
+                from_res, from_pos, to_res, to_pos = match.groups()
+                children[from_res].append(to_res)
+                all_residues.add(from_res)
+                all_residues.add(to_res)
+                
+                # Store linkage type
+                linkage_types[link] = self._parse_linkage_type(link)
+        
+        # Build adjacency list for BFS
+        adj = defaultdict(list)
+        for link in linkages:
+            match = self.LINKAGE_PATTERN.match(link)
+            if match:
+                u = ord(match.group(1)) - ord('a')
+                v = ord(match.group(3)) - ord('a')
+                if 0 <= u < num_residues and 0 <= v < num_residues:
+                    adj[u].append(v)
+                    adj[v].append(u)
+        
+        # Find branch points (residues with >1 child)
+        for res, kids in children.items():
+            if len(kids) > 1:
+                branch_points[res] = len(kids) - 1  # Number of extra branches
+        
+        # Compute depths using BFS
+        # Find root (residue with no parent)
+        child_set = set()
+        for kids in children.values():
+            child_set.update(kids)
+        roots = all_residues - child_set
+        root = min(roots) if roots else 'a'
+        
+        depths = {root: 0}
+        queue = [root]
+        while queue:
+            current = queue.pop(0)
+            for child in children.get(current, []):
+                if child not in depths:
+                    depths[child] = depths[current] + 1
+                    queue.append(child)
+        
+        return branch_points, depths, linkage_types, adj
+    
+    def _compute_distance_matrix(self, adj: Dict[int, List[int]], num_residues: int) -> List[List[int]]:
+        """
+        Compute shortest path distance (number of bonds) between all residue pairs using BFS.
+        """
+        if num_residues == 0:
+            return []
+            
+        dist_matrix = [[-1] * num_residues for _ in range(num_residues)]
+        
+        for i in range(num_residues):
+            dist_matrix[i][i] = 0
+            queue = [(i, 0)]
+            visited = {i}
+            
+            while queue:
+                curr, d = queue.pop(0)
+                dist_matrix[i][curr] = d
+                
+                for neighbor in adj[curr]:
+                    if neighbor not in visited:
+                        visited.add(neighbor)
+                        queue.append((neighbor, d + 1))
+                        
+        return dist_matrix
+             
+    def _compute_distance_matrix_OLD(self, linkages: List[str], num_residues: int) -> List[List[int]]:
+        """
+        Compute shortest path distance (number of bonds) between all residue pairs.
+        Returns a symmetric N x N matrix where N is num_residues.
+        Values are integers (number of steps). 0 on diagonal. -1 if unreachable (shouldn't happen in single tree).
+        """
+        if num_residues == 0:
+            return []
+            
+        # Initialize adjacency list
+        adj = defaultdict(list)
+        for link in linkages:
+            match = self.LINKAGE_PATTERN.match(link)
+            if match:
+                # WURCS indices are 1-based letters (a=1, b=2...)
+                from_res_char, _, to_res_char, _ = match.groups()
+                # Convert char to 0-based index
+                u = ord(from_res_char) - ord('a')
+                v = ord(to_res_char) - ord('a')
+                
+                # Undirected graph for structural distance
+                if 0 <= u < num_residues and 0 <= v < num_residues:
+                    adj[u].append(v)
+                    adj[v].append(u)
+                    
+        # Compute All-Pairs Shortest Path (BFS from each node is fine for small N)
+        # Glycans are small (N ~ 5-20 usually), so O(N^2) BFS is cheap.
+        dist_matrix = [[-1] * num_residues for _ in range(num_residues)]
+        
+        for i in range(num_residues):
+            dist_matrix[i][i] = 0
+            queue = [(i, 0)]
+            visited = {i}
+            
+            while queue:
+                curr, d = queue.pop(0)
+                dist_matrix[i][curr] = d
+                
+                for neighbor in adj[curr]:
+                    if neighbor not in visited:
+                        visited.add(neighbor)
+                        queue.append((neighbor, d + 1))
+                        
+        return dist_matrix
+    
+    def _parse_linkage_type(self, link: str) -> int:
+        """Parse linkage string to get type ID."""
+        LINKAGE_TYPES = {
+            (1, 2): 0, (2, 1): 0,
+            (1, 3): 1, (3, 1): 1,
+            (1, 4): 2, (4, 1): 2,
+            (1, 6): 3, (6, 1): 3,
+            (2, 3): 4, (3, 2): 4,
+            (2, 6): 5, (6, 2): 5,
+            (3, 6): 6, (6, 3): 6,
+        }
+        
+        match = self.LINKAGE_PATTERN.match(link)
+        if match:
+            _, from_pos, _, to_pos = match.groups()
+            try:
+                pos_tuple = (int(from_pos), int(to_pos))
+                return LINKAGE_TYPES.get(pos_tuple, 7)
+            except ValueError:
+                return 8  # Unknown
+        return 8
+
+
+class WURCSBPETokenizer:
+    """
+    BPE tokenizer for WURCS with tree-aware embeddings.
+    """
+    
+    def __init__(self, vocab_path: Optional[str] = None):
+        self.pre_tokenizer = WURCSPreTokenizer()
+        
+        # Special tokens (fixed)
+        self.special_tokens = self.pre_tokenizer.special_tokens
+        
+        # BPE vocabulary
+        self.token_to_id: Dict[str, int] = {}
+        self.id_to_token: Dict[int, str] = {}
+        self.merges: List[Tuple[str, str]] = []
+        
+        if vocab_path:
+            self.load_vocab(vocab_path)
+        else:
+            # Initialize with special tokens only
+            self.token_to_id = dict(self.special_tokens)
+            self.id_to_token = {v: k for k, v in self.token_to_id.items()}
+    
+    @classmethod
+    def train_from_corpus(
+        cls, 
+        wurcs_strings: List[str], 
+        num_merges: int = 500,
+        output_path: Optional[str] = None,
+        min_frequency: int = 2,
+        max_token_length: Optional[int] = None,
+    ) -> 'WURCSBPETokenizer':
+        """
+        Train BPE on a corpus of WURCS strings.
+        
+        Args:
+            wurcs_strings: List of WURCS strings
+            num_merges: Number of BPE merge operations
+            output_path: Optional path to save vocabulary
+            min_frequency: Minimum frequency for a token to be kept
+            max_token_length: Maximum length of a merged token (None = no limit)
+        
+        Returns:
+            Trained tokenizer
+        """
+        tokenizer = cls()
+        pre_tok = WURCSPreTokenizer()
+        
+        print(f"Training BPE on {len(wurcs_strings)} WURCS strings...")
+        
+        # Step 1: Pre-tokenize all strings to get semantic units
+        all_units = []
+        for wurcs in wurcs_strings:
+            units = pre_tok.pre_tokenize(wurcs)
+            for unit in units:
+                if unit['type'] != 'special':
+                    all_units.append(unit['text'])
+        
+        # Step 2: Count unit frequencies
+        unit_counts = Counter(all_units)
+        print(f"Found {len(unit_counts)} unique units")
+        
+        # Step 3: Initialize vocabulary with characters from all units
+        char_vocab = set()
+        for unit in unit_counts:
+            for char in unit:
+                char_vocab.add(char)
+        
+        # Build initial vocab: special tokens + characters
+        vocab_id = len(tokenizer.special_tokens)
+        for char in sorted(char_vocab):
+            tokenizer.token_to_id[char] = vocab_id
+            tokenizer.id_to_token[vocab_id] = char
+            vocab_id += 1
+        
+        print(f"Initial vocab size: {vocab_id} (special + characters)")
+        
+        # Step 4: Convert units to character sequences
+        word_freqs = {}
+        for unit, count in unit_counts.items():
+            if count >= min_frequency:
+                # Split into characters with space separator
+                chars = tuple(unit)
+                word_freqs[chars] = count
+        
+        # Step 5: BPE merging
+        merges = []
+        
+        for merge_idx in range(num_merges):
+            # Count pairs
+            pair_counts = Counter()
+            for word, freq in word_freqs.items():
+                for i in range(len(word) - 1):
+                    pair = (word[i], word[i + 1])
+                    pair_counts[pair] += freq
+            
+            if not pair_counts:
+                break
+            
+            # Find most frequent pair
+            best_pair = pair_counts.most_common(1)[0][0]
+            best_count = pair_counts[best_pair]
+            
+            if best_count < min_frequency:
+                break
+            
+            # Merge pair
+            new_token = best_pair[0] + best_pair[1]
+            
+            # Check length constraint
+            if max_token_length and len(new_token) > max_token_length:
+                # remove this pair from consideration for this iteration and future?
+                # Actually, skipping it here is tricky because we need to ignore it in pair_counts next time
+                # Simpler: Just skip adding it to merges and modify word_freqs?
+                # No, if we don't merge, we just continue to the next best pair in THIS iteration.
+                # But pair_counts is already computed.
+                # We need to loop until we find a valid pair or run out
+                
+                # In this simple implementation, let's just skip this merge efficiently
+                # We need to find the NEXT most common pair.
+                
+                # Re-do finding best pair loop
+                found_valid_pair = False
+                for pair, count in pair_counts.most_common():
+                    token_candidate = pair[0] + pair[1]
+                    if max_token_length and len(token_candidate) > max_token_length:
+                        continue # Skip too long
+                    
+                    if count < min_frequency:
+                        break # Stop if frequency too low
+                        
+                    # Found valid pair
+                    best_pair = pair
+                    best_count = count
+                    new_token = token_candidate
+                    found_valid_pair = True
+                    break
+                
+                if not found_valid_pair:
+                    print(f"  Stopping early: No more pairs satisfy max_token_length={max_token_length}")
+                    break
+            
+            # Final check before merging (in case we didn't enter the if block but updated vars)
+            # Actually the logic above handles it. If we entered the block, we either found a new best_pair or broke.
+            
+            merges.append(best_pair)
+            
+            # Add to vocab
+            tokenizer.token_to_id[new_token] = vocab_id
+            tokenizer.id_to_token[vocab_id] = new_token
+            vocab_id += 1
+            
+            # Update word_freqs
+            new_word_freqs = {}
+            for word, freq in word_freqs.items():
+                new_word = []
+                i = 0
+                while i < len(word):
+                    if i < len(word) - 1 and word[i] == best_pair[0] and word[i + 1] == best_pair[1]:
+                        new_word.append(new_token)
+                        i += 2
+                    else:
+                        new_word.append(word[i])
+                        i += 1
+                new_word_freqs[tuple(new_word)] = freq
+            word_freqs = new_word_freqs
+            
+            if (merge_idx + 1) % 100 == 0:
+                print(f"  Merge {merge_idx + 1}/{num_merges}: '{best_pair[0]}' + '{best_pair[1]}' -> '{new_token}' (count={best_count})")
+        
+        tokenizer.merges = merges
+        print(f"Final vocab size: {len(tokenizer.token_to_id)}")
+        
+        # Save if requested
+        if output_path:
+            tokenizer.save_vocab(output_path)
+        
+        return tokenizer
+    
+    def apply_bpe(self, text: str) -> List[str]:
+        """Apply BPE merges to a text string."""
+        if text in self.token_to_id:
+            return [text]
+        
+        # Split into characters
+        tokens = list(text)
+        
+        # Apply merges
+        for pair in self.merges:
+            new_tokens = []
+            i = 0
+            while i < len(tokens):
+                if i < len(tokens) - 1 and tokens[i] == pair[0] and tokens[i + 1] == pair[1]:
+                    new_tokens.append(pair[0] + pair[1])
+                    i += 2
+                else:
+                    new_tokens.append(tokens[i])
+                    i += 1
+            tokens = new_tokens
+        
+        return tokens
+    
+    def tokenize(self, wurcs: str, max_length: int = 256) -> Dict:
+        """
+        Tokenize a WURCS string.
+        
+        Returns:
+            Dict with:
+                - tokens: List of token strings
+                - token_ids: List of token IDs
+                - residue_ids: List of residue IDs
+                - branch_depths: List of branch depths
+                - linkage_types: List of linkage types
+                - attention_mask: Attention mask
+        """
+        # Pre-tokenize
+        units = self.pre_tokenizer.pre_tokenize(wurcs)
+        
+        tokens = []
+        token_ids = []
+        residue_ids = []
+        branch_depths = []
+        linkage_types = []
+        
+        for unit in units:
+            if unit['type'] == 'special':
+                # Special tokens stay as-is
+                tok = unit['text']
+                tokens.append(tok)
+                token_ids.append(self.token_to_id.get(tok, self.token_to_id['[UNK]']))
+                residue_ids.append(unit['residue_id'])
+                branch_depths.append(unit['branch_depth'])
+                linkage_types.append(unit['linkage_type'])
+            else:
+                # Apply BPE to this unit
+                bpe_tokens = self.apply_bpe(unit['text'])
+                for tok in bpe_tokens:
+                    tokens.append(tok)
+                    token_ids.append(self.token_to_id.get(tok, self.token_to_id['[UNK]']))
+                    residue_ids.append(unit['residue_id'])
+                    branch_depths.append(unit['branch_depth'])
+                    linkage_types.append(unit['linkage_type'])
+        
+        # Truncate if needed
+        if len(tokens) > max_length:
+            tokens = tokens[:max_length - 1] + ['[END]']
+            token_ids = token_ids[:max_length - 1] + [self.token_to_id['[END]']]
+            residue_ids = residue_ids[:max_length - 1] + [-1]
+            branch_depths = branch_depths[:max_length - 1] + [0]
+            linkage_types = linkage_types[:max_length - 1] + [0]
+        
+        # Create attention mask and pad
+        length = len(tokens)
+        attention_mask = [1] * length
+        
+        while len(tokens) < max_length:
+            tokens.append('[PAD]')
+            token_ids.append(self.token_to_id['[PAD]'])
+            residue_ids.append(-1)
+            branch_depths.append(0)
+            linkage_types.append(0)
+            attention_mask.append(0)
+        # Pre-tokenize
+        units = self.pre_tokenizer.pre_tokenize(wurcs)
+        
+        # Extract distance matrix from pre-tokenizer result
+        dist_matrix_raw = units[0].get('distance_matrix', [])
+        num_residues = len(dist_matrix_raw)
+        
+        # Map token-to-token distances using residue_ids
+        # token_i is associated with residue_ids[i]. 
+        # residue_ids[i] is index into dist_matrix_raw.
+        # If residue_ids[i] == -1 (special), distance is undefined (use -1 or 999)
+        
+        # Use UNPADDED length for distance matrix to save massive memory
+        # distance_matrix will be e.g. 20x20, while tokens are padded to 256
+        token_len = length 
+        distance_matrix = [[-1] * token_len for _ in range(token_len)]
+        
+        for i in range(token_len):
+            for j in range(token_len):
+                r_i = residue_ids[i]
+                r_j = residue_ids[j]
+                
+                if r_i >= 0 and r_j >= 0 and r_i < num_residues and r_j < num_residues:
+                    distance_matrix[i][j] = dist_matrix_raw[r_i][r_j]
+                else:
+                    distance_matrix[i][j] = -1 # Special/Padding
+                    
+        # MEMORY OPTIMIZATION: Do NOT pad matrix here. 
+        # Pad on-the-fly in Dataset class instead.
+        # This saves massive memory (0.2GB vs 66GB).
+        
+        return {
+            'tokens': tokens,
+            'token_ids': token_ids,
+            'residue_ids': residue_ids,
+            'branch_depths': branch_depths,
+            'linkage_types': linkage_types,
+            'attention_mask': attention_mask,
+            'distance_matrix': distance_matrix, # New Output
+            'length': length,
+        }
+    
+    def save_vocab(self, path: str):
+        """Save vocabulary to JSON file."""
+        data = {
+            'special_tokens': self.special_tokens,
+            'token_to_id': self.token_to_id,
+            'merges': [list(m) for m in self.merges],
+            'metadata': {
+                'vocab_size': len(self.token_to_id),
+                'num_merges': len(self.merges),
+            }
+        }
+        with open(path, 'w') as f:
+            json.dump(data, f, indent=2)
+        print(f"Saved vocabulary to {path}")
+    
+    def load_vocab(self, path: str):
+        """Load vocabulary from JSON file."""
+        with open(path, 'r') as f:
+            data = json.load(f)
+        
+        self.special_tokens = data['special_tokens']
+        self.token_to_id = data['token_to_id']
+        self.id_to_token = {int(v): k for k, v in self.token_to_id.items()}
+        self.merges = [tuple(m) for m in data['merges']]
+        
+        print(f"Loaded vocabulary with {len(self.token_to_id)} tokens")
+    
+    @property
+    def vocab_size(self) -> int:
+        return len(self.token_to_id)
+
+
+# ============================================================================
+# Testing
+# ============================================================================
+
+if __name__ == '__main__':
+    # Test pre-tokenizer
+    print("="*80)
+    print("Testing WURCSPreTokenizer")
+    print("="*80)
+    
+    pre_tok = WURCSPreTokenizer()
+    
+    test_wurcs = [
+        "WURCS=2.0/2,2,1/[a2122h-1b_1-5][a2211m-1a_1-5]/1-2/a4-b1",
+        "WURCS=2.0/3,3,2/[a2122h-1b_1-5_2*NCC/3=O][a2112h-1a_1-5][a2211m-1a_1-5]/1-2-3/a4-b1_b3-c1",
+    ]
+    
+    for wurcs in test_wurcs:
+        print(f"\nWURCS: {wurcs[:60]}...")
+        units = pre_tok.pre_tokenize(wurcs)
+        print(f"Units ({len(units)}):")
+        for u in units[:10]:
+            print(f"  {u['type']:10} | res={u['residue_id']:2} | depth={u['branch_depth']} | {u['text']}")
+        if len(units) > 10:
+            print(f"  ... and {len(units) - 10} more")

releases/2026-10-02/bertose_source/bert_training_v4/model/glycan_bert.py

@@ -0,0 +1,303 @@
+"""
+Glycan BERT Model
+
+Transformer-based masked language model for glycan structures.
+Based on BERT/ESM2 architecture adapted for atomic glycan tokenization.
+"""
+
+import torch
+import torch.nn as nn
+import math
+
+
+class GlycanBERTConfig:
+    """Configuration for GlycanBERT."""
+    
+    def __init__(
+        self,
+        vocab_size: int = 102,
+        hidden_size: int = 384,
+        num_hidden_layers: int = 6,
+        num_attention_heads: int = 6,
+        intermediate_size: int = 1536,
+        hidden_dropout_prob: float = 0.1,
+        attention_probs_dropout_prob: float = 0.1,
+        max_position_embeddings: int = 512,
+        layer_norm_eps: float = 1e-12,
+        pad_token_id: int = 0,
+        mask_token_id: int = 4,
+        initializer_range: float = 0.02
+    ):
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.intermediate_size = intermediate_size
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.max_position_embeddings = max_position_embeddings
+        self.layer_norm_eps = layer_norm_eps
+        self.pad_token_id = pad_token_id
+        self.mask_token_id = mask_token_id
+        self.initializer_range = initializer_range
+
+
+class GlycanBERTEmbeddings(nn.Module):
+    """
+    Embeddings for glycan tokens including token and positional embeddings.
+    """
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.token_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+        
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        
+        # position_ids (1, max_seq_len) is contiguous in memory and exported when serialized
+        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
+    
+    def forward(self, input_ids: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input_ids: Tensor of shape (batch_size, seq_len)
+        
+        Returns:
+            Embeddings of shape (batch_size, seq_len, hidden_size)
+        """
+        batch_size, seq_len = input_ids.shape
+        
+        # Token embeddings
+        token_embeds = self.token_embeddings(input_ids)
+        
+        # Position embeddings
+        position_ids = self.position_ids[:, :seq_len]
+        position_embeds = self.position_embeddings(position_ids)
+        
+        # Combine
+        embeddings = token_embeds + position_embeds
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        
+        return embeddings
+
+
+class GlycanBERTAttention(nn.Module):
+    """Multi-head self-attention."""
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        assert config.hidden_size % config.num_attention_heads == 0
+        
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = config.hidden_size // config.num_attention_heads
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+        
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+        
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+    
+    def transpose_for_scores(self, x: torch.Tensor) -> torch.Tensor:
+        """Reshape for multi-head attention."""
+        new_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(*new_shape)
+        return x.permute(0, 2, 1, 3)  # (batch, heads, seq_len, head_size)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Args:
+            hidden_states: (batch_size, seq_len, hidden_size)
+            attention_mask: (batch_size, seq_len) - 1 for valid, 0 for padding
+        
+        Returns:
+            Attention output: (batch_size, seq_len, hidden_size)
+        """
+        batch_size, seq_len, _ = hidden_states.shape
+        
+        # Linear projections
+        query_layer = self.transpose_for_scores(self.query(hidden_states))
+        key_layer = self.transpose_for_scores(self.key(hidden_states))
+        value_layer = self.transpose_for_scores(self.value(hidden_states))
+        
+        # Attention scores
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        
+        # Apply attention mask
+        if attention_mask is not None:
+            # Convert mask to additive mask
+            attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)  # (batch, 1, 1, seq_len)
+            attention_mask = (1.0 - attention_mask) * -10000.0
+            attention_scores = attention_scores + attention_mask
+        
+        # Attention probabilities
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+        attention_probs = self.dropout(attention_probs)
+        
+        # Apply attention to values
+        context_layer = torch.matmul(attention_probs, value_layer)
+        
+        # Reshape back
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_shape)
+        
+        return context_layer
+
+
+class GlycanBERTLayer(nn.Module):
+    """Single transformer layer."""
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.attention = GlycanBERTAttention(config)
+        self.attention_output = nn.Linear(config.hidden_size, config.hidden_size)
+        self.attention_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        
+        self.intermediate = nn.Linear(config.hidden_size, config.intermediate_size)
+        self.output = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.output_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Args:
+            hidden_states: (batch_size, seq_len, hidden_size)
+            attention_mask: (batch_size, seq_len)
+        
+        Returns:
+            Output: (batch_size, seq_len, hidden_size)
+        """
+        # Self-attention
+        attention_output = self.attention(hidden_states, attention_mask)
+        attention_output = self.attention_output(attention_output)
+        attention_output = self.dropout(attention_output)
+        
+        # Add & Norm
+        hidden_states = self.attention_layer_norm(hidden_states + attention_output)
+        
+        # Feed-forward
+        intermediate_output = self.intermediate(hidden_states)
+        intermediate_output = nn.functional.gelu(intermediate_output)
+        
+        layer_output = self.output(intermediate_output)
+        layer_output = self.dropout(layer_output)
+        
+        # Add & Norm
+        layer_output = self.output_layer_norm(hidden_states + layer_output)
+        
+        return layer_output
+
+
+class GlycanBERT(nn.Module):
+    """
+    Glycan BERT model for masked language modeling.
+    """
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.config = config
+        
+        # Embeddings
+        self.embeddings = GlycanBERTEmbeddings(config)
+        
+        # Transformer layers
+        self.layers = nn.ModuleList([GlycanBERTLayer(config) for _ in range(config.num_hidden_layers)])
+        
+        # MLM head
+        self.mlm_head = nn.Linear(config.hidden_size, config.vocab_size)
+        
+        # Initialize weights
+        self.apply(self._init_weights)
+    
+    def _init_weights(self, module):
+        """Initialize weights."""
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+    
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor = None,
+        labels: torch.Tensor = None
+    ):
+        """
+        Args:
+            input_ids: (batch_size, seq_len)
+            attention_mask: (batch_size, seq_len) - 1 for valid, 0 for padding
+            labels: (batch_size, seq_len) - token IDs to predict, -100 for positions to ignore
+        
+        Returns:
+            If labels provided: (loss, logits)
+            Else: logits
+        """
+        # Create attention mask if not provided
+        if attention_mask is None:
+            attention_mask = (input_ids != self.config.pad_token_id).float()
+        
+        # Embeddings
+        hidden_states = self.embeddings(input_ids)
+        
+        # Transformer layers
+        for layer in self.layers:
+            hidden_states = layer(hidden_states, attention_mask)
+        
+        # MLM prediction
+        logits = self.mlm_head(hidden_states)
+        
+        # Calculate loss if labels provided
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()  # -100 is ignored
+            loss = loss_fct(logits.view(-1, self.config.vocab_size), labels.view(-1))
+        
+        if loss is not None:
+            return loss, logits
+        return logits
+    
+    def get_embeddings(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Get contextualized embeddings (for downstream tasks).
+        
+        Args:
+            input_ids: (batch_size, seq_len)
+            attention_mask: (batch_size, seq_len)
+        
+        Returns:
+            Embeddings: (batch_size, seq_len, hidden_size)
+        """
+        if attention_mask is None:
+            attention_mask = (input_ids != self.config.pad_token_id).float()
+        
+        hidden_states = self.embeddings(input_ids)
+        
+        for layer in self.layers:
+            hidden_states = layer(hidden_states, attention_mask)
+        
+        return hidden_states
+

releases/2026-10-02/bertose_source/bert_training_v4/model/multimodal_glycan_bert_v3.py

@@ -0,0 +1,1108 @@
+"""
+Multimodal Glycan BERT Model v3
+
+Extends GlycanBERT to handle three modalities:
+- Sequence (WURCS atomic tokenization)
+- MS (mass spectrometry peaks, RT, intensity)
+- 3D structure (VQ-VAE discrete tokens, 4 per residue)
+
+Each modality has its own encoder, with cross-attention for sequence-structure alignment.
+"""
+
+import torch
+import torch.nn as nn
+from typing import Dict, Optional, Tuple
+import math
+
+try:
+    from .glycan_bert import GlycanBERTConfig, GlycanBERTEmbeddings, GlycanBERTLayer
+except ImportError:
+    from glycan_bert import GlycanBERTConfig, GlycanBERTEmbeddings, GlycanBERTLayer
+
+
+class ConvGlycanBERTEmbeddings(nn.Module):
+    """
+    Improved Convolutional front-end that mixes local WURCS context before the Transformer.
+    
+    Key improvements over original:
+    1. Position embeddings added BEFORE convolution (provides spatial context to conv)
+    2. Residual connection (conv enriches embeddings rather than replacing them)
+    3. Multi-scale convolutions (kernel sizes 3, 5, 7) for better receptive field
+    4. Proper layer normalization on the residual path
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.token_embeddings = nn.Embedding(
+            config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id
+        )
+        self.position_embeddings = nn.Embedding(
+            config.max_position_embeddings, config.hidden_size
+        )
+        
+        # NEW: Branch depth embeddings - encodes depth in glycan tree (0=root, 1=child, etc.)
+        max_branch_depth = getattr(config, "max_branch_depth", 8)
+        self.branch_embeddings = nn.Embedding(max_branch_depth, config.hidden_size)
+        
+        # NEW: Linkage type embeddings - encodes chemistry of glycosidic bond
+        # 0=none, 1=1-3, 2=1-4, 3=1-6, etc.
+        num_linkage_types = getattr(config, "num_linkage_types", 9)
+        self.linkage_embeddings = nn.Embedding(num_linkage_types, config.hidden_size)
+        
+        # Multi-scale convolutions for different receptive fields
+        kernel_size = getattr(config, "cnn_kernel_size", 3)
+        # Split channels evenly: 256 + 256 + 256 = 768 for hidden_size=768
+        channels_per_scale = config.hidden_size // 3
+        self.conv_layers = nn.ModuleList([
+            nn.Conv1d(
+                in_channels=config.hidden_size,
+                out_channels=channels_per_scale,
+                kernel_size=kernel_size + 2 * i,  # Kernels: 3, 5, 7
+                padding=(kernel_size + 2 * i) // 2,  # Same padding
+            )
+            for i in range(3)
+        ])
+        self.conv_activation = nn.GELU()
+        self.conv_proj = nn.Linear(channels_per_scale * 3, config.hidden_size)  # Project concatenated back
+        
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.conv_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.register_buffer(
+            "position_ids",
+            torch.arange(config.max_position_embeddings).expand((1, -1)),
+        )
+
+        self.hidden_size = config.hidden_size
+
+    def forward(self, input_ids, branch_depths=None, linkage_types=None):
+        seq_len = input_ids.shape[1]
+        
+        # Step 1: Token + Position embeddings FIRST (provides spatial context to conv)
+        x = self.token_embeddings(input_ids)  # (batch, seq, hidden)
+        position_ids = self.position_ids[:, :seq_len]
+        x = x + self.position_embeddings(position_ids)
+        
+        # NEW: Add branch depth embeddings (encodes tree structure)
+        if branch_depths is not None:
+            # Clamp to valid range
+            branch_depths = branch_depths.clamp(0, self.branch_embeddings.num_embeddings - 1)
+            x = x + self.branch_embeddings(branch_depths)
+        
+        # NEW: Add linkage type embeddings (encodes bond chemistry)
+        if linkage_types is not None:
+            linkage_types = linkage_types.clamp(0, self.linkage_embeddings.num_embeddings - 1)
+            x = x + self.linkage_embeddings(linkage_types)
+        
+        x = self.LayerNorm(x)
+        
+        # Step 2: Multi-scale convolution with RESIDUAL connection
+        # Convolution expects (batch, hidden, seq)
+        conv_in = x.permute(0, 2, 1)
+        
+        # Apply multi-scale convolutions and concatenate
+        conv_outputs = []
+        for conv in self.conv_layers:
+            conv_out = self.conv_activation(conv(conv_in))
+            conv_outputs.append(conv_out)
+        
+        # Concatenate multi-scale features and project back
+        conv_out = torch.cat(conv_outputs, dim=1)  # (batch, hidden, seq)
+        conv_out = conv_out.permute(0, 2, 1)  # (batch, seq, hidden)
+        conv_out = self.conv_proj(conv_out)  # Project to correct size
+        
+        # Step 3: Residual connection - conv ENRICHES rather than replaces
+        x = self.conv_norm(x + self.dropout(conv_out))
+        
+        return x
+
+
+def create_residue_level_mask(
+    seq_residue_ids: torch.Tensor,    # (batch, N_seq)
+    struct_residue_ids: torch.Tensor  # (batch, N_struct)
+) -> torch.Tensor:
+    """
+    Create residue-level attention mask for cross-attention.
+    
+    Maps WURCS tokens to VQ-VAE structural tokens based on residue IDs.
+    A WURCS token with residue_id=0 can only attend to VQ-VAE tokens with residue_id=0.
+    
+    Args:
+        seq_residue_ids: Residue IDs for sequence tokens (batch, N_seq)
+        struct_residue_ids: Residue IDs for structural tokens (batch, N_struct)
+    
+    Returns:
+        Boolean mask (batch, N_seq, N_struct) where True = can attend
+    """
+    # Expand dimensions for broadcasting
+    # seq: (batch, N_seq, 1)
+    # struct: (batch, 1, N_struct)
+    mask = seq_residue_ids.unsqueeze(2) == struct_residue_ids.unsqueeze(1)
+    # Shape: (batch, N_seq, N_struct)
+    
+    # Mask out structural tokens (residue_id = -1) and MS tokens (residue_id = -2)
+    # Only tokens with residue_id >= 0 can attend
+    mask &= (seq_residue_ids.unsqueeze(2) >= 0)
+    
+    return mask  # True = can attend, False = cannot attend
+
+
+class MultimodalGlycanBERTConfig:
+    """Configuration for Multimodal GlycanBERT v3."""
+    
+    def __init__(
+        self,
+        # Sequence modality
+        seq_vocab_size: int = 166,
+        seq_hidden_size: int = 768,
+        seq_num_layers: int = 12,
+        seq_num_heads: int = 12,
+        seq_max_length: int = 512,
+        
+        # MS modality
+        ms_vocab_size: int = 242,
+        ms_hidden_size: int = 384,
+        ms_num_layers: int = 6,
+        ms_num_heads: int = 6,
+        ms_max_length: int = 150,
+        
+        # 3D structure modality
+        struct_vocab_size: int = 1024,  # VQ-VAE codebook size
+        struct_hidden_size: int = 512,
+        struct_num_layers: int = 8,
+        struct_num_heads: int = 8,
+        struct_max_length: int = 200,
+        use_3d: bool = True,
+        
+        # Cross-attention
+        use_cross_attention: bool = True,
+        cross_attn_num_heads: int = 8,
+        
+        # Fusion
+        fusion_hidden_size: int = 768,
+        fusion_num_layers: int = 2,
+        
+        # Training
+        hidden_dropout_prob: float = 0.1,
+        attention_probs_dropout_prob: float = 0.1,
+        layer_norm_eps: float = 1e-12,
+        initializer_range: float = 0.02,
+
+        # Conv front-end
+        use_cnn_frontend: bool = True,
+        cnn_kernel_size: int = 3,
+        
+        # Loss weights
+        seq_loss_weight: float = 0.60,
+        ms_loss_weight: float = 0.15,
+        struct_loss_weight: float = 0.25,
+        
+        # Token IDs
+        pad_token_id: int = 0,
+        mask_token_id: int = 1,
+    ):
+        # Sequence config
+        self.seq_vocab_size = seq_vocab_size
+        self.seq_hidden_size = seq_hidden_size
+        self.seq_num_layers = seq_num_layers
+        self.seq_num_heads = seq_num_heads
+        self.seq_max_length = seq_max_length
+        
+        # MS config
+        self.ms_vocab_size = ms_vocab_size
+        self.ms_vocab_offset = seq_vocab_size  # MS tokens start at 166
+        self.ms_total_vocab_size = seq_vocab_size + ms_vocab_size  # 408 total
+        self.ms_hidden_size = ms_hidden_size
+        self.ms_num_layers = ms_num_layers
+        self.ms_num_heads = ms_num_heads
+        self.ms_max_length = ms_max_length
+        
+        # Structure config
+        self.struct_vocab_size = struct_vocab_size
+        self.struct_hidden_size = struct_hidden_size
+        self.struct_num_layers = struct_num_layers
+        self.struct_num_heads = struct_num_heads
+        self.struct_max_length = struct_max_length
+        self.use_3d = use_3d
+        
+        # Cross-attention config
+        self.use_cross_attention = use_cross_attention
+        self.cross_attn_num_heads = cross_attn_num_heads
+        
+        # Fusion config
+        self.fusion_hidden_size = fusion_hidden_size
+        self.fusion_num_layers = fusion_num_layers
+        
+        # Training config
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.layer_norm_eps = layer_norm_eps
+        self.initializer_range = initializer_range
+
+        # Conv front-end
+        self.use_cnn_frontend = use_cnn_frontend
+        self.cnn_kernel_size = cnn_kernel_size
+        
+        # Loss weights
+        self.seq_loss_weight = seq_loss_weight
+        self.ms_loss_weight = ms_loss_weight
+        self.struct_loss_weight = struct_loss_weight
+        
+        # Token IDs
+        self.pad_token_id = pad_token_id
+        self.mask_token_id = mask_token_id
+    
+    def to_seq_config(self) -> GlycanBERTConfig:
+        """Convert to sequence-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.seq_vocab_size,
+            hidden_size=self.seq_hidden_size,
+            num_hidden_layers=self.seq_num_layers,
+            num_attention_heads=self.seq_num_heads,
+            intermediate_size=self.seq_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.seq_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+    
+    def to_ms_config(self) -> GlycanBERTConfig:
+        """Convert to MS-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.ms_total_vocab_size,
+            hidden_size=self.ms_hidden_size,
+            num_hidden_layers=self.ms_num_layers,
+            num_attention_heads=self.ms_num_heads,
+            intermediate_size=self.ms_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.ms_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+    
+    def to_struct_config(self) -> GlycanBERTConfig:
+        """Convert to structure-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.struct_vocab_size,
+            hidden_size=self.struct_hidden_size,
+            num_hidden_layers=self.struct_num_layers,
+            num_attention_heads=self.struct_num_heads,
+            intermediate_size=self.struct_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.struct_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+
+
+# =============================================================================
+# Improvement #1: Monosaccharide-Level Pooling
+# =============================================================================
+
+class MonosaccharidePooling(nn.Module):
+    """
+    Pool token representations to monosaccharide level, then aggregate.
+    
+    This bridges the gap between token-level BERT and monosaccharide-level CNNs/GNNs.
+    Uses monosaccharide_indices from the data to know where each residue starts.
+    """
+    
+    def __init__(self, hidden_size: int, num_attention_heads: int = 8, dropout: float = 0.1):
+        super().__init__()
+        self.hidden_size = hidden_size
+        
+        # Attention pooling over monosaccharide representations
+        self.mono_attention = nn.MultiheadAttention(
+            embed_dim=hidden_size,
+            num_heads=num_attention_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        self.mono_norm = nn.LayerNorm(hidden_size)
+        
+        # Final aggregation to single glycan representation
+        self.glycan_query = nn.Parameter(torch.randn(1, 1, hidden_size) * 0.02)
+        self.glycan_attention = nn.MultiheadAttention(
+            embed_dim=hidden_size,
+            num_heads=num_attention_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        self.glycan_norm = nn.LayerNorm(hidden_size)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,      # (batch, seq_len, hidden)
+        residue_ids: torch.Tensor,         # (batch, seq_len) - which residue each token belongs to
+        attention_mask: torch.Tensor = None,  # (batch, seq_len)
+    ) -> torch.Tensor:
+        """
+        Pool tokens to monosaccharide level, then to glycan level.
+        
+        Returns:
+            Glycan representation: (batch, hidden_size)
+        """
+        batch_size = hidden_states.size(0)
+        device = hidden_states.device
+        
+        # Get unique residue IDs per sample (excluding -1 padding)
+        max_residues = 50  # Reasonable max for glycans
+        
+        # Pool tokens within each residue using mean pooling
+        mono_reps = torch.zeros(batch_size, max_residues, self.hidden_size, device=device)
+        mono_mask = torch.zeros(batch_size, max_residues, dtype=torch.bool, device=device)
+        
+        for b in range(batch_size):
+            unique_residues = torch.unique(residue_ids[b][residue_ids[b] >= 0])
+            for i, rid in enumerate(unique_residues):
+                if i >= max_residues:
+                    break
+                token_mask = residue_ids[b] == rid
+                if attention_mask is not None:
+                    token_mask = token_mask & (attention_mask[b] > 0)
+                if token_mask.sum() > 0:
+                    mono_reps[b, i] = hidden_states[b][token_mask].mean(dim=0)
+                    mono_mask[b, i] = True
+        
+        # Apply attention over monosaccharide representations
+        # Convert mask for attention: True = valid, need to invert for PyTorch
+        key_padding_mask = ~mono_mask  # True = ignore
+        
+        mono_out, _ = self.mono_attention(
+            mono_reps, mono_reps, mono_reps,
+            key_padding_mask=key_padding_mask
+        )
+        mono_out = self.mono_norm(mono_reps + mono_out)
+        
+        # Aggregate to single glycan representation using learned query
+        glycan_query = self.glycan_query.expand(batch_size, -1, -1)
+        glycan_out, _ = self.glycan_attention(
+            glycan_query, mono_out, mono_out,
+            key_padding_mask=key_padding_mask
+        )
+        glycan_out = self.glycan_norm(glycan_query + glycan_out)
+        
+        return glycan_out.squeeze(1)  # (batch, hidden)
+
+
+# =============================================================================
+# Improvement #2: Residue Type Embeddings
+# =============================================================================
+
+# Common monosaccharide types vocabulary
+MONOSACCHARIDE_VOCAB = {
+    '[PAD_MONO]': 0, '[UNK_MONO]': 1,
+    'Glc': 2, 'GlcNAc': 3, 'GlcA': 4, 'GlcN': 5,
+    'Gal': 6, 'GalNAc': 7, 'GalA': 8, 'GalN': 9,
+    'Man': 10, 'ManNAc': 11, 'ManA': 12, 'ManN': 13,
+    'Fuc': 14, 'Rha': 15, 'Xyl': 16, 'Ara': 17,
+    'Neu5Ac': 18, 'Neu5Gc': 19, 'Kdn': 20, 'Sia': 21,
+    'GalNAcA': 22, 'GlcNAcA': 23, 'IdoA': 24, 'GulA': 25,
+    'Rib': 26, 'Lyx': 27, 'All': 28, 'Alt': 29,
+    'Tal': 30, 'Ido': 31, 'Qui': 32, 'Oli': 33,
+    'Tyv': 34, 'Abe': 35, 'Par': 36, 'Dig': 37,
+    'Col': 38, 'Dha': 39, 'Kdo': 40, 'Hep': 41,
+    'NeuroGc': 42, 'Muramic': 43, 'LDManHep': 44, 'DDManHep': 45,
+    'Bac': 46, 'Pse': 47, 'Leg': 48, 'Aci': 49,
+    '6dTal': 50, 'Fru': 51, 'Tag': 52, 'Sor': 53,
+    'Psi': 54, 'Sed': 55, 'MurNAc': 56, 'MurNGc': 57,
+    'Api': 58, 'Erwiniose': 59, 'Yer': 60, 'Thre': 61,
+    # Add more as needed, up to ~70
+}
+
+
+class ResidueTypeEmbeddings(nn.Module):
+    """
+    Learnable embeddings for monosaccharide types.
+    
+    Instead of the model having to learn that 'a1221m' = Fucose from character patterns,
+    we explicitly add a Fucose embedding to all tokens belonging to that residue.
+    """
+    
+    def __init__(self, hidden_size: int, num_mono_types: int = 70):
+        super().__init__()
+        self.mono_embeddings = nn.Embedding(num_mono_types, hidden_size)
+        self.mono_vocab = MONOSACCHARIDE_VOCAB
+        self.hidden_size = hidden_size
+    
+    def forward(
+        self, 
+        token_embeddings: torch.Tensor,  # (batch, seq_len, hidden)
+        residue_ids: torch.Tensor,        # (batch, seq_len)
+        mono_type_ids: torch.Tensor = None,  # (batch, max_residues) - monosaccharide type per residue
+    ) -> torch.Tensor:
+        """
+        Add residue type embeddings to token embeddings.
+        
+        Args:
+            token_embeddings: Base token embeddings
+            residue_ids: Which residue each token belongs to (-1 for special tokens)
+            mono_type_ids: Monosaccharide type ID for each residue position
+            
+        Returns:
+            Enhanced embeddings with residue type information
+        """
+        if mono_type_ids is None:
+            return token_embeddings
+        
+        batch_size, seq_len, _ = token_embeddings.shape
+        enhanced = token_embeddings.clone()
+        
+        # Add mono type embedding to each token based on its residue
+        for b in range(batch_size):
+            for pos in range(seq_len):
+                rid = residue_ids[b, pos].item()
+                if rid >= 0 and rid < mono_type_ids.size(1):
+                    mono_id = mono_type_ids[b, rid]
+                    enhanced[b, pos] = enhanced[b, pos] + self.mono_embeddings(mono_id)
+        
+        return enhanced
+    
+    @staticmethod
+    def get_mono_type_id(mono_name: str) -> int:
+        """Convert monosaccharide name to type ID."""
+        return MONOSACCHARIDE_VOCAB.get(mono_name, MONOSACCHARIDE_VOCAB['[UNK_MONO]'])
+
+
+# =============================================================================
+# Improvement #4: Relative Position Encoding for Glycan Trees
+# =============================================================================
+
+class RelativePositionBias(nn.Module):
+    """
+    Compute relative position bias for attention based on residue IDs.
+    
+    Tokens in the same residue get distance 0.
+    Tokens in adjacent residues get distance ±1.
+    This helps the model understand glycan tree structure.
+    """
+    
+    def __init__(self, num_heads: int, max_distance: int = 10):
+        super().__init__()
+        self.num_heads = num_heads
+        self.max_distance = max_distance
+        
+        # Learnable bias for each relative distance (-max to +max)
+        num_distances = 2 * max_distance + 1
+        self.relative_bias = nn.Embedding(num_distances, num_heads)
+    
+    def forward(self, residue_ids: torch.Tensor) -> torch.Tensor:
+        """
+        Compute relative position bias.
+        
+        Args:
+            residue_ids: (batch, seq_len)
+            
+        Returns:
+            Bias to add to attention scores: (batch, num_heads, seq_len, seq_len)
+        """
+        # Compute pairwise residue distances
+        # (batch, seq_len, 1) - (batch, 1, seq_len) = (batch, seq_len, seq_len)
+        distance = residue_ids.unsqueeze(2) - residue_ids.unsqueeze(1)
+        
+        # Clamp to max distance range and shift to 0-indexed
+        distance_clamped = distance.clamp(-self.max_distance, self.max_distance)
+        distance_idx = distance_clamped + self.max_distance  # Now 0 to 2*max_distance
+        
+        # Look up bias: (batch, seq_len, seq_len, num_heads)
+        bias = self.relative_bias(distance_idx)
+        
+        # Transpose to (batch, num_heads, seq_len, seq_len)
+        bias = bias.permute(0, 3, 1, 2)
+        
+        return bias
+
+
+class CrossAttentionLayer(nn.Module):
+    """
+    Cross-attention layer for sequence-structure alignment.
+    
+    Allows sequence tokens to attend to structural atoms using attention masks.
+    """
+    
+    def __init__(self, config: MultimodalGlycanBERTConfig):
+        super().__init__()
+        self.num_heads = config.cross_attn_num_heads
+        self.hidden_size = config.seq_hidden_size
+        self.head_dim = self.hidden_size // self.num_heads
+        
+        assert self.hidden_size % self.num_heads == 0, "hidden_size must be divisible by num_heads"
+        
+        # Query from sequence, Key/Value from structure (VQ-VAE tokens)
+        self.query = nn.Linear(config.seq_hidden_size, self.hidden_size)
+        self.key = nn.Linear(config.struct_hidden_size, self.hidden_size)
+        self.value = nn.Linear(config.struct_hidden_size, self.hidden_size)
+        
+        self.output = nn.Linear(self.hidden_size, config.seq_hidden_size)
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.layer_norm = nn.LayerNorm(config.seq_hidden_size, eps=config.layer_norm_eps)
+    
+    def forward(
+        self,
+        seq_hidden: torch.Tensor,  # (batch, seq_len, seq_hidden)
+        struct_hidden: torch.Tensor,  # (batch, struct_len, struct_hidden)
+        attention_mask: Optional[torch.Tensor] = None,  # (batch, seq_len, struct_len)
+    ) -> torch.Tensor:
+        """
+        Apply cross-attention from sequence to structure.
+        
+        Args:
+            seq_hidden: Sequence hidden states
+            struct_hidden: Structure hidden states
+            attention_mask: Boolean mask (True = can attend, False = cannot attend)
+        
+        Returns:
+            Updated sequence hidden states
+        """
+        batch_size, seq_len, _ = seq_hidden.shape
+        struct_len = struct_hidden.shape[1]
+        
+        # Project to Q, K, V
+        Q = self.query(seq_hidden)  # (batch, seq_len, hidden)
+        K = self.key(struct_hidden)  # (batch, struct_len, hidden)
+        V = self.value(struct_hidden)  # (batch, struct_len, hidden)
+        
+        # Reshape for multi-head attention
+        Q = Q.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, seq_len, head_dim)
+        K = K.view(batch_size, struct_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, struct_len, head_dim)
+        V = V.view(batch_size, struct_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, struct_len, head_dim)
+        
+        # Compute attention scores
+        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.head_dim)  # (batch, heads, seq_len, struct_len)
+        
+        # Apply attention mask
+        if attention_mask is not None:
+            # attention_mask: (batch, seq_len, struct_len) -> (batch, 1, seq_len, struct_len)
+            attention_mask = attention_mask.unsqueeze(1)
+            # Convert boolean mask to float: True -> 0.0, False -> -10000.0
+            attention_mask = (~attention_mask).float() * -10000.0
+            scores = scores + attention_mask
+        
+        # Softmax and dropout
+        attn_weights = torch.softmax(scores, dim=-1)  # (batch, heads, seq_len, struct_len)
+        attn_weights = self.dropout(attn_weights)
+        
+        # Apply attention to values
+        context = torch.matmul(attn_weights, V)  # (batch, heads, seq_len, head_dim)
+        
+        # Reshape back
+        context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.hidden_size)
+        
+        # Output projection
+        output = self.output(context)
+        output = self.dropout(output)
+        
+        # Residual connection + layer norm
+        output = self.layer_norm(seq_hidden + output)
+        
+        return output
+
+
+class DistanceHead(nn.Module):
+    """
+    Head for predicting structural distance (shortest path) between token pairs.
+    
+    Input: Pair of token embeddings (x_i, x_j)
+    Output: Scalar distance prediction
+    
+    Formula: Dist(i, j) = Linear( [x_i; x_j; x_i * x_j; |x_i - x_j|] )
+    Using a comprehensive bilinear-like interaction for robust distance learning.
+    """
+    def __init__(self, config):
+        super().__init__()
+        self.hidden_size = config.seq_hidden_size
+        # Interaction features: concat(u, v, u*v, |u-v|) -> 4 * hidden
+        self.dense = nn.Linear(self.hidden_size * 4, self.hidden_size)
+        self.activation = nn.GELU()
+        self.layer_norm = nn.LayerNorm(self.hidden_size, eps=config.layer_norm_eps)
+        self.decoder = nn.Linear(self.hidden_size, 1) # Output scalar distance
+
+    def forward(self, hidden_states):
+        """
+        Args:
+            hidden_states: (batch, seq_len, hidden)
+            
+        Returns:
+            distances: (batch, seq_len, seq_len)
+        """
+        batch_size, seq_len, hidden = hidden_states.shape
+        
+        # Expand to pairs (batch, seq, seq, hidden)
+        u = hidden_states.unsqueeze(2).expand(batch_size, seq_len, seq_len, hidden)
+        v = hidden_states.unsqueeze(1).expand(batch_size, seq_len, seq_len, hidden)
+        
+        # Features
+        features = torch.cat([
+            u, 
+            v, 
+            u * v, 
+            torch.abs(u - v)
+        ], dim=-1) # (batch, seq, seq, 4*hidden)
+        
+        x = self.dense(features)
+        x = self.activation(x)
+        x = self.layer_norm(x)
+        x = self.decoder(x) # (batch, seq, seq, 1)
+        
+        return x.squeeze(-1) # (batch, seq, seq)
+
+class MultimodalGlycanBERT(nn.Module):
+    """
+    Multimodal BERT for glycan representation learning (v3).
+    
+    Architecture:
+    1. Separate encoders for each modality (sequence, MS, 3D structure)
+    2. Cross-attention for sequence-structure alignment
+    3. Modality-specific MLM heads
+    4. Fusion layer for combined representation
+    """
+    
+    def __init__(self, config: MultimodalGlycanBERTConfig):
+        super().__init__()
+        self.config = config
+        
+        # ===== Sequence Encoder =====
+        seq_config = config.to_seq_config()
+        seq_config.cnn_kernel_size = config.cnn_kernel_size
+
+        if config.use_cnn_frontend:
+            print(f"✅ Enabled Convolutional Front-End (Kernel={config.cnn_kernel_size})")
+            self.seq_embeddings = ConvGlycanBERTEmbeddings(seq_config)
+        else:
+            self.seq_embeddings = GlycanBERTEmbeddings(seq_config)
+        self.seq_layers = nn.ModuleList([GlycanBERTLayer(seq_config) for _ in range(seq_config.num_hidden_layers)])
+        self.seq_mlm_head = nn.Linear(seq_config.hidden_size, seq_config.vocab_size)
+        self.distance_head = DistanceHead(config) # New Distance Prediction Head
+
+        
+        # ===== MS Encoder =====
+        ms_config = config.to_ms_config()
+        self.ms_embeddings = GlycanBERTEmbeddings(ms_config)
+        self.ms_layers = nn.ModuleList([GlycanBERTLayer(ms_config) for _ in range(ms_config.num_hidden_layers)])
+        self.ms_mlm_head = nn.Linear(ms_config.hidden_size, ms_config.vocab_size)
+        
+        # ===== Structure Encoder (VQ-VAE tokens) =====
+        if config.use_3d:
+            struct_config = config.to_struct_config()
+            self.struct_embeddings = GlycanBERTEmbeddings(struct_config)
+            self.struct_layers = nn.ModuleList([GlycanBERTLayer(struct_config) for _ in range(struct_config.num_hidden_layers)])
+            self.struct_mlm_head = nn.Linear(struct_config.hidden_size, struct_config.vocab_size)
+            
+            # Cross-attention layer (sequence → VQ-VAE structural tokens)
+            if config.use_cross_attention:
+                self.cross_attention = CrossAttentionLayer(config)
+        
+        # ===== Projection layers (align hidden sizes) =====
+        if config.ms_hidden_size != config.seq_hidden_size:
+            self.ms_projection = nn.Linear(config.ms_hidden_size, config.seq_hidden_size)
+        else:
+            self.ms_projection = nn.Identity()
+        
+        if config.use_3d and config.struct_hidden_size != config.seq_hidden_size:
+            self.struct_projection = nn.Linear(config.struct_hidden_size, config.seq_hidden_size)
+        else:
+            self.struct_projection = nn.Identity()
+        
+        # ===== Fusion Layer =====
+        # Concatenate seq + ms + struct
+        fusion_input_size = config.seq_hidden_size * (3 if config.use_3d else 2)
+        self.fusion_layer = nn.Sequential(
+            nn.Linear(fusion_input_size, config.fusion_hidden_size),
+            nn.LayerNorm(config.fusion_hidden_size, eps=config.layer_norm_eps),
+            nn.GELU(),
+            nn.Dropout(config.hidden_dropout_prob),
+            nn.Linear(config.fusion_hidden_size, config.fusion_hidden_size),
+        )
+        
+        # Initialize weights
+        self.apply(self._init_weights)
+    
+    def _init_weights(self, module):
+        """Initialize weights."""
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+    
+    def forward(
+        self,
+        seq_token_ids: torch.Tensor,
+        seq_attention_mask: torch.Tensor,
+        seq_residue_ids: torch.Tensor,
+        seq_branch_depths: Optional[torch.Tensor] = None,  # NEW: Branch depths
+        seq_linkage_types: Optional[torch.Tensor] = None,  # NEW: Linkage types
+        ms_token_ids: torch.Tensor = None,
+        ms_attention_mask: torch.Tensor = None,
+        has_ms: torch.Tensor = None,
+        struct_token_ids: Optional[torch.Tensor] = None,
+        struct_attention_mask: Optional[torch.Tensor] = None,
+        struct_residue_ids: Optional[torch.Tensor] = None,
+        has_3d: Optional[torch.Tensor] = None,
+        seq_labels: Optional[torch.Tensor] = None,
+        ms_labels: Optional[torch.Tensor] = None,
+        struct_labels: Optional[torch.Tensor] = None,
+        dist_labels: Optional[torch.Tensor] = None,  # NEW: Topology distance labels
+        return_dict: bool = True,
+        compute_distance: bool = True,  # Skip distance_head if False (saves memory)
+    ) -> Dict[str, torch.Tensor]:
+        """
+        Forward pass for multimodal BERT v3.
+        
+        Args:
+            seq_token_ids: (batch_size, seq_len) - Sequence token IDs
+            seq_attention_mask: (batch_size, seq_len) - Sequence attention mask
+            seq_residue_ids: (batch_size, seq_len) - Sequence token residue IDs
+            ms_token_ids: (batch_size, ms_len) - MS token IDs
+            ms_attention_mask: (batch_size, ms_len) - MS attention mask
+            has_ms: (batch_size,) - Boolean mask for samples with MS data
+            struct_token_ids: (batch_size, struct_len) - Structure VQ-VAE token IDs (optional)
+            struct_attention_mask: (batch_size, struct_len) - Structure attention mask (optional)
+            struct_residue_ids: (batch_size, struct_len) - Structure token residue IDs (optional)
+            has_3d: (batch_size,) - Boolean mask for samples with 3D data (optional)
+            seq_labels: (batch_size, seq_len) - Masked sequence labels (optional)
+            ms_labels: (batch_size, ms_len) - Masked MS labels (optional)
+            struct_labels: (batch_size, struct_len) - Masked structure labels (optional)
+            return_dict: Whether to return dict or tuple
+        
+        Returns:
+            Dictionary containing logits, hidden states, losses, etc.
+        """
+        batch_size = seq_token_ids.shape[0]
+        device = seq_token_ids.device
+        
+        # ===== Sequence Encoder =====
+        # Pass branch_depths and linkage_types to embeddings for tree-aware encoding
+        seq_hidden = self.seq_embeddings(seq_token_ids, seq_branch_depths, seq_linkage_types)
+        for layer in self.seq_layers:
+            seq_hidden = layer(seq_hidden, seq_attention_mask)
+        
+        seq_pooled = seq_hidden[:, 0, :]  # [CLS] token
+        seq_logits = self.seq_mlm_head(seq_hidden)
+        
+        # Calculate structural distances
+        # Calculate structural distances only if needed (saves ~48GB memory)
+        dist_predictions = self.distance_head(seq_hidden) if compute_distance else None
+
+        
+        # ===== MS Encoder =====
+        ms_hidden = None
+        ms_pooled = None
+        ms_logits = None
+        
+        if ms_token_ids is not None:
+            ms_hidden = self.ms_embeddings(ms_token_ids)
+            for layer in self.ms_layers:
+                ms_hidden = layer(ms_hidden, ms_attention_mask)
+            
+            ms_pooled = ms_hidden[:, 0, :]  # [CLS] token
+            ms_logits = self.ms_mlm_head(ms_hidden)
+            
+            # Zero out MS representations for samples without MS data
+            if has_ms is not None:
+                has_ms_expanded = has_ms.unsqueeze(1).float()  # (batch, 1)
+                ms_pooled = ms_pooled * has_ms_expanded
+        
+        # ===== Structure Encoder =====
+        struct_pooled = None
+        struct_logits = None
+        struct_hidden = None
+        
+        if self.config.use_3d and struct_token_ids is not None:
+            struct_hidden = self.struct_embeddings(struct_token_ids)
+            for layer in self.struct_layers:
+                struct_hidden = layer(struct_hidden, struct_attention_mask)
+            
+            struct_pooled = struct_hidden[:, 0, :]  # [CLS] token
+            struct_logits = self.struct_mlm_head(struct_hidden)
+            
+            # Zero out structure representations for samples without 3D data
+            if has_3d is not None:
+                has_3d_expanded = has_3d.unsqueeze(1).float()  # (batch, 1)
+                struct_pooled = struct_pooled * has_3d_expanded
+            
+            # ===== Cross-Attention (Sequence → VQ-VAE Structural Tokens) =====
+            # Use residue-level alignment between WURCS tokens and VQ-VAE tokens
+            if self.config.use_cross_attention and struct_residue_ids is not None:
+                # Create residue-level mask
+                # WURCS token with residue_id=0 → VQ-VAE tokens with residue_id=0
+                residue_mask = create_residue_level_mask(
+                    seq_residue_ids=seq_residue_ids,
+                    struct_residue_ids=struct_residue_ids,
+                )  # (batch, N_seq, N_struct)
+                
+                # Apply cross-attention: sequence tokens attend to VQ-VAE tokens
+                seq_hidden = self.cross_attention(
+                    seq_hidden=seq_hidden,
+                    struct_hidden=struct_hidden,  # VQ-VAE token features
+                    attention_mask=residue_mask,  # Residue-based mask
+                )
+                
+                # Update seq_pooled after cross-attention
+                seq_pooled = seq_hidden[:, 0, :]
+        
+        # ===== Fusion =====
+        # Project to common hidden size
+        ms_pooled_projected = self.ms_projection(ms_pooled)
+        
+        if self.config.use_3d and struct_pooled is not None:
+            struct_pooled_projected = self.struct_projection(struct_pooled)
+            combined = torch.cat([seq_pooled, ms_pooled_projected, struct_pooled_projected], dim=-1)
+        else:
+            combined = torch.cat([seq_pooled, ms_pooled_projected], dim=-1)
+        
+        fused_repr = self.fusion_layer(combined)
+        
+        # ===== Compute Losses =====
+        total_loss = None
+        seq_loss = None
+        ms_loss = None
+        struct_loss = None
+        dist_loss = None  # NEW: Topology loss
+        
+        if seq_labels is not None:
+            loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+            seq_loss = loss_fct(
+                seq_logits.view(-1, self.config.seq_vocab_size),
+                seq_labels.view(-1)
+            )
+        
+        if ms_labels is not None:
+            ms_labels_masked = ms_labels.clone()
+            ms_labels_masked[~has_ms] = -100
+            # Only compute loss if there are valid labels (not all -100)
+            if (ms_labels_masked != -100).any():
+                loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+                ms_loss = loss_fct(
+                    ms_logits.view(-1, self.config.ms_total_vocab_size),
+                    ms_labels_masked.view(-1)
+                )
+            else:
+                ms_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        
+        if self.config.use_3d and struct_labels is not None and struct_logits is not None:
+            struct_labels_masked = struct_labels.clone()
+            if has_3d is not None:
+                struct_labels_masked[~has_3d] = -100
+            # Only compute loss if there are valid labels (not all -100)
+            if (struct_labels_masked != -100).any():
+                loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+                struct_loss = loss_fct(
+                    struct_logits.view(-1, self.config.struct_vocab_size),
+                    struct_labels_masked.view(-1)
+                )
+            else:
+                struct_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        
+        # ===== Distance Loss (Topology) =====
+        if dist_labels is not None:
+            # dist_predictions: (Batch, Seq, Seq, 1) -> (Batch, Seq, Seq)
+            preds = dist_predictions.squeeze(-1)
+            
+            # Create mask for valid distance pairs (label != -1)
+            # Also respect attention mask to avoid padding
+            valid_mask = (dist_labels != -1) & (seq_attention_mask.unsqueeze(1) * seq_attention_mask.unsqueeze(2) == 1)
+            
+            if valid_mask.sum() > 0:
+                # MSE loss on valid positions only
+                loss_fct = nn.MSELoss()
+                dist_loss = loss_fct(preds[valid_mask], dist_labels[valid_mask].float())
+            else:
+                dist_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        
+        # Weighted combination
+        losses = []
+        if seq_loss is not None:
+            losses.append(self.config.seq_loss_weight * seq_loss)
+        if ms_loss is not None:
+            losses.append(self.config.ms_loss_weight * ms_loss)
+        if struct_loss is not None:
+            losses.append(self.config.struct_loss_weight * struct_loss)
+        if dist_loss is not None:
+            losses.append(self.config.dist_loss_weight * dist_loss)
+        
+        if losses:
+            total_loss = sum(losses)
+        
+        if return_dict:
+            return {
+                'loss': total_loss,
+                'seq_loss': seq_loss,
+                'ms_loss': ms_loss,
+                'struct_loss': struct_loss,
+                'dist_loss': dist_loss,
+                'seq_logits': seq_logits,
+                'ms_logits': ms_logits,
+                'struct_logits': struct_logits,
+                'dist_predictions': dist_predictions, # Return distance predictions
+                'seq_hidden': seq_hidden,
+                'ms_hidden': ms_hidden,
+                'struct_hidden': struct_hidden,
+                'seq_pooled': seq_pooled,
+                'ms_pooled': ms_pooled,
+                'struct_pooled': struct_pooled,
+                'fused_repr': fused_repr,
+            }
+        else:
+            return (total_loss, seq_logits, ms_logits, struct_logits, fused_repr)
+    
+    def get_multimodal_representation(
+        self,
+        seq_token_ids: torch.Tensor,
+        seq_attention_mask: torch.Tensor,
+        seq_residue_ids: torch.Tensor,
+        ms_token_ids: torch.Tensor,
+        ms_attention_mask: torch.Tensor,
+        has_ms: torch.Tensor,
+        struct_token_ids: Optional[torch.Tensor] = None,
+        struct_attention_mask: Optional[torch.Tensor] = None,
+        struct_residue_ids: Optional[torch.Tensor] = None,
+        has_3d: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        """Get fused multimodal representation (for inference)."""
+        outputs = self.forward(
+            seq_token_ids=seq_token_ids,
+            seq_attention_mask=seq_attention_mask,
+            seq_residue_ids=seq_residue_ids,
+            ms_token_ids=ms_token_ids,
+            ms_attention_mask=ms_attention_mask,
+            has_ms=has_ms,
+            struct_token_ids=struct_token_ids,
+            struct_attention_mask=struct_attention_mask,
+            struct_residue_ids=struct_residue_ids,
+            has_3d=has_3d,
+            return_dict=True,
+        )
+        return outputs['fused_repr']
+
+
+if __name__ == "__main__":
+    # Test the model
+    print("="*80)
+    print("Testing Multimodal GlycanBERT v3")
+    print("="*80)
+    
+    # Create config
+    config = MultimodalGlycanBERTConfig(
+        seq_vocab_size=166,
+        seq_hidden_size=768,
+        seq_num_layers=12,
+        seq_num_heads=12,
+        ms_vocab_size=242,
+        ms_hidden_size=384,
+        ms_num_layers=6,
+        ms_num_heads=6,
+        struct_vocab_size=1024,
+        struct_hidden_size=512,
+        struct_num_layers=8,
+        struct_num_heads=8,
+        use_3d=True,
+        use_cross_attention=True,
+        seq_loss_weight=0.60,
+        ms_loss_weight=0.15,
+        struct_loss_weight=0.25,
+    )
+    
+    print(f"\nConfig:")
+    print(f"  Sequence vocab: {config.seq_vocab_size}")
+    print(f"  MS vocab: {config.ms_vocab_size}")
+    print(f"  Structure vocab: {config.struct_vocab_size}")
+    print(f"  Loss weights: seq={config.seq_loss_weight}, ms={config.ms_loss_weight}, struct={config.struct_loss_weight}")
+    
+    # Create model
+    model = MultimodalGlycanBERT(config)
+    
+    # Count parameters
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    
+    print(f"\nModel Parameters:")
+    print(f"  Total: {total_params:,}")
+    print(f"  Trainable: {trainable_params:,}")
+    
+    # Test forward pass
+    print(f"\n{'='*80}")
+    print("Testing Forward Pass (with Conv front-end)")
+    print("="*80)
+    
+    batch_size = 4
+    seq_len = 128
+    ms_len = 50
+    struct_len = 40
+    
+    # Create dummy inputs
+    seq_token_ids = torch.randint(0, config.seq_vocab_size, (batch_size, seq_len))
+    seq_attention_mask = torch.ones(batch_size, seq_len)
+    # Approximate: ~5 tokens per residue
+    seq_residue_ids = torch.div(
+        torch.arange(seq_len), 5, rounding_mode="floor"
+    ).unsqueeze(0).expand(batch_size, -1)
+
+    ms_token_ids = torch.randint(config.ms_vocab_offset, config.ms_total_vocab_size, (batch_size, ms_len))
+    ms_attention_mask = torch.ones(batch_size, ms_len)
+    struct_token_ids = torch.randint(0, config.struct_vocab_size, (batch_size, struct_len))
+    struct_attention_mask = torch.ones(batch_size, struct_len)
+    # Approximate: 4 tokens per residue for VQ-VAE tokens
+    struct_residue_ids = torch.div(
+        torch.arange(struct_len), 4, rounding_mode="floor"
+    ).unsqueeze(0).expand(batch_size, -1)
+
+    has_ms = torch.tensor([True, True, False, True])
+    has_3d = torch.tensor([True, False, True, True])
+    
+    # Create labels for MLM
+    seq_labels = seq_token_ids.clone()
+    seq_labels[seq_labels != config.mask_token_id] = -100
+    ms_labels = ms_token_ids.clone()
+    ms_labels[ms_labels != config.mask_token_id] = -100
+    struct_labels = struct_token_ids.clone()
+    struct_labels[struct_labels != config.mask_token_id] = -100
+    
+    # Forward pass
+    outputs = model(
+        seq_token_ids=seq_token_ids,
+        seq_attention_mask=seq_attention_mask,
+        seq_residue_ids=seq_residue_ids,
+        ms_token_ids=ms_token_ids,
+        ms_attention_mask=ms_attention_mask,
+        has_ms=has_ms,
+        struct_token_ids=struct_token_ids,
+        struct_attention_mask=struct_attention_mask,
+        struct_residue_ids=struct_residue_ids,
+        has_3d=has_3d,
+        seq_labels=seq_labels,
+        ms_labels=ms_labels,
+        struct_labels=struct_labels,
+    )
+    
+    print(f"\nOutput shapes:")
+    print(f"  seq_logits: {outputs['seq_logits'].shape}")
+    print(f"  ms_logits: {outputs['ms_logits'].shape}")
+    print(f"  struct_logits: {outputs['struct_logits'].shape}")
+    print(f"  fused_repr: {outputs['fused_repr'].shape}")
+    
+    print(f"\nLosses:")
+    print(f"  Total loss: {outputs['loss'].item():.4f}")
+    print(f"  Sequence loss: {outputs['seq_loss'].item():.4f}")
+    print(f"  MS loss: {outputs['ms_loss'].item():.4f}")
+    print(f"  Structure loss: {outputs['struct_loss'].item():.4f}")
+    
+    print(f"\n{'='*80}")
+    print("Model Test Complete!")
+    print("="*80)
+

releases/2026-10-02/bertose_source/data/bpe_vocabulary.json

@@ -0,0 +1,2612 @@
+{
+  "special_tokens": {
+    "[PAD]": 0,
+    "[UNK]": 1,
+    "[START]": 2,
+    "[END]": 3,
+    "[MASK]": 4,
+    "[BRANCH_OPEN]": 5,
+    "[BRANCH_CLOSE]": 6,
+    "[LINK]": 7,
+    "[MOD]": 8,
+    "[RESIDUE_ERROR]": 9
+  },
+  "token_to_id": {
+    "[PAD]": 0,
+    "[UNK]": 1,
+    "[START]": 2,
+    "[END]": 3,
+    "[MASK]": 4,
+    "[BRANCH_OPEN]": 5,
+    "[BRANCH_CLOSE]": 6,
+    "[LINK]": 7,
+    "[MOD]": 8,
+    "[RESIDUE_ERROR]": 9,
+    "#": 10,
+    "$": 11,
+    "%": 12,
+    "(": 13,
+    ")": 14,
+    "*": 15,
+    "-": 16,
+    ".": 17,
+    "/": 18,
+    "0": 19,
+    "1": 20,
+    "2": 21,
+    "3": 22,
+    "4": 23,
+    "5": 24,
+    "6": 25,
+    "7": 26,
+    "8": 27,
+    "9": 28,
+    "<": 29,
+    "=": 30,
+    ">": 31,
+    "?": 32,
+    "A": 33,
+    "B": 34,
+    "C": 35,
+    "D": 36,
+    "E": 37,
+    "F": 38,
+    "G": 39,
+    "H": 40,
+    "I": 41,
+    "J": 42,
+    "K": 43,
+    "L": 44,
+    "M": 45,
+    "N": 46,
+    "O": 47,
+    "P": 48,
+    "Q": 49,
+    "R": 50,
+    "S": 51,
+    "T": 52,
+    "U": 53,
+    "V": 54,
+    "W": 55,
+    "X": 56,
+    "Y": 57,
+    "Z": 58,
+    "^": 59,
+    "a": 60,
+    "b": 61,
+    "c": 62,
+    "d": 63,
+    "e": 64,
+    "f": 65,
+    "g": 66,
+    "h": 67,
+    "i": 68,
+    "j": 69,
+    "k": 70,
+    "l": 71,
+    "m": 72,
+    "n": 73,
+    "o": 74,
+    "p": 75,
+    "q": 76,
+    "r": 77,
+    "s": 78,
+    "t": 79,
+    "u": 80,
+    "v": 81,
+    "w": 82,
+    "x": 83,
+    "y": 84,
+    "z": 85,
+    "{": 86,
+    "|": 87,
+    "}": 88,
+    "~": 89,
+    "?|": 90,
+    "12": 91,
+    "1-": 92,
+    "-1": 93,
+    "1-5": 94,
+    "h-1": 95,
+    "122": 96,
+    "CC": 97,
+    "a2": 98,
+    "/3": 99,
+    "=O": 100,
+    "/3=O": 101,
+    "122h-1": 102,
+    "*N": 103,
+    "CC/3=O": 104,
+    "xx": 105,
+    "*NCC/3=O": 106,
+    "2*NCC/3=O": 107,
+    "a?|": 108,
+    "a?|b": 109,
+    "?|c": 110,
+    "a?|b?|c": 111,
+    "?|d": 112,
+    "a?|b?|c?|d": 113,
+    "?|e": 114,
+    "a?|b?|c?|d?|e": 115,
+    "?|f": 116,
+    "a?|b?|c?|d?|e?|f": 117,
+    "?-": 118,
+    "a2122h-1": 119,
+    "?|g": 120,
+    "a?|b?|c?|d?|e?|f?|g": 121,
+    "?|h": 122,
+    "a?|b?|c?|d?|e?|f?|g?|h": 123,
+    "?|i": 124,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i": 125,
+    "?|j": 126,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j": 127,
+    "112": 128,
+    "?|k": 129,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k": 130,
+    "?|l": 131,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l": 132,
+    "a2112": 133,
+    "?|m": 134,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m": 135,
+    "a2112h-1": 136,
+    "4-": 137,
+    "a1": 138,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|": 139,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n": 140,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|": 141,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o": 142,
+    "?}": 143,
+    "a1122h-1": 144,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|": 145,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p": 146,
+    "?}-": 147,
+    "?}-{": 148,
+    "2-": 149,
+    "122h": 150,
+    "a2122h-1b": 151,
+    "3-": 152,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|": 153,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q": 154,
+    "*O": 155,
+    "xxxx": 156,
+    "b1": 157,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|": 158,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r": 159,
+    "a2122h-1x": 160,
+    "c1": 161,
+    "d1": 162,
+    "a2112h-1b": 163,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|": 164,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s": 165,
+    "m-1": 166,
+    "21": 167,
+    "1221": 168,
+    "6-": 169,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|": 170,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t": 171,
+    "CCCC": 172,
+    "u2": 173,
+    "e1": 174,
+    "a1122h-1a": 175,
+    "-2": 176,
+    "uxxxx": 177,
+    "a2112h-1x": 178,
+    "122h-2": 179,
+    "h-1x": 180,
+    "Aa": 181,
+    "2-6": 182,
+    "d21": 183,
+    "f1": 184,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|": 185,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u": 186,
+    "a1221": 187,
+    "O/3=O": 188,
+    "a1221m-1": 189,
+    "uxxxxh": 190,
+    "Aad21": 191,
+    "Aad21122h-2": 192,
+    "a4-": 193,
+    "a1122h-1x": 194,
+    "a?-": 195,
+    "axxxx": 196,
+    "c?-": 197,
+    "*OC": 198,
+    "5*NCC/3=O": 199,
+    "a4-b1": 200,
+    "axxxxh-1x": 201,
+    "g1": 202,
+    "h1": 203,
+    "u2122h": 204,
+    "b?-": 205,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|": 206,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v": 207,
+    "b4-": 208,
+    "a?-b1": 209,
+    "i1": 210,
+    "b4-c1": 211,
+    "d?-": 212,
+    "a1221m-1a": 213,
+    "CCCCCC": 214,
+    "*OCC/3=O": 215,
+    "b?-c1": 216,
+    "c3-": 217,
+    "j1": 218,
+    "CCCCCC$": 219,
+    "(CCCCCC$": 220,
+    "Aad21122h-2a": 221,
+    "a1122h-1b": 222,
+    "a2122h-1a": 223,
+    "(CCCCCC$4": 224,
+    "*OC(CCCCCC$4": 225,
+    "c3-d1": 226,
+    "*OC(CCCCCC$4)": 227,
+    "c?-d1": 228,
+    "SO/3=O": 229,
+    "SO/3=O/3=O": 230,
+    "a6-": 231,
+    "112h": 232,
+    "k1": 233,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|": 234,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w": 235,
+    "Aad21122h-2x": 236,
+    "a3-": 237,
+    "A-1": 238,
+    "a1221m-1x": 239,
+    "d?-e1": 240,
+    "*OSO/3=O/3=O": 241,
+    "a3-b1": 242,
+    "e?-": 243,
+    "1-?": 244,
+    "c6-": 245,
+    "b3-": 246,
+    "h-1a": 247,
+    "d2-": 248,
+    "u2112h": 249,
+    "d2-e1": 250,
+    "211": 251,
+    "l1": 252,
+    "2*N": 253,
+    "a2112h-1a": 254,
+    "e4-": 255,
+    "5*N": 256,
+    "AU": 257,
+    "u1": 258,
+    "a11221": 259,
+    "c4-": 260,
+    "e?-f1": 261,
+    "m-1a": 262,
+    "b3-c1": 263,
+    "CCO/3=O": 264,
+    "a2211": 265,
+    "5*NCCO/3=O": 266,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|": 267,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x": 268,
+    "m1": 269,
+    "3|": 270,
+    "f?-": 271,
+    "*OP": 272,
+    "d4-": 273,
+    "e4-f1": 274,
+    "a212": 275,
+    "a2122": 276,
+    "h2": 277,
+    "n1": 278,
+    "m-1x": 279,
+    "u1122h": 280,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|": 281,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y": 282,
+    "-b1": 283,
+    "h-1b": 284,
+    "xh": 285,
+    "11": 286,
+    "a11221h-1a": 287,
+    "/3O/3=O": 288,
+    "a2211m-1a": 289,
+    "c4-d1": 290,
+    "g?-": 291,
+    "a2122A-1": 292,
+    "1-4": 293,
+    "*OPO": 294,
+    "o1": 295,
+    "6*OSO/3=O/3=O": 296,
+    "g2": 297,
+    "i?-": 298,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?}-{": 299,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t": 300,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?": 301,
+    "*OC(CCCCCC$4)/3=O": 302,
+    "h?-": 303,
+    "22": 304,
+    "Aad1": 305,
+    "e3-": 306,
+    "AUd21": 307,
+    "AUd21122h": 308,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?}-{": 309,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u": 310,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?": 311,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?}-{": 312,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r": 313,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?": 314,
+    "Aad1122h-2": 315,
+    "f?-g1": 316,
+    "d3-": 317,
+    "b6-": 318,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?}-{": 319,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o": 320,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?": 321,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|": 322,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z": 323,
+    "f3-": 324,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?}-{": 325,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s": 326,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?": 327,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?}-{": 328,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p": 329,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?": 330,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?}-{": 331,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q": 332,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?": 333,
+    "3*OCC/3=O": 334,
+    "uxxxxm": 335,
+    "a1-": 336,
+    "g?-h1": 337,
+    "e3-f1": 338,
+    "2*OCC/3=O": 339,
+    "p1": 340,
+    "j?-": 341,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?}-{": 342,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l": 343,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?": 344,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?}-{": 345,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n": 346,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?": 347,
+    "h?-i1": 348,
+    "a2-b1": 349,
+    "^X": 350,
+    "3*OC": 351,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?}-{": 352,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v": 353,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?": 354,
+    "k?-": 355,
+    "4*OCC/3=O": 356,
+    "i?-j1": 357,
+    "a11221h-1x": 358,
+    "d3-e1": 359,
+    "6*OCC/3=O": 360,
+    "c2-": 361,
+    "c2": 362,
+    "u1221": 363,
+    "a1122": 364,
+    "a6-b1": 365,
+    "c2-d1": 366,
+    "u1221m": 367,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?}-{": 368,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m": 369,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?": 370,
+    "d4-e1": 371,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?}-{": 372,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k": 373,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?": 374,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|": 375,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A": 376,
+    "4-i1": 377,
+    "b2-": 378,
+    "*OPO/3O/3=O": 379,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?}-{": 380,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j": 381,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?": 382,
+    "d2": 383,
+    "h2-": 384,
+    "b2-c1": 385,
+    "l?-": 386,
+    "^XO": 387,
+    "q1": 388,
+    "4-h1": 389,
+    "dxxxx": 390,
+    "f3-g1": 391,
+    "A-1a": 392,
+    "AUdxxxx": 393,
+    "CCN": 394,
+    "h4-i1": 395,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|": 396,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B": 397,
+    "~n": 398,
+    "a2122A-1b": 399,
+    "xh-1": 400,
+    "A-1x": 401,
+    "i4-": 402,
+    "j?-k1": 403,
+    "3*OC(CCCCCC$4)": 404,
+    "a211": 405,
+    "2*OSO/3=O/3=O": 406,
+    "m?-": 407,
+    "g4-h1": 408,
+    "r1": 409,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?}-{": 410,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?}-{a?|b?|c?|d?|e?|f?|g?|h?|i": 411,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?": 412,
+    "g2-": 413,
+    "a5": 414,
+    "g3-": 415,
+    "34": 416,
+    "m-1b": 417,
+    "k?-l1": 418,
+    "f?-g2": 419,
+    "a212h-1b": 420,
+    "C/": 421,
+    "a?|b?|c?|d?|e?|f?|g?|h?}-{": 422,
+    "a?|b?|c?|d?|e?|f?|g?|h?}-{a?|b?|c?|d?|e?|f?|g?|h": 423,
+    "a?|b?|c?|d?|e?|f?|g?|h?}-{a?|b?|c?|d?|e?|f?|g?|h?": 424,
+    "Aad1122h-2a": 425,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|": 426,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C": 427,
+    "i4-j1": 428,
+    "Aad1122h-2x": 429,
+    "a?|b?|c?|d?|e?|f?|g?}-{": 430,
+    "a?|b?|c?|d?|e?|f?|g?}-{a?|b?|c?|d?|e?|f?|g": 431,
+    "a?|b?|c?|d?|e?|f?|g?}-{a?|b?|c?|d?|e?|f?|g?": 432,
+    "d6-": 433,
+    "h2-i1": 434,
+    "2*NSO/3=O/3=O": 435,
+    "*OP^XO": 436,
+    "2*OC(CCCCCC$4)": 437,
+    "a2211m-1x": 438,
+    "ax": 439,
+    "f4-": 440,
+    "4|": 441,
+    "a?|b?|c?|d?|e?|f?}-{": 442,
+    "a?|b?|c?|d?|e?|f?}-{a?|b?|c?|d?|e?|f": 443,
+    "a?|b?|c?|d?|e?|f?}-{a?|b?|c?|d?|e?|f?": 444,
+    "f4-g1": 445,
+    "l?-m1": 446,
+    "e2-": 447,
+    "*OCC": 448,
+    "AUdxxxxxh": 449,
+    "h2122h": 450,
+    "e2-f1": 451,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?}-{": 452,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w": 453,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?": 454,
+    "b2": 455,
+    "i2-": 456,
+    "4*OC(CCCCCC$4)": 457,
+    "g2-h1": 458,
+    "a212h-1x": 459,
+    "j4-": 460,
+    "l4-": 461,
+    "g3-h1": 462,
+    "6*OC(CCCCCC$4)": 463,
+    "a2122A-1x": 464,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|": 465,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D": 466,
+    "e2": 467,
+    "O/": 468,
+    "i2-j1": 469,
+    "i3-": 470,
+    "a5-b1": 471,
+    "e4-g1": 472,
+    "a?|b?|c?|d?|e?}-{": 473,
+    "a?|b?|c?|d?|e?}-{a?|b?|c?|d?|e": 474,
+    "a?|b?|c?|d?|e?}-{a?|b?|c?|d?|e?": 475,
+    "f6-": 476,
+    "/3C": 477,
+    "s1": 478,
+    "j4-k1": 479,
+    "xh-1u": 480,
+    "h2112h": 481,
+    "h3-": 482,
+    "c6-h1": 483,
+    "k2-": 484,
+    "3*OSO/3=O/3=O": 485,
+    "l4-m1": 486,
+    "j2": 487,
+    "2-5": 488,
+    "a2121": 489,
+    "d1122h": 490,
+    "a4-c1": 491,
+    "AUd1122h": 492,
+    "n?-": 493,
+    "8-": 494,
+    "*OP^XOCCN": 495,
+    "2*OC": 496,
+    "a?|b?|c?|d?}-{": 497,
+    "a?|b?|c?|d?}-{a?|b?|c?|d": 498,
+    "a?|b?|c?|d?}-{a?|b?|c?|d?": 499,
+    "axx": 500,
+    "7-": 501,
+    "uxxxxxh": 502,
+    "f2-": 503,
+    "c6-g1": 504,
+    "j2-": 505,
+    "2*OC(CCCCCC$4)/3=O": 506,
+    "f2": 507,
+    "k4-": 508,
+    "m?-n1": 509,
+    "4*OSO/3=O/3=O": 510,
+    "f2-g1": 511,
+    "*OS": 512,
+    "h3-i1": 513,
+    "222": 514,
+    "k2-l1": 515,
+    "1221h": 516,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|": 517,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E": 518,
+    "axxxxm-1x": 519,
+    "i2": 520,
+    "u11221h": 521,
+    "4*OPO/3O/3=O": 522,
+    "334": 523,
+    "b6-c1": 524,
+    "c6-i1": 525,
+    "d4-h1": 526,
+    "d?-h1": 527,
+    "o?-": 528,
+    "k2": 529,
+    "6*OC": 530,
+    "a11222": 531,
+    "c?-i1": 532,
+    "a122h-1": 533,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|": 534,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F": 535,
+    "c?-h1": 536,
+    "3*OC(CCCCCC$4)/3=O": 537,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|": 538,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G": 539,
+    "i3-j1": 540,
+    "4*OC": 541,
+    "ha": 542,
+    "j2-k1": 543,
+    "j3-": 544,
+    "a4": 545,
+    "6|": 546,
+    "*OP^XOCCN/3O/3=O": 547,
+    "C/4": 548,
+    "a2112A-1a": 549,
+    "m4-": 550,
+    "n2": 551,
+    "c6-k1": 552,
+    "k4-l1": 553,
+    "ad": 554,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?}-{": 555,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x": 556,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?": 557,
+    "t1": 558,
+    "a21": 559,
+    "4*N": 560,
+    "u2211": 561,
+    "a?|b?|c?}-{": 562,
+    "a?|b?|c?}-{a?|b?|c": 563,
+    "a?|b?|c?}-{a?|b?|c?": 564,
+    "a12": 565,
+    "CCCCCCCC": 566,
+    "g6-": 567,
+    "f3-g2": 568,
+    "u2211m": 569,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|": 570,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H": 571,
+    "5-": 572,
+    "ha122h-2": 573,
+    "e6-": 574,
+    "h6-": 575,
+    "3|g": 576,
+    "c6-d1": 577,
+    "4*OC(CCCCCC$4)/3=O": 578,
+    "3*NCC/3=O": 579,
+    "2-?": 580,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|": 581,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I": 582,
+    "?}*OC": 583,
+    "C/3=O": 584,
+    "i6-": 585,
+    "c?-k1": 586,
+    "c?-g1": 587,
+    "l2-": 588,
+    "a22": 589
+  },
+  "merges": [
+    [
+      "?",
+      "|"
+    ],
+    [
+      "1",
+      "2"
+    ],
+    [
+      "1",
+      "-"
+    ],
+    [
+      "-",
+      "1"
+    ],
+    [
+      "1-",
+      "5"
+    ],
+    [
+      "h",
+      "-1"
+    ],
+    [
+      "12",
+      "2"
+    ],
+    [
+      "C",
+      "C"
+    ],
+    [
+      "a",
+      "2"
+    ],
+    [
+      "/",
+      "3"
+    ],
+    [
+      "=",
+      "O"
+    ],
+    [
+      "/3",
+      "=O"
+    ],
+    [
+      "122",
+      "h-1"
+    ],
+    [
+      "*",
+      "N"
+    ],
+    [
+      "CC",
+      "/3=O"
+    ],
+    [
+      "x",
+      "x"
+    ],
+    [
+      "*N",
+      "CC/3=O"
+    ],
+    [
+      "2",
+      "*NCC/3=O"
+    ],
+    [
+      "a",
+      "?|"
+    ],
+    [
+      "a?|",
+      "b"
+    ],
+    [
+      "?|",
+      "c"
+    ],
+    [
+      "a?|b",
+      "?|c"
+    ],
+    [
+      "?|",
+      "d"
+    ],
+    [
+      "a?|b?|c",
+      "?|d"
+    ],
+    [
+      "?|",
+      "e"
+    ],
+    [
+      "a?|b?|c?|d",
+      "?|e"
+    ],
+    [
+      "?|",
+      "f"
+    ],
+    [
+      "a?|b?|c?|d?|e",
+      "?|f"
+    ],
+    [
+      "?",
+      "-"
+    ],
+    [
+      "a2",
+      "122h-1"
+    ],
+    [
+      "?|",
+      "g"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f",
+      "?|g"
+    ],
+    [
+      "?|",
+      "h"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g",
+      "?|h"
+    ],
+    [
+      "?|",
+      "i"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h",
+      "?|i"
+    ],
+    [
+      "?|",
+      "j"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i",
+      "?|j"
+    ],
+    [
+      "1",
+      "12"
+    ],
+    [
+      "?|",
+      "k"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j",
+      "?|k"
+    ],
+    [
+      "?|",
+      "l"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k",
+      "?|l"
+    ],
+    [
+      "a2",
+      "112"
+    ],
+    [
+      "?|",
+      "m"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l",
+      "?|m"
+    ],
+    [
+      "a2112",
+      "h-1"
+    ],
+    [
+      "4",
+      "-"
+    ],
+    [
+      "a",
+      "1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|",
+      "n"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|",
+      "o"
+    ],
+    [
+      "?",
+      "}"
+    ],
+    [
+      "a1",
+      "122h-1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|",
+      "p"
+    ],
+    [
+      "?}",
+      "-"
+    ],
+    [
+      "?}-",
+      "{"
+    ],
+    [
+      "2",
+      "-"
+    ],
+    [
+      "122",
+      "h"
+    ],
+    [
+      "a2122h-1",
+      "b"
+    ],
+    [
+      "3",
+      "-"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|",
+      "q"
+    ],
+    [
+      "*",
+      "O"
+    ],
+    [
+      "xx",
+      "xx"
+    ],
+    [
+      "b",
+      "1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|",
+      "r"
+    ],
+    [
+      "a2122h-1",
+      "x"
+    ],
+    [
+      "c",
+      "1"
+    ],
+    [
+      "d",
+      "1"
+    ],
+    [
+      "a2112h-1",
+      "b"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|",
+      "s"
+    ],
+    [
+      "m",
+      "-1"
+    ],
+    [
+      "2",
+      "1"
+    ],
+    [
+      "122",
+      "1"
+    ],
+    [
+      "6",
+      "-"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|",
+      "t"
+    ],
+    [
+      "CC",
+      "CC"
+    ],
+    [
+      "u",
+      "2"
+    ],
+    [
+      "e",
+      "1"
+    ],
+    [
+      "a1122h-1",
+      "a"
+    ],
+    [
+      "-",
+      "2"
+    ],
+    [
+      "u",
+      "xxxx"
+    ],
+    [
+      "a2112h-1",
+      "x"
+    ],
+    [
+      "122h",
+      "-2"
+    ],
+    [
+      "h-1",
+      "x"
+    ],
+    [
+      "A",
+      "a"
+    ],
+    [
+      "2-",
+      "6"
+    ],
+    [
+      "d",
+      "21"
+    ],
+    [
+      "f",
+      "1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|",
+      "u"
+    ],
+    [
+      "a",
+      "1221"
+    ],
+    [
+      "O",
+      "/3=O"
+    ],
+    [
+      "a1221",
+      "m-1"
+    ],
+    [
+      "uxxxx",
+      "h"
+    ],
+    [
+      "Aa",
+      "d21"
+    ],
+    [
+      "Aad21",
+      "122h-2"
+    ],
+    [
+      "a",
+      "4-"
+    ],
+    [
+      "a1122h-1",
+      "x"
+    ],
+    [
+      "a",
+      "?-"
+    ],
+    [
+      "a",
+      "xxxx"
+    ],
+    [
+      "c",
+      "?-"
+    ],
+    [
+      "*O",
+      "C"
+    ],
+    [
+      "5",
+      "*NCC/3=O"
+    ],
+    [
+      "a4-",
+      "b1"
+    ],
+    [
+      "axxxx",
+      "h-1x"
+    ],
+    [
+      "g",
+      "1"
+    ],
+    [
+      "h",
+      "1"
+    ],
+    [
+      "u2",
+      "122h"
+    ],
+    [
+      "b",
+      "?-"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|",
+      "v"
+    ],
+    [
+      "b",
+      "4-"
+    ],
+    [
+      "a?-",
+      "b1"
+    ],
+    [
+      "i",
+      "1"
+    ],
+    [
+      "b4-",
+      "c1"
+    ],
+    [
+      "d",
+      "?-"
+    ],
+    [
+      "a1221m-1",
+      "a"
+    ],
+    [
+      "CCCC",
+      "CC"
+    ],
+    [
+      "*O",
+      "CC/3=O"
+    ],
+    [
+      "b?-",
+      "c1"
+    ],
+    [
+      "c",
+      "3-"
+    ],
+    [
+      "j",
+      "1"
+    ],
+    [
+      "CCCCCC",
+      "$"
+    ],
+    [
+      "(",
+      "CCCCCC$"
+    ],
+    [
+      "Aad21122h-2",
+      "a"
+    ],
+    [
+      "a1122h-1",
+      "b"
+    ],
+    [
+      "a2122h-1",
+      "a"
+    ],
+    [
+      "(CCCCCC$",
+      "4"
+    ],
+    [
+      "*OC",
+      "(CCCCCC$4"
+    ],
+    [
+      "c3-",
+      "d1"
+    ],
+    [
+      "*OC(CCCCCC$4",
+      ")"
+    ],
+    [
+      "c?-",
+      "d1"
+    ],
+    [
+      "S",
+      "O/3=O"
+    ],
+    [
+      "SO/3=O",
+      "/3=O"
+    ],
+    [
+      "a",
+      "6-"
+    ],
+    [
+      "112",
+      "h"
+    ],
+    [
+      "k",
+      "1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|",
+      "w"
+    ],
+    [
+      "Aad21122h-2",
+      "x"
+    ],
+    [
+      "a",
+      "3-"
+    ],
+    [
+      "A",
+      "-1"
+    ],
+    [
+      "a1221m-1",
+      "x"
+    ],
+    [
+      "d?-",
+      "e1"
+    ],
+    [
+      "*O",
+      "SO/3=O/3=O"
+    ],
+    [
+      "a3-",
+      "b1"
+    ],
+    [
+      "e",
+      "?-"
+    ],
+    [
+      "1-",
+      "?"
+    ],
+    [
+      "c",
+      "6-"
+    ],
+    [
+      "b",
+      "3-"
+    ],
+    [
+      "h-1",
+      "a"
+    ],
+    [
+      "d",
+      "2-"
+    ],
+    [
+      "u2",
+      "112h"
+    ],
+    [
+      "d2-",
+      "e1"
+    ],
+    [
+      "21",
+      "1"
+    ],
+    [
+      "l",
+      "1"
+    ],
+    [
+      "2",
+      "*N"
+    ],
+    [
+      "a2112h-1",
+      "a"
+    ],
+    [
+      "e",
+      "4-"
+    ],
+    [
+      "5",
+      "*N"
+    ],
+    [
+      "A",
+      "U"
+    ],
+    [
+      "u",
+      "1"
+    ],
+    [
+      "a1",
+      "1221"
+    ],
+    [
+      "c",
+      "4-"
+    ],
+    [
+      "e?-",
+      "f1"
+    ],
+    [
+      "m-1",
+      "a"
+    ],
+    [
+      "b3-",
+      "c1"
+    ],
+    [
+      "CC",
+      "O/3=O"
+    ],
+    [
+      "a2",
+      "211"
+    ],
+    [
+      "5*N",
+      "CCO/3=O"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|",
+      "x"
+    ],
+    [
+      "m",
+      "1"
+    ],
+    [
+      "3",
+      "|"
+    ],
+    [
+      "f",
+      "?-"
+    ],
+    [
+      "*O",
+      "P"
+    ],
+    [
+      "d",
+      "4-"
+    ],
+    [
+      "e4-",
+      "f1"
+    ],
+    [
+      "a2",
+      "12"
+    ],
+    [
+      "a2",
+      "122"
+    ],
+    [
+      "h",
+      "2"
+    ],
+    [
+      "n",
+      "1"
+    ],
+    [
+      "m-1",
+      "x"
+    ],
+    [
+      "u1",
+      "122h"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|",
+      "y"
+    ],
+    [
+      "-",
+      "b1"
+    ],
+    [
+      "h-1",
+      "b"
+    ],
+    [
+      "x",
+      "h"
+    ],
+    [
+      "1",
+      "1"
+    ],
+    [
+      "a11221",
+      "h-1a"
+    ],
+    [
+      "/3",
+      "O/3=O"
+    ],
+    [
+      "a2211",
+      "m-1a"
+    ],
+    [
+      "c4-",
+      "d1"
+    ],
+    [
+      "g",
+      "?-"
+    ],
+    [
+      "a2122",
+      "A-1"
+    ],
+    [
+      "1-",
+      "4"
+    ],
+    [
+      "*OP",
+      "O"
+    ],
+    [
+      "o",
+      "1"
+    ],
+    [
+      "6",
+      "*OSO/3=O/3=O"
+    ],
+    [
+      "g",
+      "2"
+    ],
+    [
+      "i",
+      "?-"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t",
+      "?"
+    ],
+    [
+      "*OC(CCCCCC$4)",
+      "/3=O"
+    ],
+    [
+      "h",
+      "?-"
+    ],
+    [
+      "2",
+      "2"
+    ],
+    [
+      "Aa",
+      "d1"
+    ],
+    [
+      "e",
+      "3-"
+    ],
+    [
+      "AU",
+      "d21"
+    ],
+    [
+      "AUd21",
+      "122h"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u",
+      "?"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r",
+      "?"
+    ],
+    [
+      "Aad1",
+      "122h-2"
+    ],
+    [
+      "f?-",
+      "g1"
+    ],
+    [
+      "d",
+      "3-"
+    ],
+    [
+      "b",
+      "6-"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o",
+      "?"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|",
+      "z"
+    ],
+    [
+      "f",
+      "3-"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s",
+      "?"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p",
+      "?"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q",
+      "?"
+    ],
+    [
+      "3",
+      "*OCC/3=O"
+    ],
+    [
+      "uxxxx",
+      "m"
+    ],
+    [
+      "a",
+      "1-"
+    ],
+    [
+      "g?-",
+      "h1"
+    ],
+    [
+      "e3-",
+      "f1"
+    ],
+    [
+      "2",
+      "*OCC/3=O"
+    ],
+    [
+      "p",
+      "1"
+    ],
+    [
+      "j",
+      "?-"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l",
+      "?"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n",
+      "?"
+    ],
+    [
+      "h?-",
+      "i1"
+    ],
+    [
+      "a2",
+      "-b1"
+    ],
+    [
+      "^",
+      "X"
+    ],
+    [
+      "3",
+      "*OC"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v",
+      "?"
+    ],
+    [
+      "k",
+      "?-"
+    ],
+    [
+      "4",
+      "*OCC/3=O"
+    ],
+    [
+      "i?-",
+      "j1"
+    ],
+    [
+      "a11221",
+      "h-1x"
+    ],
+    [
+      "d3-",
+      "e1"
+    ],
+    [
+      "6",
+      "*OCC/3=O"
+    ],
+    [
+      "c",
+      "2-"
+    ],
+    [
+      "c",
+      "2"
+    ],
+    [
+      "u",
+      "1221"
+    ],
+    [
+      "a1",
+      "122"
+    ],
+    [
+      "a6-",
+      "b1"
+    ],
+    [
+      "c2-",
+      "d1"
+    ],
+    [
+      "u1221",
+      "m"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m",
+      "?"
+    ],
+    [
+      "d4-",
+      "e1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k",
+      "?"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|",
+      "A"
+    ],
+    [
+      "4-",
+      "i1"
+    ],
+    [
+      "b",
+      "2-"
+    ],
+    [
+      "*OPO",
+      "/3O/3=O"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j",
+      "?"
+    ],
+    [
+      "d",
+      "2"
+    ],
+    [
+      "h",
+      "2-"
+    ],
+    [
+      "b2-",
+      "c1"
+    ],
+    [
+      "l",
+      "?-"
+    ],
+    [
+      "^X",
+      "O"
+    ],
+    [
+      "q",
+      "1"
+    ],
+    [
+      "4-",
+      "h1"
+    ],
+    [
+      "d",
+      "xxxx"
+    ],
+    [
+      "f3-",
+      "g1"
+    ],
+    [
+      "A-1",
+      "a"
+    ],
+    [
+      "AU",
+      "dxxxx"
+    ],
+    [
+      "CC",
+      "N"
+    ],
+    [
+      "h",
+      "4-i1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|",
+      "B"
+    ],
+    [
+      "~",
+      "n"
+    ],
+    [
+      "a2122A-1",
+      "b"
+    ],
+    [
+      "x",
+      "h-1"
+    ],
+    [
+      "A-1",
+      "x"
+    ],
+    [
+      "i",
+      "4-"
+    ],
+    [
+      "j?-",
+      "k1"
+    ],
+    [
+      "3",
+      "*OC(CCCCCC$4)"
+    ],
+    [
+      "a2",
+      "11"
+    ],
+    [
+      "2",
+      "*OSO/3=O/3=O"
+    ],
+    [
+      "m",
+      "?-"
+    ],
+    [
+      "g",
+      "4-h1"
+    ],
+    [
+      "r",
+      "1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?}-{a?|b?|c?|d?|e?|f?|g?|h?|i",
+      "?"
+    ],
+    [
+      "g",
+      "2-"
+    ],
+    [
+      "a",
+      "5"
+    ],
+    [
+      "g",
+      "3-"
+    ],
+    [
+      "3",
+      "4"
+    ],
+    [
+      "m-1",
+      "b"
+    ],
+    [
+      "k?-",
+      "l1"
+    ],
+    [
+      "f?-",
+      "g2"
+    ],
+    [
+      "a212",
+      "h-1b"
+    ],
+    [
+      "C",
+      "/"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?}-{a?|b?|c?|d?|e?|f?|g?|h",
+      "?"
+    ],
+    [
+      "Aad1122h-2",
+      "a"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|",
+      "C"
+    ],
+    [
+      "i4-",
+      "j1"
+    ],
+    [
+      "Aad1122h-2",
+      "x"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?}-{",
+      "a?|b?|c?|d?|e?|f?|g"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?}-{a?|b?|c?|d?|e?|f?|g",
+      "?"
+    ],
+    [
+      "d",
+      "6-"
+    ],
+    [
+      "h2-",
+      "i1"
+    ],
+    [
+      "2*N",
+      "SO/3=O/3=O"
+    ],
+    [
+      "*OP",
+      "^XO"
+    ],
+    [
+      "2",
+      "*OC(CCCCCC$4)"
+    ],
+    [
+      "a2211",
+      "m-1x"
+    ],
+    [
+      "a",
+      "x"
+    ],
+    [
+      "f",
+      "4-"
+    ],
+    [
+      "4",
+      "|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?}-{",
+      "a?|b?|c?|d?|e?|f"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?}-{a?|b?|c?|d?|e?|f",
+      "?"
+    ],
+    [
+      "f4-",
+      "g1"
+    ],
+    [
+      "l?-",
+      "m1"
+    ],
+    [
+      "e",
+      "2-"
+    ],
+    [
+      "*O",
+      "CC"
+    ],
+    [
+      "AUdxxxx",
+      "xh"
+    ],
+    [
+      "h2",
+      "122h"
+    ],
+    [
+      "e2-",
+      "f1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w",
+      "?"
+    ],
+    [
+      "b",
+      "2"
+    ],
+    [
+      "i",
+      "2-"
+    ],
+    [
+      "4",
+      "*OC(CCCCCC$4)"
+    ],
+    [
+      "g2-",
+      "h1"
+    ],
+    [
+      "a212",
+      "h-1x"
+    ],
+    [
+      "j",
+      "4-"
+    ],
+    [
+      "l",
+      "4-"
+    ],
+    [
+      "g3-",
+      "h1"
+    ],
+    [
+      "6",
+      "*OC(CCCCCC$4)"
+    ],
+    [
+      "a2122A-1",
+      "x"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|",
+      "D"
+    ],
+    [
+      "e",
+      "2"
+    ],
+    [
+      "O",
+      "/"
+    ],
+    [
+      "i2-",
+      "j1"
+    ],
+    [
+      "i",
+      "3-"
+    ],
+    [
+      "a5",
+      "-b1"
+    ],
+    [
+      "e4-",
+      "g1"
+    ],
+    [
+      "a?|b?|c?|d?|e",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?}-{",
+      "a?|b?|c?|d?|e"
+    ],
+    [
+      "a?|b?|c?|d?|e?}-{a?|b?|c?|d?|e",
+      "?"
+    ],
+    [
+      "f",
+      "6-"
+    ],
+    [
+      "/3",
+      "C"
+    ],
+    [
+      "s",
+      "1"
+    ],
+    [
+      "j4-",
+      "k1"
+    ],
+    [
+      "xh-1",
+      "u"
+    ],
+    [
+      "h2",
+      "112h"
+    ],
+    [
+      "h",
+      "3-"
+    ],
+    [
+      "c6-",
+      "h1"
+    ],
+    [
+      "k",
+      "2-"
+    ],
+    [
+      "3",
+      "*OSO/3=O/3=O"
+    ],
+    [
+      "l4-",
+      "m1"
+    ],
+    [
+      "j",
+      "2"
+    ],
+    [
+      "2-",
+      "5"
+    ],
+    [
+      "a212",
+      "1"
+    ],
+    [
+      "d1",
+      "122h"
+    ],
+    [
+      "a4-",
+      "c1"
+    ],
+    [
+      "AU",
+      "d1122h"
+    ],
+    [
+      "n",
+      "?-"
+    ],
+    [
+      "8",
+      "-"
+    ],
+    [
+      "*OP^XO",
+      "CCN"
+    ],
+    [
+      "2",
+      "*OC"
+    ],
+    [
+      "a?|b?|c?|d",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?}-{",
+      "a?|b?|c?|d"
+    ],
+    [
+      "a?|b?|c?|d?}-{a?|b?|c?|d",
+      "?"
+    ],
+    [
+      "a",
+      "xx"
+    ],
+    [
+      "7",
+      "-"
+    ],
+    [
+      "uxxxx",
+      "xh"
+    ],
+    [
+      "f",
+      "2-"
+    ],
+    [
+      "c6-",
+      "g1"
+    ],
+    [
+      "j",
+      "2-"
+    ],
+    [
+      "2",
+      "*OC(CCCCCC$4)/3=O"
+    ],
+    [
+      "f",
+      "2"
+    ],
+    [
+      "k",
+      "4-"
+    ],
+    [
+      "m?-",
+      "n1"
+    ],
+    [
+      "4",
+      "*OSO/3=O/3=O"
+    ],
+    [
+      "f2-",
+      "g1"
+    ],
+    [
+      "*O",
+      "S"
+    ],
+    [
+      "h3-",
+      "i1"
+    ],
+    [
+      "22",
+      "2"
+    ],
+    [
+      "k2-",
+      "l1"
+    ],
+    [
+      "1221",
+      "h"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|",
+      "E"
+    ],
+    [
+      "axxxx",
+      "m-1x"
+    ],
+    [
+      "i",
+      "2"
+    ],
+    [
+      "u1",
+      "1221h"
+    ],
+    [
+      "4",
+      "*OPO/3O/3=O"
+    ],
+    [
+      "3",
+      "34"
+    ],
+    [
+      "b6-",
+      "c1"
+    ],
+    [
+      "c6-",
+      "i1"
+    ],
+    [
+      "d4-",
+      "h1"
+    ],
+    [
+      "d?-",
+      "h1"
+    ],
+    [
+      "o",
+      "?-"
+    ],
+    [
+      "k",
+      "2"
+    ],
+    [
+      "6",
+      "*OC"
+    ],
+    [
+      "a1122",
+      "2"
+    ],
+    [
+      "c?-",
+      "i1"
+    ],
+    [
+      "a",
+      "122h-1"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|",
+      "F"
+    ],
+    [
+      "c?-",
+      "h1"
+    ],
+    [
+      "3",
+      "*OC(CCCCCC$4)/3=O"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|",
+      "G"
+    ],
+    [
+      "i3-",
+      "j1"
+    ],
+    [
+      "4",
+      "*OC"
+    ],
+    [
+      "h",
+      "a"
+    ],
+    [
+      "j2-",
+      "k1"
+    ],
+    [
+      "j",
+      "3-"
+    ],
+    [
+      "a",
+      "4"
+    ],
+    [
+      "6",
+      "|"
+    ],
+    [
+      "*OP^XOCCN",
+      "/3O/3=O"
+    ],
+    [
+      "C/",
+      "4"
+    ],
+    [
+      "a2112",
+      "A-1a"
+    ],
+    [
+      "m",
+      "4-"
+    ],
+    [
+      "n",
+      "2"
+    ],
+    [
+      "c6-",
+      "k1"
+    ],
+    [
+      "k4-",
+      "l1"
+    ],
+    [
+      "a",
+      "d"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?}-{",
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x",
+      "?"
+    ],
+    [
+      "t",
+      "1"
+    ],
+    [
+      "a2",
+      "1"
+    ],
+    [
+      "4",
+      "*N"
+    ],
+    [
+      "u2",
+      "211"
+    ],
+    [
+      "a?|b?|c",
+      "?}-{"
+    ],
+    [
+      "a?|b?|c?}-{",
+      "a?|b?|c"
+    ],
+    [
+      "a?|b?|c?}-{a?|b?|c",
+      "?"
+    ],
+    [
+      "a",
+      "12"
+    ],
+    [
+      "CCCC",
+      "CCCC"
+    ],
+    [
+      "g",
+      "6-"
+    ],
+    [
+      "f3-",
+      "g2"
+    ],
+    [
+      "u2211",
+      "m"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|",
+      "H"
+    ],
+    [
+      "5",
+      "-"
+    ],
+    [
+      "ha",
+      "122h-2"
+    ],
+    [
+      "e",
+      "6-"
+    ],
+    [
+      "h",
+      "6-"
+    ],
+    [
+      "3|",
+      "g"
+    ],
+    [
+      "c6-",
+      "d1"
+    ],
+    [
+      "4",
+      "*OC(CCCCCC$4)/3=O"
+    ],
+    [
+      "3",
+      "*NCC/3=O"
+    ],
+    [
+      "2-",
+      "?"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H",
+      "?|"
+    ],
+    [
+      "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|",
+      "I"
+    ],
+    [
+      "?}",
+      "*OC"
+    ],
+    [
+      "C",
+      "/3=O"
+    ],
+    [
+      "i",
+      "6-"
+    ],
+    [
+      "c?-",
+      "k1"
+    ],
+    [
+      "c?-",
+      "g1"
+    ],
+    [
+      "l",
+      "2-"
+    ],
+    [
+      "a2",
+      "2"
+    ]
+  ],
+  "metadata": {
+    "vocab_size": 590,
+    "num_merges": 500
+  }
+}

releases/2026-10-02/bertose_source/data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_authority.json

@@ -0,0 +1,511 @@
+{
+  "artifacts": {
+    "development_expansion_manifest": {
+      "bytes": 2467731,
+      "name": "review_ms_acquisition_top30_development_expansion.tsv.gz",
+      "sha256": "f337cc115011dbdb2040f01142de00f42a28a68218a7441f721cd76b74a18753"
+    },
+    "parent_manifest": {
+      "bytes": 78127,
+      "name": "review_ms_acquisition_top30_parents.tsv.gz",
+      "sha256": "10dc3fa7622e2a7e448d775f4082fdc84aa0622f9a7a74bcfaeed491c0eb7d39"
+    },
+    "row_manifest": {
+      "bytes": 65148547,
+      "name": "review_ms_acquisition_top30_rows.tsv.gz",
+      "sha256": "cf1dd59bd0b11525e643b2b44e60ff3bebc374e83d671365f4d5ec1f1e2d3a49"
+    },
+    "target_ids": {
+      "bytes": 26045132,
+      "name": "review_ms_acquisition_top30_target_ids_u16le.bin",
+      "sha256": "1d545f3d1ed77111f04298c632885b0809879ccc1dc4103c4ffc6f947a4bd472"
+    },
+    "target_offsets": {
+      "bytes": 1800456,
+      "name": "review_ms_acquisition_top30_target_offsets_u64le.bin",
+      "sha256": "42eb4beae41b9ec821e1fcc0cf18d8f36041d6e2075605012c3f9070fca750cd"
+    }
+  },
+  "counts": {
+    "active_acquisition_count": 225056,
+    "active_parent_count": 3035,
+    "active_target_token_count": 13022566,
+    "development_acquisition_count": 49573,
+    "development_parent_count": 580,
+    "train_acquisition_count": 175483,
+    "train_parent_count": 2455
+  },
+  "development_expansion_contract": {
+    "eligible_acquisition_count": 49573,
+    "eligible_parent_count": 580,
+    "every_eligible_ms_acquisition_required_for_each_output": true,
+    "ms_factorized_weight": "1/580 * 1/N_acquisition(parent)",
+    "ms_lane_acquisition_expansion_outputs": [
+      "sequence",
+      "ms"
+    ],
+    "ms_local_reduction": "family mean within acquisition, acquisition mean within MS parent, then equal over 580 MS parents",
+    "replay_sha256": "e50dc962240b622d0cedfc42db0f1653d639bbd4a4f956ed611817222b84d453",
+    "schema": "bertose_a5_ms_development_expansion_v2",
+    "sequence_global_reduction": "equal parents over full eligible sequence development roster; composite-owned",
+    "sequence_ms_parent_reduction": "mean_acquisition within MS parent",
+    "sequence_no_ms_parent_view": "one no-MS view",
+    "sequence_source": "post-fusion shared_hidden",
+    "sequence_within_ms_parent_weight": "1/N_acquisition(parent); global parent denominator is composite-owned",
+    "static_development_nesting": "state within parent, then equal parents; separate from acquisition expansion",
+    "topology_code_evidence": "review_a5_composite_model_v2_r3.py SHA-256 ee62f065fb347d3967228bf2a17caad9f2e6c0bbb1c387ca2bebefec9713f90b: seq_logits uses shared_hidden at line 2037; topology_v2 receives seq_hidden_base at lines 2041-2046",
+    "topology_development_nesting": "pre-fusion seq_hidden_base; once per eligible topology parent on the full topology roster; never acquisition-expanded or restricted to MS parents",
+    "topology_roster_ownership": "composite must replay every eligible topology development parent exactly once; MS package supplies no topology roster filter"
+  },
+  "implementation": {
+    "bytes": 43711,
+    "name": "review_a5_ms_acquisition_top30_runtime_v3.py",
+    "sha256": "68c0d543c5411276ef56c7072bded4ebda886f46b9fa4ebf3c95c1e54c1a08c6"
+  },
+  "inputs": {
+    "count_child_authority": {
+      "bytes": 15090,
+      "name": "review_a5_ms_top30_count_child_authority.json",
+      "sha256": "70a38dffb73aa9a482bc2227dd874862896453b7a45e3441f2aa97ea9ac9fab9"
+    },
+    "count_child_evidence": {
+      "bytes": 820,
+      "name": "review_a5_ms_top30_count_delta_evidence.tsv.gz",
+      "sha256": "dbdc6bbe0e8c4e17ab30908aaa510a09c522a8c4f8d154efac21b60a1453b2a8"
+    },
+    "count_child_independent_certificate": {
+      "bytes": 2078,
+      "name": "review_a5_ms_top30_count_child_authority_independent_audit.json",
+      "sha256": "c708f81a39706a9af86bbf5fe2d859a53de19f565b9f4eae2ff12f62a066513e"
+    },
+    "count_child_receipt": {
+      "bytes": 9916,
+      "name": "review_a5_ms_top30_count_child_receipt.json",
+      "sha256": "1bd22e3d7ac9312db567fdd9357b30e853ada4e7a5e2d23478f864422c3c7b15"
+    },
+    "design_independent_certificate": {
+      "bytes": 5889,
+      "name": "review_a5_ms_acquisition_top30_independent_audit_r2.json",
+      "sha256": "158450a27ae9bb642c010d5a2275adacef491bcf14a0ba227beb96cc2eaaaa5f"
+    },
+    "design_manifest": {
+      "bytes": 105029603,
+      "name": "review_a5_ms_acquisition_top30_manifest.tsv.gz",
+      "sha256": "bfe12eb3100552039dd18b217c899e15c75174b314b624deb72e320edc873e97"
+    },
+    "design_receipt": {
+      "bytes": 6517,
+      "name": "review_a5_ms_acquisition_top30_receipt.json",
+      "sha256": "86913823e6c5c14924735575dffac37ec4264ec130b0eaafda05226f4a87880e"
+    },
+    "design_summary": {
+      "bytes": 21986,
+      "name": "review_a5_ms_acquisition_top30_summary.json",
+      "sha256": "2fb09f48f204ed8fbf5edb8b109eba880b7de60ff40ce54f3d30cb41294a3211"
+    },
+    "design_superseded_metadata_certificate": {
+      "bytes": 5470,
+      "name": "review_a5_ms_acquisition_top30_independent_audit.json",
+      "sha256": "dff09234ed4b6550bf5c9f17e32e2e4f356aaa18efb2a7a21e70ac9f568e6338"
+    },
+    "design_train_only_null": {
+      "bytes": 8878,
+      "name": "review_a5_ms_acquisition_top30_train_only_null.json",
+      "sha256": "2f68b42c9201011a078ea806199fdf151473b4b6ff38a9273f1a53a63fed4493"
+    },
+    "raw_clean_double_build_certificate": {
+      "bytes": 4617,
+      "name": "review_a5_ms_raw_to_top30_clean_double_build_r3_certificate.json",
+      "sha256": "f92f2c0c56acddbdf818d015cd8f7d9d99c0b98535c97624116fe92f7b9cb28e"
+    },
+    "raw_end_to_end_receipt": {
+      "bytes": 11189,
+      "name": "review_a5_ms_raw_to_top30_end_to_end_receipt.json",
+      "sha256": "98c4bbf1088e28a0a56593fc66796ffba75235755c72adfe6e02f59c0f4a48e7"
+    },
+    "raw_publication_certificate": {
+      "bytes": 7603,
+      "name": "review_a5_ms_raw_to_top30_published_r3_certificate.json",
+      "sha256": "d9f5845940f57af88d212d395bf90bcd4e8d5728d88060c460ad0784390a1bd5"
+    },
+    "raw_transformation_authority": {
+      "bytes": 732729924,
+      "name": "review_a5_ms_primary_runtime_transformation_authority.tsv.gz",
+      "sha256": "d3c16f4bdbe8b35440855d1c83287c5bda12d512ec3b89ba0ca312829dddb7f4"
+    },
+    "raw_transformation_authority_receipt": {
+      "bytes": 1367,
+      "name": "review_a5_ms_primary_runtime_transformation_authority_receipt.json",
+      "sha256": "e82ceec1a94ec2f250d28e4ed37e818aee234eb132ece9fec03f43fabc9d6378"
+    }
+  },
+  "join_keys": {
+    "canonical_parent_identity": "canonical_wurcs",
+    "model_parent": "parent_glycorpus_id",
+    "physical_acquisition": "acquisition_identity_sha256",
+    "provenance_only": [
+      "source_record_identity",
+      "source_record_identity_sha256",
+      "source_raw_numeric_coordinate_sha256",
+      "ledger_positive_parser_projection_sha256",
+      "raw_coordinate_container_sha256",
+      "raw_container_locator",
+      "raw_transformation_row_surface_sha256"
+    ],
+    "source_row": "row_key"
+  },
+  "nova_jobs_submitted": false,
+  "null_ruler": {
+    "acquisition_count": 175483,
+    "atomic_record": "parent_glycorpus_id + acquisition_identity_sha256 + family + peak-pair label",
+    "development_rows_used_for_fit": 0,
+    "family_conditional_marginal_weight_formula": "1/N_parent * 1/N_acquisition(parent) * 1/N_peak_pair(acquisition); the common family factor 1/2 cancels after conditioning on family",
+    "family_mean_parent_risks": {
+      "intensity": 0.9538678814156866,
+      "mz": 5.058329202544485
+    },
+    "family_probabilities": {
+      "intensity": [
+        0.5197177353428715,
+        0.36756454029956603,
+        0.1127177243575615
+      ],
+      "mz": [
+        0.0006405498650642573,
+        0.0006021252988097924,
+        0.0009749945211706317,
+        0.0012252351748472381,
+        0.0014919905269334868,
+        0.0015897223541305183,
+        0.0018750290482665633,
+        0.0022325092284391297,
+        0.0034832951393886616,
+        0.0030005874190584293,
+        0.0031870148335501544,
+        0.002153589976904484,
+        0.006199135195682838,
+        0.0025635386139654104,
+        0.005081629903518679,
+        0.0021085111949207445,
+        0.0049675443759019215,
+        0.0026602408560569084,
+        0.004910147907424021,
+        0.0033596265935932593,
+        0.007460028144741095,
+        0.007342316510259218,
+        0.009383699893628727,
+        0.0035924973862568356,
+        0.007300624112203328,
+        0.003492257441496713,
+        0.007360542338169046,
+        0.007382295095945736,
+        0.014832571097070722,
+        0.004265176358855978,
+        0.010263477266301528,
+        0.0037736525044596487,
+        0.010357919182143932,
+        0.003968945641000579,
+        0.009871247361505384,
+        0.004710725207575534,
+        0.006315269663161841,
+        0.005157638724597456,
+        0.007760572611057847,
+        0.007187969630144797,
+        0.0064124494773172445,
+        0.005628045100877154,
+        0.011602968806865377,
+        0.010493624967610124,
+        0.014841790030570219,
+        0.006582790521429821,
+        0.00750222517517576,
+        0.010939826561705971,
+        0.011289749262542014,
+        0.009076003093031543,
+        0.01059155518012925,
+        0.006798531213847085,
+        0.006580023268606618,
+        0.006625866180657642,
+        0.00809072231972558,
+        0.007049768301782209,
+        0.007619380290109273,
+        0.013172914049614742,
+        0.007973038587594817,
+        0.013669095027737806,
+        0.008854889943844537,
+        0.010764243344026123,
+        0.009261971480032959,
+        0.011407087221082244,
+        0.008275493172872357,
+        0.014411502711840623,
+        0.008746366070571238,
+        0.008573085716761386,
+        0.005291706775934269,
+        0.009011519952519228,
+        0.006988717495289838,
+        0.009253048598594757,
+        0.007821243894415412,
+        0.011086758968541742,
+        0.007673134347475936,
+        0.011097951070032187,
+        0.006218925559457332,
+        0.009936426882326424,
+        0.007959877939685212,
+        0.011968876654308121,
+        0.008339926878809802,
+        0.012695391772888196,
+        0.005731582712877305,
+        0.009291721965872388,
+        0.005613550406088611,
+        0.009175948267808341,
+        0.005978035242077504,
+        0.008944619689293509,
+        0.007367184276934726,
+        0.007941269958145787,
+        0.007299264060980651,
+        0.007239133563442773,
+        0.006612679564797478,
+        0.006283524080156452,
+        0.008149139416552757,
+        0.009507867376475363,
+        0.007738268726780698,
+        0.007931483865568491,
+        0.005231235554487748,
+        0.00665149206592971,
+        0.00650735399622342,
+        0.007954727132383264,
+        0.005030903411493357,
+        0.007363008031486631,
+        0.004293715643194716,
+        0.005116324444397951,
+        0.005079498064988057,
+        0.005328559680790833,
+        0.0047181521200511745,
+        0.00452701797791838,
+        0.005665956328012772,
+        0.0056135415685971725,
+        0.006477197736781981,
+        0.0044094388131974156,
+        0.004562203092508437,
+        0.003927667497232976,
+        0.00595400228271556,
+        0.0044660876335546155,
+        0.0043911564061610954,
+        0.004415206577921035,
+        0.003937588905054545,
+        0.003719985017029448,
+        0.003676435977917263,
+        0.003814600894783378,
+        0.003433020728342275,
+        0.003935725556137375,
+        0.00404266701069346,
+        0.0028970529888585088,
+        0.004150673826274117,
+        0.0032579911376673146,
+        0.004363882486274142,
+        0.004270449886008418,
+        0.0049071061870006915,
+        0.003015248951052818,
+        0.003807070235575648,
+        0.002774851223097479,
+        0.00292725217431102,
+        0.0021288821303970945,
+        0.0032297161628375686,
+        0.0028509226016853015,
+        0.0026799148798400474,
+        0.001825988019983223,
+        0.003292129599799677,
+        0.001677051151594144,
+        0.002439523654513002,
+        0.00198363535229116,
+        0.0037587177141866174,
+        0.003490935731056946,
+        0.002995263611964447,
+        0.0018092325269436526,
+        0.002247483981193846,
+        0.0024445658007253178,
+        0.002339234579099249,
+        0.0017213923060684785,
+        0.0026590153316273036,
+        0.0013800374494157537,
+        0.002284641032769585,
+        0.0011368525865265914,
+        0.0018214148728505491,
+        0.0013022046110269289,
+        0.0013966749830251343,
+        0.0015469207178817875,
+        0.0028377577479343882,
+        0.002359877651502991,
+        0.0020768239242850046,
+        0.0016799064395334328,
+        0.001560964204396998,
+        0.002849456766570763,
+        0.0018607669582667444,
+        0.002124968758476105,
+        0.0018335763283124742,
+        0.001537877313231571,
+        0.0011432679414856727,
+        0.001173615019432312,
+        0.0012124839173755315,
+        0.001279967116160827,
+        0.001498155553665475,
+        0.001122604974469808,
+        0.0014509640741489293,
+        0.0012002230758373785,
+        0.0011659033448112672,
+        0.001313358414307407,
+        0.001296550566618564,
+        0.0020724105583319057,
+        0.0015725440101973384,
+        0.0021442389022742173,
+        0.0014270560400526352,
+        0.0013324118457630541,
+        0.0009997932453970622,
+        0.0011887167011727473,
+        0.0007072343298746987,
+        0.0013301494348818492,
+        0.0006204627186076994,
+        0.00039869722720875154,
+        0.00043077402577967574,
+        0.0004672031444357866,
+        0.00039750241121630064,
+        0.0005384150176558037,
+        0.0008002933341730924,
+        0.0008629090005762214,
+        0.0006959207112273459,
+        0.00040135183128836273,
+        0.0004873041609817168,
+        0.0005243254947311232,
+        0.000664005589046579,
+        0.0004979014294268761,
+        0.0005286575931262811,
+        0.00042244525643066514,
+        0.00040993170463503857,
+        0.00039515285548507293,
+        0.00038376572004818074,
+        0.00039552561334986583,
+        0.00019519812609798947
+      ]
+    },
+    "family_target_counts": {
+      "intensity": 4770785,
+      "mz": 4770785
+    },
+    "finite_epoch_exposure_used_for_fit": false,
+    "fit_scope": "representation-clean pretraining_train acquisitions only",
+    "fixed_before_training": true,
+    "frozen_design_oracle_coefficients_preserved": true,
+    "independent_packed_recomputed_numeric_surface_sha256": "80cf1bc7092492cf486edbcff422e61c3ad77dde152b9376d79c7457f30697d1",
+    "independent_packed_recomputed_scale": 3.006098541980087,
+    "masking_estimator": "uniform without-replacement whole-peak-pair sample mean; both MZ and intensity labels are supervised for every selected pair",
+    "masking_estimator_unbiased_for_population_loss": true,
+    "maximum_absolute_difference_from_frozen_design_oracle": 4.440892098500626e-15,
+    "parent_count": 2455,
+    "population_atomic_weight_formula": "1/N_parent * 1/N_acquisition(parent) * 1/2 * 1/N_peak_pair(acquisition)",
+    "population_loss_formula": "mean_parent(mean_acquisition(0.5*(mean_peak_mz_nll + mean_peak_intensity_nll)))",
+    "pseudocount": 0.5,
+    "realized_schedule_epochs_used": [],
+    "recomputed_from_packed_primary_train_targets": true,
+    "scale": 3.006098541980086,
+    "support_kind": "all eligible pretraining_train acquisition peak-pair labels as a population expectation, not realized finite-epoch schedule exposure",
+    "target_token_count": 10243502,
+    "weighting": "equal parents, equal acquisitions within parent, equal family means within acquisition"
+  },
+  "official_submitted_artifacts_modified": false,
+  "raw_to_top30_authority_binding": {
+    "all_row_parent_role_source_acquisition_target_joins_exact": true,
+    "authority_streamed_no_follow_not_loaded_wholesale": true,
+    "packed_runtime_binding_sha256": "5fe30dfcb673f450c600af76c70a10b225d26ae35d5d3a8cc603303dd10aafdd",
+    "raw_authority_file_sha256": "d3c16f4bdbe8b35440855d1c83287c5bda12d512ec3b89ba0ca312829dddb7f4",
+    "raw_authority_whole_surface_sha256": "83fbdd24bb99332329da7b31c8412e74fef169f3c8faede9e4e09db04f9f1200",
+    "raw_publication_certificate_sha256": "d9f5845940f57af88d212d395bf90bcd4e8d5728d88060c460ad0784390a1bd5",
+    "row_count": 225056,
+    "source_raw_differs_from_positive_parser_projection_count": 351,
+    "unique_raw_transformation_row_surface_count": 225056
+  },
+  "remaining_release_boundary": "This package certifies the MS lane only. Integrated four-objective model, optimizer, static, sequence/topology, checkpoint, and cluster release gates remain external.",
+  "schedule": {
+    "arm_and_unrelated_modality_invariant": true,
+    "development_all_acquisitions": true,
+    "development_parent_equal_reduction": true,
+    "fixture_epochs": [
+      0,
+      1,
+      7,
+      17
+    ],
+    "mask_rng_key_includes_acquisition_identity": true,
+    "once_per_parent_local_cycle": true,
+    "one_acquisition_per_parent_epoch": true,
+    "parent_order_domain": "bertose-a5-ms-parent-order-v1",
+    "population_binding_sha256": "35a729fc66db5fdb440b70843bccaf557ca2674635523ceff9e440bf8d99ee91",
+    "resume_binding": [
+      "population_binding_sha256",
+      "schedule_schema",
+      "seed",
+      "epoch",
+      "global_parent_cursor",
+      "selected_prefix_sha256"
+    ],
+    "schema": "bertose_a5_ms_parent_cycle_hash_schedule_v1",
+    "seed": 43,
+    "selection_domain": "bertose-a5-ms-acquisition-view-selection-v1"
+  },
+  "schema": "bertose_a5_ms_acquisition_top30_runtime_authority_v3",
+  "scientific_launch_authorized": false,
+  "status": "PASS_RUNTIME_PACKAGE_PREPARATION_ONLY",
+  "supersession": {
+    "predecessor_preserved_without_overwrite": true,
+    "predecessor_release_status": "NO_GO_SUPERSEDED",
+    "predecessor_runtime": {
+      "bytes": 33000,
+      "name": "review_a5_ms_acquisition_top30_runtime_v2.py",
+      "sha256": "94359f20bf8040e7758d2b793d5c78a6b3045cd726143b785d7d8cbbeda6aa14"
+    },
+    "predecessor_schema": "bertose_a5_ms_acquisition_top30_runtime_v2",
+    "reason": "The predecessor accepted caller seed values for development corruption. The v3 successor exposes a separate development-mask API fixed to seed 0 and epoch 0.",
+    "successor_schema": "bertose_a5_ms_acquisition_top30_runtime_v3"
+  },
+  "target_contract": {
+    "development_mask_api": "mask_development_target(row_index)",
+    "development_mask_epoch": 0,
+    "development_mask_seed": 0,
+    "development_mask_seed_or_epoch_caller_control": false,
+    "dtype": "uint16 little-endian",
+    "envelope": "[CLS=0,GLYCAN_ID=3,PEAKS=5,(MZ=29..241,INTENSITY=26..28)+,SEP=1]",
+    "intensity_levels": {
+      "high": 28,
+      "low": 26,
+      "medium": 27
+    },
+    "mask_pair_count_formula": "max(1, floor(N_peak_pair * 3 / 20))",
+    "mask_pair_probability_denominator": 20,
+    "mask_pair_probability_numerator": 3,
+    "mask_probability_runtime_configurable": false,
+    "mask_selection": "exact rational 3/20 of physical peak pairs via floor with minimum one pair; both the MZ and intensity token of each selected pair are supervised",
+    "maximum_length": 64,
+    "padding_id_at_collation_only": 2,
+    "peak_cap": 30,
+    "per_acquisition_equal_family_loss": "0.5*(mean selected MZ token NLL + mean selected intensity token NLL)",
+    "physical_condition_used": false,
+    "predecessor_vocabulary_metadata_non_authoritative": {
+      "parent_top_k": 50,
+      "reason": "These retained vocabulary JSON fields describe predecessor construction metadata, not the R3 target grammar. R3 TOP30 selection and target bytes are bound exclusively by the raw-to-TOP30 authority.",
+      "spectrum_top_k": 50,
+      "token_schema": "parent_consensus_pair_grammar_v1"
+    },
+    "replacement_routing": {
+      "binary_float_thresholds_used": false,
+      "half_revealed_selected_pair_possible": false,
+      "mask": "exact cumulative interval [0,4/5)",
+      "random_same_family_excluding_original": "exact cumulative interval [4/5,9/10)",
+      "routing_unit": "one physical m/z+intensity peak pair",
+      "shared_route_draw_for_both_pair_tokens": true,
+      "unchanged": "exact cumulative interval [9/10,1)"
+    },
+    "retention_time_used": false,
+    "selected_mz_intensity_counts_always_equal": true,
+    "training_mask_api": "mask_target(row_index, epoch, seed)",
+    "vocabulary_mapping_authority": "fixed IDs only: LOW/MED/HIGH=26/27/28 and MZ_8..MZ_220=29..241"
+  },
+  "training_authorized": false
+}

releases/2026-10-02/bertose_source/data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_independent_certificate.json

@@ -0,0 +1,466 @@
+{
+  "authority": {
+    "bytes": 20541,
+    "name": "review_a5_ms_acquisition_top30_runtime_authority.json",
+    "sha256": "48914855c4e458ff02452ad4db3743a4fbef12221e0313584db4c2b1bd684cd4"
+  },
+  "certifier_implementation": {
+    "bytes": 49683,
+    "name": "certify_review_a5_ms_acquisition_top30_runtime_package_r3_20260721.py",
+    "sha256": "a1e2989e36876840ee10d555b1ab69e9876fb0483aec839bb5a44187e7a1122a"
+  },
+  "checks": {
+    "all_225056_active_acquisition_targets_reopened_and_rehashed": true,
+    "all_225056_rows_rejoined_to_raw_r3_parent_source_acquisition_target_and_provenance": true,
+    "all_four_ms_active_factorial_cells_mask_identical": true,
+    "all_shortest_acquisitions_pass_pair_mask_contract": true,
+    "development_all_acquisitions_parent_equal_reduction": true,
+    "development_and_finite_epoch_rows_absent_from_null_fit": true,
+    "development_mask_fixed_seed0_epoch0_and_caller_control_absent": true,
+    "development_mask_repeat_and_factorial_cell_identity_pass": true,
+    "development_mask_seed_epoch_tamper_rejected": true,
+    "development_ms_and_sequence_within_parent_weights_and_replay_hash_independently_verified": true,
+    "development_sequence_and_ms_expand_every_eligible_ms_acquisition": true,
+    "epoch16_and_epoch100_acquisition_and_target_exposure_exact": true,
+    "every_valid_target_length_has_nonempty_equal_mz_intensity_pair_supervision": true,
+    "exact_13022566_target_tokens": true,
+    "exact_3_over_20_pair_count_boundaries_n20_n40_pass": true,
+    "exact_80_10_10_replacement_route_boundaries_pass": true,
+    "exact_resume_cursor_and_prefix_binding": true,
+    "exact_top30_train2455_175483_and_development580_49573_counts": true,
+    "factorial_arm_identity_absent_from_schedule_and_mask_apis": true,
+    "five_raw_provenance_hash_fields_bound_and_tamper_evident": true,
+    "four_epoch_schedules_independently_recomputed": true,
+    "mask_rng_includes_physical_acquisition_identity": true,
+    "no_selected_peak_pair_half_revealed_by_split_routing": true,
+    "null_matches_parent_then_acquisition_expected_sampling_estimand": true,
+    "null_support_is_full_train_population_not_finite_epoch_exposure": true,
+    "one_shared_replacement_route_per_selected_physical_pair": true,
+    "predecessor_runtime_hash_preserved_and_supersession_bound": true,
+    "predecessor_top50_vocabulary_metadata_explicitly_non_authoritative": true,
+    "random_replacement_same_family_and_excludes_original": true,
+    "shortest_acquisition_1024_seed_hash_sweep_passes": true,
+    "source_row_and_physical_acquisition_identifiers_unique": true,
+    "static_state_then_parent_nesting_kept_separate": true,
+    "tampered_resume_cursor_rejected": true,
+    "topology_pre_fusion_not_acquisition_expanded_or_ms_restricted": true,
+    "train_only_null_independently_recomputed_from_packed_targets": true,
+    "training_and_scientific_launch_false": true,
+    "whole_pair_mask_estimator_declared_unbiased_for_null_estimand": true,
+    "within_parent_sampling_is_source_and_condition_blind": true,
+    "world_size_1_2_3_4_8_disjoint_complete": true,
+    "zero_peak_pair_probability_rejected_for_active_ms": true,
+    "zero_primary_train_development_target_hash_intersection": true
+  },
+  "counts": {
+    "role_parents": {
+      "pretraining_development": 580,
+      "pretraining_train": 2455
+    },
+    "role_rows": {
+      "pretraining_development": 49573,
+      "pretraining_train": 175483
+    },
+    "target_tokens": 13022566
+  },
+  "development_expansion": {
+    "eligible_acquisition_count": 49573,
+    "eligible_parent_count": 580,
+    "manifest": {
+      "bytes": 2467731,
+      "name": "review_ms_acquisition_top30_development_expansion.tsv.gz",
+      "sha256": "f337cc115011dbdb2040f01142de00f42a28a68218a7441f721cd76b74a18753"
+    },
+    "ms_factorized_weight": "1/580 * 1/N_acquisition(parent)",
+    "ms_lane_acquisition_expansion_outputs": [
+      "sequence",
+      "ms"
+    ],
+    "replay_sha256": "e50dc962240b622d0cedfc42db0f1653d639bbd4a4f956ed611817222b84d453",
+    "sequence_within_ms_parent_weight": "1/N_acquisition(parent); global parent denominator is composite-owned",
+    "static_development_nesting": "state within parent, then equal parents; separate from acquisition expansion",
+    "topology_development_nesting": "pre-fusion seq_hidden_base; once per eligible topology parent on the full topology roster; never acquisition-expanded or restricted to MS parents"
+  },
+  "development_fixed_mask_sha256": "6e63678cd8ddb4529370398e64e4b8819acefc90481f6a74ffb8e487486869ae",
+  "development_parent_equal_fixture": 8.197980484692945,
+  "finite_window_exposure": {
+    "epoch_windows": {
+      "100": {
+        "absolute_relative_null_difference": 6.160079253677961e-06,
+        "declared_full_train_expected_null_scale": 3.006098541980086,
+        "epochs": 100,
+        "presentation_condition_signature_present_counts": {
+          "absent": 234200,
+          "present": 11300
+        },
+        "presentation_count": 245500,
+        "presentation_source_counts": {
+          "bounded": 87400,
+          "candy_cc2_test": 11300,
+          "gap_rescue": 900,
+          "legacy": 145900
+        },
+        "realized_minus_expected_null": -1.8517805262963094e-05,
+        "realized_schedule_null_risk": 3.006080024174823,
+        "unique_acquisition_condition_signature_present_counts": {
+          "absent": 55933,
+          "present": 4959
+        },
+        "unique_acquisition_count": 60892,
+        "unique_acquisition_coverage_fraction": 0.34699657516682525,
+        "unique_acquisition_source_counts": {
+          "bounded": 1225,
+          "candy_cc2_test": 4959,
+          "gap_rescue": 10,
+          "legacy": 54698
+        },
+        "unique_parent_target_pair_count": 60568,
+        "unique_target_hash_count": 60361,
+        "unique_target_hash_coverage_fraction": 0.3470538856052069
+      },
+      "16": {
+        "absolute_relative_null_difference": 9.750531018454421e-05,
+        "declared_full_train_expected_null_scale": 3.006098541980086,
+        "epochs": 16,
+        "presentation_condition_signature_present_counts": {
+          "absent": 37472,
+          "present": 1808
+        },
+        "presentation_count": 39280,
+        "presentation_source_counts": {
+          "bounded": 13984,
+          "candy_cc2_test": 1808,
+          "gap_rescue": 144,
+          "legacy": 23344
+        },
+        "realized_minus_expected_null": 0.0002931105707810744,
+        "realized_schedule_null_risk": 3.006391652550867,
+        "unique_acquisition_condition_signature_present_counts": {
+          "absent": 17362,
+          "present": 1286
+        },
+        "unique_acquisition_count": 18648,
+        "unique_acquisition_coverage_fraction": 0.1062667038972436,
+        "unique_acquisition_source_counts": {
+          "bounded": 1225,
+          "candy_cc2_test": 1286,
+          "gap_rescue": 10,
+          "legacy": 16127
+        },
+        "unique_parent_target_pair_count": 18598,
+        "unique_target_hash_count": 18490,
+        "unique_target_hash_coverage_fraction": 0.10631080241944757
+      }
+    },
+    "finite_window_interpretation": "The deterministic seed-43 realization is label-blind within parent. Source-level presentation frequencies reflect equal parent weighting, not the global acquisition histogram.",
+    "finite_window_null_alignment_rule": "Absolute realized-minus-population null difference divided by the fixed population null scale must be below 1e-4; exact finite-window equality is not expected.",
+    "global_acquisition_proportional_sampling": false,
+    "global_acquisition_to_target_redundancy_count": 1559,
+    "global_parent_target_pair_count": 174489,
+    "global_unique_target_hash_count": 173924,
+    "maximum_acquisitions_per_parent": 5116,
+    "parents_with_more_than_100_acquisitions": 315,
+    "parents_with_multiple_source_families": 0,
+    "sampling_estimand": "equal parents; within each parent, acquisition-uniform SHA-256 permutation without replacement per local cycle",
+    "source_or_condition_used_by_ranking": false,
+    "train_acquisition_count": 175483,
+    "within_parent_acquisition_to_target_redundancy_count": 994
+  },
+  "ms_active_cell_mask_sha256": "2a8f9e16e723407c6762ce2f36aa5bdbe326efa32575268aba2d9b738b623b37",
+  "nova_jobs_submitted": false,
+  "null_and_reducer_alignment": {
+    "aligned": true,
+    "finite_window_relative_difference_tolerance_exclusive": 0.0001,
+    "independent_packed_train_only_replay": {
+      "acquisition_count": 175483,
+      "development_rows_used": 0,
+      "family_mean_parent_risks": {
+        "intensity": 0.9538678814156855,
+        "mz": 5.058329202544489
+      },
+      "family_probabilities": {
+        "intensity": [
+          0.5197177353428725,
+          0.36756454029956576,
+          0.11271772435756178
+        ],
+        "mz": [
+          0.000640549865064257,
+          0.0006021252988097924,
+          0.0009749945211706308,
+          0.001225235174847238,
+          0.001491990526933486,
+          0.0015897223541305192,
+          0.0018750290482665644,
+          0.0022325092284391328,
+          0.003483295139388665,
+          0.003000587419058433,
+          0.0031870148335501557,
+          0.002153589976904486,
+          0.006199135195682839,
+          0.002563538613965407,
+          0.005081629903518681,
+          0.002108511194920743,
+          0.004967544375901917,
+          0.0026602408560569084,
+          0.004910147907424022,
+          0.0033596265935932584,
+          0.007460028144741085,
+          0.0073423165102591975,
+          0.009383699893628675,
+          0.003592497386256839,
+          0.007300624112203314,
+          0.003492257441496715,
+          0.007360542338169028,
+          0.007382295095945714,
+          0.014832571097070651,
+          0.004265176358855972,
+          0.010263477266301436,
+          0.0037736525044596452,
+          0.010357919182143871,
+          0.003968945641000572,
+          0.009871247361505292,
+          0.004710725207575529,
+          0.006315269663161832,
+          0.005157638724597448,
+          0.0077605726110578045,
+          0.007187969630144764,
+          0.006412449477317231,
+          0.005628045100877153,
+          0.011602968806865283,
+          0.010493624967610065,
+          0.01484179003057013,
+          0.0065827905214298045,
+          0.007502225175175732,
+          0.010939826561705892,
+          0.011289749262541926,
+          0.009076003093031464,
+          0.010591555180129155,
+          0.006798531213847064,
+          0.006580023268606611,
+          0.006625866180657621,
+          0.008090722319725546,
+          0.007049768301782186,
+          0.0076193802901092424,
+          0.01317291404961464,
+          0.007973038587594787,
+          0.013669095027737707,
+          0.00885488994384447,
+          0.010764243344026031,
+          0.009261971480032901,
+          0.011407087221082144,
+          0.008275493172872336,
+          0.01441150271184049,
+          0.008746366070571202,
+          0.00857308571676133,
+          0.005291706775934275,
+          0.009011519952519172,
+          0.006988717495289805,
+          0.009253048598594693,
+          0.007821243894415368,
+          0.011086758968541641,
+          0.007673134347475914,
+          0.011097951070032072,
+          0.0062189255594573304,
+          0.009936426882326339,
+          0.007959877939685181,
+          0.011968876654308003,
+          0.008339926878809764,
+          0.01269539177288809,
+          0.005731582712877293,
+          0.00929172196587231,
+          0.005613550406088605,
+          0.0091759482678083,
+          0.0059780352420775095,
+          0.008944619689293477,
+          0.007367184276934712,
+          0.007941269958145774,
+          0.007299264060980633,
+          0.007239133563442758,
+          0.006612679564797477,
+          0.006283524080156457,
+          0.008149139416552728,
+          0.009507867376475309,
+          0.007738268726780678,
+          0.007931483865568464,
+          0.005231235554487746,
+          0.006651492065929697,
+          0.006507353996223413,
+          0.00795472713238325,
+          0.005030903411493361,
+          0.007363008031486606,
+          0.004293715643194716,
+          0.005116324444397954,
+          0.005079498064988051,
+          0.005328559680790829,
+          0.004718152120051172,
+          0.004527017977918373,
+          0.005665956328012781,
+          0.005613541568597172,
+          0.006477197736781978,
+          0.004409438813197414,
+          0.004562203092508441,
+          0.003927667497232979,
+          0.0059540022827155575,
+          0.004466087633554613,
+          0.004391156406161099,
+          0.004415206577921035,
+          0.003937588905054544,
+          0.003719985017029452,
+          0.003676435977917266,
+          0.003814600894783379,
+          0.003433020728342273,
+          0.003935725556137382,
+          0.0040426670106934615,
+          0.0028970529888585096,
+          0.004150673826274122,
+          0.0032579911376673194,
+          0.004363882486274141,
+          0.004270449886008421,
+          0.004907106187000692,
+          0.0030152489510528215,
+          0.0038070702355756493,
+          0.0027748512230974798,
+          0.0029272521743110213,
+          0.0021288821303970962,
+          0.0032297161628375743,
+          0.0028509226016853032,
+          0.002679914879840049,
+          0.0018259880199832242,
+          0.0032921295997996778,
+          0.001677051151594143,
+          0.0024395236545130036,
+          0.0019836353522911625,
+          0.003758717714186613,
+          0.0034909357310569456,
+          0.002995263611964451,
+          0.0018092325269436543,
+          0.0022474839811938456,
+          0.00244456580072532,
+          0.00233923457909925,
+          0.0017213923060684793,
+          0.0026590153316273075,
+          0.0013800374494157535,
+          0.002284641032769587,
+          0.001136852586526592,
+          0.0018214148728505498,
+          0.0013022046110269284,
+          0.001396674983025135,
+          0.0015469207178817877,
+          0.002837757747934389,
+          0.002359877651502992,
+          0.002076823924285004,
+          0.0016799064395334354,
+          0.001560964204396998,
+          0.002849456766570762,
+          0.001860766958266745,
+          0.0021249687584761062,
+          0.0018335763283124761,
+          0.0015378773132315709,
+          0.0011432679414856723,
+          0.0011736150194323123,
+          0.001212483917375532,
+          0.001279967116160827,
+          0.0014981555536654756,
+          0.001122604974469808,
+          0.0014509640741489289,
+          0.0012002230758373783,
+          0.001165903344811268,
+          0.0013133584143074069,
+          0.0012965505666185648,
+          0.0020724105583319074,
+          0.0015725440101973375,
+          0.0021442389022742194,
+          0.0014270560400526345,
+          0.0013324118457630544,
+          0.0009997932453970622,
+          0.0011887167011727473,
+          0.0007072343298746989,
+          0.0013301494348818492,
+          0.0006204627186076996,
+          0.00039869722720875164,
+          0.00043077402577967584,
+          0.00046720314443578676,
+          0.00039750241121630064,
+          0.0005384150176558039,
+          0.0008002933341730924,
+          0.0008629090005762214,
+          0.0006959207112273458,
+          0.00040135183128836295,
+          0.0004873041609817168,
+          0.0005243254947311233,
+          0.000664005589046579,
+          0.0004979014294268762,
+          0.000528657593126281,
+          0.00042244525643066514,
+          0.0004099317046350386,
+          0.00039515285548507293,
+          0.00038376572004818085,
+          0.0003955256133498657,
+          0.00019519812609798947
+        ]
+      },
+      "family_target_counts": {
+        "intensity": 4770785,
+        "mz": 4770785
+      },
+      "finite_epoch_schedule_used": false,
+      "maximum_absolute_difference_from_declared_runtime_null": 4.440892098500626e-15,
+      "parent_count": 2455,
+      "scale": 3.006098541980087,
+      "target_token_count": 10243502
+    },
+    "ms_local_development_reducer": "equal MS parents then equal acquisitions within MS parent",
+    "null_scale": 3.006098541980086,
+    "null_weighting": "equal parents, equal acquisitions within parent, equal family means within acquisition",
+    "population_atomic_weight_formula": "1/N_parent * 1/N_acquisition(parent) * 1/2 * 1/N_peak_pair(acquisition)",
+    "support_kind": "all eligible pretraining_train acquisition peak-pair labels as a population expectation, not realized finite-epoch schedule exposure",
+    "training_schedule_expectation": "equal parents then equal acquisitions within parent"
+  },
+  "official_submitted_artifacts_modified": false,
+  "raw_authority_binding": {
+    "all_source_parent_acquisition_target_and_provenance_fields_match": true,
+    "raw_authority": {
+      "bytes": 732729924,
+      "name": "review_a5_ms_primary_runtime_transformation_authority.tsv.gz",
+      "sha256": "d3c16f4bdbe8b35440855d1c83287c5bda12d512ec3b89ba0ca312829dddb7f4"
+    },
+    "row_count": 225056,
+    "source_raw_differs_from_positive_projection_count": 351,
+    "streamed_no_follow_not_loaded_wholesale": true,
+    "unique_row_surface_count": 225056
+  },
+  "receipt": {
+    "bytes": 6260,
+    "name": "review_a5_ms_acquisition_top30_runtime_receipt.json",
+    "sha256": "f654177eb6fde7289b6755812c2be298084697cf0d85159b3ec9da310fe3d4b4"
+  },
+  "release_boundary": "MS lane is independently promotable into the isolated eight-cell integration bundle; global training/scientific launch remains false until every other objective and execution gate passes.",
+  "resume_cursor_fixture": {
+    "authority_sha256": "48914855c4e458ff02452ad4db3743a4fbef12221e0313584db4c2b1bd684cd4",
+    "epoch": 11,
+    "global_parent_cursor": 1337,
+    "global_parent_order_sha256": "b9efe4846a7ed24e681342982393f387ac37daf95e95e963b7f76e1131d59819",
+    "population_binding_sha256": "35a729fc66db5fdb440b70843bccaf557ca2674635523ceff9e440bf8d99ee91",
+    "receipt_sha256": "f654177eb6fde7289b6755812c2be298084697cf0d85159b3ec9da310fe3d4b4",
+    "schedule_schema": "bertose_a5_ms_parent_cycle_hash_schedule_v1",
+    "schema": "bertose_a5_ms_acquisition_top30_resume_cursor_v3",
+    "seed": 43,
+    "selected_prefix_sha256": "40076d2d1390fa7225cfbb9f37e177d16bc32eded92447b567b9265c91ab87f9"
+  },
+  "runtime_implementation": {
+    "bytes": 43711,
+    "name": "review_a5_ms_acquisition_top30_runtime_v3.py",
+    "sha256": "68c0d543c5411276ef56c7072bded4ebda886f46b9fa4ebf3c95c1e54c1a08c6"
+  },
+  "schedule_fixture_sha256_by_epoch": {
+    "0": "c9f2332c62840aa0c2e4bcbafdfff9abfd7cb2a2c4bfb0847a6b176aa9b9eed1",
+    "1": "f209078a76268d07409838423889de542e782f53355747c1940aeac497331772",
+    "17": "dc7a6debb69e6d5f995173def4066d139da51b9e7198779556211abbdbf75872",
+    "7": "33c8498639d1f0a338e9aeb90708a67f90649ce84f3c5dcd51663ae4eb19315d"
+  },
+  "schema": "bertose_a5_ms_acquisition_top30_runtime_independent_certificate_v3",
+  "scientific_launch_authorized": false,
+  "status": "PASS_MS_TOP30_LANE_RUNTIME_CERTIFIED_INTEGRATED_LAUNCH_CLOSED",
+  "training_authorized": false
+}

releases/2026-10-02/bertose_source/data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_receipt.json

@@ -0,0 +1,150 @@
+{
+  "artifacts": {
+    "development_expansion_manifest": {
+      "bytes": 2467731,
+      "name": "review_ms_acquisition_top30_development_expansion.tsv.gz",
+      "sha256": "f337cc115011dbdb2040f01142de00f42a28a68218a7441f721cd76b74a18753"
+    },
+    "parent_manifest": {
+      "bytes": 78127,
+      "name": "review_ms_acquisition_top30_parents.tsv.gz",
+      "sha256": "10dc3fa7622e2a7e448d775f4082fdc84aa0622f9a7a74bcfaeed491c0eb7d39"
+    },
+    "row_manifest": {
+      "bytes": 65148547,
+      "name": "review_ms_acquisition_top30_rows.tsv.gz",
+      "sha256": "cf1dd59bd0b11525e643b2b44e60ff3bebc374e83d671365f4d5ec1f1e2d3a49"
+    },
+    "target_ids": {
+      "bytes": 26045132,
+      "name": "review_ms_acquisition_top30_target_ids_u16le.bin",
+      "sha256": "1d545f3d1ed77111f04298c632885b0809879ccc1dc4103c4ffc6f947a4bd472"
+    },
+    "target_offsets": {
+      "bytes": 1800456,
+      "name": "review_ms_acquisition_top30_target_offsets_u64le.bin",
+      "sha256": "42eb4beae41b9ec821e1fcc0cf18d8f36041d6e2075605012c3f9070fca750cd"
+    }
+  },
+  "authority": {
+    "bytes": 20541,
+    "name": "review_a5_ms_acquisition_top30_runtime_authority.json",
+    "sha256": "48914855c4e458ff02452ad4db3743a4fbef12221e0313584db4c2b1bd684cd4"
+  },
+  "implementation": {
+    "builder": {
+      "bytes": 55528,
+      "name": "build_review_a5_ms_acquisition_top30_runtime_package_r3_20260721.py",
+      "sha256": "e797638591e884cfda0053e84519e82770155ae339f531689b04e2d7993ef6d5"
+    },
+    "certifier": {
+      "bytes": 49683,
+      "name": "certify_review_a5_ms_acquisition_top30_runtime_package_r3_20260721.py",
+      "sha256": "a1e2989e36876840ee10d555b1ab69e9876fb0483aec839bb5a44187e7a1122a"
+    },
+    "runtime": {
+      "bytes": 43711,
+      "name": "review_a5_ms_acquisition_top30_runtime_v3.py",
+      "sha256": "68c0d543c5411276ef56c7072bded4ebda886f46b9fa4ebf3c95c1e54c1a08c6"
+    },
+    "tests": {
+      "bytes": 15700,
+      "name": "test_review_a5_ms_acquisition_top30_runtime_v3_20260721.py",
+      "sha256": "3ba5679eb77bb1f3ae27b168009b4af60a7d63dca71d108cb179cb017f69b64e"
+    }
+  },
+  "inputs": {
+    "count_child_authority": {
+      "bytes": 15090,
+      "name": "review_a5_ms_top30_count_child_authority.json",
+      "sha256": "70a38dffb73aa9a482bc2227dd874862896453b7a45e3441f2aa97ea9ac9fab9"
+    },
+    "count_child_evidence": {
+      "bytes": 820,
+      "name": "review_a5_ms_top30_count_delta_evidence.tsv.gz",
+      "sha256": "dbdc6bbe0e8c4e17ab30908aaa510a09c522a8c4f8d154efac21b60a1453b2a8"
+    },
+    "count_child_independent_certificate": {
+      "bytes": 2078,
+      "name": "review_a5_ms_top30_count_child_authority_independent_audit.json",
+      "sha256": "c708f81a39706a9af86bbf5fe2d859a53de19f565b9f4eae2ff12f62a066513e"
+    },
+    "count_child_receipt": {
+      "bytes": 9916,
+      "name": "review_a5_ms_top30_count_child_receipt.json",
+      "sha256": "1bd22e3d7ac9312db567fdd9357b30e853ada4e7a5e2d23478f864422c3c7b15"
+    },
+    "design_independent_certificate": {
+      "bytes": 5889,
+      "name": "review_a5_ms_acquisition_top30_independent_audit_r2.json",
+      "sha256": "158450a27ae9bb642c010d5a2275adacef491bcf14a0ba227beb96cc2eaaaa5f"
+    },
+    "design_manifest": {
+      "bytes": 105029603,
+      "name": "review_a5_ms_acquisition_top30_manifest.tsv.gz",
+      "sha256": "bfe12eb3100552039dd18b217c899e15c75174b314b624deb72e320edc873e97"
+    },
+    "design_receipt": {
+      "bytes": 6517,
+      "name": "review_a5_ms_acquisition_top30_receipt.json",
+      "sha256": "86913823e6c5c14924735575dffac37ec4264ec130b0eaafda05226f4a87880e"
+    },
+    "design_summary": {
+      "bytes": 21986,
+      "name": "review_a5_ms_acquisition_top30_summary.json",
+      "sha256": "2fb09f48f204ed8fbf5edb8b109eba880b7de60ff40ce54f3d30cb41294a3211"
+    },
+    "design_superseded_metadata_certificate": {
+      "bytes": 5470,
+      "name": "review_a5_ms_acquisition_top30_independent_audit.json",
+      "sha256": "dff09234ed4b6550bf5c9f17e32e2e4f356aaa18efb2a7a21e70ac9f568e6338"
+    },
+    "design_train_only_null": {
+      "bytes": 8878,
+      "name": "review_a5_ms_acquisition_top30_train_only_null.json",
+      "sha256": "2f68b42c9201011a078ea806199fdf151473b4b6ff38a9273f1a53a63fed4493"
+    },
+    "raw_clean_double_build_certificate": {
+      "bytes": 4617,
+      "name": "review_a5_ms_raw_to_top30_clean_double_build_r3_certificate.json",
+      "sha256": "f92f2c0c56acddbdf818d015cd8f7d9d99c0b98535c97624116fe92f7b9cb28e"
+    },
+    "raw_end_to_end_receipt": {
+      "bytes": 11189,
+      "name": "review_a5_ms_raw_to_top30_end_to_end_receipt.json",
+      "sha256": "98c4bbf1088e28a0a56593fc66796ffba75235755c72adfe6e02f59c0f4a48e7"
+    },
+    "raw_publication_certificate": {
+      "bytes": 7603,
+      "name": "review_a5_ms_raw_to_top30_published_r3_certificate.json",
+      "sha256": "d9f5845940f57af88d212d395bf90bcd4e8d5728d88060c460ad0784390a1bd5"
+    },
+    "raw_transformation_authority": {
+      "bytes": 732729924,
+      "name": "review_a5_ms_primary_runtime_transformation_authority.tsv.gz",
+      "sha256": "d3c16f4bdbe8b35440855d1c83287c5bda12d512ec3b89ba0ca312829dddb7f4"
+    },
+    "raw_transformation_authority_receipt": {
+      "bytes": 1367,
+      "name": "review_a5_ms_primary_runtime_transformation_authority_receipt.json",
+      "sha256": "e82ceec1a94ec2f250d28e4ed37e818aee234eb132ece9fec03f43fabc9d6378"
+    }
+  },
+  "official_submitted_artifacts_modified": false,
+  "schema": "bertose_a5_ms_acquisition_top30_runtime_receipt_v3",
+  "scientific_launch_authorized": false,
+  "status": "PASS_RUNTIME_BYTES_PREPARATION_ONLY",
+  "supersession": {
+    "predecessor_preserved_without_overwrite": true,
+    "predecessor_release_status": "NO_GO_SUPERSEDED",
+    "predecessor_runtime": {
+      "bytes": 33000,
+      "name": "review_a5_ms_acquisition_top30_runtime_v2.py",
+      "sha256": "94359f20bf8040e7758d2b793d5c78a6b3045cd726143b785d7d8cbbeda6aa14"
+    },
+    "predecessor_schema": "bertose_a5_ms_acquisition_top30_runtime_v2",
+    "reason": "The predecessor accepted caller seed values for development corruption. The v3 successor exposes a separate development-mask API fixed to seed 0 and epoch 0.",
+    "successor_schema": "bertose_a5_ms_acquisition_top30_runtime_v3"
+  },
+  "training_authorized": false
+}

releases/2026-10-02/bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_sequence_tree_runtime.py

@@ -0,0 +1,287 @@
+"""Fail-closed WURCS tree channels for the review-only A5 runtime.
+
+The fitted BPE vocabulary is deliberately not changed here.  This module only
+repairs deterministic transform-time annotations.  A tree depth is emitted
+only when every linkage is a full, unambiguous residue-pair token, exactly one
+endpoint of every bond is the anomeric donor, and the resulting directed graph
+is one rooted tree.  Otherwise residue tokens receive an explicit UNKNOWN
+depth while the original WURCS units remain available to BPE.
+
+This file is an isolated review runtime.  It must not be copied over the shared
+``training/a5_wurcs_bpe.py`` module.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict, deque
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from training.a5_topology import node_index, node_label
+from training.a5_wurcs_bpe import A5WURCSBPETokenizer, A5WURCSPreTokenizer
+
+
+BRANCH_DEPTH_UNKNOWN = 202
+BRANCH_DEPTH_VOCAB_SIZE = 203
+
+LINKAGE_NONE = 0
+LINKAGE_1_2 = 1
+LINKAGE_1_3 = 2
+LINKAGE_1_4 = 3
+LINKAGE_1_6 = 4
+LINKAGE_2_3 = 5
+LINKAGE_2_6 = 6
+LINKAGE_3_6 = 7
+LINKAGE_OTHER_EXACT = 8
+LINKAGE_UNKNOWN = 9
+LINKAGE_VOCAB_SIZE = 10
+
+
+@dataclass(frozen=True)
+class TreeChannelAnalysis:
+    residue_count: int
+    exact_undirected_tree: bool
+    exact_rooted_tree: bool
+    failure_reason: str
+    depths: dict[int, int]
+    branch_open_counts: dict[int, int]
+    distance_matrix: list[list[int]]
+
+
+def _distance_matrix(adjacency: dict[int, set[int]], count: int) -> list[list[int]]:
+    matrix: list[list[int]] = []
+    for source in range(count):
+        distances = {source: 0}
+        queue: deque[int] = deque([source])
+        while queue:
+            current = queue.popleft()
+            for neighbor in sorted(adjacency[current]):
+                if neighbor not in distances:
+                    distances[neighbor] = distances[current] + 1
+                    queue.append(neighbor)
+        if len(distances) != count:
+            return []
+        matrix.append([distances[target] for target in range(count)])
+    return matrix
+
+
+class ReviewA5WURCSPreTokenizerV3(A5WURCSPreTokenizer):
+    """A5 semantic units with fail-closed branch and linkage channels."""
+
+    def _sections(
+        self, wurcs: str
+    ) -> tuple[list[str], list[str], list[str], list[int | None]]:
+        parts = self._split_wurcs_sections(wurcs)
+        if len(parts) < 4:
+            return [], [], [], []
+        residue_definitions = self.RESIDUE_PATTERN.findall(parts[2])
+        index_list = parts[3].split("-") if parts[3] else []
+        linkages = parts[4].split("_") if len(parts) > 4 and parts[4] else []
+        anomeric = self._instance_anomeric_positions(residue_definitions, index_list)
+        return residue_definitions, index_list, linkages, anomeric
+
+    def analyze_tree(self, wurcs: str) -> TreeChannelAnalysis:
+        _, index_list, linkages, anomeric = self._sections(wurcs)
+        count = len(index_list)
+        if count == 0:
+            return TreeChannelAnalysis(0, False, False, "missing_residue_instances", {}, {}, [])
+        if count == 1:
+            if linkages:
+                return TreeChannelAnalysis(
+                    1, False, False, "single_residue_has_linkage_tokens", {}, {}, []
+                )
+            return TreeChannelAnalysis(1, True, True, "", {0: 0}, {}, [[0]])
+
+        adjacency: dict[int, set[int]] = {index: set() for index in range(count)}
+        directed_children: dict[int, list[int]] = defaultdict(list)
+        child_parent: dict[int, int] = {}
+        seen_edges: set[tuple[int, int]] = set()
+        orientation_failure = ""
+
+        for linkage in linkages:
+            match = self.A5_LINKAGE_PATTERN.fullmatch(linkage)
+            if match is None:
+                return TreeChannelAnalysis(
+                    count, False, False, "non_exact_linkage_token", {}, {}, []
+                )
+            left_label, left_position, right_label, right_position = match.groups()
+            try:
+                left = node_index(left_label) - 1
+                right = node_index(right_label) - 1
+            except ValueError:
+                return TreeChannelAnalysis(
+                    count, False, False, "invalid_residue_label", {}, {}, []
+                )
+            if not (0 <= left < count and 0 <= right < count) or left == right:
+                return TreeChannelAnalysis(
+                    count, False, False, "invalid_residue_edge", {}, {}, []
+                )
+            edge = tuple(sorted((left, right)))
+            if edge in seen_edges:
+                return TreeChannelAnalysis(
+                    count, False, False, "duplicate_residue_edge", {}, {}, []
+                )
+            seen_edges.add(edge)
+            adjacency[left].add(right)
+            adjacency[right].add(left)
+
+            left_is_donor = (
+                left_position != "?"
+                and anomeric[left] is not None
+                and int(left_position) == anomeric[left]
+            )
+            right_is_donor = (
+                right_position != "?"
+                and anomeric[right] is not None
+                and int(right_position) == anomeric[right]
+            )
+            if left_is_donor == right_is_donor:
+                orientation_failure = "bond_donor_not_unique"
+                continue
+            child = left if left_is_donor else right
+            parent = right if left_is_donor else left
+            if child in child_parent and child_parent[child] != parent:
+                orientation_failure = "residue_has_multiple_parents"
+                continue
+            child_parent[child] = parent
+            directed_children[parent].append(child)
+
+        if len(seen_edges) != count - 1:
+            return TreeChannelAnalysis(
+                count, False, False, "edge_count_not_residue_count_minus_one", {}, {}, []
+            )
+        distances = _distance_matrix(adjacency, count)
+        if not distances:
+            return TreeChannelAnalysis(
+                count, False, False, "residue_graph_disconnected", {}, {}, []
+            )
+        if orientation_failure:
+            return TreeChannelAnalysis(
+                count, True, False, orientation_failure, {}, {}, distances
+            )
+
+        roots = sorted(set(range(count)) - set(child_parent))
+        if len(roots) != 1:
+            return TreeChannelAnalysis(
+                count, True, False, "root_not_unique", {}, {}, distances
+            )
+        depths = {roots[0]: 0}
+        queue: deque[int] = deque([roots[0]])
+        while queue:
+            parent = queue.popleft()
+            for child in sorted(directed_children.get(parent, [])):
+                if child in depths:
+                    return TreeChannelAnalysis(
+                        count, True, False, "directed_cycle", {}, {}, distances
+                    )
+                depths[child] = depths[parent] + 1
+                queue.append(child)
+        if len(depths) != count:
+            return TreeChannelAnalysis(
+                count, True, False, "directed_tree_disconnected", {}, {}, distances
+            )
+        if max(depths.values()) >= BRANCH_DEPTH_UNKNOWN:
+            return TreeChannelAnalysis(
+                count, True, False, "exact_depth_collides_with_unknown_id", {}, {}, distances
+            )
+        branch_counts = {
+            parent: len(children) - 1
+            for parent, children in directed_children.items()
+            if len(children) > 1
+        }
+        return TreeChannelAnalysis(
+            count, True, True, "", depths, branch_counts, distances
+        )
+
+    @staticmethod
+    def exact_linkage_type(linkage: str) -> int:
+        match = ReviewA5WURCSPreTokenizerV3.A5_LINKAGE_PATTERN.fullmatch(linkage)
+        if match is None:
+            return LINKAGE_UNKNOWN
+        _, left_position, _, right_position = match.groups()
+        if left_position == "?" or right_position == "?":
+            return LINKAGE_UNKNOWN
+        positions = tuple(sorted((int(left_position), int(right_position))))
+        mapping = {
+            (1, 2): LINKAGE_1_2,
+            (1, 3): LINKAGE_1_3,
+            (1, 4): LINKAGE_1_4,
+            (1, 6): LINKAGE_1_6,
+            (2, 3): LINKAGE_2_3,
+            (2, 6): LINKAGE_2_6,
+            (3, 6): LINKAGE_3_6,
+        }
+        return mapping.get(positions, LINKAGE_OTHER_EXACT)
+
+    def pre_tokenize(self, wurcs: str) -> list[dict]:
+        # Reuse only the already-audited semantic WURCS unit extraction.  All
+        # v2 branch markers, depths, linkage classes, and distance matrices are
+        # discarded and rebuilt below.
+        inherited = super().pre_tokenize(wurcs)
+        units = [dict(unit) for unit in inherited if unit.get("text") != "[BRANCH_OPEN]"]
+        analysis = self.analyze_tree(wurcs)
+        first_unit_for_residue: set[int] = set()
+        repaired: list[dict] = []
+        for unit in units:
+            unit.pop("distance_matrix", None)
+            residue_id = int(unit.get("residue_id", -1))
+            unit["linkage_type"] = LINKAGE_NONE
+            if residue_id >= 0:
+                depth = (
+                    analysis.depths[residue_id]
+                    if analysis.exact_rooted_tree
+                    else BRANCH_DEPTH_UNKNOWN
+                )
+                unit["branch_depth"] = depth
+                if residue_id not in first_unit_for_residue:
+                    for _ in range(analysis.branch_open_counts.get(residue_id, 0)):
+                        repaired.append(
+                            {
+                                "text": "[BRANCH_OPEN]",
+                                "type": "special",
+                                "residue_id": -1,
+                                "branch_depth": depth,
+                                "linkage_type": LINKAGE_NONE,
+                            }
+                        )
+                    first_unit_for_residue.add(residue_id)
+            else:
+                unit["branch_depth"] = 0
+                if unit.get("type") == "linkage":
+                    unit["linkage_type"] = self.exact_linkage_type(str(unit["text"]))
+            repaired.append(unit)
+
+        if repaired:
+            repaired[0]["distance_matrix"] = analysis.distance_matrix
+            repaired[0]["tree_channels_valid"] = analysis.exact_rooted_tree
+            repaired[0]["tree_channel_failure_reason"] = analysis.failure_reason
+        return repaired
+
+
+class ReviewA5WURCSBPETokenizerV3(A5WURCSBPETokenizer):
+    """Existing train-only BPE vocabulary with repaired transform channels."""
+
+    def __init__(self, vocab_path: Optional[str | Path] = None) -> None:
+        super().__init__(vocab_path)
+        self.pre_tokenizer = ReviewA5WURCSPreTokenizerV3()
+
+    def tokenize_sequence(self, wurcs: str, max_length: int = 256) -> dict:
+        encoded = super().tokenize_sequence(wurcs, max_length=max_length)
+        analysis = self.pre_tokenizer.analyze_tree(wurcs)
+        encoded["tree_channels_valid"] = analysis.exact_rooted_tree
+        encoded["tree_channel_failure_reason"] = analysis.failure_reason
+        return encoded
+
+
+__all__ = [
+    "BRANCH_DEPTH_UNKNOWN",
+    "BRANCH_DEPTH_VOCAB_SIZE",
+    "LINKAGE_NONE",
+    "LINKAGE_OTHER_EXACT",
+    "LINKAGE_UNKNOWN",
+    "LINKAGE_VOCAB_SIZE",
+    "ReviewA5WURCSBPETokenizerV3",
+    "ReviewA5WURCSPreTokenizerV3",
+    "TreeChannelAnalysis",
+]

releases/2026-10-02/bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_topology.py

@@ -0,0 +1,180 @@
+"""Residue-level shortest-path targets used by the A5 topology objective."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections import deque
+
+
+EDGE_RE = re.compile(
+    r"(?P<n1>[A-Za-z]+)(?P<p1>[0-9?]+)-(?P<n2>[A-Za-z]+)(?P<p2>[0-9?]+)"
+)
+RESDEF_RE = re.compile(r"\[([^\]]*)\]")
+WURCS_RES_INDEX_ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+
+def node_label(index: int) -> str:
+    if index < 1:
+        raise ValueError("WURCS residue indices are one-based")
+    letters = WURCS_RES_INDEX_ALPHABET
+    base = len(letters)
+    index -= 1
+    label = ""
+    while True:
+        label = letters[index % base] + label
+        index = index // base - 1
+        if index < 0:
+            return label
+
+
+def node_index(label: str) -> int:
+    if not label:
+        raise ValueError("WURCS residue label cannot be empty")
+    base = len(WURCS_RES_INDEX_ALPHABET)
+    value = 0
+    for character in label:
+        try:
+            digit = WURCS_RES_INDEX_ALPHABET.index(character) + 1
+        except ValueError as error:
+            raise ValueError(f"Invalid WURCS residue label: {label}") from error
+        value = value * base + digit
+    return value
+
+
+def split_wurcs_sections(body: str) -> list[str]:
+    sections: list[str] = []
+    current: list[str] = []
+    bracket_depth = 0
+    for character in body:
+        if character == "[":
+            bracket_depth += 1
+        elif character == "]" and bracket_depth:
+            bracket_depth -= 1
+        if character == "/" and bracket_depth == 0:
+            sections.append("".join(current))
+            current = []
+        else:
+            current.append(character)
+    sections.append("".join(current))
+    return sections
+
+
+def split_wurcs(wurcs: str) -> tuple[list[str], dict[str, str], str]:
+    if not wurcs.startswith("WURCS=2.0/"):
+        return [], {}, ""
+    parts = split_wurcs_sections(wurcs[len("WURCS=2.0/") :])
+    if len(parts) < 4:
+        return [], {}, ""
+    residue_definitions = RESDEF_RE.findall(parts[1])
+    sequence = parts[2].split("-") if parts[2] else []
+    node_to_residue: dict[str, str] = {}
+    for index, value in enumerate(sequence, start=1):
+        try:
+            residue = residue_definitions[int(value) - 1]
+        except (ValueError, IndexError):
+            residue = ""
+        node_to_residue[node_label(index)] = residue
+    return residue_definitions, node_to_residue, "/".join(parts[3:])
+
+
+def _hash_fields(*values: object) -> str:
+    payload = "\x1f".join(str(value) for value in values).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def build_residue_shortest_path(wurcs: str) -> dict[str, object]:
+    """Build the same immutable residue target frozen by the P0/P1 audit."""
+    _, node_to_residue, linkage_section = split_wurcs(wurcs)
+    node_ids = list(node_to_residue)
+    if not node_ids or any(not node_to_residue[node] for node in node_ids):
+        return _failure("missing_or_unmapped_residue_sequence", len(node_ids), 0)
+    if len(node_ids) < 2:
+        return _failure(
+            "fewer_than_two_residues_no_off_diagonal_target", len(node_ids), 0
+        )
+
+    adjacency: dict[str, set[str]] = {node: set() for node in node_ids}
+    parsed_edges: list[tuple[str, str]] = []
+    unparsed_tokens: list[str] = []
+    for token in linkage_section.split("_") if linkage_section else []:
+        match = EDGE_RE.fullmatch(token)
+        if not match:
+            if token:
+                unparsed_tokens.append(token)
+            continue
+        left, right = match.group("n1"), match.group("n2")
+        if left not in adjacency or right not in adjacency or left == right:
+            unparsed_tokens.append(token)
+            continue
+        parsed_edges.append(tuple(sorted((left, right))))
+        adjacency[left].add(right)
+        adjacency[right].add(left)
+
+    reason = ""
+    if unparsed_tokens:
+        reason = "one_or_more_edge_tokens_not_unambiguous_residue_pairs"
+    elif len(set(parsed_edges)) != len(parsed_edges):
+        reason = "duplicate_residue_edge"
+    elif len(parsed_edges) != len(node_ids) - 1:
+        reason = "edge_count_not_residue_count_minus_one"
+
+    seen = {node_ids[0]}
+    queue = deque([node_ids[0]])
+    while queue:
+        node = queue.popleft()
+        for neighbor in sorted(adjacency[node]):
+            if neighbor not in seen:
+                seen.add(neighbor)
+                queue.append(neighbor)
+    if not reason and len(seen) != len(node_ids):
+        reason = "residue_graph_disconnected"
+    if reason:
+        return _failure(reason, len(node_ids), len(parsed_edges))
+
+    matrix: list[list[int]] = []
+    for source in node_ids:
+        distance = {source: 0}
+        queue = deque([source])
+        while queue:
+            node = queue.popleft()
+            for neighbor in sorted(adjacency[node]):
+                if neighbor not in distance:
+                    distance[neighbor] = distance[node] + 1
+                    queue.append(neighbor)
+        matrix.append([distance[target] for target in node_ids])
+
+    matrix_payload = json.dumps(matrix, separators=(",", ":"))
+    matrix_sha256 = hashlib.sha256(matrix_payload.encode("utf-8")).hexdigest()
+    return {
+        "target_valid": True,
+        "failure_reason": "",
+        "residue_count": len(node_ids),
+        "parsed_edge_count": len(parsed_edges),
+        "valid_unordered_pair_count": len(node_ids) * (len(node_ids) - 1) // 2,
+        "matrix": matrix,
+        "matrix_sha256": matrix_sha256,
+        "target_identity_sha256": _hash_fields(
+            "residue_shortest_path_v2",
+            wurcs,
+            matrix_sha256,
+            len(node_ids),
+            len(parsed_edges),
+        ),
+        "schema": "residue_shortest_path_v2",
+    }
+
+
+def _failure(reason: str, residues: int, edges: int) -> dict[str, object]:
+    return {
+        "target_valid": False,
+        "failure_reason": reason,
+        "residue_count": residues,
+        "parsed_edge_count": edges,
+        "valid_unordered_pair_count": 0,
+        "matrix": [],
+        "matrix_sha256": "",
+        "target_identity_sha256": "",
+        "schema": "residue_shortest_path_v2",
+    }

releases/2026-10-02/bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_wurcs_bpe.py

@@ -0,0 +1,368 @@
+"""Deterministic train-only WURCS BPE utilities for A5."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Iterable, Optional
+
+from .a5_topology import node_index, node_label
+
+try:
+    from bert_training_v4.downstream_tasks.utils.wurcs_bpe_tokenizer import (
+        WURCSBPETokenizer,
+        WURCSPreTokenizer,
+    )
+except ImportError:
+    from ..bert_training_v4.downstream_tasks.utils.wurcs_bpe_tokenizer import (
+        WURCSBPETokenizer,
+        WURCSPreTokenizer,
+    )
+
+
+SUBMITTED_FIT_ALPHABET = tuple(
+    "#$%()*-./0123456789<=>?ABCDEFGHIJKLMNOPQRSTUVWXYZ^abcdefghijklmnopqrstuvwxyz{|}~"
+)
+
+
+class _TopLevelBracketPattern:
+    """Expose regex-like findall while respecting nested SMILES brackets."""
+
+    @staticmethod
+    def findall(text: str) -> list[str]:
+        residues: list[str] = []
+        depth = 0
+        start = -1
+        for index, character in enumerate(text):
+            if character == "[":
+                if depth == 0:
+                    start = index + 1
+                depth += 1
+            elif character == "]" and depth:
+                depth -= 1
+                if depth == 0 and start >= 0:
+                    residues.append(text[start:index])
+                    start = -1
+        if depth:
+            return []
+        return residues
+
+
+class A5WURCSPreTokenizer(WURCSPreTokenizer):
+    """Submitted pre-tokenizer with nested bracket-safe residue extraction."""
+
+    A5_LINKAGE_PATTERN = re.compile(
+        r"([A-Za-z]+)(\d+|\?)-([A-Za-z]+)(\d+|\?)"
+    )
+    A5_ANOMERIC_PATTERN = re.compile(r"-([0-9]+)([abuxo])(?:_|$)")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.RESIDUE_PATTERN = _TopLevelBracketPattern()
+
+    def _split_wurcs_sections(self, wurcs: str) -> list[str]:
+        sections = super()._split_wurcs_sections(wurcs)
+        if len(sections) <= 5:
+            return sections
+        # WURCS LIN modifications may contain unbracketed slashes. The format
+        # has exactly five top-level sections, so every trailing fragment
+        # belongs to the linkage section rather than a new section.
+        return sections[:4] + ["/".join(sections[4:])]
+
+    def _instance_anomeric_positions(
+        self, residue_definitions: list[str], index_list: list[str]
+    ) -> list[int | None]:
+        positions: list[int | None] = []
+        for definition_index in index_list:
+            try:
+                residue_definition = residue_definitions[int(definition_index) - 1]
+            except (IndexError, ValueError):
+                positions.append(None)
+                continue
+            match = self.A5_ANOMERIC_PATTERN.search(residue_definition)
+            positions.append(int(match.group(1)) if match is not None else None)
+        return positions
+
+    def _analyze_a5_tree(
+        self,
+        linkages: list[str],
+        residue_count: int,
+        anomeric_positions: list[int | None] | None = None,
+    ) -> tuple[dict[str, int], dict[str, int], dict[int, list[int]]]:
+        branch_points: dict[str, int] = defaultdict(int)
+        children: dict[str, list[str]] = defaultdict(list)
+        all_residues: set[str] = set()
+        adjacency: dict[int, list[int]] = defaultdict(list)
+        for linkage in linkages:
+            match = self.A5_LINKAGE_PATTERN.match(linkage)
+            if not match:
+                continue
+            left, left_position, right, right_position = match.groups()
+            try:
+                left_index = node_index(left) - 1
+                right_index = node_index(right) - 1
+            except ValueError:
+                continue
+            if not (
+                0 <= left_index < residue_count
+                and 0 <= right_index < residue_count
+                and left_index != right_index
+            ):
+                continue
+            parent, child = left, right
+            if anomeric_positions is not None:
+                left_anomeric = anomeric_positions[left_index]
+                right_anomeric = anomeric_positions[right_index]
+                left_is_donor = (
+                    left_position != "?"
+                    and left_anomeric is not None
+                    and int(left_position) == left_anomeric
+                )
+                right_is_donor = (
+                    right_position != "?"
+                    and right_anomeric is not None
+                    and int(right_position) == right_anomeric
+                )
+                if left_is_donor and not right_is_donor:
+                    parent, child = right, left
+                elif right_is_donor and not left_is_donor:
+                    parent, child = left, right
+            children[parent].append(child)
+            all_residues.update((parent, child))
+            adjacency[left_index].append(right_index)
+            adjacency[right_index].append(left_index)
+
+        for residue, child_labels in children.items():
+            if len(child_labels) > 1:
+                branch_points[residue] = len(child_labels) - 1
+        child_set = {child for values in children.values() for child in values}
+        roots = all_residues - child_set
+        root = min(roots, key=node_index) if roots else node_label(1)
+        depths = {root: 0}
+        queue = [root]
+        while queue:
+            current = queue.pop(0)
+            for child in children.get(current, []):
+                if child not in depths:
+                    depths[child] = depths[current] + 1
+                    queue.append(child)
+        return dict(branch_points), depths, adjacency
+
+    def _a5_linkage_type(self, linkage: str) -> int:
+        match = self.A5_LINKAGE_PATTERN.match(linkage)
+        if not match:
+            return 8
+        _, from_position, _, to_position = match.groups()
+        try:
+            positions = (int(from_position), int(to_position))
+        except ValueError:
+            return 8
+        linkage_types = {
+            (1, 2): 0,
+            (2, 1): 0,
+            (1, 3): 1,
+            (3, 1): 1,
+            (1, 4): 2,
+            (4, 1): 2,
+            (1, 6): 3,
+            (6, 1): 3,
+            (2, 3): 4,
+            (3, 2): 4,
+            (2, 6): 5,
+            (6, 2): 5,
+            (3, 6): 6,
+            (6, 3): 6,
+        }
+        return linkage_types.get(positions, 7)
+
+    def pre_tokenize(self, wurcs: str) -> list[dict]:
+        # Reuse the submitted semantic split, then correct only its tree
+        # annotations. This keeps the BPE unit text and special-token behavior.
+        inherited_units = super().pre_tokenize(wurcs)
+        try:
+            parts = self._split_wurcs_sections(wurcs)
+            index_list = parts[3].split("-") if len(parts) > 3 and parts[3] else []
+            linkages = parts[4].split("_") if len(parts) > 4 and parts[4] else []
+            residue_definitions = self.RESIDUE_PATTERN.findall(parts[2])
+            anomeric_positions = self._instance_anomeric_positions(
+                residue_definitions, index_list
+            )
+            branch_points, depths, adjacency = self._analyze_a5_tree(
+                linkages, len(index_list), anomeric_positions
+            )
+        except (IndexError, ValueError):
+            return inherited_units
+
+        units: list[dict] = []
+        opened_residues: set[int] = set()
+        for inherited in inherited_units:
+            if inherited.get("text") == "[BRANCH_OPEN]":
+                continue
+            unit = dict(inherited)
+            residue_id = int(unit.get("residue_id", -1))
+            if residue_id >= 0:
+                label = node_label(residue_id + 1)
+                if residue_id not in opened_residues:
+                    for _ in range(branch_points.get(label, 0)):
+                        units.append(
+                            {
+                                "text": "[BRANCH_OPEN]",
+                                "type": "special",
+                                "residue_id": -1,
+                                "branch_depth": depths.get(label, 0),
+                                "linkage_type": 0,
+                            }
+                        )
+                    opened_residues.add(residue_id)
+                unit["branch_depth"] = depths.get(label, 0)
+            elif unit.get("type") == "linkage":
+                unit["linkage_type"] = self._a5_linkage_type(str(unit["text"]))
+            units.append(unit)
+
+        if units:
+            units[0]["distance_matrix"] = self._compute_distance_matrix(
+                adjacency, len(index_list)
+            )
+        return units
+
+
+class A5WURCSBPETokenizer(WURCSBPETokenizer):
+    """Train-only BPE with a fit-derived alphabet and deterministic merge ties."""
+
+    def __init__(self, vocab_path: Optional[str | Path] = None) -> None:
+        super().__init__(str(vocab_path) if vocab_path is not None else None)
+        self.pre_tokenizer = A5WURCSPreTokenizer()
+
+    @classmethod
+    def train_from_fit_corpus(
+        cls,
+        wurcs_strings: Iterable[str],
+        num_merges: int = 2000,
+        output_path: Optional[str | Path] = None,
+        min_frequency: int = 2,
+        max_token_length: Optional[int] = None,
+    ) -> "A5WURCSBPETokenizer":
+        tokenizer = cls()
+        pre_tokenizer = tokenizer.pre_tokenizer
+        unit_counts: Counter[str] = Counter()
+        for wurcs in wurcs_strings:
+            for unit in pre_tokenizer.pre_tokenize(wurcs):
+                if unit["type"] != "special":
+                    unit_counts[unit["text"]] += 1
+
+        # The submitted tokenizer learned the base character inventory from its
+        # corpus. Preserve that behavior, but fit it from training parents only.
+        tokenizer.fit_alphabet = tuple(
+            sorted({char for unit in unit_counts for char in unit})
+        )
+
+        next_id = len(tokenizer.special_tokens)
+        for char in tokenizer.fit_alphabet:
+            tokenizer.token_to_id[char] = next_id
+            tokenizer.id_to_token[next_id] = char
+            next_id += 1
+
+        word_freqs: dict[tuple[str, ...], int] = {
+            tuple(unit): count
+            for unit, count in sorted(unit_counts.items())
+            if count >= min_frequency
+        }
+        merges: list[tuple[str, str]] = []
+        for _ in range(num_merges):
+            pair_counts: Counter[tuple[str, str]] = Counter()
+            for word, frequency in word_freqs.items():
+                for index in range(len(word) - 1):
+                    pair_counts[(word[index], word[index + 1])] += frequency
+            candidates = [
+                (pair, count)
+                for pair, count in pair_counts.items()
+                if count >= min_frequency
+                and (
+                    max_token_length is None
+                    or len(pair[0]) + len(pair[1]) <= max_token_length
+                )
+            ]
+            if not candidates:
+                break
+            best_pair, _ = min(
+                candidates,
+                key=lambda item: (-item[1], item[0][0], item[0][1]),
+            )
+            new_token = best_pair[0] + best_pair[1]
+            merges.append(best_pair)
+            tokenizer.token_to_id[new_token] = next_id
+            tokenizer.id_to_token[next_id] = new_token
+            next_id += 1
+
+            merged_freqs: Counter[tuple[str, ...]] = Counter()
+            for word, frequency in word_freqs.items():
+                merged_word: list[str] = []
+                index = 0
+                while index < len(word):
+                    if (
+                        index < len(word) - 1
+                        and word[index] == best_pair[0]
+                        and word[index + 1] == best_pair[1]
+                    ):
+                        merged_word.append(new_token)
+                        index += 2
+                    else:
+                        merged_word.append(word[index])
+                        index += 1
+                merged_freqs[tuple(merged_word)] += frequency
+            word_freqs = dict(merged_freqs)
+
+        tokenizer.merges = merges
+        if output_path is not None:
+            tokenizer.save_vocab(str(output_path))
+        return tokenizer
+
+    def tokenize_sequence(self, wurcs: str, max_length: int = 256) -> dict:
+        units = self.pre_tokenizer.pre_tokenize(wurcs)
+        tokens: list[str] = []
+        token_ids: list[int] = []
+        residue_ids: list[int] = []
+        branch_depths: list[int] = []
+        linkage_types: list[int] = []
+
+        for unit in units:
+            unit_tokens = (
+                [unit["text"]]
+                if unit["type"] == "special"
+                else self.apply_bpe(unit["text"])
+            )
+            for token in unit_tokens:
+                tokens.append(token)
+                token_ids.append(
+                    self.token_to_id.get(token, self.token_to_id["[UNK]"])
+                )
+                residue_ids.append(int(unit["residue_id"]))
+                branch_depths.append(int(unit["branch_depth"]))
+                linkage_types.append(int(unit["linkage_type"]))
+
+        if len(tokens) > max_length:
+            tokens = tokens[: max_length - 1] + ["[END]"]
+            token_ids = token_ids[: max_length - 1] + [self.token_to_id["[END]"]]
+            residue_ids = residue_ids[: max_length - 1] + [-1]
+            branch_depths = branch_depths[: max_length - 1] + [0]
+            linkage_types = linkage_types[: max_length - 1] + [0]
+
+        length = len(tokens)
+        attention_mask = [1] * length
+        padding = max_length - length
+        tokens.extend(["[PAD]"] * padding)
+        token_ids.extend([self.token_to_id["[PAD]"]] * padding)
+        residue_ids.extend([-1] * padding)
+        branch_depths.extend([0] * padding)
+        linkage_types.extend([0] * padding)
+        attention_mask.extend([0] * padding)
+        return {
+            "tokens": tokens,
+            "token_ids": token_ids,
+            "residue_ids": residue_ids,
+            "branch_depths": branch_depths,
+            "linkage_types": linkage_types,
+            "attention_mask": attention_mask,
+            "length": length,
+        }

releases/2026-10-02/bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_sequence_package_receipt.json

@@ -0,0 +1,149 @@
+{
+  "checkpoint_resume_authorized": false,
+  "downstream_evaluation_authorized": false,
+  "gpu_launch_authorized": false,
+  "nova_submission_authorized": false,
+  "official_submitted_or_predecessor_artifacts_modified": false,
+  "payloads": {
+    "review_attention_mask.npy": {
+      "bytes": 71989376,
+      "name": "review_attention_mask.npy",
+      "sha256": "01ed165720b9414e614dd7e7d75284a8886165f11138e16117ffcbe4e4bbf95c"
+    },
+    "review_bpe_ambiguity_tokens.json": {
+      "bytes": 19693,
+      "name": "review_bpe_ambiguity_tokens.json",
+      "sha256": "22d2aad45b978988c9e26bc9400016014ee825cc6207377385a8cd74f3c88f2b"
+    },
+    "review_bpe_fit_contributors.tsv.gz": {
+      "bytes": 9934117,
+      "name": "review_bpe_fit_contributors.tsv.gz",
+      "sha256": "4ec8dfaeacef355092313507ab71c628f48ddf1a4fe39e7663748060a07af297"
+    },
+    "review_bpe_vocabulary.json": {
+      "bytes": 138150,
+      "name": "review_bpe_vocabulary.json",
+      "sha256": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b"
+    },
+    "review_branch_depths.npy": {
+      "bytes": 71989376,
+      "name": "review_branch_depths.npy",
+      "sha256": "f39f76aa56a9bb782b2349f3ad1ca4ad16351ee1f06a8b9ae4b06bff9b1ebece"
+    },
+    "review_build_official_sequence_topology_successor.py": {
+      "bytes": 16295,
+      "name": "review_build_official_sequence_topology_successor.py",
+      "sha256": "2e84b03ab2189f009654e97c427930cc511c50d079db06f425035fcfb2ae1efb"
+    },
+    "review_frozen_sequence_tree_runtime.py": {
+      "bytes": 11405,
+      "name": "review_frozen_sequence_tree_runtime.py",
+      "sha256": "10ca4b121d2f22d7a64208e4f05172e7a756b653d0828c9dcc49dd8ea1a5ad04"
+    },
+    "review_frozen_training_a5_topology.py": {
+      "bytes": 6186,
+      "name": "review_frozen_training_a5_topology.py",
+      "sha256": "f48ba266abf30a7a1298dea747676da64d53acef4ef02cba7ac8f16509460fc7"
+    },
+    "review_frozen_training_a5_wurcs_bpe.py": {
+      "bytes": 14161,
+      "name": "review_frozen_training_a5_wurcs_bpe.py",
+      "sha256": "6591b854962c278dc797981c942e114c18a26e97af43029c1d539bae3badb2f4"
+    },
+    "review_full_untruncated_lengths.npy": {
+      "bytes": 562544,
+      "name": "review_full_untruncated_lengths.npy",
+      "sha256": "6d83b42630bd8c5d355378b423b3a0021938741b5faa711ecc129a6789e307c2"
+    },
+    "review_lengths.npy": {
+      "bytes": 562544,
+      "name": "review_lengths.npy",
+      "sha256": "ade919d1e054c0ba852aa047bf873ac675f81a6c1f8a05cc73a0a2258131f021"
+    },
+    "review_linkage_types.npy": {
+      "bytes": 71989376,
+      "name": "review_linkage_types.npy",
+      "sha256": "89edb1940765928ced6f54e0d394f95c573eb9d96310b14dbd0adf8e20ac07c4"
+    },
+    "review_owner_clean_build_report.json": {
+      "bytes": 3169,
+      "name": "review_owner_clean_build_report.json",
+      "sha256": "2c24a655f009c6994756d8199b26c3e6489222c4b26d90efd0c43aacc17b9e4c"
+    },
+    "review_residue_ids.npy": {
+      "bytes": 143978624,
+      "name": "review_residue_ids.npy",
+      "sha256": "36c96dcd3e03ba30e02e16f98d17605742627a37b37cd7824f2a745dd09dc044"
+    },
+    "review_sequence_objective_eligible.npy": {
+      "bytes": 281336,
+      "name": "review_sequence_objective_eligible.npy",
+      "sha256": "62502d0d1b44a10989350a78f1e033d271fe8417715e10d42eb47c6720ceb3bf"
+    },
+    "review_sequence_package_summary.json": {
+      "bytes": 7777,
+      "name": "review_sequence_package_summary.json",
+      "sha256": "93ed219d807d4a7735be96bf7cf6a59a0bd407619925ee194aed6d473048cdf0"
+    },
+    "review_sequence_parent_index.tsv.gz": {
+      "bytes": 14697953,
+      "name": "review_sequence_parent_index.tsv.gz",
+      "sha256": "2c39e9b26bb41a1b9317c59372414f69812ead8676b0c33b23d2676e444a48b0"
+    },
+    "review_token_categories.npy": {
+      "bytes": 71989376,
+      "name": "review_token_categories.npy",
+      "sha256": "2d51df879382deb4927a446937983fea5a07fbbc783181f7903546222b856205"
+    },
+    "review_token_ids.npy": {
+      "bytes": 143978624,
+      "name": "review_token_ids.npy",
+      "sha256": "ec2d52dced65d22f0f218ff617d351fbd2930661bc8681e939990149d493537d"
+    },
+    "review_topology_lengths.npy": {
+      "bytes": 93175,
+      "name": "review_topology_lengths.npy",
+      "sha256": "b52f6ddcf327b8cfc5159659bada97357216f9526b42c230a35192932f43d2f3"
+    },
+    "review_topology_offsets.npy": {
+      "bytes": 744512,
+      "name": "review_topology_offsets.npy",
+      "sha256": "e06d61b8e47c2a2a3e0c8aeec7e015e673f64f0f483a483abe40ccda2d08b9e0"
+    },
+    "review_topology_roster.tsv": {
+      "bytes": 3890681,
+      "name": "review_topology_roster.tsv",
+      "sha256": "a216ce485ea699fb1b66ed6915175a49cde8c7d14279dbaf835f4675bc7c7fa1"
+    },
+    "review_topology_row.npy": {
+      "bytes": 1124960,
+      "name": "review_topology_row.npy",
+      "sha256": "a0ae28b0476322e3dbeda42a891f4a42c0973002a5d8507bf387b12dcbff4e95"
+    },
+    "review_topology_values.npy": {
+      "bytes": 5027730,
+      "name": "review_topology_values.npy",
+      "sha256": "2d4ba8395f78864b7eed9ed250bb9fd50bd45ef84a10ed497ffb89c684276e4e"
+    },
+    "review_tree_channels_valid.npy": {
+      "bytes": 281336,
+      "name": "review_tree_channels_valid.npy",
+      "sha256": "d15b160afe92a91a4a3d1b85b4a0353672b217b1d5c54513f3c80eab29c6b7c5"
+    }
+  },
+  "publication": {
+    "atomic_rename": true,
+    "no_overwrite": true,
+    "nofollow_inputs": true,
+    "pre_post_source_hash_stable": true
+  },
+  "schema": "bertose_a5_official_array_sequence_topology_successor_receipt_v1",
+  "scientific_launch_authorized": false,
+  "status": "PASS_RECEIPT_LAST",
+  "summary": {
+    "bytes": 7777,
+    "name": "review_sequence_package_summary.json",
+    "sha256": "93ed219d807d4a7735be96bf7cf6a59a0bd407619925ee194aed6d473048cdf0"
+  },
+  "training_authorized": false
+}

releases/2026-10-02/bertose_source/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_sequence_package_summary.json

@@ -0,0 +1,186 @@
+{
+  "bpe": {
+    "fit_contributor_sha256": "4ec8dfaeacef355092313507ab71c628f48ddf1a4fe39e7663748060a07af297",
+    "fit_parent_count": 221899,
+    "fit_roles": [
+      "pretraining_train"
+    ],
+    "vocabulary_sha256": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "vocabulary_size": 2114
+  },
+  "checkpoint_resume_authorized": false,
+  "downstream_evaluation_authorized": false,
+  "gate_audit": {
+    "canonical_wurcs_mismatch": 0,
+    "duplicate_ids": 0,
+    "gate_rows": 285050,
+    "legitimate_extra_gate_ids": 3842,
+    "missing_sequence_parents": 0,
+    "sequence_parents": 281208
+  },
+  "gpu_launch_authorized": false,
+  "nova_submission_authorized": false,
+  "official_submitted_or_predecessor_artifacts_modified": false,
+  "output_payloads": {
+    "review_attention_mask.npy": {
+      "bytes": 71989376,
+      "name": "review_attention_mask.npy",
+      "sha256": "01ed165720b9414e614dd7e7d75284a8886165f11138e16117ffcbe4e4bbf95c"
+    },
+    "review_bpe_ambiguity_tokens.json": {
+      "bytes": 19693,
+      "name": "review_bpe_ambiguity_tokens.json",
+      "sha256": "22d2aad45b978988c9e26bc9400016014ee825cc6207377385a8cd74f3c88f2b"
+    },
+    "review_bpe_fit_contributors.tsv.gz": {
+      "bytes": 9934117,
+      "name": "review_bpe_fit_contributors.tsv.gz",
+      "sha256": "4ec8dfaeacef355092313507ab71c628f48ddf1a4fe39e7663748060a07af297"
+    },
+    "review_bpe_vocabulary.json": {
+      "bytes": 138150,
+      "name": "review_bpe_vocabulary.json",
+      "sha256": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b"
+    },
+    "review_branch_depths.npy": {
+      "bytes": 71989376,
+      "name": "review_branch_depths.npy",
+      "sha256": "f39f76aa56a9bb782b2349f3ad1ca4ad16351ee1f06a8b9ae4b06bff9b1ebece"
+    },
+    "review_build_official_sequence_topology_successor.py": {
+      "bytes": 16295,
+      "name": "review_build_official_sequence_topology_successor.py",
+      "sha256": "2e84b03ab2189f009654e97c427930cc511c50d079db06f425035fcfb2ae1efb"
+    },
+    "review_frozen_sequence_tree_runtime.py": {
+      "bytes": 11405,
+      "name": "review_frozen_sequence_tree_runtime.py",
+      "sha256": "10ca4b121d2f22d7a64208e4f05172e7a756b653d0828c9dcc49dd8ea1a5ad04"
+    },
+    "review_frozen_training_a5_topology.py": {
+      "bytes": 6186,
+      "name": "review_frozen_training_a5_topology.py",
+      "sha256": "f48ba266abf30a7a1298dea747676da64d53acef4ef02cba7ac8f16509460fc7"
+    },
+    "review_frozen_training_a5_wurcs_bpe.py": {
+      "bytes": 14161,
+      "name": "review_frozen_training_a5_wurcs_bpe.py",
+      "sha256": "6591b854962c278dc797981c942e114c18a26e97af43029c1d539bae3badb2f4"
+    },
+    "review_full_untruncated_lengths.npy": {
+      "bytes": 562544,
+      "name": "review_full_untruncated_lengths.npy",
+      "sha256": "6d83b42630bd8c5d355378b423b3a0021938741b5faa711ecc129a6789e307c2"
+    },
+    "review_lengths.npy": {
+      "bytes": 562544,
+      "name": "review_lengths.npy",
+      "sha256": "ade919d1e054c0ba852aa047bf873ac675f81a6c1f8a05cc73a0a2258131f021"
+    },
+    "review_linkage_types.npy": {
+      "bytes": 71989376,
+      "name": "review_linkage_types.npy",
+      "sha256": "89edb1940765928ced6f54e0d394f95c573eb9d96310b14dbd0adf8e20ac07c4"
+    },
+    "review_owner_clean_build_report.json": {
+      "bytes": 3169,
+      "name": "review_owner_clean_build_report.json",
+      "sha256": "2c24a655f009c6994756d8199b26c3e6489222c4b26d90efd0c43aacc17b9e4c"
+    },
+    "review_residue_ids.npy": {
+      "bytes": 143978624,
+      "name": "review_residue_ids.npy",
+      "sha256": "36c96dcd3e03ba30e02e16f98d17605742627a37b37cd7824f2a745dd09dc044"
+    },
+    "review_sequence_objective_eligible.npy": {
+      "bytes": 281336,
+      "name": "review_sequence_objective_eligible.npy",
+      "sha256": "62502d0d1b44a10989350a78f1e033d271fe8417715e10d42eb47c6720ceb3bf"
+    },
+    "review_sequence_parent_index.tsv.gz": {
+      "bytes": 14697953,
+      "name": "review_sequence_parent_index.tsv.gz",
+      "sha256": "2c39e9b26bb41a1b9317c59372414f69812ead8676b0c33b23d2676e444a48b0"
+    },
+    "review_token_categories.npy": {
+      "bytes": 71989376,
+      "name": "review_token_categories.npy",
+      "sha256": "2d51df879382deb4927a446937983fea5a07fbbc783181f7903546222b856205"
+    },
+    "review_token_ids.npy": {
+      "bytes": 143978624,
+      "name": "review_token_ids.npy",
+      "sha256": "ec2d52dced65d22f0f218ff617d351fbd2930661bc8681e939990149d493537d"
+    },
+    "review_topology_lengths.npy": {
+      "bytes": 93175,
+      "name": "review_topology_lengths.npy",
+      "sha256": "b52f6ddcf327b8cfc5159659bada97357216f9526b42c230a35192932f43d2f3"
+    },
+    "review_topology_offsets.npy": {
+      "bytes": 744512,
+      "name": "review_topology_offsets.npy",
+      "sha256": "e06d61b8e47c2a2a3e0c8aeec7e015e673f64f0f483a483abe40ccda2d08b9e0"
+    },
+    "review_topology_roster.tsv": {
+      "bytes": 3890681,
+      "name": "review_topology_roster.tsv",
+      "sha256": "a216ce485ea699fb1b66ed6915175a49cde8c7d14279dbaf835f4675bc7c7fa1"
+    },
+    "review_topology_row.npy": {
+      "bytes": 1124960,
+      "name": "review_topology_row.npy",
+      "sha256": "a0ae28b0476322e3dbeda42a891f4a42c0973002a5d8507bf387b12dcbff4e95"
+    },
+    "review_topology_values.npy": {
+      "bytes": 5027730,
+      "name": "review_topology_values.npy",
+      "sha256": "2d4ba8395f78864b7eed9ed250bb9fd50bd45ef84a10ed497ffb89c684276e4e"
+    },
+    "review_tree_channels_valid.npy": {
+      "bytes": 281336,
+      "name": "review_tree_channels_valid.npy",
+      "sha256": "d15b160afe92a91a4a3d1b85b4a0353672b217b1d5c54513f3c80eab29c6b7c5"
+    }
+  },
+  "parent_count": 281208,
+  "rooted_valid_count": 157652,
+  "schema": "bertose_a5_official_array_sequence_topology_successor_v1",
+  "scientific_launch_authorized": false,
+  "sequence_objective_roles": {
+    "pretraining_development": 55440,
+    "pretraining_train": 221827
+  },
+  "source_bindings": {
+    "ambiguity": "22d2aad45b978988c9e26bc9400016014ee825cc6207377385a8cd74f3c88f2b",
+    "builder": "2e84b03ab2189f009654e97c427930cc511c50d079db06f425035fcfb2ae1efb",
+    "fit": "4ec8dfaeacef355092313507ab71c628f48ddf1a4fe39e7663748060a07af297",
+    "gate": "5fb976a4b3440eb60b52bce9e1932d197f90bf3e074c6e8438bfe92b93c0c7da",
+    "helper": "a791b8f4bbda75317f41afb34d62fe518448f4d5d90db0b852e2b0d0af5e83a6",
+    "index": "3b9e9f6b4671448cea70a3c16717dc6538c01c59ebfce478ce274e133e563ac3",
+    "input_all": "27da2fa1513e77e7f1ced2b5461299d9a997138a643db99f5b2de704bec7a746",
+    "molwurcs": "bc38e44e66daed7ec04f7c7907a13509aac125a8a09c97d9972725ab4278edaf",
+    "owner_report": "2c24a655f009c6994756d8199b26c3e6489222c4b26d90efd0c43aacc17b9e4c",
+    "partition": "86a8c6742156683d502c93fc71b31b9a93450037d647e5a90db437a015bb3bbc",
+    "pretokenizer": "6591b854962c278dc797981c942e114c18a26e97af43029c1d539bae3badb2f4",
+    "raw": "d69583e2499f775ded3f18baaee843de4dd7c424e2ce5780ad89acab517d85fc",
+    "topology_source": "f48ba266abf30a7a1298dea747676da64d53acef4ef02cba7ac8f16509460fc7",
+    "tree_runtime": "10ca4b121d2f22d7a64208e4f05172e7a756b653d0828c9dcc49dd8ea1a5ad04",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "wurcsframework": "5449f9276a7b952adf087468c874bb13c7295062cce7d1afb13fdea78ace7f37"
+  },
+  "status": "PASS_PREPARATION_ONLY_OWNER_CLEAN_BUILD_BYTE_MATCHED",
+  "topology_roles_including_excluded_audit": {
+    "excluded_exact_or_verified_graph_identity": 3483,
+    "pretraining_development": 17650,
+    "pretraining_train": 71914
+  },
+  "topology_storage": {
+    "legacy_dense_width26_rejected": true,
+    "max_residue_count": 48,
+    "row_count": 93047,
+    "schema": "ragged_original_residue_axis_bfs_int8_offsets_uint64",
+    "value_count": 5027602
+  },
+  "training_authorized": false
+}

releases/2026-10-02/bertose_source/model/glycan_bert.py

@@ -0,0 +1,303 @@
+"""
+Glycan BERT Model
+
+Transformer-based masked language model for glycan structures.
+Based on BERT/ESM2 architecture adapted for atomic glycan tokenization.
+"""
+
+import torch
+import torch.nn as nn
+import math
+
+
+class GlycanBERTConfig:
+    """Configuration for GlycanBERT."""
+    
+    def __init__(
+        self,
+        vocab_size: int = 102,
+        hidden_size: int = 384,
+        num_hidden_layers: int = 6,
+        num_attention_heads: int = 6,
+        intermediate_size: int = 1536,
+        hidden_dropout_prob: float = 0.1,
+        attention_probs_dropout_prob: float = 0.1,
+        max_position_embeddings: int = 512,
+        layer_norm_eps: float = 1e-12,
+        pad_token_id: int = 0,
+        mask_token_id: int = 4,
+        initializer_range: float = 0.02
+    ):
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.intermediate_size = intermediate_size
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.max_position_embeddings = max_position_embeddings
+        self.layer_norm_eps = layer_norm_eps
+        self.pad_token_id = pad_token_id
+        self.mask_token_id = mask_token_id
+        self.initializer_range = initializer_range
+
+
+class GlycanBERTEmbeddings(nn.Module):
+    """
+    Embeddings for glycan tokens including token and positional embeddings.
+    """
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.token_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+        
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        
+        # position_ids (1, max_seq_len) is contiguous in memory and exported when serialized
+        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
+    
+    def forward(self, input_ids: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input_ids: Tensor of shape (batch_size, seq_len)
+        
+        Returns:
+            Embeddings of shape (batch_size, seq_len, hidden_size)
+        """
+        batch_size, seq_len = input_ids.shape
+        
+        # Token embeddings
+        token_embeds = self.token_embeddings(input_ids)
+        
+        # Position embeddings
+        position_ids = self.position_ids[:, :seq_len]
+        position_embeds = self.position_embeddings(position_ids)
+        
+        # Combine
+        embeddings = token_embeds + position_embeds
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        
+        return embeddings
+
+
+class GlycanBERTAttention(nn.Module):
+    """Multi-head self-attention."""
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        assert config.hidden_size % config.num_attention_heads == 0
+        
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = config.hidden_size // config.num_attention_heads
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+        
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+        
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+    
+    def transpose_for_scores(self, x: torch.Tensor) -> torch.Tensor:
+        """Reshape for multi-head attention."""
+        new_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(*new_shape)
+        return x.permute(0, 2, 1, 3)  # (batch, heads, seq_len, head_size)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Args:
+            hidden_states: (batch_size, seq_len, hidden_size)
+            attention_mask: (batch_size, seq_len) - 1 for valid, 0 for padding
+        
+        Returns:
+            Attention output: (batch_size, seq_len, hidden_size)
+        """
+        batch_size, seq_len, _ = hidden_states.shape
+        
+        # Linear projections
+        query_layer = self.transpose_for_scores(self.query(hidden_states))
+        key_layer = self.transpose_for_scores(self.key(hidden_states))
+        value_layer = self.transpose_for_scores(self.value(hidden_states))
+        
+        # Attention scores
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        
+        # Apply attention mask
+        if attention_mask is not None:
+            # Convert mask to additive mask
+            attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)  # (batch, 1, 1, seq_len)
+            attention_mask = (1.0 - attention_mask) * -10000.0
+            attention_scores = attention_scores + attention_mask
+        
+        # Attention probabilities
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+        attention_probs = self.dropout(attention_probs)
+        
+        # Apply attention to values
+        context_layer = torch.matmul(attention_probs, value_layer)
+        
+        # Reshape back
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_shape)
+        
+        return context_layer
+
+
+class GlycanBERTLayer(nn.Module):
+    """Single transformer layer."""
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.attention = GlycanBERTAttention(config)
+        self.attention_output = nn.Linear(config.hidden_size, config.hidden_size)
+        self.attention_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        
+        self.intermediate = nn.Linear(config.hidden_size, config.intermediate_size)
+        self.output = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.output_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Args:
+            hidden_states: (batch_size, seq_len, hidden_size)
+            attention_mask: (batch_size, seq_len)
+        
+        Returns:
+            Output: (batch_size, seq_len, hidden_size)
+        """
+        # Self-attention
+        attention_output = self.attention(hidden_states, attention_mask)
+        attention_output = self.attention_output(attention_output)
+        attention_output = self.dropout(attention_output)
+        
+        # Add & Norm
+        hidden_states = self.attention_layer_norm(hidden_states + attention_output)
+        
+        # Feed-forward
+        intermediate_output = self.intermediate(hidden_states)
+        intermediate_output = nn.functional.gelu(intermediate_output)
+        
+        layer_output = self.output(intermediate_output)
+        layer_output = self.dropout(layer_output)
+        
+        # Add & Norm
+        layer_output = self.output_layer_norm(hidden_states + layer_output)
+        
+        return layer_output
+
+
+class GlycanBERT(nn.Module):
+    """
+    Glycan BERT model for masked language modeling.
+    """
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.config = config
+        
+        # Embeddings
+        self.embeddings = GlycanBERTEmbeddings(config)
+        
+        # Transformer layers
+        self.layers = nn.ModuleList([GlycanBERTLayer(config) for _ in range(config.num_hidden_layers)])
+        
+        # MLM head
+        self.mlm_head = nn.Linear(config.hidden_size, config.vocab_size)
+        
+        # Initialize weights
+        self.apply(self._init_weights)
+    
+    def _init_weights(self, module):
+        """Initialize weights."""
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+    
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor = None,
+        labels: torch.Tensor = None
+    ):
+        """
+        Args:
+            input_ids: (batch_size, seq_len)
+            attention_mask: (batch_size, seq_len) - 1 for valid, 0 for padding
+            labels: (batch_size, seq_len) - token IDs to predict, -100 for positions to ignore
+        
+        Returns:
+            If labels provided: (loss, logits)
+            Else: logits
+        """
+        # Create attention mask if not provided
+        if attention_mask is None:
+            attention_mask = (input_ids != self.config.pad_token_id).float()
+        
+        # Embeddings
+        hidden_states = self.embeddings(input_ids)
+        
+        # Transformer layers
+        for layer in self.layers:
+            hidden_states = layer(hidden_states, attention_mask)
+        
+        # MLM prediction
+        logits = self.mlm_head(hidden_states)
+        
+        # Calculate loss if labels provided
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()  # -100 is ignored
+            loss = loss_fct(logits.view(-1, self.config.vocab_size), labels.view(-1))
+        
+        if loss is not None:
+            return loss, logits
+        return logits
+    
+    def get_embeddings(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Get contextualized embeddings (for downstream tasks).
+        
+        Args:
+            input_ids: (batch_size, seq_len)
+            attention_mask: (batch_size, seq_len)
+        
+        Returns:
+            Embeddings: (batch_size, seq_len, hidden_size)
+        """
+        if attention_mask is None:
+            attention_mask = (input_ids != self.config.pad_token_id).float()
+        
+        hidden_states = self.embeddings(input_ids)
+        
+        for layer in self.layers:
+            hidden_states = layer(hidden_states, attention_mask)
+        
+        return hidden_states
+

releases/2026-10-02/bertose_source/model/multimodal_glycan_bert_v3.py

@@ -0,0 +1,1084 @@
+"""
+Multimodal Glycan BERT Model v3
+
+Extends GlycanBERT to handle three modalities:
+- Sequence (WURCS atomic tokenization)
+- MS (mass spectrometry peaks, RT, intensity)
+- 3D structure (VQ-VAE discrete tokens, 4 per residue)
+
+Each modality has its own encoder, with cross-attention for sequence-structure alignment.
+"""
+
+import torch
+import torch.nn as nn
+from typing import Dict, Optional, Tuple
+import math
+
+try:
+    from .glycan_bert import GlycanBERTConfig, GlycanBERTEmbeddings, GlycanBERTLayer
+except ImportError:
+    from glycan_bert import GlycanBERTConfig, GlycanBERTEmbeddings, GlycanBERTLayer
+
+
+class ConvGlycanBERTEmbeddings(nn.Module):
+    """
+    Improved Convolutional front-end that mixes local WURCS context before the Transformer.
+    
+    Key improvements over original:
+    1. Position embeddings added BEFORE convolution (provides spatial context to conv)
+    2. Residual connection (conv enriches embeddings rather than replacing them)
+    3. Multi-scale convolutions (kernel sizes 3, 5, 7) for better receptive field
+    4. Proper layer normalization on the residual path
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.token_embeddings = nn.Embedding(
+            config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id
+        )
+        self.position_embeddings = nn.Embedding(
+            config.max_position_embeddings, config.hidden_size
+        )
+        
+        # NEW: Branch depth embeddings - encodes depth in glycan tree (0=root, 1=child, etc.)
+        max_branch_depth = getattr(config, "max_branch_depth", 8)
+        self.branch_embeddings = nn.Embedding(max_branch_depth, config.hidden_size)
+        
+        # NEW: Linkage type embeddings - encodes chemistry of glycosidic bond
+        # 0=none, 1=1-3, 2=1-4, 3=1-6, etc.
+        num_linkage_types = getattr(config, "num_linkage_types", 9)
+        self.linkage_embeddings = nn.Embedding(num_linkage_types, config.hidden_size)
+        
+        # Multi-scale convolutions for different receptive fields
+        kernel_size = getattr(config, "cnn_kernel_size", 3)
+        # Split channels evenly: 256 + 256 + 256 = 768 for hidden_size=768
+        channels_per_scale = config.hidden_size // 3
+        self.conv_layers = nn.ModuleList([
+            nn.Conv1d(
+                in_channels=config.hidden_size,
+                out_channels=channels_per_scale,
+                kernel_size=kernel_size + 2 * i,  # Kernels: 3, 5, 7
+                padding=(kernel_size + 2 * i) // 2,  # Same padding
+            )
+            for i in range(3)
+        ])
+        self.conv_activation = nn.GELU()
+        self.conv_proj = nn.Linear(channels_per_scale * 3, config.hidden_size)  # Project concatenated back
+        
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.conv_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.register_buffer(
+            "position_ids",
+            torch.arange(config.max_position_embeddings).expand((1, -1)),
+        )
+
+        self.hidden_size = config.hidden_size
+
+    def forward(self, input_ids, branch_depths=None, linkage_types=None):
+        seq_len = input_ids.shape[1]
+        
+        # Step 1: Token + Position embeddings FIRST (provides spatial context to conv)
+        x = self.token_embeddings(input_ids)  # (batch, seq, hidden)
+        position_ids = self.position_ids[:, :seq_len]
+        x = x + self.position_embeddings(position_ids)
+        
+        # NEW: Add branch depth embeddings (encodes tree structure)
+        if branch_depths is not None:
+            # Clamp to valid range
+            branch_depths = branch_depths.clamp(0, self.branch_embeddings.num_embeddings - 1)
+            x = x + self.branch_embeddings(branch_depths)
+        
+        # NEW: Add linkage type embeddings (encodes bond chemistry)
+        if linkage_types is not None:
+            linkage_types = linkage_types.clamp(0, self.linkage_embeddings.num_embeddings - 1)
+            x = x + self.linkage_embeddings(linkage_types)
+        
+        x = self.LayerNorm(x)
+        
+        # Step 2: Multi-scale convolution with RESIDUAL connection
+        # Convolution expects (batch, hidden, seq)
+        conv_in = x.permute(0, 2, 1)
+        
+        # Apply multi-scale convolutions and concatenate
+        conv_outputs = []
+        for conv in self.conv_layers:
+            conv_out = self.conv_activation(conv(conv_in))
+            conv_outputs.append(conv_out)
+        
+        # Concatenate multi-scale features and project back
+        conv_out = torch.cat(conv_outputs, dim=1)  # (batch, hidden, seq)
+        conv_out = conv_out.permute(0, 2, 1)  # (batch, seq, hidden)
+        conv_out = self.conv_proj(conv_out)  # Project to correct size
+        
+        # Step 3: Residual connection - conv ENRICHES rather than replaces
+        x = self.conv_norm(x + self.dropout(conv_out))
+        
+        return x
+
+
+def create_residue_level_mask(
+    seq_residue_ids: torch.Tensor,    # (batch, N_seq)
+    struct_residue_ids: torch.Tensor  # (batch, N_struct)
+) -> torch.Tensor:
+    """
+    Create residue-level attention mask for cross-attention.
+    
+    Maps WURCS tokens to VQ-VAE structural tokens based on residue IDs.
+    A WURCS token with residue_id=0 can only attend to VQ-VAE tokens with residue_id=0.
+    
+    Args:
+        seq_residue_ids: Residue IDs for sequence tokens (batch, N_seq)
+        struct_residue_ids: Residue IDs for structural tokens (batch, N_struct)
+    
+    Returns:
+        Boolean mask (batch, N_seq, N_struct) where True = can attend
+    """
+    # Expand dimensions for broadcasting
+    # seq: (batch, N_seq, 1)
+    # struct: (batch, 1, N_struct)
+    mask = seq_residue_ids.unsqueeze(2) == struct_residue_ids.unsqueeze(1)
+    # Shape: (batch, N_seq, N_struct)
+    
+    # Mask out structural tokens (residue_id = -1) and MS tokens (residue_id = -2)
+    # Only tokens with residue_id >= 0 can attend
+    mask &= (seq_residue_ids.unsqueeze(2) >= 0)
+    
+    return mask  # True = can attend, False = cannot attend
+
+
+class MultimodalGlycanBERTConfig:
+    """Configuration for Multimodal GlycanBERT v3."""
+    
+    def __init__(
+        self,
+        # Sequence modality
+        seq_vocab_size: int = 166,
+        seq_hidden_size: int = 768,
+        seq_num_layers: int = 12,
+        seq_num_heads: int = 12,
+        seq_max_length: int = 512,
+        
+        # MS modality
+        ms_vocab_size: int = 242,
+        ms_hidden_size: int = 384,
+        ms_num_layers: int = 6,
+        ms_num_heads: int = 6,
+        ms_max_length: int = 150,
+        
+        # 3D structure modality
+        struct_vocab_size: int = 1024,  # VQ-VAE codebook size
+        struct_hidden_size: int = 512,
+        struct_num_layers: int = 8,
+        struct_num_heads: int = 8,
+        struct_max_length: int = 200,
+        use_3d: bool = True,
+        
+        # Cross-attention
+        use_cross_attention: bool = True,
+        cross_attn_num_heads: int = 8,
+        
+        # Fusion
+        fusion_hidden_size: int = 768,
+        fusion_num_layers: int = 2,
+        
+        # Training
+        hidden_dropout_prob: float = 0.1,
+        attention_probs_dropout_prob: float = 0.1,
+        layer_norm_eps: float = 1e-12,
+        initializer_range: float = 0.02,
+
+        # Conv front-end
+        use_cnn_frontend: bool = True,
+        cnn_kernel_size: int = 3,
+        
+        # Loss weights
+        seq_loss_weight: float = 0.60,
+        ms_loss_weight: float = 0.15,
+        struct_loss_weight: float = 0.25,
+        dist_loss_weight: float = 0.25,
+        
+        # Token IDs
+        pad_token_id: int = 0,
+        mask_token_id: int = 1,
+    ):
+        # Sequence config
+        self.seq_vocab_size = seq_vocab_size
+        self.seq_hidden_size = seq_hidden_size
+        self.seq_num_layers = seq_num_layers
+        self.seq_num_heads = seq_num_heads
+        self.seq_max_length = seq_max_length
+        
+        # MS config
+        self.ms_vocab_size = ms_vocab_size
+        self.ms_vocab_offset = seq_vocab_size  # MS tokens start at 166
+        self.ms_total_vocab_size = seq_vocab_size + ms_vocab_size  # 408 total
+        self.ms_hidden_size = ms_hidden_size
+        self.ms_num_layers = ms_num_layers
+        self.ms_num_heads = ms_num_heads
+        self.ms_max_length = ms_max_length
+        
+        # Structure config
+        self.struct_vocab_size = struct_vocab_size
+        self.struct_hidden_size = struct_hidden_size
+        self.struct_num_layers = struct_num_layers
+        self.struct_num_heads = struct_num_heads
+        self.struct_max_length = struct_max_length
+        self.use_3d = use_3d
+        
+        # Cross-attention config
+        self.use_cross_attention = use_cross_attention
+        self.cross_attn_num_heads = cross_attn_num_heads
+        
+        # Fusion config
+        self.fusion_hidden_size = fusion_hidden_size
+        self.fusion_num_layers = fusion_num_layers
+        
+        # Training config
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.layer_norm_eps = layer_norm_eps
+        self.initializer_range = initializer_range
+
+        # Conv front-end
+        self.use_cnn_frontend = use_cnn_frontend
+        self.cnn_kernel_size = cnn_kernel_size
+        
+        # Loss weights
+        self.seq_loss_weight = seq_loss_weight
+        self.ms_loss_weight = ms_loss_weight
+        self.struct_loss_weight = struct_loss_weight
+        self.dist_loss_weight = dist_loss_weight
+        
+        # Token IDs
+        self.pad_token_id = pad_token_id
+        self.mask_token_id = mask_token_id
+    
+    def to_seq_config(self) -> GlycanBERTConfig:
+        """Convert to sequence-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.seq_vocab_size,
+            hidden_size=self.seq_hidden_size,
+            num_hidden_layers=self.seq_num_layers,
+            num_attention_heads=self.seq_num_heads,
+            intermediate_size=self.seq_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.seq_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+    
+    def to_ms_config(self) -> GlycanBERTConfig:
+        """Convert to MS-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.ms_total_vocab_size,
+            hidden_size=self.ms_hidden_size,
+            num_hidden_layers=self.ms_num_layers,
+            num_attention_heads=self.ms_num_heads,
+            intermediate_size=self.ms_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.ms_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+    
+    def to_struct_config(self) -> GlycanBERTConfig:
+        """Convert to structure-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.struct_vocab_size,
+            hidden_size=self.struct_hidden_size,
+            num_hidden_layers=self.struct_num_layers,
+            num_attention_heads=self.struct_num_heads,
+            intermediate_size=self.struct_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.struct_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+
+
+# =============================================================================
+# Improvement #1: Monosaccharide-Level Pooling
+# =============================================================================
+
+class MonosaccharidePooling(nn.Module):
+    """
+    Pool token representations to monosaccharide level, then aggregate.
+    
+    This bridges the gap between token-level BERT and monosaccharide-level CNNs/GNNs.
+    Uses monosaccharide_indices from the data to know where each residue starts.
+    """
+    
+    def __init__(self, hidden_size: int, num_attention_heads: int = 8, dropout: float = 0.1):
+        super().__init__()
+        self.hidden_size = hidden_size
+        
+        # Attention pooling over monosaccharide representations
+        self.mono_attention = nn.MultiheadAttention(
+            embed_dim=hidden_size,
+            num_heads=num_attention_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        self.mono_norm = nn.LayerNorm(hidden_size)
+        
+        # Final aggregation to single glycan representation
+        self.glycan_query = nn.Parameter(torch.randn(1, 1, hidden_size) * 0.02)
+        self.glycan_attention = nn.MultiheadAttention(
+            embed_dim=hidden_size,
+            num_heads=num_attention_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        self.glycan_norm = nn.LayerNorm(hidden_size)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,      # (batch, seq_len, hidden)
+        residue_ids: torch.Tensor,         # (batch, seq_len) - which residue each token belongs to
+        attention_mask: torch.Tensor = None,  # (batch, seq_len)
+    ) -> torch.Tensor:
+        """
+        Pool tokens to monosaccharide level, then to glycan level.
+        
+        Returns:
+            Glycan representation: (batch, hidden_size)
+        """
+        batch_size = hidden_states.size(0)
+        device = hidden_states.device
+        
+        # Get unique residue IDs per sample (excluding -1 padding)
+        max_residues = 50  # Reasonable max for glycans
+        
+        # Pool tokens within each residue using mean pooling
+        mono_reps = torch.zeros(batch_size, max_residues, self.hidden_size, device=device)
+        mono_mask = torch.zeros(batch_size, max_residues, dtype=torch.bool, device=device)
+        
+        for b in range(batch_size):
+            unique_residues = torch.unique(residue_ids[b][residue_ids[b] >= 0])
+            for i, rid in enumerate(unique_residues):
+                if i >= max_residues:
+                    break
+                token_mask = residue_ids[b] == rid
+                if attention_mask is not None:
+                    token_mask = token_mask & (attention_mask[b] > 0)
+                if token_mask.sum() > 0:
+                    mono_reps[b, i] = hidden_states[b][token_mask].mean(dim=0)
+                    mono_mask[b, i] = True
+        
+        # Apply attention over monosaccharide representations
+        # Convert mask for attention: True = valid, need to invert for PyTorch
+        key_padding_mask = ~mono_mask  # True = ignore
+        
+        mono_out, _ = self.mono_attention(
+            mono_reps, mono_reps, mono_reps,
+            key_padding_mask=key_padding_mask
+        )
+        mono_out = self.mono_norm(mono_reps + mono_out)
+        
+        # Aggregate to single glycan representation using learned query
+        glycan_query = self.glycan_query.expand(batch_size, -1, -1)
+        glycan_out, _ = self.glycan_attention(
+            glycan_query, mono_out, mono_out,
+            key_padding_mask=key_padding_mask
+        )
+        glycan_out = self.glycan_norm(glycan_query + glycan_out)
+        
+        return glycan_out.squeeze(1)  # (batch, hidden)
+
+
+# =============================================================================
+# Improvement #2: Residue Type Embeddings
+# =============================================================================
+
+# Common monosaccharide types vocabulary
+MONOSACCHARIDE_VOCAB = {
+    '[PAD_MONO]': 0, '[UNK_MONO]': 1,
+    'Glc': 2, 'GlcNAc': 3, 'GlcA': 4, 'GlcN': 5,
+    'Gal': 6, 'GalNAc': 7, 'GalA': 8, 'GalN': 9,
+    'Man': 10, 'ManNAc': 11, 'ManA': 12, 'ManN': 13,
+    'Fuc': 14, 'Rha': 15, 'Xyl': 16, 'Ara': 17,
+    'Neu5Ac': 18, 'Neu5Gc': 19, 'Kdn': 20, 'Sia': 21,
+    'GalNAcA': 22, 'GlcNAcA': 23, 'IdoA': 24, 'GulA': 25,
+    'Rib': 26, 'Lyx': 27, 'All': 28, 'Alt': 29,
+    'Tal': 30, 'Ido': 31, 'Qui': 32, 'Oli': 33,
+    'Tyv': 34, 'Abe': 35, 'Par': 36, 'Dig': 37,
+    'Col': 38, 'Dha': 39, 'Kdo': 40, 'Hep': 41,
+    'NeuroGc': 42, 'Muramic': 43, 'LDManHep': 44, 'DDManHep': 45,
+    'Bac': 46, 'Pse': 47, 'Leg': 48, 'Aci': 49,
+    '6dTal': 50, 'Fru': 51, 'Tag': 52, 'Sor': 53,
+    'Psi': 54, 'Sed': 55, 'MurNAc': 56, 'MurNGc': 57,
+    'Api': 58, 'Erwiniose': 59, 'Yer': 60, 'Thre': 61,
+    # Add more as needed, up to ~70
+}
+
+
+class ResidueTypeEmbeddings(nn.Module):
+    """
+    Learnable embeddings for monosaccharide types.
+    
+    Instead of the model having to learn that 'a1221m' = Fucose from character patterns,
+    we explicitly add a Fucose embedding to all tokens belonging to that residue.
+    """
+    
+    def __init__(self, hidden_size: int, num_mono_types: int = 70):
+        super().__init__()
+        self.mono_embeddings = nn.Embedding(num_mono_types, hidden_size)
+        self.mono_vocab = MONOSACCHARIDE_VOCAB
+        self.hidden_size = hidden_size
+    
+    def forward(
+        self, 
+        token_embeddings: torch.Tensor,  # (batch, seq_len, hidden)
+        residue_ids: torch.Tensor,        # (batch, seq_len)
+        mono_type_ids: torch.Tensor = None,  # (batch, max_residues) - monosaccharide type per residue
+    ) -> torch.Tensor:
+        """
+        Add residue type embeddings to token embeddings.
+        
+        Args:
+            token_embeddings: Base token embeddings
+            residue_ids: Which residue each token belongs to (-1 for special tokens)
+            mono_type_ids: Monosaccharide type ID for each residue position
+            
+        Returns:
+            Enhanced embeddings with residue type information
+        """
+        if mono_type_ids is None:
+            return token_embeddings
+        
+        batch_size, seq_len, _ = token_embeddings.shape
+        enhanced = token_embeddings.clone()
+        
+        # Add mono type embedding to each token based on its residue
+        for b in range(batch_size):
+            for pos in range(seq_len):
+                rid = residue_ids[b, pos].item()
+                if rid >= 0 and rid < mono_type_ids.size(1):
+                    mono_id = mono_type_ids[b, rid]
+                    enhanced[b, pos] = enhanced[b, pos] + self.mono_embeddings(mono_id)
+        
+        return enhanced
+    
+    @staticmethod
+    def get_mono_type_id(mono_name: str) -> int:
+        """Convert monosaccharide name to type ID."""
+        return MONOSACCHARIDE_VOCAB.get(mono_name, MONOSACCHARIDE_VOCAB['[UNK_MONO]'])
+
+
+# =============================================================================
+# Improvement #4: Relative Position Encoding for Glycan Trees
+# =============================================================================
+
+class RelativePositionBias(nn.Module):
+    """
+    Compute relative position bias for attention based on residue IDs.
+    
+    Tokens in the same residue get distance 0.
+    Tokens in adjacent residues get distance ±1.
+    This helps the model understand glycan tree structure.
+    """
+    
+    def __init__(self, num_heads: int, max_distance: int = 10):
+        super().__init__()
+        self.num_heads = num_heads
+        self.max_distance = max_distance
+        
+        # Learnable bias for each relative distance (-max to +max)
+        num_distances = 2 * max_distance + 1
+        self.relative_bias = nn.Embedding(num_distances, num_heads)
+    
+    def forward(self, residue_ids: torch.Tensor) -> torch.Tensor:
+        """
+        Compute relative position bias.
+        
+        Args:
+            residue_ids: (batch, seq_len)
+            
+        Returns:
+            Bias to add to attention scores: (batch, num_heads, seq_len, seq_len)
+        """
+        # Compute pairwise residue distances
+        # (batch, seq_len, 1) - (batch, 1, seq_len) = (batch, seq_len, seq_len)
+        distance = residue_ids.unsqueeze(2) - residue_ids.unsqueeze(1)
+        
+        # Clamp to max distance range and shift to 0-indexed
+        distance_clamped = distance.clamp(-self.max_distance, self.max_distance)
+        distance_idx = distance_clamped + self.max_distance  # Now 0 to 2*max_distance
+        
+        # Look up bias: (batch, seq_len, seq_len, num_heads)
+        bias = self.relative_bias(distance_idx)
+        
+        # Transpose to (batch, num_heads, seq_len, seq_len)
+        bias = bias.permute(0, 3, 1, 2)
+        
+        return bias
+
+
+class CrossAttentionLayer(nn.Module):
+    """
+    Cross-attention layer for sequence-structure alignment.
+    
+    Allows sequence tokens to attend to structural atoms using attention masks.
+    """
+    
+    def __init__(self, config: MultimodalGlycanBERTConfig):
+        super().__init__()
+        self.num_heads = config.cross_attn_num_heads
+        self.hidden_size = config.seq_hidden_size
+        self.head_dim = self.hidden_size // self.num_heads
+        
+        assert self.hidden_size % self.num_heads == 0, "hidden_size must be divisible by num_heads"
+        
+        # Query from sequence, Key/Value from structure (VQ-VAE tokens)
+        self.query = nn.Linear(config.seq_hidden_size, self.hidden_size)
+        self.key = nn.Linear(config.struct_hidden_size, self.hidden_size)
+        self.value = nn.Linear(config.struct_hidden_size, self.hidden_size)
+        
+        self.output = nn.Linear(self.hidden_size, config.seq_hidden_size)
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.layer_norm = nn.LayerNorm(config.seq_hidden_size, eps=config.layer_norm_eps)
+    
+    def forward(
+        self,
+        seq_hidden: torch.Tensor,  # (batch, seq_len, seq_hidden)
+        struct_hidden: torch.Tensor,  # (batch, struct_len, struct_hidden)
+        attention_mask: Optional[torch.Tensor] = None,  # (batch, seq_len, struct_len)
+    ) -> torch.Tensor:
+        """
+        Apply cross-attention from sequence to structure.
+        
+        Args:
+            seq_hidden: Sequence hidden states
+            struct_hidden: Structure hidden states
+            attention_mask: Boolean mask (True = can attend, False = cannot attend)
+        
+        Returns:
+            Updated sequence hidden states
+        """
+        batch_size, seq_len, _ = seq_hidden.shape
+        struct_len = struct_hidden.shape[1]
+        
+        # Project to Q, K, V
+        Q = self.query(seq_hidden)  # (batch, seq_len, hidden)
+        K = self.key(struct_hidden)  # (batch, struct_len, hidden)
+        V = self.value(struct_hidden)  # (batch, struct_len, hidden)
+        
+        # Reshape for multi-head attention
+        Q = Q.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, seq_len, head_dim)
+        K = K.view(batch_size, struct_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, struct_len, head_dim)
+        V = V.view(batch_size, struct_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, struct_len, head_dim)
+        
+        # Compute attention scores
+        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.head_dim)  # (batch, heads, seq_len, struct_len)
+        
+        # Apply attention mask
+        if attention_mask is not None:
+            # attention_mask: (batch, seq_len, struct_len) -> (batch, 1, seq_len, struct_len)
+            attention_mask = attention_mask.unsqueeze(1)
+            # Convert boolean mask to float: True -> 0.0, False -> -10000.0
+            attention_mask = (~attention_mask).float() * -10000.0
+            scores = scores + attention_mask
+        
+        # Softmax and dropout
+        attn_weights = torch.softmax(scores, dim=-1)  # (batch, heads, seq_len, struct_len)
+        attn_weights = self.dropout(attn_weights)
+        
+        # Apply attention to values
+        context = torch.matmul(attn_weights, V)  # (batch, heads, seq_len, head_dim)
+        
+        # Reshape back
+        context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.hidden_size)
+        
+        # Output projection
+        output = self.output(context)
+        output = self.dropout(output)
+        
+        # Residual connection + layer norm
+        output = self.layer_norm(seq_hidden + output)
+        
+        return output
+
+
+class MultimodalGlycanBERT(nn.Module):
+    """
+    Multimodal BERT for glycan representation learning (v3).
+    
+    Architecture:
+    1. Separate encoders for each modality (sequence, MS, 3D structure)
+    2. Cross-attention for sequence-structure alignment
+    3. Modality-specific MLM heads
+    4. Fusion layer for combined representation
+    """
+    
+    def __init__(self, config: MultimodalGlycanBERTConfig):
+        super().__init__()
+        self.config = config
+        
+        # ===== Sequence Encoder =====
+        seq_config = config.to_seq_config()
+        seq_config.cnn_kernel_size = config.cnn_kernel_size
+
+        if config.use_cnn_frontend:
+            print(f"✅ Enabled Convolutional Front-End (Kernel={config.cnn_kernel_size})")
+            self.seq_embeddings = ConvGlycanBERTEmbeddings(seq_config)
+        else:
+            self.seq_embeddings = GlycanBERTEmbeddings(seq_config)
+        self.seq_layers = nn.ModuleList([GlycanBERTLayer(seq_config) for _ in range(seq_config.num_hidden_layers)])
+        self.seq_mlm_head = nn.Linear(seq_config.hidden_size, seq_config.vocab_size)
+        
+        # ===== MS Encoder =====
+        ms_config = config.to_ms_config()
+        self.ms_embeddings = GlycanBERTEmbeddings(ms_config)
+        self.ms_layers = nn.ModuleList([GlycanBERTLayer(ms_config) for _ in range(ms_config.num_hidden_layers)])
+        self.ms_mlm_head = nn.Linear(ms_config.hidden_size, ms_config.vocab_size)
+        
+        # ===== Structure Encoder (VQ-VAE tokens) =====
+        if config.use_3d:
+            struct_config = config.to_struct_config()
+            self.struct_embeddings = GlycanBERTEmbeddings(struct_config)
+            self.struct_layers = nn.ModuleList([GlycanBERTLayer(struct_config) for _ in range(struct_config.num_hidden_layers)])
+            self.struct_mlm_head = nn.Linear(struct_config.hidden_size, struct_config.vocab_size)
+            
+            # Cross-attention layer (sequence → VQ-VAE structural tokens)
+            if config.use_cross_attention:
+                self.cross_attention = CrossAttentionLayer(config)
+        
+        # ===== Projection layers (align hidden sizes) =====
+        if config.ms_hidden_size != config.seq_hidden_size:
+            self.ms_projection = nn.Linear(config.ms_hidden_size, config.seq_hidden_size)
+        else:
+            self.ms_projection = nn.Identity()
+        
+        if config.use_3d and config.struct_hidden_size != config.seq_hidden_size:
+            self.struct_projection = nn.Linear(config.struct_hidden_size, config.seq_hidden_size)
+        else:
+            self.struct_projection = nn.Identity()
+        
+        # ===== Fusion Layer =====
+        # Concatenate seq + ms + struct
+        fusion_input_size = config.seq_hidden_size * (3 if config.use_3d else 2)
+        self.fusion_layer = nn.Sequential(
+            nn.Linear(fusion_input_size, config.fusion_hidden_size),
+            nn.LayerNorm(config.fusion_hidden_size, eps=config.layer_norm_eps),
+            nn.GELU(),
+            nn.Dropout(config.hidden_dropout_prob),
+            nn.Linear(config.fusion_hidden_size, config.fusion_hidden_size),
+        )
+        
+        # ===== Distance Prediction Head (Topology) =====
+        # OPTIMIZED: Project down to 128 dim first to save GPU memory
+        # (Batch, 256, 256, 768) -> (Batch, 256, 256, 128) reduces memory by 6x
+        self.dist_proj = nn.Linear(config.seq_hidden_size, 128)
+        self.distance_head = nn.Sequential(
+            nn.Linear(128, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1)
+        )
+        
+        # Initialize weights
+        self.apply(self._init_weights)
+    
+    def _init_weights(self, module):
+        """Initialize weights."""
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+    
+    def forward(
+        self,
+        seq_token_ids: torch.Tensor,
+        seq_attention_mask: torch.Tensor,
+        seq_residue_ids: torch.Tensor,
+        seq_branch_depths: Optional[torch.Tensor] = None,  # NEW: Branch depths
+        seq_linkage_types: Optional[torch.Tensor] = None,  # NEW: Linkage types
+        ms_token_ids: torch.Tensor = None,
+        ms_attention_mask: torch.Tensor = None,
+        has_ms: torch.Tensor = None,
+        struct_token_ids: Optional[torch.Tensor] = None,
+        struct_attention_mask: Optional[torch.Tensor] = None,
+        struct_residue_ids: Optional[torch.Tensor] = None,
+        has_3d: Optional[torch.Tensor] = None,
+        seq_labels: Optional[torch.Tensor] = None,
+        ms_labels: Optional[torch.Tensor] = None,
+        struct_labels: Optional[torch.Tensor] = None,
+        dist_labels: Optional[torch.Tensor] = None,  # NEW: Topology distance labels
+        return_dict: bool = True,
+    ) -> Dict[str, torch.Tensor]:
+        """
+        Forward pass for multimodal BERT v3.
+        
+        Args:
+            seq_token_ids: (batch_size, seq_len) - Sequence token IDs
+            seq_attention_mask: (batch_size, seq_len) - Sequence attention mask
+            seq_residue_ids: (batch_size, seq_len) - Sequence token residue IDs
+            ms_token_ids: (batch_size, ms_len) - MS token IDs
+            ms_attention_mask: (batch_size, ms_len) - MS attention mask
+            has_ms: (batch_size,) - Boolean mask for samples with MS data
+            struct_token_ids: (batch_size, struct_len) - Structure VQ-VAE token IDs (optional)
+            struct_attention_mask: (batch_size, struct_len) - Structure attention mask (optional)
+            struct_residue_ids: (batch_size, struct_len) - Structure token residue IDs (optional)
+            has_3d: (batch_size,) - Boolean mask for samples with 3D data (optional)
+            seq_labels: (batch_size, seq_len) - Masked sequence labels (optional)
+            ms_labels: (batch_size, ms_len) - Masked MS labels (optional)
+            struct_labels: (batch_size, struct_len) - Masked structure labels (optional)
+            return_dict: Whether to return dict or tuple
+        
+        Returns:
+            Dictionary containing logits, hidden states, losses, etc.
+        """
+        batch_size = seq_token_ids.shape[0]
+        device = seq_token_ids.device
+        
+        # ===== Sequence Encoder =====
+        # Pass branch_depths and linkage_types to embeddings for tree-aware encoding
+        seq_hidden = self.seq_embeddings(seq_token_ids, seq_branch_depths, seq_linkage_types)
+        for layer in self.seq_layers:
+            seq_hidden = layer(seq_hidden, seq_attention_mask)
+        
+        seq_pooled = seq_hidden[:, 0, :]  # [CLS] token
+        seq_logits = self.seq_mlm_head(seq_hidden)
+        
+        # ===== Distance Predictions (Topology) =====
+        # Compute pairwise distance predictions
+        # MEMORY OPTIMIZATION: Project to 128-dim first
+        seq_hidden_small = self.dist_proj(seq_hidden) # (batch, seq_len, 128)
+        
+        # Expand for pairwise: (batch, seq_len, 1, 128) - (batch, 1, seq_len, 128)
+        h_i = seq_hidden_small.unsqueeze(2)
+        h_j = seq_hidden_small.unsqueeze(1)
+        h_diff = torch.abs(h_i - h_j)  # (batch, seq_len, seq_len, 128) - Much smaller!
+        dist_predictions = self.distance_head(h_diff)  # (batch, seq_len, seq_len, 1)
+        
+        # ===== MS Encoder =====
+        ms_hidden = None
+        ms_pooled = None
+        ms_logits = None
+        
+        if ms_token_ids is not None:
+            ms_hidden = self.ms_embeddings(ms_token_ids)
+            for layer in self.ms_layers:
+                ms_hidden = layer(ms_hidden, ms_attention_mask)
+            
+            ms_pooled = ms_hidden[:, 0, :]  # [CLS] token
+            ms_logits = self.ms_mlm_head(ms_hidden)
+            
+            # Zero out MS representations for samples without MS data
+            if has_ms is not None:
+                has_ms_expanded = has_ms.unsqueeze(1).float()  # (batch, 1)
+                ms_pooled = ms_pooled * has_ms_expanded
+        
+        # ===== Structure Encoder =====
+        struct_pooled = None
+        struct_logits = None
+        struct_hidden = None
+        
+        if self.config.use_3d and struct_token_ids is not None:
+            struct_hidden = self.struct_embeddings(struct_token_ids)
+            for layer in self.struct_layers:
+                struct_hidden = layer(struct_hidden, struct_attention_mask)
+            
+            struct_pooled = struct_hidden[:, 0, :]  # [CLS] token
+            struct_logits = self.struct_mlm_head(struct_hidden)
+            
+            # Zero out structure representations for samples without 3D data
+            if has_3d is not None:
+                has_3d_expanded = has_3d.unsqueeze(1).float()  # (batch, 1)
+                struct_pooled = struct_pooled * has_3d_expanded
+            
+            # ===== Cross-Attention (Sequence → VQ-VAE Structural Tokens) =====
+            # Use residue-level alignment between WURCS tokens and VQ-VAE tokens
+            if self.config.use_cross_attention and struct_residue_ids is not None:
+                # Create residue-level mask
+                # WURCS token with residue_id=0 → VQ-VAE tokens with residue_id=0
+                residue_mask = create_residue_level_mask(
+                    seq_residue_ids=seq_residue_ids,
+                    struct_residue_ids=struct_residue_ids,
+                )  # (batch, N_seq, N_struct)
+                
+                # Apply cross-attention: sequence tokens attend to VQ-VAE tokens
+                seq_hidden = self.cross_attention(
+                    seq_hidden=seq_hidden,
+                    struct_hidden=struct_hidden,  # VQ-VAE token features
+                    attention_mask=residue_mask,  # Residue-based mask
+                )
+                
+                # Update seq_pooled after cross-attention
+                seq_pooled = seq_hidden[:, 0, :]
+        
+        # ===== Fusion =====
+        # Project to common hidden size
+        ms_pooled_projected = self.ms_projection(ms_pooled)
+        
+        if self.config.use_3d and struct_pooled is not None:
+            struct_pooled_projected = self.struct_projection(struct_pooled)
+            combined = torch.cat([seq_pooled, ms_pooled_projected, struct_pooled_projected], dim=-1)
+        else:
+            combined = torch.cat([seq_pooled, ms_pooled_projected], dim=-1)
+        
+        fused_repr = self.fusion_layer(combined)
+        
+        # ===== Compute Losses =====
+        total_loss = None
+        seq_loss = None
+        ms_loss = None
+        struct_loss = None
+        dist_loss = None  # NEW: Topology distance loss
+        
+        if seq_labels is not None:
+            loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+            seq_loss = loss_fct(
+                seq_logits.view(-1, self.config.seq_vocab_size),
+                seq_labels.view(-1)
+            )
+        
+        if ms_labels is not None:
+            ms_labels_masked = ms_labels.clone()
+            ms_labels_masked[~has_ms] = -100
+            # Only compute loss if there are valid labels (not all -100)
+            if (ms_labels_masked != -100).any():
+                loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+                ms_loss = loss_fct(
+                    ms_logits.view(-1, self.config.ms_total_vocab_size),
+                    ms_labels_masked.view(-1)
+                )
+            else:
+                ms_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        
+        if self.config.use_3d and struct_labels is not None and struct_logits is not None:
+            struct_labels_masked = struct_labels.clone()
+            if has_3d is not None:
+                struct_labels_masked[~has_3d] = -100
+            # Only compute loss if there are valid labels (not all -100)
+            if (struct_labels_masked != -100).any():
+                loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+                struct_loss = loss_fct(
+                    struct_logits.view(-1, self.config.struct_vocab_size),
+                    struct_labels_masked.view(-1)
+                )
+            else:
+                struct_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        
+        # ===== Distance Loss (Topology) =====
+        if dist_labels is not None:
+            # dist_predictions: (Batch, Seq, Seq, 1) -> (Batch, Seq, Seq)
+            preds = dist_predictions.squeeze(-1)
+            
+            # Create mask for valid distance pairs (label != -1)
+            # Also respect attention mask to avoid padding
+            valid_mask = (dist_labels != -1) & (seq_attention_mask.unsqueeze(1) * seq_attention_mask.unsqueeze(2) == 1)
+            
+            # DEBUG: Print once
+            if not hasattr(self, '_dist_debug_printed'):
+                print(f"[DIST DEBUG] dist_labels shape: {dist_labels.shape}, valid_mask.sum: {valid_mask.sum().item()}")
+                self._dist_debug_printed = True
+            
+            if valid_mask.sum() > 0:
+                # MSE loss on valid positions only
+                loss_fct = nn.MSELoss()
+                dist_loss = loss_fct(preds[valid_mask], dist_labels[valid_mask].float())
+            else:
+                dist_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        else:
+            # DEBUG: dist_labels is None
+            if not hasattr(self, '_dist_none_printed'):
+                print("[DIST DEBUG] dist_labels is None!")
+                self._dist_none_printed = True
+        
+        # Weighted combination
+        losses = []
+        if seq_loss is not None:
+            losses.append(self.config.seq_loss_weight * seq_loss)
+        if ms_loss is not None:
+            losses.append(self.config.ms_loss_weight * ms_loss)
+        if struct_loss is not None:
+            losses.append(self.config.struct_loss_weight * struct_loss)
+        if dist_loss is not None:
+            losses.append(self.config.dist_loss_weight * dist_loss)
+        
+        if losses:
+            total_loss = sum(losses)
+        
+        if return_dict:
+            return {
+                'loss': total_loss,
+                'seq_loss': seq_loss,
+                'ms_loss': ms_loss,
+                'struct_loss': struct_loss,
+                'dist_loss': dist_loss,  # NEW: Topology loss
+                'seq_logits': seq_logits,
+                'ms_logits': ms_logits,
+                'struct_logits': struct_logits,
+                'dist_predictions': dist_predictions,  # NEW: Distance predictions
+                'seq_hidden': seq_hidden,
+                'ms_hidden': ms_hidden,
+                'struct_hidden': struct_hidden,
+                'seq_pooled': seq_pooled,
+                'ms_pooled': ms_pooled,
+                'struct_pooled': struct_pooled,
+                'fused_repr': fused_repr,
+            }
+        else:
+            return (total_loss, seq_logits, ms_logits, struct_logits, fused_repr)
+    
+    def get_multimodal_representation(
+        self,
+        seq_token_ids: torch.Tensor,
+        seq_attention_mask: torch.Tensor,
+        seq_residue_ids: torch.Tensor,
+        ms_token_ids: torch.Tensor,
+        ms_attention_mask: torch.Tensor,
+        has_ms: torch.Tensor,
+        struct_token_ids: Optional[torch.Tensor] = None,
+        struct_attention_mask: Optional[torch.Tensor] = None,
+        struct_residue_ids: Optional[torch.Tensor] = None,
+        has_3d: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        """Get fused multimodal representation (for inference)."""
+        outputs = self.forward(
+            seq_token_ids=seq_token_ids,
+            seq_attention_mask=seq_attention_mask,
+            seq_residue_ids=seq_residue_ids,
+            ms_token_ids=ms_token_ids,
+            ms_attention_mask=ms_attention_mask,
+            has_ms=has_ms,
+            struct_token_ids=struct_token_ids,
+            struct_attention_mask=struct_attention_mask,
+            struct_residue_ids=struct_residue_ids,
+            has_3d=has_3d,
+            return_dict=True,
+        )
+        return outputs['fused_repr']
+
+
+if __name__ == "__main__":
+    # Test the model
+    print("="*80)
+    print("Testing Multimodal GlycanBERT v3")
+    print("="*80)
+    
+    # Create config
+    config = MultimodalGlycanBERTConfig(
+        seq_vocab_size=166,
+        seq_hidden_size=768,
+        seq_num_layers=12,
+        seq_num_heads=12,
+        ms_vocab_size=242,
+        ms_hidden_size=384,
+        ms_num_layers=6,
+        ms_num_heads=6,
+        struct_vocab_size=1024,
+        struct_hidden_size=512,
+        struct_num_layers=8,
+        struct_num_heads=8,
+        use_3d=True,
+        use_cross_attention=True,
+        seq_loss_weight=0.60,
+        ms_loss_weight=0.15,
+        struct_loss_weight=0.25,
+    )
+    
+    print(f"\nConfig:")
+    print(f"  Sequence vocab: {config.seq_vocab_size}")
+    print(f"  MS vocab: {config.ms_vocab_size}")
+    print(f"  Structure vocab: {config.struct_vocab_size}")
+    print(f"  Loss weights: seq={config.seq_loss_weight}, ms={config.ms_loss_weight}, struct={config.struct_loss_weight}")
+    
+    # Create model
+    model = MultimodalGlycanBERT(config)
+    
+    # Count parameters
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    
+    print(f"\nModel Parameters:")
+    print(f"  Total: {total_params:,}")
+    print(f"  Trainable: {trainable_params:,}")
+    
+    # Test forward pass
+    print(f"\n{'='*80}")
+    print("Testing Forward Pass (with Conv front-end)")
+    print("="*80)
+    
+    batch_size = 4
+    seq_len = 128
+    ms_len = 50
+    struct_len = 40
+    
+    # Create dummy inputs
+    seq_token_ids = torch.randint(0, config.seq_vocab_size, (batch_size, seq_len))
+    seq_attention_mask = torch.ones(batch_size, seq_len)
+    # Approximate: ~5 tokens per residue
+    seq_residue_ids = torch.div(
+        torch.arange(seq_len), 5, rounding_mode="floor"
+    ).unsqueeze(0).expand(batch_size, -1)
+
+    ms_token_ids = torch.randint(config.ms_vocab_offset, config.ms_total_vocab_size, (batch_size, ms_len))
+    ms_attention_mask = torch.ones(batch_size, ms_len)
+    struct_token_ids = torch.randint(0, config.struct_vocab_size, (batch_size, struct_len))
+    struct_attention_mask = torch.ones(batch_size, struct_len)
+    # Approximate: 4 tokens per residue for VQ-VAE tokens
+    struct_residue_ids = torch.div(
+        torch.arange(struct_len), 4, rounding_mode="floor"
+    ).unsqueeze(0).expand(batch_size, -1)
+
+    has_ms = torch.tensor([True, True, False, True])
+    has_3d = torch.tensor([True, False, True, True])
+    
+    # Create labels for MLM
+    seq_labels = seq_token_ids.clone()
+    seq_labels[seq_labels != config.mask_token_id] = -100
+    ms_labels = ms_token_ids.clone()
+    ms_labels[ms_labels != config.mask_token_id] = -100
+    struct_labels = struct_token_ids.clone()
+    struct_labels[struct_labels != config.mask_token_id] = -100
+    
+    # Forward pass
+    outputs = model(
+        seq_token_ids=seq_token_ids,
+        seq_attention_mask=seq_attention_mask,
+        seq_residue_ids=seq_residue_ids,
+        ms_token_ids=ms_token_ids,
+        ms_attention_mask=ms_attention_mask,
+        has_ms=has_ms,
+        struct_token_ids=struct_token_ids,
+        struct_attention_mask=struct_attention_mask,
+        struct_residue_ids=struct_residue_ids,
+        has_3d=has_3d,
+        seq_labels=seq_labels,
+        ms_labels=ms_labels,
+        struct_labels=struct_labels,
+    )
+    
+    print(f"\nOutput shapes:")
+    print(f"  seq_logits: {outputs['seq_logits'].shape}")
+    print(f"  ms_logits: {outputs['ms_logits'].shape}")
+    print(f"  struct_logits: {outputs['struct_logits'].shape}")
+    print(f"  fused_repr: {outputs['fused_repr'].shape}")
+    
+    print(f"\nLosses:")
+    print(f"  Total loss: {outputs['loss'].item():.4f}")
+    print(f"  Sequence loss: {outputs['seq_loss'].item():.4f}")
+    print(f"  MS loss: {outputs['ms_loss'].item():.4f}")
+    print(f"  Structure loss: {outputs['struct_loss'].item():.4f}")
+    
+    print(f"\n{'='*80}")
+    print("Model Test Complete!")
+    print("="*80)

releases/2026-10-02/bertose_source/training/a5_wurcs_bpe.py

@@ -0,0 +1,368 @@
+"""Deterministic train-only WURCS BPE utilities for A5."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Iterable, Optional
+
+from .a5_topology import node_index, node_label
+
+try:
+    from bert_training_v4.downstream_tasks.utils.wurcs_bpe_tokenizer import (
+        WURCSBPETokenizer,
+        WURCSPreTokenizer,
+    )
+except ImportError:
+    from ..bert_training_v4.downstream_tasks.utils.wurcs_bpe_tokenizer import (
+        WURCSBPETokenizer,
+        WURCSPreTokenizer,
+    )
+
+
+SUBMITTED_FIT_ALPHABET = tuple(
+    "#$%()*-./0123456789<=>?ABCDEFGHIJKLMNOPQRSTUVWXYZ^abcdefghijklmnopqrstuvwxyz{|}~"
+)
+
+
+class _TopLevelBracketPattern:
+    """Expose regex-like findall while respecting nested SMILES brackets."""
+
+    @staticmethod
+    def findall(text: str) -> list[str]:
+        residues: list[str] = []
+        depth = 0
+        start = -1
+        for index, character in enumerate(text):
+            if character == "[":
+                if depth == 0:
+                    start = index + 1
+                depth += 1
+            elif character == "]" and depth:
+                depth -= 1
+                if depth == 0 and start >= 0:
+                    residues.append(text[start:index])
+                    start = -1
+        if depth:
+            return []
+        return residues
+
+
+class A5WURCSPreTokenizer(WURCSPreTokenizer):
+    """Submitted pre-tokenizer with nested bracket-safe residue extraction."""
+
+    A5_LINKAGE_PATTERN = re.compile(
+        r"([A-Za-z]+)(\d+|\?)-([A-Za-z]+)(\d+|\?)"
+    )
+    A5_ANOMERIC_PATTERN = re.compile(r"-([0-9]+)([abuxo])(?:_|$)")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.RESIDUE_PATTERN = _TopLevelBracketPattern()
+
+    def _split_wurcs_sections(self, wurcs: str) -> list[str]:
+        sections = super()._split_wurcs_sections(wurcs)
+        if len(sections) <= 5:
+            return sections
+        # WURCS LIN modifications may contain unbracketed slashes. The format
+        # has exactly five top-level sections, so every trailing fragment
+        # belongs to the linkage section rather than a new section.
+        return sections[:4] + ["/".join(sections[4:])]
+
+    def _instance_anomeric_positions(
+        self, residue_definitions: list[str], index_list: list[str]
+    ) -> list[int | None]:
+        positions: list[int | None] = []
+        for definition_index in index_list:
+            try:
+                residue_definition = residue_definitions[int(definition_index) - 1]
+            except (IndexError, ValueError):
+                positions.append(None)
+                continue
+            match = self.A5_ANOMERIC_PATTERN.search(residue_definition)
+            positions.append(int(match.group(1)) if match is not None else None)
+        return positions
+
+    def _analyze_a5_tree(
+        self,
+        linkages: list[str],
+        residue_count: int,
+        anomeric_positions: list[int | None] | None = None,
+    ) -> tuple[dict[str, int], dict[str, int], dict[int, list[int]]]:
+        branch_points: dict[str, int] = defaultdict(int)
+        children: dict[str, list[str]] = defaultdict(list)
+        all_residues: set[str] = set()
+        adjacency: dict[int, list[int]] = defaultdict(list)
+        for linkage in linkages:
+            match = self.A5_LINKAGE_PATTERN.match(linkage)
+            if not match:
+                continue
+            left, left_position, right, right_position = match.groups()
+            try:
+                left_index = node_index(left) - 1
+                right_index = node_index(right) - 1
+            except ValueError:
+                continue
+            if not (
+                0 <= left_index < residue_count
+                and 0 <= right_index < residue_count
+                and left_index != right_index
+            ):
+                continue
+            parent, child = left, right
+            if anomeric_positions is not None:
+                left_anomeric = anomeric_positions[left_index]
+                right_anomeric = anomeric_positions[right_index]
+                left_is_donor = (
+                    left_position != "?"
+                    and left_anomeric is not None
+                    and int(left_position) == left_anomeric
+                )
+                right_is_donor = (
+                    right_position != "?"
+                    and right_anomeric is not None
+                    and int(right_position) == right_anomeric
+                )
+                if left_is_donor and not right_is_donor:
+                    parent, child = right, left
+                elif right_is_donor and not left_is_donor:
+                    parent, child = left, right
+            children[parent].append(child)
+            all_residues.update((parent, child))
+            adjacency[left_index].append(right_index)
+            adjacency[right_index].append(left_index)
+
+        for residue, child_labels in children.items():
+            if len(child_labels) > 1:
+                branch_points[residue] = len(child_labels) - 1
+        child_set = {child for values in children.values() for child in values}
+        roots = all_residues - child_set
+        root = min(roots, key=node_index) if roots else node_label(1)
+        depths = {root: 0}
+        queue = [root]
+        while queue:
+            current = queue.pop(0)
+            for child in children.get(current, []):
+                if child not in depths:
+                    depths[child] = depths[current] + 1
+                    queue.append(child)
+        return dict(branch_points), depths, adjacency
+
+    def _a5_linkage_type(self, linkage: str) -> int:
+        match = self.A5_LINKAGE_PATTERN.match(linkage)
+        if not match:
+            return 8
+        _, from_position, _, to_position = match.groups()
+        try:
+            positions = (int(from_position), int(to_position))
+        except ValueError:
+            return 8
+        linkage_types = {
+            (1, 2): 0,
+            (2, 1): 0,
+            (1, 3): 1,
+            (3, 1): 1,
+            (1, 4): 2,
+            (4, 1): 2,
+            (1, 6): 3,
+            (6, 1): 3,
+            (2, 3): 4,
+            (3, 2): 4,
+            (2, 6): 5,
+            (6, 2): 5,
+            (3, 6): 6,
+            (6, 3): 6,
+        }
+        return linkage_types.get(positions, 7)
+
+    def pre_tokenize(self, wurcs: str) -> list[dict]:
+        # Reuse the submitted semantic split, then correct only its tree
+        # annotations. This keeps the BPE unit text and special-token behavior.
+        inherited_units = super().pre_tokenize(wurcs)
+        try:
+            parts = self._split_wurcs_sections(wurcs)
+            index_list = parts[3].split("-") if len(parts) > 3 and parts[3] else []
+            linkages = parts[4].split("_") if len(parts) > 4 and parts[4] else []
+            residue_definitions = self.RESIDUE_PATTERN.findall(parts[2])
+            anomeric_positions = self._instance_anomeric_positions(
+                residue_definitions, index_list
+            )
+            branch_points, depths, adjacency = self._analyze_a5_tree(
+                linkages, len(index_list), anomeric_positions
+            )
+        except (IndexError, ValueError):
+            return inherited_units
+
+        units: list[dict] = []
+        opened_residues: set[int] = set()
+        for inherited in inherited_units:
+            if inherited.get("text") == "[BRANCH_OPEN]":
+                continue
+            unit = dict(inherited)
+            residue_id = int(unit.get("residue_id", -1))
+            if residue_id >= 0:
+                label = node_label(residue_id + 1)
+                if residue_id not in opened_residues:
+                    for _ in range(branch_points.get(label, 0)):
+                        units.append(
+                            {
+                                "text": "[BRANCH_OPEN]",
+                                "type": "special",
+                                "residue_id": -1,
+                                "branch_depth": depths.get(label, 0),
+                                "linkage_type": 0,
+                            }
+                        )
+                    opened_residues.add(residue_id)
+                unit["branch_depth"] = depths.get(label, 0)
+            elif unit.get("type") == "linkage":
+                unit["linkage_type"] = self._a5_linkage_type(str(unit["text"]))
+            units.append(unit)
+
+        if units:
+            units[0]["distance_matrix"] = self._compute_distance_matrix(
+                adjacency, len(index_list)
+            )
+        return units
+
+
+class A5WURCSBPETokenizer(WURCSBPETokenizer):
+    """Train-only BPE with a fit-derived alphabet and deterministic merge ties."""
+
+    def __init__(self, vocab_path: Optional[str | Path] = None) -> None:
+        super().__init__(str(vocab_path) if vocab_path is not None else None)
+        self.pre_tokenizer = A5WURCSPreTokenizer()
+
+    @classmethod
+    def train_from_fit_corpus(
+        cls,
+        wurcs_strings: Iterable[str],
+        num_merges: int = 2000,
+        output_path: Optional[str | Path] = None,
+        min_frequency: int = 2,
+        max_token_length: Optional[int] = None,
+    ) -> "A5WURCSBPETokenizer":
+        tokenizer = cls()
+        pre_tokenizer = tokenizer.pre_tokenizer
+        unit_counts: Counter[str] = Counter()
+        for wurcs in wurcs_strings:
+            for unit in pre_tokenizer.pre_tokenize(wurcs):
+                if unit["type"] != "special":
+                    unit_counts[unit["text"]] += 1
+
+        # The submitted tokenizer learned the base character inventory from its
+        # corpus. Preserve that behavior, but fit it from training parents only.
+        tokenizer.fit_alphabet = tuple(
+            sorted({char for unit in unit_counts for char in unit})
+        )
+
+        next_id = len(tokenizer.special_tokens)
+        for char in tokenizer.fit_alphabet:
+            tokenizer.token_to_id[char] = next_id
+            tokenizer.id_to_token[next_id] = char
+            next_id += 1
+
+        word_freqs: dict[tuple[str, ...], int] = {
+            tuple(unit): count
+            for unit, count in sorted(unit_counts.items())
+            if count >= min_frequency
+        }
+        merges: list[tuple[str, str]] = []
+        for _ in range(num_merges):
+            pair_counts: Counter[tuple[str, str]] = Counter()
+            for word, frequency in word_freqs.items():
+                for index in range(len(word) - 1):
+                    pair_counts[(word[index], word[index + 1])] += frequency
+            candidates = [
+                (pair, count)
+                for pair, count in pair_counts.items()
+                if count >= min_frequency
+                and (
+                    max_token_length is None
+                    or len(pair[0]) + len(pair[1]) <= max_token_length
+                )
+            ]
+            if not candidates:
+                break
+            best_pair, _ = min(
+                candidates,
+                key=lambda item: (-item[1], item[0][0], item[0][1]),
+            )
+            new_token = best_pair[0] + best_pair[1]
+            merges.append(best_pair)
+            tokenizer.token_to_id[new_token] = next_id
+            tokenizer.id_to_token[next_id] = new_token
+            next_id += 1
+
+            merged_freqs: Counter[tuple[str, ...]] = Counter()
+            for word, frequency in word_freqs.items():
+                merged_word: list[str] = []
+                index = 0
+                while index < len(word):
+                    if (
+                        index < len(word) - 1
+                        and word[index] == best_pair[0]
+                        and word[index + 1] == best_pair[1]
+                    ):
+                        merged_word.append(new_token)
+                        index += 2
+                    else:
+                        merged_word.append(word[index])
+                        index += 1
+                merged_freqs[tuple(merged_word)] += frequency
+            word_freqs = dict(merged_freqs)
+
+        tokenizer.merges = merges
+        if output_path is not None:
+            tokenizer.save_vocab(str(output_path))
+        return tokenizer
+
+    def tokenize_sequence(self, wurcs: str, max_length: int = 256) -> dict:
+        units = self.pre_tokenizer.pre_tokenize(wurcs)
+        tokens: list[str] = []
+        token_ids: list[int] = []
+        residue_ids: list[int] = []
+        branch_depths: list[int] = []
+        linkage_types: list[int] = []
+
+        for unit in units:
+            unit_tokens = (
+                [unit["text"]]
+                if unit["type"] == "special"
+                else self.apply_bpe(unit["text"])
+            )
+            for token in unit_tokens:
+                tokens.append(token)
+                token_ids.append(
+                    self.token_to_id.get(token, self.token_to_id["[UNK]"])
+                )
+                residue_ids.append(int(unit["residue_id"]))
+                branch_depths.append(int(unit["branch_depth"]))
+                linkage_types.append(int(unit["linkage_type"]))
+
+        if len(tokens) > max_length:
+            tokens = tokens[: max_length - 1] + ["[END]"]
+            token_ids = token_ids[: max_length - 1] + [self.token_to_id["[END]"]]
+            residue_ids = residue_ids[: max_length - 1] + [-1]
+            branch_depths = branch_depths[: max_length - 1] + [0]
+            linkage_types = linkage_types[: max_length - 1] + [0]
+
+        length = len(tokens)
+        attention_mask = [1] * length
+        padding = max_length - length
+        tokens.extend(["[PAD]"] * padding)
+        token_ids.extend([self.token_to_id["[PAD]"]] * padding)
+        residue_ids.extend([-1] * padding)
+        branch_depths.extend([0] * padding)
+        linkage_types.extend([0] * padding)
+        attention_mask.extend([0] * padding)
+        return {
+            "tokens": tokens,
+            "token_ids": token_ids,
+            "residue_ids": residue_ids,
+            "branch_depths": branch_depths,
+            "linkage_types": linkage_types,
+            "attention_mask": attention_mask,
+            "length": length,
+        }

releases/2026-10-02/bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_cuda_resume_diagnostic_20260727_r5_submission_readback_11767377/review_a5_native_eight_cuda_resume_diagnostic_r5_11767377_terminal_certification_receipt.json

@@ -0,0 +1,135 @@
+{
+  "schema": "bertose_review_a5_native_eight_cuda_resume_diagnostic_r5_terminal_certification_20260727",
+  "status": "PASS_TERMINAL_CERTIFIED_REAL_CUDA_EXACT_RESUME",
+  "job": {
+    "job_id": "11767377",
+    "job_name": "a5-n8-cuda-resume-r5",
+    "state": "COMPLETED",
+    "exit_code": "0:0",
+    "submit_time": "2026-07-26T16:38:45",
+    "eligible_time": "2026-07-26T16:38:45",
+    "start_time": "2026-07-26T16:38:48",
+    "end_time": "2026-07-26T16:41:19",
+    "scheduler_wait_seconds": 3,
+    "elapsed": "00:02:31",
+    "restarts": 0,
+    "node": "nova18-singularity"
+  },
+  "route": {
+    "partition": "interactive",
+    "account": "ratul",
+    "qos": "normal",
+    "requested_gres": "gpu:1",
+    "gpu_feature_constraint": null,
+    "allocated_gpu": "v100-sxm2-32g",
+    "allocated_gpu_count": 1,
+    "cpus": 4,
+    "memory": "16G",
+    "time_limit": "00:30:00",
+    "requeue": false
+  },
+  "frozen_submission": {
+    "runner_sha256": "3e561dceed9a4a05b720b46598d18b7f98cf04e49dbe8ccf228afb1aa5f236b5",
+    "runner_bytes": 11473,
+    "sbatch_sha256": "87dadccc4b99db12acdd5f62f5429444489f403fddcd12ceaa9225208defb547",
+    "sbatch_bytes": 2346,
+    "submission_readback_receipt_sha256": "4824c00d3e28ee15cab63401204ff2c6b2aaa250012b97fd1776dacc6e36266c",
+    "submission_readback_receipt_bytes": 3307,
+    "submission_count": 1,
+    "other_runnable_copy_count_after_terminal": 0
+  },
+  "terminal_scheduler_readback": {
+    "scontrol_sha256": "b5e8b47da0a15a3cedfea54a85a397b744affddae2d5bffae394c40b754b1d10",
+    "scontrol_bytes": 2450,
+    "sacct_sha256": "fd3a55dc63abd830ec2620f7f637e51871552f663466c6496a9a72ed7eb18216",
+    "sacct_bytes": 300
+  },
+  "cuda_success_receipt": {
+    "path": "review/multimodal/outputs/review_a5_native_eight_cuda_resume_diagnostic_20260727_r5_synthetic_device_receipt_fix/review_a5_native_eight_cuda_resume_diagnostic_receipt_r5.json",
+    "file_sha256": "6a1bc65c568a17dc45f1102cd122ac43c62a8ee3b28e06ec855577857cc41ce0",
+    "bytes": 127461,
+    "self_domain_sha256": "0e491d188a71df9c51dc9deb5df8faea2f88f5096f65ac83a5cde5b53c1762a3",
+    "self_domain_sha256_verified": true,
+    "schema": "bertose_review_a5_native_eight_cuda_resume_diagnostic_20260727_r5",
+    "status": "PASS_REAL_CUDA_R7_BOTH_LOADS_EXACT_RESUME_DRAWS_AND_DEVICE_RECEIPT"
+  },
+  "cuda_exact_resume_proof": {
+    "load_latest_executed": true,
+    "load_best_executed": true,
+    "interrupted_uninterrupted_exact_match": true,
+    "python_numpy_torch_cpu_torch_cuda_next_draws_exact": true,
+    "private_generators_did_not_mutate_global_rng": true,
+    "latest_model_tensor_devices": [
+      "cuda:0"
+    ],
+    "latest_optimizer_tensor_devices": [
+      "cuda:0"
+    ],
+    "latest_rng_tensor_devices": [
+      "cpu",
+      "cpu",
+      "cpu"
+    ],
+    "best_model_tensor_devices": [
+      "cuda:0"
+    ],
+    "best_optimizer_tensor_devices": [
+      "cuda:0"
+    ],
+    "best_rng_tensor_devices": [
+      "cpu",
+      "cpu",
+      "cpu"
+    ],
+    "latest_provenance_record_lifecycle": [
+      1,
+      1,
+      0
+    ],
+    "best_provenance_record_lifecycle": [
+      1,
+      1,
+      0
+    ],
+    "negative_cuda_boundary_cases_rejected": [
+      "dtype",
+      "shape",
+      "value",
+      "mixed_device",
+      "requested_device"
+    ],
+    "negative_case_checkpoint_model_optimizer_unchanged": true,
+    "negative_case_global_rng_unchanged": true,
+    "production_runtime_source_modified": false,
+    "r7_source_modified": false,
+    "production_live_cell_claim_requested_by_synthetic_diagnostic": false
+  },
+  "output_integrity": {
+    "checkpoint_index_sha256": "9292c31195a7eddfe9f987a8cfe8cda843b283bb10a1bc8fb1b05d88f82a92d9",
+    "checkpoint_index_bytes": 796,
+    "checkpoint_payload_sha256": "6885400540a9701725519e4e476cfbca0dec700836c52c0777e9ae5858ef6bb3",
+    "checkpoint_payload_bytes": 1683243,
+    "slurm_stdout_sha256": "60c00132b50b4fcfd887f4fef35828f55c5cb3fe5562fa7a6f81d20fc64244ae",
+    "slurm_stdout_bytes": 131246,
+    "slurm_stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "slurm_stderr_bytes": 0,
+    "terminal_hash_ledger_sha256": "19036f29acc263a1b3c1a764e87bfc3c420c4420c052c7c37500a90128350808",
+    "terminal_hash_ledger_bytes": 2644,
+    "terminal_hash_ledger_entry_count": 10
+  },
+  "scope": {
+    "synthetic_isolated_fixture": true,
+    "production_review_artifacts_opened_read_only": true,
+    "production_training_examples_used": false,
+    "production_training_occurred": false,
+    "official_submitted_artifacts_modified": false,
+    "cuda_exact_resume_gate_certified": true,
+    "training_authorized": false,
+    "scientific_launch_authorized": false,
+    "nova_submission_authorized": false,
+    "native_eight_array_submission_authorized_by_this_receipt": false
+  },
+  "resubmit_authorized": false,
+  "reroute_authorized": false,
+  "cancel_authorized": false
+}

releases/2026-10-02/bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_cuda_resume_diagnostic_20260727_r5_synthetic_device_receipt_fix/review_checkpoints_r1/review_checkpoint_index.json

@@ -0,0 +1 @@
+{"cell_id":"A111","generation":1,"index_sha256":"68c0dedf930e9e4cb54f58a8cf2ab15fe6a52a2c0567b68873265856d67cc087","roles":{"best":{"bytes":1683243,"development_loss":1.0,"epoch":1,"filename":"review_checkpoint_payload_e001_6885400540a9701725519e4e476cfbca0dec700836c52c0777e9ae5858ef6bb3.pt","sha256":"6885400540a9701725519e4e476cfbca0dec700836c52c0777e9ae5858ef6bb3"},"latest":{"bytes":1683243,"development_loss":1.0,"epoch":1,"filename":"review_checkpoint_payload_e001_6885400540a9701725519e4e476cfbca0dec700836c52c0777e9ae5858ef6bb3.pt","sha256":"6885400540a9701725519e4e476cfbca0dec700836c52c0777e9ae5858ef6bb3"},"milestones":{}},"run_identity_sha256":"d35d4d8041d8a5448c68584b0c8ab9b0aeaa939fee7b1fe4fca1b606aef92f9a","schema":"bertose_review_a5_native_eight_checkpoint_index_20260722_r3"}

releases/2026-10-02/bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_data_adapter_20260721_r1/review_a5_native_eight_data_adapter_receipt_r1.json

@@ -0,0 +1,95 @@
+{
+  "artifacts": {
+    "development_manifest": {
+      "bytes": 3982015,
+      "canonical_row_surface_sha256": "92f46de77c5e1831f01dbe4f672bad19b180d8fb0ea6798040bd07ed7009112b",
+      "name": "review_a5_native_eight_joined_development_manifest_r1.tsv.gz",
+      "rows": 55440,
+      "sha256": "4eea50c1bd4eee0ea10062c287f31c619cef5835e2e660facd098698859f7e70"
+    },
+    "train_manifest": {
+      "bytes": 15455767,
+      "canonical_row_surface_sha256": "94f8e3b13bf95bed3f2768c9303d8602ecfa78d3c1d7956699c68856f33e8eef",
+      "name": "review_a5_native_eight_joined_train_manifest_r1.tsv.gz",
+      "rows": 221827,
+      "sha256": "13b7ebc78b22baa1a38d2ae40da202dcc1e20e56f44220b4d4d5003ca5f3b8f2"
+    }
+  },
+  "authority_bindings": {
+    "composite_r5": "24c35257fc61e1c9c77630d2b0075775a7f46b6500ecb5f175ef8f42bd214e0e",
+    "executor_r5": "a482a70a2edcb7c9936b091a86a0f7d98714b5bab09a0bdc80cd927f015a46f2",
+    "ms_authority": "48914855c4e458ff02452ad4db3743a4fbef12221e0313584db4c2b1bd684cd4",
+    "ms_certificate": "53098620a5c22dafdc951ba743515b4b10b1673c02f0aa4d881db669584902fa",
+    "ms_receipt": "f654177eb6fde7289b6755812c2be298084697cf0d85159b3ec9da310fe3d4b4",
+    "ms_runtime": "68c0d543c5411276ef56c7072bded4ebda886f46b9fa4ebf3c95c1e54c1a08c6",
+    "planner_r5": "1b9b05c812603db7b216aa989214a3c3715f80032b3a8b82577ae2b9e48f048d",
+    "sequence_receipt": "53b058a2032c424718a96757b3aa63df5160c20910001fcb128b0ace03a13a4c",
+    "sequence_runtime": "0b212043878ebfc7edb75929aa0cfe025df7eaf69bc526ed57b85e5cd0b4ba69",
+    "sequence_summary": "31fd5a9e015b370681a9d2bacdc1b3ebce0e9408f0cf2835affa35596110460a",
+    "static_r7_authority": "59cf794d52341847b08aaa7f4212d1203dec4df89609157d924fda50d54f7602",
+    "static_r7_receipt": "0729fa35e7a34a51ee77d2752f008a783d582b845e6c8dd9ae694eb9edb61d9c",
+    "static_r7_summary": "f95235a74962fd8aec04b0a14ad17aea3e2bcec27826102d5d26d3f907871908"
+  },
+  "availability_pattern_counts": {
+    "development": {
+      "000": 37213,
+      "001": 238,
+      "010": 339,
+      "011": 0,
+      "100": 12351,
+      "101": 5058,
+      "110": 147,
+      "111": 94
+    },
+    "train": {
+      "000": 147444,
+      "001": 978,
+      "010": 1491,
+      "011": 0,
+      "100": 49345,
+      "101": 21605,
+      "110": 567,
+      "111": 397
+    }
+  },
+  "counts": {
+    "development_sequence_parents": 55440,
+    "ms_development_acquisitions": 49573,
+    "ms_development_parents": 580,
+    "ms_train_parents": 2455,
+    "static_development_parents": 5390,
+    "static_development_states": 7964,
+    "static_exact_single_state_parents": 14368,
+    "static_open_unspecified_two_state_parents": 8951,
+    "static_train_parents": 22980,
+    "static_train_states": 34408,
+    "static_unknown_x_anomer_two_state_parents": 5051,
+    "topology_development_parents": 17650,
+    "topology_train_parents": 71914,
+    "train_sequence_parents": 221827
+  },
+  "execution_certified": false,
+  "gpu_launch_authorized": false,
+  "join_contract": {
+    "ms": "exact_parent_id_role_and_canonical_wurcs",
+    "official_or_submitted_artifacts_modified": false,
+    "sequence_topology": "authoritative_sequence_row_parent_role_and_topology_row",
+    "static": "exact_parent_id_and_role; preserve parent canonical WURCS plus every R7 state effective WURCS; x-anomer or open/unspecified parent identities expand only through the R7-declared alpha/beta states"
+  },
+  "nova_submission_authorized": false,
+  "runtime_source": {
+    "bytes": 79461,
+    "name": "review_a5_native_eight_data_adapter_r1.py",
+    "sha256": "bc34703f189f240a27282542a4e6268b8eeab7d92ad276dc0e375efa66841ce1"
+  },
+  "schema": "bertose_a5_native_eight_data_adapter_receipt_20260721_r1",
+  "scientific_launch_authorized": false,
+  "split_roster_sha256": {
+    "development": "dbadd12a88e29cc1a7ca1da85895d89f0162fa8bc9f3dcf8aebf5b8781a1e698",
+    "train": "2a7c8121c9ec88418e930cdec47302b7ef2b4d92e01fafa523218461a249de6e"
+  },
+  "static_active_production_materialization_authorized": false,
+  "static_final_token_package_bound": false,
+  "status": "PASS_IMMUTABLE_JOIN_PREPARATION_ONLY_STATIC_TOKENS_ABSENT",
+  "training_authorized": false
+}

releases/2026-10-02/bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_data_adapter_20260721_r2/review_a5_native_eight_data_adapter_receipt_r2.json

@@ -0,0 +1 @@
+{"affinose_supported":false,"authority_bindings":{"adapter_r1_receipt":"cacec838740d64a493c2e56fd1efa8a85ba7d11fce3ec26e40905c33db05e58d","composite_r5":"24c35257fc61e1c9c77630d2b0075775a7f46b6500ecb5f175ef8f42bd214e0e","executor_r5":"a482a70a2edcb7c9936b091a86a0f7d98714b5bab09a0bdc80cd927f015a46f2","joined_development_manifest_r1":"4eea50c1bd4eee0ea10062c287f31c619cef5835e2e660facd098698859f7e70","joined_train_manifest_r1":"13b7ebc78b22baa1a38d2ae40da202dcc1e20e56f44220b4d4d5003ca5f3b8f2","ms_authority":"48914855c4e458ff02452ad4db3743a4fbef12221e0313584db4c2b1bd684cd4","ms_certificate":"53098620a5c22dafdc951ba743515b4b10b1673c02f0aa4d881db669584902fa","ms_parent_manifest":"10dc3fa7622e2a7e448d775f4082fdc84aa0622f9a7a74bcfaeed491c0eb7d39","ms_receipt":"f654177eb6fde7289b6755812c2be298084697cf0d85159b3ec9da310fe3d4b4","ms_runtime":"68c0d543c5411276ef56c7072bded4ebda886f46b9fa4ebf3c95c1e54c1a08c6","planner_r5":"1b9b05c812603db7b216aa989214a3c3715f80032b3a8b82577ae2b9e48f048d","planner_r5_certificate":"4b3198f26e45d84ffced87280e7ac6cd59932bb92cf4da66db1eefb099b897bf","sequence_mask_runtime":"831bebd2dcf6a8308d01ec62eb6e1132fe7edbbc666c1c83787335acc576b19c","sequence_null":"b10556643abf560b9e8622e8ae67936d2d3ca8867433db485e785f31d049a8fb","sequence_null_receipt":"f4eb239f56e472d57dd3a3848c1a6c142e193cb326320ac8bf134b96ac35102a","sequence_package_receipt":"399df3de2b6c4d5e88aa442c8326214ab9cff2e8f0411e6921762bbade1475ba","sequence_receipt":"53b058a2032c424718a96757b3aa63df5160c20910001fcb128b0ace03a13a4c","sequence_runtime":"0b212043878ebfc7edb75929aa0cfe025df7eaf69bc526ed57b85e5cd0b4ba69","sequence_summary":"31fd5a9e015b370681a9d2bacdc1b3ebce0e9408f0cf2835affa35596110460a","static_r7_authority":"59cf794d52341847b08aaa7f4212d1203dec4df89609157d924fda50d54f7602","static_r7_receipt":"0729fa35e7a34a51ee77d2752f008a783d582b845e6c8dd9ae694eb9edb61d9c","static_r7_summary":"f95235a74962fd8aec04b0a14ad17aea3e2bcec27826102d5d26d3f907871908","topology_null":"a752ffd350fbe38aa0e6f6b42b76137f4f72d76fa9a7f5d3609bc47c65c552de","topology_null_receipt":"dace4cb5df71912f5aa7531bb0ce87db3b63d726b2a12aa41facabf9d54b5c35","topology_package_receipt":"333ee6f34e69f89e26b810cc565415b89d6874615ea4ac57850371fb159c1b71"},"cells":["A000","A100","A010","A001","A110","A101","A011","A111"],"common_seed":43,"downstream_supported":false,"execution_certified":false,"fresh_corrected_fit_required_for_all_cells":true,"gpu_launch_authorized":false,"historical_a000_a111_reuse_for_training":false,"nova_submission_authorized":false,"official_or_submitted_artifacts_modified":false,"reused_r1_artifacts":{"development_manifest":{"bytes":3982015,"canonical_row_surface_sha256":"92f46de77c5e1831f01dbe4f672bad19b180d8fb0ea6798040bd07ed7009112b","name":"review_a5_native_eight_joined_development_manifest_r1.tsv.gz","rows":55440,"sha256":"4eea50c1bd4eee0ea10062c287f31c619cef5835e2e660facd098698859f7e70"},"train_manifest":{"bytes":15455767,"canonical_row_surface_sha256":"94f8e3b13bf95bed3f2768c9303d8602ecfa78d3c1d7956699c68856f33e8eef","name":"review_a5_native_eight_joined_train_manifest_r1.tsv.gz","rows":221827,"sha256":"13b7ebc78b22baa1a38d2ae40da202dcc1e20e56f44220b4d4d5003ca5f3b8f2"}},"runtime_source":{"bytes":102990,"name":"review_a5_native_eight_data_adapter_r2.py","sha256":"9f8f167148aa234df413e4c3d4e1846881781c8e5a19bd91b0b178b260a3a537"},"schema":"bertose_a5_native_eight_data_adapter_receipt_20260721_r2","scientific_launch_authorized":false,"static_active_production_materialization_authorized":false,"static_final_token_package_bound":false,"status":"PASS_PREPARATION_ONLY_STATIC_FINAL_TOKENS_ABSENT_LAUNCH_CLOSED","training_authorized":false,"world_size":1}

releases/2026-10-02/bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_data_adapter_20260721_r3/review_a5_native_eight_data_adapter_receipt_r3.json

@@ -0,0 +1 @@
+{"affinose_supported":false,"cells":["A000","A100","A010","A001","A110","A101","A011","A111"],"common_seed":43,"downstream_supported":false,"execution_certified":false,"external_authority_bindings":{"adapter_r2_receipt":"3b2118e128a5550ba4918b4f4f2c6d8045e319b7cff37b76d74dce6b3220c9f0","adapter_r2_source":"9f8f167148aa234df413e4c3d4e1846881781c8e5a19bd91b0b178b260a3a537","ms_authority":"48914855c4e458ff02452ad4db3743a4fbef12221e0313584db4c2b1bd684cd4","ms_certificate":"53098620a5c22dafdc951ba743515b4b10b1673c02f0aa4d881db669584902fa","ms_parent_manifest":"10dc3fa7622e2a7e448d775f4082fdc84aa0622f9a7a74bcfaeed491c0eb7d39","ms_receipt":"f654177eb6fde7289b6755812c2be298084697cf0d85159b3ec9da310fe3d4b4","ms_runtime":"68c0d543c5411276ef56c7072bded4ebda886f46b9fa4ebf3c95c1e54c1a08c6","scientific_boundary_authority":"1238f76e5da5184d16d33077bf3e5342033918fadb4eba84242c47cb1b1322cc","scientific_boundary_receipt":"fb65dddf0bc61b4c73b5dc5ec796967e65263e9d7bdc4882e07684e882280fdb","sequence_topology_r3_predecessor_receipt":"53b058a2032c424718a96757b3aa63df5160c20910001fcb128b0ace03a13a4c","sequence_topology_r4_bfs_receipt":"f20a1dd444f2760ccd8605d53ad716ceb55112fd32d3409826bcaf78ff2c6c3d","sequence_topology_r4_bfs_result":"75914916591d1db97a77d64b9e7a51e0f23526aeb87bd6e394d49c6583309469","sequence_topology_r4_receipt":"654f5b9728c3dfd2588c4b570b0e3a1bcab8feb366af28eeead36f9beb37d921","sequence_topology_r4_runtime":"efc56a84cb82f30c0566da83a38bf0f02fdd507e02d116d827c1bbd827151ecf","sequence_topology_r4_summary":"ccd4b81d3afac8ae789c538e0af332f74f2468d403da1d243fefefd4df013538","static_r7_authority":"59cf794d52341847b08aaa7f4212d1203dec4df89609157d924fda50d54f7602","static_r7_receipt":"0729fa35e7a34a51ee77d2752f008a783d582b845e6c8dd9ae694eb9edb61d9c","static_r7_summary":"f95235a74962fd8aec04b0a14ad17aea3e2bcec27826102d5d26d3f907871908","topology_loss_source":"64eaf9174f523ae909c84987049d071bf3869ca8e83919f14f0572ef77b0530e"},"fixed_loss_coefficients":[1,"topology_bit","ms_bit","static_bit"],"fixed_loss_denominator":4,"gpu_launch_authorized":false,"md_supported":false,"nova_submission_authorized":false,"official_or_submitted_artifacts_modified":false,"predecessor_adapter_r2":{"receipt_sha256":"3b2118e128a5550ba4918b4f4f2c6d8045e319b7cff37b76d74dce6b3220c9f0","source_sha256":"9f8f167148aa234df413e4c3d4e1846881781c8e5a19bd91b0b178b260a3a537"},"provenance_fields":["sequence_rows","roles","seq_token_categories","topology_rows","topology_residue_counts","topology_target_counts"],"runtime_source":{"bytes":41304,"name":"review_a5_native_eight_data_adapter_r3.py","sha256":"a76c24cb0a3b904ae95bfda21bdeb2ba96e36293368fe44a218429be2b10d43e"},"schema":"bertose_a5_native_eight_data_adapter_receipt_20260721_r3","scientific_launch_authorized":false,"static_active_production_materialization_authorized":false,"static_final_token_package_bound":false,"status":"PASS_PREPARATION_ONLY_R4_BOUND_STATIC_FINAL_TOKENS_ABSENT_LAUNCH_CLOSED","training_authorized":false,"weight_ablation_supported":false}

releases/2026-10-02/bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_data_adapter_20260721_r3/review_a5_native_eight_data_adapter_verification_receipt_r1.json

@@ -0,0 +1 @@
+{"affinose_supported":false,"artifacts":{"migration_handoff":{"bytes":4796,"name":"review_a5_native_eight_adapter_r3_r4_migration_handoff_20260721.md","sha256":"400bcb62d730f8449060f9becbacbec89e90f64c487be0d35c3dc43067e74c0e"},"release_receipt":{"bytes":3016,"name":"review_a5_native_eight_data_adapter_receipt_r3.json","sha256":"e29df7a91d0c30238abe9155e600fb1b77b0d3d3481f6599d2ca0d2185371b9f"},"runtime_source":{"bytes":41304,"name":"review_a5_native_eight_data_adapter_r3.py","sha256":"a76c24cb0a3b904ae95bfda21bdeb2ba96e36293368fe44a218429be2b10d43e"},"test_source":{"bytes":14372,"name":"test_review_a5_native_eight_data_adapter_r3_20260721.py","sha256":"44d54ed68291527ae98c2f5970ea339d791f8372a7a5d5a5b114b5a10f5d5360"}},"contracts":{"collate_only_through_r4_store":true,"corrected_scientific_boundary_bound":true,"direct_ms_v3_authorities_bound":true,"direct_static_r7_authorities_bound":true,"eight_fresh_seed43_cells":true,"explicit_frozen_r3_predecessor":true,"fixed_coefficients_constant_denominator_4":true,"r4_masker_only_sequence_checkpoint_restore":true,"r4_provenance_fields_retained":["sequence_rows","roles","seq_token_categories","topology_rows","topology_residue_counts","topology_target_counts"],"receipt_bound_topology_loss":true,"rows_only_through_r4_store_sample":true,"static_active_materialization_blocked":true},"downstream_supported":false,"execution_certified":false,"gpu_launch_authorized":false,"identities":{"a000_epoch_2_step_0_sha256":"05ac100b4f77b0ff33e126fe5560b24d7c4f732d07987862acbde8dcea6ee61c","adapter_contract_sha256":"a3b681f307bad96abb8e446eb8efd769f29ccb65728d424295c89c9ba065224f","authority_set_sha256":"7804332dfc2be432b45f6a82459f21f0b577fc5c358f16b1fea90ba4cb6bb52f","epoch_2_plan_sha256":"b3bdd276a7582748937c461e5c2ba6f927068c380af7d52eb3ad14701ad97330","store_manifest_identity_sha256":"7bd44c2f15715924bce78c7bbdbe57d40fc69aaf90ed834e17d9632bded0fc17"},"md_supported":false,"nova_submission_authorized":false,"publication":{"no_overwrite":true,"official_or_submitted_artifacts_modified":false,"receipt_written_last":true},"schema":"bertose_a5_native_eight_data_adapter_r3_verification_receipt_20260721_r1","scientific_launch_authorized":false,"status":"PASS_PREPARATION_ONLY_R4_MIGRATION_CERTIFIED_LAUNCH_CLOSED","tests":{"adapter_r3":{"clean_process_replays":2,"failed":0,"passed":11,"warnings":0},"certified_r4_runtime":{"failed":0,"passed":12,"warnings":0},"combined_passed":33,"independent_readback":{"remaining_p0":0,"remaining_p1":0,"remaining_p2":0,"status":"PASS"},"predecessor_adapter_r2":{"failed":0,"passed":10,"warnings":0}},"training_authorized":false,"weight_ablation_supported":false}

releases/2026-10-02/bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_hotpath_20260726_r4/review_a5_native_eight_hotpath_r4_integrity_receipt.json

@@ -0,0 +1,115 @@
+{
+  "authorization": {
+    "nova_accessed": false,
+    "nova_submission_authorized": false,
+    "production_epoch_executed": false,
+    "scientific_launch_authorized": false,
+    "training_authorized": false
+  },
+  "caveats": {
+    "cuda_available_in_certification_environment": false,
+    "cuda_disposable_generator_positive_path_executed": false,
+    "cuda_state_behavior": "R4 requires a CPU uint8 CUDA state and a live CUDA runtime, then calls set_state on a disposable torch.Generator bound to the executor's exact CUDA device; when no executor is available it uses the current CUDA device, and without CUDA any CUDA-bearing checkpoint fails closed before mutation",
+    "scientific_or_training_semantics_changed": false,
+    "test_scope": "isolated one-step exact-R9 checkpoint/resume fixture plus frozen predecessor/controller regressions; no production epoch or Nova execution"
+  },
+  "closure": {
+    "loader": {
+      "bytes": 4013,
+      "mode": "0444",
+      "path": "review/multimodal/runtime/a5_native_eight_hotpath_20260726_r4/load_review_a5_native_eight_hotpath_r4.py",
+      "sha256": "662d0766a8d68638480e9c44ca4070387481d43e1c666a20363025cf5b9bc958"
+    },
+    "runtime": {
+      "bytes": 23798,
+      "mode": "0444",
+      "path": "review/multimodal/runtime/a5_native_eight_hotpath_20260726_r4/review_a5_native_eight_hotpath_r4.py",
+      "sha256": "600af4b6b0fab63b7780bb1e6be8233eb28bd0808ff390c3096369afec9c6649"
+    },
+    "test": {
+      "bytes": 19081,
+      "mode": "0444",
+      "path": "review/multimodal/runtime/a5_native_eight_hotpath_20260726_r4/test_review_a5_native_eight_hotpath_r4.py",
+      "sha256": "ebbbdb35644e84b566278fec702afdf7bb23b77cc0b9da7dec226d68feb0504d"
+    }
+  },
+  "guards": {
+    "checkpoint_creation_chain_recomputed_from_exact_one_per_step_identity_list": true,
+    "checkpoint_creation_or_manager_verified_load_provenance_required": true,
+    "checkpoint_cursor_prevalidated_before_model_optimizer_state_mutation": true,
+    "checkpoint_history_max_epochs": 100,
+    "checkpoint_lightweight_provenance_fields": [
+      "step_identity_chain_sha256",
+      "epoch",
+      "plan_sha256",
+      "run_identity_sha256",
+      "cell_id",
+      "trusted_manager_entry_sha256_on_load"
+    ],
+    "checkpoint_lightweight_provenance_retired_after_successful_commit_or_restore": true,
+    "checkpoint_restore_chain_recomputed_from_step_identities": false,
+    "checkpoint_top_level_chain_equals_last_development_history_row_at_commit": true,
+    "checkpoint_top_level_chain_equals_last_development_history_row_at_validation": true,
+    "development_history_epochs_sequential_from_one": true,
+    "development_history_step_chain_fields_exact_lowercase_sha256": true,
+    "invalid_rng_rejected_before_model_optimizer_or_global_rng_mutation": true,
+    "additional_full_model_optimizer_or_checkpoint_state_hashes": 0,
+    "numpy_state_exact_serialized_shape_and_types": {
+      "cached_gaussian": "finite builtin float",
+      "has_gauss": "builtin int in {0,1}",
+      "keys": "plain CPU contiguous torch.int64 tensor shape [624], values in uint32 range",
+      "name": "builtin str exactly MT19937",
+      "position": "builtin int in [0,624]"
+    },
+    "python_state_parsed_by_disposable_random_instance": true,
+    "torch_cpu_state_parsed_by_disposable_generator_set_state": true,
+    "torch_cuda_state_parsed_by_disposable_generator_set_state": true,
+    "valid_checkpoint_bytes_changed": false
+  },
+  "predecessor_r3": {
+    "loader": {
+      "bytes": 4013,
+      "sha256": "e99f4556a8e3b3721d1f9155738d2bf4e9765e43a0e9f7734259e33533ff4b30"
+    },
+    "receipt": {
+      "bytes": 2464,
+      "sha256": "bbce190f463159fe5ed7f80d317ec84e93c08d3119bcd0ee343a3793a13cd8ba"
+    },
+    "runtime": {
+      "bytes": 36449,
+      "sha256": "a81dd58c727a28b1a383477338e41922a2d746dac5cb33f351b4501ee8c5d0dd"
+    },
+    "test": {
+      "bytes": 22249,
+      "sha256": "0d9c387ff7d7314ca5645dd0fc052bd3a4f814637094c5901e5c7a51078ad07b"
+    }
+  },
+  "r13_nonmutation": {
+    "frozen_runner": {
+      "bytes": 55423,
+      "sha256": "f5d5eceff5377c7146f9ee000559483f2779117661945342fd112059a1c7a6b1"
+    },
+    "frozen_test": {
+      "bytes": 49920,
+      "sha256": "765b20221105571ae8aa031d7926130ea604172824472b633d404ff1f28abaf5"
+    },
+    "current_frozen_r13_accepts_r4_receipt": false,
+    "integration_note": "R4 intentionally omits R3's broad cursor-prevalidation claim and exposes the narrower model/optimizer boundary; a future no-overwrite R13 successor must bind this exact R4 surface."
+  },
+  "schema": "bertose_review_a5_native_eight_hotpath_integrity_receipt_20260726_r4",
+  "status": "PASS_LOCAL_EXACT_INTEGRITY_SUCCESSOR_PREPARATION_ONLY_LAUNCH_CLOSED",
+  "tests": {
+    "certification_process_order": [
+      "fresh_interpreter_1_frozen_r3_8_of_8_pass_warning_fatal",
+      "fresh_interpreter_2_frozen_r13_invocation_collected_no_tests_due_missing_PYTHONPATH",
+      "fresh_interpreter_3_frozen_r13_19_of_19_pass_warning_fatal_with_PYTHONPATH",
+      "fresh_interpreter_4_r4_7_of_7_pass_warning_fatal",
+      "fresh_interpreter_5_r4_after_final_provenance_revision_7_of_7_pass_warning_fatal"
+    ],
+    "fresh_interpreter_note": "Each listed command was a separate OS Python process. The first R13 invocation was an environment-path invocation error, not a test failure; the corrected fresh process collected and passed all 19 tests. The final R4 process ran after replacement of recursive checkpoint fingerprinting with lightweight chain/epoch/plan/run/cell provenance.",
+    "frozen_r13_regression": "19/19 PASS warning-fatal",
+    "frozen_r3_regression": "8/8 PASS warning-fatal",
+    "no_pycache_in_r4_runtime_tree": true,
+    "r4_focused": "7/7 PASS warning-fatal"
+  }
+}

releases/2026-10-02/bertose_source/writing/review/multimodal/outputs/review_a5_native_eight_hotpath_20260726_r5/review_a5_native_eight_hotpath_r5_integrity_receipt.json

@@ -0,0 +1,98 @@
+{
+  "authorization": {
+    "nova_accessed": false,
+    "nova_submission_authorized": false,
+    "production_epoch_executed": false,
+    "scientific_launch_authorized": false,
+    "training_authorized": false
+  },
+  "closure": {
+    "loader": {
+      "bytes": 4013,
+      "mode": "0444",
+      "path": "review/multimodal/runtime/a5_native_eight_hotpath_20260726_r5/load_review_a5_native_eight_hotpath_r5.py",
+      "sha256": "864a05e86c5ea91318b11373d2cdffcdd2ddd0777f141cb7ef0305f779a42ea6"
+    },
+    "runtime": {
+      "bytes": 17677,
+      "mode": "0444",
+      "path": "review/multimodal/runtime/a5_native_eight_hotpath_20260726_r5/review_a5_native_eight_hotpath_r5.py",
+      "sha256": "ce4bad9195229341cab0890ed775b78126c17a23d82f2244757f120c12b346c8"
+    },
+    "test": {
+      "bytes": 20423,
+      "mode": "0444",
+      "path": "review/multimodal/runtime/a5_native_eight_hotpath_20260726_r5/test_review_a5_native_eight_hotpath_r5.py",
+      "sha256": "fb36b4b6e474ecce6c61565a55e50092e6bbe8405d1e4bdd6032af4fdbdacd01"
+    }
+  },
+  "guards": {
+    "abandoned_created_or_loaded_checkpoint_gc_cleanup": true,
+    "additional_full_model_optimizer_or_checkpoint_state_hashes": 0,
+    "checkpoint_bytes_changed": false,
+    "commit_success_and_failure_cleanup": true,
+    "deterministic_id_reuse_simulation_rejected": true,
+    "history_epoch_chain_pair_digest": {
+      "domain": "bertose-review-a5-native8-history-chain-pairs-20260726-r5",
+      "maximum_rows": 100,
+      "scope": "all sequential epoch and step_identity_chain_sha256 pairs"
+    },
+    "provenance_identity_binding": [
+      "strong development_history owner identity",
+      "weak Torch CPU RNG tensor identity sentinel",
+      "chain",
+      "history-pair digest",
+      "epoch",
+      "plan_sha256",
+      "run_identity_sha256",
+      "cell_id",
+      "trusted manager entry SHA on load"
+    ],
+    "restore_success_and_failure_cleanup": true,
+    "validation_failure_cleanup": true
+  },
+  "integration": {
+    "current_r13_binding_sha256": "c30b6b03dae852a4b10c6d01596e977d8a071e738dc3074f1ca0592a50778dd3",
+    "current_r13_runner_sha256": "17cf8ab216b354ec1de7574ebebd7bfe02b5935da605b4131e45c7aa13982d5b",
+    "current_r13_test_sha256": "1fb1a9cbf6149f706786301fa57644cde5db57eb068fbc754fc939303f25b425",
+    "exact_source_chain": [
+      "R5 exact-byte loader/runtime",
+      "current exact R13 runner",
+      "R13-pinned exact R12 predecessor",
+      "R13-pinned exact R11 release gate",
+      "R13-pinned exact R9 runtime"
+    ],
+    "fresh_process_result": "PASS_EXACT_R5_R13_R12_R11_R9",
+    "optimization_kind_on_current_r13_surface": "r4_successor_over_frozen_r3",
+    "outer_scientific_launch_authorized": false,
+    "predecessor_r3_scientific_launch_authorized": false,
+    "predecessor_r4_scientific_launch_authorized": false,
+    "terminal_binding_caveat": "The current binding references an absent live terminal-binding file. The integration regression used one isolated read-only terminal-binding fixture, removed automatically at process exit; no production authority or project output was created."
+  },
+  "predecessor_r4": {
+    "loader": {
+      "bytes": 4013,
+      "sha256": "662d0766a8d68638480e9c44ca4070387481d43e1c666a20363025cf5b9bc958"
+    },
+    "receipt": {
+      "bytes": 5728,
+      "sha256": "9aa5860bfc032afd82561a6db6f8df1439245b73aa3f7575b2b88836e384a1f9"
+    },
+    "runtime": {
+      "bytes": 23798,
+      "sha256": "600af4b6b0fab63b7780bb1e6be8233eb28bd0808ff390c3096369afec9c6649"
+    },
+    "test": {
+      "bytes": 19081,
+      "sha256": "ebbbdb35644e84b566278fec702afdf7bb23b77cc0b9da7dec226d68feb0504d"
+    }
+  },
+  "schema": "bertose_review_a5_native_eight_hotpath_integrity_receipt_20260726_r5",
+  "status": "PASS_LOCAL_PROVENANCE_LIFECYCLE_SUCCESSOR_PREPARATION_ONLY_LAUNCH_CLOSED",
+  "tests": {
+    "exact_loader_mutable_copy_negative": true,
+    "focused_warning_fatal": "8/8 PASS",
+    "fresh_process_integration": true,
+    "no_pycache_in_r5_runtime_tree": true
+  }
+}