surrogate v1: REAL trained torch MLP Λ-gate-decision surrogate (fidelity 0.967 MEASURED) + config + receipt + scripts + honest card/provenance

MODEL_PROVENANCE.json

@@ -5,7 +5,21 @@
     "id": "SZLHOLDINGS/szl-lambda-gate",
     "repository_type": "model",
     "artifact_kind": "kernel-code-and-configuration",
-    "trained_weights_present": false
+    "trained_weights_present": true,
+    "surrogate": {
+      "file": "model.safetensors",
+      "config": "config.json",
+      "sha256": "79987d9dd53f6c5496569c588ac5203b8d4debda2d8ef9ee7147c43d4740358d",
+      "role": "advisory \u039b gate-decision surrogate (torch MLP) \u2014 kernel \u039b remains sole ground truth",
+      "fidelity_MEASURED": {
+        "fidelity_vs_kernel_heldout": 0.967,
+        "recall_GATE_PASS": 0.9912,
+        "recall_GATE_FAIL": 0.9469
+      },
+      "receipt": "TRAINING_RECEIPT.json",
+      "reverify": "python scripts/eval.py"
+    },
+    "torch_only_note": "kernel is pure-torch; the OPTIONAL surrogate adds safetensors for weight IO"
   },
   "source_of_record": {
     "state": "VERIFIED_HF_SOURCE_OF_RECORD",
@@ -73,7 +87,7 @@
     "github_repository_parity": "NOT_CLAIMED",
     "github_artifact_scope_parity": "NOT_CLAIMED_DUE_TO_RECORDED_DIVERGENCE",
     "reproducible_build": "NOT_CLAIMED",
-    "trained_model": "NOT_CLAIMED",
+    "trained_model": "SURROGATE_PRESENT_MEASURED_FIDELITY",
     "serving_process_revision": "NOT_APPLICABLE_REPOSITORY_ARTIFACT"
   },
   "limits": [
@@ -82,4 +96,4 @@
     "The attestation overlay cannot self-embed its resulting Hub commit, so the immutable artifact_base_revision is the measured pre-overlay base.",
     "No .bin, .safetensors, .pt, .pth, .onnx, or .gguf weight artifact was present in the measured base tree."
   ]
-}
+}

README.md

@@ -5,6 +5,9 @@ tags:
 - lambda
 - gate
 - provenance
+- torch
+- surrogate
+- pytorch
 - doi:10.5281/zenodo.19944926
 library_name: kernels
 license: apache-2.0
@@ -22,7 +25,7 @@ license: apache-2.0
 <!-- SZL-ESTATE-CARD:v2:END -->
 
 <!-- SZL-ARTIFACT-NOTICE:v1:START — honesty plate: repo semantics, no fake model tags. -->
-> **⬛ NOT A RUNNABLE MODEL.** This repository is a **governance kernel / artifact set** (specifications, invariants, receipts, or reference material) published under the SZL honesty doctrine. It deliberately declares **no `pipeline_tag` and no `base_model`** because none truthfully applies — you cannot load this repo into an inference pipeline, and tagging it otherwise would fake semantics. Verification of anything here proves **integrity & origin only, never accuracy or performance**. Λ = Conjecture 1 · ADVISORY.
+> **🟩 Kernel + REAL trained torch surrogate.** The Λ governance kernel (pure-torch, differentiable) is UNCHANGED and remains the sole ground truth. Since **surrogate v1** this repo also ships `model.safetensors` + `config.json` — a real trained tiny torch MLP that predicts the ADVISORY gate decision `lambda_gate(axes, threshold).passed` over the 13-axis Yuyay space, with **MEASURED** fidelity **0.9670** (agreement vs the kernel on a held-out split). The surrogate approximates the gate DECISION only; the kernel Λ stays authoritative and `get_kernel`-discoverable. **Λ is the weighted geometric mean, NOT proven trust — uniqueness = Conjecture 1 (OPEN).**
 <!-- SZL-ARTIFACT-NOTICE:v1:END -->
 
 
@@ -119,6 +122,47 @@ Python 3.9+, `torch>=2.5`, standard library + torch only.
 
 Apache-2.0. Copyright 2026 SZL Holdings.
 
