forge: ship REAL trained surrogate v1 for szl-formulas (model.joblib + receipt + scripts; honest card + provenance)

MODEL_PROVENANCE.json

@@ -3,10 +3,28 @@
   "model": {
     "id": "SZLHOLDINGS/szl-formulas",
     "repository_type": "model",
-    "artifact_kind": "kernel-code-and-configuration",
-    "trained_weights_present": false,
-    "stdlib_only": true,
-    "torch_required": false
+    "artifact_kind": "kernel-code-and-configuration + trained surrogate (model.joblib)",
+    "trained_weights_present": true,
+    "stdlib_only": false,
+    "torch_required": false,
+    "surrogate": {
+      "file": "model.joblib",
+      "sha256": "94cca70dc950fa957c0931ee80240c4369cab0ff8446ffbfedb483c3e2907698",
+      "role": "21-class formula identifier from call-trace observables \u2014 kernel remains sole ground truth",
+      "fidelity_MEASURED": {
+        "test_accuracy_21_class": 0.9709,
+        "mean_per_class_recall": 0.9709,
+        "blind_spot_classes_recall_lt_0.90": {
+          "bohr_complementarity_floor": 0.7778,
+          "fisher_rao_distance": 0.8889,
+          "pinsker_kl_bound": 0.8833,
+          "schur_concave_lambda_two_axis": 0.85
+        }
+      },
+      "receipt": "TRAINING_RECEIPT.json",
+      "reverify": "python scripts/eval.py"
+    },
+    "stdlib_only_note": "kernel package itself stays stdlib-only; the OPTIONAL surrogate needs sklearn+joblib"
   },
   "source_of_record": {
     "state": "VERIFIED_HF_SOURCE_OF_RECORD",
@@ -22,31 +40,41 @@
   "verification": {
     "tests": "17/17 passed",
     "tests_basis": "MEASURED local python3 -m pytest run, stdlib-only, offline",
-    "falsifiability": "registry must be exactly 21; locked-proven set must be exactly 8; PROOF_STATUS must match the dataset verbatim and raises on unknown names; Λ zero-pins on a zero axis; a tampered receipt fails verify_chain; a sub-floor Λ halts the governed loop"
+    "falsifiability": "registry must be exactly 21; locked-proven set must be exactly 8; PROOF_STATUS must match the dataset verbatim and raises on unknown names; \u039b zero-pins on a zero axis; a tampered receipt fails verify_chain; a sub-floor \u039b halts the governed loop"
   },
   "proof_status": {
     "policy": "mirrored VERBATIM from SZLHOLDINGS/canonical-formulas-v1 (PROVEN/AXIOM/SORRY/CONJECTURE)",
     "obligation_vs_locked": "a per-formula PROVEN(...) tag is an obligation-level label, NOT membership in the locked-proven canonical set",
     "locked_proven_count": 8,
-    "locked_proven_ids": ["F1", "F4", "F7", "F11", "F12", "F18", "F19", "F22"],
+    "locked_proven_ids": [
+      "F1",
+      "F4",
+      "F7",
+      "F11",
+      "F12",
+      "F18",
+      "F19",
+      "F22"
+    ],
     "locked_count_theorem": "locked_count_eight (no-axiom, szl-holdings/lutar-lean PROVEN_FORMULAS.md)",
-    "f_number_to_registry_mapping": "UNKNOWN — lutar-lean corpus (>=22 formulas) is a separate numbering; mapping onto these 21 registry entries is NOT asserted here (never fabricated)"
+    "f_number_to_registry_mapping": "UNKNOWN \u2014 lutar-lean corpus (>=22 formulas) is a separate numbering; mapping onto these 21 registry entries is NOT asserted here (never fabricated)"
   },
   "lambda": {
-    "status": "Conjecture 1 (open) — uniqueness unproven (Uniqueness.lean:120 sorry)",
+    "status": "Conjecture 1 (open) \u2014 uniqueness unproven (Uniqueness.lean:120 sorry)",
     "definition": "weighted geometric mean (D2)",
-    "composer_role": "ADVISORY only — non-compensatory roll-up, NOT proven trust"
+    "composer_role": "ADVISORY only \u2014 non-compensatory roll-up, NOT proven trust"
   },
   "claims": {
-    "trained_model": "NOT_CLAIMED",
+    "trained_model": "CLAIMED \u2014 sklearn HistGradientBoostingClassifier, MEASURED, receipted",
     "reproducible_build": "NOT_CLAIMED",
-    "weights_present": "NONE"
+    "weights_present": "model.joblib (sklearn surrogate; kernel stays weightless)"
   },
   "limits": [
-    "No .bin, .safetensors, .pt, .pth, .onnx, or .gguf weight artifact is present.",
+    "The trained surrogate is a fast formula IDENTIFIER from trace shape; it does NOT replace the kernel's real evaluators, which remain authoritative for formula identity.",
+    "Some formulas share an argument+output observable signature and are confusable from trace shape alone; these blind spots are MEASURED and stated in TRAINING_RECEIPT.json.",
     "The 21 formulas are pure/no-I/O; the composer performs no network access.",
     "PROOF_STATUS labels are the dataset's obligation-level declarations, not upgraded here.",
     "Locked-proven canonical set is fixed at exactly 8 and never inflated.",
-    "The composer's Λ roll-up does not prove or upgrade Λ, which stays Conjecture 1 (open)."
+    "The composer's \u039b roll-up does not prove or upgrade \u039b, which stays Conjecture 1 (open)."
   ]
-}
+}

