Publish reviewed research staging to main

CITATION.cff

@@ -0,0 +1,9 @@
+cff-version: 1.2.0
+message: "Private research preparation; obtain author and rights approval before public citation."
+title: "icl-native-r5-opcode"
+type: software
+authors:
+  - family-names: "Yıldırım"
+    given-names: "Emirhan"
+version: "2026.10.13-CP03R2"
+abstract: "Source-derived research preparation. Date identifies this private package version, not a verified public release."

LICENSE_STATUS.md

@@ -0,0 +1 @@
+Private preparation only. Read the retained source Model Card. No public license or release permission has been granted by this packaging.

MODEL_LINEAGE.json

@@ -0,0 +1,109 @@
+{
+  "R5_origin": "NEW_FROM_SCRATCH_NOT_R4_CONTINUATION",
+  "base_model": null,
+  "recovered_language": "ICL-Core0.1.0 -> modified0.2.1",
+  "catalogue_candidate_dispositions": [
+    {
+      "id": "M01",
+      "name": "RARI NeuroBrain estimators",
+      "source_locator": "https://docs.google.com/document/d/1RBT36aPWYAkKcSGxaElZPFqBqVerRJrrPqq-MC3A3LM/edit",
+      "planned_role": "ORACLE_OR_BASELINE",
+      "source_map_statement": "Source map, estimator parameters/loader not verified this turn",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M02",
+      "name": "RARI observer/filter models",
+      "source_locator": "https://docs.google.com/document/d/1RBT36aPWYAkKcSGxaElZPFqBqVerRJrrPqq-MC3A3LM/edit",
+      "planned_role": "OBSERVER_BASELINE",
+      "source_map_statement": "Source map, estimator parameters/loader not verified this turn",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M03",
+      "name": "GOP G6 finite comparator",
+      "source_locator": "https://drive.google.com/file/d/1H2c_ssij0kXkbAVFfhRJ8Wb59pC-ZpQl/view",
+      "planned_role": "FINITE_COMPARATOR",
+      "source_map_statement": "Archive link only this turn; limited finite scope",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M04",
+      "name": "Prometheus MRI checkpoint",
+      "source_locator": "https://drive.google.com/file/d/11_x0BT2apjFYz__dQkhb2POo4ihj--gN/view",
+      "planned_role": "OPTIONAL_DOMAIN_ADAPTER",
+      "source_map_statement": "Same locator as M05; distinct model weights not established",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M05",
+      "name": "HuReT MRI research model",
+      "source_locator": "https://drive.google.com/file/d/11_x0BT2apjFYz__dQkhb2POo4ihj--gN/view",
+      "planned_role": "OPTIONAL_DOMAIN_ADAPTER",
+      "source_map_statement": "Same locator as M04; distinct model weights not established",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M06",
+      "name": "RhythmWalk predictors",
+      "source_locator": "https://drive.google.com/file/d/1YylwcOdH6f02hhipfVqOsCV5eAgr3tZz/view",
+      "planned_role": "OPTIONAL_TEMPORAL_ADAPTER",
+      "source_map_statement": "V3 product/source locator; model weights not established",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M07",
+      "name": "NCL predictive models",
+      "source_locator": "https://drive.google.com/file/d/1XNh9as3LWt7fCcQ1m95fMPMfhuDkYP9u/view",
+      "planned_role": "SYNTHETIC_DATA_NOT_WEIGHTS",
+      "source_map_statement": "Resolved and sampled ncl_synthetic_dataset.csv; not a neural checkpoint",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M08",
+      "name": "Humanization bounded policy",
+      "source_locator": "https://drive.google.com/drive/folders/1wKiCAKnpVhBffRjfCCuINxN2dJsVqQ4N",
+      "planned_role": "POLICY_SOURCE_CANDIDATE",
+      "source_map_statement": "Programme folder, not a verified model loader; enforce authority outside neural model",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M09",
+      "name": "RouterKey / MoE adapters",
+      "source_locator": "https://drive.google.com/file/d/1yhiYJktJKxFMqco5Dp8RwT18j9jZSrJd/view",
+      "planned_role": "ROUTER_CODEC_NOT_WEIGHTS",
+      "source_map_statement": "Full key-only report read; no full model forward; shares locator M10",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    },
+    {
+      "id": "M10",
+      "name": "Offline GLM adapters",
+      "source_locator": "https://drive.google.com/file/d/1yhiYJktJKxFMqco5Dp8RwT18j9jZSrJd/view",
+      "planned_role": "OFFLINE_RUNTIME_CANDIDATE",
+      "source_map_statement": "Same key-only report as M09; no loaded GLM model verified",
+      "R5_weight_use": "NOT_USED",
+      "R5_loader_or_rights_verification": "NOT_REPEATED; locator disposition only",
+      "reason": "New native kernel trained from random initialization; these domain artifacts are not interchangeable generic language-model weights."
+    }
+  ],
+  "complete_10_family_content_audit": false,
+  "legacy_patients_or_closed_tests_used": false
+}

README.md

@@ -0,0 +1,25 @@
+---
+tags:
+- research
+- custom-code
+- program-synthesis
+---
+# ICL-Native R5: bounded semantic opcode kernel
+
+Private custom-Python model staging. Actual 2,774 trained parameters, no base model. This model selects finite opcodes/errors from structured input; it is NOT general source-text generation, an LLM or a learned arithmetic system.
+
+```sh
+python -I -S inference.py --request examples/demo.json
+python -I -S validate.py
+```
+
+Only Python 3.11+ standard library is needed. `model/weights.json` holds the selected seed17 fitted weights. The model graph and all twelve core runtime files are pinned by the original manifest. `examples/demo.json` returns Ok(-4) after independent VM verification. Context/memory errors and denied journal examples are included. No external tools are installed. Confidence is uncalibrated.
+
+Read SOURCE_MODEL_CARD.md for the original 18-run training record, 16 intents, 22 classes, 1–32 supplied steps, split design and negative budget-comparison result. Historical benchmark scores are not new replications here. Exact arithmetic, code emission, state, memory and permissions are deterministic. The 30,000-example data and complete checkpoints are preserved in the sibling `github/icl-native-r5` research package.
+
+This repository is not Transformers AutoModel/Inference API compatible. Public licensing, rights and author approval are pending; no public HF upload is performed. Source code remains unmodified in this repackaging. No license is granted by this preparation.
+## Verified packaging revision — 2026-10-20
+
+Preserved model weights reloaded; saved or synthetic example checks passed. No training, held-out evaluation, clinical or hosted verification.
+
+Runtime state: `PASS`. Rights and release approval are separate. See `RELEASE_VERIFICATION.json`. No paper or conference submission is included as a new software result.

RELEASE_SOURCE_MANIFEST.json

@@ -0,0 +1,216 @@
+{
+  "excluded_counts": {},
+  "files": [
+    {
+      "bytes": 386,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/CITATION.cff",
+      "path": "CITATION.cff",
+      "sha256": "b7c5e01b2da2167865556d757f071ac249d4b7c9e1aae77d1475798c4b7c3c79"
+    },
+    {
+      "bytes": 139,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/LICENSE_STATUS.md",
+      "path": "LICENSE_STATUS.md",
+      "sha256": "e33fe2492403b3a513ddd3da44931c7e4424dd33da2ce4ce8ed59b19761963f5"
+    },
+    {
+      "bytes": 6174,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/MODEL_LINEAGE.json",
+      "path": "MODEL_LINEAGE.json",
+      "sha256": "3078cca7acd9101ebe85718268164da191cd23552d5e3464fa9b2f3eff05ecbc"
+    },
+    {
+      "bytes": 1509,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/README.md",
+      "path": "README.md",
+      "sha256": "de5244c2445bba44805cc481505189e60efa66c44ed2abb31ad6f28478093500"
+    },
+    {
+      "bytes": 4110,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/SOURCE_MODEL_CARD.md",
+      "path": "SOURCE_MODEL_CARD.md",
+      "sha256": "b821a5e409120b866ca5c5c3ebb67c9dc9525ff1ca1342767ab53fe23e928955"
+    },
+    {
+      "bytes": 3514,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/examples/demo.json",
+      "path": "examples/demo.json",
+      "sha256": "26da428cf2256cdfff5fe78ec194f4750664923ff347e1f4e21fa8276556db73"
+    },
+    {
+      "bytes": 398,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/examples/denied_journal.json",
+      "path": "examples/denied_journal.json",
+      "sha256": "e3a6a1ad83fef390e0eaa84fbe48aafc832721c2f780f1ba94400ec627fba1d7"
+    },
+    {
+      "bytes": 397,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/examples/missing_memory.json",
+      "path": "examples/missing_memory.json",
+      "sha256": "b58ea254c7eee1710c986c4463457834bd8666d2ea752eb6e97737e6b397a3b0"
+    },
+    {
+      "bytes": 399,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/examples/missing_witness.json",
+      "path": "examples/missing_witness.json",
+      "sha256": "6cbf83bdf405865fe72934f5db1cffbdab881b4b19cd576e4b7def6f7f98ee90"
+    },
+    {
+      "bytes": 401,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/examples/wrong_observer.json",
+      "path": "examples/wrong_observer.json",
+      "sha256": "9398899c2a272e8bbc788def6177188ae0cb9f18dad40c4470f721db500821a4"
+    },
+    {
+      "bytes": 241,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/inference.py",
+      "path": "inference.py",
+      "sha256": "9148ce61babebb4b5c3c1c2a0cc0b38f676d3afd241aebc37ff8e51b690d3d08"
+    },
+    {
+      "bytes": 4920,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/model/compiled_model.ocir",
+      "path": "model/compiled_model.ocir",
+      "sha256": "65913fa9b4ff565aaaf5ce88eecaf069a64113cb51a45d72f957a3925b6ce31d"
+    },
+    {
+      "bytes": 1798,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/model/manifest.json",
+      "path": "model/manifest.json",
+      "sha256": "3e58d88d09b78fd34cbcaaf3f2b78b6d8988f7b0904c2748dc4df7ff0f279387"
+    },
+    {
+      "bytes": 262,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/model/model.icl",
+      "path": "model/model.icl",
+      "sha256": "d6b00095f8850cc1a8dc5f1d7fd0838e5c30faa98a8943c17aa4c95efa974574"
+    },
+    {
+      "bytes": 1543,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/model/model_config.json",
+      "path": "model/model_config.json",
+      "sha256": "0a8faf7c094a4d983ba908fbd96144a8b5bbbcda29b298086e4435ced90f0a69"
+    },
+    {
+      "bytes": 75290,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/model/weights.json",
+      "path": "model/weights.json",
+      "sha256": "f4385f7237787a2486eaa1f69551e113d4c356c184877bc69422cb2f6297d2c6"
+    },
+    {
+      "bytes": 1151,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/OCIR_SCHEMA.json",
+      "path": "source/icl/OCIR_SCHEMA.json",
+      "sha256": "0dd381cb61f65f3346c07918aae587c42c583f8b4449583fdd4dca1afdcee60c"
+    },
+    {
+      "bytes": 1587,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/TOKEN_VOCAB.json",
+      "path": "source/icl/TOKEN_VOCAB.json",
+      "sha256": "2a8d6cd58182ad668b9dd73c1287126490b21ca45fe083cee87132e5da147224"
+    },
+    {
+      "bytes": 86,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/__init__.py",
+      "path": "source/icl/__init__.py",
+      "sha256": "f73f293d01ef19c8f813a446bdcff125994f4237a9beded8eebde17a31a28807"
+    },
+    {
+      "bytes": 47,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/__main__.py",
+      "path": "source/icl/__main__.py",
+      "sha256": "79ee6f134c5c5193377cf9b189cbdcc3e2095e49ba9cec310114441c15a917c4"
+    },
+    {
+      "bytes": 9681,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/api.py",
+      "path": "source/icl/api.py",
+      "sha256": "a0037de6a1f7eb3a69a64ce3b85f8e916a9fadea89e5a4acfba47054b23c499b"
+    },
+    {
+      "bytes": 16155,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/checker.py",
+      "path": "source/icl/checker.py",
+      "sha256": "41339273bfed74b4f4c28cb7948b1ff8b06fb347908ff04dde0a68a46de3b4e4"
+    },
+    {
+      "bytes": 5197,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/cli.py",
+      "path": "source/icl/cli.py",
+      "sha256": "2384aea45b82c887d4e46cab69421d41cb6d60c690b75685ab263d57b1c7a848"
+    },
+    {
+      "bytes": 12456,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/frontend.py",
+      "path": "source/icl/frontend.py",
+      "sha256": "54f77a11fddfe631756506a9dd64af91a8fedf49951b2fbe982e8e66118bb98f"
+    },
+    {
+      "bytes": 4129,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/interpreter.py",
+      "path": "source/icl/interpreter.py",
+      "sha256": "6a03904e82bcfaff33e44c658de84e1b34445d7b7f567244cd4388391ea34a34"
+    },
+    {
+      "bytes": 3912,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/legacy_afc.py",
+      "path": "source/icl/legacy_afc.py",
+      "sha256": "20abd74e06a61d96c829446d1faf584418affc9a4e098d405a54c87ecdf99742"
+    },
+    {
+      "bytes": 12707,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/runtime.py",
+      "path": "source/icl/runtime.py",
+      "sha256": "23b3bcfc7264e1ba24111d067a35676cf7171d72891522253475c9d78dd97ded"
+    },
+    {
+      "bytes": 25567,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl/vm.py",
+      "path": "source/icl/vm.py",
+      "sha256": "9fa1f8a257a5cb4873cb3689bbf81886456074d3ad1b8c1e7a8db7938ba462b8"
+    },
+    {
+      "bytes": 101,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl_native/__init__.py",
+      "path": "source/icl_native/__init__.py",
+      "sha256": "a19b62d88904dbba347c03c66708942f7c6fa2c11f0fdd33135dc3a9bae4baa3"
+    },
+    {
+      "bytes": 5233,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl_native/common.py",
+      "path": "source/icl_native/common.py",
+      "sha256": "1c801ff306842a3a04405d8243a5423822467c6fc9f080af50ef93ac931481f4"
+    },
+    {
+      "bytes": 2642,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl_native/emitter.py",
+      "path": "source/icl_native/emitter.py",
+      "sha256": "9ae3d2a2f6068787adb2107c4e72077d02bb307971fe4ac7fd7ccd465dc0d551"
+    },
+    {
+      "bytes": 2938,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl_native/execution.py",
+      "path": "source/icl_native/execution.py",
+      "sha256": "e42517a23b1339075756080d30c6c86ae21ef90e3822b9c98f7306c65d106c1b"
+    },
+    {
+      "bytes": 5033,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/source/icl_native/offline_infer.py",
+      "path": "source/icl_native/offline_infer.py",
+      "sha256": "98d0ca6076c83daec1fb20110ea99ae41ed0bc109f007f2fd7c1c11ffb1086ea"
+    },
+    {
+      "bytes": 1056,
+      "original_source_member": "Invariant_CP03R2/huggingface/models/icl-native-r5-opcode/validate.py",
+      "path": "validate.py",
+      "sha256": "5b869783d2a1ff3672db336c98e622bd3df02a80017fc04a2dc46d6d21b2c9bb"
+    }
+  ],
+  "published_files": 34,
+  "repository": "huggingface/models/icl-native-r5-opcode",
+  "schema": "invariant.source_member_manifest.v1",
+  "scope": "source files + minimal repository metadata; no new training or independent experiment",
+  "selected_from_files": 34,
+  "source_archive": "CP03R2",
+  "source_archive_sha256": "b5ea9257da3bd31fd3398cc7c172a2ad79fc90d4cb61f5e33661a43e716ca874"
+}

RELEASE_VERIFICATION.json

@@ -0,0 +1,14 @@
+{
+  "schema": "invariant.software_release_verification.v1",
+  "runtime_status": "PASS",
+  "scope": "Preserved model weights reloaded; saved or synthetic example checks passed. No training, held-out evaluation, clinical or hosted verification.",
+  "checked_in": "isolated Linux container; Python 3.13.5 / Node 22.16.0 / Chromium 144 where applicable",
+  "actual_server_tested": false,
+  "actual_windows_tested": false,
+  "hosted_platform_tested": false,
+  "public_release_performed": false,
+  "public_rights_approved": false,
+  "target_codes": [],
+  "source_class": "archived_source",
+  "evidence_file_in_delivery_audit": "model_reload_final.json"
+}

SOURCE_MODEL_CARD.md

@@ -0,0 +1,32 @@
+# ICL-Native R5 — Model Card
+
+## Identity and actual task
+New random-initialized, **2774-parameter**, bounded semantic opcode kernel. Base model: null. OCIL-Core 0.2.1; ICL graph `model.icl` is parsed/type checked and executed by a Torch training adapter. Offline deployment evaluates the same trained weights through the ICL VM with Python standard library only. This is not the unrecovered R4 model, an LLM, unrestricted source generation, or a clinical model.
+
+Input: one of 16 explicit intents, eight effective Boolean context/state fields, and six numeric nuisance features. Output: one of 22 opcode/error classes. The controller visits a supplied plan of 1–32 steps. It is **not a learned autoregressive plan-length decoder**. Memory availability is derived from actual runtime state rather than trusting a caller's memory-present flag. Exact values, memory storage and numerical recovery are deterministic. Confidence is uncalibrated.
+
+## Training and data
+20 epochs, 1,080 optimizer updates per run, 20,000 training task roots/110,235 local node labels; 2,000 validation task roots. Three seeds 17, 29, 43 for native, flat and four ablations; 18 real runs. Model selection uses validation CE only. Numeric nuisance values are randomized in augmentation; observer/witness flags are not derived from number residues. No old closed/clinical bank or external model weights is used. Labels after a first error are auxiliary local supervision, not an actual continuing execution trace.
+
+## Metrics (mean of three seeds)
+| Variant | ID 2,000 | Long 2,000 | Flag-paired 4,000 |
+|---|---:|---:|---:|
+| native | 1.000000 | 1.000000 | 1.000000 |
+| flat | 0.998500 | 0.996000 | 0.998250 |
+| no_context | 0.727167 | 0.497833 | 0.626667 |
+| no_witness | 0.917000 | 0.869500 | 0.866250 |
+| no_memory | 0.947000 | 0.939500 | 0.940000 |
+| no_invariance | 1.000000 | 1.000000 | 1.000000 |
+
+Metric = **raw semantic opcode-prefix exact match across all supplied plans**, before a verifier can turn an incorrect action into a rejection. Positive/negative/per-intent/selective-risk details are in reports/evaluation. Grammar validity comes from the emitter and is not credited as learned syntax. Long-plan success uses deterministic composition and state execution; it does not establish learned long-horizon planning.
+
+The input-program AST audit is split-disjoint after literal erasure. Specialized output strings, especially early errors, overlap across splits; the audit lists those overlaps. It would be wrong to present these results as novel source-program generation. The 602,112-case per-seed grid enumerates all effective Boolean contexts at 147 sampled numeric combinations, NOT all possible integers. It found no errors in that finite grid.
+
+## Comparisons and negative findings
+The flat baseline has 2,758 parameters. Training wall-time ratio native/flat is 0.448806; the requested ±10% budget match is not met. Even though the paired long-task difference is 0.004, confidence interval [0.002333, 0.005833] conditional on these seeds, **superiority is not established**. Removing the extra consistency loss gave the same perfect task score; no independent gain for that objective is demonstrated. Domain/semantic generalization beyond this finite task is untested.
+
+## Recovery and authority
+`restore` simulates loss and recovery of a known x by generating its witness inside the program. It is not recovery of unavailable information. Observer/witness Boolean flags describe synthetic scenarios, not authenticated external facts. Only an in-memory local journal can be permitted by an independent host setting; there is no shell/network/device/email/clinical adapter. Local console records files through host code, distinct from language-program capabilities. Hash checks are not signatures. A Python audit hook is not an OS sandbox.
+
+## Reuse and distribution
+Code, actual safe-tensor checkpoints, optimizer/RNG states, graph, raw predictions, source maps and tests are included. Keep private. No license grant or public publication decision is invented; source-study/third-party rights remain separate.

examples/demo.json

@@ -0,0 +1,156 @@
+{
+  "initial": 5,
+  "memory": null,
+  "steps": [
+    {
+      "intent": "increase",
+      "arg": 3,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "repeat",
+      "arg": -1,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "translate",
+      "arg": 2,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "remember",
+      "arg": 0,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "scale",
+      "arg": 3,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "recall",
+      "arg": 0,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "restore",
+      "arg": 0,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "record_add",
+      "arg": -2,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "axis_reverse",
+      "arg": 0,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    },
+    {
+      "intent": "list_add",
+      "arg": 1,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    }
+  ]
+}

examples/denied_journal.json

@@ -0,0 +1,21 @@
+{
+  "initial": 5,
+  "memory": null,
+  "steps": [
+    {
+      "intent": "journal",
+      "arg": 2,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    }
+  ]
+}

examples/missing_memory.json

@@ -0,0 +1,21 @@
+{
+  "initial": 5,
+  "memory": null,
+  "steps": [
+    {
+      "intent": "recall",
+      "arg": 2,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    }
+  ]
+}

examples/missing_witness.json