+## Trained Λ-gate surrogate v1 (MEASURED — see `TRAINING_RECEIPT.json`)
+
+A real **tiny torch MLP** (3 hidden ReLU layers, 64 units; `model.safetensors` + `config.json`)
+trained on **40,000 axis-score vectors** synthesized and **labeled by this kernel itself**
+(`lambda_gate(axes, weights=yuyay_uniform_1/13, threshold=0.5).passed`, seed 20260721; 800
+samples re-audited by independent full kernel replay during generation — all agreed). Inputs are
+the 13 Yuyay axis scores in [0,1], including non-compensatory zero-route rows (a single zeroed
+axis must fail the gate).
+
+| metric | value |
+|---|---|
+| fidelity vs kernel (held-out agreement) | **0.9670** |
+| recall GATE_PASS | 0.9912 |
+| recall GATE_FAIL | 0.9469 |
+
+**Honest boundary:** the surrogate learns the *decision boundary* of an ADVISORY, non-compensatory
+aggregator; it is a fast approximation, NOT the exact Λ and NOT proven trust. Residual disagreement
+lives near the Λ=threshold surface — the exact kernel `lambda_gate` remains authoritative. Class
+counts: GATE_FAIL=21828, GATE_PASS=18172. Λ uniqueness = Conjecture 1 (open).
+
+```python
+import torch, json
+from safetensors.torch import load_file
+from torch import nn
+cfg = json.load(open("config.json"))          # architecture + input_axes spec
+class GateMLP(nn.Module):
+    def __init__(self, k, h):
+        super().__init__()
+        self.net = nn.Sequential(nn.Linear(k,h), nn.ReLU(), nn.Linear(h,h), nn.ReLU(),
+                                 nn.Linear(h,h), nn.ReLU(), nn.Linear(h,1))
+    def forward(self, x): return self.net(x).squeeze(-1)
+model = GateMLP(cfg["input_dim"], cfg["hidden"])
+model.load_state_dict(load_file("model.safetensors")); model.eval()
+axes = torch.rand(1, 13)
+pred_pass = (torch.sigmoid(model(axes)) >= 0.5).item()   # advisory gate decision (surrogate)
+```
+
+Re-verify everything: `python scripts/eval.py` (sha256-checks the shipped `model.safetensors`
+against the receipt, regenerates the seeded kernel-labeled dataset, retrains, and compares
+fidelity within ±0.02).
+
 ---
 
 ## SZL Kernels Suite

TRAINING_RECEIPT.json

@@ -0,0 +1,87 @@
+{
+  "artifact": "SZLHOLDINGS/szl-lambda-gate surrogate v1",
+  "role": "advisory \u039b gate-decision surrogate (torch MLP) \u2014 kernel remains ground truth",
+  "generator": {
+    "script": "scripts/forge.py",
+    "seed": 20260721,
+    "kernel_version": "0.2.0",
+    "kernel_labelled": true,
+    "kernel_audited_samples": 800,
+    "labeler": "lambda_gate(axes, weights=yuyay_uniform_1/13, threshold=0.5).passed",
+    "axes": [
+      "moralGrounding",
+      "measurabilityHonesty",
+      "empiricalGrounding",
+      "logicalConsistency",
+      "sourceTransparency",
+      "reproducibility",
+      "licenseHygiene",
+      "scopeDiscipline",
+      "claimCalibration",
+      "evalAwareness",
+      "deceptionKeywords",
+      "conflictingDirectives",
+      "reversalDirective"
+    ],
+    "threshold": 0.5
+  },
+  "data": {
+    "rows": 40000,
+    "classes": [
+      "GATE_FAIL",
+      "GATE_PASS"
+    ],
+    "class_counts": {
+      "GATE_FAIL": 21828,
+      "GATE_PASS": 18172
+    },
+    "split": "80/20 permutation",
+    "features": [
+      "moralGrounding",
+      "measurabilityHonesty",
+      "empiricalGrounding",
+      "logicalConsistency",
+      "sourceTransparency",
+      "reproducibility",
+      "licenseHygiene",
+      "scopeDiscipline",
+      "claimCalibration",
+      "evalAwareness",
+      "deceptionKeywords",
+      "conflictingDirectives",
+      "reversalDirective"
+    ],
+    "feature_policy": "13 Yuyay axis scores in [0,1]; includes non-compensatory zero-route rows"
+  },
+  "model": {
+    "type": "pytorch GateMLP (3 hidden ReLU layers, 64 units)",
+    "params": {
+      "input_dim": 13,
+      "hidden": 64,
+      "epochs": 150,
+      "batch": 512,
+      "lr": 0.002,
+      "optimizer": "Adam",
+      "loss": "BCEWithLogits",
+      "seed": 20260721
+    },
+    "file": "model.safetensors",
+    "sha256": "79987d9dd53f6c5496569c588ac5203b8d4debda2d8ef9ee7147c43d4740358d",
+    "config": "config.json"
+  },
+  "metrics_MEASURED": {
+    "fidelity_vs_kernel_heldout": 0.967,
+    "test_accuracy": 0.967,
+    "recall_GATE_PASS": 0.9912,
+    "recall_GATE_FAIL": 0.9469
+  },
+  "environment": {
+    "python": "3.12.12",
+    "torch": "2.13.0+cpu",
+    "numpy": "2.5.1",
+    "host": "replit 2-vCPU container",
+    "wall_seconds": 12.0
+  },
+  "honesty": "Every number above is MEASURED by this run. Fidelity = agreement%% with the kernel's ADVISORY lambda_gate decision on a held-out split. \u039b is the weighted geometric mean, NOT proven trust; uniqueness = Conjecture 1 (open). The surrogate never replaces the kernel gate.",
+  "trained_at_utc": "2026-07-21T02:53:27Z"
+}