README.md

@@ -6,8 +6,12 @@ tags:
 - proof-status
 - lean4
 - lambda-aggregate
+- sklearn
+- surrogate
+- tabular-classification
 - doi:10.5281/zenodo.19944926
 library_name: kernels
+pipeline_tag: tabular-classification
 license: apache-2.0
 szl-governance:
   verdict: ADVISORY
@@ -27,7 +31,7 @@ szl-governance:
 
 </div>
 
-> **⬛ No `.safetensors`/`.bin`/`.pt`/`.gguf` — governance kernel repo.** Not a trained model, NO weights. Pure-Python, **stdlib-only** offline replay of the live Alloy formula surface — the 21 canonical formulas of [`canonical-formulas-v1`](https://huggingface.co/datasets/SZLHOLDINGS/canonical-formulas-v1) plus the Codex-Kernel governed-loop composer. No network, no torch, no tensors. **Λ uniqueness stays Conjecture 1 (open); the composer's Λ roll-up is ADVISORY only.**
+> **🟩 Kernel + REAL trained surrogate.** The governance kernel (pure-Python, **stdlib-only**) is UNCHANGED and remains the sole ground truth — an offline replay of the live Alloy formula surface: the 21 canonical formulas of [`canonical-formulas-v1`](https://huggingface.co/datasets/SZLHOLDINGS/canonical-formulas-v1) plus the Codex-Kernel governed-loop composer. Since **surrogate v1** this repo ALSO ships `model.joblib` — a real trained sklearn classifier that identifies WHICH of the 21 formulas produced a given call trace, with **MEASURED** held-out accuracy **0.9709** (21-class). The surrogate never replaces the kernel's real evaluators. No network, no torch, no tensors in the kernel. **Λ uniqueness stays Conjecture 1 (open); the composer's Λ roll-up is ADVISORY only.**
 
 > **Kernel Hub migration (verified 2026-07-15):** `get_kernel(...)` resolves the first-class [Kernel Hub repo](https://huggingface.co/kernels/SZLHOLDINGS/szl-formulas); `main` and `v1` pin verified revision `39a9fe6fd295f500f30ad7c6ff4cfdf559b48c4a`.
 
@@ -70,6 +74,60 @@ Mirrors [`canonical-formulas-v1`](https://huggingface.co/datasets/SZLHOLDINGS/ca
 
 Apache-2.0 · © 2026 SZL Holdings · Stephen P. Lutar · ORCID [0009-0001-0110-4173](https://orcid.org/0009-0001-0110-4173).
 
+
+## Trained formula-identifier v1 (MEASURED — see `TRAINING_RECEIPT.json`)
+
+A real sklearn `HistGradientBoostingClassifier` trained on **18,900 traces**
+(900 per formula) generated and **labeled by this kernel itself**:
+every sample is produced by calling the REAL `REGISTRY[name]` evaluator, so the label is
+definitionally the producing formula (seed 20260721;
+126 samples re-audited by kernel replay).
+Features are **trace observables only** — argument-shape + the formula's own output
+shape/type/aggregate stats. No formula name is ever leaked into a feature. Registry count
+is read from the kernel (`registry_count()` → **21**) and asserted.
+
+| metric | value |
+|---|---|
+| test accuracy (21-class) | **0.9709** |
+| mean per-class recall | **0.9709** |
+
+| per-class recall | value |
+|---|---|
+| `bekenstein_cascade` | 1.0000 |
+| `bohr_complementarity_floor` | 0.7778 |
+| `css_ingress_verify` | 1.0000 |
+| `dsse_envelope` | 1.0000 |
+| `fisher_rao_distance` | 0.8889 |
+| `gleason_quantum_lambda` | 1.0000 |
+| `hoeffding_tail` | 1.0000 |
+| `khipu_merkle_root` | 1.0000 |
+| `kitaev_surface_correct` | 1.0000 |
+| `kochen_specker_18vector_witness` | 1.0000 |
+| `lambda_aggregate` | 0.9889 |
+| `lambda_bounded` | 1.0000 |
+| `lambda_homogeneous` | 1.0000 |
+| `madhava_series` | 1.0000 |
+| `pac_bayes_mcallester` | 1.0000 |
+| `pinsker_kl_bound` | 0.8833 |
+| `reed_solomon_singleton` | 1.0000 |
+| `reidemeister_invariant` | 1.0000 |
+| `schur_concave_lambda_two_axis` | 0.8500 |
+| `shor_codeword_distance` | 1.0000 |
+| `two_witness_ks18_soundness` | 1.0000 |
+
+**Measured blind spot (stated, never hidden):** `bohr_complementarity_floor` (0.7778), `fisher_rao_distance` (0.8889), `pinsker_kl_bound` (0.8833), `schur_concave_lambda_two_axis` (0.8500) sit below 0.90 recall.
+formulas that share an argument+output OBSERVABLE signature (e.g. several bool-returning axiom checks over similar inputs) are confusable from trace shape alone; the kernel's evaluators remain authoritative for identity Fast identification belongs to the surrogate; the real
+evaluators (the kernel) remain authoritative for formula identity. Λ untouched = Conjecture 1.
+
+```python
+import joblib
+clf = joblib.load("model.joblib")   # feature spec: TRAINING_RECEIPT.json data.features
+```
+
+Re-verify everything: `python scripts/eval.py` (sha256-checks the shipped model against the
+receipt, regenerates the seeded dataset via the in-repo kernel, retrains, and compares the
+21-class accuracy within ±0.02).
+
 ---
 
 <sub><b>SZL Holdings honesty footer.</b> Λ = Conjecture 1 (advisory, never a theorem). locked-proven = exactly 8 {F1,F4,F7,F11,F12,F18,F19,F22}. Honesty labels: MEASURED / REPORTED / MODELED / HEURISTIC / UNKNOWN / UNAVAILABLE. Trust never 100% (ceiling 0.97). PROOF_STATUS mirrored verbatim, never inflated. <a href="https://a-11-oy.com">a-11-oy.com</a> · <a href="https://huggingface.co/SZLHOLDINGS">huggingface.co/SZLHOLDINGS</a></sub>

TRAINING_RECEIPT.json

@@ -0,0 +1,158 @@
+{
+  "artifact": "SZLHOLDINGS/szl-formulas surrogate v1",
+  "role": "21-class formula identifier from call-trace observables \u2014 kernel remains ground truth",
+  "generator": {
+    "script": "scripts/forge.py",
+    "seed": 20260721,
+    "kernel_version": "0.1.0",
+    "kernel_labelled": true,
+    "kernel_registry_count": 21,
+    "kernel_replay_audited_samples": 126,
+    "label_source": "each sample is produced by calling the REAL REGISTRY[name] evaluator; label == producing formula"
+  },
+  "data": {
+    "rows": 18900,
+    "n_classes": 21,
+    "classes": [
+      "bekenstein_cascade",
+      "bohr_complementarity_floor",
+      "css_ingress_verify",
+      "dsse_envelope",
+      "fisher_rao_distance",
+      "gleason_quantum_lambda",
+      "hoeffding_tail",
+      "khipu_merkle_root",
+      "kitaev_surface_correct",
+      "kochen_specker_18vector_witness",
+      "lambda_aggregate",
+      "lambda_bounded",
+      "lambda_homogeneous",
+      "madhava_series",
+      "pac_bayes_mcallester",
+      "pinsker_kl_bound",
+      "reed_solomon_singleton",
+      "reidemeister_invariant",
+      "schur_concave_lambda_two_axis",
+      "shor_codeword_distance",
+      "two_witness_ks18_soundness"
+    ],
+    "per_class_samples": 900,
+    "class_counts": {
+      "bekenstein_cascade": 900,
+      "bohr_complementarity_floor": 900,
+      "css_ingress_verify": 900,
+      "dsse_envelope": 900,
+      "fisher_rao_distance": 900,
+      "gleason_quantum_lambda": 900,
+      "hoeffding_tail": 900,
+      "khipu_merkle_root": 900,
+      "kitaev_surface_correct": 900,
+      "kochen_specker_18vector_witness": 900,
+      "lambda_aggregate": 900,
+      "lambda_bounded": 900,
+      "lambda_homogeneous": 900,
+      "madhava_series": 900,
+      "pac_bayes_mcallester": 900,
+      "pinsker_kl_bound": 900,
+      "reed_solomon_singleton": 900,
+      "reidemeister_invariant": 900,
+      "schur_concave_lambda_two_axis": 900,
+      "shor_codeword_distance": 900,
+      "two_witness_ks18_soundness": 900
+    },
+    "split": "80/20 stratified",
+    "features": [
+      "arity",
+      "argshape_n",
+      "argshape_depth",
+      "argshape_is_str",
+      "argshape_is_bytes",
+      "argshape_is_dict",
+      "argshape_is_list",
+      "argshape_is_bool",
+      "argnum_count",
+      "argnum_mean",
+      "argnum_std",
+      "argnum_min",
+      "argnum_max",
+      "argnum_frac_zero",
+      "outshape_n",
+      "outshape_depth",
+      "outshape_is_str",
+      "outshape_is_bytes",
+      "outshape_is_dict",
+      "outshape_is_list",
+      "outshape_is_bool",
+      "outnum_count",
+      "outnum_mean",
+      "outnum_std",
+      "outnum_min",
+      "outnum_max",
+      "outnum_frac_zero",
+      "out_is_bool",
+      "out_is_int",
+      "out_is_float",
+      "out_is_bytes",
+      "out_is_dict",
+      "out_is_list",
+      "out_scalar_logabs"
+    ],
+    "feature_policy": "trace observables ONLY: argument-shape + kernel-output shape/type/aggregate stats; no formula name leaked into features"
+  },
+  "model": {
+    "type": "sklearn.HistGradientBoostingClassifier",
+    "params": {
+      "max_iter": 300,
+      "early_stopping": true,
+      "random_state": 20260721
+    },
+    "file": "model.joblib",
+    "sha256": "94cca70dc950fa957c0931ee80240c4369cab0ff8446ffbfedb483c3e2907698"
+  },
+  "metrics_MEASURED": {
+    "test_accuracy_21_class": 0.9709,
+    "mean_per_class_recall": 0.9709,
+    "per_class_recall": {
+      "bekenstein_cascade": 1.0,
+      "bohr_complementarity_floor": 0.7778,
+      "css_ingress_verify": 1.0,
+      "dsse_envelope": 1.0,
+      "fisher_rao_distance": 0.8889,
+      "gleason_quantum_lambda": 1.0,
+      "hoeffding_tail": 1.0,
+      "khipu_merkle_root": 1.0,
+      "kitaev_surface_correct": 1.0,
+      "kochen_specker_18vector_witness": 1.0,
+      "lambda_aggregate": 0.9889,
+      "lambda_bounded": 1.0,
+      "lambda_homogeneous": 1.0,
+      "madhava_series": 1.0,
+      "pac_bayes_mcallester": 1.0,
+      "pinsker_kl_bound": 0.8833,
+      "reed_solomon_singleton": 1.0,
+      "reidemeister_invariant": 1.0,
+      "schur_concave_lambda_two_axis": 0.85,
+      "shor_codeword_distance": 1.0,
+      "two_witness_ks18_soundness": 1.0
+    },
+    "blind_spots": {
+      "policy": "classes with held-out recall < 0.90 reported honestly",
+      "classes": {
+        "bohr_complementarity_floor": 0.7778,
+        "fisher_rao_distance": 0.8889,
+        "pinsker_kl_bound": 0.8833,
+        "schur_concave_lambda_two_axis": 0.85
+      },
+      "statement": "formulas that share an argument+output OBSERVABLE signature (e.g. several bool-returning axiom checks over similar inputs) are confusable from trace shape alone; the kernel's evaluators remain authoritative for identity"
+    }
+  },
+  "environment": {
+    "python": "3.12.12",
+    "sklearn": "1.9.0",
+    "numpy": "2.5.1",
+    "host": "replit 2-vCPU container",
+    "wall_seconds": 4.3
+  },
+  "honesty": "Every number above is MEASURED by this run. The surrogate identifies formulas from trace shape; it never replaces the kernel's real evaluators. \u039b untouched = Conjecture 1.",
+  "trained_at_utc": "2026-07-21T02:50:06Z"
+}

model.joblib

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

scripts/eval.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""Re-verify the szl-formulas surrogate: sha256 the shipped model against
+TRAINING_RECEIPT.json, then deterministically regenerate the seeded dataset via
+scripts/forge.py (which resolves the kernel from this repo's own build/ dir) and
+compare re-measured 21-class accuracy to the receipt (tolerance 0.02 across lib
+versions). Run from repo root: python scripts/eval.py"""
+import hashlib, json, subprocess, sys, tempfile, os, shutil
+root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+receipt = json.load(open(f"{root}/TRAINING_RECEIPT.json"))
+got = hashlib.sha256(open(f"{root}/model.joblib", "rb").read()).hexdigest()
+want = receipt["model"]["sha256"]
+print(f"model.joblib sha256 {'MATCHES receipt' if got==want else 'MISMATCH — refuse'}: {got[:16]}…")
+if got != want: sys.exit(1)
+with tempfile.TemporaryDirectory() as td:
+    os.makedirs(f"{td}/repo/scripts")
+    # symlink the kernel build dir so forge.py's in-repo path logic resolves it
+    os.symlink(f"{root}/build", f"{td}/repo/build")
+    shutil.copy(f"{root}/scripts/forge.py", f"{td}/repo/scripts/forge.py")
+    out = subprocess.run([sys.executable, f"{td}/repo/scripts/forge.py"],
+                         capture_output=True, text=True)
+    print(out.stdout[-500:] if out.returncode == 0 else out.stderr[-500:])
+    if out.returncode: sys.exit(1)
+    re_receipt = json.load(open(f"{td}/repo/scripts/TRAINING_RECEIPT.json"))
+    d = abs(re_receipt["metrics_MEASURED"]["test_accuracy_21_class"]
+            - receipt["metrics_MEASURED"]["test_accuracy_21_class"])
+    print(f"re-measured 21-class accuracy delta vs receipt: {d:.4f} ({'OK ≤0.02' if d<=0.02 else 'FAIL'})")
+    sys.exit(0 if d <= 0.02 else 1)

scripts/forge.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""Forge a REAL trained surrogate for szl-formulas.
+Kernel = ground truth. Surrogate = a 21-class formula IDENTIFIER: given the
+OBSERVABLE trace of a single formula call (argument-shape observables + the
+formula's own output observables, produced by the kernel's REAL evaluators),
+predict WHICH of the 21 canonical formulas produced it. The registry count (21)
+is read from the kernel itself (registry_count()); we assert it == 21 and say so.
+Labels come from the kernel: each sample is generated BY calling the real
+REGISTRY[name] evaluator, so the label is definitionally the producing formula.
+A sample of traces is re-audited by replaying the kernel call and asserting the
+recorded output matches. Seeded, receipted, reproducible."""
+import json, os, random, sys, time, hashlib, platform, math
+_here = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if os.path.isdir(os.path.join(_here, "build", "torch-universal")):
+    sys.path.insert(0, os.path.join(_here, "build", "torch-universal"))  # in-repo run
+else:
+    sys.path.insert(0, "/tmp/kernel-probe/szl-formulas/build/torch-universal")  # forge-dev run
+import szl_formulas as fx
+import numpy as np
+from sklearn.ensemble import HistGradientBoostingClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, recall_score
+import joblib
+
+SEED = 20260721
+random.seed(SEED); np.random.seed(SEED)
+T0 = time.time()
+
+REG_COUNT = fx.registry_count()
+assert REG_COUNT == 21, f"expected 21 canonical formulas, kernel reports {REG_COUNT}"
+CLASSES = sorted(fx.REGISTRY.keys())
+assert len(CLASSES) == 21
+
+# ---- per-formula argument generators (produce VALID args for the REAL kernel) ----
+def _simplex(k):
+    v = [random.random() + 1e-3 for _ in range(k)]
+    s = sum(v); return [x / s for x in v]
+
+def _axes(k):
+    return [random.uniform(0.05, 1.0) for _ in range(k)]
+
+def gen_args(name):
+    if name == "lambda_aggregate":
+        k = random.randint(2, 6); ax = _axes(k)
+        if random.random() < 0.5:
+            return [ax, _simplex(k)]
+        return [ax]
+    if name == "lambda_homogeneous":
+        k = random.randint(2, 5)
+        return [random.uniform(0.0, 3.0), _axes(k)]
+    if name == "lambda_bounded":
+        return [_axes(random.randint(2, 6))]
+    if name == "pac_bayes_mcallester":
+        return [random.uniform(0.0, 0.5), random.uniform(0.0, 5.0),
+                random.randint(10, 5000), random.uniform(0.01, 0.5)]
+    if name == "bekenstein_cascade":
+        return [random.uniform(0.0, 10.0), random.uniform(0.0, 1e-10)]
+    if name == "reidemeister_invariant":
+        alphabet = "abAB"
+        s = "".join(random.choice(alphabet) for _ in range(random.randint(2, 8)))
+        return [s, random.choice(["R1", "R2", "R3"])]
+    if name == "khipu_merkle_root":
+        n = random.randint(1, 5)
+        return [[{"decision_id": f"d{i}", "value": random.randint(0, 100)} for i in range(n)]]
+    if name == "dsse_envelope":
+        blen = random.randint(1, 24)
+        return [bytes(random.randint(0, 255) for _ in range(blen)), f"key-{random.randint(0,9)}"]
+    if name == "gleason_quantum_lambda":
+        n = random.randint(2, 4)
+        return [[[random.uniform(-1, 1) for _ in range(n)] for _ in range(n)]]
+    if name == "hoeffding_tail":
+        return [random.uniform(0.0, 1.0), random.randint(1, 5000)]
+    if name == "pinsker_kl_bound":
+        k = random.randint(2, 5); return [_simplex(k), _simplex(k)]
+    if name == "fisher_rao_distance":
+        k = random.randint(2, 5); return [_simplex(k), _simplex(k)]
+    if name == "bohr_complementarity_floor":
+        return [random.uniform(0.0, 1.0), random.uniform(0.0, 1.0)]
+    if name == "kochen_specker_18vector_witness":
+        rows = random.randint(2, 7)
+        return [[[1 if random.random() < 0.4 else 0 for _ in range(random.randint(2, 5))] for _ in range(rows)]]
+    if name == "two_witness_ks18_soundness":
+        return [random.random() < 0.5, random.random() < 0.5]
+    if name == "shor_codeword_distance":
+        rows = random.randint(1, 5); cols = random.randint(2, 6)
+        return [[[random.randint(0, 1) for _ in range(cols)] for _ in range(rows)]]
+    if name == "css_ingress_verify":
+        payload = bytes(random.randint(0, 255) for _ in range(random.randint(0, 20)))
+        env = fx.dsse_envelope(payload, "signer")
+        from hashlib import sha256
+        commit = sha256(bytes.fromhex(env["payload"]) if env["payload"] else b"").digest()
+        # half the time provide the matching root, half a random one
+        css_root = commit if random.random() < 0.5 else bytes(random.randint(0, 255) for _ in range(4))
+        return [env, css_root]
+    if name == "kitaev_surface_correct":
+        return [[random.randint(0, 3) for _ in range(random.randint(2, 8))]]
+    if name == "reed_solomon_singleton":
+        n = random.randint(2, 255); k = random.randint(1, n)
+        return [n, k]
+    if name == "madhava_series":
+        return [random.uniform(-1.0, 1.0), random.randint(1, 60)]
+    if name == "schur_concave_lambda_two_axis":
+        return [random.uniform(0.0, 1.0), random.uniform(0.0, 1.0)]
+    raise KeyError(name)
+
+# ---- trace observables (features) — derived ONLY from args + REAL kernel output ----
+def _flatten_num(x):
+    """Yield numeric leaves from an arbitrarily nested arg/output structure."""
+    if isinstance(x, bool):
+        yield float(x)
+    elif isinstance(x, (int, float)):
+        yield float(x)
+    elif isinstance(x, (bytes, bytearray)):
+        for b in x: yield float(b)
+    elif isinstance(x, str):
+        yield float(len(x))
+    elif isinstance(x, dict):
+        for v in x.values():
+            yield from _flatten_num(v)
+    elif isinstance(x, (list, tuple)):
+        for v in x:
+            yield from _flatten_num(v)
+
+def _shape_stats(obj):
+    """Structural stats for a single object: (n_items, depth, is_str, is_bytes, is_dict, is_list, is_bool)."""
+    def depth(o):
+        if isinstance(o, (list, tuple)) and o:
+            return 1 + max(depth(v) for v in o)
+        if isinstance(o, dict) and o:
+            return 1 + max(depth(v) for v in o.values())
+        return 0
+    n = 0
+    if isinstance(obj, (list, tuple, dict, str, bytes, bytearray)):
+        n = len(obj)
+    return [float(n), float(depth(obj)),
+            float(isinstance(obj, str)), float(isinstance(obj, (bytes, bytearray))),
+            float(isinstance(obj, dict)), float(isinstance(obj, (list, tuple))),
+            float(isinstance(obj, bool))]
+
+def observe(args, out):
+    """Produce a FIXED-LENGTH numeric feature vector from the call trace."""
+    arg_leaves = list(_flatten_num(args))
+    out_leaves = list(_flatten_num(out))
+    def agg(leaves):
+        if not leaves:
+            return [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+        a = np.array(leaves, dtype=np.float64)
+        finite = a[np.isfinite(a)]
+        if finite.size == 0:
+            finite = np.array([0.0])
+        return [float(finite.size), float(finite.mean()), float(finite.std()),
+                float(finite.min()), float(finite.max()),
+                float(np.mean(np.abs(finite) < 1e-6))]
+    feats = []
+    feats += [float(len(args))]                       # arity
+    feats += _shape_stats(args)                       # arg container shape
+    feats += agg(arg_leaves)                          # arg numeric aggregate
+    feats += _shape_stats(out)                        # output shape
+    feats += agg(out_leaves)                          # output numeric aggregate
+    # output-type one-hots (the kernel's real return type is a strong signal)
+    feats += [float(isinstance(out, bool)),
+              float(isinstance(out, int) and not isinstance(out, bool)),
+              float(isinstance(out, float)),
+              float(isinstance(out, (bytes, bytearray))),
+              float(isinstance(out, dict)),
+              float(isinstance(out, (list, tuple)))]
+    # magnitude of a scalar output (log-abs), else 0
+    if isinstance(out, (int, float)) and not isinstance(out, bool):
+        feats += [math.log1p(abs(float(out)))]
+    else:
+        feats += [0.0]
+    return feats
+
+FEATURE_NAMES = (
+    ["arity"]
+    + [f"argshape_{s}" for s in ["n", "depth", "is_str", "is_bytes", "is_dict", "is_list", "is_bool"]]
+    + [f"argnum_{s}" for s in ["count", "mean", "std", "min", "max", "frac_zero"]]
+    + [f"outshape_{s}" for s in ["n", "depth", "is_str", "is_bytes", "is_dict", "is_list", "is_bool"]]
+    + [f"outnum_{s}" for s in ["count", "mean", "std", "min", "max", "frac_zero"]]
+    + ["out_is_bool", "out_is_int", "out_is_float", "out_is_bytes", "out_is_dict", "out_is_list"]
+    + ["out_scalar_logabs"]
+)
+
+# ---- generate ----
+PER_CLASS = 900
+X, y, audited = [], [], 0
+sample_bank = {}  # name -> list of (args, recorded_out) for audit
+for name in CLASSES:
+    for _ in range(PER_CLASS):
+        args = gen_args(name)
+        out = fx.REGISTRY[name](*args)   # REAL kernel evaluator == ground truth label
+        X.append(observe(args, out)); y.append(name)
+        if len(sample_bank.get(name, [])) < 6:
+            sample_bank.setdefault(name, []).append((args, out))
+
+# ---- kernel-replay audit: re-call the real evaluator, assert output agrees ----
+def _eq(a, b):
+    if isinstance(a, float) or isinstance(b, float):
+        try:
+            return abs(float(a) - float(b)) <= 1e-9 * max(1.0, abs(float(a)), abs(float(b)))
+        except Exception:
+            return a == b
+    return a == b
+
+for name, samples in sample_bank.items():
+    for args, recorded in samples:
+        replay = fx.REGISTRY[name](*args)
+        assert _eq(replay, recorded), f"kernel replay disagreement for {name}: {replay!r} != {recorded!r}"
+        audited += 1
+
+X = np.array(X, dtype=np.float64); y = np.array(y)
+Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=SEED, stratify=y)
+clf = HistGradientBoostingClassifier(random_state=SEED, max_iter=300, early_stopping=True)
+clf.fit(Xtr, ytr)
+pred = clf.predict(Xte)
+acc = accuracy_score(yte, pred)
+per_class_recall = {c: float(recall_score(yte == c, pred == c)) for c in CLASSES}
+# honest blind-spot detection: classes whose recall is materially below the mean
+mean_recall = float(np.mean(list(per_class_recall.values())))
+weak = {c: round(r, 4) for c, r in per_class_recall.items() if r < 0.90}
+
+out_dir = os.path.dirname(os.path.abspath(__file__))
+joblib.dump(clf, f"{out_dir}/model.joblib")
+model_sha = hashlib.sha256(open(f"{out_dir}/model.joblib", "rb").read()).hexdigest()
+receipt = {
+  "artifact": "SZLHOLDINGS/szl-formulas surrogate v1",
+  "role": "21-class formula identifier from call-trace observables — kernel remains ground truth",
+  "generator": {"script": "scripts/forge.py", "seed": SEED, "kernel_version": fx.__version__,
+                 "kernel_labelled": True, "kernel_registry_count": REG_COUNT,
+                 "kernel_replay_audited_samples": audited,
+                 "label_source": "each sample is produced by calling the REAL REGISTRY[name] evaluator; label == producing formula"},
+  "data": {"rows": int(len(y)), "n_classes": len(CLASSES), "classes": CLASSES,
+            "per_class_samples": PER_CLASS,
+            "class_counts": {c: int((y == c).sum()) for c in CLASSES},
+            "split": "80/20 stratified", "features": FEATURE_NAMES,
+            "feature_policy": "trace observables ONLY: argument-shape + kernel-output shape/type/aggregate stats; no formula name leaked into features"},
+  "model": {"type": "sklearn.HistGradientBoostingClassifier",
+             "params": {"max_iter": 300, "early_stopping": True, "random_state": SEED},
+             "file": "model.joblib", "sha256": model_sha},
+  "metrics_MEASURED": {"test_accuracy_21_class": round(float(acc), 4),
+                        "mean_per_class_recall": round(mean_recall, 4),
+                        "per_class_recall": {k: round(v, 4) for k, v in per_class_recall.items()},
+                        "blind_spots": {"policy": "classes with held-out recall < 0.90 reported honestly",
+                          "classes": weak,
+                          "statement": "formulas that share an argument+output OBSERVABLE signature (e.g. several bool-returning axiom checks over similar inputs) are confusable from trace shape alone; the kernel's evaluators remain authoritative for identity"}},
+  "environment": {"python": platform.python_version(), "sklearn": __import__("sklearn").__version__,
+                   "numpy": np.__version__, "host": "replit 2-vCPU container", "wall_seconds": round(time.time()-T0, 1)},
+  "honesty": "Every number above is MEASURED by this run. The surrogate identifies formulas from trace shape; it never replaces the kernel's real evaluators. Λ untouched = Conjecture 1.",
+  "trained_at_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+}
+with open(f"{out_dir}/TRAINING_RECEIPT.json", "w") as f: json.dump(receipt, f, indent=2)
+print(json.dumps({"acc": receipt["metrics_MEASURED"]["test_accuracy_21_class"],
+                  "mean_recall": mean_recall, "weak": weak}, indent=2))
+print(f"rows={len(y)} classes={len(CLASSES)} audited={audited} wall={receipt['environment']['wall_seconds']}s")