@@ -0,0 +1,21 @@
+{
+  "initial": 5,
+  "memory": null,
+  "steps": [
+    {
+      "intent": "restore",
+      "arg": 2,
+      "modulus": 7,
+      "flags": {
+        "observer_match": true,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": false,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    }
+  ]
+}

examples/wrong_observer.json

@@ -0,0 +1,21 @@
+{
+  "initial": 5,
+  "memory": null,
+  "steps": [
+    {
+      "intent": "translate",
+      "arg": 2,
+      "modulus": 7,
+      "flags": {
+        "observer_match": false,
+        "frame_match": true,
+        "unit_match": true,
+        "witness_present": true,
+        "witness_valid": true,
+        "memory_present": true,
+        "journal_allowed": true,
+        "condition": true
+      }
+    }
+  ]
+}

inference.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+import sys
+R=Path(__file__).resolve().parent;sys.path.insert(0,str(R/'source'))
+from icl_native.offline_infer import main
+a=sys.argv[1:]
+if '--model' not in a:a=['--model',str(R/'model')]+a
+raise SystemExit(main(a))

model/compiled_model.ocir

@@ -0,0 +1 @@
+{"entrypoint":"main","feature_set":["functions","modules","lexical_scope","checked_int64","finite_float64","bounded_loop","list","record","tuple","option","result","tensor","observer","recovery","policy_effect","checkpoint","record_annotations","type_aliases","contextual_empty_lists"],"integrity_sha256":"1525e4acb1403f1907fb5446ba66642ab793ac5a6052ba082f28a5aa2529ac4e","limits":{"max_items":100000,"max_output":1000000,"max_stack":128,"max_steps":100000,"max_tensor":4096},"module_graph":[{"imports":[],"module":"model_graph","source_sha256":"d6b00095f8850cc1a8dc5f1d7fd0838e5c30faa98a8943c17aa4c95efa974574"}],"numeric_policy":{"atol":1e-06,"float64":"finite_only","int64":"checked_signed","integer_division":"truncate_toward_zero","normalize_epsilon":1e-05,"rtol":1e-05},"observer_context":{"implicit_conversion":false,"mode":"explicit_metadata"},"operand_types":[["Tensor[1,30]","Tensor[30,32]"],["Tensor[1,32]","Tensor[1,32]"],["Tensor[1,32]"],["Tensor[1,32]","Tensor[32,32]"],["Tensor[1,32]","Tensor[1,32]"],["Tensor[1,32]"],["Tensor[1,32]","Tensor[32,22]"],["Tensor[1,22]","Tensor[1,22]"]],"ops":[{"name":"matmul","operand_types":["Tensor[1,30]","Tensor[30,32]"],"result_type":"Tensor[1,32]"},{"name":"add","operand_types":["Tensor[1,32]","Tensor[1,32]"],"result_type":"Tensor[1,32]"},{"name":"tanh","operand_types":["Tensor[1,32]"],"result_type":"Tensor[1,32]"},{"name":"matmul","operand_types":["Tensor[1,32]","Tensor[32,32]"],"result_type":"Tensor[1,32]"},{"name":"add","operand_types":["Tensor[1,32]","Tensor[1,32]"],"result_type":"Tensor[1,32]"},{"name":"tanh","operand_types":["Tensor[1,32]"],"result_type":"Tensor[1,32]"},{"name":"matmul","operand_types":["Tensor[1,32]","Tensor[32,22]"],"result_type":"Tensor[1,22]"},{"name":"add","operand_types":["Tensor[1,22]","Tensor[1,22]"],"result_type":"Tensor[1,22]"}],"program_id":"f30a68d253716d362ab399dc0cd016cf2cdcf2cad60560651f4fd4d15d4c1307","provenance_refs":[{"module":"model_graph","source_sha256":"d6b00095f8850cc1a8dc5f1d7fd0838e5c30faa98a8943c17aa4c95efa974574","status":"COMPILED_LOCAL_SOURCE"}],"required_effects":[],"schema_sha256":"0dd381cb61f65f3346c07918aae587c42c583f8b4449583fdd4dca1afdcee60c","schema_version":"0.2.1","shape_constraints":[{"left":[1,30],"op":"matmul","output":[1,32],"right":[30,32]},{"left":[1,32],"op":"matmul","output":[1,32],"right":[32,32]},{"left":[1,32],"op":"matmul","output":[1,22],"right":[32,22]}],"source_sha256":"d6b00095f8850cc1a8dc5f1d7fd0838e5c30faa98a8943c17aa4c95efa974574","typed_blocks":[{"body":[{"expr":{"args":[{"args":[{"args":[{"inferred_type":"Tensor[1,30]","kind":"var","name":"x","span":{"column":24,"line":3,"offset":182}},{"inferred_type":"Tensor[30,32]","kind":"var","name":"w1","span":{"column":26,"line":3,"offset":184}}],"inferred_type":"Tensor[1,32]","kind":"call","name":"matmul","span":{"column":17,"line":3,"offset":175}},{"inferred_type":"Tensor[1,32]","kind":"var","name":"b1","span":{"column":30,"line":3,"offset":188}}],"inferred_type":"Tensor[1,32]","kind":"call","name":"add","span":{"column":13,"line":3,"offset":171}}],"inferred_type":"Tensor[1,32]","kind":"call","name":"tanh","span":{"column":8,"line":3,"offset":166}},"inferred_type":"Tensor[1,32]","kind":"let","mutable":false,"name":"h1","span":{"column":1,"line":3,"offset":159},"type":null},{"expr":{"args":[{"args":[{"args":[{"inferred_type":"Tensor[1,32]","kind":"var","name":"h1","span":{"column":24,"line":4,"offset":217}},{"inferred_type":"Tensor[32,32]","kind":"var","name":"w2","span":{"column":27,"line":4,"offset":220}}],"inferred_type":"Tensor[1,32]","kind":"call","name":"matmul","span":{"column":17,"line":4,"offset":210}},{"inferred_type":"Tensor[1,32]","kind":"var","name":"b2","span":{"column":31,"line":4,"offset":224}}],"inferred_type":"Tensor[1,32]","kind":"call","name":"add","span":{"column":13,"line":4,"offset":206}}],"inferred_type":"Tensor[1,32]","kind":"call","name":"tanh","span":{"column":8,"line":4,"offset":201}},"inferred_type":"Tensor[1,32]","kind":"let","mutable":false,"name":"h2","span":{"column":1,"line":4,"offset":194},"type":null},{"expr":{"args":[{"args":[{"inferred_type":"Tensor[1,32]","kind":"var","name":"h2","span":{"column":19,"line":5,"offset":248}},{"inferred_type":"Tensor[32,22]","kind":"var","name":"wo","span":{"column":22,"line":5,"offset":251}}],"inferred_type":"Tensor[1,22]","kind":"call","name":"matmul","span":{"column":12,"line":5,"offset":241}},{"inferred_type":"Tensor[1,22]","kind":"var","name":"bo","span":{"column":26,"line":5,"offset":255}}],"inferred_type":"Tensor[1,22]","kind":"call","name":"add","span":{"column":8,"line":5,"offset":237}},"kind":"return","span":{"column":1,"line":5,"offset":230}}],"name":"main","params":[["x","Tensor[1,30]"],["w1","Tensor[30,32]"],["b1","Tensor[1,32]"],["w2","Tensor[32,32]"],["b2","Tensor[1,32]"],["wo","Tensor[32,22]"],["bo","Tensor[1,22]"]],"return_type":"Tensor[1,22]","span":{"column":1,"line":2,"offset":20}}]}

model/manifest.json

@@ -0,0 +1,36 @@
+{
+  "schema": "ICL_R5_OFFLINE_BUNDLE/1",
+  "files": {
+    "weights.json": {
+      "bytes": 75290,
+      "sha256": "f4385f7237787a2486eaa1f69551e113d4c356c184877bc69422cb2f6297d2c6"
+    },
+    "compiled_model.ocir": {
+      "bytes": 4920,
+      "sha256": "65913fa9b4ff565aaaf5ce88eecaf069a64113cb51a45d72f957a3925b6ce31d"
+    },
+    "model.icl": {
+      "bytes": 262,
+      "sha256": "d6b00095f8850cc1a8dc5f1d7fd0838e5c30faa98a8943c17aa4c95efa974574"
+    },
+    "model_config.json": {
+      "bytes": 1543,
+      "sha256": "0a8faf7c094a4d983ba908fbd96144a8b5bbbcda29b298086e4435ced90f0a69"
+    }
+  },
+  "runtime_file_hashes": {
+    "__init__.py": "f73f293d01ef19c8f813a446bdcff125994f4237a9beded8eebde17a31a28807",
+    "__main__.py": "79ee6f134c5c5193377cf9b189cbdcc3e2095e49ba9cec310114441c15a917c4",
+    "api.py": "a0037de6a1f7eb3a69a64ce3b85f8e916a9fadea89e5a4acfba47054b23c499b",
+    "checker.py": "41339273bfed74b4f4c28cb7948b1ff8b06fb347908ff04dde0a68a46de3b4e4",
+    "cli.py": "2384aea45b82c887d4e46cab69421d41cb6d60c690b75685ab263d57b1c7a848",
+    "frontend.py": "54f77a11fddfe631756506a9dd64af91a8fedf49951b2fbe982e8e66118bb98f",
+    "interpreter.py": "6a03904e82bcfaff33e44c658de84e1b34445d7b7f567244cd4388391ea34a34",
+    "legacy_afc.py": "20abd74e06a61d96c829446d1faf584418affc9a4e098d405a54c87ecdf99742",
+    "runtime.py": "23b3bcfc7264e1ba24111d067a35676cf7171d72891522253475c9d78dd97ded",
+    "vm.py": "9fa1f8a257a5cb4873cb3689bbf81886456074d3ad1b8c1e7a8db7938ba462b8",
+    "OCIR_SCHEMA.json": "0dd381cb61f65f3346c07918aae587c42c583f8b4449583fdd4dca1afdcee60c",
+    "TOKEN_VOCAB.json": "2a8d6cd58182ad668b9dd73c1287126490b21ca45fe083cee87132e5da147224"
+  },
+  "security": "Hash detects accidental/tampered-content mismatch, not publisher authentication or OS sandbox certification."
+}

model/model.icl

@@ -0,0 +1,6 @@
+module model_graph;
+fn main(x:Tensor[1,30],w1:Tensor[30,32],b1:Tensor[1,32],w2:Tensor[32,32],b2:Tensor[1,32],wo:Tensor[32,22],bo:Tensor[1,22])->Tensor[1,22] {
+let h1=tanh(add(matmul(x,w1),b1));
+let h2=tanh(add(matmul(h1,w2),b2));
+return add(matmul(h2,wo),bo);
+}

model/model_config.json

@@ -0,0 +1,66 @@
+{
+  "seed": 17,
+  "choice": "preselected first seed, not selected on held-out outcomes",
+  "actions": [
+    "ADD",
+    "SUB",
+    "MUL",
+    "MAX",
+    "MIN",
+    "ABS",
+    "REPEAT",
+    "TRANSLATE",
+    "RESTORE",
+    "STORE",
+    "RECALL",
+    "JOURNAL",
+    "RECORD_ADD",
+    "LIST_ADD",
+    "NEGATE",
+    "OBSERVER_MISMATCH",
+    "FRAME_MISMATCH",
+    "UNIT_MISMATCH",
+    "NON_IDENTIFIABLE",
+    "WITNESS_CORRUPT",
+    "MEMORY_MISSING",
+    "EFFECT_DENIED"
+  ],
+  "feature_names": [
+    "intent:increase",
+    "intent:decrease",
+    "intent:scale",
+    "intent:floor",
+    "intent:ceiling",
+    "intent:magnitude",
+    "intent:repeat",
+    "intent:translate",
+    "intent:restore",
+    "intent:remember",
+    "intent:recall",
+    "intent:journal",
+    "intent:conditional",
+    "intent:record_add",
+    "intent:list_add",
+    "intent:axis_reverse",
+    "flag:observer_match",
+    "flag:frame_match",
+    "flag:unit_match",
+    "flag:witness_present",
+    "flag:witness_valid",
+    "flag:memory_present",
+    "flag:journal_allowed",
+    "flag:condition",
+    "nuisance:value",
+    "nuisance:arg",
+    "nuisance:modulus",
+    "nuisance:parity",
+    "nuisance:residue3",
+    "nuisance:residue5"
+  ],
+  "schema_version": "0.2.1",
+  "schema_sha256": "0dd381cb61f65f3346c07918aae587c42c583f8b4449583fdd4dca1afdcee60c",
+  "parameters": 2774,
+  "base_model": null,
+  "source_checkpoint_sha256": "46b25e6559918e769eb730da61719828fd6c88409cf1a1e4d5651c624bc3118f",
+  "scope": "bounded opcode classifier, deterministic composer/emitter/executor"
+}

model/weights.json

@@ -0,0 +1,2824 @@
+{
+  "w1": {
+    "shape": [
+      30,
+      32
+    ],
+    "data": [
+      -0.5488966703414917,
+      -0.08593291789293289,
+      0.5386847257614136,
+      -0.11527922004461288,
+      0.5276094675064087,
+      0.5239102244377136,
+      0.2667744755744934,
+      -0.48160919547080994,
+      -0.42378148436546326,
+      -0.45551472902297974,
+      0.44894301891326904,
+      0.40508943796157837,
+      0.32896095514297485,
+      -0.1297110617160797,
+      0.46540695428848267,
+      0.5252204537391663,
+      -0.4742470979690552,
+      -0.44977128505706787,
+      -0.5083129405975342,
+      0.048102714121341705,
+      0.48412609100341797,
+      0.31284621357917786,
+      0.5330861806869507,
+      0.26352381706237793,
+      -0.5231456756591797,
+      -0.7219465374946594,
+      -0.5547614693641663,
+      -0.19468623399734497,
+      -0.3103106915950775,
+      0.3873853385448456,
+      -0.3373004198074341,
+      -0.5831712484359741,
+      0.41279247403144836,
+      -0.446401983499527,
+      0.2757759094238281,
+      0.35344198346138,
+      0.4034237861633301,
+      0.5448958873748779,
+      0.5372898578643799,
+      0.40051308274269104,
+      -0.28691014647483826,
+      0.5974467992782593,
+      -0.9412275552749634,
+      0.5422351956367493,
+      0.4789050817489624,
+      -0.5489935874938965,
+      0.3875492513179779,
+      -0.3904019594192505,
+      -0.29790589213371277,
+      0.5539658665657043,
+      -0.37398454546928406,
+      -0.36495241522789,
+      -0.42312175035476685,
+      0.06898502260446548,
+      0.3863160312175751,
+      0.44947755336761475,
+      -0.37245747447013855,
+      0.6392247080802917,
+      -0.39478254318237305,
+      0.6875461935997009,
+      -0.5576581954956055,
+      0.47803521156311035,
+      -0.48461440205574036,
+      0.3100711405277252,
+      -0.24585741758346558,
+      0.6967970132827759,
+      -0.3403576612472534,
+      0.2939182221889496,
+      0.5761148929595947,
+      -0.4314090311527252,
+      0.5944485664367676,
+      0.7156250476837158,
+      0.5832403898239136,
+      0.6609600186347961,
+      0.4671705365180969,
+      0.44416898488998413,
+      -0.4081263542175293,
+      -0.41817739605903625,
+      0.5767237544059753,
+      -0.43526920676231384,
+      0.4799668788909912,
+      -0.2550618052482605,
+      0.3990604877471924,
+      -0.6457293033599854,
+      -0.5282684564590454,
+      -0.49335336685180664,
+      0.3576943874359131,
+      -0.6070857644081116,
+      0.45286858081817627,
+      -0.6534950733184814,
+      0.5726582407951355,
+      -0.38555899262428284,
+      0.5510165095329285,
+      0.4904101490974426,
+      -0.3645825982093811,
+      0.48236018419265747,
+      0.5967796444892883,
+      -0.4618927836418152,
+      0.47114798426628113,
+      -0.7329348921775818,
+      -0.48430487513542175,
+      -0.5966583490371704,
+      0.5011285543441772,
+      -0.3746306598186493,
+      -0.3945414125919342,
+      -0.1043902039527893,
+      -0.49297523498535156,
+      -0.6017966866493225,
+      0.5076148509979248,
+      -0.4691731035709381,
+      -0.1496807485818863,
+      -0.37746888399124146,
+      -0.3639369010925293,
+      0.299565851688385,
+      0.5902070999145508,
+      0.4756924510002136,
+      -0.5825579762458801,
+      0.45068368315696716,
+      -0.5842808485031128,
+      0.5202412605285645,
+      -0.5344223976135254,
+      -0.45949897170066833,
+      -0.3554128408432007,
+      0.45180270075798035,
+      0.48409485816955566,
+      -0.6837796568870544,
+      0.6565655469894409,
+      0.6284458637237549,
+      0.581606388092041,
+      0.08924071490764618,
+      -0.5221413373947144,
+      0.3925965428352356,
+      0.7244848012924194,
+      -0.48466020822525024,
+      -0.6208491325378418,
+      -0.537087619304657,
+      0.5254541635513306,
+      0.6037610173225403,
+      0.40344175696372986,
+      -0.4285893738269806,
+      0.3539985120296478,
+      0.4335514008998871,
+      -0.39308956265449524,
+      -0.5236027240753174,
+      0.8613845109939575,
+      0.6111376285552979,
+      -0.5862669348716736,
+      0.5153316855430603,
+      -0.29207855463027954,
+      0.3187897801399231,
+      -0.6437675952911377,
+      -0.487657368183136,
+      -0.238347128033638,
+      0.5846917629241943,
+      0.3970000445842743,
+      -0.4527803957462311,
+      0.3972559869289398,
+      0.1303258240222931,
+      0.4329298436641693,
+      0.3383236229419708,
+      -0.11817159503698349,
+      0.6526093482971191,
+      0.7772384881973267,
+      -0.6000686883926392,
+      0.328559935092926,
+      -0.5089402198791504,
+      -0.22956186532974243,
+      -0.38165557384490967,
+      0.4861235022544861,
+      -0.43756017088890076,
+      -0.6197691559791565,
+      -0.46117734909057617,
+      0.5947796702384949,
+      0.5957403779029846,
+      0.6052441000938416,
+      -0.005228719208389521,
+      0.5038419961929321,
+      -0.46628355979919434,
+      -0.5361005067825317,
+      -0.45644819736480713,
+      0.2022489607334137,
+      0.9743813872337341,
+      -0.5054241418838501,
+      0.413500040769577,
+      -0.609239935874939,
+      0.2887095510959625,
+      0.6669336557388306,
+      0.8208209872245789,
+      -0.4311579763889313,
+      -0.473364919424057,
+      -0.5393997430801392,
+      0.07978760451078415,
+      0.40551045536994934,
+      0.39571866393089294,
+      -0.41139501333236694,
+      0.5627273917198181,
+      0.42904725670814514,
+      0.10078001022338867,
+      -0.6481370329856873,
+      -0.45294639468193054,
+      -0.7407980561256409,
+      0.30929553508758545,
+      -0.5597099661827087,
+      -0.4542389214038849,
+      -0.5131598114967346,
+      -0.5234488844871521,
+      -0.5677126049995422,
+      0.02679944597184658,
+      0.7225686311721802,
+      0.5193125009536743,
+      -0.4365570843219757,
+      -0.17807486653327942,
+      0.5545235872268677,
+      -0.6007466912269592,
+      0.42812374234199524,
+      0.08186574280261993,
+      0.2659360468387604,
+      -0.41609466075897217,
+      -0.5962536334991455,
+      -0.3122826814651489,
+      0.32409751415252686,
+      0.6739369630813599,
+      0.5346131324768066,
+      -0.6569995284080505,
+      -0.5584861636161804,
+      0.5756837725639343,
+      0.7416533827781677,
+      0.23805756866931915,
+      -0.3694150149822235,
+      0.4609140157699585,
+      0.4063715934753418,
+      0.09016892313957214,
+      -0.23848992586135864,
+      0.5578575134277344,
+      -0.46439528465270996,
+      -0.4068780541419983,
+      0.544366717338562,
+      0.3993358314037323,
+      -0.4173828065395355,
+      0.229123055934906,
+      -0.5490871667861938,
+      0.5770585536956787,
+      -0.39044317603111267,
+      -0.6179271936416626,
+      -0.4629450738430023,
+      0.47791239619255066,
+      0.7727953195571899,
+      -0.4947788417339325,
+      0.21023114025592804,
+      -0.2763822674751282,
+      0.31660231947898865,
+      0.7578261494636536,
+      0.36358076333999634,
+      -0.2730739414691925,
+      0.7853317856788635,
+      0.0518028624355793,
+      -0.5771622061729431,
+      0.34737157821655273,
+      -0.05463007092475891,
+      -0.48710644245147705,
+      -0.2929217219352722,
+      0.10876808315515518,
+      0.56290602684021,
+      0.44349828362464905,
+      0.48770076036453247,
+      -0.4980546832084656,
+      -0.5883984565734863,
+      0.25160253047943115,
+      0.10964559763669968,
+      0.37879517674446106,
+      -0.290043443441391,
+      0.5417924523353577,
+      0.4497000277042389,
+      -0.5163202285766602,
+      -0.28064480423927307,
+      0.29856574535369873,
+      0.4774533808231354,
+      -0.3002442419528961,
+      -0.1280519813299179,
+      -0.404786080121994,
+      0.5543663501739502,
+      -0.5511503219604492,
+      0.4968489706516266,
+      -0.4734399616718292,
+      0.5590401887893677,
+      -0.5166779160499573,
+      0.40771347284317017,
+      -0.6714063882827759,
+      0.6584751009941101,
+      -0.09569267183542252,
+      0.5472999215126038,
+      -0.48260003328323364,
+      -0.11467840522527695,
+      -0.18142664432525635,
+      -0.6749077439308167,
+      0.5573946237564087,
+      0.440958172082901,
+      -0.3269651234149933,
+      0.5036769509315491,
+      -0.6093200445175171,
+      0.38963407278060913,
+      -0.0026236730627715588,
+      -0.4701225161552429,
+      -0.520491898059845,
+      -0.4147573709487915,
+      -0.3283874988555908,
+      0.4954054057598114,
+      -0.6171549558639526,
+      0.38185861706733704,
+      -0.5666277408599854,
+      0.7219245433807373,
+      0.58454430103302,
+      -0.47670692205429077,
+      0.42368021607398987,
+      -0.5197672247886658,
+      -0.48470231890678406,
+      -0.6032153964042664,
+      -0.1776377558708191,
+      0.34772226214408875,
+      -0.5075376033782959,
+      0.5055197477340698,
+      -0.6107749342918396,
+      0.5693075060844421,
+      0.9442098736763,
+      -0.6182811856269836,
+      0.5870493054389954,
+      0.2253257781267166,
+      -0.1791469007730484,
+      -0.22695675492286682,
+      0.31226152181625366,
+      0.04046796262264252,
+      0.17730140686035156,
+      -0.6283512115478516,
+      0.6919345855712891,
+      0.6322853565216064,
+      -0.21163585782051086,
+      -0.525471568107605,
+      0.3001823425292969,
+      -0.2083841860294342,
+      0.4563871920108795,
+      -0.46424710750579834,
+      0.5040539503097534,
+      -0.4580048620700836,
+      -0.5883434414863586,
+      0.6421611309051514,
+      -0.7878042459487915,
+      0.793711245059967,
+      0.42383310198783875,
+      0.49203595519065857,
+      -0.14698092639446259,
+      -0.013634764589369297,
+      -0.6515633463859558,
+      -0.611086905002594,
+      0.4841988980770111,
+      -0.6612274646759033,
+      -0.40686869621276855,
+      -0.28031399846076965,
+      0.47590166330337524,
+      -0.8496487140655518,
+      0.4805188775062561,
+      0.10948624461889267,
+      0.5154337286949158,
+      -0.2509177327156067,
+      -0.29934972524642944,
+      -0.6761432886123657,
+      0.7292912602424622,
+      -0.4002574682235718,
+      -0.6207399964332581,
+      -0.838944673538208,
+      -0.6486210823059082,
+      -0.5000784993171692,
+      -0.6842228174209595,
+      0.213387131690979,
+      -0.5762696266174316,
+      -0.12696601450443268,
+      -0.5075131058692932,
+      -0.5239382982254028,
+      -0.09663907438516617,
+      0.08113496750593185,
+      -0.5137198567390442,
+      -0.30290159583091736,
+      -0.5024582743644714,
+      0.2599025070667267,
+      0.48784178495407104,
+      0.055365972220897675,
+      -0.31638234853744507,
+      0.2888021767139435,
+      0.21264268457889557,
+      0.638916015625,
+      0.45516276359558105,
+      0.5979908108711243,
+      0.2697484791278839,
+      -0.601152241230011,
+      0.08367829769849777,
+      0.27593091130256653,
+      0.2619452476501465,
+      0.37542665004730225,
+      -0.5827372670173645,
+      0.7164355516433716,
+      0.29327672719955444,
+      -0.3225495219230652,
+      0.14185361564159393,
+      -0.8465701937675476,
+      -0.17891362309455872,
+      0.2571544051170349,
+      0.1886378526687622,
+      0.46635645627975464,
+      0.27793434262275696,
+      -0.47681981325149536,
+      -0.1061960980296135,
+      -0.5719597339630127,
+      0.4304024577140808,
+      -0.5177552700042725,
+      0.43166348338127136,
+      -0.5323641896247864,
+      -0.11818656325340271,
+      -0.05869956314563751,
+      -0.630853533744812,
+      0.5522435903549194,
+      -0.26830682158470154,
+      -0.5874941945075989,
+      0.274897038936615,
+      0.6072633862495422,
+      -0.5939161777496338,
+      -0.5861645340919495,
+      -0.4334408640861511,
+      0.3161979615688324,
+      0.2808525562286377,
+      -0.4504222869873047,
+      -0.0519416444003582,
+      0.2261221706867218,
+      0.49213266372680664,
+      0.4448302388191223,
+      -0.4500104784965515,
+      -0.039395689964294434,
+      0.42932918667793274,
+      0.5171367526054382,
+      0.5085828304290771,
+      -0.32407456636428833,
+      -0.44762447476387024,
+      0.3271075487136841,
+      0.38971295952796936,
+      0.5840552449226379,
+      -0.38570669293403625,
+      -0.6695638298988342,
+      -0.7533370852470398,
+      -0.5539284348487854,
+      0.6343709826469421,
+      -0.4014757573604584,
+      -0.5834019780158997,
+      -0.4964871108531952,
+      0.5439229011535645,
+      -0.37932559847831726,
+      0.556016743183136,
+      0.36505022644996643,
+      0.658854603767395,
+      -0.5856919884681702,
+      0.5211732983589172,
+      0.5257969498634338,
+      0.033363766968250275,
+      -0.6026785373687744,
+      -0.36229389905929565,
+      0.5080668330192566,
+      -0.48063787817955017,
+      -0.17072567343711853,
+      0.2689678370952606,
+      0.6430474519729614,
+      0.5084283351898193,
+      0.032115768641233444,
+      -0.42459872364997864,
+      -0.5446518659591675,
+      0.4938414394855499,
+      0.4291890263557434,
+      0.4820692539215088,
+      -0.5631460547447205,
+      -0.5235498547554016,
+      -0.1327357292175293,
+      -0.6124010682106018,
+      0.5722095370292664,
+      0.5760930180549622,
+      -0.557637631893158,
+      0.22705884277820587,
+      0.511828601360321,
+      -0.3010265529155731,
+      0.607011079788208,
+      -0.6336585283279419,
+      -0.6199253797531128,
+      0.48826292157173157,
+      0.3967286944389343,
+      -0.2849735617637634,
+      0.43583595752716064,
+      0.6015684604644775,
+      0.4726688265800476,
+      0.3331848978996277,
+      -0.4791380763053894,
+      0.3802970349788666,
+      0.5389403700828552,
+      -0.5349174737930298,
+      0.6625897288322449,
+      0.5519260168075562,
+      0.5648009777069092,
+      0.4412316083908081,
+      -0.6444944739341736,
+      0.3868718147277832,
+      0.7869400382041931,
+      0.5635072588920593,
+      -0.7581864595413208,
+      -0.43755513429641724,
+      -0.19367095828056335,
+      0.60500568151474,
+      -0.473347008228302,
+      -0.04229379817843437,
+      -0.16389791667461395,
+      -0.046836283057928085,
+      0.17623679339885712,
+      -0.042533792555332184,
+      -0.14560171961784363,
+      -0.10979795455932617,
+      -0.000812417536508292,
+      0.10412212461233139,
+      0.20097237825393677,
+      -0.00750306760892272,
+      0.1720348298549652,
+      0.06982551515102386,
+      0.048237212002277374,
+      -0.23839281499385834,
+      0.3583084046840668,
+      -0.23288936913013458,
+      -0.22252047061920166,
+      -0.07366273552179337,
+      0.3645133674144745,
+      -0.26447516679763794,
+      -0.11945220828056335,
+      0.26163938641548157,
+      0.2344539314508438,
+      0.15971706807613373,
+      -0.1326783150434494,
+      0.12608030438423157,
+      -0.4383699595928192,
+      -0.5530542135238647,
+      0.20570719242095947,
+      0.05023733898997307,
+      0.1964007318019867,
+      0.5211929678916931,
+      0.011690662242472172,
+      -0.1282302439212799,
+      0.2111765444278717,
+      -0.06438232958316803,
+      0.018117204308509827,
+      -0.10277930647134781,
+      -0.39649415016174316,
+      -0.1702582687139511,
+      -0.023678457364439964,
+      -0.03561067208647728,
+      0.06724896281957626,
+      0.09960493445396423,
+      0.20002371072769165,
+      0.2907847464084625,
+      0.03925766795873642,
+      0.0065562245436012745,
+      -0.11187387257814407,
+      0.1333198845386505,
+      -0.05301545560359955,
+      -0.034278661012649536,
+      0.09543751925230026,
+      0.07358504086732864,
+      0.26777175068855286,
+      -0.16850227117538452,
+      0.2209654003381729,
+      0.502488911151886,
+      0.6801419854164124,
+      -0.4001198410987854,
+      -0.29424628615379333,
+      -0.08849529922008514,
+      0.25346314907073975,
+      0.12016011029481888,
+      -0.183090940117836,
+      0.24284860491752625,
+      0.2019088715314865,
+      0.2086249589920044,
+      0.26586925983428955,
+      -0.23053331673145294,
+      -0.04497445374727249,
+      -0.12829023599624634,
+      0.1478312462568283,
+      0.1556464284658432,
+      0.09635277837514877,
+      0.2254221886396408,
+      0.2085561901330948,
+      -0.04151191934943199,
+      -0.3400104343891144,
+      -0.161619171500206,
+      0.061953913420438766,
+      0.06938552856445312,
+      0.2185511291027069,
+      0.13206222653388977,
+      -0.13662301003932953,
+      0.03838811814785004,
+      0.24795491993427277,
+      -0.22635267674922943,
+      0.26808175444602966,
+      0.05375305190682411,
+      0.1312665194272995,
+      -0.18162821233272552,
+      0.2682986855506897,
+      0.37956565618515015,
+      0.057593319565057755,
+      0.14767535030841827,
+      -0.23180840909481049,
+      -0.3678608238697052,
+      -0.5583789944648743,
+      0.07128473371267319,
+      0.10965823382139206,
+      -0.31575843691825867,
+      -0.10914731025695801,
+      -0.35615110397338867,
+      0.04601464793086052,
+      -0.23540574312210083,
+      -0.17907334864139557,
+      -0.34793782234191895,
+      -0.34167394042015076,
+      -0.47616836428642273,
+      -0.24529176950454712,
+      0.11963231861591339,
+      0.1936894804239273,
+      -0.006651640869677067,
+      0.007289855275303125,
+      -0.03284122049808502,
+      -0.22686517238616943,
+      -0.13926152884960175,
+      -0.25020575523376465,
+      0.20833373069763184,
+      -0.11253945529460907,
+      0.12057550251483917,
+      -0.022917678579688072,
+      0.04169459268450737,
+      0.14982087910175323,
+      -0.10561981052160263,
+      0.2822776436805725,
+      0.01875096559524536,
+      -0.07925187051296234,
+      -0.22598512470722198,
+      -0.18576356768608093,
+      0.16715767979621887,
+      0.1415344923734665,
+      0.026288799941539764,
+      0.2131047248840332,
+      -0.040931981056928635,
+      0.24032042920589447,
+      -0.010192576795816422,
+      -0.003330687992274761,
+      0.504662036895752,
+      0.5437992811203003,
+      -0.3169926404953003,
+      0.09638766944408417,
+      0.3067358434200287,
+      0.06145891919732094,
+      -0.07863249629735947,
+      -0.08540267497301102,
+      0.1543775498867035,
+      -0.30020517110824585,
+      -0.35361987352371216,
+      0.04363108426332474,
+      0.24259968101978302,
+      -0.4847774803638458,
+      0.20528705418109894,
+      0.20164655148983002,
+      -0.01677972637116909,
+      0.04092950001358986,
+      -0.11456584185361862,
+      0.11674720793962479,
+      -0.21948687732219696,
+      0.09659700840711594,
+      -0.06174008175730705,
+      -0.12229377031326294,
+      -0.18225517868995667,
+      -0.13672633469104767,
+      0.2011241614818573,
+      -0.40462711453437805,
+      -0.03922515735030174,
+      0.4779961407184601,
+      -0.16949136555194855,
+      0.28197190165519714,
+      -0.0651712417602539,
+      -0.18198411166667938,
+      0.052842386066913605,
+      0.09949929267168045,
+      -0.22297944128513336,
+      -0.057711027562618256,
+      0.27514883875846863,
+      -0.39546141028404236,
+      0.1879843771457672,
+      -0.19569970667362213,
+      -0.21887756884098053,
+      -0.192561537027359,
+      0.16887126863002777,
+      -0.08057205379009247,
+      -0.09789175540208817,
+      -0.05233345553278923,
+      0.005102627445012331,
+      -0.2575450837612152,
+      0.330186665058136,
+      -0.6725046634674072,
+      -0.09959437698125839,
+      -0.045458149164915085,
+      0.21965444087982178,
+      -0.00013260619016364217,
+      0.28631147742271423,
+      0.395963191986084,
+      0.014002902433276176,
+      0.05100059136748314,
+      -0.47803983092308044,
+      -0.35184553265571594,
+      0.24095815420150757,
+      -0.26707109808921814,
+      0.02945927157998085,
+      -0.021550685167312622,
+      0.0865086168050766,
+      0.12556840479373932,
+      -0.023434923961758614,
+      -0.23609891533851624,
+      -0.11124417930841446,
+      0.08189614117145538,
+      -0.0623178668320179,
+      0.5730078816413879,
+      0.07188976556062698,
+      -0.2833845615386963,
+      0.10521174222230911,
+      0.04196837544441223,
+      0.1458122879266739,
+      -0.2975368797779083,
+      -0.221624493598938,
+      -0.25704318284988403,
+      -0.11698277294635773,
+      -0.4051510691642761,
+      0.24249841272830963,
+      -0.36092066764831543,
+      0.09584717452526093,
+      0.049728281795978546,
+      -0.04320039227604866,
+      0.11536545306444168,
+      -0.07639521360397339,
+      -0.14649368822574615,
+      -0.25324591994285583,
+      -0.005763915833085775,
+      -0.5686010718345642,
+      0.2630966305732727,
+      0.02403961308300495,
+      -0.10315421968698502,
+      -0.033482328057289124,
+      0.1061115488409996,
+      0.12253917753696442,
+      0.04944491386413574,
+      -0.3874559998512268,
+      0.028973400592803955,
+      0.17262256145477295,
+      0.22983339428901672,
+      0.10847950726747513,
+      0.07570980489253998,
+      -0.29912444949150085,
+      -0.1893816739320755,
+      -0.31946074962615967,
+      -0.10217683017253876,
+      -0.4927314817905426,
+      0.1326046586036682,
+      0.27646544575691223,
+      0.16918408870697021,
+      -0.1824277937412262,
+      0.002850130433216691,
+      -0.0009537636069580913,
+      0.0019877750892192125,
+      -0.004948409739881754,
+      -0.008316612802445889,
+      0.004207105841487646,
+      -0.005114191211760044,
+      -0.00041094611515291035,
+      0.004531696438789368,
+      0.0046106320805847645,
+      -0.004249882884323597,
+      -0.0028968206606805325,
+      -0.004400105681270361,
+      0.005509004928171635,
+      0.004082438535988331,
+      0.0033618228044360876,
+      0.005578058306127787,
+      0.0025190431624650955,
+      0.0029459537472575903,
+      0.0029643557500094175,
+      0.008913869969546795,
+      -0.00119783787522465,
+      -0.0011385264806449413,
+      0.0010599781526252627,
+      -0.009323070757091045,
+      0.00029228199855424464,
+      0.0032860198989510536,
+      -0.0018906857585534453,
+      -0.004786238539963961,
+      0.0029093800112605095,
+      0.008732978254556656,
+      -0.0012697507627308369,
+      -0.0015244890237227082,
+      -0.0007339715375564992,
+      0.004065475892275572,
+      -0.002048727124929428,
+      0.0037553783040493727,
+      0.0065777297131717205,
+      0.0031715575605630875,
+      0.00325014628469944,
+      -0.006142215803265572,
+      -0.005848207511007786,
+      -0.0037326489109545946,
+      -0.00044978829100728035,
+      -0.011724578216671944,
+      0.005017526913434267,
+      -0.0035253034438937902,
+      -0.00019609919399954379,
+      -0.00148602738045156,
+      0.0021495576947927475,
+      0.0009647426195442677,
+      0.002942750696092844,
+      -0.01105999294668436,
+      0.00486386101692915,
+      -0.004324464127421379,
+      0.005949683953076601,
+      -0.004664322827011347,
+      0.003913524094969034,
+      -0.0012645965907722712,
+      -0.001229200861416757,
+      -0.00215838011354208,
+      0.002429769840091467,
+      0.00014661383465863764,
+      -0.00026782171335071325,
+      0.0014878136571496725,
+      -0.011606430634856224,
+      0.013660091906785965,
+      -0.03923620283603668,
+      0.012667507864534855,
+      -0.01129599753767252,
+      -0.002176530659198761,
+      -0.005026976577937603,
+      -0.00729585625231266,
+      0.0351935513317585,
+      -0.008873775601387024,
+      0.008286446332931519,
+      -0.0018937521381303668,
+      0.004342446569353342,
+      0.005578185431659222,
+      0.001724852598272264,
+      0.029082277789711952,
+      -0.01923050358891487,
+      -0.0023423731327056885,
+      -0.005308382213115692,
+      -0.033989015966653824,
+      -0.006406776607036591,
+      -0.01943986490368843,
+      0.004477210342884064,
+      0.006001736037433147,
+      -0.013980921357870102,
+      -0.011277023702859879,
+      -0.015905721113085747,
+      -0.02820765972137451,
+      0.019384276121854782,
+      0.029217487201094627,
+      -0.0157290268689394,
+      -0.00011734727013390511,
+      -0.000315455166855827,
+      -0.007524586282670498,
+      -0.011345199309289455,
+      -0.00017373525770381093,
+      0.022696511819958687,
+      0.00016490250709466636,
+      -0.006264247931540012,
+      -0.0005076624802313745,
+      0.014368499629199505,
+      -0.005704553332179785,
+      0.0048988894559443,
+      0.0034469368401914835,
+      0.005690488964319229,
+      -0.00731660658493638,
+      -0.01312793418765068,
+      0.027105165645480156,
+      0.004152554087340832,
+      0.015373715199530125,
+      -0.00014540599659085274,
+      -0.008389804512262344,
+      0.0024012592621147633,
+      0.007523218169808388,
+      -0.002189652994275093,
+      -0.0079547930508852,
+      0.00887039490044117,
+      -0.003295361762866378,
+      -0.011245502158999443,
+      0.01634286344051361,
+      -0.004305421374738216,
+      -0.020577874034643173,
+      -0.010176942683756351,
+      -0.002636705059558153,
+      0.002629427472129464,
+      0.010027662850916386,
+      -0.0019386817002668977,
+      0.011943185701966286,
+      0.0013497850159183145,
+      -0.0030482232104986906,
+      0.0027056438848376274,
+      0.004057863261550665,
+      0.01590159721672535,
+      -0.006561584770679474,
+      0.005488707218319178,
+      -0.0035933731123805046,
+      0.012101414613425732,
+      0.009126783348619938,
+      0.006772737018764019,
+      0.017966073006391525,
+      0.01271012146025896,
+      0.011593744158744812,
+      0.00381386443041265,
+      -0.007865527644753456,
+      0.0008343009976670146,
+      -0.0030884721782058477,
+      0.010167327709496021,
+      -0.011945083737373352,
+      -0.007140151225030422,
+      -0.0012977288570255041,
+      -0.010239080525934696,
+      -0.015454847365617752,
+      -0.0038246193435043097,
+      0.014328232035040855,
+      -0.011641643941402435,
+      -0.007750903721898794,
+      0.013255380094051361,
+      0.011205035261809826,
+      -0.015209320932626724,
+      0.006413482595235109,
+      0.008777493610978127,
+      0.004896240308880806,
+      0.0013897825265303254,
+      -0.001962441485375166,
+      0.0057435366325080395,
+      0.0014271686086431146,
+      -0.008656928315758705,
+      -0.0009493909310549498,
+      -4.59537077404093e-05,
+      0.006630320567637682,
+      -0.007160136476159096,
+      0.021778007969260216,
+      0.012312923558056355,
+      0.006152208428829908,
+      0.005909174680709839,
+      -0.011128720827400684,
+      0.005952140782028437,
+      -0.01499018631875515,
+      0.0040036034770309925,
+      -0.007701188325881958,
+      -0.002836391795426607,
+      -0.0007777111022733152,
+      -0.010451355949044228,
+      -0.022016670554876328,
+      -0.0022132727317512035,
+      0.01658616214990616,
+      -0.01811685971915722
+    ]
+  },
+  "b1": {
+    "shape": [
+      1,
+      32
+    ],
+    "data": [
+      0.41140854358673096,
+      0.04173576086759567,
+      0.13452301919460297,
+      -0.16835665702819824,
+      -0.18976707756519318,
+      0.24743373692035675,
+      0.2824676036834717,
+      0.33658891916275024,
+      -0.21462462842464447,
+      0.2634226083755493,
+      -0.1966567486524582,
+      -0.2314452975988388,
+      -0.16719190776348114,
+      0.15494607388973236,
+      -0.016421256586909294,
+      -0.11141982674598694,
+      0.12311933189630508,
+      -0.09508314728736877,
+      0.04821639508008957,
+      0.0026365062221884727,
+      -0.09570834040641785,
+      0.09805349260568619,
+      0.07465144246816635,
+      0.18552590906620026,
+      0.06514368206262589,
+      -0.26759371161460876,
+      -0.09934244304895401,
+      0.3285941183567047,
+      -0.05968666449189186,
+      -0.17026019096374512,
+      -0.0382223017513752,
+      -0.36833757162094116
+    ]
+  },
+  "w2": {
+    "shape": [
+      32,
+      32
+    ],
+    "data": [
+      0.5833324790000916,
+      -0.04406915232539177,
+      0.6600975394248962,
+      0.7142001390457153,
+      -0.5744909644126892,
+      0.5403149724006653,
+      0.5255634188652039,
+      0.4884111285209656,
+      0.7351821660995483,
+      -0.40603965520858765,
+      -0.5451126098632812,
+      -0.8551400303840637,
+      0.6571963429450989,
+      -0.0016029041726142168,
+      -0.21257120370864868,
+      0.262179970741272,
+      0.5852038264274597,
+      -0.4373844563961029,
+      -0.3300783932209015,
+      0.5403759479522705,
+      0.5167884826660156,
+      -0.5400581359863281,
+      0.349983274936676,
+      0.6145856976509094,
+      -0.5377432703971863,
+      -0.4395396113395691,
+      0.242854505777359,
+      0.3129275441169739,
+      0.5349745750427246,
+      -0.36281147599220276,
+      -0.012708989903330803,
+      -0.29258570075035095,
+      0.1502782255411148,
+      -0.5993214845657349,
+      -0.42047733068466187,
+      -0.7328343391418457,
+      0.07879219204187393,
+      -0.4335479736328125,
+      -0.46740323305130005,
+      0.3897668719291687,
+      -0.34847062826156616,
+      0.2858060598373413,
+      0.6377367377281189,
+      -0.5783088803291321,
+      0.4374323785305023,
+      0.6072802543640137,
+      0.1994921714067459,
+      0.4401877224445343,
+      -0.5351462960243225,
+      0.6453456878662109,
+      0.349551796913147,
+      -0.3295154571533203,
+      0.15862075984477997,
+      -0.38853126764297485,
+      -0.03560666739940643,
+      -1.0106849670410156,
+      -0.05049445480108261,
+      0.5666105151176453,
+      0.1269836723804474,
+      0.49595582485198975,
+      -0.25165697932243347,
+      0.3981028199195862,
+      -0.3493008017539978,
+      -0.580100417137146,
+      0.512855589389801,
+      0.49403664469718933,
+      0.7002808451652527,
+      -0.6447817087173462,
+      -0.46112489700317383,
+      -0.6727323532104492,
+      -0.30430856347084045,
+      0.029585890471935272,
+      0.5084590911865234,
+      -0.02487567998468876,
+      -0.6376674175262451,
+      0.15851113200187683,
+      -0.16205526888370514,
+      0.49677708745002747,
+      0.6316495537757874,
+      0.09202060848474503,
+      -0.044446852058172226,
+      -0.44909048080444336,
+      -0.3618501126766205,
+      0.2309982031583786,
+      -0.3059355318546295,
+      0.2216901332139969,
+      0.7052450180053711,
+      0.5653706789016724,
+      -0.24655191600322723,
+      0.012539896182715893,
+      -0.5066306591033936,
+      0.4240724742412567,
+      0.2995709776878357,
+      0.4913083612918854,
+      -0.3670593202114105,
+      0.1709272414445877,
+      -0.16780859231948853,
+      0.27923518419265747,
+      0.3594975471496582,
+      -0.10006467998027802,
+      0.11873389780521393,
+      -0.21080812811851501,
+      0.36188894510269165,
+      0.1155799925327301,
+      -0.03603120148181915,
+      -0.4752098321914673,
+      -0.06422003358602524,
+      -0.2022850066423416,
+      0.46574854850769043,
+      -0.5363007187843323,
+      -0.49227839708328247,
+      0.5008364915847778,
+      0.15924297273159027,
+      0.4999876916408539,
+      0.2093067318201065,
+      0.2674435079097748,
+      0.19237685203552246,
+      0.3519442081451416,
+      -0.3069104850292206,
+      -0.035096026957035065,
+      -0.48597055673599243,
+      0.43370747566223145,
+      0.26168137788772583,
+      -0.7016384601593018,
+      0.24665753543376923,
+      -0.6467354893684387,
+      0.5018359422683716,
+      0.033296145498752594,
+      0.6295042634010315,
+      -0.4614506661891937,
+      0.13660889863967896,
+      0.21576815843582153,
+      -0.5289676189422607,
+      0.16124995052814484,
+      -0.430896133184433,
+      -0.2777698338031769,
+      -0.3694620132446289,
+      -0.3000061810016632,
+      0.4746783673763275,
+      -0.21980877220630646,
+      0.028262704610824585,
+      -0.6049205660820007,
+      -0.2659418284893036,
+      0.5230205059051514,
+      0.428293377161026,
+      0.7031703591346741,
+      -0.8487260341644287,
+      0.14968392252922058,
+      -0.33109772205352783,
+      0.015154345892369747,
+      -0.634479820728302,
+      -0.5703725814819336,
+      -0.42063236236572266,
+      0.5424582362174988,
+      -0.3817545771598816,
+      -0.34744349122047424,
+      -0.24597947299480438,
+      -0.36885523796081543,
+      -0.4962368905544281,
+      -0.30333632230758667,
+      -0.5365340709686279,
+      0.4581771492958069,
+      0.3692333698272705,
+      -0.6331499218940735,
+      0.37304970622062683,
+      -0.2613667845726013,
+      0.6492074131965637,
+      0.14226311445236206,
+      0.5509650111198425,
+      0.45414191484451294,
+      -0.29219260811805725,
+      0.1414361596107483,
+      -0.24997463822364807,
+      -0.20976391434669495,
+      -0.4982142746448517,
+      0.29630526900291443,
+      0.07064923644065857,
+      -0.4267894923686981,
+      0.3634204566478729,
+      0.017851252108812332,
+      0.5771238207817078,
+      0.20217125117778778,
+      0.39566054940223694,
+      -0.5220259428024292,
+      0.4514642357826233,
+      0.37925097346305847,
+      -0.10530488193035126,
+      -0.2922782003879547,
+      0.08175758272409439,
+      -0.20521482825279236,
+      -0.0306957196444273,
+      0.48851072788238525,
+      -0.10273008048534393,
+      0.42951491475105286,
+      0.02238401770591736,
+      -0.5642263889312744,
+      0.6398353576660156,
+      0.3255603015422821,
+      0.05302750691771507,
+      0.22017233073711395,
+      0.48476746678352356,
+      -0.36019018292427063,
+      -0.3300016522407532,
+      0.4121972918510437,
+      -0.060121260583400726,
+      -0.47367820143699646,
+      0.4820711612701416,
+      -0.3144012987613678,
+      -0.18787987530231476,
+      -0.6451897621154785,
+      0.09151020646095276,
+      0.3710666596889496,
+      0.015813039615750313,
+      0.493587464094162,
+      0.6230376958847046,
+      -0.5254106521606445,
+      -0.6215486526489258,
+      0.6611680388450623,
+      -0.529807448387146,
+      0.31883421540260315,
+      -0.48107075691223145,
+      -0.3159598112106323,
+      0.14964470267295837,
+      0.5351456999778748,
+      -0.2974824905395508,
+      -0.46421006321907043,
+      0.5263380408287048,
+      -0.6271401047706604,
+      0.4400186538696289,
+      -0.17663508653640747,
+      0.26863738894462585,
+      0.6724404096603394,
+      -0.22855490446090698,
+      -0.3761236071586609,
+      0.260640412569046,
+      -0.3002377450466156,
+      -0.5119364857673645,
+      0.19921129941940308,
+      -0.3379356563091278,
+      -0.5390681624412537,
+      0.26380741596221924,
+      -0.7100263237953186,
+      0.7113850712776184,
+      0.23713169991970062,
+      0.6110486388206482,
+      0.19032925367355347,
+      -0.3739713430404663,
+      -0.5558298230171204,
+      0.21515342593193054,
+      0.24163122475147247,
+      -0.4011124074459076,
+      0.6750406622886658,
+      -0.3016811013221741,
+      0.6329986453056335,
+      -0.6256395578384399,
+      -0.4204891324043274,
+      0.3094017207622528,
+      -0.5445554852485657,
+      -0.41654062271118164,
+      0.012857383117079735,
+      -0.1534586399793625,
+      0.5336133241653442,
+      -0.2742224931716919,
+      0.4339938461780548,
+      -0.5819524526596069,
+      -0.4246542751789093,
+      0.5119465589523315,
+      -0.08963221311569214,
+      -0.27624261379241943,
+      0.5424147248268127,
+      -0.5992923378944397,
+      -0.2918991446495056,
+      0.5111084580421448,
+      0.6846715807914734,
+      0.7504979372024536,
+      -0.245253324508667,
+      -0.6776694655418396,
+      -0.07147231698036194,
+      -0.3852207362651825,
+      0.2938641309738159,
+      -0.46525564789772034,
+      -0.5311563014984131,
+      -0.5654810070991516,
+      0.6059191226959229,
+      -0.2312941551208496,
+      0.44127240777015686,
+      -0.23609904944896698,
+      -0.4189485013484955,
+      -0.02442186512053013,
+      -0.08868797868490219,
+      0.44043442606925964,
+      -0.7043417096138,
+      0.6295157074928284,
+      -0.2798103094100952,
+      0.8230570554733276,
+      0.614812970161438,
+      -0.29268983006477356,
+      -0.7184505462646484,
+      -0.39698925614356995,
+      -0.45872190594673157,
+      -0.05979219451546669,
+      -0.3655514121055603,
+      -0.38769295811653137,
+      0.3701415956020355,
+      -0.2648469805717468,
+      0.3112601935863495,
+      -0.42514297366142273,
+      0.262031227350235,
+      0.6487522125244141,
+      -0.8340243697166443,
+      -0.3777776062488556,
+      -0.6580366492271423,
+      -0.7763147354125977,
+      0.3084772527217865,
+      0.47092580795288086,
+      -0.5821054577827454,
+      -0.18236568570137024,
+      0.26621055603027344,
+      0.23267990350723267,
+      -0.40806877613067627,
+      0.33092641830444336,
+      0.5049144625663757,
+      0.5978044867515564,
+      0.09595219790935516,
+      0.13087329268455505,
+      0.3329981863498688,
+      -0.4476466774940491,
+      0.4787166118621826,
+      -0.8050774931907654,
+      -0.3497099280357361,
+      0.40341219305992126,
+      0.16913624107837677,
+      -0.430574506521225,
+      0.1418146789073944,
+      -0.595954418182373,
+      -0.2903168797492981,
+      0.6807904243469238,
+      -0.3185294270515442,
+      -0.21566346287727356,
+      0.19651934504508972,
+      -0.516979992389679,
+      0.44546905159950256,
+      0.045729346573352814,
+      0.3873681128025055,
+      0.5284611582756042,
+      -0.5343829989433289,
+      -0.1261325180530548,
+      -0.1843467652797699,
+      0.6600763201713562,
+      0.37744462490081787,
+      -0.0635499432682991,
+      -0.10794416815042496,
+      -0.0002241041511297226,
+      0.22270141541957855,
+      0.6185049414634705,
+      -0.6216243505477905,
+      0.41236862540245056,
+      0.1597968488931656,
+      -0.40577638149261475,
+      0.049581047147512436,
+      -0.5208377838134766,
+      -0.6065584421157837,
+      0.07122477144002914,
+      0.4274607300758362,
+      -0.3176823854446411,
+      -0.6851423382759094,
+      -0.17077049612998962,
+      -0.4044148027896881,
+      0.3310195803642273,
+      0.6188254356384277,
+      0.24962544441223145,
+      -0.2544820308685303,
+      -0.5683344006538391,
+      0.7191358804702759,
+      0.3987292945384979,
+      -0.29436302185058594,
+      0.24791575968265533,
+      0.4268662929534912,
+      -0.812101423740387,
+      -0.5028775930404663,
+      -0.4908024072647095,
+      -0.31225505471229553,
+      -0.39285531640052795,
+      0.2145087718963623,
+      0.5212684869766235,
+      -0.4105469882488251,
+      -0.32129278779029846,
+      -0.23772810399532318,
+      -0.28639471530914307,
+      0.08771773427724838,
+      0.07542192935943604,
+      -0.017433010041713715,
+      0.0651613101363182,
+      -0.3744242787361145,
+      0.001255915267392993,
+      0.6371977925300598,
+      -0.5604463815689087,
+      0.12174168974161148,
+      0.5265082716941833,
+      0.580610454082489,
+      -0.4659837782382965,
+      0.5650064945220947,
+      -0.5126415491104126,
+      -0.5266972184181213,
+      -0.02548130974173546,
+      -0.5531303882598877,
+      0.7300903797149658,
+      0.3502790033817291,
+      -0.19735898077487946,
+      0.3693282902240753,
+      -0.6501651406288147,
+      0.4646427631378174,
+      0.5543301105499268,
+      -0.30201414227485657,
+      -0.47283875942230225,
+      -0.44695931673049927,
+      -0.39823076128959656,
+      -0.331135094165802,
+      -0.4449721574783325,
+      -0.5523015856742859,
+      0.025226440280675888,
+      -0.4603944718837738,
+      -0.3619481027126312,
+      0.6661345958709717,
+      -0.16382713615894318,
+      0.22786790132522583,
+      0.35439828038215637,
+      -0.3898983597755432,
+      0.5926012396812439,
+      0.6024504899978638,
+      0.21765899658203125,
+      -0.16284504532814026,
+      -0.3862069249153137,
+      0.2501187324523926,
+      -0.08133663982152939,
+      -0.7289565801620483,
+      -0.09309838712215424,
+      -0.14477242529392242,
+      0.48450803756713867,
+      0.4594329297542572,
+      0.006138231139630079,
+      -0.4999004602432251,
+      0.2860872447490692,
+      0.09353700280189514,
+      0.15789562463760376,
+      0.5243611335754395,
+      -0.6703538298606873,
+      0.3256537616252899,
+      -0.1973860114812851,
+      0.49629539251327515,
+      0.3557225167751312,
+      -0.6070427894592285,
+      -0.2587185502052307,
+      0.6013321876525879,
+      -0.21388165652751923,
+      0.27553173899650574,
+      0.4662202298641205,
+      -0.2665696442127228,
+      -0.03399352729320526,
+      0.259753942489624,
+      -0.33015790581703186,
+      -0.296721488237381,
+      -0.5230078101158142,
+      -0.4484809637069702,
+      0.24322441220283508,
+      -0.4481692314147949,
+      -0.11759919673204422,
+      0.5892905592918396,
+      -0.3177355229854584,
+      0.35668259859085083,
+      0.40587493777275085,
+      0.5350204706192017,
+      -0.4253546893596649,
+      0.4767685830593109,
+      -0.23908862471580505,
+      -0.5818323493003845,
+      -0.47033533453941345,
+      -0.13237595558166504,
+      -0.3849073052406311,
+      -0.09731189161539078,
+      -0.4081884026527405,
+      0.2294994294643402,
+      -0.00451787281781435,
+      -0.0033397148363292217,
+      0.3084481358528137,
+      -0.5034567713737488,
+      -0.5140432119369507,
+      -0.5681009292602539,
+      0.3150945007801056,
+      0.6291296482086182,
+      -0.38377049565315247,
+      0.5602982044219971,
+      0.5160306692123413,
+      -0.32025274634361267,
+      0.5780768394470215,
+      -0.23512595891952515,
+      -0.4884661138057709,
+      -0.13480080664157867,
+      0.26555335521698,
+      -0.5860243439674377,
+      -0.567520797252655,
+      0.4778851568698883,
+      0.331341952085495,
+      -0.48603272438049316,
+      0.6391537189483643,
+      0.5108295679092407,
+      -0.5969434976577759,
+      -0.0065856981091201305,
+      -0.2848271131515503,
+      -0.2556472718715668,
+      -0.3502233922481537,
+      0.5650025606155396,
+      0.5705208778381348,
+      -0.48064252734184265,
+      0.28450024127960205,
+      0.45592421293258667,
+      -0.24283505976200104,
+      0.3628832697868347,
+      -0.537107527256012,
+      -0.3009094297885895,
+      0.1435806304216385,
+      0.2973416745662689,
+      0.3000403344631195,
+      0.14843465387821198,
+      0.6331756711006165,
+      -0.8105208277702332,
+      0.6428540349006653,
+      -0.5015450119972229,
+      0.585994303226471,
+      0.3610047996044159,
+      0.19323234260082245,
+      -0.35460948944091797,
+      -0.4039037227630615,
+      0.38896507024765015,
+      -0.536838710308075,
+      -0.3164752125740051,
+      -0.2043737918138504,
+      -0.07109805941581726,
+      0.059553660452365875,
+      -0.24188177287578583,
+      -0.5634654760360718,
+      0.15655209124088287,
+      0.4238407611846924,
+      0.14595751464366913,
+      -0.10296721011400223,
+      0.38230571150779724,
+      -0.28457918763160706,
+      0.5762684345245361,
+      -0.6562983393669128,
+      0.09346769750118256,
+      0.6954041123390198,
+      0.29474541544914246,
+      -0.1399531066417694,
+      -0.6600004434585571,
+      -0.6112341284751892,
+      -0.10551806539297104,
+      0.375020295381546,
+      -0.6612086892127991,
+      -0.4609551429748535,
+      0.5355013608932495,
+      0.6289262175559998,
+      0.5566124320030212,
+      0.42343708872795105,
+      0.23909102380275726,
+      0.3759506046772003,
+      -0.6171351671218872,
+      0.02336261048913002,
+      0.12490686774253845,
+      -0.5330260992050171,
+      0.20627610385417938,
+      0.43712615966796875,
+      -0.2231852412223816,
+      0.4220152199268341,
+      -0.2680485248565674,
+      0.3509346842765808,
+      -0.264874130487442,
+      0.4431266486644745,
+      0.08768787980079651,
+      0.4680672883987427,
+      0.5259952545166016,
+      0.7430881857872009,
+      -0.088637575507164,
+      -0.15696024894714355,
+      0.1818857043981552,
+      -0.6777862906455994,
+      -0.6387791037559509,
+      0.11267044395208359,
+      0.40609756112098694,
+      -0.7288401126861572,
+      0.28566256165504456,
+      0.8961007595062256,
+      -0.41366830468177795,
+      -0.01137426309287548,
+      -0.6116126179695129,
+      -0.5873274207115173,
+      0.8039853572845459,
+      0.5238677263259888,
+      0.627322793006897,
+      -0.30294591188430786,
+      0.3690156042575836,
+      0.1990407407283783,
+      -0.3586515784263611,
+      0.31159451603889465,
+      0.5810842514038086,
+      -0.42150405049324036,
+      0.5331746935844421,
+      -0.007083773147314787,
+      -0.7303491830825806,
+      -0.130608931183815,
+      0.3361595869064331,
+      0.45849668979644775,
+      0.5759662985801697,
+      -0.3778841495513916,
+      0.33967170119285583,
+      0.4483658969402313,
+      0.4283217489719391,
+      -0.13051319122314453,
+      -0.567672073841095,
+      -0.1505625993013382,
+      0.5552942752838135,
+      0.5884599685668945,
+      -0.07561260461807251,
+      0.3589589297771454,
+      -0.5309117436408997,
+      0.25145286321640015,
+      -0.03258868306875229,
+      -0.4362887442111969,
+      -0.22799895703792572,
+      -0.6275490522384644,
+      0.4849860668182373,
+      -0.025979941710829735,
+      0.22708173096179962,
+      0.6644428372383118,
+      -0.5695757865905762,
+      0.08982725441455841,
+      -0.4195552170276642,
+      0.10517806559801102,
+      -0.4226057827472687,
+      0.4714082181453705,
+      0.6985716819763184,
+      0.0006538079469464719,
+      -0.448317289352417,
+      0.5904045701026917,
+      0.3350187838077545,
+      0.14181968569755554,
+      -0.5558332800865173,
+      -0.6289500594139099,
+      -0.5208578705787659,
+      0.285884290933609,
+      0.6213005781173706,
+      0.597499668598175,
+      -0.05058666318655014,
+      0.0651242807507515,
+      0.1600625216960907,
+      0.3476071357727051,
+      0.6439316868782043,
+      0.25930044054985046,
+      -0.38758036494255066,
+      -0.6922540068626404,
+      -0.2964532971382141,
+      -0.3088078796863556,
+      0.3672376275062561,
+      -0.16195623576641083,
+      -0.4334561824798584,
+      0.5793628692626953,
+      0.3117627799510956,
+      -0.15734943747520447,
+      -0.7649829983711243,
+      -0.5475243330001831,
+      0.5346915125846863,
+      -0.36272743344306946,
+      0.3564032316207886,
+      0.533324122428894,
+      0.42281702160835266,
+      -0.28033384680747986,
+      -0.4088839888572693,
+      -0.2303830087184906,
+      -0.23751872777938843,
+      0.041421279311180115,
+      0.5180373787879944,
+      0.7062609791755676,
+      -0.542513906955719,
+      -0.4302293062210083,
+      0.20035797357559204,
+      -0.08692830801010132,
+      0.25010326504707336,
+      0.7066624164581299,
+      -0.10798093676567078,
+      -0.25053149461746216,
+      -0.17489944398403168,
+      -0.4802313446998596,
+      -0.48023828864097595,
+      -0.814469575881958,
+      0.37388914823532104,
+      0.6281175017356873,
+      0.6759769320487976,
+      -0.5401461720466614,
+      -0.10508890450000763,
+      0.07514649629592896,
+      -0.4732096195220947,
+      0.1317974030971527,
+      0.1791929453611374,
+      0.14001530408859253,
+      0.06956925243139267,
+      0.2839416265487671,
+      0.29040631651878357,
+      0.504808247089386,
+      -0.5646824240684509,
+      -0.2524738013744354,
+      -0.4599587917327881,
+      0.08754394203424454,
+      -0.3513955771923065,
+      0.22336141765117645,
+      0.7614261507987976,
+      -0.18434885144233704,
+      -0.3153497874736786,
+      -0.5770508646965027,
+      -0.43566399812698364,
+      -0.29947298765182495,
+      0.5062375664710999,
+      0.023155812174081802,
+      -0.6824156641960144,
+      0.6973771452903748,
+      0.47541025280952454,
+      0.5671731233596802,
+      -0.09654698520898819,
+      0.4690018892288208,
+      -0.38557863235473633,
+      0.3489590585231781,
+      0.5635160207748413,
+      -0.4245689809322357,
+      0.4814533591270447,
+      0.46730050444602966,
+      -0.3316380977630615,
+      -0.32189619541168213,
+      0.2787921726703644,
+      0.2366294413805008,
+      -0.002128796186298132,
+      0.0287551861256361,
+      0.6690114140510559,
+      -0.5146788358688354,
+      0.3941262662410736,
+      0.5120462775230408,
+      -0.7658915519714355,
+      0.40105944871902466,
+      0.01692848466336727,
+      0.3542935848236084,
+      0.5126014351844788,
+      -0.4018067419528961,
+      0.4152436852455139,
+      0.05601850897073746,
+      0.13929006457328796,
+      0.24814122915267944,
+      -0.5372462868690491,
+      -0.3253263831138611,
+      0.5030489563941956,
+      0.4511641263961792,
+      -0.5183212161064148,
+      0.13135740160942078,
+      0.04129188135266304,
+      0.21124593913555145,
+      -0.3409647047519684,
+      -0.415905237197876,
+      -0.15260761976242065,
+      -0.5333403944969177,
+      -0.48056522011756897,
+      -0.40028244256973267,
+      -0.43734610080718994,
+      -0.2133392095565796,
+      -0.29550036787986755,
+      0.5717685222625732,
+      0.7785221934318542,
+      0.4324593245983124,
+      -0.5249910950660706,
+      0.4615764021873474,
+      0.4814251661300659,
+      -0.414835125207901,
+      -0.6916537880897522,
+      -0.5298791527748108,
+      -0.9781942367553711,
+      0.43843767046928406,
+      -0.16492238640785217,
+      0.7092018723487854,
+      -0.2542411684989929,
+      0.42584559321403503,
+      0.4929214119911194,
+      0.7086622714996338,
+      -0.28084853291511536,
+      -0.34635114669799805,
+      0.5568549036979675,
+      -0.1549905240535736,
+      -0.16537271440029144,
+      -0.050287213176488876,
+      0.213552787899971,
+      0.6236043572425842,
+      -0.30276042222976685,
+      -0.5958431959152222,
+      0.6351655125617981,
+      0.23172463476657867,
+      0.5608846545219421,
+      0.26491817831993103,
+      -0.316093772649765,
+      -0.1831120401620865,
+      0.8002948760986328,
+      0.04656974598765373,
+      0.2370678186416626,
+      0.22652243077754974,
+      -0.7128554582595825,
+      -0.8337548971176147,
+      -0.16446147859096527,
+      -0.3271506726741791,
+      0.41788023710250854,
+      -0.33075541257858276,
+      -0.6836495995521545,
+      -0.17264102399349213,
+      0.3705328702926636,
+      0.4749191403388977,
+      0.1391599327325821,
+      -0.5449556112289429,
+      -0.5832648873329163,
+      0.3470316231250763,
+      -0.43681544065475464,
+      -0.46869179606437683,
+      0.7697038650512695,
+      0.15680909156799316,
+      -0.5450631380081177,
+      -0.6293807029724121,
+      -0.41992709040641785,
+      -0.5036922693252563,
+      0.5164766311645508,
+      -0.31142181158065796,
+      -0.702892541885376,
+      -0.18341974914073944,
+      -0.4195866286754608,
+      -0.2083660513162613,
+      -0.6964157819747925,
+      0.5260657668113708,
+      0.8384340405464172,
+      -0.2592344582080841,
+      0.3397483229637146,
+      -0.3004448413848877,
+      0.4325181245803833,
+      -0.8016352653503418,
+      -0.43784213066101074,
+      0.5688702464103699,
+      -0.75948166847229,
+      0.6093763113021851,
+      -0.5252845287322998,
+      -0.39608830213546753,
+      0.6188247799873352,
+      0.6929423809051514,
+      -0.7569720149040222,
+      -0.4368495047092438,
+      -0.07049106806516647,
+      0.23626691102981567,
+      0.7666605710983276,
+      -0.5498153567314148,
+      -0.09556187689304352,
+      0.04998994991183281,
+      0.6980904936790466,
+      -0.4719732999801636,
+      0.3808833658695221,
+      0.17173363268375397,
+      0.5301147103309631,
+      0.018489066511392593,
+      0.4967963695526123,
+      -0.35475456714630127,
+      -0.5022993087768555,
+      -0.44733163714408875,
+      0.08119704574346542,
+      0.5238443613052368,
+      -0.12852875888347626,
+      0.6751067042350769,
+      -0.18058136105537415,
+      -0.6614764332771301,
+      0.05523592233657837,
+      0.5554388761520386,
+      0.22215212881565094,
+      0.6175872087478638,
+      0.2960164546966553,
+      -0.19046010076999664,
+      -0.17398317158222198,
+      0.2275778204202652,
+      0.1352202594280243,
+      0.6905826330184937,
+      -0.5913413763046265,
+      0.3991498053073883,
+      -0.7693127393722534,
+      -0.9064828157424927,
+      0.024206487461924553,
+      -0.5105448365211487,
+      0.3440760374069214,
+      0.08142603188753128,
+      -0.7207233905792236,
+      -0.581031858921051,
+      0.6479102969169617,
+      0.04334093630313873,
+      -0.30378004908561707,
+      -0.4127667546272278,
+      0.6746240854263306,
+      0.050040654838085175,
+      -0.3975379467010498,
+      0.26459383964538574,
+      0.6994006037712097,
+      -0.44536566734313965,
+      -0.6420013904571533,
+      0.5272977948188782,
+      -0.4972582757472992,
+      0.30368050932884216,
+      0.05429714173078537,
+      0.283643513917923,
+      -0.34861692786216736,
+      -0.6315703392028809,
+      0.09768600761890411,
+      0.5355572700500488,
+      0.3888274133205414,
+      -0.32823553681373596,
+      0.5622992515563965,
+      0.00037535018054768443,
+      -0.10881635546684265,
+      -0.35476061701774597,
+      0.5007027387619019,
+      0.34218084812164307,
+      0.7894691228866577,
+      0.3980063199996948,
+      -0.48286494612693787,
+      0.6152166128158569,
+      -0.13069315254688263,
+      0.7056953310966492,
+      -0.1718815118074417,
+      0.4852822721004486,
+      -0.23409131169319153,
+      -0.5914760231971741,
+      -0.13249142467975616,
+      -0.2958221137523651,
+      -0.1889641284942627,
+      -0.1702418476343155,
+      -0.6497222185134888,
+      0.43457621335983276,
+      -0.3974471986293793,
+      -0.3153226673603058,
+      -0.27306753396987915,
+      -0.6676968932151794,
+      0.4435681402683258,
+      0.7421004772186279,
+      0.898250937461853,
+      0.5075480341911316,
+      0.34645119309425354,
+      -0.3892960846424103,
+      0.24199649691581726,
+      -0.09604883193969727,
+      -0.6230077147483826,
+      0.004666227847337723,
+      0.35588639974594116,
+      -0.19468386471271515,
+      -0.3568110167980194,
+      0.45404884219169617,
+      -0.3219132721424103,
+      -0.3362879753112793,
+      -0.26973214745521545,
+      -0.31137168407440186,
+      -0.15835611522197723,
+      -0.48432013392448425,
+      0.6654230952262878,
+      0.42798832058906555,
+      -0.42348819971084595,
+      0.5631161332130432,
+      0.4840729236602783,
+      -0.44726112484931946,
+      -0.0321044884622097,
+      0.5132392048835754,
+      -0.0316803939640522,
+      -0.08635670691728592,
+      -0.5747225284576416,
+      0.4643561840057373,
+      0.12942247092723846,
+      -0.5961591005325317,
+      -0.7048725485801697,
+      0.6244539022445679,
+      -0.2646646201610565,
+      0.511993944644928,
+      -0.1782059520483017,
+      -0.476296991109848,
+      0.4509793817996979,
+      0.5829113125801086,
+      0.3998103439807892,
+      0.3810572624206543,
+      0.41784316301345825,
+      0.7890206575393677,
+      -0.43540871143341064,
+      0.3865264356136322,
+      -0.34199434518814087,
+      0.39215153455734253,
+      0.49108052253723145,
+      -0.6903269290924072,
+      -0.43151429295539856,
+      0.41944727301597595,
+      0.4959307909011841,
+      -0.38634493947029114,
+      -0.06019069626927376,
+      -0.6517764329910278,
+      -0.5308097004890442,
+      -0.6533023118972778,
+      0.6312675476074219,
+      -0.7227610945701599,
+      -0.27052104473114014,
+      -0.3082827925682068,
+      -0.10922528058290482,
+      -0.21197618544101715,
+      -0.16172805428504944,
+      -0.5405601859092712,
+      -0.2898384630680084,
+      0.4028785228729248,
+      -0.3429325520992279,
+      0.08492431044578552,
+      0.5002052187919617,
+      -0.3180886209011078,
+      -0.3115167021751404,
+      0.5471441745758057,
+      -0.51177579164505,
+      -0.6650250554084778,
+      0.502768874168396,
+      0.610641598701477,
+      -0.7797952890396118
+    ]
+  },
+  "b2": {
+    "shape": [
+      1,
+      32
+    ],
+    "data": [
+      0.11029242724180222,
+      -0.08818363398313522,
+      0.21428751945495605,
+      -0.26356834173202515,
+      -0.0757112130522728,
+      0.21244093775749207,
+      0.08072414994239807,
+      -0.15003493428230286,
+      0.34987780451774597,
+      -0.0707574412226677,
+      0.18416622281074524,
+      -0.02180960215628147,
+      0.13338498771190643,
+      0.07643681019544601,
+      0.0541238933801651,
+      -0.2533218264579773,
+      0.12554669380187988,
+      -0.04735559970140457,
+      -0.08126572519540787,
+      -0.008954617194831371,
+      0.24354955554008484,
+      -0.12422681599855423,
+      0.18584653735160828,
+      -0.29332807660102844,
+      -0.1264396607875824,
+      0.03589838370680809,
+      0.20483575761318207,
+      -0.028695637360215187,
+      0.050322018563747406,
+      -0.038248296827077866,
+      -0.028875255957245827,
+      -0.15547749400138855
+    ]
+  },
+  "wo": {
+    "shape": [
+      32,
+      22
+    ],
+    "data": [
+      0.2762174606323242,
+      0.38260236382484436,
+      0.6634435653686523,
+      0.6160672307014465,
+      0.618087112903595,
+      0.4818056523799896,
+      0.2630511522293091,
+      0.17242300510406494,
+      -0.5038496255874634,
+      0.46820735931396484,
+      -0.5860238075256348,
+      -0.4638080894947052,
+      0.04449983313679695,
+      -0.6682363748550415,
+      0.48581254482269287,
+      -0.6896366477012634,
+      -0.3773996829986572,
+      -0.8340221047401428,
+      -0.46437785029411316,
+      -0.34659188985824585,
+      -0.41334599256515503,
+      -0.5741592049598694,
+      0.540574312210083,
+      0.3167288303375244,
+      -0.5873416066169739,
+      0.5378468632698059,
+      -0.6735031604766846,
+      -0.5706233382225037,
+      -0.7310205101966858,
+      0.15331706404685974,
+      -0.6116790175437927,
+      -0.6461313962936401,
+      0.48966002464294434,
+      -0.41905346512794495,
+      0.5812327861785889,
+      0.47562021017074585,
+      -0.5833849906921387,
+      0.30892935395240784,
+      0.879585862159729,
+      0.7100825309753418,
+      -0.7786852121353149,
+      -0.396296888589859,
+      0.4688151478767395,
+      -0.5761070847511292,
+      0.3663385510444641,
+      0.5172922611236572,
+      0.5905728340148926,
+      -0.4988265335559845,
+      -0.5703363418579102,
+      -0.6751488447189331,
+      0.6445662975311279,
+      -0.4882478713989258,
+      -0.7962093353271484,
+      0.5388670563697815,
+      0.5973828434944153,
+      -0.4852631092071533,
+      0.5018942952156067,
+      0.5644686222076416,
+      0.5871429443359375,
+      -0.6652399301528931,
+      -0.7051059603691101,
+      -0.6356050372123718,
+      0.7077520489692688,
+      -0.6082721948623657,
+      0.5385633111000061,
+      -0.4855056405067444,
+      -0.44983747601509094,
+      -0.4362034201622009,
+      -0.5738614797592163,
+      0.6923324465751648,
+      0.4645172357559204,
+      -0.54719477891922,
+      0.7204819917678833,
+      -0.4316576421260834,
+      0.9733572602272034,
+      0.6341553330421448,
+      -0.3463224470615387,
+      -0.4671844244003296,
+      -0.14754365384578705,
+      0.5878990292549133,
+      0.5936049818992615,
+      -0.3043825626373291,
+      -0.5673109292984009,
+      -0.5464169383049011,
+      -1.4350059032440186,
+      1.1843616962432861,
+      -0.25862279534339905,
+      -0.5993593335151672,
+      -0.4683132767677307,
+      -0.46493440866470337,
+      0.4174375534057617,
+      -0.4334781765937805,
+      -0.36766958236694336,
+      -0.5756783485412598,
+      -0.520487904548645,
+      0.5291165709495544,
+      0.22205358743667603,
+      -0.20053093135356903,
+      -0.7626599073410034,
+      0.5866607427597046,
+      0.5070990920066833,
+      0.4739514887332916,
+      -0.31505128741264343,
+      -0.33632615208625793,
+      0.3349793553352356,
+      0.2755506932735443,
+      0.547707200050354,
+      0.22649769484996796,
+      0.6663766503334045,
+      0.6018823981285095,
+      -0.1206974908709526,
+      0.5885554552078247,
+      0.5397472977638245,
+      0.46453940868377686,
+      0.49745607376098633,
+      0.47549256682395935,
+      -0.39476722478866577,
+      -0.5115877389907837,
+      0.4765133857727051,
+      -0.02468481846153736,
+      0.5047079920768738,
+      -0.36710482835769653,
+      0.5644846558570862,
+      0.3845056891441345,
+      -0.36820632219314575,
+      -0.5722693204879761,
+      -0.7034974098205566,
+      -0.3987295627593994,
+      -0.5897213816642761,
+      -0.6326191425323486,
+      -0.7034371495246887,
+      -0.012065979652106762,
+      -0.8285946846008301,
+      0.8296675682067871,
+      -0.6391251683235168,
+      0.4824085235595703,
+      0.2662737965583801,
+      -0.45178771018981934,
+      0.4167381823062897,
+      0.1888199746608734,
+      0.10366911441087723,
+      -0.13760298490524292,
+      0.3917267620563507,
+      -0.6645610928535461,
+      -0.6286388635635376,
+      0.7123810648918152,
+      -0.36468470096588135,
+      0.5265372395515442,
+      0.6040055155754089,
+      0.5391143560409546,
+      -0.6874354481697083,
+      -0.12013101577758789,
+      0.4214313328266144,
+      0.329968124628067,
+      -0.42050573229789734,
+      -0.2965017855167389,
+      0.43154042959213257,
+      0.22178961336612701,
+      0.6041280031204224,
+      -0.4616892635822296,
+      -0.5610184073448181,
+      0.511191189289093,
+      -0.9847272634506226,
+      -0.2686040997505188,
+      0.4998469352722168,
+      -0.7635945677757263,
+      -0.3490637540817261,
+      0.31444230675697327,
+      -0.27581509947776794,
+      0.12745776772499084,
+      0.463368684053421,
+      0.3285757303237915,
+      1.2063647508621216,
+      0.3136107623577118,
+      0.6877472400665283,
+      0.7344233393669128,
+      0.39539551734924316,
+      0.5607619881629944,
+      -0.46110090613365173,
+      0.385048508644104,
+      -0.6186272501945496,
+      0.7879599332809448,
+      0.43810954689979553,
+      -1.4704221487045288,
+      -0.5251647233963013,
+      0.053348179906606674,
+      0.5798595547676086,
+      -0.3335433900356293,
+      0.7289069890975952,
+      -0.3729146420955658,
+      -0.6326716542243958,
+      0.8238807916641235,
+      0.4038623571395874,
+      0.7858222723007202,
+      0.5091748237609863,
+      -0.1323343813419342,
+      0.4509986340999603,
+      -0.42712271213531494,
+      0.6994235515594482,
+      -0.7509125471115112,
+      -0.5346124768257141,
+      -0.5669982433319092,
+      -0.5477046370506287,
+      0.6296712160110474,
+      0.5847958326339722,
+      -0.8572463393211365,
+      0.26333028078079224,
+      0.5428904294967651,
+      -0.5374228954315186,
+      0.4498865306377411,
+      0.48142313957214355,
+      -0.552471399307251,
+      -0.6603292226791382,
+      1.1879570484161377,
+      -0.3418349623680115,
+      1.0870345830917358,
+      0.3856070637702942,
+      0.3835785388946533,
+      -0.5942299365997314,
+      0.5717557668685913,
+      0.8368513584136963,
+      -0.706018328666687,
+      0.4310198426246643,
+      -0.3431468605995178,
+      0.3705883324146271,
+      0.24579164385795593,
+      0.40529656410217285,
+      -0.7347528338432312,
+      0.47128406167030334,
+      0.40954914689064026,
+      -0.4108256995677948,
+      0.1841387301683426,
+      -0.6659297347068787,
+      0.24402162432670593,
+      0.4651864469051361,
+      -0.6440028548240662,
+      0.16260544955730438,
+      -0.8298006653785706,
+      0.2799663841724396,
+      0.3284505307674408,
+      -0.36959049105644226,
+      0.6910378932952881,
+      0.5328362584114075,
+      0.11063619703054428,
+      -0.4516947269439697,
+      0.670394778251648,
+      -0.4215903580188751,
+      0.31891292333602905,
+      -0.48818227648735046,
+      -0.525229275226593,
+      0.9826000332832336,
+      -0.18492431938648224,
+      -0.45432189106941223,
+      -0.20655077695846558,
+      0.560407280921936,
+      0.4782520830631256,
+      0.6039958596229553,
+      -0.7649849057197571,
+      -0.05115603283047676,
+      -0.036306802183389664,
+      -0.3178698420524597,
+      -0.8242605924606323,
+      -0.43732377886772156,
+      -0.6577175855636597,
+      -0.6005761027336121,
+      -0.42529159784317017,
+      -0.252436101436615,
+      -0.3653200566768646,
+      0.3749310374259949,
+      0.2415284514427185,
+      0.6607235074043274,
+      -0.8916924595832825,
+      0.30440300703048706,
+      -0.5797411799430847,
+      0.4763459861278534,
+      -0.3834957480430603,
+      0.17959997057914734,
+      -0.4806287884712219,
+      -0.3293042480945587,
+      1.4099925756454468,
+      -0.5782971382141113,
+      -0.25100967288017273,
+      0.34332075715065,
+      0.7590599060058594,
+      0.5793614387512207,
+      -0.14703218638896942,
+      0.2382507175207138,
+      -0.6149412393569946,
+      -0.46754541993141174,
+      0.4866132140159607,
+      -0.5945234298706055,
+      0.49302321672439575,
+      -0.49208739399909973,
+      -0.7851443886756897,
+      -0.721621572971344,
+      0.4701803922653198,
+      0.9017214179039001,
+      0.5615847706794739,
+      -0.5120549201965332,
+      -0.5149061679840088,
+      0.5607555508613586,
+      -0.28218767046928406,
+      0.6372897624969482,
+      -0.04090454429388046,
+      0.5986918210983276,
+      1.177694320678711,
+      -0.9514838457107544,
+      0.26694732904434204,
+      -0.4607114791870117,
+      -0.5161164999008179,
+      -0.5676852464675903,
+      0.689904510974884,
+      -0.43909451365470886,
+      0.5715568661689758,
+      0.15583942830562592,
+      0.1759614497423172,
+      0.5622710585594177,
+      -0.5133169293403625,
+      -0.966285228729248,
+      -0.7068552374839783,
+      0.51691734790802,
+      -0.4716677665710449,
+      0.482737272977829,
+      1.1952630281448364,
+      -0.23928700387477875,
+      0.09857846051454544,
+      0.686741054058075,
+      0.9820990562438965,
+      1.288217544555664,
+      -0.8169243931770325,
+      0.17603223025798798,
+      0.5037521719932556,
+      -0.6182132959365845,
+      -0.504029393196106,
+      0.4417513608932495,
+      -0.1985960453748703,
+      0.6795202493667603,
+      0.6448993682861328,
+      -0.5122780799865723,
+      0.6680283546447754,
+      -0.44850480556488037,
+      1.0339990854263306,
+      -0.5934554934501648,
+      -0.37804606556892395,
+      -0.46256497502326965,
+      0.7947261929512024,
+      0.3209127187728882,
+      0.27259036898612976,
+      -0.5537301898002625,
+      -0.65911865234375,
+      -0.8579578995704651,
+      -0.757592499256134,
+      0.1761830598115921,
+      0.5941749215126038,
+      0.3916952311992645,
+      -0.6979409456253052,
+      0.43938183784484863,
+      -0.27733761072158813,
+      0.34475070238113403,
+      -0.3636750280857086,
+      -0.3655831217765808,
+      0.5025510787963867,
+      0.9833573698997498,
+      -0.5371208190917969,
+      0.4600584805011749,
+      0.44406309723854065,
+      0.5689285397529602,
+      -0.4591400921344757,
+      -0.7043213248252869,
+      -0.44484901428222656,
+      -0.29595959186553955,
+      -0.05744972452521324,
+      -0.7198536396026611,
+      -0.37415748834609985,
+      -0.22749324142932892,
+      -0.15711641311645508,
+      0.512513279914856,
+      -0.48238661885261536,
+      0.43338680267333984,
+      0.4921077787876129,
+      0.6738750338554382,
+      1.3007397651672363,
+      0.5449212789535522,
+      -0.5261181592941284,
+      0.9909772276878357,
+      0.4888579845428467,
+      -0.4672129154205322,
+      -0.49559709429740906,
+      0.6408059000968933,
+      0.5489431619644165,
+      -0.8408327102661133,
+      -1.0097509622573853,
+      -0.08235977590084076,
+      -0.5264580249786377,
+      -0.7316493391990662,
+      -0.4777064025402069,
+      -0.37026745080947876,
+      -0.28342539072036743,
+      0.5148628354072571,
+      -0.5813735127449036,
+      -0.5189685225486755,
+      -0.46130526065826416,
+      0.3944005072116852,
+      0.4785750210285187,
+      0.6659310460090637,
+      -0.3814562261104584,
+      0.5811219811439514,
+      -1.3794913291931152,
+      -0.7975471615791321,
+      -0.5317023396492004,
+      -0.40248191356658936,
+      0.6557966470718384,
+      0.3905821144580841,
+      0.3303625285625458,
+      0.4527250826358795,
+      0.5193310379981995,
+      -0.044568002223968506,
+      1.131442904472351,
+      0.21221168339252472,
+      0.5138939023017883,
+      0.6107815504074097,
+      0.5872597694396973,
+      -0.5841915607452393,
+      -0.476718544960022,
+      0.6374842524528503,
+      -1.0065571069717407,
+      -0.36163052916526794,
+      0.573855459690094,
+      0.5805584788322449,
+      -0.4341932535171509,
+      -0.4878757894039154,
+      0.5740911364555359,
+      -0.48466601967811584,
+      -0.7972078919410706,
+      1.0755324363708496,
+      -0.4944220781326294,
+      -0.46047723293304443,
+      -0.2845273017883301,
+      0.10875864326953888,
+      -0.3748782277107239,
+      -1.0652053356170654,
+      0.7138442397117615,
+      -0.07556568831205368,
+      0.4279324412345886,
+      -0.5489216446876526,
+      -0.5482203364372253,
+      0.4148668348789215,
+      0.2537778615951538,
+      -0.5335351824760437,
+      0.6548264026641846,
+      -0.7312013506889343,
+      0.5162219405174255,
+      -0.587507426738739,
+      0.6256941556930542,
+      -0.5618646740913391,
+      0.4995773434638977,
+      0.565326452255249,
+      0.6767951846122742,
+      -0.38121354579925537,
+      -0.28882095217704773,
+      0.09667010605335236,
+      0.6904206275939941,
+      0.7203397154808044,
+      -1.052193284034729,
+      0.5294094681739807,
+      -0.39017772674560547,
+      -0.5623560547828674,
+      -0.6423949003219604,
+      -0.3397647440433502,
+      -0.0691433697938919,
+      0.4959563910961151,
+      -0.5409778952598572,
+      0.2738248407840729,
+      -0.5870262980461121,
+      0.4849012494087219,
+      0.43244343996047974,
+      0.5593093633651733,
+      -0.7735945582389832,
+      0.023031825199723244,
+      -0.6313595175743103,
+      0.6824097037315369,
+      0.5879532694816589,
+      1.1227784156799316,
+      -0.5371152758598328,
+      0.4747001826763153,
+      0.33417966961860657,
+      -0.41958531737327576,
+      0.591909646987915,
+      -0.6244659423828125,
+      0.6524537205696106,
+      -0.5735373497009277,
+      0.6572942733764648,
+      -0.6202780604362488,
+      -0.0754583403468132,
+      0.5355802178382874,
+      -0.5512004494667053,
+      0.6083162426948547,
+      -0.4698520302772522,
+      -0.4684063792228699,
+      0.42200011014938354,
+      0.5226775407791138,
+      0.8250173330307007,
+      0.8414651155471802,
+      -0.851728618144989,
+      0.38968703150749207,
+      -0.6002296805381775,
+      -0.5224602222442627,
+      -0.49654296040534973,
+      -0.5692058205604553,
+      0.4617942273616791,
+      0.5733236074447632,
+      0.5646223425865173,
+      -0.6716178059577942,
+      1.0224409103393555,
+      -0.09524110704660416,
+      0.6074790358543396,
+      0.4464361369609833,
+      -0.6058829426765442,
+      0.6488597393035889,
+      -0.051166534423828125,
+      -0.28485044836997986,
+      -1.1255578994750977,
+      -1.6854982376098633,
+      1.430800199508667,
+      -0.7434956431388855,
+      -0.2788616716861725,
+      0.5903058648109436,
+      0.18630436062812805,
+      0.7093695402145386,
+      -0.8175922632217407,
+      -0.6127452254295349,
+      -0.32356882095336914,
+      -0.5329993367195129,
+      -0.6670728325843811,
+      0.46830451488494873,
+      -0.34746330976486206,
+      0.4621020257472992,
+      0.5941657423973083,
+      -0.5245645046234131,
+      0.48068639636039734,
+      0.4261752963066101,
+      0.5562680959701538,
+      0.5139241814613342,
+      -0.6281471252441406,
+      -0.37956735491752625,
+      0.09982912987470627,
+      0.37919309735298157,
+      0.4715290367603302,
+      -0.5141017436981201,
+      0.807801365852356,
+      0.7183742523193359,
+      0.37379318475723267,
+      0.49484768509864807,
+      -0.5575850605964661,
+      -0.6334258317947388,
+      -0.3973656892776489,
+      0.5574955344200134,
+      0.6527130007743835,
+      0.571622371673584,
+      -0.5989436507225037,
+      -0.8798049092292786,
+      0.16753914952278137,
+      -0.6151334643363953,
+      -0.4558465778827667,
+      -0.3383508026599884,
+      0.5112338066101074,
+      0.6807130575180054,
+      0.4764179587364197,
+      0.6525121927261353,
+      0.0027866645250469446,
+      0.5865671634674072,
+      -0.5713533163070679,
+      -0.5435633659362793,
+      -0.5980391502380371,
+      0.31999897956848145,
+      0.5026710033416748,
+      0.4728953540325165,
+      -0.5805755853652954,
+      0.6091205477714539,
+      0.23990114033222198,
+      -1.4398947954177856,
+      -0.5714873671531677,
+      0.4868257939815521,
+      0.5222137570381165,
+      -0.15680432319641113,
+      0.6000910401344299,
+      -0.42508503794670105,
+      -0.00959792360663414,
+      -0.029155075550079346,
+      -0.1008482575416565,
+      -0.8494348526000977,
+      1.2123634815216064,
+      0.4655742645263672,
+      0.4054800271987915,
+      -0.5789232850074768,
+      -0.448654443025589,
+      0.27178430557250977,
+      0.4194319546222687,
+      -0.19238217175006866,
+      0.05927124619483948,
+      -0.6821643114089966,
+      0.41220661997795105,
+      0.6587613224983215,
+      0.6502217650413513,
+      -0.5879285335540771,
+      -1.168091058731079,
+      -0.3738193213939667,
+      -0.5478828549385071,
+      -0.5600888729095459,
+      0.47108131647109985,
+      0.6038346290588379,
+      0.41559746861457825,
+      0.43140798807144165,
+      0.28290143609046936,
+      0.10957807302474976,
+      1.1261096000671387,
+      0.7557782530784607,
+      -0.09454663842916489,
+      -0.5396714806556702,
+      0.35051873326301575,
+      0.5337030291557312,
+      -0.6197061538696289,
+      0.5249195098876953,
+      0.5282478928565979,
+      -0.4826344847679138,
+      0.4673355519771576,
+      0.3739103376865387,
+      -0.9414332509040833,
+      -0.5626897215843201,
+      -0.5404248237609863,
+      -0.5264711380004883,
+      0.2077837735414505,
+      0.46527746319770813,
+      0.33550122380256653,
+      -0.40758731961250305,
+      -0.6036528944969177,
+      0.26444369554519653,
+      0.46062955260276794,
+      -0.5042088627815247,
+      -0.45936450362205505,
+      0.5368273854255676,
+      -0.4445859491825104,
+      0.13990464806556702,
+      0.392370343208313,
+      -0.5358730554580688,
+      0.6539669632911682,
+      -1.058388352394104,
+      0.44580644369125366,
+      -0.33838632702827454,
+      0.7091957330703735,
+      0.6832798719406128,
+      0.32566845417022705,
+      0.37672311067581177,
+      -0.5974972248077393,
+      -0.7361176013946533,
+      0.3428240418434143,
+      0.8432598114013672,
+      1.0732468366622925,
+      -0.38249415159225464,
+      0.3295719027519226,
+      -0.4954387843608856,
+      -0.4817511737346649,
+      0.06269682198762894,
+      0.5361617803573608,
+      0.5865234732627869,
+      -0.5824471712112427,
+      0.6671242117881775,
+      0.5579132437705994,
+      0.44468265771865845,
+      -0.6306341290473938,
+      0.31353601813316345,
+      0.0050523350946605206,
+      0.68552565574646,
+      0.5105887055397034,
+      -0.6457495093345642,
+      -0.19686691462993622,
+      0.5883159041404724,
+      -0.11447283625602722,
+      -0.5710955262184143,
+      0.8761969804763794,
+      0.6187066435813904,
+      0.1643069088459015,
+      0.505480945110321,
+      -0.12307372689247131,
+      -0.5035899877548218,
+      -0.4392324686050415,
+      -0.4859899878501892,
+      -0.33788636326789856,
+      -0.18072181940078735,
+      -1.148506760597229,
+      0.5270877480506897,
+      -0.5454695224761963,
+      0.4946799576282501,
+      -0.5850204229354858,
+      0.5722922086715698,
+      -0.4286102056503296,
+      -0.5083222985267639,
+      1.3998783826828003,
+      -0.39149075746536255,
+      -0.2195635288953781,
+      0.7510740756988525,
+      0.515981912612915,
+      0.5395689010620117,
+      -0.180013045668602
+    ]
+  },
+  "bo": {
+    "shape": [
+      1,
+      22
+    ],
+    "data": [
+      0.17882657051086426,
+      0.12335005402565002,
+      0.2260214239358902,
+      0.13428771495819092,
+      0.16737928986549377,
+      0.17964711785316467,
+      0.18897251784801483,
+      -0.3008984923362732,
+      0.108077771961689,
+      -0.00163695914670825,
+      -0.030290693044662476,
+      -0.0816558375954628,
+      0.0860346108675003,
+      0.16864551603794098,
+      -0.06500505656003952,
+      -0.20006951689720154,
+      -0.13271963596343994,
+      -0.12611454725265503,
+      -0.14777983725070953,
+      -0.14544935524463654,
+      -0.10858025401830673,
+      -0.13828061521053314
+    ]
+  }
+}

source/icl/OCIR_SCHEMA.json

@@ -0,0 +1 @@
+{"$schema":"https://json-schema.org/draft/2020-12/schema","title":"OCIR finite core","schema_version":"0.2.1","type":"object","additionalProperties":false,"required":["schema_version","schema_sha256","feature_set","program_id","source_sha256","module_graph","typed_blocks","ops","operand_types","shape_constraints","observer_context","provenance_refs","required_effects","limits","numeric_policy","entrypoint","integrity_sha256"],"properties":{"schema_version":{"const":"0.2.1"},"schema_sha256":{"type":"string"},"feature_set":{"type":"array"},"program_id":{"type":"string"},"source_sha256":{"type":"string"},"module_graph":{"type":"array"},"typed_blocks":{"type":"array"},"ops":{"type":"array"},"operand_types":{"type":"array"},"shape_constraints":{"type":"array"},"observer_context":{"type":"object"},"provenance_refs":{"type":"array"},"required_effects":{"type":"array"},"limits":{"type":"object"},"numeric_policy":{"type":"object"},"entrypoint":{"type":"string"},"integrity_sha256":{"type":"string"}},"runtime_validation":"icl.api.validate_ocir additionally validates AST node keys, typed operations, numeric policy, limits and structural depth"}

source/icl/TOKEN_VOCAB.json

@@ -0,0 +1,113 @@
+{
+  "version": "0.2.1",
+  "keywords": [
+    "else",
+    "false",
+    "fn",
+    "if",
+    "import",
+    "let",
+    "limit",
+    "module",
+    "return",
+    "true",
+    "type",
+    "var",
+    "while"
+  ],
+  "operators": [
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "==",
+    "!=",
+    "<",
+    "<=",
+    ">",
+    ">=",
+    "&&",
+    "||",
+    "!"
+  ],
+  "builtins": [
+    "abs",
+    "add",
+    "approx",
+    "approx_value",
+    "context",
+    "convert_frame",
+    "err_int",
+    "exact_value",
+    "is_some",
+    "len",
+    "make_witness",
+    "matmul",
+    "max",
+    "min",
+    "mul",
+    "none_int",
+    "normalize",
+    "observe_mod",
+    "observer",
+    "ok",
+    "provenance",
+    "random_int",
+    "recover",
+    "recover_without_witness",
+    "relu",
+    "repr_add",
+    "repr_value",
+    "represent",
+    "request_effect",
+    "reshape",
+    "softmax",
+    "some",
+    "sub",
+    "sum",
+    "tanh",
+    "tensor",
+    "to_float",
+    "unwrap"
+  ],
+  "ast_kinds": [
+    "literal",
+    "var",
+    "binary",
+    "unary",
+    "call",
+    "list",
+    "record",
+    "tuple",
+    "index",
+    "field",
+    "let",
+    "assign",
+    "if",
+    "while",
+    "return",
+    "expr"
+  ],
+  "types": [
+    "Bool",
+    "Int64",
+    "Float64",
+    "String",
+    "List",
+    "Tuple",
+    "Record",
+    "Option",
+    "Result",
+    "Tensor",
+    "Observer",
+    "Context",
+    "Representation",
+    "ProvenanceRef",
+    "RecoveryWitness",
+    "Capability",
+    "Exact",
+    "Approx"
+  ],
+  "token_policy": "ASCII identifiers; UTF-8 string content; no invisible controls or unpaired surrogates"
+}

source/icl/__init__.py

@@ -0,0 +1,2 @@
+"""Invariant Cognition Language v0.2.1 — NEW_IMPLEMENTATION."""
+__version__='0.2.1'

source/icl/__main__.py

@@ -0,0 +1,2 @@
+from .cli import main
+raise SystemExit(main())

source/icl/api.py

@@ -0,0 +1,132 @@
+"""Public compile/check/run/serialize contract. Never resolves filesystem imports."""
+import copy,hashlib,json,re
+from pathlib import Path
+from .frontend import parse,canonical_ast,pretty
+from .checker import check,validate_value
+from .runtime import ICLError,RuntimeContext,canonical,digest,DEFAULT_LIMITS
+from .interpreter import execute_tree
+from .vm import compile_bytecode,execute_bytecode
+SCHEMA_VERSION='0.2.1'
+SCHEMA_PATH=Path(__file__).with_name('OCIR_SCHEMA.json')
+if not SCHEMA_PATH.exists():SCHEMA_PATH=Path(__file__).parent.parent/'OCIR_SCHEMA.json'
+SCHEMA_SHA256=hashlib.sha256(SCHEMA_PATH.read_bytes()).hexdigest()
+FEATURES=['functions','modules','lexical_scope','checked_int64','finite_float64','bounded_loop','list','record','tuple','option','result','tensor','observer','recovery','policy_effect','checkpoint','record_annotations','type_aliases','contextual_empty_lists']
+NUMERIC={'int64':'checked_signed','integer_division':'truncate_toward_zero','float64':'finite_only','atol':1e-6,'rtol':1e-5,'normalize_epsilon':1e-5}
+
+def load_program(source,module_map=None):
+    modules=module_map or {}
+    if not isinstance(modules,dict) or len(modules)>64:raise ICLError('IMPORT','module map must have <=64 entries')
+    visiting=set();done={};graph=[];functions=[]
+    root=parse(source)
+    def visit(p,src,isroot=False):
+        nm=p['module']
+        if nm in visiting:raise ICLError('IMPORT_CYCLE','cyclic module import')
+        if nm in done:return
+        visiting.add(nm)
+        if len(visiting)>32:raise ICLError('IMPORT_LIMIT','import nesting limit')
+        for name in p['imports']:
+            if name not in modules:raise ICLError('IMPORT','missing explicit module '+name)
+            sub=parse(modules[name])
+            if sub['module']!=name:raise ICLError('IMPORT','module declaration mismatch')
+            visit(sub,modules[name])
+        own={f['name'] for f in p['functions']}
+        def rename(v):
+            if isinstance(v,dict):
+                if v.get('kind')=='call':
+                    target=v['name']
+                    if target in own and not isroot:v['name']=nm+'.'+target
+                    elif '.' in target and target.split('.')[0] not in p['imports']:raise ICLError('IMPORT','qualified call without import')
+                for child in v.values():rename(child)
+            elif isinstance(v,list):
+                for child in v:rename(child)
+        rename(p)
+        for f in p['functions']:
+            if not isroot:f['name']=nm+'.'+f['name']
+            functions.append(f)
+        graph.append({'module':nm,'imports':p['imports'],'source_sha256':hashlib.sha256(src.encode()).hexdigest()})
+        visiting.remove(nm);done[nm]=True
+    visit(root,source,True)
+    return {'module':root['module'],'imports':root['imports'],'functions':functions},graph
+
+def compile_source(source,module_map=None,limits=None,entry='main'):
+    p,graph=load_program(source,module_map);c=check(p);ctx=RuntimeContext(limits)
+    if entry not in {f['name'] for f in p['functions']}:raise ICLError('NAME','entrypoint missing')
+    source_hash=hashlib.sha256(source.encode()).hexdigest()
+    ocir={'schema_version':SCHEMA_VERSION,'schema_sha256':SCHEMA_SHA256,'feature_set':list(FEATURES),'program_id':digest({'ast':canonical_ast(p),'modules':graph}),'source_sha256':source_hash,'module_graph':graph,'typed_blocks':p['functions'],'ops':c['ops'],'operand_types':[o['operand_types'] for o in c['ops']],'shape_constraints':c['shape_constraints'],'observer_context':{'mode':'explicit_metadata','implicit_conversion':False},'provenance_refs':[{'source_sha256':g['source_sha256'],'module':g['module'],'status':'COMPILED_LOCAL_SOURCE'} for g in graph],'required_effects':c['effects'],'limits':ctx.limits,'numeric_policy':dict(NUMERIC),'entrypoint':entry}
+    ocir['integrity_sha256']=digest(ocir);return ocir
+
+def check_source(source,**kwargs):return compile_source(source,**kwargs)
+def canonicalize_source(source):return canonical_ast(parse(source))
+def pretty_source(source):return pretty(parse(source))
+
+AST_KEYS={
+'literal':{'kind','value'},'var':{'kind','name'},'binary':{'kind','op','left','right'},'unary':{'kind','op','expr'},'call':{'kind','name','args'},'list':{'kind','items'},'tuple':{'kind','items'},'record':{'kind','fields'},'index':{'kind','target','index'},'field':{'kind','target','name'},'let':{'kind','name','type','mutable','expr'},'assign':{'kind','name','expr'},'return':{'kind','expr'},'expr':{'kind','expr'},'if':{'kind','cond','then','else'},'while':{'kind','cond','limit','body'}}
+def validate_ocir(ocir):
+    if not isinstance(ocir,dict):raise ICLError('OCIR_CORRUPT','object required')
+    try:
+        if ocir.get('schema_version')!=SCHEMA_VERSION or ocir.get('schema_sha256')!=SCHEMA_SHA256:raise ICLError('SCHEMA_INCOMPATIBLE','OCIR schema/hash differs')
+        data={k:v for k,v in ocir.items() if k!='integrity_sha256'}
+        if digest(data)!=ocir.get('integrity_sha256'):raise ICLError('CHECKSUM','OCIR integrity mismatch')
+        required=set(json.loads(SCHEMA_PATH.read_text())['required'])
+        if set(ocir)!=required:raise ICLError('OCIR_CORRUPT','unexpected/missing OCIR fields')
+        if ocir['numeric_policy']!=NUMERIC or ocir['feature_set']!=FEATURES:raise ICLError('SCHEMA_INCOMPATIBLE','numeric/feature policy differs')
+        ctx=RuntimeContext(ocir['limits']);ctx.check_value(ocir)
+        count=0
+        def walk(v,depth=0):
+            nonlocal count
+            count+=1
+            if count>100000 or depth>128:raise ICLError('OCIR_CORRUPT','AST size/depth limit')
+            if isinstance(v,dict):
+                if 'kind' in v:
+                    k=v['kind']
+                    if k not in AST_KEYS:raise ICLError('UNSUPPORTED_OP','unknown AST opcode')
+                    if set(v)-{'span','inferred_type'}!=AST_KEYS[k]:raise ICLError('OCIR_CORRUPT','malformed AST operation')
+                    if k=='binary' and v['op'] not in ('+','-','*','/','%','==','!=','<','<=','>','>=','&&','||'):raise ICLError('UNSUPPORTED_OP','binary opcode')
+                    if k=='unary' and v['op'] not in ('-','!'):raise ICLError('UNSUPPORTED_OP','unary opcode')
+                    if k=='while' and (type(v['limit'])!=int or not 0<=v['limit']<=100000):raise ICLError('OCIR_CORRUPT','invalid loop limit')
+                for child in v.values():walk(child,depth+1)
+            elif isinstance(v,list):
+                for child in v:walk(child,depth+1)
+        walk(ocir['typed_blocks'])
+        p={'module':ocir['module_graph'][-1]['module'],'imports':ocir['module_graph'][-1]['imports'],'functions':copy.deepcopy(ocir['typed_blocks'])};checked=check(p)
+        if digest({'ast':canonical_ast(p),'modules':ocir['module_graph']})!=ocir['program_id']:raise ICLError('OCIR_CORRUPT','program identity inconsistent')
+        if p['functions']!=ocir['typed_blocks'] or checked['ops']!=ocir['ops'] or checked['effects']!=ocir['required_effects'] or checked['shape_constraints']!=ocir['shape_constraints']:raise ICLError('OCIR_CORRUPT','typed data differs from checker')
+        if ocir['operand_types']!=[o['operand_types'] for o in checked['ops']]:raise ICLError('OCIR_CORRUPT','operand types differ')
+        if ocir['entrypoint'] not in {f['name'] for f in p['functions']}:raise ICLError('NAME','invalid entrypoint')
+        return p
+    except ICLError:raise
+    except (KeyError,TypeError,ValueError,IndexError,RecursionError,OverflowError) as e:raise ICLError('OCIR_CORRUPT','invalid serialized structure: '+type(e).__name__)
+
+def dumps_ocir(ocir):validate_ocir(ocir);return canonical(ocir)
+def loads_ocir(text):
+    try:
+        if not isinstance(text,str) or len(text.encode())>4000000:raise ICLError('OCIR_CORRUPT','serialized size limit')
+    except UnicodeError:raise ICLError('OCIR_CORRUPT','invalid Unicode')
+    def pairs(items):
+        d={}
+        for k,v in items:
+            if k in d:raise ICLError('OCIR_CORRUPT','duplicate key')
+            d[k]=v
+        return d
+    try:o=json.loads(text,object_pairs_hook=pairs,parse_constant=lambda x:(_ for _ in ()).throw(ICLError('NONFINITE','JSON nonfinite')))
+    except (ValueError,RecursionError):raise ICLError('OCIR_CORRUPT','invalid JSON')
+    validate_ocir(o);return o
+
+def run_ocir(ocir,args=None,engine='vm',entry=None,policy=None,limits=None,checkpoint=None,stop_after=None):
+    p=validate_ocir(ocir);entry=entry or ocir['entrypoint'];args=[] if args is None else args
+    requested=RuntimeContext(limits).limits if limits is not None else ocir['limits']
+    lim={k:min(requested[k],ocir['limits'][k]) for k in DEFAULT_LIMITS};ctx=RuntimeContext(lim,policy)
+    fn=next((f for f in p['functions'] if f['name']==entry),None)
+    if fn is None:raise ICLError('NAME','entry missing')
+    if not isinstance(args,list) or len(args)!=len(fn['params']):raise ICLError('TYPE','entry argument count')
+    for (_,tp),v in zip(fn['params'],args):validate_value(v,tp,ctx)
+    if engine=='tree':
+        if checkpoint is not None or stop_after is not None:raise ICLError('UNSUPPORTED_OP','tree checkpoint unsupported; VM checkpoint supported')
+        return execute_tree(p,entry,args,lim,policy)
+    if engine!='vm':raise ICLError('ENGINE','unknown execution engine')
+    out=execute_bytecode(compile_bytecode(p),entry,args,lim,policy,checkpoint,stop_after)
+    if 'value' in out and out.get('checkpoint') is None:validate_value(out['value'],fn['return_type'],ctx)
+    return out
+
+def run_source(source,args=None,engine='vm',entry='main',module_map=None,limits=None,policy=None,checkpoint=None,stop_after=None):
+    return run_ocir(compile_source(source,module_map,limits,entry),args,engine,entry,policy,limits,checkpoint,stop_after)

source/icl/checker.py

@@ -0,0 +1,254 @@
+"""Nominal primitive + structural compound types and conservative effect analysis."""
+import math,re
+from .runtime import ICLError,BUILTINS
+BASIC={'Int64','Float64','Bool','String','Observer','Context','ProvenanceRef','RecoveryWitness','Capability'}
+def split_types(s):
+    out=[];start=0;d=0
+    for i,c in enumerate(s):
+        if c in '[{':d+=1
+        elif c in ']}':d-=1
+        elif c==',' and d==0:out.append(s[start:i]);start=i+1
+    out.append(s[start:]);return out
+
+def valid_type(t):
+    if not isinstance(t,str) or len(t)>8192:return False
+    if t in BASIC:return True
+    if t.startswith('Record{') and t.endswith('}'):
+        try:
+            pairs=[x.split(':',1) for x in split_types(t[7:-1])]
+            if not pairs or any(len(x)!=2 for x in pairs):return False
+            names=[x[0] for x in pairs]
+            return len(set(names))==len(names) and names==sorted(names) and all(re.fullmatch(r'[A-Za-z_][A-Za-z_0-9]*',k) and valid_type(v) for k,v in pairs)
+        except (ValueError,RecursionError):return False
+    if t.startswith('Tensor['):
+        try:d=[int(x) for x in t[7:-1].split(',')];return t.endswith(']') and 1<=len(d)<=3 and all(x>0 for x in d) and math.prod(d)<=4096
+        except ValueError:return False
+    for g in ('List','Option','Result','Representation','Exact','Approx','Tuple'):
+        if t.startswith(g+'[') and t.endswith(']'):
+            ts=split_types(t[len(g)+1:-1]);return len(ts)>=1 and all(valid_type(x) for x in ts) and (g=='Tuple' or len(ts)==1)
+    return False
+
+def shape(t):
+    if not t.startswith('Tensor['):raise ICLError('TYPE','Tensor required')
+    return [int(x) for x in t[7:-1].split(',')]
+def tt(s):return 'Tensor['+','.join(map(str,s))+']'
+
+def check(program):
+    fs={};effects=set();ops=[];shapes=[]
+    for f in program['functions']:
+        if f['name'] in fs or f['name'] in BUILTINS:raise ICLError('NAME','duplicate/reserved function '+f['name'],f.get('span'))
+        if not valid_type(f['return_type']):raise ICLError('TYPE','unsupported return type '+f['return_type'])
+        if len({n for n,t in f['params']})!=len(f['params']):raise ICLError('NAME','duplicate parameter')
+        for n,t in f['params']:
+            if not valid_type(t):raise ICLError('TYPE','unsupported parameter type '+t)
+        fs[f['name']]=f
+    def same(a,b,span=None):
+        if a!=b:raise ICLError('TYPE',f'{a} incompatible with {b}',span)
+    def ex(x,env,expected=None):
+        k=x['kind'];sp=x.get('span')
+        if k=='literal':
+            v=x['value'];t='Bool' if type(v)==bool else 'Int64' if type(v)==int else 'Float64' if type(v)==float else 'String'
+            if type(v)==int and not -(1<<63)<=v<(1<<63):raise ICLError('OVERFLOW','literal outside Int64',sp)
+            if type(v)==float and not math.isfinite(v):raise ICLError('NONFINITE','nonfinite literal',sp)
+        elif k=='var':
+            if x['name'] not in env:raise ICLError('NAME','undefined name '+x['name'],sp)
+            t=env[x['name']][0]
+        elif k=='unary':
+            # Smallest Int64 is expressed by unary minus of its magnitude.
+            if x['op']=='-' and x['expr']['kind']=='literal' and type(x['expr']['value'])==int and x['expr']['value']==(1<<63):
+                x['expr']['inferred_type']='Int64';t='Int64'
+            else:
+                a=ex(x['expr'],env);t='Bool' if x['op']=='!' else a
+                if x['op']=='!':same(a,'Bool',sp)
+                elif a not in ('Int64','Float64'):raise ICLError('TYPE','numeric negation only',sp)
+        elif k=='binary':
+            a=ex(x['left'],env);b=ex(x['right'],env);same(a,b,sp);op=x['op']
+            if op in ('&&','||'):same(a,'Bool',sp);t='Bool'
+            elif op in ('==','!='):t='Bool'
+            elif op in ('<','<=','>','>='):
+                if a not in ('Int64','Float64','String'):raise ICLError('TYPE','ordered scalar required',sp)
+                t='Bool'
+            else:
+                if a not in ('Int64','Float64') and not(op=='+' and a=='String'):raise ICLError('TYPE','numeric arithmetic only',sp)
+                t=a
+        elif k in ('list','tuple'):
+            inner=expected[5:-1] if k=='list' and isinstance(expected,str) and expected.startswith('List[') and valid_type(expected) else None
+            ts=[ex(y,env,inner) for y in x['items']]
+            if not ts:
+                if k=='list' and inner is not None:
+                    x['inferred_type']=expected
+                    return expected
+                raise ICLError('TYPE','empty list requires a contextual List type',sp)
+            if k=='list':
+                for a in ts:same(a,ts[0],sp)
+                t='List['+ts[0]+']'
+            else:t='Tuple['+','.join(ts)+']'
+        elif k=='record':t='Record{'+','.join(n+':'+ex(v,env) for n,v in sorted(x['fields'].items()))+'}'
+        elif k=='field':
+            a=ex(x['target'],env)
+            if not a.startswith('Record{'):raise ICLError('TYPE','record required',sp)
+            fields=dict(item.split(':',1) for item in split_types(a[7:-1]))
+            if x['name'] not in fields:raise ICLError('NAME','no such record field',sp)
+            t=fields[x['name']]
+        elif k=='index':
+            a=ex(x['target'],env);same(ex(x['index'],env),'Int64',sp)
+            if a.startswith('List['):t=a[5:-1]
+            elif a=='String':t='String'
+            elif a.startswith('Tuple['):
+                ix=x['index']
+                if ix['kind']!='literal' or type(ix['value'])!=int:raise ICLError('TYPE','tuple index must be literal',sp)
+                ts=split_types(a[6:-1]);i=ix['value']
+                if i<0 or i>=len(ts):raise ICLError('INDEX','tuple index out of range',sp)
+                t=ts[i]
+            else:raise ICLError('TYPE','indexable value required',sp)
+        elif k=='call':
+            nm=x['name'];args=x['args']
+            expected_args=[t for _,t in fs[nm]['params']] if nm in fs else []
+            ts=[ex(y,env,expected_args[i] if i<len(expected_args) else None) for i,y in enumerate(args)]
+            def sig(types,ret):
+                if len(ts)!=len(types):raise ICLError('TYPE',nm+' arity mismatch',sp)
+                for a,b in zip(ts,types):same(a,b,sp)
+                return ret
+            def ar(n):
+                if len(ts)!=n:raise ICLError('TYPE',nm+' arity mismatch',sp)
+            if nm in fs:t=sig([v for n,v in fs[nm]['params']],fs[nm]['return_type'])
+            elif nm=='len':
+                ar(1)
+                if ts[0]!='String' and not ts[0].startswith('List['):raise ICLError('TYPE','len list/string',sp)
+                t='Int64'
+            elif nm in ('abs','min','max'):
+                ar(1 if nm=='abs' else 2)
+                if ts[0] not in ('Int64','Float64') or len(set(ts))!=1:raise ICLError('TYPE','numeric homogeneous inputs')
+                t=ts[0]
+            elif nm=='to_float':t=sig(['Int64'],'Float64')
+            elif nm=='tensor':
+                sig(['List[Float64]','List[Int64]'],'')
+                sh=args[1]
+                if sh['kind']!='list' or any(y['kind']!='literal' or type(y['value'])!=int for y in sh['items']):raise ICLError('SHAPE','tensor shape must be literal',sp)
+                ds=[y['value'] for y in sh['items']];t=tt(ds)
+                if not valid_type(t):raise ICLError('SHAPE','invalid tensor shape',sp)
+                if args[0]['kind']=='list' and len(args[0]['items'])!=math.prod(ds):raise ICLError('SHAPE','tensor literal data length',sp)
+                shapes.append({'op':'tensor','shape':ds})
+            elif nm=='matmul':
+                ar(2);a=shape(ts[0]);b=shape(ts[1])
+                if len(a)!=2 or len(b)!=2 or a[1]!=b[0]:raise ICLError('SHAPE','matmul dimensions',sp)
+                t=tt([a[0],b[1]]);shapes.append({'op':'matmul','left':a,'right':b,'output':[a[0],b[1]]})
+            elif nm in ('add','sub','mul'):
+                ar(2);shape(ts[0]);same(ts[0],ts[1],sp);t=ts[0]
+            elif nm in ('relu','tanh','normalize','softmax','sum'):
+                ar(1);shape(ts[0]);t='Float64' if nm=='sum' else ts[0]
+            elif nm=='reshape':
+                ar(2);a=shape(ts[0]);same(ts[1],'List[Int64]')
+                if args[1]['kind']!='list' or any(y['kind']!='literal' or type(y['value'])!=int for y in args[1]['items']):raise ICLError('SHAPE','reshape literal shape required')
+                b=[y['value'] for y in args[1]['items']];t=tt(b)
+                if not valid_type(t) or math.prod(a)!=math.prod(b):raise ICLError('SHAPE','reshape elements differ')
+            elif nm in ('some','ok'):ar(1);t=('Option' if nm=='some' else 'Result')+'['+ts[0]+']'
+            elif nm=='none_int':t=sig([],'Option[Int64]')
+            elif nm=='err_int':t=sig(['String'],'Result[Int64]')
+            elif nm in ('unwrap','is_some'):
+                ar(1)
+                if not ts[0].startswith(('Option[','Result[')):raise ICLError('TYPE','Option/Result required')
+                if nm=='is_some' and not ts[0].startswith('Option['):raise ICLError('TYPE','Option required')
+                t='Bool' if nm=='is_some' else ts[0][ts[0].index('[')+1:-1]
+            elif nm=='observer':t=sig(['String'],'Observer')
+            elif nm=='context':t=sig(['String','String'],'Context')
+            elif nm=='provenance':t=sig(['String'],'ProvenanceRef')
+            elif nm=='represent':ar(4);sig([ts[0],'String','String','String'],'');t='Representation['+ts[0]+']'
+            elif nm=='repr_value':
+                ar(1)
+                if not ts[0].startswith('Representation['):raise ICLError('TYPE','Representation required')
+                t=ts[0][15:-1]
+            elif nm=='repr_add':
+                ar(2);same(ts[0],ts[1])
+                if ts[0] not in ('Representation[Int64]','Representation[Float64]'):raise ICLError('TYPE','numeric representations required')
+                t=ts[0]
+            elif nm=='convert_frame':
+                ar(4)
+                if ts[0] not in ('Representation[Int64]','Representation[Float64]'):raise ICLError('TYPE','numeric representation required')
+                t=sig([ts[0],'String',ts[0][15:-1],'String'],ts[0])
+            elif nm=='observe_mod':t=sig(['Int64','Int64','String'],'Representation[Int64]')
+            elif nm=='make_witness':t=sig(['Int64','Int64'],'RecoveryWitness')
+            elif nm=='recover':t=sig(['Representation[Int64]','RecoveryWitness'],'Exact[Int64]')
+            elif nm=='recover_without_witness':t=sig(['Representation[Int64]'],'Exact[Int64]')
+            elif nm=='exact_value':
+                ar(1)
+                if not ts[0].startswith('Exact['):raise ICLError('TYPE','Exact required')
+                t=ts[0][6:-1]
+            elif nm=='approx':t=sig(['Float64','Float64'],'Approx[Float64]')
+            elif nm=='approx_value':t=sig(['Approx[Float64]'],'Float64')
+            elif nm=='request_effect':t=sig(['String','String'],'Bool');effects.add('policy_request')
+            elif nm=='random_int':t=sig(['Int64'],'Int64');effects.add('prng')
+            else:raise ICLError('NAME','unknown function '+nm,sp)
+            ops.append({'name':nm,'operand_types':ts,'result_type':t})
+        else:raise ICLError('UNSUPPORTED_OP',k,sp)
+        x['inferred_type']=t;return t
+    def body(ss,outer,ret):
+        env=dict(outer);local=set();always=False
+        for s in ss:
+            k=s['kind'];sp=s.get('span')
+            if k=='let':
+                if s['name'] in local:raise ICLError('NAME','duplicate local binding',sp)
+                t=ex(s['expr'],env,s.get('type'))
+                if s.get('type'):
+                    if not valid_type(s['type']):raise ICLError('TYPE','invalid local type',sp)
+                    same(t,s['type'],sp)
+                env[s['name']]=(t,s['mutable']);local.add(s['name']);s['inferred_type']=t
+            elif k=='assign':
+                if s['name'] not in env:raise ICLError('NAME','undefined assignment',sp)
+                t,mut=env[s['name']]
+                if not mut:raise ICLError('IMMUTABLE','cannot assign let/parameter',sp)
+                same(ex(s['expr'],env,t),t,sp)
+            elif k=='return':same(ex(s['expr'],env,ret),ret,sp);always=True
+            elif k=='expr':ex(s['expr'],env)
+            elif k=='if':
+                same(ex(s['cond'],env),'Bool',sp);a=body(s['then'],env,ret);b=body(s['else'],env,ret);always=always or (a and b)
+            elif k=='while':same(ex(s['cond'],env),'Bool',sp);body(s['body'],env,ret)
+            else:raise ICLError('UNSUPPORTED_OP',k,sp)
+        return always
+    for f in program['functions']:
+        env={n:(t,False) for n,t in f['params']}
+        if not body(f['body'],env,f['return_type']):raise ICLError('RETURN','function must return on every path',f.get('span'))
+    return {'program':program,'effects':sorted(effects),'ops':ops,'shape_constraints':shapes}
+
+def validate_value(value,t,ctx):
+    ctx.check_value(value)
+    valid=False
+    if t=='Int64':valid=type(value)==int
+    elif t=='Float64':valid=type(value)==float
+    elif t=='Bool':valid=type(value)==bool
+    elif t=='String':valid=type(value)==str
+    elif t.startswith('Tensor['):
+        from .runtime import validate_tensor
+        v=validate_tensor(value,ctx);valid=v['shape']==shape(t)
+    elif t.startswith('List['):valid=type(value)==list and all(validate_value(x,t[5:-1],ctx) for x in value)
+    elif t.startswith('Tuple['):
+        ts=split_types(t[6:-1]);valid=type(value)==list and len(value)==len(ts) and all(validate_value(x,st,ctx) for x,st in zip(value,ts))
+    elif t.startswith('Record{'):
+        fields=dict(item.split(':',1) for item in split_types(t[7:-1]));valid=isinstance(value,dict) and set(value)==set(fields) and all(validate_value(value[k],st,ctx) for k,st in fields.items())
+    elif isinstance(value,dict):
+        tag=t.split('[',1)[0];inner=t[t.index('[')+1:-1] if '[' in t else None
+        def fields(required):return all(k in value for k in required)
+        if tag=='Option':
+            valid=value.get('tag')=='None' and value.get('value') is None
+            if value.get('tag')=='Some':valid=fields(['value']) and validate_value(value['value'],inner,ctx)
+        elif tag=='Result':
+            valid=value.get('tag')=='Err' and isinstance(value.get('error'),str)
+            if value.get('tag')=='Ok':valid=fields(['value']) and validate_value(value['value'],inner,ctx)
+        elif tag=='Representation':
+            valid=value.get('tag')==tag and fields(['value','observer','frame','unit','source_hash','provenance']) and all(isinstance(value[k],str) for k in ('observer','frame','unit')) and isinstance(value['provenance'],dict) and (value['source_hash'] is None or isinstance(value['source_hash'],str))
+            if valid:valid=validate_value(value['value'],inner,ctx)
+            if 'modulus' in value:valid=valid and type(value['modulus'])==int and value['modulus']>0
+        elif tag=='Exact':
+            valid=value.get('tag')==tag and fields(['value','witness_bytes','scope']) and type(value['witness_bytes'])==int and value['witness_bytes']>=0 and isinstance(value['scope'],str)
+            if valid:valid=validate_value(value['value'],inner,ctx)
+        elif tag=='Approx':
+            valid=value.get('tag')==tag and fields(['value','error_bound']) and type(value['error_bound'])==float and value['error_bound']>=0
+            if valid:valid=validate_value(value['value'],inner,ctx)
+        elif tag=='Observer':valid=value.get('tag')==tag and isinstance(value.get('id'),str)
+        elif tag=='Context':valid=value.get('tag')==tag and isinstance(value.get('frame'),str) and isinstance(value.get('unit'),str)
+        elif tag=='ProvenanceRef':valid=value.get('tag')==tag and isinstance(value.get('source_id'),str) and value.get('verified') is False
+        elif tag=='RecoveryWitness':
+            valid=value.get('tag')==tag and all(type(value.get(k))==int for k in ('quotient','modulus','remainder','payload_bytes')) and value.get('modulus',0)>0 and value.get('payload_bytes',-1)>=0 and isinstance(value.get('sha256'),str)
+        elif tag=='Capability':valid=False  # no transferable authority values in v0.1
+    if not valid:raise ICLError('TYPE','input does not match '+t)
+    return True

source/icl/cli.py

@@ -0,0 +1,59 @@
+"""Offline CLI. JSON diagnostics on stderr, successful JSON on stdout."""
+import argparse,json,sys
+from pathlib import Path
+from . import __version__
+from .api import compile_source,run_source,run_ocir,loads_ocir,dumps_ocir,SCHEMA_SHA256
+from .runtime import ICLError,digest
+
+def read(path,max_bytes=4000000):
+    p=Path(path)
+    if p.is_symlink() or any(parent.is_symlink() for parent in p.parents):raise ICLError('PATH','symlinks are not accepted')
+    if not p.is_file():raise ICLError('PATH','regular file required')
+    if p.stat().st_size>max_bytes:raise ICLError('SOURCE_LIMIT','file size exceeded')
+    try:return p.read_text(encoding='utf-8')
+    except (UnicodeError,OSError):raise ICLError('PATH','UTF-8 file unavailable')
+def js(text):
+    try:return json.loads(text,parse_constant=lambda x:(_ for _ in ()).throw(ValueError(x)))
+    except (ValueError,RecursionError):raise ICLError('JSON','invalid finite JSON argument')
+def output(obj):print(json.dumps(obj,ensure_ascii=False,allow_nan=False,sort_keys=True))
+def main(argv=None):
+    parser=argparse.ArgumentParser(prog='icl',description='Invariant Cognition Language finite core, offline v0.1')
+    parser.add_argument('--version',action='version',version=__version__)
+    subs=parser.add_subparsers(dest='command',required=True)
+    for name in ('check','run','compile'):
+        p=subs.add_parser(name);p.add_argument('source');p.add_argument('--module-map',help='JSON file mapping module names to source text');p.add_argument('--entry',default='main');p.add_argument('--json',action='store_true',help='JSON is also the default output')
+        p.add_argument('--max-steps',type=int)
+        if name=='run':
+            p.add_argument('--args',default='[]',help='JSON argument array');p.add_argument('--engine',choices=['vm','tree'],default='vm');p.add_argument('--policy',help='Separate trusted host policy JSON file');p.add_argument('--trace',action='store_true');p.add_argument('--stop-after',type=int);p.add_argument('--checkpoint-out')
+        if name=='compile':p.add_argument('-o','--output',required=True)
+    p=subs.add_parser('inspect');p.add_argument('ocir');p.add_argument('--json',action='store_true')
+    p=subs.add_parser('replay');p.add_argument('ocir');p.add_argument('checkpoint');p.add_argument('--args',default='[]');p.add_argument('--policy');p.add_argument('--json',action='store_true');p.add_argument('--trace',action='store_true')
+    p=subs.add_parser('test');p.add_argument('--json',action='store_true')
+    a=parser.parse_args(argv)
+    try:
+        if a.command in ('check','run','compile'):
+            source=read(a.source,1000000);modules=js(read(a.module_map)) if a.module_map else None;limits={'max_steps':a.max_steps} if a.max_steps is not None else None
+            ocir=compile_source(source,modules,limits,a.entry)
+            if a.command=='check':output({'status':'PASS','schema_sha256':SCHEMA_SHA256,'program_id':ocir['program_id'],'required_effects':ocir['required_effects']});return 0
+            if a.command=='compile':
+                Path(a.output).write_text(dumps_ocir(ocir)+'\n',encoding='utf-8');output({'status':'PASS','output':a.output,'sha256':ocir['integrity_sha256']});return 0
+            policy=js(read(a.policy)) if a.policy else None
+            r=run_ocir(ocir,js(a.args),a.engine,policy=policy,stop_after=a.stop_after)
+            if a.checkpoint_out and r.get('checkpoint'):Path(a.checkpoint_out).write_text(json.dumps(r['checkpoint'],sort_keys=True),encoding='utf-8')
+        elif a.command=='inspect':
+            o=loads_ocir(read(a.ocir));output({'schema_version':o['schema_version'],'schema_sha256':o['schema_sha256'],'program_id':o['program_id'],'entrypoint':o['entrypoint'],'functions':[f['name'] for f in o['typed_blocks']],'required_effects':o['required_effects'],'limits':o['limits'],'integrity':'PASS'});return 0
+        elif a.command=='replay':
+            o=loads_ocir(read(a.ocir));r=run_ocir(o,js(a.args),policy=js(read(a.policy)) if a.policy else None,checkpoint=js(read(a.checkpoint)))
+        else:
+            fixtures=[('arithmetic','module t; fn main() -> Int64 { return 7 * 6; }',42),('branch','module t; fn main() -> Int64 { if true { return 1; } else { return 0; } }',1),('function','module t; fn f(x:Int64)->Int64{return x*x;} fn main()->Int64{return f(9);}',81)]
+            results=[]
+            for name,s,v in fixtures:
+                vals=[run_source(s,engine=e)['value'] for e in ('tree','vm')];results.append({'name':name,'passed':vals==[v,v]})
+            passed=all(x['passed'] for x in results);output({'status':'PASS' if passed else 'FAIL','tests':results});return 0 if passed else 1
+        if not a.trace and 'trace' in r:r['trace_sha256']=digest(r['trace']);r['trace_events']=len(r.pop('trace'))
+        output({'status':'PAUSED' if r.get('checkpoint') else 'PASS',**r});return 0
+    except ICLError as e:
+        print(json.dumps({'status':'ERROR','diagnostic':e.as_dict()},ensure_ascii=False),file=sys.stderr);return 2
+    except (OSError,UnicodeError) as e:
+        print(json.dumps({'status':'ERROR','diagnostic':{'code':'IO','message':str(e)}}),file=sys.stderr);return 3
+if __name__=='__main__':raise SystemExit(main())

source/icl/frontend.py

@@ -0,0 +1,208 @@
+"""ICL 0.1 hand-written lexer/parser. No host language parsing or evaluation."""
+import bisect, json, re, unicodedata
+from .runtime import ICLError
+
+KEYWORDS={'module','import','fn','let','var','if','else','while','limit','return','true','false','type'}
+class Parser:
+    def __init__(self,source):
+        if not isinstance(source,str) or len(source.encode())>1000000: raise ICLError('SOURCE_LIMIT','source must be UTF-8 text <= 1MB')
+        for c in source:
+            if unicodedata.category(c) in ('Cf','Cs') or (ord(c)<32 and c not in '\n\r\t'): raise ICLError('LEX','invisible/control character forbidden')
+        self.source=source; self.tokens=[]; self.i=0; self.depth=0; self.aliases={}
+        self.newlines=[-1]+[i for i,c in enumerate(source) if c=='\n']
+        pattern=re.compile(r'(?P<space>\s+)|(?P<comment>//[^\n]*)|(?P<string>"(?:[^"\\\n]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*")|(?P<float>\d+\.\d+(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+)|(?P<int>\d+)|(?P<id>[A-Za-z_][A-Za-z_0-9]*)|(?P<op>->|==|!=|<=|>=|&&|\|\||[{}()\[\],;:.+*/%<>=!\-])')
+        p=0
+        while p<len(source):
+            m=pattern.match(source,p)
+            if not m: raise ICLError('LEX',f'unexpected character {source[p]!r}',self.span(p))
+            if m.lastgroup in ('int','float') and len(m.group())>128:
+                raise ICLError('NUMBER_LIMIT','numeric token exceeds 128 characters',self.span(p))
+            if m.lastgroup not in ('space','comment'): self.tokens.append((m.lastgroup,m.group(),self.span(p)))
+            p=m.end()
+        if len(self.tokens)>100000: raise ICLError('SOURCE_LIMIT','too many tokens')
+        self.tokens.append(('eof','<eof>',self.span(len(source))))
+    def span(self,p):
+        line=bisect.bisect_left(self.newlines,p)
+        return {'line':line,'column':p-self.newlines[line-1],'offset':p}
+    def peek(self,v=None): return self.tokens[self.i][1] if v is None else self.tokens[self.i][1]==v
+    def take(self,v=None):
+        if self.i>=len(self.tokens) or self.tokens[self.i][0]=='eof':
+            raise ICLError('PARSE','unexpected end of source',self.tokens[-1][2])
+        t=self.tokens[self.i]
+        if v is not None and t[1]!=v: raise ICLError('PARSE',f'expected {v}, got {t[1]}',t[2])
+        self.i+=1; return t
+    def ident(self):
+        t=self.take()
+        if t[0]!='id' or t[1] in KEYWORDS: raise ICLError('PARSE','identifier expected',t[2])
+        return t[1]
+    def typ(self):
+        name=self.ident()
+        if name in self.aliases:
+            if self.peek('['):
+                raise ICLError('TYPE','type alias cannot take arguments')
+            return self.aliases[name]
+        if name=='Record' and self.peek('{'):
+            self.take('{'); fields={}
+            if self.peek('}'):raise ICLError('TYPE','empty record annotation is unsupported')
+            while True:
+                field=self.ident()
+                if field in fields:raise ICLError('TYPE','duplicate record type field')
+                self.take(':'); fields[field]=self.typ()
+                if not self.peek(','):break
+                self.take(',')
+            self.take('}')
+            return 'Record{'+','.join(k+':'+v for k,v in sorted(fields.items()))+'}'
+        if self.peek('['):
+            self.take(); args=[]
+            if not self.peek(']'):
+                while True:
+                    args.append(self.take()[1] if self.tokens[self.i][0]=='int' else self.typ())
+                    if not self.peek(','): break
+                    self.take(',')
+            self.take(']'); name+='['+','.join(args)+']'
+        return name
+    def parse(self):
+        self.take('module'); module=self.ident(); self.take(';'); imports=[]; funcs=[]
+        while self.peek('import'):
+            self.take(); imports.append(self.ident()); self.take(';')
+        while self.peek('type'):
+            self.take('type'); alias=self.ident()
+            if alias in self.aliases or alias in {'Int64','Float64','Bool','String','Record','Tensor','List','Result','Option','Observer','Context','ProvenanceRef','RecoveryWitness','Capability','Tuple','Exact','Approx','Representation'}:
+                raise ICLError('TYPE','duplicate or reserved type alias')
+            self.take('='); target=self.typ(); self.take(';')
+            from .checker import valid_type
+            if not valid_type(target):raise ICLError('TYPE','alias must resolve to an already defined type')
+            self.aliases[alias]=target
+        while not self.peek('<eof>'):
+            sp=self.take('fn')[2]; name=self.ident(); self.take('('); params=[]
+            if not self.peek(')'):
+                while True:
+                    nm=self.ident(); self.take(':'); params.append([nm,self.typ()])
+                    if not self.peek(','): break
+                    self.take(',')
+            self.take(')'); self.take('->'); ret=self.typ(); funcs.append({'name':name,'params':params,'return_type':ret,'body':self.block(),'span':sp})
+        if not funcs: raise ICLError('PARSE','module requires function')
+        return {'module':module,'imports':imports,'functions':funcs}
+    def block(self):
+        self.take('{'); body=[]
+        while not self.peek('}'):
+            if self.peek('<eof>'): raise ICLError('PARSE','unterminated block')
+            body.append(self.stmt())
+        self.take('}'); return body
+    def stmt(self):
+        sp=self.tokens[self.i][2]; v=self.peek()
+        if v in ('let','var'):
+            self.take(); nm=self.ident(); tp=None
+            if self.peek(':'): self.take();tp=self.typ()
+            self.take('='); ex=self.expr();self.take(';');return {'kind':'let','name':nm,'type':tp,'mutable':v=='var','expr':ex,'span':sp}
+        if v=='return':
+            self.take();ex=self.expr();self.take(';');return {'kind':'return','expr':ex,'span':sp}
+        if v=='if':
+            self.take();co=self.expr();yes=self.block();no=[]
+            if self.peek('else'):self.take();no=self.block()
+            return {'kind':'if','cond':co,'then':yes,'else':no,'span':sp}
+        if v=='while':
+            self.take();co=self.expr();self.take('limit');t=self.take()
+            if t[0]!='int' or not 0<=int(t[1])<=100000:raise ICLError('PARSE','loop limit must be literal 0..100000',t[2])
+            return {'kind':'while','cond':co,'limit':int(t[1]),'body':self.block(),'span':sp}
+        if self.tokens[self.i][0]=='id' and self.tokens[self.i+1][1]=='=':
+            nm=self.ident();self.take('=');ex=self.expr();self.take(';');return {'kind':'assign','name':nm,'expr':ex,'span':sp}
+        ex=self.expr();self.take(';');return {'kind':'expr','expr':ex,'span':sp}
+    PREC={'||':1,'&&':2,'==':3,'!=':3,'<':4,'>':4,'<=':4,'>=':4,'+':5,'-':5,'*':6,'/':6,'%':6}
+    def expr(self,p=0):
+        self.depth+=1
+        if self.depth>150:raise ICLError('PARSE_DEPTH','expression nesting exceeds 150')
+        try:
+            t=self.take();sp=t[2];v=t[1]
+            if v=='-' and self.tokens[self.i][0]=='int' and self.tokens[self.i][1]==str(1<<63):
+                self.take();left={'kind':'literal','value':-(1<<63),'span':sp}
+            elif v in ('!','-'):left={'kind':'unary','op':v,'expr':self.expr(7),'span':sp}
+            elif t[0] in ('int','float','string') or v in ('true','false'):
+                val=json.loads(v) if t[0]=='string' else float(v) if t[0]=='float' else int(v) if t[0]=='int' else v=='true'
+                if isinstance(val,str) and any(unicodedata.category(c)=='Cs' for c in val):raise ICLError('LEX','unpaired Unicode surrogate forbidden',sp)
+                left={'kind':'literal','value':val,'span':sp}
+            elif v=='(':
+                left=self.expr()
+                if self.peek(','):
+                    items=[left]
+                    while self.peek(','):self.take();items.append(self.expr())
+                    left={'kind':'tuple','items':items,'span':sp}
+                self.take(')')
+            elif v=='[':
+                items=[]
+                if not self.peek(']'):
+                    while True:
+                        items.append(self.expr())
+                        if not self.peek(','):break
+                        self.take(',')
+                self.take(']');left={'kind':'list','items':items,'span':sp}
+            elif v=='{':
+                fields={}
+                if not self.peek('}'):
+                    while True:
+                        k=self.ident()
+                        if k in fields:raise ICLError('PARSE','duplicate field')
+                        self.take(':');fields[k]=self.expr()
+                        if not self.peek(','):break
+                        self.take(',')
+                self.take('}');left={'kind':'record','fields':fields,'span':sp}
+            elif t[0]=='id' and v not in KEYWORDS:left={'kind':'var','name':v,'span':sp}
+            else:raise ICLError('PARSE','expression expected',sp)
+            while True:
+                if self.peek('('):
+                    if left['kind'] not in ('var','field'):raise ICLError('PARSE','calls require named function',sp)
+                    name=left['name'] if left['kind']=='var' else left['target']['name']+'.'+left['name'] if left['target']['kind']=='var' else None
+                    if name is None:raise ICLError('PARSE','invalid call target',sp)
+                    self.take();args=[]
+                    if not self.peek(')'):
+                        while True:
+                            args.append(self.expr())
+                            if not self.peek(','):break
+                            self.take(',')
+                    self.take(')');left={'kind':'call','name':name,'args':args,'span':sp};continue
+                if self.peek('['):
+                    self.take();ix=self.expr();self.take(']');left={'kind':'index','target':left,'index':ix,'span':sp};continue
+                if self.peek('.'):
+                    self.take();nm=self.ident();left={'kind':'field','target':left,'name':nm,'span':sp};continue
+                op=self.peek();prec=self.PREC.get(op,-1)
+                if prec<p:break
+                self.take();right=self.expr(prec+1);left={'kind':'binary','op':op,'left':left,'right':right,'span':sp}
+            return left
+        finally:self.depth-=1
+
+def parse(source):
+    try:return Parser(source).parse()
+    except RecursionError:raise ICLError('PARSE_DEPTH','parser recursion limit')
+    except IndexError:raise ICLError('PARSE','unexpected end of source')
+    except (ValueError,OverflowError):raise ICLError('LEX','invalid or oversized literal')
+
+def canonical_ast(node):
+    if isinstance(node,dict):return {k:canonical_ast(v) for k,v in sorted(node.items()) if k not in ('span','inferred_type','effects')}
+    if isinstance(node,list):return [canonical_ast(v) for v in node]
+    return node
+
+def pretty(program):
+    def e(x):
+        k=x['kind']
+        if k=='literal':return json.dumps(x['value'],ensure_ascii=False)
+        if k=='var':return x['name']
+        if k=='binary':return '('+e(x['left'])+' '+x['op']+' '+e(x['right'])+')'
+        if k=='unary':return '('+x['op']+e(x['expr'])+')'
+        if k=='call':return x['name']+'('+', '.join(e(a) for a in x['args'])+')'
+        if k in ('list','tuple'):return ('[' if k=='list' else '(')+', '.join(e(a) for a in x['items'])+(']' if k=='list' else ')')
+        if k=='record':return '{'+', '.join(n+': '+e(a) for n,a in x['fields'].items())+'}'
+        if k=='index':return e(x['target'])+'['+e(x['index'])+']'
+        if k=='field':return e(x['target'])+'.'+x['name']
+        raise ICLError('UNSUPPORTED_OP',k)
+    def b(ss):
+        out=[]
+        for s in ss:
+            k=s['kind']
+            if k=='let':out.append(('var ' if s['mutable'] else 'let ')+s['name']+(':'+s['type'] if s.get('type') else '')+' = '+e(s['expr'])+';')
+            elif k=='assign':out.append(s['name']+' = '+e(s['expr'])+';')
+            elif k=='return':out.append('return '+e(s['expr'])+';')
+            elif k=='expr':out.append(e(s['expr'])+';')
+            elif k=='if':out.append('if '+e(s['cond'])+' { '+b(s['then'])+' } else { '+b(s['else'])+' }')
+            elif k=='while':out.append('while '+e(s['cond'])+' limit '+str(s['limit'])+' { '+b(s['body'])+' }')
+        return ' '.join(out)
+    return 'module '+program['module']+';\n'+''.join('import '+m+';\n' for m in program['imports'])+'\n'.join('fn '+f['name']+'('+', '.join(n+': '+t for n,t in f['params'])+') -> '+f['return_type']+' { '+b(f['body'])+' }' for f in program['functions'])+'\n'

source/icl/interpreter.py

@@ -0,0 +1,79 @@
+"""Independent recursive tree evaluator: no bytecode compiler or VM calls."""
+from .runtime import ICLError,RuntimeContext,checked_binary,checked_unary,builtin,BUILTINS,digest
+from .checker import validate_value
+class Returned(Exception):
+    def __init__(self,value):self.value=value
+class Scope:
+    def __init__(self,parent=None):self.parent=parent;self.values={}
+    def get(self,name):
+        if name in self.values:return self.values[name]
+        if self.parent is not None:return self.parent.get(name)
+        raise ICLError('NAME','undefined '+name)
+    def set(self,name,val):
+        if name in self.values:self.values[name]=val
+        elif self.parent is not None:self.parent.set(name,val)
+        else:raise ICLError('NAME','undefined assignment '+name)
+
+def execute_tree(program,entry='main',args=None,limits=None,policy=None):
+    ctx=RuntimeContext(limits,policy);fs={f['name']:f for f in program['functions']};depth=0
+    def ex(x,scope):
+        chain=[];cur=scope
+        while cur is not None:chain.append(cur.values);cur=cur.parent
+        ctx.step('tree.'+x['kind'],inputs={'scope':chain,'prng':ctx.prng})
+        event=ctx.trace[-1]
+        try:
+            value=_ex(x,scope);event['output_hash']=digest(value);event['state_ref']=event['output_hash'];return value
+        except ICLError as error:event['error_code']=error.code;raise
+    def _ex(x,scope):
+        k=x['kind']
+        if k=='literal':return x['value']
+        if k=='var':return scope.get(x['name'])
+        if k=='unary':return checked_unary(x['op'],ex(x['expr'],scope))
+        if k=='binary':
+            a=ex(x['left'],scope)
+            if x['op']=='&&' and a is False:return False
+            if x['op']=='||' and a is True:return True
+            return ctx.check_value(checked_binary(x['op'],a,ex(x['right'],scope)))
+        if k=='call':
+            aa=[ex(v,scope) for v in x['args']]
+            return ctx.check_value(builtin(x['name'],aa,ctx) if x['name'] in BUILTINS else call(x['name'],aa))
+        if k in ('list','tuple'):return ctx.check_value([ex(v,scope) for v in x['items']])
+        if k=='record':return ctx.check_value({n:ex(x['fields'][n],scope) for n in sorted(x['fields'])})
+        if k=='index':
+            a=ex(x['target'],scope);i=ex(x['index'],scope)
+            if i<0 or i>=len(a):raise ICLError('BOUNDS','index out of bounds')
+            return a[i]
+        if k=='field':return ex(x['target'],scope)[x['name']]
+        raise ICLError('UNSUPPORTED_OP',k)
+    def block(ss,parent):
+        scope=Scope(parent)
+        for s in ss:
+            k=s['kind'];ctx.step('tree.'+k)
+            if k=='let':scope.values[s['name']]=ex(s['expr'],scope)
+            elif k=='assign':scope.set(s['name'],ex(s['expr'],scope))
+            elif k=='return':raise Returned(ex(s['expr'],scope))
+            elif k=='expr':ex(s['expr'],scope)
+            elif k=='if':block(s['then'] if ex(s['cond'],scope) else s['else'],scope)
+            elif k=='while':
+                count=0
+                while ex(s['cond'],scope):
+                    if count>=s['limit']:raise ICLError('LOOP_LIMIT','declared iteration bound exceeded')
+                    count+=1;block(s['body'],scope)
+            else:raise ICLError('UNSUPPORTED_OP',k)
+    def call(name,aa):
+        nonlocal depth
+        if name not in fs:raise ICLError('NAME','entry/function missing '+name)
+        f=fs[name]
+        if len(aa)!=len(f['params']):raise ICLError('TYPE','function argument count')
+        depth+=1
+        if depth>ctx.limits['max_stack']:raise ICLError('STACK_LIMIT','call stack budget')
+        env=Scope()
+        for (n,t),v in zip(f['params'],aa):validate_value(v,t,ctx);env.values[n]=v
+        try:block(f['body'],env)
+        except Returned as r:validate_value(r.value,f['return_type'],ctx);return r.value
+        finally:depth-=1
+        raise ICLError('RETURN','function reached end')
+    try:value=call(entry,args or [])
+    except RecursionError:raise ICLError('STACK_LIMIT','host recursion boundary reached')
+    ctx.check_value(value)
+    return {'value':value,'trace':ctx.trace,'effects':ctx.effects,'steps':ctx.steps}

source/icl/legacy_afc.py

@@ -0,0 +1,98 @@
+"""Bounded AFC Phase-I finite-state recovery algorithm transfer.
+
+Port source: INVARIANT_FINAL_PHASE_I, source/src/science.py:afc_finite_limits.
+Finite arithmetic only (2..10 bits). Does NOT demonstrate physical/hardware
+reversibility, zero dissipation, clinical effectiveness, or general laws.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+CLAIM_BOUNDARY = (
+    "Elementary finite-state injectivity and recovery examples with explicit "
+    "side-information cost. Not a universal physical law, erasure-free hardware "
+    "demonstration, clinical validation, or independent venture-domain experiments."
+)
+ORIGINAL_PHASE_I_ZIP_SHA256 = "469f3eedb6c26f601dc2357f029364a2b3974cfbd3d937385d1dfe5c2840231e"
+ORIGINAL_RESULT_MEMBER_SHA256 = "02167c798d3f2e56fed9e9c0966f6ab3a151bd4e5e4747a5e6ed40472c844f2e"
+
+
+def _bits(bits: int) -> int:
+    if type(bits) is not int or not 2 <= bits <= 10:
+        raise ValueError("AFC_FINITE_BITS_2_TO_10_ONLY")
+    return bits
+
+
+def encode_permutation(x: int, bits: int) -> int:
+    """Exactly follows original fixed finite permutation y=(5x+3) mod 2^bits."""
+    n = 1 << _bits(bits)
+    if type(x) is not int or not 0 <= x < n:
+        raise ValueError("AFC_FINITE_INPUT_OUT_OF_RANGE")
+    return (5*x+3) % n
+
+
+def decode_permutation(y: int, bits: int) -> int:
+    n = 1 << _bits(bits)
+    if type(y) is not int or not 0 <= y < n:
+        raise ValueError("AFC_FINITE_INPUT_OUT_OF_RANGE")
+    return ((y-3)*pow(5,-1,n)) % n
+
+
+def quotient(x: int, bits: int) -> int:
+    n = 1 << _bits(bits)
+    if type(x) is not int or not 0 <= x < n:
+        raise ValueError("AFC_FINITE_INPUT_OUT_OF_RANGE")
+    kept = max(1,bits//2)
+    return x % (1 << kept)
+
+
+def recover_from_quotient(q: int, side: int, bits: int) -> int:
+    """Original quotient + REQUIRED side-information; no silent recovery guess."""
+    _bits(bits)
+    kept = max(1,bits//2)
+    if type(q) is not int or not 0 <= q < (1 << kept):
+        raise ValueError("AFC_QUOTIENT_OUT_OF_RANGE")
+    if type(side) is not int or not 0 <= side < (1 << (bits-kept)):
+        raise ValueError("AFC_SIDE_INFORMATION_REQUIRED_OR_INVALID")
+    return q + (1 << kept) * side
+
+
+def finite_report(bits: int) -> dict[str, Any]:
+    """Bounded deterministic report with original Phase-I field names."""
+    _bits(bits)
+    n = 1 << bits
+    kept = max(1, bits//2)
+    fibers: dict[int,list[int]] = {}
+    perm=[]
+    for x in range(n):
+        perm.append(encode_permutation(x,bits))
+        fibers.setdefault(quotient(x,bits),[]).append(x)
+    inv_exact=all(decode_permutation(y,bits)==x for x,y in enumerate(perm))
+    side_exact=all(recover_from_quotient(quotient(x,bits),x//(1<<kept),bits)==x for x in range(n))
+    witness=next(v[:2] for v in fibers.values() if len(v)>1)
+    return {
+        'bits':bits,'states':n,'permutation_inverse_exact':inv_exact,
+        'retained_bits':kept,'lost_bits':bits-kept,
+        'best_uniform_exact_recovery_probability_without_side_information':len(fibers)/n,
+        'collision_witness':witness,
+        'side_information_bits_needed_for_full_uniform_recovery':bits-kept,
+        'recovery_with_quotient_side_information_exact':side_exact,
+    }
+
+
+def product_diagnostic(bits: int) -> dict[str, Any]:
+    """Read-only local product feature. The scientific claim remains scope-limited."""
+    return {
+        'schema':'invariant-os-afc-finite-diagnostic/4',
+        'experiment':'afc_finite_limits',
+        'research_programme':'AFC',
+        'implementation':'DIRECT_FINITE_ALGORITHM_PORT',
+        'scientific_validation':'SOURCE_BOUNDED_FINITE_ONLY',
+        'source_zip_sha256':ORIGINAL_PHASE_I_ZIP_SHA256,
+        'source_result_sha256':ORIGINAL_RESULT_MEMBER_SHA256,
+        'result':finite_report(bits),
+        'claim_boundary':CLAIM_BOUNDARY,
+        'clinical_validation':False,
+        'universal_physical_law':False,
+        'physical_hardware_test':False,
+    }

source/icl/runtime.py

@@ -0,0 +1,197 @@
+"""Primitive numeric/metadata registry shared by independent execution engines.
+No I/O, FFI, shell, eval or dynamic import is exposed by the language.
+"""
+import hashlib,json,math,operator
+
+class ICLError(Exception):
+    def __init__(self,code,message,span=None):
+        self.code=code;self.message=message;self.span=span
+        super().__init__(f'{code}: {message}')
+    def as_dict(self):return {'code':self.code,'message':self.message,'span':self.span}
+
+def canonical(x):return json.dumps(x,sort_keys=True,separators=(',',':'),ensure_ascii=False,allow_nan=False)
+def digest(x):return hashlib.sha256(canonical(x).encode()).hexdigest()
+DEFAULT_LIMITS={'max_steps':100000,'max_stack':128,'max_items':100000,'max_output':1000000,'max_tensor':4096}
+class RuntimeContext:
+    def __init__(self,limits=None,policy=None):
+        self.limits=dict(DEFAULT_LIMITS)
+        if limits:
+            for k,v in limits.items():
+                if k not in self.limits or type(v)!=int or v<1 or v>DEFAULT_LIMITS[k]:raise ICLError('RESOURCE_POLICY','limits may only reduce defaults')
+                self.limits[k]=v
+        self.policy={} if policy is None else policy
+        if not isinstance(self.policy,dict):raise ICLError('RESOURCE_POLICY','policy must be object')
+        for action,permission in self.policy.items():
+            if not isinstance(action,str) or not isinstance(permission,dict) or set(permission)-{'allow','human_required','human_approved'}:raise ICLError('RESOURCE_POLICY','invalid policy descriptor')
+            if any(type(v)!=bool for v in permission.values()):raise ICLError('RESOURCE_POLICY','policy flags require strict booleans')
+        self.steps=0;self.trace=[];self.effects=[];self.prng=1
+    def step(self,op='',inputs=None,output=None):
+        self.steps+=1
+        if self.steps>self.limits['max_steps']:raise ICLError('FUEL_EXHAUSTED','step budget exceeded')
+        self.trace.append({'run_id':'deterministic','step':self.steps,'op_id':op,'input_hash':digest(inputs),'output_hash':digest(output),'state_ref':None,'effect_request':None,'effect_decision':None,'recovery_ref':None,'error_code':None,'clock_mode':'logical'})
+    def check_value(self,value):
+        count=0
+        def walk(v,depth=0):
+            nonlocal count
+            count+=1
+            if depth>128 or count>self.limits['max_items']:raise ICLError('MEMORY_LIMIT','value size/depth limit')
+            if isinstance(v,(list,tuple)):
+                for x in v:walk(x,depth+1)
+            elif isinstance(v,dict):
+                for x in v.values():walk(x,depth+1)
+            elif isinstance(v,float) and not math.isfinite(v):raise ICLError('NONFINITE','NaN/Inf forbidden')
+            elif type(v)==int and not -(1<<63)<=v<(1<<63):raise ICLError('OVERFLOW','Int64 overflow')
+            elif isinstance(v,str) and len(v.encode())>self.limits['max_output']:raise ICLError('OUTPUT_LIMIT','string too large')
+        walk(value)
+        if len(canonical(value).encode())>self.limits['max_output']:raise ICLError('OUTPUT_LIMIT','serialized value too large')
+        return value
+
+def checked_num(v):
+    if type(v)==int and not -(1<<63)<=v<(1<<63):raise ICLError('OVERFLOW','Int64 overflow')
+    if isinstance(v,float) and not math.isfinite(v):raise ICLError('NONFINITE','NaN/Inf forbidden')
+    return v
+
+def checked_binary(op,a,b):
+    if op in ('&&','||'):
+        if type(a)!=bool or type(b)!=bool:raise ICLError('TYPE','Bool operands required')
+        return a and b if op=='&&' else a or b
+    if op in ('==','!='):
+        if type(a)!=type(b):raise ICLError('TYPE','same types required')
+        return a==b if op=='==' else a!=b
+    if op in ('<','<=','>','>='):
+        if type(a) not in (int,float,str) or type(a)!=type(b):raise ICLError('TYPE','homogeneous ordered scalar operands required')
+        return {'<':operator.lt,'<=':operator.le,'>':operator.gt,'>=':operator.ge}[op](a,b)
+    if op=='+' and type(a)==type(b)==str:return a+b
+    if type(a) not in (int,float) or type(a)!=type(b):raise ICLError('TYPE','homogeneous numeric operands required')
+    if op in ('/','%') and b==0:raise ICLError('DIVISION_BY_ZERO','zero divisor')
+    if op=='+':v=a+b
+    elif op=='-':v=a-b
+    elif op=='*':v=a*b
+    elif op=='/':v=(abs(a)//abs(b))*(-1 if (a<0)!=(b<0) else 1) if type(a)==int else a/b
+    elif op=='%':v=a-((abs(a)//abs(b))*(-1 if (a<0)!=(b<0) else 1))*b if type(a)==int else math.fmod(a,b)
+    else:raise ICLError('UNSUPPORTED_OP',op)
+    return checked_num(v)
+def checked_unary(op,a):
+    if op=='!' and type(a)==bool:return not a
+    if op=='-' and type(a) in (int,float):return checked_num(-a)
+    raise ICLError('TYPE','invalid unary operand')
+
+def tensor(data,shape,ctx):
+    if not isinstance(shape,list) or not 1<=len(shape)<=3 or any(type(x)!=int or x<1 for x in shape):raise ICLError('SHAPE','rank 1..3, positive dimensions required')
+    n=math.prod(shape)
+    if n>ctx.limits['max_tensor']:raise ICLError('TENSOR_LIMIT','tensor element limit')
+    if not isinstance(data,list) or n!=len(data):raise ICLError('SHAPE','data length mismatch')
+    if any(type(x)!=float or not math.isfinite(x) for x in data):raise ICLError('TYPE','finite Float64 tensor data required')
+    return {'shape':shape[:],'data':data[:]}
+def istensor(x):return isinstance(x,dict) and set(x)=={'shape','data'}
+def validate_tensor(x,ctx):
+    if not istensor(x):raise ICLError('TYPE','Tensor required')
+    return tensor(x['data'],x['shape'],ctx)
+
+def _builtin(name,args,ctx):
+    def n(count):
+        if len(args)!=count:raise ICLError('TYPE',f'{name} expects {count} arguments')
+    if name=='len':n(1);return len(args[0])
+    if name=='abs':n(1);return checked_num(abs(args[0]))
+    if name in ('min','max'):n(2);return min(args) if name=='min' else max(args)
+    if name=='to_float':n(1);return float(args[0])
+    if name=='tensor':n(2);return tensor(args[0],args[1],ctx)
+    if name in ('matmul','add','sub','mul'):
+        n(2);a,b=[validate_tensor(x,ctx) for x in args]
+        if name=='matmul':
+            if len(a['shape'])!=2 or len(b['shape'])!=2 or a['shape'][1]!=b['shape'][0]:raise ICLError('SHAPE','matmul dimensions')
+            m,k=a['shape'];_,p=b['shape']
+            if m*p>ctx.limits['max_tensor']:raise ICLError('TENSOR_LIMIT','matmul output exceeds tensor limit before allocation')
+            return tensor([float(sum(a['data'][i*k+t]*b['data'][t*p+j] for t in range(k))) for i in range(m) for j in range(p)],[m,p],ctx)
+        if a['shape']!=b['shape']:raise ICLError('SHAPE','elementwise shapes differ')
+        op={'add':operator.add,'sub':operator.sub,'mul':operator.mul}[name]
+        return tensor([op(x,y) for x,y in zip(a['data'],b['data'])],a['shape'],ctx)
+    if name in ('relu','tanh','normalize','softmax'):
+        n(1);a=validate_tensor(args[0],ctx);d=a['data'];w=a['shape'][-1]
+        if name=='relu':d=[max(0.0,x) for x in d]
+        elif name=='tanh':d=[math.tanh(x) for x in d]
+        else:
+            out=[]
+            for j in range(0,len(d),w):
+                r=d[j:j+w]
+                if name=='softmax':z=[math.exp(x-max(r)) for x in r];s=sum(z);out.extend(x/s for x in z)
+                else:
+                    mean=checked_num(sum(r)/w)
+                    var=checked_num(sum((x-mean)**2 for x in r)/w)
+                    out.extend((x-mean)/math.sqrt(var+1e-5) for x in r)
+            d=out
+        return tensor(d,a['shape'],ctx)
+    if name=='reshape':n(2);a=validate_tensor(args[0],ctx);return tensor(a['data'],args[1],ctx)
+    if name=='sum':n(1);a=validate_tensor(args[0],ctx);return checked_num(float(sum(a['data'])))
+    if name=='some':n(1);return {'tag':'Some','value':args[0]}
+    if name=='none_int':n(0);return {'tag':'None','value':None}
+    if name=='ok':n(1);return {'tag':'Ok','value':args[0]}
+    if name=='err_int':n(1);return {'tag':'Err','error':args[0]}
+    if name=='unwrap':
+        n(1);a=args[0]
+        if a.get('tag') not in ('Some','Ok'):raise ICLError('UNWRAP','empty/Err cannot unwrap')
+        return a['value']
+    if name=='is_some':n(1);return args[0]['tag']=='Some'
+    if name=='observer':n(1);return {'tag':'Observer','id':args[0]}
+    if name=='context':n(2);return {'tag':'Context','frame':args[0],'unit':args[1]}
+    if name=='provenance':n(1);return {'tag':'ProvenanceRef','source_id':args[0],'verified':False}
+    if name=='represent':
+        n(4);v,o,f,u=args
+        return {'tag':'Representation','value':v,'observer':o,'frame':f,'unit':u,'source_hash':digest(v),'provenance':{'status':'LOCAL_COMPUTATION','claim':'hash_is_integrity_only'}}
+    if name=='repr_value':n(1);return args[0]['value']
+    if name=='repr_add':
+        n(2);a,b=args
+        for field,code in [('observer','OBSERVER_MISMATCH'),('frame','FRAME_MISMATCH'),('unit','UNIT_MISMATCH')]:
+            if a[field]!=b[field]:raise ICLError(code,field+' mismatch; explicit conversion required')
+        return builtin('represent',[checked_binary('+',a['value'],b['value']),a['observer'],a['frame'],a['unit']],ctx)
+    if name=='convert_frame':
+        n(4);r,new,offset,protocol=args
+        if protocol!='affine_translation_v1':raise ICLError('NEEDS_EVIDENCE','unregistered transform protocol')
+        out=builtin('represent',[checked_binary('+',r['value'],offset),r['observer'],new,r['unit']],ctx)
+        out['provenance']={'source_hash':digest(r),'protocol':protocol,'offset':offset};return out
+    if name=='observe_mod':
+        n(3);x,m,o=args
+        if m<=0:raise ICLError('DOMAIN','positive modulus required')
+        r=builtin('represent',[x%m,o,'scalar','dimensionless'],ctx);r['modulus']=m;r['source_hash']=None;r['ambiguous']=True;return r
+    if name=='make_witness':
+        n(2);x,m=args
+        if m<=0:raise ICLError('DOMAIN','positive modulus required')
+        payload={'tag':'RecoveryWitness','quotient':x//m,'modulus':m,'remainder':x%m};payload['sha256']=digest(payload);payload['payload_bytes']=len(canonical(payload).encode());return payload
+    if name=='recover':
+        n(2);r,w=args
+        if w.get('tag')!='RecoveryWitness':raise ICLError('WITNESS_MISSING','witness required')
+        p={k:w[k] for k in ('tag','quotient','modulus','remainder')}
+        if digest(p)!=w.get('sha256'):raise ICLError('WITNESS_CORRUPT','witness checksum')
+        if r.get('modulus')!=w['modulus'] or r['value']!=w['remainder']:raise ICLError('WITNESS_CORRUPT','witness measurement mismatch')
+        return {'tag':'Exact','value':checked_num(w['quotient']*w['modulus']+w['remainder']),'witness_bytes':w['payload_bytes'],'scope':'declared_integer_modulo_protocol'}
+    if name=='recover_without_witness':n(1);raise ICLError('NON_IDENTIFIABLE','measurement has multiple compatible sources')
+    if name=='exact_value':n(1);return args[0]['value']
+    if name=='approx':
+        n(2)
+        if args[1]<0:raise ICLError('DOMAIN','nonnegative error bound required')
+        return {'tag':'Approx','value':args[0],'error_bound':args[1]}
+    if name=='approx_value':n(1);return args[0]['value']
+    if name=='request_effect':
+        n(2);action,payload=args;permission=ctx.policy.get(action,{})
+        allowed=action=='journal' and permission.get('allow') is True
+        if permission.get('human_required') is True and permission.get('human_approved') is not True:allowed=False;code='HUMAN_APPROVAL_REQUIRED'
+        else:code='EFFECT_DENIED'
+        event={'action':action,'payload_hash':digest(payload),'decision':'ALLOWED_LOCAL_JOURNAL' if allowed else 'DENIED','external_executed':False}
+        ctx.effects.append(event)
+        if not allowed:raise ICLError(code,'trusted host policy denied action')
+        return True
+    if name=='random_int':
+        n(1)
+        if args[0]<=0:raise ICLError('DOMAIN','positive PRNG range')
+        ctx.prng=(1103515245*ctx.prng+12345)%(1<<31);return ctx.prng%args[0]
+    raise ICLError('NAME','unknown builtin '+name)
+
+def builtin(name,args,ctx):
+    """Convert host primitive failures into bounded language diagnostics."""
+    try:return _builtin(name,args,ctx)
+    except (OverflowError,ZeroDivisionError):
+        raise ICLError('NONFINITE','numeric primitive overflow or undefined finite result') from None
+    except (TypeError,ValueError,KeyError,IndexError,AttributeError):
+        raise ICLError('TYPE','malformed primitive input for '+str(name)) from None
+
+BUILTINS={'len','abs','min','max','to_float','tensor','matmul','add','sub','mul','relu','tanh','normalize','softmax','reshape','sum','some','none_int','ok','err_int','unwrap','is_some','observer','context','provenance','represent','repr_value','repr_add','convert_frame','observe_mod','make_witness','recover','recover_without_witness','exact_value','approx','approx_value','request_effect','random_int'}

source/icl/vm.py

@@ -0,0 +1,511 @@
+"""ICL bytecode compiler and independent stack interpreter.
+
+This backend shares scalar arithmetic, builtins, and resource accounting with
+the tree interpreter; it does not call the tree interpreter or execute Python
+source. Checkpoint hashes detect accidental modification, not adversarial
+forgery: they are unkeyed checksums and confer no trust or authority.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from copy import deepcopy
+
+from .runtime import ICLError, RuntimeContext, builtin, checked_binary, checked_unary, DEFAULT_LIMITS
+from .checker import valid_type, validate_value
+
+BYTECODE_SCHEMA = "icl-bytecode/1"
+CHECKPOINT_SCHEMA = "icl-vm-checkpoint/1"
+OPCODES = {"PUSH", "LOAD", "LET", "STORE", "POP", "BINARY", "UNARY", "CALL",
+           "LIST", "TUPLE", "RECORD", "INDEX", "FIELD", "JUMP", "JUMP_FALSE",
+           "LOOP_RESET", "LOOP_GUARD", "ENTER_SCOPE", "EXIT_SCOPE", "RETURN"}
+_DEFAULT_LIMITS = dict(DEFAULT_LIMITS)
+
+
+def _fail(code, message, span=None):
+    code = {"E_BYTECODE": "BYTECODE_CORRUPT", "E_CHECKPOINT": "CHECKPOINT_CORRUPT",
+            "E_LIMIT": "MEMORY_LIMIT", "E_NUMERIC": "NONFINITE", "E_VALUE": "TYPE",
+            "E_TYPE": "TYPE", "E_ENTRY": "NAME", "E_NAME": "NAME", "E_ARITY": "TYPE",
+            "E_IMMUTABLE": "IMMUTABLE", "E_INDEX": "BOUNDS", "E_FIELD": "TYPE"}.get(code, code)
+    raise ICLError(code, message, span)
+
+
+def _canonical(value):
+    try:
+        return json.dumps(value, sort_keys=True, separators=(",", ":"),
+                          ensure_ascii=False, allow_nan=False)
+    except (TypeError, ValueError, RecursionError):
+        _fail("E_BYTECODE", "Value is not finite canonical JSON")
+
+
+def _hash(value):
+    return hashlib.sha256(_canonical(value).encode("utf-8")).hexdigest()
+
+
+def compile_bytecode(program):
+    """Lower a checked ICL AST to a JSON-serializable instruction stream."""
+    functions = {}
+    for function in program.get("functions", []):
+        name = function["name"]
+        if name in functions:
+            _fail("E_BYTECODE", "Duplicate function: " + name)
+        code = []
+        loop_sequence = [0]
+
+        def emit(op, span=None, **kwargs):
+            index = len(code)
+            code.append({"op": op, **kwargs, "span": span or function.get("span")})
+            return index
+
+        def expr(node):
+            kind = node["kind"]
+            span = node.get("span")
+            if kind == "literal":
+                emit("PUSH", span, value=node["value"])
+            elif kind == "var":
+                emit("LOAD", span, name=node["name"])
+            elif kind == "binary":
+                # Preserve short-circuit evaluation without calling AST eval.
+                if node["op"] in ("&&", "and"):
+                    expr(node["left"])
+                    branch = emit("JUMP_FALSE", span, target=0)
+                    expr(node["right"])
+                    finish = emit("JUMP", span, target=0)
+                    code[branch]["target"] = len(code)
+                    emit("PUSH", span, value=False)
+                    code[finish]["target"] = len(code)
+                elif node["op"] in ("||", "or"):
+                    expr(node["left"])
+                    branch = emit("JUMP_FALSE", span, target=0)
+                    emit("PUSH", span, value=True)
+                    finish = emit("JUMP", span, target=0)
+                    code[branch]["target"] = len(code)
+                    expr(node["right"])
+                    code[finish]["target"] = len(code)
+                else:
+                    expr(node["left"])
+                    expr(node["right"])
+                    emit("BINARY", span, operator=node["op"])
+            elif kind == "unary":
+                operand = node["expr"]
+                if node["op"] == "-" and operand["kind"] == "literal" and type(operand["value"]) is int and operand["value"] == 1 << 63:
+                    emit("PUSH", span, value=-(1 << 63))
+                else:
+                    expr(operand)
+                    emit("UNARY", span, operator=node["op"])
+            elif kind == "call":
+                for argument in node["args"]:
+                    expr(argument)
+                emit("CALL", span, name=node["name"], argc=len(node["args"]))
+            elif kind in ("list", "tuple"):
+                for item in node["items"]:
+                    expr(item)
+                emit(kind.upper(), span, count=len(node["items"]))
+            elif kind == "record":
+                ordered_fields = sorted(node["fields"])
+                for name in ordered_fields:
+                    expr(node["fields"][name])
+                emit("RECORD", span, fields=ordered_fields)
+            elif kind == "index":
+                expr(node["target"])
+                expr(node["index"])
+                emit("INDEX", span)
+            elif kind == "field":
+                expr(node["target"])
+                emit("FIELD", span, name=node["name"])
+            else:
+                _fail("E_BYTECODE", "Unsupported expression: " + str(kind), span)
+
+        def statements(nodes, scoped=False):
+            if scoped:
+                emit("ENTER_SCOPE")
+            for node in nodes:
+                kind, span = node["kind"], node.get("span")
+                if kind == "let":
+                    expr(node["expr"])
+                    emit("LET", span, name=node["name"], mutable=node.get("mutable", False))
+                elif kind == "assign":
+                    expr(node["expr"])
+                    emit("STORE", span, name=node["name"])
+                elif kind == "return":
+                    expr(node["expr"]) if node.get("expr") is not None else emit("PUSH", span, value=None)
+                    emit("RETURN", span)
+                elif kind == "expr":
+                    expr(node["expr"])
+                    emit("POP", span)
+                elif kind == "if":
+                    expr(node["cond"])
+                    branch = emit("JUMP_FALSE", span, target=0)
+                    statements(node["then"], scoped=True)
+                    finish = emit("JUMP", span, target=0)
+                    code[branch]["target"] = len(code)
+                    statements(node.get("else", []), scoped=True)
+                    code[finish]["target"] = len(code)
+                elif kind == "while":
+                    loop_sequence[0] += 1
+                    key = str(loop_sequence[0])
+                    emit("LOOP_RESET", span, key=key)
+                    start = len(code)
+                    expr(node["cond"])
+                    branch = emit("JUMP_FALSE", span, target=0)
+                    emit("LOOP_GUARD", span, key=key, limit=node["limit"])
+                    statements(node["body"], scoped=True)
+                    emit("JUMP", span, target=start)
+                    code[branch]["target"] = len(code)
+                else:
+                    _fail("E_BYTECODE", "Unsupported statement: " + str(kind), span)
+            if scoped:
+                emit("EXIT_SCOPE")
+
+        # Parameters occupy the call frame; the function body is a child lexical
+        # scope, matching the source rule that a body local may shadow a parameter.
+        statements(function["body"], scoped=True)
+        emit("PUSH", value=None)
+        emit("RETURN")
+        functions[name] = {"params": function["params"], "return_type": function["return_type"],
+                           "code": code}
+    result = {"schema": BYTECODE_SCHEMA, "module": program.get("module", "main"), "functions": functions}
+    validate_bytecode(result)
+    return result
+
+
+def _integer(value, lower=0, upper=10000000):
+    return type(value) is int and lower <= value <= upper
+
+
+def _validate_bytecode_impl(bytecode):
+    """Fail closed on malformed code before executing any instruction."""
+    if not isinstance(bytecode, dict) or bytecode.get("schema") != BYTECODE_SCHEMA:
+        _fail("E_BYTECODE", "Unsupported bytecode schema")
+    if len(_canonical(bytecode)) > 20000000:
+        _fail("E_BYTECODE", "Bytecode exceeds serialized size limit")
+    functions = bytecode.get("functions")
+    if not isinstance(functions, dict) or not functions or len(functions) > 10000:
+        _fail("E_BYTECODE", "Invalid function table")
+    for name, function in functions.items():
+        if not isinstance(name, str) or not name or not isinstance(function, dict):
+            _fail("E_BYTECODE", "Invalid function descriptor")
+        params, code = function.get("params"), function.get("code")
+        if not isinstance(params, list) or any(not isinstance(p, (list, tuple)) or len(p) != 2
+             or not isinstance(p[0], str) or not isinstance(p[1], str) for p in params):
+            _fail("E_BYTECODE", "Invalid parameter table")
+        if len({p[0] for p in params}) != len(params):
+            _fail("E_BYTECODE", "Duplicate parameter")
+        if any(not valid_type(p[1]) for p in params) or not isinstance(function.get("return_type"), str) or not valid_type(function["return_type"]):
+            _fail("E_BYTECODE", "Invalid function type signature")
+        if not isinstance(code, list) or not code or len(code) > 1000000:
+            _fail("E_BYTECODE", "Invalid instruction stream")
+        for instruction in code:
+            if not isinstance(instruction, dict) or not isinstance(instruction.get("op"), str) or instruction["op"] not in OPCODES:
+                _fail("E_BYTECODE", "Unknown or malformed opcode")
+            op = instruction["op"]
+            if op in {"LOAD", "LET", "STORE", "CALL", "FIELD"} and not isinstance(instruction.get("name"), str):
+                _fail("E_BYTECODE", "Invalid identifier operand")
+            if op == "PUSH" and "value" not in instruction:
+                _fail("E_BYTECODE", "Missing literal operand")
+            if op == "LET" and type(instruction.get("mutable")) is not bool:
+                _fail("E_BYTECODE", "Invalid mutability operand")
+            if op in {"LIST", "TUPLE"} and not _integer(instruction.get("count")):
+                _fail("E_BYTECODE", "Invalid collection size")
+            if op == "CALL" and not _integer(instruction.get("argc")):
+                _fail("E_BYTECODE", "Invalid argument count")
+            if op == "RECORD" and (not isinstance(instruction.get("fields"), list)
+                    or any(not isinstance(k, str) for k in instruction["fields"])
+                    or len(instruction["fields"]) != len(set(instruction["fields"]))):
+                _fail("E_BYTECODE", "Invalid record fields")
+            if op in {"JUMP", "JUMP_FALSE"} and not _integer(instruction.get("target"), 0, len(code) - 1):
+                _fail("E_BYTECODE", "Jump target outside instruction stream")
+            if op == "BINARY" and (not isinstance(instruction.get("operator"), str) or instruction["operator"] not in {"+", "-", "*", "/", "%", "==", "!=", "<", "<=", ">", ">=", "&&", "||"}):
+                _fail("E_BYTECODE", "Invalid binary operator")
+            if op == "UNARY" and (not isinstance(instruction.get("operator"), str) or instruction["operator"] not in {"-", "!"}):
+                _fail("E_BYTECODE", "Invalid unary operator")
+            if op in {"LOOP_RESET", "LOOP_GUARD"} and not isinstance(instruction.get("key"), str):
+                _fail("E_BYTECODE", "Invalid loop key")
+            if op == "LOOP_GUARD" and not _integer(instruction.get("limit"), 0):
+                _fail("E_BYTECODE", "Invalid loop limit")
+    return True
+
+
+def validate_bytecode(bytecode):
+    """Validate untrusted JSON data and expose only deterministic ICL errors."""
+    try:
+        return _validate_bytecode_impl(bytecode)
+    except ICLError:
+        raise
+    except (TypeError, KeyError, IndexError, ValueError, AttributeError, RecursionError):
+        raise ICLError("BYTECODE_CORRUPT", "Malformed bytecode descriptor") from None
+
+
+def _normalized_limits(limits):
+    result = dict(_DEFAULT_LIMITS)
+    if limits:
+        for key, value in limits.items():
+            if key not in result or not _integer(value, 1, result[key]):
+                _fail("RESOURCE_POLICY", "Invalid resource limit: " + str(key))
+            result[key] = value
+    return result
+
+
+def _validate_value(value, limits, depth=0, budget=None):
+    if budget is None:
+        budget = [limits["max_items"]]
+    budget[0] -= 1
+    if budget[0] < 0 or depth > 128:
+        _fail("E_LIMIT", "Value exceeds collection or nesting limit")
+    if type(value) is int and not -(1 << 63) <= value < (1 << 63):
+        _fail("OVERFLOW", "Int64 overflow")
+    if value is None or type(value) in (bool, int):
+        return
+    if type(value) is float:
+        if not math.isfinite(value):
+            _fail("E_NUMERIC", "Non-finite floating-point value")
+        return
+    if isinstance(value, str):
+        if len(value) > limits["max_output"]:
+            _fail("E_LIMIT", "String exceeds output limit")
+        return
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            _validate_value(item, limits, depth + 1, budget)
+        return
+    if isinstance(value, dict) and all(isinstance(k, str) for k in value):
+        for item in value.values():
+            _validate_value(item, limits, depth + 1, budget)
+        return
+    _fail("E_VALUE", "Unsupported runtime value")
+
+
+def _new_frame(name, args, functions, ctx):
+    params = functions[name]["params"]
+    if len(args) != len(params):
+        _fail("E_ARITY", "Wrong argument count for " + name)
+    for (_, typ), value in zip(params, args):
+        validate_value(value, typ, ctx)
+    scope = {"locals": {p[0]: deepcopy(v) for p, v in zip(params, args)},
+             "mutable": {p[0]: False for p in params}}
+    return {"function": name, "pc": 0, "scopes": [scope], "stack": [], "loops": {}}
+
+
+def _execute_bytecode(bytecode, entry="main", args=None, limits=None, policy=None,
+                     checkpoint=None, stop_after=None):
+    """Execute, pause, or resume verified bytecode. No ambient I/O is available."""
+    validate_bytecode(bytecode)
+    functions = bytecode["functions"]
+    limits = _normalized_limits(limits)
+    # Authority always comes from this trusted host argument, including replay.
+    # A checkpoint is data with an unkeyed checksum, never an authorization token.
+    policy = {} if policy is None else policy
+    if not isinstance(policy, dict):
+        _fail("RESOURCE_POLICY", "Host policy must be an object")
+    if stop_after is not None and not _integer(stop_after, 0):
+        _fail("E_LIMIT", "stop_after must be a nonnegative integer")
+    if checkpoint is not None:
+        if not isinstance(checkpoint, dict) or checkpoint.get("schema") != CHECKPOINT_SCHEMA:
+            _fail("E_CHECKPOINT", "Unsupported checkpoint schema")
+        payload = {k: v for k, v in checkpoint.items() if k != "integrity"}
+        if checkpoint.get("integrity") != _hash(payload) or checkpoint.get("bytecode_hash") != _hash(bytecode):
+            _fail("E_CHECKPOINT", "Checkpoint integrity or bytecode identity mismatch")
+        if len(_canonical(checkpoint)) > 20000000:
+            _fail("E_CHECKPOINT", "Checkpoint too large")
+        previous_limits = _normalized_limits(checkpoint.get("limits"))
+        limits = {k: min(v, previous_limits[k]) for k, v in limits.items()}
+        prior_policy = checkpoint.get("policy")
+        if policy != prior_policy:
+            _fail("E_CHECKPOINT", "Replay requires an independently supplied identical host policy")
+    ctx = RuntimeContext(limits=limits, policy=policy)
+    if checkpoint is None:
+        if entry not in functions:
+            _fail("E_ENTRY", "Unknown entry function: " + entry)
+        args = [] if args is None else args
+        if not isinstance(args, list):
+            _fail("E_ARITY", "Entry arguments must be a list")
+        _validate_value(args, limits)
+        frames = [_new_frame(entry, args, functions, ctx)]
+    else:
+        frames = deepcopy(checkpoint.get("frames"))
+        steps, trace, effects = checkpoint.get("steps"), checkpoint.get("trace"), checkpoint.get("effects")
+        if not _integer(steps, 0, limits["max_steps"]) or not isinstance(trace, list) or not isinstance(effects, list):
+            _fail("E_CHECKPOINT", "Malformed checkpoint accounting")
+        if not isinstance(frames, list) or not frames or len(frames) > limits["max_stack"]:
+            _fail("E_CHECKPOINT", "Malformed checkpoint frame stack")
+        for frame in frames:
+            if not isinstance(frame, dict) or frame.get("function") not in functions:
+                _fail("E_CHECKPOINT", "Unknown checkpoint function")
+            if not _integer(frame.get("pc"), 0, len(functions[frame["function"]]["code"]) - 1):
+                _fail("E_CHECKPOINT", "Invalid checkpoint instruction pointer")
+            if not isinstance(frame.get("scopes"), list) or not frame["scopes"] or not isinstance(frame.get("stack"), list):
+                _fail("E_CHECKPOINT", "Invalid checkpoint values")
+            if len(frame["scopes"]) > limits["max_steps"] + 1:
+                _fail("E_CHECKPOINT", "Too many lexical scopes")
+            for scope in frame["scopes"]:
+                if not isinstance(scope, dict) or not isinstance(scope.get("locals"), dict) or not isinstance(scope.get("mutable"), dict) or set(scope["mutable"]) != set(scope["locals"]) or any(type(v) is not bool for v in scope["mutable"].values()):
+                    _fail("E_CHECKPOINT", "Invalid checkpoint mutability table")
+                _validate_value(scope["locals"], limits)
+            if not isinstance(frame.get("loops"), dict) or any(not _integer(v) for v in frame["loops"].values()):
+                _fail("E_CHECKPOINT", "Invalid checkpoint loop counters")
+            _validate_value(frame["stack"], limits)
+        ctx.steps, ctx.trace, ctx.effects = steps, deepcopy(trace), deepcopy(effects)
+        if not _integer(checkpoint.get("prng"), 0, (1 << 31) - 1):
+            _fail("E_CHECKPOINT", "Invalid checkpoint PRNG state")
+        ctx.prng = checkpoint["prng"]
+    start_steps = ctx.steps
+
+    def result(value, paused=False):
+        output = {"value": value, "trace": ctx.trace, "effects": ctx.effects,
+                  "steps": ctx.steps, "halted": not paused}
+        if paused:
+            payload = {"schema": CHECKPOINT_SCHEMA, "bytecode_hash": _hash(bytecode),
+                       "frames": deepcopy(frames), "steps": ctx.steps, "trace": deepcopy(ctx.trace),
+                       "effects": deepcopy(ctx.effects), "limits": limits, "policy": ctx.policy,
+                       "prng": ctx.prng}
+            payload["integrity"] = _hash(payload)
+            output["checkpoint"] = payload
+        return output
+
+    while frames:
+        if stop_after is not None and ctx.steps - start_steps >= stop_after:
+            return result(None, True)
+        if len(frames) > limits["max_stack"]:
+            _fail("STACK_LIMIT", "VM call stack limit exceeded")
+        frame = frames[-1]
+        code = functions[frame["function"]]["code"]
+        if not 0 <= frame["pc"] < len(code):
+            _fail("E_BYTECODE", "Instruction pointer outside function")
+        instruction = code[frame["pc"]]
+        input_state = {"frames": frames, "prng": ctx.prng}
+        trace_index = len(ctx.trace)
+        effects_before = len(ctx.effects)
+        ctx.step("BC:" + instruction["op"], inputs=input_state)
+        frame["pc"] += 1
+        op, span, stack = instruction["op"], instruction.get("span"), frame["stack"]
+
+        def finish_trace(return_value=None, returning=False):
+            state = {"frames": frames, "prng": ctx.prng}
+            if returning:
+                state["return_value"] = return_value
+            event = ctx.trace[trace_index]
+            event["output_hash"] = _hash(state)
+            event["state_ref"] = event["output_hash"]
+            if len(ctx.effects) > effects_before:
+                effect = ctx.effects[-1]
+                event["effect_request"] = {"action": effect["action"], "payload_hash": effect["payload_hash"]}
+                event["effect_decision"] = effect["decision"]
+
+        def pop(count=1):
+            if len(stack) < count:
+                _fail("E_BYTECODE", "Operand stack underflow", span)
+            if count == 0:
+                return []
+            values = stack[-count:]
+            del stack[-count:]
+            return values
+
+        if op == "PUSH":
+            stack.append(deepcopy(instruction["value"]))
+        elif op == "LOAD":
+            name = instruction["name"]
+            scope = next((s for s in reversed(frame["scopes"]) if name in s["locals"]), None)
+            if scope is None:
+                _fail("E_NAME", "Undefined variable: " + name, span)
+            stack.append(deepcopy(scope["locals"][name]))
+        elif op == "LET":
+            name = instruction["name"]
+            scope = frame["scopes"][-1]
+            if name in scope["locals"]:
+                _fail("E_NAME", "Duplicate local declaration: " + name, span)
+            scope["locals"][name] = pop()[0]
+            scope["mutable"][name] = instruction["mutable"]
+        elif op == "STORE":
+            name = instruction["name"]
+            scope = next((s for s in reversed(frame["scopes"]) if name in s["locals"]), None)
+            if scope is None:
+                _fail("E_NAME", "Undefined variable: " + name, span)
+            if not scope["mutable"][name]:
+                _fail("E_IMMUTABLE", "Cannot assign immutable variable: " + name, span)
+            scope["locals"][name] = pop()[0]
+        elif op == "ENTER_SCOPE":
+            frame["scopes"].append({"locals": {}, "mutable": {}})
+        elif op == "EXIT_SCOPE":
+            if len(frame["scopes"]) <= 1:
+                _fail("E_BYTECODE", "Cannot exit function root scope", span)
+            frame["scopes"].pop()
+        elif op == "POP":
+            pop()
+        elif op == "BINARY":
+            a, b = pop(2)
+            stack.append(checked_binary(instruction["operator"], a, b))
+        elif op == "UNARY":
+            stack.append(checked_unary(instruction["operator"], pop()[0]))
+        elif op == "CALL":
+            arguments = pop(instruction["argc"])
+            name = instruction["name"]
+            if name in functions:
+                if len(frames) >= limits["max_stack"]:
+                    _fail("STACK_LIMIT", "VM call stack limit exceeded", span)
+                frames.append(_new_frame(name, arguments, functions, ctx))
+            else:
+                stack.append(builtin(name, arguments, ctx))
+        elif op in {"LIST", "TUPLE"}:
+            values = pop(instruction["count"])
+            stack.append(values)
+        elif op == "RECORD":
+            stack.append(dict(zip(instruction["fields"], pop(len(instruction["fields"])))))
+        elif op == "INDEX":
+            target, index = pop(2)
+            if not isinstance(target, (list, tuple, str)) or type(index) is not int or not 0 <= index < len(target):
+                _fail("E_INDEX", "Invalid or out-of-range index", span)
+            stack.append(target[index])
+        elif op == "FIELD":
+            target = pop()[0]
+            if not isinstance(target, dict) or instruction["name"] not in target:
+                _fail("E_FIELD", "Missing record field: " + instruction["name"], span)
+            stack.append(target[instruction["name"]])
+        elif op == "JUMP":
+            frame["pc"] = instruction["target"]
+        elif op == "JUMP_FALSE":
+            condition = pop()[0]
+            if type(condition) is not bool:
+                _fail("E_TYPE", "Branch condition must be Bool", span)
+            if not condition:
+                frame["pc"] = instruction["target"]
+        elif op == "LOOP_RESET":
+            frame["loops"][instruction["key"]] = 0
+        elif op == "LOOP_GUARD":
+            key = instruction["key"]
+            if key not in frame["loops"]:
+                _fail("E_BYTECODE", "Loop guard without reset", span)
+            frame["loops"][key] += 1
+            if frame["loops"][key] > instruction["limit"]:
+                _fail("LOOP_LIMIT", "Bounded loop limit exceeded", span)
+        elif op == "RETURN":
+            value = pop()[0]
+            validate_value(value, functions[frame["function"]]["return_type"], ctx)
+            if stack:
+                _fail("E_BYTECODE", "Unbalanced operand stack at return", span)
+            frames.pop()
+            if not frames:
+                _validate_value(value, limits)
+                finish_trace(value, returning=True)
+                return result(value)
+            frames[-1]["stack"].append(value)
+        if len(stack) > limits["max_items"]:
+            _fail("E_LIMIT", "VM operand stack limit exceeded", span)
+        if stack:
+            _validate_value(stack[-1], limits)
+            ctx.check_value(stack[-1])
+        finish_trace()
+    _fail("E_BYTECODE", "VM terminated without return")
+
+
+def execute_bytecode(bytecode, entry="main", args=None, limits=None, policy=None,
+                     checkpoint=None, stop_after=None):
+    """Public fail-closed boundary; malformed data cannot escape as host errors."""
+    try:
+        return _execute_bytecode(bytecode, entry, args, limits, policy, checkpoint, stop_after)
+    except ICLError:
+        raise
+    except (TypeError, KeyError, IndexError, ValueError, OverflowError, ZeroDivisionError, AttributeError) as error:
+        raise ICLError("TYPE", "Malformed bytecode operand or primitive argument: " + type(error).__name__) from None
+    except RecursionError:
+        raise ICLError("STACK_LIMIT", "Bytecode structure exceeds host recursion limit") from None

source/icl_native/__init__.py

@@ -0,0 +1,2 @@
+"""ICL R5 bounded learned action compiler, not a general language model."""
+__version__ = '0.1.0-r5'

source/icl_native/common.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+import hashlib,json,math,os
+from pathlib import Path
+from typing import Any
+ROOT=Path(__file__).resolve().parents[2]
+INTENTS=['increase','decrease','scale','floor','ceiling','magnitude','repeat','translate','restore','remember','recall','journal','conditional','record_add','list_add','axis_reverse']
+FLAGS=['observer_match','frame_match','unit_match','witness_present','witness_valid','memory_present','journal_allowed','condition']
+ERRORS=['OBSERVER_MISMATCH','FRAME_MISMATCH','UNIT_MISMATCH','NON_IDENTIFIABLE','WITNESS_CORRUPT','MEMORY_MISSING','EFFECT_DENIED']
+ACTIONS=['ADD','SUB','MUL','MAX','MIN','ABS','REPEAT','TRANSLATE','RESTORE','STORE','RECALL','JOURNAL','RECORD_ADD','LIST_ADD','NEGATE']+ERRORS
+FEATURE_NAMES=['intent:'+s for s in INTENTS]+['flag:'+s for s in FLAGS]+['nuisance:'+s for s in ['value','arg','modulus','parity','residue3','residue5']]
+D=len(FEATURE_NAMES);K=len(ACTIONS);H=32
+
+def canonical(x:Any)->str:return json.dumps(x,ensure_ascii=False,sort_keys=True,separators=(',',':'),allow_nan=False)
+def digest(x:Any)->str:return hashlib.sha256(canonical(x).encode()).hexdigest()
+def sha(p:Path)->str:return hashlib.sha256(p.read_bytes()).hexdigest()
+def dump(p:Path,x:Any)->None:p.parent.mkdir(parents=True,exist_ok=True);p.write_text(json.dumps(x,ensure_ascii=False,indent=2,allow_nan=False)+'\n')
+def strict_load(p:Path,max_bytes:int=8_000_000)->Any:
+    if p.stat().st_size>max_bytes:raise ValueError('INPUT_SIZE_LIMIT')
+    def pairs(xs):
+        d={}
+        for k,v in xs:
+            if k in d:raise ValueError('DUPLICATE_JSON_KEY')
+            d[k]=v
+        return d
+    def finite_float(s):
+        x=float(s)
+        if not math.isfinite(x):raise ValueError('NONFINITE')
+        return x
+    return json.loads(p.read_text(),object_pairs_hook=pairs,parse_float=finite_float,parse_constant=lambda _:(_ for _ in ()).throw(ValueError('NONFINITE')))
+
+def validate_step(s:dict)->None:
+    if type(s)!=dict or set(s)!={'intent','arg','modulus','flags'}:raise ValueError('STEP_SCHEMA')
+    if s['intent'] not in INTENTS:raise ValueError('UNSUPPORTED_INTENT')
+    if type(s['arg'])!=int or not -3<=s['arg']<=3:raise ValueError('ARG_RANGE')
+    if type(s['modulus'])!=int or not 2<=s['modulus']<=11:raise ValueError('MODULUS_RANGE')
+    if type(s['flags'])!=dict or set(s['flags'])!=set(FLAGS) or any(type(v)!=bool for v in s['flags'].values()):raise ValueError('FLAGS_SCHEMA')
+
+def features(s:dict,x:int,memory_present:bool)->list[float]:
+    f=dict(s['flags']);f['memory_present']=memory_present
+    return [float(s['intent']==i) for i in INTENTS]+[float(f[k]) for k in FLAGS]+[math.tanh(x/50),s['arg']/3,s['modulus']/11,float(x%2),x%3/2,x%5/4]
+
+def oracle_action(s:dict,memory_present:bool)->str:
+    """Supervision ONLY. Never called by production prediction or its encoder."""
+    i=s['intent'];f=s['flags']
+    if i=='translate':
+        for flag,err in [('observer_match','OBSERVER_MISMATCH'),('frame_match','FRAME_MISMATCH'),('unit_match','UNIT_MISMATCH')]:
+            if not f[flag]:return err
+    if i=='restore':
+        if not f['witness_present']:return 'NON_IDENTIFIABLE'
+        if not f['witness_valid']:return 'WITNESS_CORRUPT'
+    if i=='recall' and not memory_present:return 'MEMORY_MISSING'
+    if i=='journal' and not f['journal_allowed']:return 'EFFECT_DENIED'
+    if i=='conditional':return 'ADD' if f['condition'] else 'SUB'
+    return {'increase':'ADD','decrease':'SUB','scale':'MUL','floor':'MAX','ceiling':'MIN','magnitude':'ABS','repeat':'REPEAT','translate':'TRANSLATE','restore':'RESTORE','remember':'STORE','recall':'RECALL','journal':'JOURNAL','record_add':'RECORD_ADD','list_add':'LIST_ADD','axis_reverse':'NEGATE'}[i]
+
+def scalar_reference(action:str,x:int,a:int,memory:int|None)->tuple[int,int|None]:
+    """Independent finite arithmetic oracle, used only by datasets/evaluation."""
+    if action in ERRORS:return x,memory
+    if action in ('ADD','TRANSLATE','RECORD_ADD','LIST_ADD'):x+=a
+    elif action=='SUB':x-=a
+    elif action=='MUL':x*=a
+    elif action=='MAX':x=max(x,a)
+    elif action=='MIN':x=min(x,a)
+    elif action=='ABS':x=abs(x)
+    elif action=='REPEAT':x+=3*a
+    elif action=='NEGATE':x=-x
+    elif action=='STORE':memory=x
+    elif action=='RECALL':
+        if memory is None:raise ValueError('MEMORY_MISSING')
+        x=memory
+    elif action not in ('RESTORE','JOURNAL'):raise ValueError('UNSUPPORTED_ACTION')
+    if not -(1<<63)<=x<(1<<63):raise OverflowError('INT64')
+    return x,memory
+
+def target_steps(plan:dict):
+    x=plan['initial'];mem=plan['memory'];allfeat=[];labels=[];states=[];first_error=None;prefix=True
+    for i,s in enumerate(plan['steps']):
+        a=oracle_action(s,mem is not None);allfeat.append(features(s,x,mem is not None));labels.append(ACTIONS.index(a));states.append(x)
+        if a in ERRORS:
+            if first_error is None:first_error=(i,a)
+        else:x,mem=scalar_reference(a,x,s['arg'],mem)
+    # Actual program stops at its first error. Labels after it are auxiliary independent local supervision only.
+    if first_error:return allfeat,labels,{'tag':'Err','error':first_error[1]},first_error[0]+1,states
+    return allfeat,labels,{'tag':'Ok','value':x},len(labels),states

source/icl_native/emitter.py

@@ -0,0 +1,46 @@
+"""Deterministic, audited ICL code emitter. Syntax is supplied here, not learned.
+No oracle/ground-truth label is imported. Model actions alone select operations.
+"""
+from __future__ import annotations
+import json
+from .common import ACTIONS,ERRORS,validate_step
+HEADER='''module native_plan;
+type Pair = Record{delta:Int64,value:Int64};
+fn record_sum(p:Pair)->Int64 {return p.value+p.delta;}
+fn main(initial:Int64, initial_memory:Int64)->Result[Int64] {
+var x = initial; var memo = initial_memory;
+'''
+
+def emit(plan:dict,actions:list[str])->str:
+    if len(actions)!=len(plan['steps']) or not 1<=len(actions)<=32:raise ValueError('ACTION_LENGTH')
+    parts=[HEADER]
+    for j,(s,action) in enumerate(zip(plan['steps'],actions)):
+        validate_step(s)
+        if action not in ACTIONS:raise ValueError('ACTION_UNKNOWN')
+        a=s['arg'];lit=str(a);f=s['flags']
+        if action in ERRORS:
+            parts.append('return err_int('+json.dumps(action)+');');break
+        if action=='ADD':code=f'x=x+({lit});'
+        elif action=='SUB':code=f'x=x-({lit});'
+        elif action=='MUL':code=f'x=x*({lit});'
+        elif action=='MAX':code=f'x=max(x,({lit}));'
+        elif action=='MIN':code=f'x=min(x,({lit}));'
+        elif action=='ABS':code='x=abs(x);'
+        elif action=='NEGATE':code='x=-x;'
+        elif action=='REPEAT':code=f'var k{j}=0; while k{j}<3 limit 3 {{x=x+({lit}); k{j}=k{j}+1;}}'
+        elif action=='STORE':code='memo=x;'
+        elif action=='RECALL':code='x=memo;'
+        elif action=='JOURNAL':code=f'let permitted{j}=request_effect("journal","step_{j}");'
+        elif action=='RECORD_ADD':code=f'x=record_sum({{delta:({lit}),value:x}});'
+        elif action=='LIST_ADD':code=f'let items{j}=[x,({lit})]; x=items{j}[0]+items{j}[1];'
+        elif action=='TRANSLATE':
+            ob='main' if f['observer_match'] else 'other';fr='scalar' if f['frame_match'] else 'other';un='unit' if f['unit_match'] else 'other'
+            code=f'let left{j}=represent(x,"main","scalar","unit"); let right{j}=represent(({lit}),"{ob}","{fr}","{un}"); x=repr_value(repr_add(left{j},right{j}));'
+        elif action=='RESTORE':
+            # Synthetic known-state roundtrip: witness is made from x, not recovered from unknown data.
+            # The wrapper checks supplied boolean scenario conditions, NOT an external witness signature.
+            code=f'let r{j}=observe_mod(x,{s["modulus"]},"main"); let w{j}=make_witness(x,{s["modulus"]}); x=exact_value(recover(r{j},w{j}));'
+        else:raise ValueError('UNSUPPORTED_ACTION')
+        parts.append(code)
+    parts.append('return ok(x); }')
+    return '\n'.join(parts)+'\n'

source/icl_native/execution.py

@@ -0,0 +1,52 @@
+"""Pure deterministic control/verification. No trained model or teaching oracle here.
+These functions supply exact execution, not learned state prediction."""
+from .common import ERRORS,validate_step
+from .emitter import emit
+from icl.runtime import checked_binary,checked_unary,ICLError
+from icl.api import compile_source,run_ocir
+
+def validate_plan(p):
+    if type(p)!=dict or set(p)!={'initial','memory','steps'}:raise ValueError('PLAN_SCHEMA')
+    if type(p['initial'])!=int or not -100000<=p['initial']<=100000:raise ValueError('INITIAL_RANGE')
+    if p['memory'] is not None and (type(p['memory'])!=int or not -100000<=p['memory']<=100000):raise ValueError('MEMORY_RANGE')
+    if type(p['steps'])!=list or not 1<=len(p['steps'])<=32:raise ValueError('STEP_LIMIT')
+    for s in p['steps']:validate_step(s)
+
+def protocol_guard(action,s,memory,journal_permission):
+    """Trusted wrapper check; NEVER modifies a prediction or grants capability."""
+    f=s['flags']
+    if action=='TRANSLATE':
+        for field,error in [('observer_match','OBSERVER_MISMATCH'),('frame_match','FRAME_MISMATCH'),('unit_match','UNIT_MISMATCH')]:
+            if not f[field]:return error
+    if action=='RESTORE':
+        if not f['witness_present']:return 'NON_IDENTIFIABLE'
+        if not f['witness_valid']:return 'WITNESS_CORRUPT'
+    if action=='RECALL' and memory is None:return 'MEMORY_MISSING'
+    if action=='JOURNAL' and (journal_permission is not True or f['journal_allowed'] is not True):return 'EFFECT_DENIED'
+    return None
+
+def advance_runtime(action,x,a,memory):
+    """Normative runtime state transition using checked ICL primitives, not labels."""
+    if action in ('ADD','TRANSLATE','RECORD_ADD','LIST_ADD'):x=checked_binary('+',x,a)
+    elif action=='SUB':x=checked_binary('-',x,a)
+    elif action=='MUL':x=checked_binary('*',x,a)
+    elif action=='MAX':x=max(x,a)
+    elif action=='MIN':x=min(x,a)
+    elif action=='ABS':x=checked_unary('-',x) if x<0 else x
+    elif action=='NEGATE':x=checked_unary('-',x)
+    elif action=='REPEAT':
+        for _ in range(3):x=checked_binary('+',x,a)
+    elif action=='STORE':memory=x
+    elif action=='RECALL':
+        if memory is None:raise ValueError('MEMORY_MISSING')
+        x=memory
+    elif action not in ('RESTORE','JOURNAL'):raise ValueError('ACTION_UNKNOWN')
+    return x,memory
+
+def vm_verify(plan,pred,journal_permission=False,engine='vm'):
+    if pred['guard_rejection'] is not None:return {'executed':False,'reason':'INDEPENDENT_GUARD_REJECTED','raw_prediction_preserved':True}
+    actions=pred['actions']+[ERRORS[0]]*(len(plan['steps'])-len(pred['actions']))
+    src=emit(plan,actions);ocir=compile_source(src)
+    out=run_ocir(ocir,args=[plan['initial'],plan['memory'] or 0],engine=engine,policy={'journal':{'allow':journal_permission is True}})
+    return {'executed':True,'source_program':src,'ocir':ocir,'result':out,'runtime_consistency':out['value']==pred['composed_result']}
+

source/icl_native/offline_infer.py

@@ -0,0 +1,60 @@
+"""Standard-library inference with real trained weights evaluated by the ICL VM.
+No Torch, NumPy, network API, label oracle or training object is needed.
+The native model selects finite semantic opcodes, not unrestricted source text.
+"""
+from __future__ import annotations
+import argparse,copy,json,math,sys
+from pathlib import Path
+from .common import ACTIONS,ERRORS,FEATURE_NAMES,features,strict_load,dump,sha,canonical
+from .execution import validate_plan,protocol_guard,advance_runtime,vm_verify
+from icl.api import run_ocir,loads_ocir,SCHEMA_VERSION,SCHEMA_SHA256
+from icl.runtime import ICLError
+import icl
+SHAPES={'w1':[30,32],'b1':[1,32],'w2':[32,32],'b2':[1,32],'wo':[32,22],'bo':[1,22]}
+class OfflineModel:
+ def __init__(self,path:Path):
+  if not path.is_dir():raise ValueError('MODEL_NOT_LOADED')
+  man=strict_load(path/'manifest.json',200000)
+  if man.get('schema')!='ICL_R5_OFFLINE_BUNDLE/1' or set(man.get('files',{}))!={'weights.json','compiled_model.ocir','model.icl','model_config.json'}:raise ValueError('BUNDLE_SCHEMA')
+  for n,m in man['files'].items():
+   p=path/n
+   if p.is_symlink() or not p.is_file() or p.stat().st_size!=m['bytes'] or p.stat().st_size>2_000_000 or sha(p)!=m['sha256']:raise ValueError('MODEL_INTEGRITY')
+  core=Path(icl.__file__).parent
+  if set(man['runtime_file_hashes'])!={'__init__.py','__main__.py','api.py','checker.py','cli.py','frontend.py','interpreter.py','legacy_afc.py','runtime.py','vm.py','OCIR_SCHEMA.json','TOKEN_VOCAB.json'}:raise ValueError('RUNTIME_LOCK_SCHEMA')
+  if any(sha(core/n)!=h for n,h in man['runtime_file_hashes'].items()):raise ValueError('RUNTIME_INCOMPATIBLE')
+  cfg=strict_load(path/'model_config.json');self.cfg=cfg
+  if cfg['actions']!=ACTIONS or cfg['feature_names']!=FEATURE_NAMES or cfg['schema_version']!=SCHEMA_VERSION or cfg['schema_sha256']!=SCHEMA_SHA256:raise ValueError('MODEL_CONTRACT')
+  self.weights=strict_load(path/'weights.json',500000)
+  if set(self.weights)!=set(SHAPES):raise ValueError('WEIGHT_KEYS')
+  for k,v in self.weights.items():
+   if set(v)!={'shape','data'} or v['shape']!=SHAPES[k] or len(v['data'])!=math.prod(SHAPES[k]) or any(type(x) not in (float,int) or not math.isfinite(x) for x in v['data']):raise ValueError('WEIGHT_SHAPE_OR_FINITE')
+  self.graph=loads_ocir((path/'compiled_model.ocir').read_text())
+ def logits(self,row):
+  if len(row)!=30 or any(not math.isfinite(v) for v in row):raise ValueError('FEATURE_INPUT')
+  out=run_ocir(self.graph,args=[{'shape':[1,30],'data':row}]+[self.weights[k] for k in SHAPES],engine='vm')
+  return out['value']['data']
+ def predict(self,plan,journal_permission=False):
+  validate_plan(plan);x=plan['initial'];mem=plan['memory'];actions=[];conf=[];guard=None;result=None;attempts=0;allow=0
+  for j,s0 in enumerate(plan['steps']):
+   s=copy.deepcopy(s0);s['flags']['journal_allowed']=journal_permission is True and s['flags']['journal_allowed'] is True
+   logits=self.logits(features(s,x,mem is not None));m=max(logits);den=sum(math.exp(v-m) for v in logits);a=max(range(len(logits)),key=lambda k:logits[k]);act=ACTIONS[a]
+   actions.append(act);conf.append(math.exp(logits[a]-m)/den)
+   if act in ERRORS:result={'tag':'Err','error':act};break
+   if act=='JOURNAL':attempts+=1
+   err=protocol_guard(act,s0,mem,journal_permission)
+   if err:guard={'step':j,'reason':err};result={'tag':'Err','error':err};break
+   try:x,mem=advance_runtime(act,x,s0['arg'],mem)
+   except (ICLError,OverflowError,ValueError) as e:
+    reason=getattr(e,'code',str(e));guard={'step':j,'reason':reason};result={'tag':'Err','error':reason};break
+   if act=='JOURNAL':allow+=1
+  return {'actions':actions,'confidence':min(conf) if conf else 0.0,'composed_result':result or {'tag':'Ok','value':x},'guard_rejection':guard,'journal_attempts':attempts,'journal_allow_decisions':allow,'execution_scope':'host simulation until vm_verify executes the candidate'}
+def main(argv=None):
+ p=argparse.ArgumentParser();p.add_argument('--model',type=Path,required=True);p.add_argument('--request',type=Path,required=True);p.add_argument('--output',type=Path);p.add_argument('--permit-local-journal',action='store_true');a=p.parse_args(argv)
+ try:
+  m=OfflineModel(a.model);req=strict_load(a.request,100000);pred=m.predict(req,a.permit_local_journal);v=vm_verify(req,pred,a.permit_local_journal)
+  answer={'schema':'ICL_R5_PRODUCT_RESULT/1','model_seed':m.cfg['seed'],'proposal':pred,'verification':v,'scope':'finite structured intent -> learned opcode -> deterministic ICL code and VM','learned':'opcode and finite error-class decision','not_learned':'source syntax, composition control, exact arithmetic, authoritative permission, persistent memory','confidence_is_uncalibrated':True,'tensor_backend':'ICL VM pure Python float64','third_party_weights_used':False}
+  if a.output:dump(a.output,answer)
+  print(canonical(answer));return 0
+ except Exception as e:
+  print(canonical({'status':'ERROR','error_type':type(e).__name__,'reason':str(e)}),file=sys.stderr);return 2
+if __name__=='__main__':raise SystemExit(main())

validate.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+import sys,json
+R=Path(__file__).resolve().parent;sys.path.insert(0,str(R/'source'))
+from icl_native.offline_infer import OfflineModel
+from icl_native.execution import vm_verify
+m=OfflineModel(R/'model');checks=[]
+for name,expected in [('demo',{'tag':'Ok','value':-4}),('denied_journal',{'tag':'Err','error':'EFFECT_DENIED'}),('missing_witness',{'tag':'Err','error':'NON_IDENTIFIABLE'}),('wrong_observer',{'tag':'Err','error':'OBSERVER_MISMATCH'}),('missing_memory',{'tag':'Err','error':'MEMORY_MISSING'})]:
+ p=json.loads((R/'examples'/f'{name}.json').read_text());pr=m.predict(p);v=vm_verify(p,pr);assert v['executed'] and v['runtime_consistency'] and v['result']['value']==expected;checks.append({'case':name,'result':v['result']['value']})
+assert 'torch' not in sys.modules and 'numpy' not in sys.modules
+print(json.dumps({'status':'PASS','checks':checks,'n_checks':len(checks),'model_seed':17,'runtime':'Python standard library and bundled ICL VM','scope':'Five source examples, not a rerun of training/evaluation'},indent=2))