config.json

@@ -0,0 +1,36 @@
+{
+  "architecture": "GateMLP",
+  "task": "advisory-lambda-gate-decision-surrogate",
+  "framework": "pytorch",
+  "input_dim": 13,
+  "input_axes": [
+    "moralGrounding",
+    "measurabilityHonesty",
+    "empiricalGrounding",
+    "logicalConsistency",
+    "sourceTransparency",
+    "reproducibility",
+    "licenseHygiene",
+    "scopeDiscipline",
+    "claimCalibration",
+    "evalAwareness",
+    "deceptionKeywords",
+    "conflictingDirectives",
+    "reversalDirective"
+  ],
+  "hidden": 64,
+  "layers": [
+    "Linear(13,64)",
+    "ReLU",
+    "Linear(64,64)",
+    "ReLU",
+    "Linear(64,64)",
+    "ReLU",
+    "Linear(64,1)"
+  ],
+  "output": "logit; sigmoid>=0.5 => predicted gate PASS (\u039b>=threshold)",
+  "threshold": 0.5,
+  "weights": "yuyay uniform 1/13",
+  "label_source": "szl_lambda_gate.lambda_gate(axes, weights=yuyay, threshold=0.5).passed",
+  "honesty": "predicts the ADVISORY gate DECISION only; \u039b is NOT proven trust; uniqueness = Conjecture 1 (open)"
+}

model.safetensors

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

scripts/eval.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Re-verify the torch surrogate: sha256 the shipped model.safetensors against
+TRAINING_RECEIPT.json, then deterministically regenerate the seeded dataset via
+scripts/forge.py and compare re-measured fidelity to the receipt (tolerance 0.02).
+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.safetensors", "rb").read()).hexdigest()
+want = receipt["model"]["sha256"]
+print(f"model.safetensors sha256 {'MATCHES receipt' if got==want else 'MISMATCH — refuse'}: {got[:16]}…")
+if got != want:
+    sys.exit(1)
+with tempfile.TemporaryDirectory() as td:
+    shutil.copy(f"{root}/scripts/forge.py", f"{td}/forge.py")
+    out = subprocess.run([sys.executable, f"{td}/forge.py"], capture_output=True, text=True, cwd=td)
+    print(out.stdout[-400:] if out.returncode == 0 else out.stderr[-600:])
+    if out.returncode:
+        sys.exit(1)
+    re_receipt = json.load(open(f"{td}/TRAINING_RECEIPT.json"))
+    d = abs(re_receipt["metrics_MEASURED"]["fidelity_vs_kernel_heldout"]
+            - receipt["metrics_MEASURED"]["fidelity_vs_kernel_heldout"])
+    print(f"re-measured fidelity 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,169 @@
+#!/usr/bin/env python3
+"""Forge a REAL trained torch surrogate for szl-lambda-gate.
+Kernel = ground truth. Surrogate = a tiny torch MLP that predicts the ADVISORY
+gate decision `lambda_gate(axes, threshold).passed` — i.e. Λ(axes) >= threshold —
+over the canonical 13-axis Yuyay space. The kernel's weighted-geometric-mean Λ
+(with non-compensatory zero-routing: any zero/non-finite axis fails the gate) is
+the sole labeler; a sample of labels is re-audited by full kernel replay and MUST
+agree or the run fails loudly.
+
+Λ IS NOT PROVEN TRUST — it is the ADVISORY weighted geometric mean, uniqueness =
+Conjecture 1 (OPEN). The surrogate approximates the gate DECISION, nothing more.
+Seeded, receipted, reproducible. Ships .safetensors + config.json."""
+import json, os, random, sys, time, hashlib, platform
+_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-lambda-gate/build/torch-universal")  # forge-dev run
+import szl_lambda_gate as lg
+import numpy as np
+import torch
+from torch import nn
+from safetensors.torch import save_file
+
+SEED = 20260721
+random.seed(SEED); np.random.seed(SEED)
+torch.manual_seed(SEED)
+T0 = time.time()
+
+K = len(lg.YUYAY_AXES)          # 13 canonical axes
+THRESHOLD = 0.5
+WEIGHTS = lg.yuyay_weights(dtype=torch.float64)   # uniform 1/13, advisory
+
+
+def kernel_gate(axes_np):
+    """Ground truth: lambda_gate(axes).passed for a batch (N,K)."""
+    t = torch.tensor(axes_np, dtype=torch.float64)
+    res = lg.lambda_gate(t, weights=WEIGHTS, threshold=THRESHOLD)
+    return res.passed.numpy().astype(np.int64)
+
+
+def synth_axes(n):
+    """Synthesize axis-score vectors that straddle the gate boundary, including
+    non-compensatory zero-route cases (a single zeroed axis must fail)."""
+    X = np.random.uniform(0.0, 1.0, size=(n, K)).astype(np.float64)
+    # push a chunk toward the boundary region so the label is non-trivial
+    hi = np.random.rand(n) < 0.45
+    X[hi] = np.random.uniform(0.55, 1.0, size=(hi.sum(), K))
+    # inject explicit zero-route rows (one axis exactly 0 -> Λ=0 -> fail)
+    zr = np.random.rand(n) < 0.12
+    idx = np.where(zr)[0]
+    for i in idx:
+        X[i, np.random.randint(K)] = 0.0
+    return X
+
+
+class GateMLP(nn.Module):
+    def __init__(self, k, hidden=64):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(k, hidden), nn.ReLU(),
+            nn.Linear(hidden, hidden), nn.ReLU(),
+            nn.Linear(hidden, hidden), nn.ReLU(),
+            nn.Linear(hidden, 1),
+        )
+
+    def forward(self, x):
+        return self.net(x).squeeze(-1)
+
+
+# ---- generate (kernel-labeled) ----
+N = 40000
+Xall = synth_axes(N)
+yall = kernel_gate(Xall)
+
+# ground-truth audit: independent fresh kernel replay must agree on a sample
+audit_idx = np.array(sorted(random.sample(range(N), 800)))
+replay = kernel_gate(Xall[audit_idx])
+assert np.array_equal(replay, yall[audit_idx]), "kernel disagrees on audited sample"
+audit_checked = int(len(audit_idx))
+
+# split 80/20 deterministic
+perm = np.random.permutation(N)
+cut = int(N * 0.8)
+tr, te = perm[:cut], perm[cut:]
+Xtr = torch.tensor(Xall[tr], dtype=torch.float32)
+ytr = torch.tensor(yall[tr], dtype=torch.float32)
+Xte = torch.tensor(Xall[te], dtype=torch.float32)
+yte = torch.tensor(yall[te], dtype=torch.float32)
+
+HIDDEN = 64
+model = GateMLP(K, hidden=HIDDEN)
+opt = torch.optim.Adam(model.parameters(), lr=2e-3)
+lossf = nn.BCEWithLogitsLoss()
+EPOCHS = 150
+BATCH = 512
+model.train()
+for ep in range(EPOCHS):
+    order = torch.randperm(Xtr.shape[0])
+    for b in range(0, Xtr.shape[0], BATCH):
+        bi = order[b:b + BATCH]
+        opt.zero_grad()
+        logits = model(Xtr[bi])
+        loss = lossf(logits, ytr[bi])
+        loss.backward(); opt.step()
+
+model.eval()
+with torch.no_grad():
+    pred = (torch.sigmoid(model(Xte)) >= 0.5).long()
+    yte_l = yte.long()
+    acc = float((pred == yte_l).float().mean())   # fidelity vs kernel
+    # per-class recall
+    pos = yte_l == 1
+    neg = yte_l == 0
+    rec_pass = float((pred[pos] == 1).float().mean()) if pos.any() else float("nan")
+    rec_fail = float((pred[neg] == 0).float().mean()) if neg.any() else float("nan")
+
+out = os.path.dirname(os.path.abspath(__file__))
+state = {k: v.contiguous() for k, v in model.state_dict().items()}
+save_file(state, f"{out}/model.safetensors")
+model_sha = hashlib.sha256(open(f"{out}/model.safetensors", "rb").read()).hexdigest()
+
+config = {
+    "architecture": "GateMLP",
+    "task": "advisory-lambda-gate-decision-surrogate",
+    "framework": "pytorch",
+    "input_dim": K,
+    "input_axes": list(lg.YUYAY_AXES),
+    "hidden": HIDDEN,
+    "layers": ["Linear(13,64)", "ReLU", "Linear(64,64)", "ReLU", "Linear(64,64)", "ReLU", "Linear(64,1)"],
+    "output": "logit; sigmoid>=0.5 => predicted gate PASS (Λ>=threshold)",
+    "threshold": THRESHOLD,
+    "weights": "yuyay uniform 1/13",
+    "label_source": "szl_lambda_gate.lambda_gate(axes, weights=yuyay, threshold=0.5).passed",
+    "honesty": "predicts the ADVISORY gate DECISION only; Λ is NOT proven trust; uniqueness = Conjecture 1 (open)",
+}
+with open(f"{out}/config.json", "w") as f:
+    json.dump(config, f, indent=2)
+
+n_pos = int(yall.sum()); n_neg = int(N - n_pos)
+receipt = {
+  "artifact": "SZLHOLDINGS/szl-lambda-gate surrogate v1",
+  "role": "advisory Λ gate-decision surrogate (torch MLP) — kernel remains ground truth",
+  "generator": {"script": "scripts/forge.py", "seed": SEED, "kernel_version": lg.__version__,
+                 "kernel_labelled": True, "kernel_audited_samples": audit_checked,
+                 "labeler": "lambda_gate(axes, weights=yuyay_uniform_1/13, threshold=0.5).passed",
+                 "axes": list(lg.YUYAY_AXES), "threshold": THRESHOLD},
+  "data": {"rows": int(N), "classes": ["GATE_FAIL", "GATE_PASS"],
+            "class_counts": {"GATE_FAIL": n_neg, "GATE_PASS": n_pos},
+            "split": "80/20 permutation", "features": list(lg.YUYAY_AXES),
+            "feature_policy": "13 Yuyay axis scores in [0,1]; includes non-compensatory zero-route rows"},
+  "model": {"type": "pytorch GateMLP (3 hidden ReLU layers, 64 units)",
+             "params": {"input_dim": K, "hidden": HIDDEN, "epochs": EPOCHS, "batch": BATCH,
+                        "lr": 2e-3, "optimizer": "Adam", "loss": "BCEWithLogits", "seed": SEED},
+             "file": "model.safetensors", "sha256": model_sha, "config": "config.json"},
+  "metrics_MEASURED": {"fidelity_vs_kernel_heldout": round(acc, 4),
+                        "test_accuracy": round(acc, 4),
+                        "recall_GATE_PASS": round(rec_pass, 4),
+                        "recall_GATE_FAIL": round(rec_fail, 4)},
+  "environment": {"python": platform.python_version(), "torch": torch.__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. Fidelity = agreement%% with the kernel's ADVISORY lambda_gate decision on a held-out split. Λ is the weighted geometric mean, NOT proven trust; uniqueness = Conjecture 1 (open). The surrogate never replaces the kernel gate.",
+  "trained_at_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+}
+with open(f"{out}/TRAINING_RECEIPT.json", "w") as f:
+    json.dump(receipt, f, indent=2)
+print(json.dumps(receipt["metrics_MEASURED"], indent=2))
+print(f"rows={N} pos={n_pos} neg={n_neg} kernel_audited={audit_checked} wall={receipt['environment']['wall_seconds']}s")