Align version=1 with the strict Lambda v0.2.0 source

by betterwithage - opened about 12 hours ago

base: refs/heads/v1

←

from: refs/pr/2

Discussion Files changed

+5072

-556

Files changed (28) hide show

build.toml +5 -0
build/torch-cpu/__init__.py +2 -0
build/torch-cpu/metadata.json +1 -10
build/torch-cpu/szl_lambda_gate/__init__.py +216 -172
build/torch-cpu/szl_lambda_gate/_lambda.py +556 -313
build/torch-cpu/szl_lambda_gate/_ops.py +10 -10
build/torch-cpu/szl_lambda_gate/_v1.py +221 -0
build/torch-cpu/szl_lambda_gate/governed_norm/__init__.py +279 -0
build/torch-cpu/szl_lambda_gate/governed_norm/_norm.py +246 -0
build/torch-cpu/szl_lambda_gate/governed_norm/_receipt.py +253 -0
build/torch-cpu/szl_lambda_gate/governed_norm/layers.py +60 -0
build/torch-cpu/szl_lambda_gate/layers.py +54 -51
build/torch-universal/__init__.py +2 -0
build/torch-universal/metadata.json +1 -0
build/torch-universal/szl_lambda_gate/__init__.py +216 -0
build/torch-universal/szl_lambda_gate/_lambda.py +556 -0
build/torch-universal/szl_lambda_gate/_ops.py +10 -0
build/torch-universal/szl_lambda_gate/_v1.py +221 -0
build/torch-universal/szl_lambda_gate/governed_norm/__init__.py +279 -0
build/torch-universal/szl_lambda_gate/governed_norm/_norm.py +246 -0
build/torch-universal/szl_lambda_gate/governed_norm/_receipt.py +253 -0
build/torch-universal/szl_lambda_gate/governed_norm/layers.py +60 -0
build/torch-universal/szl_lambda_gate/layers.py +54 -0
distribution.json +1 -0
reference/szl_lambda_v1.py +205 -0
source/LICENSE +202 -0
spec/lambda_v1_vectors.json +730 -0
spec/szl.lambda.v1.json +133 -0

build.toml ADDED Viewed

	@@ -0,0 +1,5 @@

+[general]
+name = "szl_lambda_gate"
+[torch]
+universal = true

build/torch-cpu/__init__.py ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ from .szl_lambda_gate import * # noqa: F401,F403
2	+ from .szl_lambda_gate import __all__

build/torch-cpu/metadata.json CHANGED Viewed

@@ -1,10 +1 @@
-{
-  "name": "szl-lambda-gate",
-  "id": "_szl_lambda_gate_cpu_9cf02fddf8",
-  "version": 1,
-  "license": "Apache-2.0",
-  "python-depends": [],
-  "backend": {
-    "type": "cpu"
-  }
-}


1	+ {"backend":{"type":"cpu"},"digest":{"algorithm":"sha256","files":{"__init__.py":"NuinjlWRNlWgg0y2D61HEaKtW/VOktRHP8w2Nj3opjQ=","szl_lambda_gate/__init__.py":"QpfkkacuKUGxXitqBYLq0nM4NnCsX7uNFOLHbeye0V0=","szl_lambda_gate/_lambda.py":"+VOjgBnJGm+oqcQR9VuqT18rnnbXFTu6VLuKXZRprzg=","szl_lambda_gate/_ops.py":"at8dxC56nm2pFOME2pcgQ45ZwjQQThHz5cyqRezuI7Y=","szl_lambda_gate/_v1.py":"msLY/gpH/xkeunbmKx6d2bK1T2S6DD2GMG4M3Vi8Row=","szl_lambda_gate/governed_norm/__init__.py":"UP5PsJoWXQrpp4Hw7zUVOIx1KhTN6V9zaHhU9Zp9+tw=","szl_lambda_gate/governed_norm/_norm.py":"z3Ks4oHshsUEQm914j7r22YaHjoS5N/MbIufpjSwOUI=","szl_lambda_gate/governed_norm/_receipt.py":"2xJEvRhK/9ypKb04rHKLJpb4KtVlqvgtFMo4RdTXSKk=","szl_lambda_gate/governed_norm/layers.py":"15yDNVyyMyudDp2YWEuGQ05IZTLifTBlLfEBWLMPw3s=","szl_lambda_gate/layers.py":"UdpHjhhe5NFtqplxvcvc/LsMDFt4N6ACuXzQXLlo6nU="}},"id":"_szl_lambda_gate_cpu_7cb79cba7ecb5dbb9da59b2d6b516a98d2a114d6","license":"Apache-2.0","name":"szl-lambda-gate","python-depends":[],"source":"https://github.com/szl-holdings/szl-lambda-gate","universal":false,"version":1}

build/torch-cpu/szl_lambda_gate/__init__.py CHANGED Viewed

@@ -1,172 +1,216 @@
-# SPDX-License-Identifier: Apache-2.0
-# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
-"""szl_lambda_gate — the Lambda-Spine aggregator (Λ) as a universal kernel.
-A pure-PyTorch (universal) kernel from SZL Holdings for the Hugging Face
-Kernel Hub. It ports the canonical Λ aggregator into a differentiable,
-torch.compile-friendly torch op:
-    Λ(x) = ∏ xᵢ^{wᵢ},  Σwᵢ = 1,  wᵢ > 0,  xᵢ ∈ [0,1]   (weighted geometric mean)
-plus an ADVISORY governance gate (Λ vs threshold), the four carried axioms as
-real runtime self-checks, and pure nn.Module layers.
-Load from the Hub:
-    import torch
-    from kernels import get_kernel
-    lg = get_kernel("SZLHOLDINGS/szl-lambda-gate")
-    axes = torch.tensor([0.9, 0.8, 0.95])        # axis scores in [0,1]
-    score = lg.lambda_aggregate(axes)            # Λ(x) ∈ [0,1]
-    res = lg.lambda_gate(axes, threshold=0.5)    # ADVISORY pass/fail
-    print(res.score, res.passed, res.advisory)
-WHAT Λ IS / IS NOT (HONESTY — SZL Holdings doctrine v11):
-  Λ is the weighted-geometric-mean aggregator — a non-compensatory, ADVISORY
-  way to roll axis scores in [0,1] into one number (any zeroed axis zeroes the
-  aggregate). It is NOT "proven trust" and NOT a closed theorem: Λ-uniqueness
-  remains Conjecture 1 (OPEN — an unresolved CAUCHY_ND step plus a missing
-  symmetry axiom). Label it honestly everywhere; a gate "pass" is advisory.
-PROVENANCE: backed by the Lean 4 formalization szl-holdings/lutar-lean
-  (749 declarations / 14 axioms / 163 tracked sorries),
-  DOI 10.5281/zenodo.20434308 (lutar-lean). Λ uniqueness = Conjecture 1 (open).
-"""
-from typing import Optional
-import torch
-from . import layers  # noqa: F401  (must be importable for Hub layer mapping)
-from ._lambda import YUYAY_AXES, YUYAY_FLOORS, LambdaGateResult
-from ._lambda import find_axiom_violation as _find_axiom_violation
-from ._lambda import is_bounded_by_max as _is_bounded_by_max
-from ._lambda import is_egyptian_exact as _is_egyptian_exact
-from ._lambda import is_homogeneous as _is_homogeneous
-from ._lambda import is_monotone as _is_monotone
-from ._lambda import lambda_aggregate as _lambda_aggregate
-from ._lambda import lambda_gate as _lambda_gate
-from ._lambda import lambda_gate_batch as _lambda_gate_batch
-from ._lambda import selfcheck as _selfcheck
-from ._lambda import yuyay_weights as _yuyay_weights
-__all__ = [
-    "lambda_aggregate",
-    "lambda_gate",
-    "lambda_gate_batch",
-    "LambdaGateResult",
-    "is_monotone",
-    "is_egyptian_exact",
-    "is_bounded_by_max",
-    "is_homogeneous",
-    "find_axiom_violation",
-    "selfcheck",
-    "yuyay_weights",
-    "YUYAY_AXES",
-    "YUYAY_FLOORS",
-    "layers",
-    "DOCTRINE_FOOTER",
-    "PROVENANCE",
-    "__version__",
-]
-__version__ = "0.2.0"
-DOCTRINE_FOOTER = (
-    "SZL Holdings · Λ = Conjecture 1 (ADVISORY, weighted geometric mean) · "
-    "uniqueness OPEN · NOT proven trust · honesty over checklist"
-)
-PROVENANCE = {
-    "lean_repo": "szl-holdings/lutar-lean",
-    "lean_declarations": 749,
-    "lean_axioms": 14,
-    "lean_tracked_sorries": 163,
-    "doi_lutar_lean": "10.5281/zenodo.20434308",
-    "lambda_status": "Conjecture 1 (open) — uniqueness unproven; advisory only",
-}
-def lambda_aggregate(
-    axes: torch.Tensor,
-    weights: Optional[torch.Tensor] = None,
-) -> torch.Tensor:
-    """Λ(x) = ∏ xᵢ^{wᵢ}, the weighted geometric mean over the last dim of axes.
-    See ``szl_lambda_gate._lambda.lambda_aggregate``. Axis scores in [0,1],
-    uniform weights when ``weights`` is None. Differentiable, batched, and
-    torch.compile-friendly. ADVISORY — NOT proven trust.
-    """
-    return _lambda_aggregate(axes, weights=weights)
-def lambda_gate(
-    axes: torch.Tensor,
-    weights: Optional[torch.Tensor] = None,
-    threshold: float = 0.5,
-) -> LambdaGateResult:
-    """ADVISORY Λ governance gate: returns LambdaGateResult(score, passed,
-    threshold, advisory). ``passed`` = Λ(axes) >= threshold. A pass is an
-    advisory, non-compensatory signal — NOT proven trust (Λ = Conjecture 1).
-    """
-    return _lambda_gate(axes, weights=weights, threshold=threshold)
-def lambda_gate_batch(
-    candidates: torch.Tensor,
-    weights: Optional[torch.Tensor] = None,
-    threshold: float = 0.5,
-) -> LambdaGateResult:
-    """ADVISORY batch gate over many candidate action-vectors (shape (..., N, k)).
-    The realistic per-inference-step call: score all N candidates at once and
-    return the advisory pass mask. Returns LambdaGateResult(score, passed,
-    threshold, advisory) with score/passed of shape (..., N). NOT proven trust.
-    """
-    return _lambda_gate_batch(candidates, weights=weights, threshold=threshold)
-def yuyay_weights(dtype: torch.dtype = torch.float64, device=None) -> torch.Tensor:
-    """Canonical 13-axis Yuyay Λ weight vector (uniform 1/13), ADVISORY only.
-    Use as ``weights`` over the 13 ``YUYAY_AXES``. The yuyay_v3 gate is a
-    conjunctive AND with per-axis floors (``YUYAY_FLOORS``); this Λ roll-up is
-    the weighted geometric mean and is ADVISORY — NOT proven trust.
-    """
-    return _yuyay_weights(dtype=dtype, device=device)
-def find_axiom_violation(k=5, trials=200, weights=None, seed=0, tol=1e-6):
-    """Random-search for any A1–A4 violation; returns (axiom, axes, weights) or
-    None. An honest falsification attempt — finding nothing is evidence, not a
-    proof (Λ-uniqueness is Conjecture 1, open).
-    """
-    return _find_axiom_violation(k=k, trials=trials, weights=weights, seed=seed, tol=tol)
-def selfcheck(k=5, trials=64, seed=0) -> dict:
-    """Expose the A1–A4 empirical self-checks + version as a single verdict dict.
-    Callable as get_kernel(...).selfcheck(). EMPIRICAL checks on sampled inputs,
-    NOT a proof of Λ-uniqueness (Conjecture 1, open). Advisory only.
-    """
-    return _selfcheck(k=k, trials=trials, seed=seed)
-# ---- axiom runtime self-checks (real, verifiable; NOT a uniqueness proof) -- #
-def is_monotone(axes, weights=None, delta=0.05, tol=1e-7) -> bool:
-    """A1 IsMonotone self-check: Λ is non-decreasing in each axis (on this data)."""
-    return _is_monotone(axes, weights=weights, delta=delta, tol=tol)
-def is_egyptian_exact(c, k=3, weights=None, tol=1e-5) -> bool:
-    """A3 IsEgyptianExact self-check: Λ(c, …, c) = c."""
-    return _is_egyptian_exact(c, k=k, weights=weights, tol=tol)
-def is_bounded_by_max(axes, weights=None, tol=1e-6) -> bool:
-    """A4 IsBounded self-check: Λ(x) ≤ maxᵢ xᵢ."""
-    return _is_bounded_by_max(axes, weights=weights, tol=tol)
-def is_homogeneous(axes, t, weights=None, tol=1e-5) -> bool:
-    """A2 IsHomogeneous(degree 1) self-check: Λ(t·x) = t·Λ(x)."""
-    return _is_homogeneous(axes, t, weights=weights, tol=tol)

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""szl_lambda_gate — the Lambda-Spine aggregator (Λ) as a universal kernel.
+A pure-PyTorch (universal) kernel from SZL Holdings for the Hugging Face
+Kernel Hub. It ports the canonical Λ aggregator into a differentiable,
+torch.compile-friendly torch op:
+    Λ(x) = ∏ xᵢ^{wᵢ},  Σwᵢ = 1,  wᵢ > 0,  xᵢ ∈ [0,1]   (weighted geometric mean)
+plus an ADVISORY governance gate (Λ vs threshold), the four carried axioms as
+real runtime self-checks, and pure nn.Module layers.
+Load from the Hub:
+    import torch
+    from kernels import get_kernel
+    lg = get_kernel("SZLHOLDINGS/szl-lambda-gate")
+    axes = torch.tensor([0.9, 0.8, 0.95])        # axis scores in [0,1]
+    score = lg.lambda_aggregate(axes)            # Λ(x) ∈ [0,1]
+    res = lg.lambda_gate(axes, threshold=0.5)    # ADVISORY pass/fail
+    print(res.score, res.passed, res.advisory)
+    # szl.lambda/v1 strict gate (spec/szl.lambda.v1.json): no clamping, no
+    # renormalisation, tau required; bad input -> verdict BLOCK with a code.
+    w = torch.tensor([0.4, 0.3, 0.3], dtype=torch.float64)
+    v1 = lg.lambda_v1_gate(axes.double(), w, tau=0.8)
+    print(v1.verdict, v1.code)                   # GO / NO_GO / ABSTAIN / BLOCK
+WHAT Λ IS / IS NOT (HONESTY — SZL Holdings doctrine v11):
+  Λ is the weighted-geometric-mean aggregator — a non-compensatory, ADVISORY
+  way to roll axis scores in [0,1] into one number (any zeroed axis zeroes the
+  aggregate). It is NOT "proven trust" and NOT a closed theorem: Λ-uniqueness
+  remains Conjecture 1 (OPEN — an unresolved CAUCHY_ND step plus a missing
+  symmetry axiom). Label it honestly everywhere; a gate "pass" is advisory.
+PROVENANCE: backed by the Lean 4 formalization szl-holdings/lutar-lean
+  (749 declarations / 14 axioms / 163 tracked sorries),
+  DOI 10.5281/zenodo.20434308 (lutar-lean). Λ uniqueness = Conjecture 1 (open).
+"""
+from typing import Optional
+import torch
+from . import layers  # noqa: F401  (must be importable for Hub layer mapping)
+# CONSOLIDATION (Wave D): the governed-norm universal kernel is folded in here
+# as a subpackage so szl-lambda-gate is the ONE canonical kernels package. The
+# source repo szl-holdings/szl-governed-norm is DEPRECATED and points here;
+# nothing was deleted (additive, reversible copy). Λ stays Conjecture 1.
+from . import governed_norm  # noqa: F401  (folded-in governed normalization kernels)
+from ._lambda import YUYAY_AXES, YUYAY_FLOORS, LambdaGateResult
+from ._lambda import _resolve_threshold
+from ._lambda import find_axiom_violation as _find_axiom_violation
+from ._lambda import is_bounded_by_max as _is_bounded_by_max
+from ._lambda import is_egyptian_exact as _is_egyptian_exact
+from ._lambda import is_homogeneous as _is_homogeneous
+from ._lambda import is_monotone as _is_monotone
+from ._lambda import lambda_aggregate as _lambda_aggregate
+from ._lambda import lambda_gate as _lambda_gate
+from ._lambda import lambda_gate_batch as _lambda_gate_batch
+from ._lambda import selfcheck as _selfcheck
+from ._lambda import yuyay_weights as _yuyay_weights
+# szl.lambda/v1 strict entry (spec/szl.lambda.v1.json): validated, coded, tau required.
+from ._v1 import LambdaV1Error, LambdaV1GateResult, lambda_v1, lambda_v1_gate
+__all__ = [
+    "lambda_aggregate",
+    "lambda_gate",
+    "lambda_gate_batch",
+    "LambdaGateResult",
+    "lambda_v1",
+    "lambda_v1_gate",
+    "LambdaV1Error",
+    "LambdaV1GateResult",
+    "is_monotone",
+    "is_egyptian_exact",
+    "is_bounded_by_max",
+    "is_homogeneous",
+    "find_axiom_violation",
+    "selfcheck",
+    "yuyay_weights",
+    "YUYAY_AXES",
+    "YUYAY_FLOORS",
+    "layers",
+    "DOCTRINE_FOOTER",
+    "PROVENANCE",
+    "__version__",
+    # ---- folded-in governed-norm kernels (Wave D consolidation) ----
+    "governed_norm",
+    "rms_norm",
+    "layer_norm",
+    "fused_add_rms_norm",
+]
+# ---- folded-in governed-norm surface (Wave D consolidation) ---------------- #
+# Convenience top-level re-exports of the governed normalization kernels that
+# were absorbed from szl-governed-norm. The full surface (ReceiptChain,
+# emit_receipt, receipt_* helpers, selfcheck, layers) lives under
+# ``szl_lambda_gate.governed_norm``. These are a DIFFERENT kernel family from Λ
+# (normalization, not the Λ aggregator); Λ itself remains Conjecture 1
+# (advisory, uniqueness OPEN) and is never described as proven trust.
+rms_norm = governed_norm.rms_norm
+layer_norm = governed_norm.layer_norm
+fused_add_rms_norm = governed_norm.fused_add_rms_norm
+__version__ = "0.2.0"
+DOCTRINE_FOOTER = (
+    "SZL Holdings · Λ = Conjecture 1 (ADVISORY, weighted geometric mean) · "
+    "uniqueness OPEN · NOT proven trust · honesty over checklist"
+)
+PROVENANCE = {
+    "lean_repo": "szl-holdings/lutar-lean",
+    "lean_declarations": 749,
+    "lean_axioms": 14,
+    "lean_tracked_sorries": 163,
+    "doi_lutar_lean": "10.5281/zenodo.20434308",
+    "lambda_status": "Conjecture 1 (open) — uniqueness unproven; advisory only",
+}
+def lambda_aggregate(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    """Λ(x) = ∏ xᵢ^{wᵢ}, the weighted geometric mean over the last dim of axes.
+    See ``szl_lambda_gate._lambda.lambda_aggregate``. Axis scores in [0,1],
+    uniform weights when ``weights`` is None. Differentiable, batched, and
+    torch.compile-friendly. ADVISORY — NOT proven trust.
+    """
+    return _lambda_aggregate(axes, weights=weights)
+def lambda_gate(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    threshold: Optional[float] = None,
+) -> LambdaGateResult:
+    """ADVISORY Λ governance gate: returns LambdaGateResult(score, passed,
+    threshold, advisory). ``passed`` = Λ(axes) >= threshold. ``threshold`` must
+    lie within Λ's range [0,1] (a value outside it is a misconfiguration — a
+    negative threshold would advisory-pass a fully-failing Λ=0 candidate — and
+    is rejected). Omitting it uses the legacy 0.5 with a DeprecationWarning
+    (policy_tau is 0.8); pass it, or use ``lambda_v1_gate(axes, weights, tau)``.
+    A pass is an advisory, non-compensatory signal — NOT proven trust
+    (Λ = Conjecture 1).
+    """
+    threshold = _resolve_threshold(threshold, stacklevel=2)
+    return _lambda_gate(axes, weights=weights, threshold=threshold)
+def lambda_gate_batch(
+    candidates: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    threshold: Optional[float] = None,
+) -> LambdaGateResult:
+    """ADVISORY batch gate over many candidate action-vectors (shape (..., N, k)).
+    The realistic per-inference-step call: score all N candidates at once and
+    return the advisory pass mask. Returns LambdaGateResult(score, passed,
+    threshold, advisory) with score/passed of shape (..., N). ``threshold``
+    must lie within Λ's range [0,1] (same domain guard as ``lambda_gate``);
+    omitting it uses the legacy 0.5 with a DeprecationWarning.
+    NOT proven trust.
+    """
+    threshold = _resolve_threshold(threshold, stacklevel=2)
+    return _lambda_gate_batch(candidates, weights=weights, threshold=threshold)
+def yuyay_weights(dtype: torch.dtype = torch.float64, device=None) -> torch.Tensor:
+    """Canonical 13-axis Yuyay Λ weight vector (uniform 1/13), ADVISORY only.
+    Use as ``weights`` over the 13 ``YUYAY_AXES``. The yuyay_v3 gate is a
+    conjunctive AND with per-axis floors (``YUYAY_FLOORS``); this Λ roll-up is
+    the weighted geometric mean and is ADVISORY — NOT proven trust.
+    """
+    return _yuyay_weights(dtype=dtype, device=device)
+def find_axiom_violation(k=5, trials=200, weights=None, seed=0, tol=1e-6):
+    """Random-search for any A1–A4 violation; returns (axiom, axes, weights) or
+    None. An honest falsification attempt — finding nothing is evidence, not a
+    proof (Λ-uniqueness is Conjecture 1, open).
+    """
+    return _find_axiom_violation(k=k, trials=trials, weights=weights, seed=seed, tol=tol)
+def selfcheck(k=5, trials=64, seed=0) -> dict:
+    """Expose the A1–A4 empirical self-checks + version as a single verdict dict.
+    Callable as get_kernel(...).selfcheck(). EMPIRICAL checks on sampled inputs,
+    NOT a proof of Λ-uniqueness (Conjecture 1, open). Advisory only.
+    """
+    return _selfcheck(k=k, trials=trials, seed=seed)
+# ---- axiom runtime self-checks (real, verifiable; NOT a uniqueness proof) -- #
+def is_monotone(axes, weights=None, delta=0.05, tol=1e-7) -> bool:
+    """A1 IsMonotone self-check: Λ is non-decreasing in each axis (on this data)."""
+    return _is_monotone(axes, weights=weights, delta=delta, tol=tol)
+def is_egyptian_exact(c, k=3, weights=None, tol=1e-5) -> bool:
+    """A3 IsEgyptianExact self-check: Λ(c, …, c) = c."""
+    return _is_egyptian_exact(c, k=k, weights=weights, tol=tol)
+def is_bounded_by_max(axes, weights=None, tol=1e-6) -> bool:
+    """A4 IsBounded self-check: Λ(x) ≤ maxᵢ xᵢ."""
+    return _is_bounded_by_max(axes, weights=weights, tol=tol)
+def is_homogeneous(axes, t, weights=None, tol=1e-5) -> bool:
+    """A2 IsHomogeneous(degree 1) self-check: Λ(t·x) = t·Λ(x)."""
+    return _is_homogeneous(axes, t, weights=weights, tol=tol)

build/torch-cpu/szl_lambda_gate/_lambda.py CHANGED Viewed

@@ -1,313 +1,556 @@
-# SPDX-License-Identifier: Apache-2.0
-# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
-"""Pure-PyTorch Lambda-Spine aggregator (Λ) for the szl-lambda-gate kernel.
-Λ(x) = ∏ xᵢ^{wᵢ},  Σwᵢ = 1,  wᵢ > 0,  xᵢ ∈ [0,1]   (weighted geometric mean)
-This is a TORCH port of the canonical pure-Python reference. It is a
-correctness reference, computed via logs in float32 for stability,
-differentiable (autograd works), and torch.compile-friendly. Depends ONLY on
-torch + the Python standard library (a Kernel Hub requirement for universal
-kernels).
-WHAT Λ IS / IS NOT (HONESTY — SZL Holdings doctrine v11):
-  Λ is the *weighted-geometric-mean aggregator*: a non-compensatory way to
-  combine axis scores in [0,1] into one number. It is an ADVISORY governance
-  signal — a conservative roll-up where any single zeroed axis drives the
-  aggregate to 0. It is NOT "proven trust" and NOT a closed theorem. Its
-  *uniqueness* remains Conjecture 1 — OPEN (an unresolved CAUCHY_ND step plus a
-  missing symmetry axiom in the Lean development). Do not describe Λ as proven
-  trust anywhere.
-PRIOR ART (honest attribution): the weighted geometric mean as a less-
-  compensatory composite-indicator aggregator is established practice — the UN
-  HDI (arithmetic→geometric switch, 2010) and the OECD Handbook on Constructing
-  Composite Indicators (2008) both use it to limit the compensation effect. The
-  veto / cut-off idea (a single failing criterion blocks a pass) is the ELECTRE
-  veto threshold. The 13-axis conjunctive form (yuyay_weights) is SZL's own
-  yuyay_v3 gate. None of this makes Λ "proven trust"; the gate is ADVISORY.
-PROVENANCE: backed by the Lean 4 formalization szl-holdings/lutar-lean
-  (749 declarations / 14 axioms / 163 tracked sorries),
-  DOI 10.5281/zenodo.20434308 (lutar-lean). Λ uniqueness = Conjecture 1 (open).
-Axioms carried (Lutar/Axioms.lean), available below as runtime self-checks:
-  A1 IsMonotone        — Λ is non-decreasing in each axis
-  A2 IsHomogeneous     — Λ(t·x) = t·Λ(x)  (degree 1)
-  A3 IsEgyptianExact   — Λ(c,…,c) = c       (the uniform-diagonal fixpoint)
-  A4 IsBounded(by max) — Λ(x) ≤ maxᵢ xᵢ
-"""
-from typing import Optional
-import torch
-_SUPPORTED_DTYPES = (torch.float16, torch.bfloat16, torch.float32, torch.float64)
-def _compute_dtype(in_dtype: torch.dtype) -> torch.dtype:
-    return torch.float32 if in_dtype in (torch.float16, torch.bfloat16) else in_dtype
-def _check_axes(axes: torch.Tensor) -> None:
-    """Cheap, allocation-free metadata guards on the axis-score tensor."""
-    if not isinstance(axes, torch.Tensor):
-        raise TypeError(f"axes must be a torch.Tensor, got {type(axes).__name__}")
-    if axes.dtype not in _SUPPORTED_DTYPES:
-        raise TypeError(
-            f"axes has unsupported dtype {axes.dtype}; "
-            f"expected one of {tuple(str(d) for d in _SUPPORTED_DTYPES)}"
-        )
-    if axes.dim() < 1:
-        raise ValueError(
-            "axes must have at least 1 dimension (the k axis scores live on "
-            f"the last dim); got a {axes.dim()}-d tensor"
-        )
-    if axes.shape[-1] < 1:
-        raise ValueError("axes last dimension (k = number of axes) must be >= 1")
-def _resolve_weights(
-    axes: torch.Tensor,
-    weights: Optional[torch.Tensor],
-    cdt: torch.dtype,
-) -> torch.Tensor:
-    """Return a normalized (Σw = 1) weight vector of shape (k,) in compute dtype."""
-    k = axes.shape[-1]
-    if weights is None:
-        return torch.full((k,), 1.0 / k, dtype=cdt, device=axes.device)
-    if not isinstance(weights, torch.Tensor):
-        raise TypeError(f"weights must be a torch.Tensor or None, got {type(weights).__name__}")
-    if weights.device != axes.device:
-        raise ValueError(
-            f"weights is on device {weights.device} but axes is on {axes.device}; "
-            "move them to the same device"
-        )
-    if weights.dim() != 1 or weights.shape[0] != k:
-        raise ValueError(
-            f"weights must be 1-D with shape ({k},) to match the last dim of axes; "
-            f"got shape {tuple(weights.shape)}"
-        )
-    wf = weights.to(cdt)
-    if not bool(torch.all(torch.isfinite(wf))):
-        raise ValueError("weights must all be finite (no NaN/Inf)")
-    if bool(torch.any(wf <= 0.0)):
-        raise ValueError("weights must be strictly positive (wᵢ > 0)")
-    sw = wf.sum()
-    if not bool(sw > 0.0):
-        raise ValueError("weights must sum to a positive value")
-    return wf / sw
-def lambda_aggregate(
-    axes: torch.Tensor,
-    weights: Optional[torch.Tensor] = None,
-) -> torch.Tensor:
-    """Weighted geometric mean Λ(x) = ∏ xᵢ^{wᵢ} over the last dim of ``axes``.
-    Axis scores expected in [0,1] and clamped into [0,1]; uniform weights (1/k)
-    when ``weights`` is None. Computed via logs for stability:
-        Λ(x) = exp( Σᵢ wᵢ · log(clamp(xᵢ, 0, 1)) )
-    Non-compensatory zero-routing (A4-consistent): any axis that is zero, OR
-    that is NON-FINITE (NaN / ±Inf), is treated as a FAILING axis and drives
-    the whole aggregate to exactly 0. A garbage/invalid axis must never silently
-    pass as a perfect (clamped-to-1) axis; output and gradient stay finite and
-    in [0,1] for every input.
-    Returns a tensor of shape (...) — Λ(x) ∈ [0,1] per batch row, differentiable
-    w.r.t. ``axes``.
-    HONESTY: a non-compensatory governance roll-up, NOT proven trust.
-    Λ-uniqueness is Conjecture 1 (open).
-    """
-    _check_axes(axes)
-    in_dtype = axes.dtype
-    cdt = _compute_dtype(in_dtype)
-    xf = axes.to(cdt)
-    w = _resolve_weights(axes, weights, cdt)  # (k,), Σw=1
-    finite_mask = torch.isfinite(xf)
-    xc = xf.clamp(0.0, 1.0)
-    bad_mask = (~finite_mask) | (xc <= 0.0)
-    any_bad = torch.any(bad_mask, dim=-1)  # (...)
-    safe = torch.where(bad_mask, torch.ones_like(xc), xc)
-    logx = torch.log(safe)                    # (..., k)
-    acc = (logx * w).sum(dim=-1)              # (...)
-    val = torch.exp(acc)                      # (...)
-    out = torch.where(any_bad, torch.zeros_like(val), val)
-    out = out.clamp(0.0, 1.0)
-    return out.to(in_dtype)
-def lambda_gate(
-    axes: torch.Tensor,
-    weights: Optional[torch.Tensor] = None,
-    threshold: float = 0.5,
-):
-    """ADVISORY governance gate over Λ(x): score plus a pass/fail vs threshold.
-    Returns a :class:`LambdaGateResult` namedtuple (score, passed, threshold,
-    advisory). ``passed`` := Λ(x) >= threshold; ``advisory`` is always True.
-    HONESTY: a "pass" is an ADVISORY signal only. Λ is the weighted-geometric-
-    mean aggregator; its uniqueness is Conjecture 1 (open). Do not treat a pass
-    as proven trust or a closed theorem.
-    """
-    t = float(threshold)
-    if t != t or t == float("inf") or t == float("-inf"):
-        raise ValueError(f"threshold must be a finite float, got {threshold!r}")
-    score = lambda_aggregate(axes, weights)
-    passed = score >= t
-    return LambdaGateResult(score=score, passed=passed, threshold=t, advisory=True)
-def lambda_gate_batch(
-    candidates: torch.Tensor,
-    weights: Optional[torch.Tensor] = None,
-    threshold: float = 0.5,
-):
-    """ADVISORY batch gate: score MANY candidate action-vectors in one call.
-    ``candidates`` is shape (..., N, k): last dim ``k`` is per-axis scores of one
-    candidate, the dim before it enumerates the N candidates. Returns a
-    :class:`LambdaGateResult` with score/passed of shape (..., N).
-    HONESTY: the pass mask is ADVISORY, non-compensatory. NOT proven trust;
-    Λ-uniqueness is Conjecture 1 (open).
-    """
-    _check_axes(candidates)
-    if candidates.dim() < 2:
-        raise ValueError(
-            "candidates must be at least 2-D, shape (..., N, k); "
-            f"got a {candidates.dim()}-d tensor"
-        )
-    return lambda_gate(candidates, weights=weights, threshold=threshold)
-# ---- A1..A4 axiom RUNTIME self-checks (real, verifiable) ------------------- #
-def is_egyptian_exact(c, k: int = 3, weights=None, tol: float = 1e-5) -> bool:
-    """A3 IsEgyptianExact: Λ(c, …, c) = c for a constant axis vector of length k."""
-    if k < 1:
-        raise ValueError("k must be >= 1")
-    cc = min(max(float(c), 0.0), 1.0)
-    axes = torch.full((k,), cc, dtype=torch.float64)
-    val = lambda_aggregate(axes, weights)
-    return bool(torch.abs(val - cc) <= tol)
-def is_bounded_by_max(axes: torch.Tensor, weights=None, tol: float = 1e-6) -> bool:
-    """A4 IsBounded: Λ(x) ≤ maxᵢ xᵢ (over the last dim), within ``tol``."""
-    _check_axes(axes)
-    val = lambda_aggregate(axes, weights)
-    xf = axes.to(_compute_dtype(axes.dtype))
-    xf = torch.where(torch.isfinite(xf), xf, torch.zeros_like(xf))
-    mx = xf.clamp(0.0, 1.0).amax(dim=-1)
-    return bool(torch.all(val.to(mx.dtype) <= mx + tol))
-def is_homogeneous(axes: torch.Tensor, t, weights=None, tol: float = 1e-5) -> bool:
-    """A2 IsHomogeneous (degree 1): Λ(t·x) = t·Λ(x) for scalar t in [0,1]."""
-    _check_axes(axes)
-    tt = min(max(float(t), 0.0), 1.0)
-    x = axes.to(torch.float64).clamp(0.0, 1.0)
-    lhs = lambda_aggregate(x * tt, weights)
-    rhs = tt * lambda_aggregate(x, weights)
-    return bool(torch.all(torch.abs(lhs - rhs) <= tol))
-def is_monotone(axes: torch.Tensor, weights=None, delta: float = 0.05, tol: float = 1e-7) -> bool:
-    """A1 IsMonotone: Λ is non-decreasing in each axis."""
-    _check_axes(axes)
-    x = axes.to(torch.float64).clamp(0.0, 1.0)
-    base = lambda_aggregate(x, weights)
-    k = x.shape[-1]
-    ok = True
-    for j in range(k):
-        bumped = x.clone()
-        bumped[..., j] = (bumped[..., j] + float(delta)).clamp(0.0, 1.0)
-        bumped_val = lambda_aggregate(bumped, weights)
-        ok = ok and bool(torch.all(bumped_val - base >= -tol))
-    return ok
-def find_axiom_violation(k: int = 5, trials: int = 200, weights=None, seed=0, tol: float = 1e-6):
-    """Random-search for ANY A1–A4 violation. Returns the first violating triple
-    ``(axiom, axes, weights)`` or ``None``. An honest FALSIFICATION attempt —
-    finding nothing is empirical evidence, NOT a proof (Λ-uniqueness = Conjecture 1).
-    """
-    gen = torch.Generator()
-    if seed is not None:
-        gen.manual_seed(int(seed))
-    for _ in range(int(trials)):
-        x = torch.rand(k, generator=gen, dtype=torch.float64)
-        w = weights
-        if w is None:
-            w = torch.rand(k, generator=gen, dtype=torch.float64) + 1e-3
-        c = float(torch.rand(1, generator=gen).item())
-        if not is_egyptian_exact(c, k=k, weights=w, tol=max(tol, 1e-5)):
-            return ("A3_IsEgyptianExact", torch.full((k,), c, dtype=torch.float64), w)
-        if not is_bounded_by_max(x, w, tol=max(tol, 1e-6)):
-            return ("A4_IsBounded", x, w)
-        t = float(torch.rand(1, generator=gen).item())
-        if not is_homogeneous(x, t, weights=w, tol=max(tol, 1e-5)):
-            return ("A2_IsHomogeneous", x, w)
-        if not is_monotone(x * 0.9, w, tol=max(tol, 1e-7)):
-            return ("A1_IsMonotone", x * 0.9, w)
-    return None
-# ---- Canonical 13-axis Yuyay preset (ADVISORY ONLY) ------------------------ #
-YUYAY_AXES = (
-    "moralGrounding", "measurabilityHonesty", "empiricalGrounding",
-    "logicalConsistency", "sourceTransparency", "reproducibility",
-    "licenseHygiene", "scopeDiscipline", "claimCalibration", "evalAwareness",
-    "deceptionKeywords", "conflictingDirectives", "reversalDirective",
-)
-YUYAY_FLOORS = (
-    0.95, 0.95,
-    0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90,
-    0.90, 0.90, 0.90, 0.90,
-)
-def yuyay_weights(dtype: torch.dtype = torch.float64, device=None) -> torch.Tensor:
-    """Canonical 13-axis Yuyay Λ weight vector (uniform 1/13), ADVISORY only."""
-    k = len(YUYAY_AXES)
-    return torch.full((k,), 1.0 / k, dtype=dtype, device=device)
-def selfcheck(k: int = 5, trials: int = 64, seed=0) -> dict:
-    """Run the A1–A4 empirical self-checks and report a verdict + version.
-    HONESTY: EMPIRICAL checks on sampled inputs, NOT a proof of Λ-uniqueness
-    (Conjecture 1, open). A clean run is evidence, not proof.
-    """
-    x = torch.rand(k, dtype=torch.float64) * 0.9
-    w = torch.rand(k, dtype=torch.float64) + 1e-3
-    axioms = {
-        "A1_IsMonotone": is_monotone(x, w),
-        "A2_IsHomogeneous": is_homogeneous(x, float(torch.rand(1).item()), weights=w),
-        "A3_IsEgyptianExact": is_egyptian_exact(float(torch.rand(1).item()), k=k, weights=w),
-        "A4_IsBounded": is_bounded_by_max(x, w),
-    }
-    violation = find_axiom_violation(k=k, trials=trials, seed=seed)
-    return {
-        "version": __version__,
-        "axioms": axioms,
-        "all_axioms_hold": all(axioms.values()) and violation is None,
-        "adversarial": {"trials": int(trials), "violation": violation},
-        "advisory": True,
-        "lambda_status": "Conjecture 1 (open) — uniqueness unproven; advisory only",
-    }
-__version__ = "0.2.0"
-from collections import namedtuple  # noqa: E402
-LambdaGateResult = namedtuple(
-    "LambdaGateResult", ["score", "passed", "threshold", "advisory"]
-)

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Pure-PyTorch Lambda-Spine aggregator (Λ) for the szl-lambda-gate kernel.
+Λ(x) = ∏ xᵢ^{wᵢ},  Σwᵢ = 1,  wᵢ > 0,  xᵢ ∈ [0,1]   (weighted geometric mean)
+This is a TORCH port of the canonical pure-Python reference
+(packages/puriq-os/puriq_os/lambda_aggregator.py — saved alongside this kernel
+as lambda_aggregator_source.py). It is a correctness reference, computed via
+logs in float32 for stability, differentiable (autograd works), and
+torch.compile-friendly. Depends ONLY on torch + the Python standard library
+(a Kernel Hub requirement for universal kernels).
+WHAT Λ IS / IS NOT (HONESTY — SZL Holdings doctrine v11):
+  Λ is the *weighted-geometric-mean aggregator*: a non-compensatory way to
+  combine axis scores in [0,1] into one number. It is ADVISORY governance
+  signal — a conservative roll-up where any single zeroed axis drives the
+  aggregate to 0. It is NOT "proven trust" and NOT a closed theorem. Its
+  *uniqueness* (that the weighted geometric mean is the only aggregator
+  satisfying the carried axioms) remains Conjecture 1 — OPEN (an unresolved
+  CAUCHY_ND step plus a missing symmetry axiom in the Lean development). Do
+  not describe Λ as proven trust anywhere.
+PRIOR ART (honest attribution): the weighted geometric mean as a *less-
+  compensatory* composite-indicator aggregator is established practice — the
+  UN HDI (arithmetic→geometric switch, 2010), the OECD Handbook on
+  Constructing Composite Indicators (2008), and the UNECE well-being
+  guidelines all use it "to limit the compensation effect". The veto / cut-off
+  idea (a single failing criterion blocks a pass regardless of the others) is
+  the ELECTRE veto threshold / "satisficing" minimum-threshold screen. The
+  13-axis conjunctive form exposed by :func:`yuyay_weights` is SZL's own
+  yuyay_v3 "Heart" gate. None of this makes Λ "proven trust"; the gate is
+  ADVISORY (a11oy: "the advisory Λ trust score is a research conjecture, not a
+  pass/fail oracle").
+PROVENANCE: backed by the Lean 4 formalization szl-holdings/lutar-lean
+  (749 declarations / 14 axioms / 163 tracked sorries),
+  DOI 10.5281/zenodo.20434308 (lutar-lean).
+  Λ uniqueness = Conjecture 1 (open).
+Axioms carried (Lutar/Axioms.lean), available below as runtime self-checks:
+  A1 IsMonotone        — Λ is non-decreasing in each axis
+  A2 IsHomogeneous     — Λ(t·x) = t·Λ(x)  (degree 1)
+  A3 IsEgyptianExact   — Λ(c,…,c) = c       (the uniform-diagonal fixpoint)
+  A4 IsBounded(by max) — Λ(x) ≤ maxᵢ xᵢ
+"""
+import warnings
+from typing import Optional
+import torch
+# ---- the deprecated implicit threshold ------------------------------------- #
+# lambda_gate / lambda_gate_batch / layers.LambdaGate used to default to 0.5.
+# That default stays, so there is no behaviour change, but omitting the
+# threshold now raises a DeprecationWarning. The admit policy value is
+# policy_tau in frontier/model_admit_contract.v1.json, and the strict
+# szl.lambda/v1 gate (_v1.lambda_v1_gate) takes tau as a required argument.
+_LEGACY_DEFAULT_THRESHOLD = 0.5
+_DEFAULT_THRESHOLD_WARNING = (
+    "default threshold 0.5 differs from policy_tau 0.8; pass tau. Omitting the "
+    "threshold of lambda_gate / lambda_gate_batch / LambdaGate is deprecated: "
+    "pass threshold= explicitly (policy_tau is in "
+    "frontier/model_admit_contract.v1.json), or use the strict "
+    "lambda_v1_gate(axes, weights, tau). The legacy default 0.5 still applies."
+)
+def _resolve_threshold(threshold: Optional[float], stacklevel: int) -> float:
+    """``None`` (the threshold was omitted) -> the legacy 0.5, with a DeprecationWarning.
+    ``stacklevel`` is what the calling entry point would pass to
+    ``warnings.warn`` itself (2 = its caller), so the warning names the line
+    that omitted the threshold. Dynamo cannot trace ``warnings.warn`` (a
+    fullgraph compile would fail), so the warning is skipped while
+    ``torch.compile`` traces; the default is applied either way.
+    """
+    if threshold is not None:
+        return threshold
+    if not bool(getattr(torch.compiler, "is_compiling", lambda: False)()):
+        warnings.warn(_DEFAULT_THRESHOLD_WARNING, DeprecationWarning, stacklevel=stacklevel + 1)
+    return _LEGACY_DEFAULT_THRESHOLD
+# Compute reductions/log-sum in float32 for stability when inputs are low
+# precision; keep float64 inputs in float64 (downcasting would break gradcheck
+# and silently lose precision).
+_SUPPORTED_DTYPES = (torch.float16, torch.bfloat16, torch.float32, torch.float64)
+def _compute_dtype(in_dtype: torch.dtype) -> torch.dtype:
+    return torch.float32 if in_dtype in (torch.float16, torch.bfloat16) else in_dtype
+def _check_axes(axes: torch.Tensor) -> None:
+    """Cheap, allocation-free metadata guards on the axis-score tensor.
+    Inspects only type / dtype / rank / last-dim, so it constant-folds under
+    torch.compile and adds no tensor work on the happy path.
+    """
+    if not isinstance(axes, torch.Tensor):
+        raise TypeError(f"axes must be a torch.Tensor, got {type(axes).__name__}")
+    if axes.dtype not in _SUPPORTED_DTYPES:
+        raise TypeError(
+            f"axes has unsupported dtype {axes.dtype}; "
+            f"expected one of {tuple(str(d) for d in _SUPPORTED_DTYPES)}"
+        )
+    if axes.dim() < 1:
+        raise ValueError(
+            "axes must have at least 1 dimension (the k axis scores live on "
+            f"the last dim); got a {axes.dim()}-d tensor"
+        )
+    if axes.shape[-1] < 1:
+        raise ValueError("axes last dimension (k = number of axes) must be >= 1")
+def _resolve_weights(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor],
+    cdt: torch.dtype,
+) -> torch.Tensor:
+    """Return a normalized (Σw = 1) weight vector of shape (k,) in compute dtype.
+    ``weights=None`` -> uniform 1/k (the Egyptian-exact diagonal). Otherwise the
+    weights must be 1-D of length k, strictly positive, with a positive sum;
+    they are normalized so Σwᵢ = 1.
+    """
+    k = axes.shape[-1]
+    if weights is None:
+        return torch.full((k,), 1.0 / k, dtype=cdt, device=axes.device)
+    if not isinstance(weights, torch.Tensor):
+        raise TypeError(f"weights must be a torch.Tensor or None, got {type(weights).__name__}")
+    if weights.device != axes.device:
+        raise ValueError(
+            f"weights is on device {weights.device} but axes is on {axes.device}; "
+            "move them to the same device"
+        )
+    if weights.dim() != 1 or weights.shape[0] != k:
+        raise ValueError(
+            f"weights must be 1-D with shape ({k},) to match the last dim of axes; "
+            f"got shape {tuple(weights.shape)}"
+        )
+    wf = weights.to(cdt)
+    compiling = bool(getattr(torch.compiler, "is_compiling", lambda: False)())
+    if not compiling:
+        if not bool(torch.all(torch.isfinite(wf))):
+            raise ValueError("weights must all be finite (no NaN/Inf)")
+        if bool(torch.any(wf <= 0.0)):
+            raise ValueError("weights must be strictly positive (wᵢ > 0)")
+        sw = wf.sum()
+        if not bool(sw > 0.0):
+            raise ValueError("weights must sum to a positive value")
+        return wf / sw
+    # Compiled path stays in tensor-land. Non-positive weights are a misuse;
+    # clamp them away from zero so the graph does not break, then normalize.
+    # This path is outside szl.lambda/v1; _v1.lambda_v1 validates before it
+    # gets here and is not meant to run under torch.compile.
+    wf = torch.where(torch.isfinite(wf), wf, torch.ones_like(wf))
+    wf = torch.clamp(wf, min=torch.finfo(wf.dtype).tiny)
+    return wf / wf.sum()
+def lambda_aggregate(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    """Weighted geometric mean Λ(x) = ∏ xᵢ^{wᵢ} over the last dim of ``axes``.
+    Λ is the (ADVISORY) Lambda-Spine aggregator. Axis scores are expected in
+    [0,1] and are clamped into [0,1]; uniform weights (1/k) are used when
+    ``weights`` is None — the Egyptian-exact diagonal. Computed via logs in
+    float32 (or float64 for float64 inputs) for numerical stability:
+        Λ(x) = exp( Σᵢ wᵢ · log(clamp(xᵢ, 0, 1)) )
+    Non-compensatory zero-routing (A4-consistent): any axis that is zero, OR
+    that is NON-FINITE (NaN / ±Inf), is treated as a FAILING axis and drives
+    the whole aggregate to exactly 0. This is the conservative governance
+    choice — a garbage/invalid axis must never silently pass as a "perfect"
+    (clamped-to-1) axis, and the output (and its gradient) stay finite and in
+    [0,1] for every input. Zeros/non-finite axes are routed explicitly so
+    log(0) = -inf and log(NaN) = NaN never produce a NaN value or gradient.
+    Args:
+        axes:    tensor of shape (..., k) of axis scores in [0,1]. Batched:
+                 the reduction is over the last dim, leading dims are batch.
+        weights: optional 1-D tensor of shape (k,); None -> uniform. Normalized
+                 internally so Σwᵢ = 1.
+    Returns:
+        tensor of shape (...) — Λ(x) ∈ [0,1] per batch row. Differentiable
+        w.r.t. ``axes`` (and ``weights``).
+    NOT the szl.lambda/v1 contract: this function clamps, zero-routes NaN/±Inf
+    and renormalises (pinned in tests/test_lambda_v1_torch_divergence.py). For
+    validated, coded errors use :func:`szl_lambda_gate._v1.lambda_v1`.
+    HONESTY: this is a non-compensatory governance roll-up, NOT proven trust.
+    Λ-uniqueness is Conjecture 1 (open).
+    """
+    _check_axes(axes)
+    in_dtype = axes.dtype
+    cdt = _compute_dtype(in_dtype)
+    xf = axes.to(cdt)
+    w = _resolve_weights(axes, weights, cdt)  # (k,), Σw=1
+    # A "bad" axis is one that fails non-compensatorily: a non-positive score
+    # OR a non-finite value (NaN / ±Inf). clamp(+inf)=1 would otherwise count a
+    # garbage axis as perfect, and clamp(NaN)=NaN would poison the product — we
+    # treat BOTH as failing (zeroing) axes. Detect non-finite on the RAW input.
+    finite_mask = torch.isfinite(xf)
+    xc = xf.clamp(0.0, 1.0)
+    bad_mask = (~finite_mask) | (xc <= 0.0)
+    any_bad = torch.any(bad_mask, dim=-1)  # (...)
+    # Replace bad axes with 1.0 before the log purely to keep log finite and the
+    # gradient well-defined; the bad-axis contribution is reinstated via any_bad.
+    safe = torch.where(bad_mask, torch.ones_like(xc), xc)
+    logx = torch.log(safe)                    # (..., k)
+    acc = (logx * w).sum(dim=-1)              # (...)  weighted log-sum
+    val = torch.exp(acc)                      # (...)  Λ before zero-routing
+    out = torch.where(any_bad, torch.zeros_like(val), val)
+    out = out.clamp(0.0, 1.0)
+    return out.to(in_dtype)
+def lambda_gate(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    threshold: Optional[float] = None,
+):
+    """ADVISORY governance gate over Λ(x): score plus a pass/fail vs threshold.
+    Computes Λ(x) (see :func:`lambda_aggregate`) and compares it to
+    ``threshold``: pass := Λ(x) >= threshold.
+    DEPRECATED DEFAULT: omitting ``threshold`` (or passing ``None``) still uses
+    the legacy 0.5 but raises a ``DeprecationWarning``, because 0.5 differs
+    from the admit contract's policy_tau (0.8). Pass the threshold explicitly,
+    or use the strict szl.lambda/v1 gate
+    :func:`szl_lambda_gate._v1.lambda_v1_gate`, where tau is required.
+    ``threshold`` must be a finite float within Λ's range ``[0, 1]`` (Λ is the
+    weighted geometric mean over [0,1]). This bound is enforced: a threshold
+    below 0 or above 1 is meaningless for the advisory gate and is rejected —
+    see the non-compensatory rationale below. The domain edges are valid:
+    ``0.0`` admits every candidate (a permissive "no-gate" boundary) and
+    ``1.0`` admits only a Λ == 1 candidate.
+    Returns a :class:`LambdaGateResult` namedtuple with fields:
+        score     — Λ(x) tensor of shape (...), in [0,1]
+        passed    — boolean tensor of shape (...), Λ(x) >= threshold
+        threshold — the float threshold used
+        advisory  — always True; a STANDING reminder that this is a
+                    non-compensatory governance signal, NOT proven trust.
+    Non-compensatory threshold hardening: because a failing/garbage candidate
+    (a zero, NaN, or ±Inf axis) is routed to Λ = 0, a NEGATIVE threshold would
+    advisory-"pass" exactly those fully-failing candidates (0 >= t for t < 0) —
+    the opposite of a conservative admission gate. A threshold above 1 can
+    never pass. Both are misconfigurations, so the [0,1] domain is enforced up
+    front rather than silently producing a wrong pass mask.
+    HONESTY: a "pass" is an ADVISORY signal only. Λ is the weighted-geometric-
+    mean aggregator; its uniqueness is Conjecture 1 (open). Do not treat a
+    pass as proven trust or a closed theorem.
+    """
+    threshold = _resolve_threshold(threshold, stacklevel=2)
+    t = float(threshold)
+    if t != t or t == float("inf") or t == float("-inf"):
+        raise ValueError(f"threshold must be a finite float, got {threshold!r}")
+    if t < 0.0 or t > 1.0:
+        raise ValueError(
+            "threshold must be within Λ's range [0, 1] (Λ is the weighted "
+            f"geometric mean over [0,1]); got {t!r}. A threshold below 0 would "
+            "advisory-pass a fully-failing (Λ=0) candidate and one above 1 can "
+            "never pass — both signal a misconfigured gate."
+        )
+    score = lambda_aggregate(axes, weights)
+    passed = score >= t
+    return LambdaGateResult(score=score, passed=passed, threshold=t, advisory=True)
+def lambda_gate_batch(
+    candidates: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    threshold: Optional[float] = None,
+):
+    """ADVISORY batch gate: score MANY candidate action-vectors in one call.
+    This is the realistic way a model/agent uses the gate — one call per
+    inference step that scores every proposed action-vector at once and returns
+    the advisory pass mask (which candidates clear the threshold).
+    ``candidates`` is a tensor of shape (..., N, k): the last dim ``k`` holds
+    the per-axis scores of a single candidate, and the second-to-last dim ``N``
+    enumerates the candidates (any leading dims are extra batch). Equivalent to
+    calling :func:`lambda_gate` on the whole tensor — the reduction is over the
+    last dim — but named to make the agent-loop intent explicit. ``threshold``
+    inherits the same [0,1] domain guard as :func:`lambda_gate` (a threshold
+    outside Λ's range is a misconfiguration and is rejected). Omitting it uses
+    the legacy 0.5 with a ``DeprecationWarning``, as in :func:`lambda_gate`.
+    Returns a :class:`LambdaGateResult` with:
+        score     — Λ tensor of shape (..., N), one score per candidate
+        passed    — boolean mask of shape (..., N): score >= threshold
+        threshold — the float threshold used
+        advisory  — always True (NOT proven trust)
+    HONESTY: the pass mask is an ADVISORY, non-compensatory signal. A "pass"
+    is not proven trust; Λ-uniqueness is Conjecture 1 (open).
+    """
+    threshold = _resolve_threshold(threshold, stacklevel=2)
+    _check_axes(candidates)
+    if candidates.dim() < 2:
+        raise ValueError(
+            "candidates must be at least 2-D, shape (..., N, k): the last dim is "
+            f"the k axis scores and the one before it enumerates the N candidates; "
+            f"got a {candidates.dim()}-d tensor"
+        )
+    # Reuse the single-call gate — its reduction over the last dim already gives
+    # one score per candidate, so the (..., N) layout falls out for free.
+    return lambda_gate(candidates, weights=weights, threshold=threshold)
+# ---- A1..A4 axiom RUNTIME self-checks (real, verifiable) ------------------- #
+# These are honest empirical checks callers can run on concrete inputs. They
+# verify the carried axioms hold for THIS implementation on the given data —
+# they are NOT a proof of Λ-uniqueness (that is Conjecture 1, open).
+def is_egyptian_exact(
+    c: float,
+    k: int = 3,
+    weights: Optional[torch.Tensor] = None,
+    tol: float = 1e-5,
+) -> bool:
+    """A3 IsEgyptianExact: Λ(c, …, c) = c for a constant axis vector of length k.
+    Builds the uniform vector (c repeated k times) and checks Λ equals c within
+    ``tol``. ``c`` is clamped into [0,1] to match the aggregator's domain.
+    """
+    if k < 1:
+        raise ValueError("k must be >= 1")
+    cc = min(max(float(c), 0.0), 1.0)
+    axes = torch.full((k,), cc, dtype=torch.float64)
+    val = lambda_aggregate(axes, weights)
+    return bool(torch.abs(val - cc) <= tol)
+def is_bounded_by_max(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    tol: float = 1e-6,
+) -> bool:
+    """A4 IsBounded: Λ(x) ≤ maxᵢ xᵢ (over the last dim), within ``tol``.
+    Returns True iff the bound holds for every batch row. Non-finite axis
+    values are clamped/zero-routed the same way the aggregator treats them, so
+    the bound is checked on the conservative (finite) domain.
+    """
+    _check_axes(axes)
+    val = lambda_aggregate(axes, weights)                       # (...)
+    xf = axes.to(_compute_dtype(axes.dtype))
+    # Mirror the aggregator: non-finite axes are failing (treated as 0) for the
+    # purposes of the max bound, so the check matches the routed semantics.
+    xf = torch.where(torch.isfinite(xf), xf, torch.zeros_like(xf))
+    mx = xf.clamp(0.0, 1.0).amax(dim=-1)                        # (...)
+    return bool(torch.all(val.to(mx.dtype) <= mx + tol))
+def is_homogeneous(
+    axes: torch.Tensor,
+    t: float,
+    weights: Optional[torch.Tensor] = None,
+    tol: float = 1e-5,
+) -> bool:
+    """A2 IsHomogeneous (degree 1): Λ(t·x) = t·Λ(x) for scalar t in [0,1].
+    Verified on the clamped domain: both ``axes`` and ``t*axes`` must remain in
+    [0,1] for the identity to be meaningful, so ``axes`` is clamped to [0,1] and
+    ``t`` to [0,1] before the comparison.
+    """
+    _check_axes(axes)
+    tt = min(max(float(t), 0.0), 1.0)
+    x = axes.to(torch.float64).clamp(0.0, 1.0)
+    lhs = lambda_aggregate(x * tt, weights)
+    rhs = tt * lambda_aggregate(x, weights)
+    return bool(torch.all(torch.abs(lhs - rhs) <= tol))
+def is_monotone(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    delta: float = 0.05,
+    tol: float = 1e-7,
+) -> bool:
+    """A1 IsMonotone: Λ is non-decreasing in each axis.
+    For each axis j, nudges that axis UP by ``delta`` (clamped to stay ≤ 1) on
+    every batch row and checks Λ does not decrease (within ``tol``). Rows that
+    cannot move (already at 1) are skipped for that axis. A real check on the
+    given data — not a symbolic proof.
+    """
+    _check_axes(axes)
+    x = axes.to(torch.float64).clamp(0.0, 1.0)
+    base = lambda_aggregate(x, weights)
+    k = x.shape[-1]
+    ok = True
+    for j in range(k):
+        bumped = x.clone()
+        bumped[..., j] = (bumped[..., j] + float(delta)).clamp(0.0, 1.0)
+        bumped_val = lambda_aggregate(bumped, weights)
+        # Λ must not go DOWN when an axis goes UP.
+        ok = ok and bool(torch.all(bumped_val - base >= -tol))
+    return ok
+# ---- Adversarial axiom search (honest: a falsification attempt) ------------ #
+def find_axiom_violation(
+    k: int = 5,
+    trials: int = 200,
+    weights: Optional[torch.Tensor] = None,
+    seed: Optional[int] = 0,
+    tol: float = 1e-6,
+):
+    """Random-search for ANY A1–A4 violation on random axis/weight draws.
+    Returns the first ``(axiom, axes, weights)`` triple that violates a carried
+    axiom within ``tol``, or ``None`` if none is found in ``trials`` draws. This
+    is an honest FALSIFICATION attempt on this implementation — finding nothing
+    is empirical evidence, NOT a proof (Λ-uniqueness is Conjecture 1, open).
+    """
+    gen = torch.Generator()
+    if seed is not None:
+        gen.manual_seed(int(seed))
+    for _ in range(int(trials)):
+        x = torch.rand(k, generator=gen, dtype=torch.float64)
+        w = weights
+        if w is None:
+            w = torch.rand(k, generator=gen, dtype=torch.float64) + 1e-3
+        # A3 on a constant draw
+        c = float(torch.rand(1, generator=gen).item())
+        if not is_egyptian_exact(c, k=k, weights=w, tol=max(tol, 1e-5)):
+            return ("A3_IsEgyptianExact", torch.full((k,), c, dtype=torch.float64), w)
+        # A4 bounded-by-max
+        if not is_bounded_by_max(x, w, tol=max(tol, 1e-6)):
+            return ("A4_IsBounded", x, w)
+        # A2 homogeneous at a random t
+        t = float(torch.rand(1, generator=gen).item())
+        if not is_homogeneous(x, t, weights=w, tol=max(tol, 1e-5)):
+            return ("A2_IsHomogeneous", x, w)
+        # A1 monotone (leave headroom so an up-bump stays in range)
+        if not is_monotone(x * 0.9, w, tol=max(tol, 1e-7)):
+            return ("A1_IsMonotone", x * 0.9, w)
+    return None
+# ---- Canonical 13-axis Yuyay preset (ADVISORY ONLY) ------------------------ #
+# SZL's own yuyay_v3 "Heart" gate is a 13-axis CONJUNCTIVE-AND screen (each axis
+# independently clears its floor — no compensation). We expose its published
+# axis NAMES and per-axis FLOORS as advisory metadata, and a uniform Λ weight
+# vector over the 13 axes. This is ADVISORY: Λ here is still the weighted
+# geometric mean, and a "pass" is a research-conjecture signal, NOT proven
+# trust. Source: yuyay_v3 spec (Lutar, 2026).
+YUYAY_AXES = (
+    "moralGrounding",
+    "measurabilityHonesty",
+    "empiricalGrounding",
+    "logicalConsistency",
+    "sourceTransparency",
+    "reproducibility",
+    "licenseHygiene",
+    "scopeDiscipline",
+    "claimCalibration",
+    "evalAwareness",
+    "deceptionKeywords",
+    "conflictingDirectives",
+    "reversalDirective",
+)
+# Published per-axis advisory floors for the CONJUNCTIVE screen: two "sacred"
+# axes at 0.95, seven "structural" at 0.90, four "introspection" at 0.90.
+YUYAY_FLOORS = (
+    0.95, 0.95,                          # sacred
+    0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90,  # structural (7)
+    0.90, 0.90, 0.90, 0.90,              # introspection (4)
+)
+def yuyay_weights(
+    dtype: torch.dtype = torch.float64,
+    device: Optional[torch.device] = None,
+) -> torch.Tensor:
+    """Canonical 13-axis Yuyay Λ weight vector (uniform 1/13), ADVISORY only.
+    Returns a length-13 weight tensor for use as the ``weights`` argument to
+    :func:`lambda_aggregate` / :func:`lambda_gate` over the 13 :data:`YUYAY_AXES`.
+    Uniform by default (the Egyptian-exact diagonal). The published yuyay_v3
+    gate is a conjunctive AND with per-axis floors (:data:`YUYAY_FLOORS`); the
+    Λ roll-up here is the weighted geometric mean and is ADVISORY — NOT proven
+    trust (Λ-uniqueness is Conjecture 1, open).
+    """
+    k = len(YUYAY_AXES)
+    return torch.full((k,), 1.0 / k, dtype=dtype, device=device)
+# ---- Kernel self-check surface --------------------------------------------- #
+def selfcheck(
+    k: int = 5,
+    trials: int = 64,
+    seed: Optional[int] = 0,
+) -> dict:
+    """Run the A1–A4 empirical self-checks and report a verdict + version.
+    Returns a dict:
+        version          — kernel version string
+        axioms           — {A1..A4: bool} empirical pass on sampled inputs
+        all_axioms_hold  — bool, every sampled axiom check passed
+        adversarial      — {trials, violation} from a random falsification search
+                           (violation is None when no violation was found)
+        advisory         — always True
+        lambda_status    — Conjecture 1 (open) honesty string
+    HONESTY: these are EMPIRICAL checks on sampled inputs, NOT a proof of
+    Λ-uniqueness (Conjecture 1, open). A clean run is evidence, not proof.
+    """
+    x = torch.rand(k, dtype=torch.float64) * 0.9  # headroom for the A1 up-bump
+    w = torch.rand(k, dtype=torch.float64) + 1e-3
+    axioms = {
+        "A1_IsMonotone": is_monotone(x, w),
+        "A2_IsHomogeneous": is_homogeneous(x, float(torch.rand(1).item()), weights=w),
+        "A3_IsEgyptianExact": is_egyptian_exact(float(torch.rand(1).item()), k=k, weights=w),
+        "A4_IsBounded": is_bounded_by_max(x, w),
+    }
+    violation = find_axiom_violation(k=k, trials=trials, seed=seed)
+    return {
+        "version": __version__,
+        "axioms": axioms,
+        "all_axioms_hold": all(axioms.values()) and violation is None,
+        "adversarial": {"trials": int(trials), "violation": violation},
+        "advisory": True,
+        "lambda_status": "Conjecture 1 (open) — uniqueness unproven; advisory only",
+    }
+# Kept in sync with the package __version__ (single source of truth lives in
+# __init__; duplicated here so _lambda is importable/selfcheck-able standalone).
+__version__ = "0.2.0"
+# Namedtuple result type for the gate. Defined after functions so docstrings
+# above can reference it; imported by __init__ and layers.
+from collections import namedtuple  # noqa: E402
+LambdaGateResult = namedtuple(
+    "LambdaGateResult", ["score", "passed", "threshold", "advisory"]
+)

build/torch-cpu/szl_lambda_gate/_ops.py CHANGED Viewed

@@ -1,10 +1,10 @@
-# SPDX-License-Identifier: Apache-2.0
-# Auto-style ops namespace shim for the universal kernel. Unique suffix lets
-# multiple versions load in the same process (Kernel Hub requirement).
-import torch
-ops = torch.ops._szl_lambda_gate_20260623081355
-def add_op_namespace_prefix(op_name: str) -> str:
-    return f"_szl_lambda_gate_20260623081355::{op_name}"

+# SPDX-License-Identifier: Apache-2.0
+# Auto-style ops namespace shim for the universal kernel. Unique suffix lets
+# multiple versions load in the same process (Kernel Hub requirement).
+import torch
+ops = torch.ops._szl_lambda_gate_20260623081355
+def add_op_namespace_prefix(op_name: str) -> str:
+    return f"_szl_lambda_gate_20260623081355::{op_name}"

build/torch-cpu/szl_lambda_gate/_v1.py ADDED Viewed

	@@ -0,0 +1,221 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""szl.lambda/v1 strict kernel entry: Λ and its gate on tensors, with no clamping or defaults.
+This is the torch port of ``reference/szl_lambda_v1.py`` and follows
+``spec/szl.lambda.v1.json``. An input outside the contract makes ``lambda_v1``
+raise ``LambdaV1Error(code)`` and makes ``lambda_v1_gate`` return verdict BLOCK
+with that code. Nothing is clamped, renormalised, defaulted or rounded before
+the compare::
+    lambda_v1(axes, weights)            -> 0-d float64 tensor, Λ in [0, 1]
+    lambda_v1_gate(axes, weights, tau)  -> LambdaV1GateResult(verdict, code, score, tau, advisory)
+The legacy ``lambda_aggregate`` / ``lambda_gate`` are unchanged. They clamp
+x > 1 to 1, route NaN and ±Inf to 0 and renormalise weights, and
+``lambda_gate`` falls back to a threshold of 0.5, which is now deprecated.
+Use this module when a verdict must follow szl.lambda/v1.
+Inputs
+    ``axes`` and ``weights`` are 1-D tensors of a real dtype (floating or
+    integer). bool and complex are not numbers. A Python list, None, or a 0-d
+    or 2-D tensor is LAMBDA_TYPE_INVALID; build the tensor with
+    ``torch.tensor(values, dtype=torch.float64)``. ``weights`` is moved to the
+    device of ``axes``. Inputs are read and never modified.
+    ``tau`` is a Python int or float (not bool), finite, with 0 < tau <= 1. It
+    is required and has no default. The policy value is ``policy_tau`` in
+    frontier/model_admit_contract.v1.json.
+Checks run in phases, in the reference's order, so the reported code does not
+depend on axis order::
+    LAMBDA_TYPE_INVALID (container) > LAMBDA_EMPTY > LAMBDA_LENGTH_MISMATCH
+    > LAMBDA_TYPE_INVALID (dtype) > LAMBDA_NONFINITE_AXIS
+    > LAMBDA_AXIS_OUT_OF_RANGE > LAMBDA_NONFINITE_WEIGHT
+    > LAMBDA_WEIGHT_NONPOSITIVE > LAMBDA_WEIGHT_SUM
+The gate checks tau first (LAMBDA_TAU_INVALID). The element checks and the
+weight sum (``math.fsum``) run on the float64 values exactly as the reference
+runs them, so every error code agrees with the reference.
+How the numbers are computed
+    * Λ, which is ``lambda_v1`` and the gate's ``score``, comes from
+      ``_lambda.lambda_aggregate`` in float64, so it stays a differentiable
+      tensor. On validated input that function's clamp and NaN routing change
+      nothing, and a zero axis gives exactly 0. Its renormalisation divides by
+      a sum within 1e-12 of 1, which moves Λ by at most Λ·|log Λ|·1e-12
+      (<= 3.7e-13) plus float64 rounding. The vectors' value_tol is 1e-12.
+    * The verdict comes from log Λ = fsum(w_k · log x_k) over the same float64
+      values, as in the reference, so it never depends on how Λ rounds (a
+      subnormal Λ has little relative precision). A zero axis gives
+      log Λ = -inf and the verdict NO_GO / ZERO_VETO, a veto rather than an
+      error. |log Λ - log tau| <= TIE_EPS gives ABSTAIN / NUMERIC_TIE. Above
+      the band the verdict is GO, and below it NO_GO / BELOW_TAU.
+The checks depend on the data and the verdict is a Python string, so this
+entry is not meant to run inside ``torch.compile``. The legacy compiled weight
+path in ``_lambda._resolve_weights``, which clamps weights to ``finfo.tiny``,
+is outside szl.lambda/v1.
+Λ is advisory. Λ uniqueness is Conjecture 1 (open), and nothing here depends on it.
+"""
+from __future__ import annotations
+import math
+from collections import namedtuple
+from typing import Any, List, Optional, Tuple
+import torch
+from ._lambda import lambda_aggregate
+SCHEMA = "szl.lambda/v1"
+UNIQUENESS = "CONJECTURE_1_NOT_USED"
+WEIGHT_SUM_TOL = 1e-12
+TIE_EPS = 1e-9
+TYPE_INVALID = "LAMBDA_TYPE_INVALID"
+EMPTY = "LAMBDA_EMPTY"
+LENGTH_MISMATCH = "LAMBDA_LENGTH_MISMATCH"
+NONFINITE_AXIS = "LAMBDA_NONFINITE_AXIS"
+AXIS_OUT_OF_RANGE = "LAMBDA_AXIS_OUT_OF_RANGE"
+NONFINITE_WEIGHT = "LAMBDA_NONFINITE_WEIGHT"
+WEIGHT_NONPOSITIVE = "LAMBDA_WEIGHT_NONPOSITIVE"
+WEIGHT_SUM = "LAMBDA_WEIGHT_SUM"
+TAU_INVALID = "LAMBDA_TAU_INVALID"
+#: Every error code, in precedence order (tau is checked first by the gate).
+ERROR_CODES = (
+    TYPE_INVALID,
+    EMPTY,
+    LENGTH_MISMATCH,
+    NONFINITE_AXIS,
+    AXIS_OUT_OF_RANGE,
+    NONFINITE_WEIGHT,
+    WEIGHT_NONPOSITIVE,
+    WEIGHT_SUM,
+    TAU_INVALID,
+)
+GO = "GO"
+NO_GO = "NO_GO"
+ABSTAIN = "ABSTAIN"
+BLOCK = "BLOCK"
+VERDICTS = (GO, NO_GO, ABSTAIN, BLOCK)
+ZERO_VETO = "ZERO_VETO"
+BELOW_TAU = "BELOW_TAU"
+NUMERIC_TIE = "NUMERIC_TIE"
+_INTEGER_DTYPES = (torch.uint8, torch.int8, torch.int16, torch.int32, torch.int64)
+class LambdaV1Error(ValueError):
+    """An input outside the szl.lambda/v1 contract. ``code`` is one of ERROR_CODES."""
+    def __init__(self, code: str, detail: str = "") -> None:
+        self.code = code
+        self.detail = detail
+        super().__init__(f"{code}: {detail}" if detail else code)
+#: verdict in VERDICTS; code as in the spec's gate rules; score is Λ as a 0-d
+#: float64 tensor (None on BLOCK); tau is the validated float (None when tau
+#: itself is invalid); advisory is always True.
+LambdaV1GateResult = namedtuple(
+    "LambdaV1GateResult", ["verdict", "code", "score", "tau", "advisory"]
+)
+def _is_real(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+def _is_real_dtype(dtype: torch.dtype) -> bool:
+    return dtype.is_floating_point or dtype in _INTEGER_DTYPES
+def _validate(
+    axes: Any, weights: Any
+) -> Tuple[torch.Tensor, torch.Tensor, List[float], List[float]]:
+    """Float64 tensors and their values, or LambdaV1Error in the reference's phase order."""
+    for name, t in (("axes", axes), ("weights", weights)):
+        if not isinstance(t, torch.Tensor):
+            raise LambdaV1Error(TYPE_INVALID, f"{name} must be a 1-D torch.Tensor, got {type(t).__name__}")
+        if t.dim() != 1:
+            raise LambdaV1Error(TYPE_INVALID, f"{name} must be a 1-D tensor, got {t.dim()}-D")
+    k, m = axes.shape[0], weights.shape[0]
+    if k == 0 or m == 0:
+        raise LambdaV1Error(EMPTY, f"len(axes)={k}, len(weights)={m}")
+    if k != m:
+        raise LambdaV1Error(LENGTH_MISMATCH, f"len(axes)={k} != len(weights)={m}")
+    for name, t in (("axes", axes), ("weights", weights)):
+        if not _is_real_dtype(t.dtype):
+            raise LambdaV1Error(TYPE_INVALID, f"{name} has dtype {t.dtype}, not a real number type")
+    x = axes.to(torch.float64)
+    w = weights.to(device=x.device, dtype=torch.float64)
+    xs, ws = x.tolist(), w.tolist()
+    for i, v in enumerate(xs):
+        if not math.isfinite(v):
+            raise LambdaV1Error(NONFINITE_AXIS, f"axes[{i}]={v!r}")
+    for i, v in enumerate(xs):
+        if not 0.0 <= v <= 1.0:
+            raise LambdaV1Error(AXIS_OUT_OF_RANGE, f"axes[{i}]={v!r} is outside [0, 1]")
+    for i, v in enumerate(ws):
+        if not math.isfinite(v):
+            raise LambdaV1Error(NONFINITE_WEIGHT, f"weights[{i}]={v!r}")
+    for i, v in enumerate(ws):
+        if not v > 0.0:
+            raise LambdaV1Error(WEIGHT_NONPOSITIVE, f"weights[{i}]={v!r} is not > 0")
+    try:
+        total = math.fsum(ws)
+    except OverflowError:
+        raise LambdaV1Error(WEIGHT_SUM, "sum of weights overflows a float") from None
+    if not abs(total - 1.0) <= WEIGHT_SUM_TOL:
+        raise LambdaV1Error(WEIGHT_SUM, f"fsum(weights)={total!r} is not within {WEIGHT_SUM_TOL} of 1")
+    return x, w, xs, ws
+def lambda_v1(axes: torch.Tensor, weights: torch.Tensor) -> torch.Tensor:
+    """Λ_w(axes) as a 0-d float64 tensor in [0, 1]; exactly 0 iff some axis is 0.
+    Raises ``LambdaV1Error(code)`` for any input outside szl.lambda/v1.
+    Differentiable with respect to ``axes``.
+    """
+    x, w, _, _ = _validate(axes, weights)
+    return lambda_aggregate(x, w)
+def _check_tau(tau: Any) -> float:
+    if not _is_real(tau):
+        raise LambdaV1Error(TAU_INVALID, f"tau is {type(tau).__name__}, not a real number")
+    if isinstance(tau, float) and not math.isfinite(tau):
+        raise LambdaV1Error(TAU_INVALID, f"tau={tau!r} is not finite")
+    if not 0 < tau <= 1:
+        raise LambdaV1Error(TAU_INVALID, f"tau={tau!r} is outside (0, 1]")
+    return float(tau)
+def lambda_v1_gate(axes: torch.Tensor, weights: torch.Tensor, tau: float) -> LambdaV1GateResult:
+    """The szl.lambda/v1 gate. It never raises on bad input; it returns BLOCK with the code.
+    tau is required. The compare is in log space on the unrounded value, and a
+    tie within TIE_EPS is ABSTAIN. A verdict is ADVISORY.
+    """
+    t: Optional[float] = None
+    try:
+        t = _check_tau(tau)
+        x, w, xs, ws = _validate(axes, weights)
+    except LambdaV1Error as err:
+        return LambdaV1GateResult(BLOCK, err.code, None, t, True)
+    score = lambda_aggregate(x, w)
+    if any(v == 0.0 for v in xs):
+        return LambdaV1GateResult(NO_GO, ZERO_VETO, score, t, True)
+    log_lam = math.fsum(wk * math.log(xk) for xk, wk in zip(xs, ws))
+    delta = log_lam - math.log(t)
+    if abs(delta) <= TIE_EPS:
+        return LambdaV1GateResult(ABSTAIN, NUMERIC_TIE, score, t, True)
+    if delta > 0:
+        return LambdaV1GateResult(GO, None, score, t, True)
+    return LambdaV1GateResult(NO_GO, BELOW_TAU, score, t, True)

build/torch-cpu/szl_lambda_gate/governed_norm/__init__.py ADDED Viewed

	@@ -0,0 +1,279 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""szl_lambda_gate.governed_norm — governed normalization kernels (folded in).
+CONSOLIDATION (Wave D): this subpackage is the ``szl-governed-norm`` universal
+kernel folded into the canonical ``szl-lambda-gate`` kernels package so the two
+duplicate micro-repos become ONE canonical home. The source repo
+``szl-holdings/szl-governed-norm`` is DEPRECATED (see its DEPRECATED.md) and
+points here; nothing was deleted — this is the additive, reversible copy.
+It provides correctness-verified RMSNorm and LayerNorm that run on CPU and CUDA
+and are torch.compile-friendly, plus an optional *governed* path that emits
+content-addressed, SHA3-256 hash-chained receipts of each call — provenance at
+the kernel layer, in the spirit of the a11oy governed-AI platform
+(https://a-11-oy.com).
+Usage (as a subpackage of the canonical kernel)::
+    import torch
+    from szl_lambda_gate import governed_norm as gn
+    print(gn.selfcheck())                 # one-shot correctness + receipt check
+    x = torch.randn(4, 1024, dtype=torch.float16)
+    y = gn.rms_norm(x, eps=1e-6)          # plain path
+    y2 = gn.rms_norm(x, eps=1e-6, governed=True)   # records to the default chain
+    chain = gn.ReceiptChain()
+    y3 = gn.rms_norm(x, eps=1e-6, chain=chain)     # records into YOUR chain only
+    print(chain.verify())                 # (ok, depth, first_break_seq)
+Honesty: this is a universal (pure-Python) kernel — a correctness reference,
+not a hand-tuned CUDA speed record. No fabricated benchmarks. Its
+differentiator is verifiable governance, not raw FLOPs. Λ = Conjecture 1
+(advisory, uniqueness OPEN) — never described as proven trust anywhere.
+Note on torch.compile: every op is torch.compile(fullgraph=True)-compatible.
+Receipt emission is an eager-only side effect (it hashes materialized tensor
+bytes), so when a *governed* call is captured into a compiled graph the
+numerics are unchanged but NO receipt is recorded — govern at the eager audit
+boundary. This is documented honestly and covered by tests.
+"""
+from typing import Any, Dict, List, Optional, Tuple
+import torch
+from . import layers  # noqa: F401  (must be importable for Hub layer mapping)
+from ._norm import fused_add_rms_norm as _fused_add_rms_norm
+from ._norm import layer_norm as _layer_norm
+from ._norm import rms_norm as _rms_norm
+from ._receipt import _GENESIS as _GENESIS_HEAD
+from ._receipt import ReceiptChain, default_chain, emit_receipt
+__all__ = [
+    "rms_norm",
+    "layer_norm",
+    "fused_add_rms_norm",
+    "layers",
+    "ReceiptChain",
+    "emit_receipt",
+    "receipt_head",
+    "receipt_count",
+    "receipt_tail",
+    "receipt_verify",
+    "selfcheck",
+    "DOCTRINE_FOOTER",
+    "__version__",
+]
+__version__ = "0.2.0"
+DOCTRINE_FOOTER = (
+    "SZL Holdings · governed normalization · provenance at the kernel layer · "
+    "Lambda = Conjecture 1 (advisory) · honesty over checklist"
+)
+def _is_tracing() -> bool:
+    """True while torch.compile / Dynamo is tracing this code.
+    Receipt emission reads materialized tensor bytes (hashing on CPU), which is
+    an inherently eager, side-effecting host operation that cannot live inside
+    a traced FX graph — so under torch.compile we skip the emit. This keeps
+    EVERY op torch.compile(fullgraph=True)-compatible while remaining honest:
+    when a governed call is captured into a compiled graph, NO receipt is
+    recorded (the numerics are unchanged and identical to the eager path).
+    Governance is intended for the eager audit boundary; record receipts there.
+    """
+    is_compiling = getattr(torch.compiler, "is_compiling", None)
+    return bool(is_compiling()) if is_compiling is not None else False
+def _emit(
+    chain: Optional[ReceiptChain],
+    op: str,
+    x: torch.Tensor,
+    out: torch.Tensor,
+    eps: float,
+    sign_key: Optional[Any] = None,
+    organ: str = "szl-governed-norm",
+) -> None:
+    """Append a receipt to ``chain`` (or the process default chain if None).
+    No-op while torch.compile is tracing (see ``_is_tracing``). When
+    ``sign_key`` (a PEM ECDSA-P256 private key) is supplied and szl-receipt is
+    installed, the receipt carries an additive DSSE ``signature`` envelope;
+    keyless is UNSIGNED-honest.
+    """
+    if _is_tracing():
+        return
+    target = chain if chain is not None else default_chain()
+    target.emit(op, x, out, eps, sign_key=sign_key, organ=organ)
+def rms_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 1e-6,
+    governed: bool = False,
+    chain: Optional[ReceiptChain] = None,
+    sign_key: Optional[Any] = None,
+    organ: str = "szl-governed-norm",
+) -> torch.Tensor:
+    """RMSNorm over the last dim.
+    If ``governed=True``, append an audit receipt. By default the receipt goes
+    to the process-wide default chain (convenient). Pass your own ``chain`` (a
+    ``ReceiptChain`` instance) to record into a caller-owned chain instead —
+    this avoids global-state contention when many threads/requests govern
+    independently. Passing ``chain`` implies governance even if
+    ``governed=False`` is left at its default. Pass ``sign_key`` (PEM
+    ECDSA-P256) to additively sign the receipt via szl-receipt.
+    """
+    out = _rms_norm(x, weight=weight, eps=eps)
+    if governed or chain is not None:
+        _emit(chain, "rms_norm", x, out, eps, sign_key=sign_key, organ=organ)
+    return out
+def layer_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    bias: Optional[torch.Tensor] = None,
+    eps: float = 1e-5,
+    governed: bool = False,
+    chain: Optional[ReceiptChain] = None,
+    sign_key: Optional[Any] = None,
+    organ: str = "szl-governed-norm",
+) -> torch.Tensor:
+    """LayerNorm over the last dim.
+    If ``governed=True`` (or a ``chain`` is supplied), append an audit receipt
+    to ``chain`` when given, otherwise to the process default chain. See
+    ``rms_norm`` for the per-call ``chain`` rationale and ``sign_key``.
+    """
+    out = _layer_norm(x, weight=weight, bias=bias, eps=eps)
+    if governed or chain is not None:
+        _emit(chain, "layer_norm", x, out, eps, sign_key=sign_key, organ=organ)
+    return out
+def fused_add_rms_norm(
+    x: torch.Tensor,
+    residual: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 1e-6,
+    governed: bool = False,
+    chain: Optional[ReceiptChain] = None,
+    sign_key: Optional[Any] = None,
+    organ: str = "szl-governed-norm",
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Residual-add + RMSNorm (transformer block pattern).
+    Returns ``(y, new_residual)`` where ``new_residual = x + residual`` and
+    ``y = rms_norm(new_residual, weight, eps)``. If ``governed=True`` (or a
+    ``chain`` is supplied), append an audit receipt over the normalized output
+    to ``chain`` when given, otherwise to the process default chain. Pass
+    ``sign_key`` to additively sign the receipt via szl-receipt.
+    """
+    out, new_residual = _fused_add_rms_norm(x, residual, weight=weight, eps=eps)
+    if governed or chain is not None:
+        _emit(chain, "fused_add_rms_norm", x, out, eps, sign_key=sign_key, organ=organ)
+    return out, new_residual
+# ---- governance receipt surface (operates on the default in-process chain) --
+def receipt_head() -> str:
+    """SHA3-256 head of the governed-call receipt chain ('0'*64 if empty)."""
+    return default_chain().head()
+def receipt_count() -> int:
+    """Number of governed calls recorded."""
+    return default_chain().count()
+def receipt_tail(n: int = 10) -> List[Dict[str, Any]]:
+    """Last n receipts."""
+    return default_chain().tail(n)
+def receipt_verify() -> Dict[str, Any]:
+    """Re-walk the receipt chain. Returns {ok, depth, first_break_seq}."""
+    ok, depth, brk = default_chain().verify()
+    return {"ok": ok, "depth": depth, "first_break_seq": brk, "head": default_chain().head()}
+# ---- one-shot self-verification --------------------------------------------
+def selfcheck() -> Dict[str, Any]:
+    """Verify correctness + governance in a single call; never raises.
+    Runs a tiny, self-contained, CPU-only smoke test against PyTorch references
+    so downstream code (and SZL's own a11oy / hatun-mcp) can confirm the loaded
+    kernel is the real, working article before trusting it.
+    Checks (all on a *private, throwaway* ReceiptChain so the process default
+    chain is never touched):
+      * ``rms_norm`` matches a Llama-style float32 reference,
+      * ``layer_norm`` matches ``torch.nn.functional.layer_norm``,
+      * ``fused_add_rms_norm`` matches the unfused add-then-norm path,
+      * a governed call emits exactly one receipt and the chain verifies.
+    Returns a JSON-able dict:
+      ``{ok, version, checks: {name: bool}, receipt_ok, receipt_head, error}``
+    ``ok`` is True iff every check passed. On unexpected failure ``ok`` is
+    False and ``error`` carries the message — this function is designed to be
+    safe to call in a health probe and will not raise.
+    """
+    checks: Dict[str, bool] = {}
+    receipt_ok = False
+    receipt_head = _GENESIS_HEAD
+    error = None
+    try:
+        torch.manual_seed(0)
+        x = torch.randn(4, 64, dtype=torch.float32)
+        w = torch.randn(64, dtype=torch.float32)
+        b = torch.randn(64, dtype=torch.float32)
+        res = torch.randn(4, 64, dtype=torch.float32)
+        eps_r, eps_l = 1e-6, 1e-5
+        # rms_norm vs Llama-style fp32 reference
+        xf = x.to(torch.float32)
+        ref_rms = (xf * torch.rsqrt(xf.pow(2).mean(-1, keepdim=True) + eps_r)) * w
+        checks["rms_norm"] = bool(
+            torch.allclose(rms_norm(x, weight=w, eps=eps_r), ref_rms, rtol=1e-5, atol=1e-5)
+        )
+        # layer_norm vs torch reference
+        ref_ln = torch.nn.functional.layer_norm(x, (64,), weight=w, bias=b, eps=eps_l)
+        checks["layer_norm"] = bool(
+            torch.allclose(layer_norm(x, weight=w, bias=b, eps=eps_l), ref_ln,
+                           rtol=1e-5, atol=1e-5)
+        )
+        # fused_add_rms_norm vs unfused path
+        y_f, new_res = fused_add_rms_norm(x, res, weight=w, eps=eps_r)
+        h = x.to(torch.float32) + res.to(torch.float32)
+        ref_y = rms_norm(h.to(x.dtype), weight=w, eps=eps_r)
+        checks["fused_add_rms_norm"] = bool(
+            torch.allclose(y_f, ref_y, rtol=1e-5, atol=1e-5)
+            and torch.allclose(new_res, h.to(x.dtype), rtol=1e-6, atol=1e-6)
+        )
+        # governance on a private chain: one emit, chain verifies
+        probe_chain = ReceiptChain()
+        rms_norm(x, weight=w, eps=eps_r, chain=probe_chain)
+        ok, depth, brk = probe_chain.verify()
+        receipt_ok = bool(ok and depth == 1 and brk == -1)
+        receipt_head = probe_chain.head()
+        checks["governance"] = receipt_ok
+    except Exception as exc:  # never raise from a health probe
+        error = f"{type(exc).__name__}: {exc}"
+    ok = bool(checks) and all(checks.values()) and error is None
+    return {
+        "ok": ok,
+        "version": __version__,
+        "checks": checks,
+        "receipt_ok": receipt_ok,
+        "receipt_head": receipt_head,
+        "error": error,
+    }

build/torch-cpu/szl_lambda_gate/governed_norm/_norm.py ADDED Viewed

	@@ -0,0 +1,246 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Pure-PyTorch normalization primitives for the SZL governed-norm kernel.
+These are correctness-verified reference implementations (RMSNorm, LayerNorm,
+and the residual-fused RMSNorm pattern used by transformer blocks) written in
+pure PyTorch. They run on CPU and CUDA, are torch.compile-friendly, and depend
+ONLY on torch + the Python standard library (a Kernel Hub requirement for
+universal kernels).
+HONESTY: this is a *universal* (pure-Python) kernel. It does NOT ship a
+hand-tuned CUDA/Triton binary, so it is a correctness reference, not a
+speed record. We make no fabricated benchmark claims. Where it adds value
+is the optional *governed* path (see _receipt.py): every normalization call
+can emit a content-addressed, hash-chained receipt of its inputs/outputs so
+the operation is auditable — SZL Holdings' provenance doctrine applied at
+the kernel layer.
+Numerical convention (all ops): reductions and the normalization math are
+computed in float32 for stability, then the result is cast back to the input
+dtype. This is the standard Llama-style convention and is what makes
+float16 / bfloat16 inputs numerically well-behaved.
+Validation convention: guards below are cheap, branch-only checks on metadata
+(dtype / ndim / shape / device) — they allocate nothing on the happy path and
+constant-fold away under torch.compile, so they do not perturb traced graphs.
+They exist to turn silent broadcasting / device-mismatch bugs into clear,
+early errors. A zero-size normalized last dimension is rejected (normalizing
+over zero elements is undefined); a single-element last dimension is allowed
+(RMSNorm yields sign(x); LayerNorm yields 0, matching F.layer_norm).
+Non-finite convention (NaN / Inf inputs): these ops do NOT sanitize their
+input. A NaN or Inf in the input propagates through the reduction and appears
+in the output, exactly as it would in torch.nn.functional.layer_norm / a
+hand-written kernel. We deliberately do NOT silently replace non-finite values
+(that would hide upstream numerical bugs); detecting/handling them is the
+caller's responsibility. This propagation behavior is covered by regression
+tests so it cannot change unnoticed.
+"""
+from typing import Optional
+import torch
+# Floating dtypes this kernel supports. Integer / complex inputs are rejected
+# early with a clear message rather than silently producing garbage.
+_SUPPORTED_DTYPES = (torch.float16, torch.bfloat16, torch.float32, torch.float64)
+def _compute_dtype(in_dtype: torch.dtype) -> torch.dtype:
+    """Reduction/normalization compute dtype.
+    Low-precision inputs (fp16/bf16) are upcast to float32 for stability — the
+    standard Llama-style convention. float64 inputs are NOT downcast: doing so
+    would silently lose precision (and break gradcheck), so we keep float64.
+    """
+    return torch.float32 if in_dtype in (torch.float16, torch.bfloat16) else in_dtype
+def _check_input(x: torch.Tensor, name: str = "x") -> None:
+    """Cheap, allocation-free guards on the primary input tensor.
+    Only inspects metadata (type / dtype / ndim), so it is constant-folded by
+    torch.compile and adds no runtime tensor work on the happy path.
+    """
+    if not isinstance(x, torch.Tensor):
+        raise TypeError(f"{name} must be a torch.Tensor, got {type(x).__name__}")
+    if x.dtype not in _SUPPORTED_DTYPES:
+        raise TypeError(
+            f"{name} has unsupported dtype {x.dtype}; "
+            f"expected one of {tuple(str(d) for d in _SUPPORTED_DTYPES)}"
+        )
+    if x.dim() < 1:
+        raise ValueError(
+            f"{name} must have at least 1 dimension (the normalized dim); "
+            f"got a {x.dim()}-d tensor"
+        )
+    # A zero-size normalized (last) dimension is mathematically undefined:
+    # mean/RMS over zero elements is NaN, so normalization has no meaning.
+    # Reject it early with a clear message instead of silently returning an
+    # empty/NaN tensor (the classic shape-bug-masquerading-as-success case).
+    if x.shape[-1] == 0:
+        raise ValueError(
+            f"{name} has a zero-size normalized last dimension {tuple(x.shape)}; "
+            f"normalization over zero elements is undefined"
+        )
+def _check_affine(
+    x: torch.Tensor,
+    param: Optional[torch.Tensor],
+    name: str,
+) -> None:
+    """Validate an optional affine parameter (weight/bias/residual peer).
+    Enforces that the parameter is 1-D and matches the normalized (last)
+    dimension, and lives on the same device as ``x``. This catches the
+    classic silent-broadcast bug where a mis-shaped weight would broadcast
+    instead of erroring. Metadata-only: no allocations.
+    """
+    if param is None:
+        return
+    if not isinstance(param, torch.Tensor):
+        raise TypeError(f"{name} must be a torch.Tensor or None, got {type(param).__name__}")
+    if param.device != x.device:
+        raise ValueError(
+            f"{name} is on device {param.device} but x is on {x.device}; "
+            f"move them to the same device"
+        )
+    last = x.shape[-1]
+    if param.dim() != 1 or param.shape[0] != last:
+        raise ValueError(
+            f"{name} must be 1-D with shape ({last},) to match the normalized "
+            f"last dimension of x; got shape {tuple(param.shape)}"
+        )
+def _check_eps(eps: float) -> None:
+    """eps must be a positive, finite scalar (rsqrt(var+eps) must be safe)."""
+    e = float(eps)
+    if not (e > 0.0) or e != e or e == float("inf"):
+        raise ValueError(f"eps must be a positive finite float, got {eps!r}")
+def rms_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 1e-6,
+) -> torch.Tensor:
+    """Root-mean-square layer normalization over the last dimension.
+    y = x / sqrt(mean(x^2, dim=-1) + eps) * weight
+    Computed in float32 for numerical stability, then cast back to the input
+    dtype (the standard, correctness-preserving convention used by Llama-style
+    RMSNorm). `weight` is optional; when omitted, no affine scale is applied.
+    Raises clear TypeError/ValueError on bad dtype, rank, eps, or a weight
+    whose shape/device does not match x's normalized dimension.
+    """
+    _check_input(x)
+    _check_eps(eps)
+    _check_affine(x, weight, "weight")
+    in_dtype = x.dtype
+    xf = x.to(_compute_dtype(in_dtype))
+    variance = xf.pow(2).mean(dim=-1, keepdim=True)
+    xf = xf * torch.rsqrt(variance + eps)
+    out = xf.to(in_dtype)
+    if weight is not None:
+        out = out * weight
+    return out
+def layer_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    bias: Optional[torch.Tensor] = None,
+    eps: float = 1e-5,
+) -> torch.Tensor:
+    """Standard layer normalization over the last dimension.
+    Mean/variance computed in float32 for stability, then cast back. Matches
+    torch.nn.functional.layer_norm semantics for the normalized-shape = last
+    dim case; verified against it in the test suite.
+    Raises clear TypeError/ValueError on bad dtype, rank, eps, or a
+    weight/bias whose shape/device does not match x's normalized dimension.
+    """
+    _check_input(x)
+    _check_eps(eps)
+    _check_affine(x, weight, "weight")
+    _check_affine(x, bias, "bias")
+    in_dtype = x.dtype
+    xf = x.to(_compute_dtype(in_dtype))
+    mean = xf.mean(dim=-1, keepdim=True)
+    # Biased (population) variance = mean of squared deviations. We compute it
+    # directly rather than via Tensor.var(unbiased=False): torch's .var emits a
+    # "degrees of freedom <= 0" UserWarning when the normalized dim has a single
+    # element, even though unbiased=False is well-defined there (variance 0).
+    # Computing it ourselves matches F.layer_norm exactly and stays silent and
+    # torch.compile(fullgraph=True)-clean for the single-element edge case.
+    centered = xf - mean
+    var = centered.pow(2).mean(dim=-1, keepdim=True)
+    xf = centered * torch.rsqrt(var + eps)
+    out = xf.to(in_dtype)
+    if weight is not None:
+        out = out * weight
+    if bias is not None:
+        out = out + bias
+    return out
+def fused_add_rms_norm(
+    x: torch.Tensor,
+    residual: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 1e-6,
+):
+    """Residual-add followed by RMSNorm — the canonical transformer block pattern.
+        h = x + residual          # updated residual stream
+        y = rms_norm(h, weight, eps)
+        return y, h
+    This mirrors the `fused_add_rms_norm` used in real LLM inference stacks
+    (e.g. the pre-norm transformer block: the normalized output `y` feeds the
+    sublayer, while the un-normalized sum `h` is carried forward as the next
+    residual). We return BOTH so callers can thread the residual stream, which
+    is exactly why the fused form exists.
+    HONESTY: "fused" here means *logically* fused (one Python op, one float32
+    cast path, the add done in float32 alongside the norm) — it is a correct,
+    allocation-conscious pure-PyTorch reference, not a hand-written fused CUDA
+    kernel. No speed claims are made.
+    The add is performed in float32 so that, for float16/bfloat16 inputs, the
+    residual accumulation does not lose precision before normalization — this
+    matches high-quality reference implementations.
+    """
+    _check_input(x, "x")
+    _check_input(residual, "residual")
+    _check_eps(eps)
+    if residual.shape != x.shape:
+        raise ValueError(
+            f"residual shape {tuple(residual.shape)} must equal x shape "
+            f"{tuple(x.shape)} for the residual add"
+        )
+    if residual.device != x.device:
+        raise ValueError(
+            f"residual is on device {residual.device} but x is on {x.device}; "
+            f"move them to the same device"
+        )
+    _check_affine(x, weight, "weight")
+    in_dtype = x.dtype
+    cdt = _compute_dtype(in_dtype)
+    # Add in compute dtype, keep both the normalized output and the residual.
+    hf = x.to(cdt) + residual.to(cdt)
+    new_residual = hf.to(in_dtype)
+    variance = hf.pow(2).mean(dim=-1, keepdim=True)
+    yf = hf * torch.rsqrt(variance + eps)
+    out = yf.to(in_dtype)
+    if weight is not None:
+        out = out * weight
+    return out, new_residual

build/torch-cpu/szl_lambda_gate/governed_norm/_receipt.py ADDED Viewed

	@@ -0,0 +1,253 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Content-addressed governance receipts for normalization calls.
+SZL Holdings' provenance doctrine applied at the kernel layer: when a
+normalization runs in *governed* mode, it emits a small, deterministic
+receipt describing the call — input shape/dtype, eps, and a SHA3-256 digest
+of the (quantized) output tensor — and hash-chains it to the previous
+receipt. This makes a sequence of kernel calls independently auditable
+without trusting the caller.
+HONESTY:
+- The digest is a real SHA3-256 over the output bytes (rounded to a fixed
+  decimal precision so it is reproducible across runs/devices). It is an
+  integrity fingerprint, NOT a cryptographic signature — we never claim
+  it proves authorship. DSSE signing is a separate, out-of-band concern.
+- Receipts are kept in an in-process, append-only chain. Nothing is written
+  to disk or the network from inside the kernel.
+- Stdlib + torch (+ numpy for the output digest) only — Kernel Hub
+  universal-kernel requirement.
+- The canonical szl-receipt v0.2.0 evidence binding (``emit_receipt``) is
+  ADDITIVE and IMPORT-GUARDED: with szl-receipt absent it returns ``None`` and
+  the kernel runs unchanged. It binds subject / input-digest / output-digest /
+  policy-id / energy; energy is the literal string "UNAVAILABLE" because this
+  kernel measures NO joules — a value is never fabricated. Like the SHA3-256
+  chain, it is an EVIDENCE trail, NOT a proof of correctness.
+"""
+import hashlib
+import json
+import threading
+import time
+from typing import Any, Dict, List, Optional, Union
+import torch
+_GENESIS = "0" * 64
+# Logical signing-authority label stamped onto signature envelopes.
+_ORGAN = "szl-governed-norm"
+# Governing policy id bound into every canonical szl-receipt evidence binding.
+_POLICY_ID = "szl-governed-norm/provenance@v1"
+# This universal kernel measures NO joules. The honesty doctrine forbids
+# fabricating an energy value, so the canonical binding records the literal
+# string "UNAVAILABLE" rather than a placeholder number.
+_ENERGY_UNAVAILABLE = "UNAVAILABLE"
+def _maybe_sign(
+    body: Dict[str, Any],
+    sign_key: Optional[Union[str, bytes]],
+    organ: str,
+) -> Optional[Dict[str, Any]]:
+    """ADDITIVE szl-receipt signature layer over the receipt *body*.
+    Returns a DSSE envelope (from ``szl_receipt.sign_receipt``) covering the
+    exact canonical body, or ``None`` when szl-receipt is not installed (the
+    kernel then behaves exactly as before). Doctrine: with no *sign_key* the
+    envelope is UNSIGNED-honest (``signed=False``); a signature is NEVER
+    fabricated. This is distinct from and additive to the SHA3-256 chain
+    integrity hash (``digest``) — szl-receipt's envelope carries its own
+    SHA-256 ``digest``/``algo`` so the two integrity hashes are explicit.
+    """
+    try:
+        from szl_receipt import Receipt, sign_receipt
+    except Exception:  # noqa: BLE001 - signing is optional; absence is honest
+        return None
+    env = sign_receipt(Receipt(kind="governed-norm", body=body),
+                       sign_key, organ=organ)
+    return env
+def _tensor_digest(t: torch.Tensor, decimals: int = 6) -> str:
+    """Deterministic SHA3-256 over a tensor's rounded float32 contents.
+    Rounding to a fixed number of decimals makes the digest stable across
+    devices/dtypes for the same logical values (tiny FP noise won't change
+    it). This is an integrity fingerprint, not a signature.
+    """
+    flat = t.detach().to(torch.float32).reshape(-1)
+    # Round to `decimals` places, integerize, hash the raw bytes. CPU move is
+    # required to read bytes; kept O(n) and allocation-light.
+    scaled = torch.round(flat * (10 ** decimals)).to(torch.int64).cpu().numpy().tobytes()
+    h = hashlib.sha3_256()
+    h.update(scaled)
+    return h.hexdigest()
+def _input_digest(x: torch.Tensor, eps: float) -> str:
+    """SHA3-256 over the canonical JSON of a call's input spec.
+    Binds {input shape, dtype, eps} — the *shape* of the call, not the input
+    bytes — so the receipt is a compact fingerprint of what produced the
+    output. Deterministic and stdlib-only (json + hashlib).
+    """
+    spec = {
+        "in_shape": list(x.shape),
+        "in_dtype": str(x.dtype).replace("torch.", ""),
+        "eps": float(eps),
+    }
+    raw = json.dumps(spec, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha3_256(raw).hexdigest()
+def emit_receipt(
+    op: str,
+    x: torch.Tensor,
+    out: torch.Tensor,
+    eps: float,
+    subject: Optional[str] = None,
+    policy_id: str = _POLICY_ID,
+    sign_key: Optional[Union[str, bytes]] = None,
+    organ: str = _ORGAN,
+) -> Optional[Dict[str, Any]]:
+    """Canonical szl-receipt v0.2.0 evidence binding for a governed-norm call.
+    ADDITIVE and IMPORT-GUARDED: returns ``None`` when szl-receipt is not
+    installed, so this universal Kernel-Hub kernel still imports and runs on
+    stdlib + torch + numpy alone. When szl-receipt is present it binds an
+    EVIDENCE trail and wraps it in a DSSE envelope via ``sign_receipt``:
+        subject        organ / norm-call id (who/what emitted this)
+        input_digest   SHA3-256 over canonical {input shape, dtype, eps}
+        output_digest  the EXISTING SHA3-256 rounded-tensor digest of ``out``
+        policy_id      the governing policy id
+        energy         the literal string "UNAVAILABLE"
+    Doctrine (non-negotiable):
+      * A receipt is an integrity/EVIDENCE trail, NOT a proof of correctness.
+      * ``energy == "UNAVAILABLE"`` — this kernel measures NO joules; a joule is
+        NEVER fabricated.
+      * Keyless => UNSIGNED-honest (``signature["signed"] is False``); a
+        signature is NEVER fabricated. A real ``sign_key`` yields a real DSSE
+        signature over the exact canonical binding.
+    Returns the binding dict (subject/input_digest/output_digest/policy_id/
+    energy) with the DSSE envelope under ``signature``, or ``None`` when
+    szl-receipt is absent.
+    """
+    try:
+        from szl_receipt import Receipt, sign_receipt
+    except Exception:  # noqa: BLE001 - canonical binding is optional; absence is honest
+        return None
+    body = {
+        "subject": subject if subject is not None else f"{organ}/{op}",
+        "input_digest": _input_digest(x, eps),
+        "output_digest": _tensor_digest(out),
+        "policy_id": policy_id,
+        "energy": _ENERGY_UNAVAILABLE,
+    }
+    env = sign_receipt(Receipt(kind="governed-norm", body=body), sign_key, organ=organ)
+    return dict(body, signature=env)
+class ReceiptChain:
+    """Append-only, SHA3-256 hash-chained log of normalization receipts.
+    Each receipt: {seq, op, in_shape, in_dtype, eps, out_digest, prev, digest, ts}
+    digest = SHA3-256 over the canonical JSON body (excluding digest/ts).
+    verify() re-walks the chain and returns (ok, depth, first_break_seq).
+    """
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+        self._records: List[Dict[str, Any]] = []
+    @staticmethod
+    def _digest_body(body: Dict[str, Any]) -> str:
+        raw = json.dumps(body, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        return hashlib.sha3_256(raw).hexdigest()
+    def emit(
+        self,
+        op: str,
+        x: torch.Tensor,
+        out: torch.Tensor,
+        eps: float,
+        sign_key: Optional[Union[str, bytes]] = None,
+        organ: str = _ORGAN,
+        policy_id: str = _POLICY_ID,
+    ) -> Dict[str, Any]:
+        with self._lock:
+            prev = self._records[-1]["digest"] if self._records else _GENESIS
+            seq = len(self._records)
+            body = {
+                "seq": seq,
+                "op": op,
+                "in_shape": list(x.shape),
+                "in_dtype": str(x.dtype).replace("torch.", ""),
+                "eps": float(eps),
+                "out_digest": _tensor_digest(out),
+                "prev": prev,
+            }
+            digest = self._digest_body(body)
+            rec = dict(body, digest=digest, ts=time.time())
+            sig = _maybe_sign(body, sign_key, organ)
+            if sig is not None:
+                rec["signature"] = sig
+            # ADDITIVE canonical szl-receipt v0.2.0 evidence binding. Import-
+            # guarded: None when szl-receipt is absent, so the universal kernel
+            # keeps working on stdlib + torch + numpy only. Binds subject /
+            # input-digest / output-digest / policy-id / energy; energy is
+            # "UNAVAILABLE" (no joules measured here). It does NOT enter the
+            # SHA3-256 chain body, so verify() is unaffected.
+            binding = emit_receipt(
+                op, x, out, eps,
+                subject=f"{organ}/{op}#{seq}",
+                policy_id=policy_id,
+                sign_key=sign_key,
+                organ=organ,
+            )
+            if binding is not None:
+                rec["receipt"] = binding
+            self._records.append(rec)
+            return rec
+    def head(self) -> str:
+        with self._lock:
+            return self._records[-1]["digest"] if self._records else _GENESIS
+    def count(self) -> int:
+        with self._lock:
+            return len(self._records)
+    def tail(self, n: int = 10) -> List[Dict[str, Any]]:
+        with self._lock:
+            return list(self._records[-n:])
+    def verify(self):
+        """Re-walk the chain. Returns (ok: bool, depth: int, first_break: int)."""
+        with self._lock:
+            prev = _GENESIS
+            for i, rec in enumerate(self._records):
+                body = {k: rec[k] for k in
+                        ("seq", "op", "in_shape", "in_dtype", "eps", "out_digest", "prev")}
+                if rec["prev"] != prev or rec["digest"] != self._digest_body(body):
+                    return (False, len(self._records), i)
+                prev = rec["digest"]
+            return (True, len(self._records), -1)
+# Module-level default chain (opt-in: only written when governed=True is used).
+_DEFAULT_CHAIN: Optional[ReceiptChain] = None
+_chain_lock = threading.Lock()
+def default_chain() -> ReceiptChain:
+    global _DEFAULT_CHAIN
+    with _chain_lock:
+        if _DEFAULT_CHAIN is None:
+            _DEFAULT_CHAIN = ReceiptChain()
+        return _DEFAULT_CHAIN

build/torch-cpu/szl_lambda_gate/governed_norm/layers.py ADDED Viewed

	@@ -0,0 +1,60 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Hub-compliant kernel layers.
+Per the Kernel Hub `kernel-requirements`, layers exposed for extension must
+be PURE torch.nn.Module subclasses:
+  - no custom __init__,
+  - no class variables,
+  - only a `forward` method,
+  - forward signature compatible with the module it extends.
+These layers therefore read their parameters (weight/bias/eps) off the
+module instance they are bound to (set by the host model), and only define
+`forward`. They are drop-in replacements for an existing RMSNorm/LayerNorm
+module via the `kernels` layer-mapping mechanism.
+"""
+import torch
+from torch import nn
+from ._norm import fused_add_rms_norm, layer_norm, rms_norm
+class RMSNorm(nn.Module):
+    """Pure RMSNorm layer. Expects the host module to provide `self.weight`
+    (optional) and `self.variance_epsilon` or `self.eps`."""
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        weight = getattr(self, "weight", None)
+        eps = getattr(self, "variance_epsilon", None)
+        if eps is None:
+            eps = getattr(self, "eps", 1e-6)
+        return rms_norm(hidden_states, weight=weight, eps=float(eps))
+class LayerNorm(nn.Module):
+    """Pure LayerNorm layer. Expects the host module to provide `self.weight`
+    (optional), `self.bias` (optional), and `self.eps`."""
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        weight = getattr(self, "weight", None)
+        bias = getattr(self, "bias", None)
+        eps = getattr(self, "eps", 1e-5)
+        return layer_norm(hidden_states, weight=weight, bias=bias, eps=float(eps))
+class FusedAddRMSNorm(nn.Module):
+    """Pure residual-add + RMSNorm layer for pre-norm transformer blocks.
+    Expects the host module to provide `self.weight` (optional) and
+    `self.variance_epsilon` or `self.eps`. Returns `(normalized, new_residual)`
+    where `new_residual = hidden_states + residual` is carried forward as the
+    next block's residual stream.
+    """
+    def forward(self, hidden_states: torch.Tensor, residual: torch.Tensor):
+        weight = getattr(self, "weight", None)
+        eps = getattr(self, "variance_epsilon", None)
+        if eps is None:
+            eps = getattr(self, "eps", 1e-6)
+        return fused_add_rms_norm(hidden_states, residual, weight=weight, eps=float(eps))

build/torch-cpu/szl_lambda_gate/layers.py CHANGED Viewed

@@ -1,51 +1,54 @@
-# SPDX-License-Identifier: Apache-2.0
-# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
-"""Hub-compliant kernel layer for the szl-lambda-gate kernel.
-Per the Kernel Hub `kernel-requirements`, layers exposed for extension must be
-PURE torch.nn.Module subclasses:
-  - no custom __init__,
-  - no class variables,
-  - only a `forward` method.
-The layer therefore reads its parameters (weights / threshold) off the module
-instance it is bound to (set by the host model) and only defines `forward`.
-HONESTY: `LambdaGate` emits an ADVISORY governance signal (the weighted
-geometric mean Λ plus a pass/fail vs threshold). Λ is NOT proven trust; its
-uniqueness is Conjecture 1 (open).
-"""
-import torch
-from torch import nn
-from ._lambda import lambda_aggregate, lambda_gate
-class LambdaGate(nn.Module):
-    """Pure Λ-gate layer.
-    Reads optional ``self.weights`` (1-D, length k) and ``self.threshold``
-    (float, default 0.5) off the bound module instance.
-    forward(axes) -> LambdaGateResult(score, passed, threshold, advisory) where
-    ``score`` = Λ(axes) over the last dim and ``passed`` = score >= threshold.
-    Differentiable in ``score`` w.r.t. ``axes``.
-    """
-    def forward(self, axes: torch.Tensor):
-        weights = getattr(self, "weights", None)
-        threshold = getattr(self, "threshold", 0.5)
-        return lambda_gate(axes, weights=weights, threshold=float(threshold))
-class LambdaAggregate(nn.Module):
-    """Pure Λ-aggregator layer: forward(axes) -> Λ(axes) tensor in [0,1].
-    Reads optional ``self.weights`` (1-D, length k) off the bound module
-    instance; uniform weights when absent. Returns just the score (no gate),
-    fully differentiable w.r.t. ``axes``.
-    """
-    def forward(self, axes: torch.Tensor) -> torch.Tensor:
-        weights = getattr(self, "weights", None)
-        return lambda_aggregate(axes, weights=weights)

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Hub-compliant kernel layer for the szl-lambda-gate kernel.
+Per the Kernel Hub `kernel-requirements`, layers exposed for extension must be
+PURE torch.nn.Module subclasses:
+  - no custom __init__,
+  - no class variables,
+  - only a `forward` method.
+The layer therefore reads its parameters (weights / threshold) off the module
+instance it is bound to (set by the host model) and only defines `forward`.
+HONESTY: `LambdaGate` emits an ADVISORY governance signal (the weighted
+geometric mean Λ plus a pass/fail vs threshold). Λ is NOT proven trust; its
+uniqueness is Conjecture 1 (open).
+"""
+import torch
+from torch import nn
+from ._lambda import lambda_aggregate, lambda_gate
+class LambdaGate(nn.Module):
+    """Pure Λ-gate layer.
+    Reads optional ``self.weights`` (1-D, length k) and ``self.threshold``
+    (float) off the bound module instance. An unset threshold uses the legacy
+    0.5 with a DeprecationWarning (see ``lambda_gate``); set it explicitly.
+    forward(axes) -> LambdaGateResult(score, passed, threshold, advisory) where
+    ``score`` = Λ(axes) over the last dim and ``passed`` = score >= threshold.
+    Differentiable in ``score`` w.r.t. ``axes``.
+    """
+    def forward(self, axes: torch.Tensor):
+        weights = getattr(self, "weights", None)
+        threshold = getattr(self, "threshold", None)
+        if threshold is not None:
+            threshold = float(threshold)
+        return lambda_gate(axes, weights=weights, threshold=threshold)
+class LambdaAggregate(nn.Module):
+    """Pure Λ-aggregator layer: forward(axes) -> Λ(axes) tensor in [0,1].
+    Reads optional ``self.weights`` (1-D, length k) off the bound module
+    instance; uniform weights when absent. Returns just the score (no gate),
+    fully differentiable w.r.t. ``axes``.
+    """
+    def forward(self, axes: torch.Tensor) -> torch.Tensor:
+        weights = getattr(self, "weights", None)
+        return lambda_aggregate(axes, weights=weights)

build/torch-universal/__init__.py ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ from .szl_lambda_gate import * # noqa: F401,F403
2	+ from .szl_lambda_gate import __all__

build/torch-universal/metadata.json ADDED Viewed

	@@ -0,0 +1 @@

+ {"backend":{"type":"cpu"},"digest":{"algorithm":"sha256","files":{"__init__.py":"NuinjlWRNlWgg0y2D61HEaKtW/VOktRHP8w2Nj3opjQ=","szl_lambda_gate/__init__.py":"QpfkkacuKUGxXitqBYLq0nM4NnCsX7uNFOLHbeye0V0=","szl_lambda_gate/_lambda.py":"+VOjgBnJGm+oqcQR9VuqT18rnnbXFTu6VLuKXZRprzg=","szl_lambda_gate/_ops.py":"at8dxC56nm2pFOME2pcgQ45ZwjQQThHz5cyqRezuI7Y=","szl_lambda_gate/_v1.py":"msLY/gpH/xkeunbmKx6d2bK1T2S6DD2GMG4M3Vi8Row=","szl_lambda_gate/governed_norm/__init__.py":"UP5PsJoWXQrpp4Hw7zUVOIx1KhTN6V9zaHhU9Zp9+tw=","szl_lambda_gate/governed_norm/_norm.py":"z3Ks4oHshsUEQm914j7r22YaHjoS5N/MbIufpjSwOUI=","szl_lambda_gate/governed_norm/_receipt.py":"2xJEvRhK/9ypKb04rHKLJpb4KtVlqvgtFMo4RdTXSKk=","szl_lambda_gate/governed_norm/layers.py":"15yDNVyyMyudDp2YWEuGQ05IZTLifTBlLfEBWLMPw3s=","szl_lambda_gate/layers.py":"UdpHjhhe5NFtqplxvcvc/LsMDFt4N6ACuXzQXLlo6nU="}},"id":"_szl_lambda_gate_universal_7cb79cba7ecb5dbb9da59b2d6b516a98d2a114d6","license":"Apache-2.0","name":"szl-lambda-gate","python-depends":[],"source":"https://github.com/szl-holdings/szl-lambda-gate","universal":true,"version":1}

build/torch-universal/szl_lambda_gate/__init__.py ADDED Viewed

	@@ -0,0 +1,216 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""szl_lambda_gate — the Lambda-Spine aggregator (Λ) as a universal kernel.
+A pure-PyTorch (universal) kernel from SZL Holdings for the Hugging Face
+Kernel Hub. It ports the canonical Λ aggregator into a differentiable,
+torch.compile-friendly torch op:
+    Λ(x) = ∏ xᵢ^{wᵢ},  Σwᵢ = 1,  wᵢ > 0,  xᵢ ∈ [0,1]   (weighted geometric mean)
+plus an ADVISORY governance gate (Λ vs threshold), the four carried axioms as
+real runtime self-checks, and pure nn.Module layers.
+Load from the Hub:
+    import torch
+    from kernels import get_kernel
+    lg = get_kernel("SZLHOLDINGS/szl-lambda-gate")
+    axes = torch.tensor([0.9, 0.8, 0.95])        # axis scores in [0,1]
+    score = lg.lambda_aggregate(axes)            # Λ(x) ∈ [0,1]
+    res = lg.lambda_gate(axes, threshold=0.5)    # ADVISORY pass/fail
+    print(res.score, res.passed, res.advisory)
+    # szl.lambda/v1 strict gate (spec/szl.lambda.v1.json): no clamping, no
+    # renormalisation, tau required; bad input -> verdict BLOCK with a code.
+    w = torch.tensor([0.4, 0.3, 0.3], dtype=torch.float64)
+    v1 = lg.lambda_v1_gate(axes.double(), w, tau=0.8)
+    print(v1.verdict, v1.code)                   # GO / NO_GO / ABSTAIN / BLOCK
+WHAT Λ IS / IS NOT (HONESTY — SZL Holdings doctrine v11):
+  Λ is the weighted-geometric-mean aggregator — a non-compensatory, ADVISORY
+  way to roll axis scores in [0,1] into one number (any zeroed axis zeroes the
+  aggregate). It is NOT "proven trust" and NOT a closed theorem: Λ-uniqueness
+  remains Conjecture 1 (OPEN — an unresolved CAUCHY_ND step plus a missing
+  symmetry axiom). Label it honestly everywhere; a gate "pass" is advisory.
+PROVENANCE: backed by the Lean 4 formalization szl-holdings/lutar-lean
+  (749 declarations / 14 axioms / 163 tracked sorries),
+  DOI 10.5281/zenodo.20434308 (lutar-lean). Λ uniqueness = Conjecture 1 (open).
+"""
+from typing import Optional
+import torch
+from . import layers  # noqa: F401  (must be importable for Hub layer mapping)
+# CONSOLIDATION (Wave D): the governed-norm universal kernel is folded in here
+# as a subpackage so szl-lambda-gate is the ONE canonical kernels package. The
+# source repo szl-holdings/szl-governed-norm is DEPRECATED and points here;
+# nothing was deleted (additive, reversible copy). Λ stays Conjecture 1.
+from . import governed_norm  # noqa: F401  (folded-in governed normalization kernels)
+from ._lambda import YUYAY_AXES, YUYAY_FLOORS, LambdaGateResult
+from ._lambda import _resolve_threshold
+from ._lambda import find_axiom_violation as _find_axiom_violation
+from ._lambda import is_bounded_by_max as _is_bounded_by_max
+from ._lambda import is_egyptian_exact as _is_egyptian_exact
+from ._lambda import is_homogeneous as _is_homogeneous
+from ._lambda import is_monotone as _is_monotone
+from ._lambda import lambda_aggregate as _lambda_aggregate
+from ._lambda import lambda_gate as _lambda_gate
+from ._lambda import lambda_gate_batch as _lambda_gate_batch
+from ._lambda import selfcheck as _selfcheck
+from ._lambda import yuyay_weights as _yuyay_weights
+# szl.lambda/v1 strict entry (spec/szl.lambda.v1.json): validated, coded, tau required.
+from ._v1 import LambdaV1Error, LambdaV1GateResult, lambda_v1, lambda_v1_gate
+__all__ = [
+    "lambda_aggregate",
+    "lambda_gate",
+    "lambda_gate_batch",
+    "LambdaGateResult",
+    "lambda_v1",
+    "lambda_v1_gate",
+    "LambdaV1Error",
+    "LambdaV1GateResult",
+    "is_monotone",
+    "is_egyptian_exact",
+    "is_bounded_by_max",
+    "is_homogeneous",
+    "find_axiom_violation",
+    "selfcheck",
+    "yuyay_weights",
+    "YUYAY_AXES",
+    "YUYAY_FLOORS",
+    "layers",
+    "DOCTRINE_FOOTER",
+    "PROVENANCE",
+    "__version__",
+    # ---- folded-in governed-norm kernels (Wave D consolidation) ----
+    "governed_norm",
+    "rms_norm",
+    "layer_norm",
+    "fused_add_rms_norm",
+]
+# ---- folded-in governed-norm surface (Wave D consolidation) ---------------- #
+# Convenience top-level re-exports of the governed normalization kernels that
+# were absorbed from szl-governed-norm. The full surface (ReceiptChain,
+# emit_receipt, receipt_* helpers, selfcheck, layers) lives under
+# ``szl_lambda_gate.governed_norm``. These are a DIFFERENT kernel family from Λ
+# (normalization, not the Λ aggregator); Λ itself remains Conjecture 1
+# (advisory, uniqueness OPEN) and is never described as proven trust.
+rms_norm = governed_norm.rms_norm
+layer_norm = governed_norm.layer_norm
+fused_add_rms_norm = governed_norm.fused_add_rms_norm
+__version__ = "0.2.0"
+DOCTRINE_FOOTER = (
+    "SZL Holdings · Λ = Conjecture 1 (ADVISORY, weighted geometric mean) · "
+    "uniqueness OPEN · NOT proven trust · honesty over checklist"
+)
+PROVENANCE = {
+    "lean_repo": "szl-holdings/lutar-lean",
+    "lean_declarations": 749,
+    "lean_axioms": 14,
+    "lean_tracked_sorries": 163,
+    "doi_lutar_lean": "10.5281/zenodo.20434308",
+    "lambda_status": "Conjecture 1 (open) — uniqueness unproven; advisory only",
+}
+def lambda_aggregate(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    """Λ(x) = ∏ xᵢ^{wᵢ}, the weighted geometric mean over the last dim of axes.
+    See ``szl_lambda_gate._lambda.lambda_aggregate``. Axis scores in [0,1],
+    uniform weights when ``weights`` is None. Differentiable, batched, and
+    torch.compile-friendly. ADVISORY — NOT proven trust.
+    """
+    return _lambda_aggregate(axes, weights=weights)
+def lambda_gate(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    threshold: Optional[float] = None,
+) -> LambdaGateResult:
+    """ADVISORY Λ governance gate: returns LambdaGateResult(score, passed,
+    threshold, advisory). ``passed`` = Λ(axes) >= threshold. ``threshold`` must
+    lie within Λ's range [0,1] (a value outside it is a misconfiguration — a
+    negative threshold would advisory-pass a fully-failing Λ=0 candidate — and
+    is rejected). Omitting it uses the legacy 0.5 with a DeprecationWarning
+    (policy_tau is 0.8); pass it, or use ``lambda_v1_gate(axes, weights, tau)``.
+    A pass is an advisory, non-compensatory signal — NOT proven trust
+    (Λ = Conjecture 1).
+    """
+    threshold = _resolve_threshold(threshold, stacklevel=2)
+    return _lambda_gate(axes, weights=weights, threshold=threshold)
+def lambda_gate_batch(
+    candidates: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    threshold: Optional[float] = None,
+) -> LambdaGateResult:
+    """ADVISORY batch gate over many candidate action-vectors (shape (..., N, k)).
+    The realistic per-inference-step call: score all N candidates at once and
+    return the advisory pass mask. Returns LambdaGateResult(score, passed,
+    threshold, advisory) with score/passed of shape (..., N). ``threshold``
+    must lie within Λ's range [0,1] (same domain guard as ``lambda_gate``);
+    omitting it uses the legacy 0.5 with a DeprecationWarning.
+    NOT proven trust.
+    """
+    threshold = _resolve_threshold(threshold, stacklevel=2)
+    return _lambda_gate_batch(candidates, weights=weights, threshold=threshold)
+def yuyay_weights(dtype: torch.dtype = torch.float64, device=None) -> torch.Tensor:
+    """Canonical 13-axis Yuyay Λ weight vector (uniform 1/13), ADVISORY only.
+    Use as ``weights`` over the 13 ``YUYAY_AXES``. The yuyay_v3 gate is a
+    conjunctive AND with per-axis floors (``YUYAY_FLOORS``); this Λ roll-up is
+    the weighted geometric mean and is ADVISORY — NOT proven trust.
+    """
+    return _yuyay_weights(dtype=dtype, device=device)
+def find_axiom_violation(k=5, trials=200, weights=None, seed=0, tol=1e-6):
+    """Random-search for any A1–A4 violation; returns (axiom, axes, weights) or
+    None. An honest falsification attempt — finding nothing is evidence, not a
+    proof (Λ-uniqueness is Conjecture 1, open).
+    """
+    return _find_axiom_violation(k=k, trials=trials, weights=weights, seed=seed, tol=tol)
+def selfcheck(k=5, trials=64, seed=0) -> dict:
+    """Expose the A1–A4 empirical self-checks + version as a single verdict dict.
+    Callable as get_kernel(...).selfcheck(). EMPIRICAL checks on sampled inputs,
+    NOT a proof of Λ-uniqueness (Conjecture 1, open). Advisory only.
+    """
+    return _selfcheck(k=k, trials=trials, seed=seed)
+# ---- axiom runtime self-checks (real, verifiable; NOT a uniqueness proof) -- #
+def is_monotone(axes, weights=None, delta=0.05, tol=1e-7) -> bool:
+    """A1 IsMonotone self-check: Λ is non-decreasing in each axis (on this data)."""
+    return _is_monotone(axes, weights=weights, delta=delta, tol=tol)
+def is_egyptian_exact(c, k=3, weights=None, tol=1e-5) -> bool:
+    """A3 IsEgyptianExact self-check: Λ(c, …, c) = c."""
+    return _is_egyptian_exact(c, k=k, weights=weights, tol=tol)
+def is_bounded_by_max(axes, weights=None, tol=1e-6) -> bool:
+    """A4 IsBounded self-check: Λ(x) ≤ maxᵢ xᵢ."""
+    return _is_bounded_by_max(axes, weights=weights, tol=tol)
+def is_homogeneous(axes, t, weights=None, tol=1e-5) -> bool:
+    """A2 IsHomogeneous(degree 1) self-check: Λ(t·x) = t·Λ(x)."""
+    return _is_homogeneous(axes, t, weights=weights, tol=tol)

build/torch-universal/szl_lambda_gate/_lambda.py ADDED Viewed

	@@ -0,0 +1,556 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Pure-PyTorch Lambda-Spine aggregator (Λ) for the szl-lambda-gate kernel.
+Λ(x) = ∏ xᵢ^{wᵢ},  Σwᵢ = 1,  wᵢ > 0,  xᵢ ∈ [0,1]   (weighted geometric mean)
+This is a TORCH port of the canonical pure-Python reference
+(packages/puriq-os/puriq_os/lambda_aggregator.py — saved alongside this kernel
+as lambda_aggregator_source.py). It is a correctness reference, computed via
+logs in float32 for stability, differentiable (autograd works), and
+torch.compile-friendly. Depends ONLY on torch + the Python standard library
+(a Kernel Hub requirement for universal kernels).
+WHAT Λ IS / IS NOT (HONESTY — SZL Holdings doctrine v11):
+  Λ is the *weighted-geometric-mean aggregator*: a non-compensatory way to
+  combine axis scores in [0,1] into one number. It is ADVISORY governance
+  signal — a conservative roll-up where any single zeroed axis drives the
+  aggregate to 0. It is NOT "proven trust" and NOT a closed theorem. Its
+  *uniqueness* (that the weighted geometric mean is the only aggregator
+  satisfying the carried axioms) remains Conjecture 1 — OPEN (an unresolved
+  CAUCHY_ND step plus a missing symmetry axiom in the Lean development). Do
+  not describe Λ as proven trust anywhere.
+PRIOR ART (honest attribution): the weighted geometric mean as a *less-
+  compensatory* composite-indicator aggregator is established practice — the
+  UN HDI (arithmetic→geometric switch, 2010), the OECD Handbook on
+  Constructing Composite Indicators (2008), and the UNECE well-being
+  guidelines all use it "to limit the compensation effect". The veto / cut-off
+  idea (a single failing criterion blocks a pass regardless of the others) is
+  the ELECTRE veto threshold / "satisficing" minimum-threshold screen. The
+  13-axis conjunctive form exposed by :func:`yuyay_weights` is SZL's own
+  yuyay_v3 "Heart" gate. None of this makes Λ "proven trust"; the gate is
+  ADVISORY (a11oy: "the advisory Λ trust score is a research conjecture, not a
+  pass/fail oracle").
+PROVENANCE: backed by the Lean 4 formalization szl-holdings/lutar-lean
+  (749 declarations / 14 axioms / 163 tracked sorries),
+  DOI 10.5281/zenodo.20434308 (lutar-lean).
+  Λ uniqueness = Conjecture 1 (open).
+Axioms carried (Lutar/Axioms.lean), available below as runtime self-checks:
+  A1 IsMonotone        — Λ is non-decreasing in each axis
+  A2 IsHomogeneous     — Λ(t·x) = t·Λ(x)  (degree 1)
+  A3 IsEgyptianExact   — Λ(c,…,c) = c       (the uniform-diagonal fixpoint)
+  A4 IsBounded(by max) — Λ(x) ≤ maxᵢ xᵢ
+"""
+import warnings
+from typing import Optional
+import torch
+# ---- the deprecated implicit threshold ------------------------------------- #
+# lambda_gate / lambda_gate_batch / layers.LambdaGate used to default to 0.5.
+# That default stays, so there is no behaviour change, but omitting the
+# threshold now raises a DeprecationWarning. The admit policy value is
+# policy_tau in frontier/model_admit_contract.v1.json, and the strict
+# szl.lambda/v1 gate (_v1.lambda_v1_gate) takes tau as a required argument.
+_LEGACY_DEFAULT_THRESHOLD = 0.5
+_DEFAULT_THRESHOLD_WARNING = (
+    "default threshold 0.5 differs from policy_tau 0.8; pass tau. Omitting the "
+    "threshold of lambda_gate / lambda_gate_batch / LambdaGate is deprecated: "
+    "pass threshold= explicitly (policy_tau is in "
+    "frontier/model_admit_contract.v1.json), or use the strict "
+    "lambda_v1_gate(axes, weights, tau). The legacy default 0.5 still applies."
+)
+def _resolve_threshold(threshold: Optional[float], stacklevel: int) -> float:
+    """``None`` (the threshold was omitted) -> the legacy 0.5, with a DeprecationWarning.
+    ``stacklevel`` is what the calling entry point would pass to
+    ``warnings.warn`` itself (2 = its caller), so the warning names the line
+    that omitted the threshold. Dynamo cannot trace ``warnings.warn`` (a
+    fullgraph compile would fail), so the warning is skipped while
+    ``torch.compile`` traces; the default is applied either way.
+    """
+    if threshold is not None:
+        return threshold
+    if not bool(getattr(torch.compiler, "is_compiling", lambda: False)()):
+        warnings.warn(_DEFAULT_THRESHOLD_WARNING, DeprecationWarning, stacklevel=stacklevel + 1)
+    return _LEGACY_DEFAULT_THRESHOLD
+# Compute reductions/log-sum in float32 for stability when inputs are low
+# precision; keep float64 inputs in float64 (downcasting would break gradcheck
+# and silently lose precision).
+_SUPPORTED_DTYPES = (torch.float16, torch.bfloat16, torch.float32, torch.float64)
+def _compute_dtype(in_dtype: torch.dtype) -> torch.dtype:
+    return torch.float32 if in_dtype in (torch.float16, torch.bfloat16) else in_dtype
+def _check_axes(axes: torch.Tensor) -> None:
+    """Cheap, allocation-free metadata guards on the axis-score tensor.
+    Inspects only type / dtype / rank / last-dim, so it constant-folds under
+    torch.compile and adds no tensor work on the happy path.
+    """
+    if not isinstance(axes, torch.Tensor):
+        raise TypeError(f"axes must be a torch.Tensor, got {type(axes).__name__}")
+    if axes.dtype not in _SUPPORTED_DTYPES:
+        raise TypeError(
+            f"axes has unsupported dtype {axes.dtype}; "
+            f"expected one of {tuple(str(d) for d in _SUPPORTED_DTYPES)}"
+        )
+    if axes.dim() < 1:
+        raise ValueError(
+            "axes must have at least 1 dimension (the k axis scores live on "
+            f"the last dim); got a {axes.dim()}-d tensor"
+        )
+    if axes.shape[-1] < 1:
+        raise ValueError("axes last dimension (k = number of axes) must be >= 1")
+def _resolve_weights(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor],
+    cdt: torch.dtype,
+) -> torch.Tensor:
+    """Return a normalized (Σw = 1) weight vector of shape (k,) in compute dtype.
+    ``weights=None`` -> uniform 1/k (the Egyptian-exact diagonal). Otherwise the
+    weights must be 1-D of length k, strictly positive, with a positive sum;
+    they are normalized so Σwᵢ = 1.
+    """
+    k = axes.shape[-1]
+    if weights is None:
+        return torch.full((k,), 1.0 / k, dtype=cdt, device=axes.device)
+    if not isinstance(weights, torch.Tensor):
+        raise TypeError(f"weights must be a torch.Tensor or None, got {type(weights).__name__}")
+    if weights.device != axes.device:
+        raise ValueError(
+            f"weights is on device {weights.device} but axes is on {axes.device}; "
+            "move them to the same device"
+        )
+    if weights.dim() != 1 or weights.shape[0] != k:
+        raise ValueError(
+            f"weights must be 1-D with shape ({k},) to match the last dim of axes; "
+            f"got shape {tuple(weights.shape)}"
+        )
+    wf = weights.to(cdt)
+    compiling = bool(getattr(torch.compiler, "is_compiling", lambda: False)())
+    if not compiling:
+        if not bool(torch.all(torch.isfinite(wf))):
+            raise ValueError("weights must all be finite (no NaN/Inf)")
+        if bool(torch.any(wf <= 0.0)):
+            raise ValueError("weights must be strictly positive (wᵢ > 0)")
+        sw = wf.sum()
+        if not bool(sw > 0.0):
+            raise ValueError("weights must sum to a positive value")
+        return wf / sw
+    # Compiled path stays in tensor-land. Non-positive weights are a misuse;
+    # clamp them away from zero so the graph does not break, then normalize.
+    # This path is outside szl.lambda/v1; _v1.lambda_v1 validates before it
+    # gets here and is not meant to run under torch.compile.
+    wf = torch.where(torch.isfinite(wf), wf, torch.ones_like(wf))
+    wf = torch.clamp(wf, min=torch.finfo(wf.dtype).tiny)
+    return wf / wf.sum()
+def lambda_aggregate(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    """Weighted geometric mean Λ(x) = ∏ xᵢ^{wᵢ} over the last dim of ``axes``.
+    Λ is the (ADVISORY) Lambda-Spine aggregator. Axis scores are expected in
+    [0,1] and are clamped into [0,1]; uniform weights (1/k) are used when
+    ``weights`` is None — the Egyptian-exact diagonal. Computed via logs in
+    float32 (or float64 for float64 inputs) for numerical stability:
+        Λ(x) = exp( Σᵢ wᵢ · log(clamp(xᵢ, 0, 1)) )
+    Non-compensatory zero-routing (A4-consistent): any axis that is zero, OR
+    that is NON-FINITE (NaN / ±Inf), is treated as a FAILING axis and drives
+    the whole aggregate to exactly 0. This is the conservative governance
+    choice — a garbage/invalid axis must never silently pass as a "perfect"
+    (clamped-to-1) axis, and the output (and its gradient) stay finite and in
+    [0,1] for every input. Zeros/non-finite axes are routed explicitly so
+    log(0) = -inf and log(NaN) = NaN never produce a NaN value or gradient.
+    Args:
+        axes:    tensor of shape (..., k) of axis scores in [0,1]. Batched:
+                 the reduction is over the last dim, leading dims are batch.
+        weights: optional 1-D tensor of shape (k,); None -> uniform. Normalized
+                 internally so Σwᵢ = 1.
+    Returns:
+        tensor of shape (...) — Λ(x) ∈ [0,1] per batch row. Differentiable
+        w.r.t. ``axes`` (and ``weights``).
+    NOT the szl.lambda/v1 contract: this function clamps, zero-routes NaN/±Inf
+    and renormalises (pinned in tests/test_lambda_v1_torch_divergence.py). For
+    validated, coded errors use :func:`szl_lambda_gate._v1.lambda_v1`.
+    HONESTY: this is a non-compensatory governance roll-up, NOT proven trust.
+    Λ-uniqueness is Conjecture 1 (open).
+    """
+    _check_axes(axes)
+    in_dtype = axes.dtype
+    cdt = _compute_dtype(in_dtype)
+    xf = axes.to(cdt)
+    w = _resolve_weights(axes, weights, cdt)  # (k,), Σw=1
+    # A "bad" axis is one that fails non-compensatorily: a non-positive score
+    # OR a non-finite value (NaN / ±Inf). clamp(+inf)=1 would otherwise count a
+    # garbage axis as perfect, and clamp(NaN)=NaN would poison the product — we
+    # treat BOTH as failing (zeroing) axes. Detect non-finite on the RAW input.
+    finite_mask = torch.isfinite(xf)
+    xc = xf.clamp(0.0, 1.0)
+    bad_mask = (~finite_mask) | (xc <= 0.0)
+    any_bad = torch.any(bad_mask, dim=-1)  # (...)
+    # Replace bad axes with 1.0 before the log purely to keep log finite and the
+    # gradient well-defined; the bad-axis contribution is reinstated via any_bad.
+    safe = torch.where(bad_mask, torch.ones_like(xc), xc)
+    logx = torch.log(safe)                    # (..., k)
+    acc = (logx * w).sum(dim=-1)              # (...)  weighted log-sum
+    val = torch.exp(acc)                      # (...)  Λ before zero-routing
+    out = torch.where(any_bad, torch.zeros_like(val), val)
+    out = out.clamp(0.0, 1.0)
+    return out.to(in_dtype)
+def lambda_gate(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    threshold: Optional[float] = None,
+):
+    """ADVISORY governance gate over Λ(x): score plus a pass/fail vs threshold.
+    Computes Λ(x) (see :func:`lambda_aggregate`) and compares it to
+    ``threshold``: pass := Λ(x) >= threshold.
+    DEPRECATED DEFAULT: omitting ``threshold`` (or passing ``None``) still uses
+    the legacy 0.5 but raises a ``DeprecationWarning``, because 0.5 differs
+    from the admit contract's policy_tau (0.8). Pass the threshold explicitly,
+    or use the strict szl.lambda/v1 gate
+    :func:`szl_lambda_gate._v1.lambda_v1_gate`, where tau is required.
+    ``threshold`` must be a finite float within Λ's range ``[0, 1]`` (Λ is the
+    weighted geometric mean over [0,1]). This bound is enforced: a threshold
+    below 0 or above 1 is meaningless for the advisory gate and is rejected —
+    see the non-compensatory rationale below. The domain edges are valid:
+    ``0.0`` admits every candidate (a permissive "no-gate" boundary) and
+    ``1.0`` admits only a Λ == 1 candidate.
+    Returns a :class:`LambdaGateResult` namedtuple with fields:
+        score     — Λ(x) tensor of shape (...), in [0,1]
+        passed    — boolean tensor of shape (...), Λ(x) >= threshold
+        threshold — the float threshold used
+        advisory  — always True; a STANDING reminder that this is a
+                    non-compensatory governance signal, NOT proven trust.
+    Non-compensatory threshold hardening: because a failing/garbage candidate
+    (a zero, NaN, or ±Inf axis) is routed to Λ = 0, a NEGATIVE threshold would
+    advisory-"pass" exactly those fully-failing candidates (0 >= t for t < 0) —
+    the opposite of a conservative admission gate. A threshold above 1 can
+    never pass. Both are misconfigurations, so the [0,1] domain is enforced up
+    front rather than silently producing a wrong pass mask.
+    HONESTY: a "pass" is an ADVISORY signal only. Λ is the weighted-geometric-
+    mean aggregator; its uniqueness is Conjecture 1 (open). Do not treat a
+    pass as proven trust or a closed theorem.
+    """
+    threshold = _resolve_threshold(threshold, stacklevel=2)
+    t = float(threshold)
+    if t != t or t == float("inf") or t == float("-inf"):
+        raise ValueError(f"threshold must be a finite float, got {threshold!r}")
+    if t < 0.0 or t > 1.0:
+        raise ValueError(
+            "threshold must be within Λ's range [0, 1] (Λ is the weighted "
+            f"geometric mean over [0,1]); got {t!r}. A threshold below 0 would "
+            "advisory-pass a fully-failing (Λ=0) candidate and one above 1 can "
+            "never pass — both signal a misconfigured gate."
+        )
+    score = lambda_aggregate(axes, weights)
+    passed = score >= t
+    return LambdaGateResult(score=score, passed=passed, threshold=t, advisory=True)
+def lambda_gate_batch(
+    candidates: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    threshold: Optional[float] = None,
+):
+    """ADVISORY batch gate: score MANY candidate action-vectors in one call.
+    This is the realistic way a model/agent uses the gate — one call per
+    inference step that scores every proposed action-vector at once and returns
+    the advisory pass mask (which candidates clear the threshold).
+    ``candidates`` is a tensor of shape (..., N, k): the last dim ``k`` holds
+    the per-axis scores of a single candidate, and the second-to-last dim ``N``
+    enumerates the candidates (any leading dims are extra batch). Equivalent to
+    calling :func:`lambda_gate` on the whole tensor — the reduction is over the
+    last dim — but named to make the agent-loop intent explicit. ``threshold``
+    inherits the same [0,1] domain guard as :func:`lambda_gate` (a threshold
+    outside Λ's range is a misconfiguration and is rejected). Omitting it uses
+    the legacy 0.5 with a ``DeprecationWarning``, as in :func:`lambda_gate`.
+    Returns a :class:`LambdaGateResult` with:
+        score     — Λ tensor of shape (..., N), one score per candidate
+        passed    — boolean mask of shape (..., N): score >= threshold
+        threshold — the float threshold used
+        advisory  — always True (NOT proven trust)
+    HONESTY: the pass mask is an ADVISORY, non-compensatory signal. A "pass"
+    is not proven trust; Λ-uniqueness is Conjecture 1 (open).
+    """
+    threshold = _resolve_threshold(threshold, stacklevel=2)
+    _check_axes(candidates)
+    if candidates.dim() < 2:
+        raise ValueError(
+            "candidates must be at least 2-D, shape (..., N, k): the last dim is "
+            f"the k axis scores and the one before it enumerates the N candidates; "
+            f"got a {candidates.dim()}-d tensor"
+        )
+    # Reuse the single-call gate — its reduction over the last dim already gives
+    # one score per candidate, so the (..., N) layout falls out for free.
+    return lambda_gate(candidates, weights=weights, threshold=threshold)
+# ---- A1..A4 axiom RUNTIME self-checks (real, verifiable) ------------------- #
+# These are honest empirical checks callers can run on concrete inputs. They
+# verify the carried axioms hold for THIS implementation on the given data —
+# they are NOT a proof of Λ-uniqueness (that is Conjecture 1, open).
+def is_egyptian_exact(
+    c: float,
+    k: int = 3,
+    weights: Optional[torch.Tensor] = None,
+    tol: float = 1e-5,
+) -> bool:
+    """A3 IsEgyptianExact: Λ(c, …, c) = c for a constant axis vector of length k.
+    Builds the uniform vector (c repeated k times) and checks Λ equals c within
+    ``tol``. ``c`` is clamped into [0,1] to match the aggregator's domain.
+    """
+    if k < 1:
+        raise ValueError("k must be >= 1")
+    cc = min(max(float(c), 0.0), 1.0)
+    axes = torch.full((k,), cc, dtype=torch.float64)
+    val = lambda_aggregate(axes, weights)
+    return bool(torch.abs(val - cc) <= tol)
+def is_bounded_by_max(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    tol: float = 1e-6,
+) -> bool:
+    """A4 IsBounded: Λ(x) ≤ maxᵢ xᵢ (over the last dim), within ``tol``.
+    Returns True iff the bound holds for every batch row. Non-finite axis
+    values are clamped/zero-routed the same way the aggregator treats them, so
+    the bound is checked on the conservative (finite) domain.
+    """
+    _check_axes(axes)
+    val = lambda_aggregate(axes, weights)                       # (...)
+    xf = axes.to(_compute_dtype(axes.dtype))
+    # Mirror the aggregator: non-finite axes are failing (treated as 0) for the
+    # purposes of the max bound, so the check matches the routed semantics.
+    xf = torch.where(torch.isfinite(xf), xf, torch.zeros_like(xf))
+    mx = xf.clamp(0.0, 1.0).amax(dim=-1)                        # (...)
+    return bool(torch.all(val.to(mx.dtype) <= mx + tol))
+def is_homogeneous(
+    axes: torch.Tensor,
+    t: float,
+    weights: Optional[torch.Tensor] = None,
+    tol: float = 1e-5,
+) -> bool:
+    """A2 IsHomogeneous (degree 1): Λ(t·x) = t·Λ(x) for scalar t in [0,1].
+    Verified on the clamped domain: both ``axes`` and ``t*axes`` must remain in
+    [0,1] for the identity to be meaningful, so ``axes`` is clamped to [0,1] and
+    ``t`` to [0,1] before the comparison.
+    """
+    _check_axes(axes)
+    tt = min(max(float(t), 0.0), 1.0)
+    x = axes.to(torch.float64).clamp(0.0, 1.0)
+    lhs = lambda_aggregate(x * tt, weights)
+    rhs = tt * lambda_aggregate(x, weights)
+    return bool(torch.all(torch.abs(lhs - rhs) <= tol))
+def is_monotone(
+    axes: torch.Tensor,
+    weights: Optional[torch.Tensor] = None,
+    delta: float = 0.05,
+    tol: float = 1e-7,
+) -> bool:
+    """A1 IsMonotone: Λ is non-decreasing in each axis.
+    For each axis j, nudges that axis UP by ``delta`` (clamped to stay ≤ 1) on
+    every batch row and checks Λ does not decrease (within ``tol``). Rows that
+    cannot move (already at 1) are skipped for that axis. A real check on the
+    given data — not a symbolic proof.
+    """
+    _check_axes(axes)
+    x = axes.to(torch.float64).clamp(0.0, 1.0)
+    base = lambda_aggregate(x, weights)
+    k = x.shape[-1]
+    ok = True
+    for j in range(k):
+        bumped = x.clone()
+        bumped[..., j] = (bumped[..., j] + float(delta)).clamp(0.0, 1.0)
+        bumped_val = lambda_aggregate(bumped, weights)
+        # Λ must not go DOWN when an axis goes UP.
+        ok = ok and bool(torch.all(bumped_val - base >= -tol))
+    return ok
+# ---- Adversarial axiom search (honest: a falsification attempt) ------------ #
+def find_axiom_violation(
+    k: int = 5,
+    trials: int = 200,
+    weights: Optional[torch.Tensor] = None,
+    seed: Optional[int] = 0,
+    tol: float = 1e-6,
+):
+    """Random-search for ANY A1–A4 violation on random axis/weight draws.
+    Returns the first ``(axiom, axes, weights)`` triple that violates a carried
+    axiom within ``tol``, or ``None`` if none is found in ``trials`` draws. This
+    is an honest FALSIFICATION attempt on this implementation — finding nothing
+    is empirical evidence, NOT a proof (Λ-uniqueness is Conjecture 1, open).
+    """
+    gen = torch.Generator()
+    if seed is not None:
+        gen.manual_seed(int(seed))
+    for _ in range(int(trials)):
+        x = torch.rand(k, generator=gen, dtype=torch.float64)
+        w = weights
+        if w is None:
+            w = torch.rand(k, generator=gen, dtype=torch.float64) + 1e-3
+        # A3 on a constant draw
+        c = float(torch.rand(1, generator=gen).item())
+        if not is_egyptian_exact(c, k=k, weights=w, tol=max(tol, 1e-5)):
+            return ("A3_IsEgyptianExact", torch.full((k,), c, dtype=torch.float64), w)
+        # A4 bounded-by-max
+        if not is_bounded_by_max(x, w, tol=max(tol, 1e-6)):
+            return ("A4_IsBounded", x, w)
+        # A2 homogeneous at a random t
+        t = float(torch.rand(1, generator=gen).item())
+        if not is_homogeneous(x, t, weights=w, tol=max(tol, 1e-5)):
+            return ("A2_IsHomogeneous", x, w)
+        # A1 monotone (leave headroom so an up-bump stays in range)
+        if not is_monotone(x * 0.9, w, tol=max(tol, 1e-7)):
+            return ("A1_IsMonotone", x * 0.9, w)
+    return None
+# ---- Canonical 13-axis Yuyay preset (ADVISORY ONLY) ------------------------ #
+# SZL's own yuyay_v3 "Heart" gate is a 13-axis CONJUNCTIVE-AND screen (each axis
+# independently clears its floor — no compensation). We expose its published
+# axis NAMES and per-axis FLOORS as advisory metadata, and a uniform Λ weight
+# vector over the 13 axes. This is ADVISORY: Λ here is still the weighted
+# geometric mean, and a "pass" is a research-conjecture signal, NOT proven
+# trust. Source: yuyay_v3 spec (Lutar, 2026).
+YUYAY_AXES = (
+    "moralGrounding",
+    "measurabilityHonesty",
+    "empiricalGrounding",
+    "logicalConsistency",
+    "sourceTransparency",
+    "reproducibility",
+    "licenseHygiene",
+    "scopeDiscipline",
+    "claimCalibration",
+    "evalAwareness",
+    "deceptionKeywords",
+    "conflictingDirectives",
+    "reversalDirective",
+)
+# Published per-axis advisory floors for the CONJUNCTIVE screen: two "sacred"
+# axes at 0.95, seven "structural" at 0.90, four "introspection" at 0.90.
+YUYAY_FLOORS = (
+    0.95, 0.95,                          # sacred
+    0.90, 0.90, 0.90, 0.90, 0.90, 0.90, 0.90,  # structural (7)
+    0.90, 0.90, 0.90, 0.90,              # introspection (4)
+)
+def yuyay_weights(
+    dtype: torch.dtype = torch.float64,
+    device: Optional[torch.device] = None,
+) -> torch.Tensor:
+    """Canonical 13-axis Yuyay Λ weight vector (uniform 1/13), ADVISORY only.
+    Returns a length-13 weight tensor for use as the ``weights`` argument to
+    :func:`lambda_aggregate` / :func:`lambda_gate` over the 13 :data:`YUYAY_AXES`.
+    Uniform by default (the Egyptian-exact diagonal). The published yuyay_v3
+    gate is a conjunctive AND with per-axis floors (:data:`YUYAY_FLOORS`); the
+    Λ roll-up here is the weighted geometric mean and is ADVISORY — NOT proven
+    trust (Λ-uniqueness is Conjecture 1, open).
+    """
+    k = len(YUYAY_AXES)
+    return torch.full((k,), 1.0 / k, dtype=dtype, device=device)
+# ---- Kernel self-check surface --------------------------------------------- #
+def selfcheck(
+    k: int = 5,
+    trials: int = 64,
+    seed: Optional[int] = 0,
+) -> dict:
+    """Run the A1–A4 empirical self-checks and report a verdict + version.
+    Returns a dict:
+        version          — kernel version string
+        axioms           — {A1..A4: bool} empirical pass on sampled inputs
+        all_axioms_hold  — bool, every sampled axiom check passed
+        adversarial      — {trials, violation} from a random falsification search
+                           (violation is None when no violation was found)
+        advisory         — always True
+        lambda_status    — Conjecture 1 (open) honesty string
+    HONESTY: these are EMPIRICAL checks on sampled inputs, NOT a proof of
+    Λ-uniqueness (Conjecture 1, open). A clean run is evidence, not proof.
+    """
+    x = torch.rand(k, dtype=torch.float64) * 0.9  # headroom for the A1 up-bump
+    w = torch.rand(k, dtype=torch.float64) + 1e-3
+    axioms = {
+        "A1_IsMonotone": is_monotone(x, w),
+        "A2_IsHomogeneous": is_homogeneous(x, float(torch.rand(1).item()), weights=w),
+        "A3_IsEgyptianExact": is_egyptian_exact(float(torch.rand(1).item()), k=k, weights=w),
+        "A4_IsBounded": is_bounded_by_max(x, w),
+    }
+    violation = find_axiom_violation(k=k, trials=trials, seed=seed)
+    return {
+        "version": __version__,
+        "axioms": axioms,
+        "all_axioms_hold": all(axioms.values()) and violation is None,
+        "adversarial": {"trials": int(trials), "violation": violation},
+        "advisory": True,
+        "lambda_status": "Conjecture 1 (open) — uniqueness unproven; advisory only",
+    }
+# Kept in sync with the package __version__ (single source of truth lives in
+# __init__; duplicated here so _lambda is importable/selfcheck-able standalone).
+__version__ = "0.2.0"
+# Namedtuple result type for the gate. Defined after functions so docstrings
+# above can reference it; imported by __init__ and layers.
+from collections import namedtuple  # noqa: E402
+LambdaGateResult = namedtuple(
+    "LambdaGateResult", ["score", "passed", "threshold", "advisory"]
+)

build/torch-universal/szl_lambda_gate/_ops.py ADDED Viewed

	@@ -0,0 +1,10 @@

+# SPDX-License-Identifier: Apache-2.0
+# Auto-style ops namespace shim for the universal kernel. Unique suffix lets
+# multiple versions load in the same process (Kernel Hub requirement).
+import torch
+ops = torch.ops._szl_lambda_gate_20260623081355
+def add_op_namespace_prefix(op_name: str) -> str:
+    return f"_szl_lambda_gate_20260623081355::{op_name}"

build/torch-universal/szl_lambda_gate/_v1.py ADDED Viewed

	@@ -0,0 +1,221 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""szl.lambda/v1 strict kernel entry: Λ and its gate on tensors, with no clamping or defaults.
+This is the torch port of ``reference/szl_lambda_v1.py`` and follows
+``spec/szl.lambda.v1.json``. An input outside the contract makes ``lambda_v1``
+raise ``LambdaV1Error(code)`` and makes ``lambda_v1_gate`` return verdict BLOCK
+with that code. Nothing is clamped, renormalised, defaulted or rounded before
+the compare::
+    lambda_v1(axes, weights)            -> 0-d float64 tensor, Λ in [0, 1]
+    lambda_v1_gate(axes, weights, tau)  -> LambdaV1GateResult(verdict, code, score, tau, advisory)
+The legacy ``lambda_aggregate`` / ``lambda_gate`` are unchanged. They clamp
+x > 1 to 1, route NaN and ±Inf to 0 and renormalise weights, and
+``lambda_gate`` falls back to a threshold of 0.5, which is now deprecated.
+Use this module when a verdict must follow szl.lambda/v1.
+Inputs
+    ``axes`` and ``weights`` are 1-D tensors of a real dtype (floating or
+    integer). bool and complex are not numbers. A Python list, None, or a 0-d
+    or 2-D tensor is LAMBDA_TYPE_INVALID; build the tensor with
+    ``torch.tensor(values, dtype=torch.float64)``. ``weights`` is moved to the
+    device of ``axes``. Inputs are read and never modified.
+    ``tau`` is a Python int or float (not bool), finite, with 0 < tau <= 1. It
+    is required and has no default. The policy value is ``policy_tau`` in
+    frontier/model_admit_contract.v1.json.
+Checks run in phases, in the reference's order, so the reported code does not
+depend on axis order::
+    LAMBDA_TYPE_INVALID (container) > LAMBDA_EMPTY > LAMBDA_LENGTH_MISMATCH
+    > LAMBDA_TYPE_INVALID (dtype) > LAMBDA_NONFINITE_AXIS
+    > LAMBDA_AXIS_OUT_OF_RANGE > LAMBDA_NONFINITE_WEIGHT
+    > LAMBDA_WEIGHT_NONPOSITIVE > LAMBDA_WEIGHT_SUM
+The gate checks tau first (LAMBDA_TAU_INVALID). The element checks and the
+weight sum (``math.fsum``) run on the float64 values exactly as the reference
+runs them, so every error code agrees with the reference.
+How the numbers are computed
+    * Λ, which is ``lambda_v1`` and the gate's ``score``, comes from
+      ``_lambda.lambda_aggregate`` in float64, so it stays a differentiable
+      tensor. On validated input that function's clamp and NaN routing change
+      nothing, and a zero axis gives exactly 0. Its renormalisation divides by
+      a sum within 1e-12 of 1, which moves Λ by at most Λ·|log Λ|·1e-12
+      (<= 3.7e-13) plus float64 rounding. The vectors' value_tol is 1e-12.
+    * The verdict comes from log Λ = fsum(w_k · log x_k) over the same float64
+      values, as in the reference, so it never depends on how Λ rounds (a
+      subnormal Λ has little relative precision). A zero axis gives
+      log Λ = -inf and the verdict NO_GO / ZERO_VETO, a veto rather than an
+      error. |log Λ - log tau| <= TIE_EPS gives ABSTAIN / NUMERIC_TIE. Above
+      the band the verdict is GO, and below it NO_GO / BELOW_TAU.
+The checks depend on the data and the verdict is a Python string, so this
+entry is not meant to run inside ``torch.compile``. The legacy compiled weight
+path in ``_lambda._resolve_weights``, which clamps weights to ``finfo.tiny``,
+is outside szl.lambda/v1.
+Λ is advisory. Λ uniqueness is Conjecture 1 (open), and nothing here depends on it.
+"""
+from __future__ import annotations
+import math
+from collections import namedtuple
+from typing import Any, List, Optional, Tuple
+import torch
+from ._lambda import lambda_aggregate
+SCHEMA = "szl.lambda/v1"
+UNIQUENESS = "CONJECTURE_1_NOT_USED"
+WEIGHT_SUM_TOL = 1e-12
+TIE_EPS = 1e-9
+TYPE_INVALID = "LAMBDA_TYPE_INVALID"
+EMPTY = "LAMBDA_EMPTY"
+LENGTH_MISMATCH = "LAMBDA_LENGTH_MISMATCH"
+NONFINITE_AXIS = "LAMBDA_NONFINITE_AXIS"
+AXIS_OUT_OF_RANGE = "LAMBDA_AXIS_OUT_OF_RANGE"
+NONFINITE_WEIGHT = "LAMBDA_NONFINITE_WEIGHT"
+WEIGHT_NONPOSITIVE = "LAMBDA_WEIGHT_NONPOSITIVE"
+WEIGHT_SUM = "LAMBDA_WEIGHT_SUM"
+TAU_INVALID = "LAMBDA_TAU_INVALID"
+#: Every error code, in precedence order (tau is checked first by the gate).
+ERROR_CODES = (
+    TYPE_INVALID,
+    EMPTY,
+    LENGTH_MISMATCH,
+    NONFINITE_AXIS,
+    AXIS_OUT_OF_RANGE,
+    NONFINITE_WEIGHT,
+    WEIGHT_NONPOSITIVE,
+    WEIGHT_SUM,
+    TAU_INVALID,
+)
+GO = "GO"
+NO_GO = "NO_GO"
+ABSTAIN = "ABSTAIN"
+BLOCK = "BLOCK"
+VERDICTS = (GO, NO_GO, ABSTAIN, BLOCK)
+ZERO_VETO = "ZERO_VETO"
+BELOW_TAU = "BELOW_TAU"
+NUMERIC_TIE = "NUMERIC_TIE"
+_INTEGER_DTYPES = (torch.uint8, torch.int8, torch.int16, torch.int32, torch.int64)
+class LambdaV1Error(ValueError):
+    """An input outside the szl.lambda/v1 contract. ``code`` is one of ERROR_CODES."""
+    def __init__(self, code: str, detail: str = "") -> None:
+        self.code = code
+        self.detail = detail
+        super().__init__(f"{code}: {detail}" if detail else code)
+#: verdict in VERDICTS; code as in the spec's gate rules; score is Λ as a 0-d
+#: float64 tensor (None on BLOCK); tau is the validated float (None when tau
+#: itself is invalid); advisory is always True.
+LambdaV1GateResult = namedtuple(
+    "LambdaV1GateResult", ["verdict", "code", "score", "tau", "advisory"]
+)
+def _is_real(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+def _is_real_dtype(dtype: torch.dtype) -> bool:
+    return dtype.is_floating_point or dtype in _INTEGER_DTYPES
+def _validate(
+    axes: Any, weights: Any
+) -> Tuple[torch.Tensor, torch.Tensor, List[float], List[float]]:
+    """Float64 tensors and their values, or LambdaV1Error in the reference's phase order."""
+    for name, t in (("axes", axes), ("weights", weights)):
+        if not isinstance(t, torch.Tensor):
+            raise LambdaV1Error(TYPE_INVALID, f"{name} must be a 1-D torch.Tensor, got {type(t).__name__}")
+        if t.dim() != 1:
+            raise LambdaV1Error(TYPE_INVALID, f"{name} must be a 1-D tensor, got {t.dim()}-D")
+    k, m = axes.shape[0], weights.shape[0]
+    if k == 0 or m == 0:
+        raise LambdaV1Error(EMPTY, f"len(axes)={k}, len(weights)={m}")
+    if k != m:
+        raise LambdaV1Error(LENGTH_MISMATCH, f"len(axes)={k} != len(weights)={m}")
+    for name, t in (("axes", axes), ("weights", weights)):
+        if not _is_real_dtype(t.dtype):
+            raise LambdaV1Error(TYPE_INVALID, f"{name} has dtype {t.dtype}, not a real number type")
+    x = axes.to(torch.float64)
+    w = weights.to(device=x.device, dtype=torch.float64)
+    xs, ws = x.tolist(), w.tolist()
+    for i, v in enumerate(xs):
+        if not math.isfinite(v):
+            raise LambdaV1Error(NONFINITE_AXIS, f"axes[{i}]={v!r}")
+    for i, v in enumerate(xs):
+        if not 0.0 <= v <= 1.0:
+            raise LambdaV1Error(AXIS_OUT_OF_RANGE, f"axes[{i}]={v!r} is outside [0, 1]")
+    for i, v in enumerate(ws):
+        if not math.isfinite(v):
+            raise LambdaV1Error(NONFINITE_WEIGHT, f"weights[{i}]={v!r}")
+    for i, v in enumerate(ws):
+        if not v > 0.0:
+            raise LambdaV1Error(WEIGHT_NONPOSITIVE, f"weights[{i}]={v!r} is not > 0")
+    try:
+        total = math.fsum(ws)
+    except OverflowError:
+        raise LambdaV1Error(WEIGHT_SUM, "sum of weights overflows a float") from None
+    if not abs(total - 1.0) <= WEIGHT_SUM_TOL:
+        raise LambdaV1Error(WEIGHT_SUM, f"fsum(weights)={total!r} is not within {WEIGHT_SUM_TOL} of 1")
+    return x, w, xs, ws
+def lambda_v1(axes: torch.Tensor, weights: torch.Tensor) -> torch.Tensor:
+    """Λ_w(axes) as a 0-d float64 tensor in [0, 1]; exactly 0 iff some axis is 0.
+    Raises ``LambdaV1Error(code)`` for any input outside szl.lambda/v1.
+    Differentiable with respect to ``axes``.
+    """
+    x, w, _, _ = _validate(axes, weights)
+    return lambda_aggregate(x, w)
+def _check_tau(tau: Any) -> float:
+    if not _is_real(tau):
+        raise LambdaV1Error(TAU_INVALID, f"tau is {type(tau).__name__}, not a real number")
+    if isinstance(tau, float) and not math.isfinite(tau):
+        raise LambdaV1Error(TAU_INVALID, f"tau={tau!r} is not finite")
+    if not 0 < tau <= 1:
+        raise LambdaV1Error(TAU_INVALID, f"tau={tau!r} is outside (0, 1]")
+    return float(tau)
+def lambda_v1_gate(axes: torch.Tensor, weights: torch.Tensor, tau: float) -> LambdaV1GateResult:
+    """The szl.lambda/v1 gate. It never raises on bad input; it returns BLOCK with the code.
+    tau is required. The compare is in log space on the unrounded value, and a
+    tie within TIE_EPS is ABSTAIN. A verdict is ADVISORY.
+    """
+    t: Optional[float] = None
+    try:
+        t = _check_tau(tau)
+        x, w, xs, ws = _validate(axes, weights)
+    except LambdaV1Error as err:
+        return LambdaV1GateResult(BLOCK, err.code, None, t, True)
+    score = lambda_aggregate(x, w)
+    if any(v == 0.0 for v in xs):
+        return LambdaV1GateResult(NO_GO, ZERO_VETO, score, t, True)
+    log_lam = math.fsum(wk * math.log(xk) for xk, wk in zip(xs, ws))
+    delta = log_lam - math.log(t)
+    if abs(delta) <= TIE_EPS:
+        return LambdaV1GateResult(ABSTAIN, NUMERIC_TIE, score, t, True)
+    if delta > 0:
+        return LambdaV1GateResult(GO, None, score, t, True)
+    return LambdaV1GateResult(NO_GO, BELOW_TAU, score, t, True)

build/torch-universal/szl_lambda_gate/governed_norm/__init__.py ADDED Viewed

	@@ -0,0 +1,279 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""szl_lambda_gate.governed_norm — governed normalization kernels (folded in).
+CONSOLIDATION (Wave D): this subpackage is the ``szl-governed-norm`` universal
+kernel folded into the canonical ``szl-lambda-gate`` kernels package so the two
+duplicate micro-repos become ONE canonical home. The source repo
+``szl-holdings/szl-governed-norm`` is DEPRECATED (see its DEPRECATED.md) and
+points here; nothing was deleted — this is the additive, reversible copy.
+It provides correctness-verified RMSNorm and LayerNorm that run on CPU and CUDA
+and are torch.compile-friendly, plus an optional *governed* path that emits
+content-addressed, SHA3-256 hash-chained receipts of each call — provenance at
+the kernel layer, in the spirit of the a11oy governed-AI platform
+(https://a-11-oy.com).
+Usage (as a subpackage of the canonical kernel)::
+    import torch
+    from szl_lambda_gate import governed_norm as gn
+    print(gn.selfcheck())                 # one-shot correctness + receipt check
+    x = torch.randn(4, 1024, dtype=torch.float16)
+    y = gn.rms_norm(x, eps=1e-6)          # plain path
+    y2 = gn.rms_norm(x, eps=1e-6, governed=True)   # records to the default chain
+    chain = gn.ReceiptChain()
+    y3 = gn.rms_norm(x, eps=1e-6, chain=chain)     # records into YOUR chain only
+    print(chain.verify())                 # (ok, depth, first_break_seq)
+Honesty: this is a universal (pure-Python) kernel — a correctness reference,
+not a hand-tuned CUDA speed record. No fabricated benchmarks. Its
+differentiator is verifiable governance, not raw FLOPs. Λ = Conjecture 1
+(advisory, uniqueness OPEN) — never described as proven trust anywhere.
+Note on torch.compile: every op is torch.compile(fullgraph=True)-compatible.
+Receipt emission is an eager-only side effect (it hashes materialized tensor
+bytes), so when a *governed* call is captured into a compiled graph the
+numerics are unchanged but NO receipt is recorded — govern at the eager audit
+boundary. This is documented honestly and covered by tests.
+"""
+from typing import Any, Dict, List, Optional, Tuple
+import torch
+from . import layers  # noqa: F401  (must be importable for Hub layer mapping)
+from ._norm import fused_add_rms_norm as _fused_add_rms_norm
+from ._norm import layer_norm as _layer_norm
+from ._norm import rms_norm as _rms_norm
+from ._receipt import _GENESIS as _GENESIS_HEAD
+from ._receipt import ReceiptChain, default_chain, emit_receipt
+__all__ = [
+    "rms_norm",
+    "layer_norm",
+    "fused_add_rms_norm",
+    "layers",
+    "ReceiptChain",
+    "emit_receipt",
+    "receipt_head",
+    "receipt_count",
+    "receipt_tail",
+    "receipt_verify",
+    "selfcheck",
+    "DOCTRINE_FOOTER",
+    "__version__",
+]
+__version__ = "0.2.0"
+DOCTRINE_FOOTER = (
+    "SZL Holdings · governed normalization · provenance at the kernel layer · "
+    "Lambda = Conjecture 1 (advisory) · honesty over checklist"
+)
+def _is_tracing() -> bool:
+    """True while torch.compile / Dynamo is tracing this code.
+    Receipt emission reads materialized tensor bytes (hashing on CPU), which is
+    an inherently eager, side-effecting host operation that cannot live inside
+    a traced FX graph — so under torch.compile we skip the emit. This keeps
+    EVERY op torch.compile(fullgraph=True)-compatible while remaining honest:
+    when a governed call is captured into a compiled graph, NO receipt is
+    recorded (the numerics are unchanged and identical to the eager path).
+    Governance is intended for the eager audit boundary; record receipts there.
+    """
+    is_compiling = getattr(torch.compiler, "is_compiling", None)
+    return bool(is_compiling()) if is_compiling is not None else False
+def _emit(
+    chain: Optional[ReceiptChain],
+    op: str,
+    x: torch.Tensor,
+    out: torch.Tensor,
+    eps: float,
+    sign_key: Optional[Any] = None,
+    organ: str = "szl-governed-norm",
+) -> None:
+    """Append a receipt to ``chain`` (or the process default chain if None).
+    No-op while torch.compile is tracing (see ``_is_tracing``). When
+    ``sign_key`` (a PEM ECDSA-P256 private key) is supplied and szl-receipt is
+    installed, the receipt carries an additive DSSE ``signature`` envelope;
+    keyless is UNSIGNED-honest.
+    """
+    if _is_tracing():
+        return
+    target = chain if chain is not None else default_chain()
+    target.emit(op, x, out, eps, sign_key=sign_key, organ=organ)
+def rms_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 1e-6,
+    governed: bool = False,
+    chain: Optional[ReceiptChain] = None,
+    sign_key: Optional[Any] = None,
+    organ: str = "szl-governed-norm",
+) -> torch.Tensor:
+    """RMSNorm over the last dim.
+    If ``governed=True``, append an audit receipt. By default the receipt goes
+    to the process-wide default chain (convenient). Pass your own ``chain`` (a
+    ``ReceiptChain`` instance) to record into a caller-owned chain instead —
+    this avoids global-state contention when many threads/requests govern
+    independently. Passing ``chain`` implies governance even if
+    ``governed=False`` is left at its default. Pass ``sign_key`` (PEM
+    ECDSA-P256) to additively sign the receipt via szl-receipt.
+    """
+    out = _rms_norm(x, weight=weight, eps=eps)
+    if governed or chain is not None:
+        _emit(chain, "rms_norm", x, out, eps, sign_key=sign_key, organ=organ)
+    return out
+def layer_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    bias: Optional[torch.Tensor] = None,
+    eps: float = 1e-5,
+    governed: bool = False,
+    chain: Optional[ReceiptChain] = None,
+    sign_key: Optional[Any] = None,
+    organ: str = "szl-governed-norm",
+) -> torch.Tensor:
+    """LayerNorm over the last dim.
+    If ``governed=True`` (or a ``chain`` is supplied), append an audit receipt
+    to ``chain`` when given, otherwise to the process default chain. See
+    ``rms_norm`` for the per-call ``chain`` rationale and ``sign_key``.
+    """
+    out = _layer_norm(x, weight=weight, bias=bias, eps=eps)
+    if governed or chain is not None:
+        _emit(chain, "layer_norm", x, out, eps, sign_key=sign_key, organ=organ)
+    return out
+def fused_add_rms_norm(
+    x: torch.Tensor,
+    residual: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 1e-6,
+    governed: bool = False,
+    chain: Optional[ReceiptChain] = None,
+    sign_key: Optional[Any] = None,
+    organ: str = "szl-governed-norm",
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Residual-add + RMSNorm (transformer block pattern).
+    Returns ``(y, new_residual)`` where ``new_residual = x + residual`` and
+    ``y = rms_norm(new_residual, weight, eps)``. If ``governed=True`` (or a
+    ``chain`` is supplied), append an audit receipt over the normalized output
+    to ``chain`` when given, otherwise to the process default chain. Pass
+    ``sign_key`` to additively sign the receipt via szl-receipt.
+    """
+    out, new_residual = _fused_add_rms_norm(x, residual, weight=weight, eps=eps)
+    if governed or chain is not None:
+        _emit(chain, "fused_add_rms_norm", x, out, eps, sign_key=sign_key, organ=organ)
+    return out, new_residual
+# ---- governance receipt surface (operates on the default in-process chain) --
+def receipt_head() -> str:
+    """SHA3-256 head of the governed-call receipt chain ('0'*64 if empty)."""
+    return default_chain().head()
+def receipt_count() -> int:
+    """Number of governed calls recorded."""
+    return default_chain().count()
+def receipt_tail(n: int = 10) -> List[Dict[str, Any]]:
+    """Last n receipts."""
+    return default_chain().tail(n)
+def receipt_verify() -> Dict[str, Any]:
+    """Re-walk the receipt chain. Returns {ok, depth, first_break_seq}."""
+    ok, depth, brk = default_chain().verify()
+    return {"ok": ok, "depth": depth, "first_break_seq": brk, "head": default_chain().head()}
+# ---- one-shot self-verification --------------------------------------------
+def selfcheck() -> Dict[str, Any]:
+    """Verify correctness + governance in a single call; never raises.
+    Runs a tiny, self-contained, CPU-only smoke test against PyTorch references
+    so downstream code (and SZL's own a11oy / hatun-mcp) can confirm the loaded
+    kernel is the real, working article before trusting it.
+    Checks (all on a *private, throwaway* ReceiptChain so the process default
+    chain is never touched):
+      * ``rms_norm`` matches a Llama-style float32 reference,
+      * ``layer_norm`` matches ``torch.nn.functional.layer_norm``,
+      * ``fused_add_rms_norm`` matches the unfused add-then-norm path,
+      * a governed call emits exactly one receipt and the chain verifies.
+    Returns a JSON-able dict:
+      ``{ok, version, checks: {name: bool}, receipt_ok, receipt_head, error}``
+    ``ok`` is True iff every check passed. On unexpected failure ``ok`` is
+    False and ``error`` carries the message — this function is designed to be
+    safe to call in a health probe and will not raise.
+    """
+    checks: Dict[str, bool] = {}
+    receipt_ok = False
+    receipt_head = _GENESIS_HEAD
+    error = None
+    try:
+        torch.manual_seed(0)
+        x = torch.randn(4, 64, dtype=torch.float32)
+        w = torch.randn(64, dtype=torch.float32)
+        b = torch.randn(64, dtype=torch.float32)
+        res = torch.randn(4, 64, dtype=torch.float32)
+        eps_r, eps_l = 1e-6, 1e-5
+        # rms_norm vs Llama-style fp32 reference
+        xf = x.to(torch.float32)
+        ref_rms = (xf * torch.rsqrt(xf.pow(2).mean(-1, keepdim=True) + eps_r)) * w
+        checks["rms_norm"] = bool(
+            torch.allclose(rms_norm(x, weight=w, eps=eps_r), ref_rms, rtol=1e-5, atol=1e-5)
+        )
+        # layer_norm vs torch reference
+        ref_ln = torch.nn.functional.layer_norm(x, (64,), weight=w, bias=b, eps=eps_l)
+        checks["layer_norm"] = bool(
+            torch.allclose(layer_norm(x, weight=w, bias=b, eps=eps_l), ref_ln,
+                           rtol=1e-5, atol=1e-5)
+        )
+        # fused_add_rms_norm vs unfused path
+        y_f, new_res = fused_add_rms_norm(x, res, weight=w, eps=eps_r)
+        h = x.to(torch.float32) + res.to(torch.float32)
+        ref_y = rms_norm(h.to(x.dtype), weight=w, eps=eps_r)
+        checks["fused_add_rms_norm"] = bool(
+            torch.allclose(y_f, ref_y, rtol=1e-5, atol=1e-5)
+            and torch.allclose(new_res, h.to(x.dtype), rtol=1e-6, atol=1e-6)
+        )
+        # governance on a private chain: one emit, chain verifies
+        probe_chain = ReceiptChain()
+        rms_norm(x, weight=w, eps=eps_r, chain=probe_chain)
+        ok, depth, brk = probe_chain.verify()
+        receipt_ok = bool(ok and depth == 1 and brk == -1)
+        receipt_head = probe_chain.head()
+        checks["governance"] = receipt_ok
+    except Exception as exc:  # never raise from a health probe
+        error = f"{type(exc).__name__}: {exc}"
+    ok = bool(checks) and all(checks.values()) and error is None
+    return {
+        "ok": ok,
+        "version": __version__,
+        "checks": checks,
+        "receipt_ok": receipt_ok,
+        "receipt_head": receipt_head,
+        "error": error,
+    }

build/torch-universal/szl_lambda_gate/governed_norm/_norm.py ADDED Viewed

	@@ -0,0 +1,246 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Pure-PyTorch normalization primitives for the SZL governed-norm kernel.
+These are correctness-verified reference implementations (RMSNorm, LayerNorm,
+and the residual-fused RMSNorm pattern used by transformer blocks) written in
+pure PyTorch. They run on CPU and CUDA, are torch.compile-friendly, and depend
+ONLY on torch + the Python standard library (a Kernel Hub requirement for
+universal kernels).
+HONESTY: this is a *universal* (pure-Python) kernel. It does NOT ship a
+hand-tuned CUDA/Triton binary, so it is a correctness reference, not a
+speed record. We make no fabricated benchmark claims. Where it adds value
+is the optional *governed* path (see _receipt.py): every normalization call
+can emit a content-addressed, hash-chained receipt of its inputs/outputs so
+the operation is auditable — SZL Holdings' provenance doctrine applied at
+the kernel layer.
+Numerical convention (all ops): reductions and the normalization math are
+computed in float32 for stability, then the result is cast back to the input
+dtype. This is the standard Llama-style convention and is what makes
+float16 / bfloat16 inputs numerically well-behaved.
+Validation convention: guards below are cheap, branch-only checks on metadata
+(dtype / ndim / shape / device) — they allocate nothing on the happy path and
+constant-fold away under torch.compile, so they do not perturb traced graphs.
+They exist to turn silent broadcasting / device-mismatch bugs into clear,
+early errors. A zero-size normalized last dimension is rejected (normalizing
+over zero elements is undefined); a single-element last dimension is allowed
+(RMSNorm yields sign(x); LayerNorm yields 0, matching F.layer_norm).
+Non-finite convention (NaN / Inf inputs): these ops do NOT sanitize their
+input. A NaN or Inf in the input propagates through the reduction and appears
+in the output, exactly as it would in torch.nn.functional.layer_norm / a
+hand-written kernel. We deliberately do NOT silently replace non-finite values
+(that would hide upstream numerical bugs); detecting/handling them is the
+caller's responsibility. This propagation behavior is covered by regression
+tests so it cannot change unnoticed.
+"""
+from typing import Optional
+import torch
+# Floating dtypes this kernel supports. Integer / complex inputs are rejected
+# early with a clear message rather than silently producing garbage.
+_SUPPORTED_DTYPES = (torch.float16, torch.bfloat16, torch.float32, torch.float64)
+def _compute_dtype(in_dtype: torch.dtype) -> torch.dtype:
+    """Reduction/normalization compute dtype.
+    Low-precision inputs (fp16/bf16) are upcast to float32 for stability — the
+    standard Llama-style convention. float64 inputs are NOT downcast: doing so
+    would silently lose precision (and break gradcheck), so we keep float64.
+    """
+    return torch.float32 if in_dtype in (torch.float16, torch.bfloat16) else in_dtype
+def _check_input(x: torch.Tensor, name: str = "x") -> None:
+    """Cheap, allocation-free guards on the primary input tensor.
+    Only inspects metadata (type / dtype / ndim), so it is constant-folded by
+    torch.compile and adds no runtime tensor work on the happy path.
+    """
+    if not isinstance(x, torch.Tensor):
+        raise TypeError(f"{name} must be a torch.Tensor, got {type(x).__name__}")
+    if x.dtype not in _SUPPORTED_DTYPES:
+        raise TypeError(
+            f"{name} has unsupported dtype {x.dtype}; "
+            f"expected one of {tuple(str(d) for d in _SUPPORTED_DTYPES)}"
+        )
+    if x.dim() < 1:
+        raise ValueError(
+            f"{name} must have at least 1 dimension (the normalized dim); "
+            f"got a {x.dim()}-d tensor"
+        )
+    # A zero-size normalized (last) dimension is mathematically undefined:
+    # mean/RMS over zero elements is NaN, so normalization has no meaning.
+    # Reject it early with a clear message instead of silently returning an
+    # empty/NaN tensor (the classic shape-bug-masquerading-as-success case).
+    if x.shape[-1] == 0:
+        raise ValueError(
+            f"{name} has a zero-size normalized last dimension {tuple(x.shape)}; "
+            f"normalization over zero elements is undefined"
+        )
+def _check_affine(
+    x: torch.Tensor,
+    param: Optional[torch.Tensor],
+    name: str,
+) -> None:
+    """Validate an optional affine parameter (weight/bias/residual peer).
+    Enforces that the parameter is 1-D and matches the normalized (last)
+    dimension, and lives on the same device as ``x``. This catches the
+    classic silent-broadcast bug where a mis-shaped weight would broadcast
+    instead of erroring. Metadata-only: no allocations.
+    """
+    if param is None:
+        return
+    if not isinstance(param, torch.Tensor):
+        raise TypeError(f"{name} must be a torch.Tensor or None, got {type(param).__name__}")
+    if param.device != x.device:
+        raise ValueError(
+            f"{name} is on device {param.device} but x is on {x.device}; "
+            f"move them to the same device"
+        )
+    last = x.shape[-1]
+    if param.dim() != 1 or param.shape[0] != last:
+        raise ValueError(
+            f"{name} must be 1-D with shape ({last},) to match the normalized "
+            f"last dimension of x; got shape {tuple(param.shape)}"
+        )
+def _check_eps(eps: float) -> None:
+    """eps must be a positive, finite scalar (rsqrt(var+eps) must be safe)."""
+    e = float(eps)
+    if not (e > 0.0) or e != e or e == float("inf"):
+        raise ValueError(f"eps must be a positive finite float, got {eps!r}")
+def rms_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 1e-6,
+) -> torch.Tensor:
+    """Root-mean-square layer normalization over the last dimension.
+    y = x / sqrt(mean(x^2, dim=-1) + eps) * weight
+    Computed in float32 for numerical stability, then cast back to the input
+    dtype (the standard, correctness-preserving convention used by Llama-style
+    RMSNorm). `weight` is optional; when omitted, no affine scale is applied.
+    Raises clear TypeError/ValueError on bad dtype, rank, eps, or a weight
+    whose shape/device does not match x's normalized dimension.
+    """
+    _check_input(x)
+    _check_eps(eps)
+    _check_affine(x, weight, "weight")
+    in_dtype = x.dtype
+    xf = x.to(_compute_dtype(in_dtype))
+    variance = xf.pow(2).mean(dim=-1, keepdim=True)
+    xf = xf * torch.rsqrt(variance + eps)
+    out = xf.to(in_dtype)
+    if weight is not None:
+        out = out * weight
+    return out
+def layer_norm(
+    x: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    bias: Optional[torch.Tensor] = None,
+    eps: float = 1e-5,
+) -> torch.Tensor:
+    """Standard layer normalization over the last dimension.
+    Mean/variance computed in float32 for stability, then cast back. Matches
+    torch.nn.functional.layer_norm semantics for the normalized-shape = last
+    dim case; verified against it in the test suite.
+    Raises clear TypeError/ValueError on bad dtype, rank, eps, or a
+    weight/bias whose shape/device does not match x's normalized dimension.
+    """
+    _check_input(x)
+    _check_eps(eps)
+    _check_affine(x, weight, "weight")
+    _check_affine(x, bias, "bias")
+    in_dtype = x.dtype
+    xf = x.to(_compute_dtype(in_dtype))
+    mean = xf.mean(dim=-1, keepdim=True)
+    # Biased (population) variance = mean of squared deviations. We compute it
+    # directly rather than via Tensor.var(unbiased=False): torch's .var emits a
+    # "degrees of freedom <= 0" UserWarning when the normalized dim has a single
+    # element, even though unbiased=False is well-defined there (variance 0).
+    # Computing it ourselves matches F.layer_norm exactly and stays silent and
+    # torch.compile(fullgraph=True)-clean for the single-element edge case.
+    centered = xf - mean
+    var = centered.pow(2).mean(dim=-1, keepdim=True)
+    xf = centered * torch.rsqrt(var + eps)
+    out = xf.to(in_dtype)
+    if weight is not None:
+        out = out * weight
+    if bias is not None:
+        out = out + bias
+    return out
+def fused_add_rms_norm(
+    x: torch.Tensor,
+    residual: torch.Tensor,
+    weight: Optional[torch.Tensor] = None,
+    eps: float = 1e-6,
+):
+    """Residual-add followed by RMSNorm — the canonical transformer block pattern.
+        h = x + residual          # updated residual stream
+        y = rms_norm(h, weight, eps)
+        return y, h
+    This mirrors the `fused_add_rms_norm` used in real LLM inference stacks
+    (e.g. the pre-norm transformer block: the normalized output `y` feeds the
+    sublayer, while the un-normalized sum `h` is carried forward as the next
+    residual). We return BOTH so callers can thread the residual stream, which
+    is exactly why the fused form exists.
+    HONESTY: "fused" here means *logically* fused (one Python op, one float32
+    cast path, the add done in float32 alongside the norm) — it is a correct,
+    allocation-conscious pure-PyTorch reference, not a hand-written fused CUDA
+    kernel. No speed claims are made.
+    The add is performed in float32 so that, for float16/bfloat16 inputs, the
+    residual accumulation does not lose precision before normalization — this
+    matches high-quality reference implementations.
+    """
+    _check_input(x, "x")
+    _check_input(residual, "residual")
+    _check_eps(eps)
+    if residual.shape != x.shape:
+        raise ValueError(
+            f"residual shape {tuple(residual.shape)} must equal x shape "
+            f"{tuple(x.shape)} for the residual add"
+        )
+    if residual.device != x.device:
+        raise ValueError(
+            f"residual is on device {residual.device} but x is on {x.device}; "
+            f"move them to the same device"
+        )
+    _check_affine(x, weight, "weight")
+    in_dtype = x.dtype
+    cdt = _compute_dtype(in_dtype)
+    # Add in compute dtype, keep both the normalized output and the residual.
+    hf = x.to(cdt) + residual.to(cdt)
+    new_residual = hf.to(in_dtype)
+    variance = hf.pow(2).mean(dim=-1, keepdim=True)
+    yf = hf * torch.rsqrt(variance + eps)
+    out = yf.to(in_dtype)
+    if weight is not None:
+        out = out * weight
+    return out, new_residual

build/torch-universal/szl_lambda_gate/governed_norm/_receipt.py ADDED Viewed

	@@ -0,0 +1,253 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Content-addressed governance receipts for normalization calls.
+SZL Holdings' provenance doctrine applied at the kernel layer: when a
+normalization runs in *governed* mode, it emits a small, deterministic
+receipt describing the call — input shape/dtype, eps, and a SHA3-256 digest
+of the (quantized) output tensor — and hash-chains it to the previous
+receipt. This makes a sequence of kernel calls independently auditable
+without trusting the caller.
+HONESTY:
+- The digest is a real SHA3-256 over the output bytes (rounded to a fixed
+  decimal precision so it is reproducible across runs/devices). It is an
+  integrity fingerprint, NOT a cryptographic signature — we never claim
+  it proves authorship. DSSE signing is a separate, out-of-band concern.
+- Receipts are kept in an in-process, append-only chain. Nothing is written
+  to disk or the network from inside the kernel.
+- Stdlib + torch (+ numpy for the output digest) only — Kernel Hub
+  universal-kernel requirement.
+- The canonical szl-receipt v0.2.0 evidence binding (``emit_receipt``) is
+  ADDITIVE and IMPORT-GUARDED: with szl-receipt absent it returns ``None`` and
+  the kernel runs unchanged. It binds subject / input-digest / output-digest /
+  policy-id / energy; energy is the literal string "UNAVAILABLE" because this
+  kernel measures NO joules — a value is never fabricated. Like the SHA3-256
+  chain, it is an EVIDENCE trail, NOT a proof of correctness.
+"""
+import hashlib
+import json
+import threading
+import time
+from typing import Any, Dict, List, Optional, Union
+import torch
+_GENESIS = "0" * 64
+# Logical signing-authority label stamped onto signature envelopes.
+_ORGAN = "szl-governed-norm"
+# Governing policy id bound into every canonical szl-receipt evidence binding.
+_POLICY_ID = "szl-governed-norm/provenance@v1"
+# This universal kernel measures NO joules. The honesty doctrine forbids
+# fabricating an energy value, so the canonical binding records the literal
+# string "UNAVAILABLE" rather than a placeholder number.
+_ENERGY_UNAVAILABLE = "UNAVAILABLE"
+def _maybe_sign(
+    body: Dict[str, Any],
+    sign_key: Optional[Union[str, bytes]],
+    organ: str,
+) -> Optional[Dict[str, Any]]:
+    """ADDITIVE szl-receipt signature layer over the receipt *body*.
+    Returns a DSSE envelope (from ``szl_receipt.sign_receipt``) covering the
+    exact canonical body, or ``None`` when szl-receipt is not installed (the
+    kernel then behaves exactly as before). Doctrine: with no *sign_key* the
+    envelope is UNSIGNED-honest (``signed=False``); a signature is NEVER
+    fabricated. This is distinct from and additive to the SHA3-256 chain
+    integrity hash (``digest``) — szl-receipt's envelope carries its own
+    SHA-256 ``digest``/``algo`` so the two integrity hashes are explicit.
+    """
+    try:
+        from szl_receipt import Receipt, sign_receipt
+    except Exception:  # noqa: BLE001 - signing is optional; absence is honest
+        return None
+    env = sign_receipt(Receipt(kind="governed-norm", body=body),
+                       sign_key, organ=organ)
+    return env
+def _tensor_digest(t: torch.Tensor, decimals: int = 6) -> str:
+    """Deterministic SHA3-256 over a tensor's rounded float32 contents.
+    Rounding to a fixed number of decimals makes the digest stable across
+    devices/dtypes for the same logical values (tiny FP noise won't change
+    it). This is an integrity fingerprint, not a signature.
+    """
+    flat = t.detach().to(torch.float32).reshape(-1)
+    # Round to `decimals` places, integerize, hash the raw bytes. CPU move is
+    # required to read bytes; kept O(n) and allocation-light.
+    scaled = torch.round(flat * (10 ** decimals)).to(torch.int64).cpu().numpy().tobytes()
+    h = hashlib.sha3_256()
+    h.update(scaled)
+    return h.hexdigest()
+def _input_digest(x: torch.Tensor, eps: float) -> str:
+    """SHA3-256 over the canonical JSON of a call's input spec.
+    Binds {input shape, dtype, eps} — the *shape* of the call, not the input
+    bytes — so the receipt is a compact fingerprint of what produced the
+    output. Deterministic and stdlib-only (json + hashlib).
+    """
+    spec = {
+        "in_shape": list(x.shape),
+        "in_dtype": str(x.dtype).replace("torch.", ""),
+        "eps": float(eps),
+    }
+    raw = json.dumps(spec, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha3_256(raw).hexdigest()
+def emit_receipt(
+    op: str,
+    x: torch.Tensor,
+    out: torch.Tensor,
+    eps: float,
+    subject: Optional[str] = None,
+    policy_id: str = _POLICY_ID,
+    sign_key: Optional[Union[str, bytes]] = None,
+    organ: str = _ORGAN,
+) -> Optional[Dict[str, Any]]:
+    """Canonical szl-receipt v0.2.0 evidence binding for a governed-norm call.
+    ADDITIVE and IMPORT-GUARDED: returns ``None`` when szl-receipt is not
+    installed, so this universal Kernel-Hub kernel still imports and runs on
+    stdlib + torch + numpy alone. When szl-receipt is present it binds an
+    EVIDENCE trail and wraps it in a DSSE envelope via ``sign_receipt``:
+        subject        organ / norm-call id (who/what emitted this)
+        input_digest   SHA3-256 over canonical {input shape, dtype, eps}
+        output_digest  the EXISTING SHA3-256 rounded-tensor digest of ``out``
+        policy_id      the governing policy id
+        energy         the literal string "UNAVAILABLE"
+    Doctrine (non-negotiable):
+      * A receipt is an integrity/EVIDENCE trail, NOT a proof of correctness.
+      * ``energy == "UNAVAILABLE"`` — this kernel measures NO joules; a joule is
+        NEVER fabricated.
+      * Keyless => UNSIGNED-honest (``signature["signed"] is False``); a
+        signature is NEVER fabricated. A real ``sign_key`` yields a real DSSE
+        signature over the exact canonical binding.
+    Returns the binding dict (subject/input_digest/output_digest/policy_id/
+    energy) with the DSSE envelope under ``signature``, or ``None`` when
+    szl-receipt is absent.
+    """
+    try:
+        from szl_receipt import Receipt, sign_receipt
+    except Exception:  # noqa: BLE001 - canonical binding is optional; absence is honest
+        return None
+    body = {
+        "subject": subject if subject is not None else f"{organ}/{op}",
+        "input_digest": _input_digest(x, eps),
+        "output_digest": _tensor_digest(out),
+        "policy_id": policy_id,
+        "energy": _ENERGY_UNAVAILABLE,
+    }
+    env = sign_receipt(Receipt(kind="governed-norm", body=body), sign_key, organ=organ)
+    return dict(body, signature=env)
+class ReceiptChain:
+    """Append-only, SHA3-256 hash-chained log of normalization receipts.
+    Each receipt: {seq, op, in_shape, in_dtype, eps, out_digest, prev, digest, ts}
+    digest = SHA3-256 over the canonical JSON body (excluding digest/ts).
+    verify() re-walks the chain and returns (ok, depth, first_break_seq).
+    """
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+        self._records: List[Dict[str, Any]] = []
+    @staticmethod
+    def _digest_body(body: Dict[str, Any]) -> str:
+        raw = json.dumps(body, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        return hashlib.sha3_256(raw).hexdigest()
+    def emit(
+        self,
+        op: str,
+        x: torch.Tensor,
+        out: torch.Tensor,
+        eps: float,
+        sign_key: Optional[Union[str, bytes]] = None,
+        organ: str = _ORGAN,
+        policy_id: str = _POLICY_ID,
+    ) -> Dict[str, Any]:
+        with self._lock:
+            prev = self._records[-1]["digest"] if self._records else _GENESIS
+            seq = len(self._records)
+            body = {
+                "seq": seq,
+                "op": op,
+                "in_shape": list(x.shape),
+                "in_dtype": str(x.dtype).replace("torch.", ""),
+                "eps": float(eps),
+                "out_digest": _tensor_digest(out),
+                "prev": prev,
+            }
+            digest = self._digest_body(body)
+            rec = dict(body, digest=digest, ts=time.time())
+            sig = _maybe_sign(body, sign_key, organ)
+            if sig is not None:
+                rec["signature"] = sig
+            # ADDITIVE canonical szl-receipt v0.2.0 evidence binding. Import-
+            # guarded: None when szl-receipt is absent, so the universal kernel
+            # keeps working on stdlib + torch + numpy only. Binds subject /
+            # input-digest / output-digest / policy-id / energy; energy is
+            # "UNAVAILABLE" (no joules measured here). It does NOT enter the
+            # SHA3-256 chain body, so verify() is unaffected.
+            binding = emit_receipt(
+                op, x, out, eps,
+                subject=f"{organ}/{op}#{seq}",
+                policy_id=policy_id,
+                sign_key=sign_key,
+                organ=organ,
+            )
+            if binding is not None:
+                rec["receipt"] = binding
+            self._records.append(rec)
+            return rec
+    def head(self) -> str:
+        with self._lock:
+            return self._records[-1]["digest"] if self._records else _GENESIS
+    def count(self) -> int:
+        with self._lock:
+            return len(self._records)
+    def tail(self, n: int = 10) -> List[Dict[str, Any]]:
+        with self._lock:
+            return list(self._records[-n:])
+    def verify(self):
+        """Re-walk the chain. Returns (ok: bool, depth: int, first_break: int)."""
+        with self._lock:
+            prev = _GENESIS
+            for i, rec in enumerate(self._records):
+                body = {k: rec[k] for k in
+                        ("seq", "op", "in_shape", "in_dtype", "eps", "out_digest", "prev")}
+                if rec["prev"] != prev or rec["digest"] != self._digest_body(body):
+                    return (False, len(self._records), i)
+                prev = rec["digest"]
+            return (True, len(self._records), -1)
+# Module-level default chain (opt-in: only written when governed=True is used).
+_DEFAULT_CHAIN: Optional[ReceiptChain] = None
+_chain_lock = threading.Lock()
+def default_chain() -> ReceiptChain:
+    global _DEFAULT_CHAIN
+    with _chain_lock:
+        if _DEFAULT_CHAIN is None:
+            _DEFAULT_CHAIN = ReceiptChain()
+        return _DEFAULT_CHAIN

build/torch-universal/szl_lambda_gate/governed_norm/layers.py ADDED Viewed

	@@ -0,0 +1,60 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Hub-compliant kernel layers.
+Per the Kernel Hub `kernel-requirements`, layers exposed for extension must
+be PURE torch.nn.Module subclasses:
+  - no custom __init__,
+  - no class variables,
+  - only a `forward` method,
+  - forward signature compatible with the module it extends.
+These layers therefore read their parameters (weight/bias/eps) off the
+module instance they are bound to (set by the host model), and only define
+`forward`. They are drop-in replacements for an existing RMSNorm/LayerNorm
+module via the `kernels` layer-mapping mechanism.
+"""
+import torch
+from torch import nn
+from ._norm import fused_add_rms_norm, layer_norm, rms_norm
+class RMSNorm(nn.Module):
+    """Pure RMSNorm layer. Expects the host module to provide `self.weight`
+    (optional) and `self.variance_epsilon` or `self.eps`."""
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        weight = getattr(self, "weight", None)
+        eps = getattr(self, "variance_epsilon", None)
+        if eps is None:
+            eps = getattr(self, "eps", 1e-6)
+        return rms_norm(hidden_states, weight=weight, eps=float(eps))
+class LayerNorm(nn.Module):
+    """Pure LayerNorm layer. Expects the host module to provide `self.weight`
+    (optional), `self.bias` (optional), and `self.eps`."""
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        weight = getattr(self, "weight", None)
+        bias = getattr(self, "bias", None)
+        eps = getattr(self, "eps", 1e-5)
+        return layer_norm(hidden_states, weight=weight, bias=bias, eps=float(eps))
+class FusedAddRMSNorm(nn.Module):
+    """Pure residual-add + RMSNorm layer for pre-norm transformer blocks.
+    Expects the host module to provide `self.weight` (optional) and
+    `self.variance_epsilon` or `self.eps`. Returns `(normalized, new_residual)`
+    where `new_residual = hidden_states + residual` is carried forward as the
+    next block's residual stream.
+    """
+    def forward(self, hidden_states: torch.Tensor, residual: torch.Tensor):
+        weight = getattr(self, "weight", None)
+        eps = getattr(self, "variance_epsilon", None)
+        if eps is None:
+            eps = getattr(self, "eps", 1e-6)
+        return fused_add_rms_norm(hidden_states, residual, weight=weight, eps=float(eps))

build/torch-universal/szl_lambda_gate/layers.py ADDED Viewed

	@@ -0,0 +1,54 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""Hub-compliant kernel layer for the szl-lambda-gate kernel.
+Per the Kernel Hub `kernel-requirements`, layers exposed for extension must be
+PURE torch.nn.Module subclasses:
+  - no custom __init__,
+  - no class variables,
+  - only a `forward` method.
+The layer therefore reads its parameters (weights / threshold) off the module
+instance it is bound to (set by the host model) and only defines `forward`.
+HONESTY: `LambdaGate` emits an ADVISORY governance signal (the weighted
+geometric mean Λ plus a pass/fail vs threshold). Λ is NOT proven trust; its
+uniqueness is Conjecture 1 (open).
+"""
+import torch
+from torch import nn
+from ._lambda import lambda_aggregate, lambda_gate
+class LambdaGate(nn.Module):
+    """Pure Λ-gate layer.
+    Reads optional ``self.weights`` (1-D, length k) and ``self.threshold``
+    (float) off the bound module instance. An unset threshold uses the legacy
+    0.5 with a DeprecationWarning (see ``lambda_gate``); set it explicitly.
+    forward(axes) -> LambdaGateResult(score, passed, threshold, advisory) where
+    ``score`` = Λ(axes) over the last dim and ``passed`` = score >= threshold.
+    Differentiable in ``score`` w.r.t. ``axes``.
+    """
+    def forward(self, axes: torch.Tensor):
+        weights = getattr(self, "weights", None)
+        threshold = getattr(self, "threshold", None)
+        if threshold is not None:
+            threshold = float(threshold)
+        return lambda_gate(axes, weights=weights, threshold=threshold)
+class LambdaAggregate(nn.Module):
+    """Pure Λ-aggregator layer: forward(axes) -> Λ(axes) tensor in [0,1].
+    Reads optional ``self.weights`` (1-D, length k) off the bound module
+    instance; uniform weights when absent. Returns just the score (no gate),
+    fully differentiable w.r.t. ``axes``.
+    """
+    def forward(self, axes: torch.Tensor) -> torch.Tensor:
+        weights = getattr(self, "weights", None)
+        return lambda_aggregate(axes, weights=weights)

distribution.json ADDED Viewed

	@@ -0,0 +1 @@

+ {"files":{"build.toml":"5c5ebbfe83770a898b8b8893e342c2c5547c65cd2b5a96146b14e3abb9411f3b","build/torch-cpu/__init__.py":"36e8a78e55913655a0834cb60fad4711a2ad5bf54e92d4473fcc36363de8a634","build/torch-cpu/metadata.json":"d15c8285af060f9c1e43ff269650508fe0f31a0297cfbd309aff552e9de8d3d4","build/torch-cpu/szl_lambda_gate/__init__.py":"4297e491a72e2941b15e2b6a0582ead273383670ac5fbb8d14e2c76dec9ed15d","build/torch-cpu/szl_lambda_gate/_lambda.py":"f953a38019c91a6fa8a9c411f55baa4f5f2b9e76d7153bba54bb8a5d9469af38","build/torch-cpu/szl_lambda_gate/_ops.py":"6adf1dc42e7a9e6da914e304da9720438e59c234104e11f3e5ccaa45ecee23b6","build/torch-cpu/szl_lambda_gate/_v1.py":"9ac2d8fe0a47ff191eba76e62b1e9dd9b2b54f64ba0c3d86306e0cdd58bc468c","build/torch-cpu/szl_lambda_gate/governed_norm/__init__.py":"50fe4fb09a165d0ae9a781f0ef3515388c752a14cde95f73687854f59a7dfadc","build/torch-cpu/szl_lambda_gate/governed_norm/_norm.py":"cf72ace281ec86c504426f75e23eebdb661a1e3a12e4dfcc6c8b9fa634b03942","build/torch-cpu/szl_lambda_gate/governed_norm/_receipt.py":"db1244bd184affdca929bd38ac728b2696f82ad565aaf82d14ca3845d4d748a9","build/torch-cpu/szl_lambda_gate/governed_norm/layers.py":"d79c83355cb2332b9d0e9d98584b86434e486532e27d30652df10158b30fc37b","build/torch-cpu/szl_lambda_gate/layers.py":"51da478e185ee4d16daa9971bdcbdcfcbb0c0c5b7837a002b97cd05cb968ea75","build/torch-universal/__init__.py":"36e8a78e55913655a0834cb60fad4711a2ad5bf54e92d4473fcc36363de8a634","build/torch-universal/metadata.json":"448ed5fb0c866455d045cdc7a75e1bbcaccc8d9f323039daf62cda1f5a35e0b4","build/torch-universal/szl_lambda_gate/__init__.py":"4297e491a72e2941b15e2b6a0582ead273383670ac5fbb8d14e2c76dec9ed15d","build/torch-universal/szl_lambda_gate/_lambda.py":"f953a38019c91a6fa8a9c411f55baa4f5f2b9e76d7153bba54bb8a5d9469af38","build/torch-universal/szl_lambda_gate/_ops.py":"6adf1dc42e7a9e6da914e304da9720438e59c234104e11f3e5ccaa45ecee23b6","build/torch-universal/szl_lambda_gate/_v1.py":"9ac2d8fe0a47ff191eba76e62b1e9dd9b2b54f64ba0c3d86306e0cdd58bc468c","build/torch-universal/szl_lambda_gate/governed_norm/__init__.py":"50fe4fb09a165d0ae9a781f0ef3515388c752a14cde95f73687854f59a7dfadc","build/torch-universal/szl_lambda_gate/governed_norm/_norm.py":"cf72ace281ec86c504426f75e23eebdb661a1e3a12e4dfcc6c8b9fa634b03942","build/torch-universal/szl_lambda_gate/governed_norm/_receipt.py":"db1244bd184affdca929bd38ac728b2696f82ad565aaf82d14ca3845d4d748a9","build/torch-universal/szl_lambda_gate/governed_norm/layers.py":"d79c83355cb2332b9d0e9d98584b86434e486532e27d30652df10158b30fc37b","build/torch-universal/szl_lambda_gate/layers.py":"51da478e185ee4d16daa9971bdcbdcfcbb0c0c5b7837a002b97cd05cb968ea75","reference/szl_lambda_v1.py":"57b264fa96056d1f2d77b797ba80eab087a729283f16416196fdd1423c9c532f","source/LICENSE":"bc8cef3450d423b046a3ba2b1a03089c8c795302f502cabbdbef055a68f0b1e7","spec/lambda_v1_vectors.json":"460bb966ff2bec4fd99e03d267b721f22c5fad731e0667723407a6909bd4dcec","spec/szl.lambda.v1.json":"04a8368568d59509c8603cdc45cf80f6b1395e751c77eabb1957bbe12906f2d9"},"packager":"scripts/build_lambda_distribution.py","schema":"szl.lambda/distribution.v1","source_commit":"7cb79cba7ecb5dbb9da59b2d6b516a98d2a114d6","source_files":{"LICENSE":"bc8cef3450d423b046a3ba2b1a03089c8c795302f502cabbdbef055a68f0b1e7","build.toml":"5c5ebbfe83770a898b8b8893e342c2c5547c65cd2b5a96146b14e3abb9411f3b","reference/szl_lambda_v1.py":"57b264fa96056d1f2d77b797ba80eab087a729283f16416196fdd1423c9c532f","spec/lambda_v1_vectors.json":"460bb966ff2bec4fd99e03d267b721f22c5fad731e0667723407a6909bd4dcec","spec/szl.lambda.v1.json":"04a8368568d59509c8603cdc45cf80f6b1395e751c77eabb1957bbe12906f2d9","torch-ext/szl_lambda_gate/__init__.py":"4297e491a72e2941b15e2b6a0582ead273383670ac5fbb8d14e2c76dec9ed15d","torch-ext/szl_lambda_gate/_lambda.py":"f953a38019c91a6fa8a9c411f55baa4f5f2b9e76d7153bba54bb8a5d9469af38","torch-ext/szl_lambda_gate/_ops.py":"6adf1dc42e7a9e6da914e304da9720438e59c234104e11f3e5ccaa45ecee23b6","torch-ext/szl_lambda_gate/_v1.py":"9ac2d8fe0a47ff191eba76e62b1e9dd9b2b54f64ba0c3d86306e0cdd58bc468c","torch-ext/szl_lambda_gate/governed_norm/__init__.py":"50fe4fb09a165d0ae9a781f0ef3515388c752a14cde95f73687854f59a7dfadc","torch-ext/szl_lambda_gate/governed_norm/_norm.py":"cf72ace281ec86c504426f75e23eebdb661a1e3a12e4dfcc6c8b9fa634b03942","torch-ext/szl_lambda_gate/governed_norm/_receipt.py":"db1244bd184affdca929bd38ac728b2696f82ad565aaf82d14ca3845d4d748a9","torch-ext/szl_lambda_gate/governed_norm/layers.py":"d79c83355cb2332b9d0e9d98584b86434e486532e27d30652df10158b30fc37b","torch-ext/szl_lambda_gate/layers.py":"51da478e185ee4d16daa9971bdcbdcfcbb0c0c5b7837a002b97cd05cb968ea75"},"source_repository":"https://github.com/szl-holdings/szl-lambda-gate","vectors_count":60,"vectors_sha256":"61bfb0410b9f0eaab0eb9f22f29cb7cb13cfde8c083fe308d895565d6ba9ebd4"}

reference/szl_lambda_v1.py ADDED Viewed

	@@ -0,0 +1,205 @@

+# SPDX-License-Identifier: Apache-2.0
+# © 2026 SZL Holdings · Stephen P. Lutar · ORCID 0009-0001-0110-4173
+"""szl.lambda/v1 stdlib reference: Λ and its gate, exactly as spec/szl.lambda.v1.json says.
+    Λ_w(x) = ∏_k x_k^{w_k} = exp(fsum_k(w_k · log x_k)),   Λ = 0 if some x_k == 0
+Contract (every violation raises ``LambdaV1Error(code)``; nothing is clamped,
+renormalised, defaulted or rounded):
+* ``axes`` and ``weights`` are lists or tuples of real numbers (``bool`` is not
+  a number), of equal, non-zero length.
+* every axis is finite and 0 <= x_k <= 1;
+* every weight is finite and w_k > 0, and |fsum(w) - 1| <= 1e-12.
+Checks run in phases, each over every element, so the code reported for an
+input with several faults does not depend on axis order::
+    LAMBDA_TYPE_INVALID (container) > LAMBDA_EMPTY > LAMBDA_LENGTH_MISMATCH
+    > LAMBDA_TYPE_INVALID (element) > LAMBDA_NONFINITE_AXIS
+    > LAMBDA_AXIS_OUT_OF_RANGE > LAMBDA_NONFINITE_WEIGHT
+    > LAMBDA_WEIGHT_NONPOSITIVE > LAMBDA_WEIGHT_SUM
+``gate_v1(axes, weights, tau)`` takes tau as a required argument (no implicit
+default; the policy value lives in frontier/model_admit_contract.v1.json) and
+returns ``(verdict, code)``:
+* BLOCK with the error code if tau is invalid (checked first: real, finite,
+  0 < tau <= 1) or Λ raises;
+* NO_GO / ZERO_VETO if some axis is 0 (log Λ = -inf; a veto, not an error);
+* ABSTAIN / NUMERIC_TIE if |log Λ - log tau| <= TIE_EPS (1e-9);
+* GO / None if log Λ > log tau, otherwise NO_GO / BELOW_TAU.
+The compare is in log space on the unrounded value. Λ is advisory. Λ
+uniqueness is Conjecture 1 (open) and nothing here depends on it.
+Stdlib only. Other implementations port this file; they must agree on every
+error code and verdict, and on values within each vector's ``value_tol``.
+"""
+from __future__ import annotations
+import hashlib
+import json
+import math
+import struct
+from typing import Any, Optional, Tuple
+SCHEMA = "szl.lambda/v1"
+WEIGHT_SUM_TOL = 1e-12
+TIE_EPS = 1e-9
+TYPE_INVALID = "LAMBDA_TYPE_INVALID"
+EMPTY = "LAMBDA_EMPTY"
+LENGTH_MISMATCH = "LAMBDA_LENGTH_MISMATCH"
+NONFINITE_AXIS = "LAMBDA_NONFINITE_AXIS"
+AXIS_OUT_OF_RANGE = "LAMBDA_AXIS_OUT_OF_RANGE"
+NONFINITE_WEIGHT = "LAMBDA_NONFINITE_WEIGHT"
+WEIGHT_NONPOSITIVE = "LAMBDA_WEIGHT_NONPOSITIVE"
+WEIGHT_SUM = "LAMBDA_WEIGHT_SUM"
+TAU_INVALID = "LAMBDA_TAU_INVALID"
+#: Every error code, in precedence order (tau is checked first by the gate).
+ERROR_CODES = (
+    TYPE_INVALID,
+    EMPTY,
+    LENGTH_MISMATCH,
+    NONFINITE_AXIS,
+    AXIS_OUT_OF_RANGE,
+    NONFINITE_WEIGHT,
+    WEIGHT_NONPOSITIVE,
+    WEIGHT_SUM,
+    TAU_INVALID,
+)
+GO = "GO"
+NO_GO = "NO_GO"
+ABSTAIN = "ABSTAIN"
+BLOCK = "BLOCK"
+VERDICTS = (GO, NO_GO, ABSTAIN, BLOCK)
+ZERO_VETO = "ZERO_VETO"
+BELOW_TAU = "BELOW_TAU"
+NUMERIC_TIE = "NUMERIC_TIE"
+class LambdaV1Error(ValueError):
+    """An input outside the szl.lambda/v1 contract. ``code`` is one of ERROR_CODES."""
+    def __init__(self, code: str, detail: str = "") -> None:
+        self.code = code
+        self.detail = detail
+        super().__init__(f"{code}: {detail}" if detail else code)
+def _is_real(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+def _is_nonfinite(value: Any) -> bool:
+    # ints are always finite; only floats can be NaN or ±Inf.
+    return isinstance(value, float) and not math.isfinite(value)
+def _validate(axes: Any, weights: Any) -> None:
+    for name, seq in (("axes", axes), ("weights", weights)):
+        if not isinstance(seq, (list, tuple)):
+            raise LambdaV1Error(TYPE_INVALID, f"{name} must be a list or tuple, got {type(seq).__name__}")
+    if len(axes) == 0 or len(weights) == 0:
+        raise LambdaV1Error(EMPTY, f"len(axes)={len(axes)}, len(weights)={len(weights)}")
+    if len(axes) != len(weights):
+        raise LambdaV1Error(LENGTH_MISMATCH, f"len(axes)={len(axes)} != len(weights)={len(weights)}")
+    for name, seq in (("axes", axes), ("weights", weights)):
+        for i, value in enumerate(seq):
+            if not _is_real(value):
+                raise LambdaV1Error(TYPE_INVALID, f"{name}[{i}] is {type(value).__name__}, not a real number")
+    for i, x in enumerate(axes):
+        if _is_nonfinite(x):
+            raise LambdaV1Error(NONFINITE_AXIS, f"axes[{i}]={x!r}")
+    for i, x in enumerate(axes):
+        if not 0 <= x <= 1:
+            raise LambdaV1Error(AXIS_OUT_OF_RANGE, f"axes[{i}]={x!r} is outside [0, 1]")
+    for i, w in enumerate(weights):
+        if _is_nonfinite(w):
+            raise LambdaV1Error(NONFINITE_WEIGHT, f"weights[{i}]={w!r}")
+    for i, w in enumerate(weights):
+        if not w > 0:
+            raise LambdaV1Error(WEIGHT_NONPOSITIVE, f"weights[{i}]={w!r} is not > 0")
+    try:
+        total = math.fsum(weights)
+    except OverflowError:
+        raise LambdaV1Error(WEIGHT_SUM, "sum of weights overflows a float") from None
+    if not abs(total - 1.0) <= WEIGHT_SUM_TOL:
+        raise LambdaV1Error(WEIGHT_SUM, f"fsum(weights)={total!r} is not within {WEIGHT_SUM_TOL} of 1")
+def log_lambda_v1(axes: Any, weights: Any) -> float:
+    """log Λ_w(x) = fsum(w_k · log x_k); -inf if some axis is 0. Raises LambdaV1Error."""
+    _validate(axes, weights)
+    if any(x == 0 for x in axes):
+        return -math.inf
+    return math.fsum(float(w) * math.log(float(x)) for x, w in zip(axes, weights))
+def lambda_v1(axes: Any, weights: Any) -> float:
+    """Λ_w(x) in [0, 1]; exactly 0.0 iff some axis is 0. Raises LambdaV1Error."""
+    log_lam = log_lambda_v1(axes, weights)
+    if log_lam == -math.inf:
+        return 0.0
+    return math.exp(log_lam)
+def _check_tau(tau: Any) -> float:
+    if not _is_real(tau):
+        raise LambdaV1Error(TAU_INVALID, f"tau is {type(tau).__name__}, not a real number")
+    if _is_nonfinite(tau):
+        raise LambdaV1Error(TAU_INVALID, f"tau={tau!r} is not finite")
+    if not 0 < tau <= 1:
+        raise LambdaV1Error(TAU_INVALID, f"tau={tau!r} is outside (0, 1]")
+    return float(tau)
+def gate_v1(axes: Any, weights: Any, tau: Any) -> Tuple[str, Optional[str]]:
+    """(verdict, code) for Λ_w(axes) against tau. Never raises on bad input: it BLOCKs."""
+    try:
+        t = _check_tau(tau)
+        log_lam = log_lambda_v1(axes, weights)
+    except LambdaV1Error as err:
+        return BLOCK, err.code
+    if log_lam == -math.inf:
+        return NO_GO, ZERO_VETO
+    delta = log_lam - math.log(t)
+    if abs(delta) <= TIE_EPS:
+        return ABSTAIN, NUMERIC_TIE
+    if delta > 0:
+        return GO, None
+    return NO_GO, BELOW_TAU
+# ------------------------------------------------ canonical numbers and bytes --
+def encode_f64(x: float) -> str:
+    """'f64:' + the 16 lowercase hex digits of the IEEE-754 binary64 bits (big-endian)."""
+    return "f64:" + struct.pack(">d", float(x)).hex()
+def decode_f64(text: str) -> float:
+    """Inverse of encode_f64. Rejects anything that is not exactly 'f64:' + 16 lowercase hex."""
+    if not isinstance(text, str) or len(text) != 20 or not text.startswith("f64:"):
+        raise ValueError(f"not an f64 literal: {text!r}")
+    digits = text[4:]
+    if any(c not in "0123456789abcdef" for c in digits):
+        raise ValueError(f"not an f64 literal: {text!r}")
+    return struct.unpack(">d", bytes.fromhex(digits))[0]
+def canonical_json_bytes(obj: Any) -> bytes:
+    """Canonical JSON: sorted keys, compact separators, UTF-8, no NaN/Infinity."""
+    return json.dumps(
+        obj, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False
+    ).encode("utf-8")
+def canonical_sha256(obj: Any) -> str:
+    """SHA-256 hex over canonical_json_bytes(obj): stable across CRLF/LF checkouts."""
+    return hashlib.sha256(canonical_json_bytes(obj)).hexdigest()

source/LICENSE ADDED Viewed

	@@ -0,0 +1,202 @@

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

spec/lambda_v1_vectors.json ADDED Viewed

	@@ -0,0 +1,730 @@

+{
+  "schema": "szl.lambda/v1.vectors",
+  "spec": "spec/szl.lambda.v1.json",
+  "float_encoding": "Every float is \"f64:<16 lowercase hex digits of the IEEE-754 binary64 bits, big-endian>\"; the *_decimal fields are Python repr() for humans. A JSON value that is not an f64 string (true, null, another string, an integer) is passed to the implementation unchanged.",
+  "expect": "value_f64 or error describes lambda_v1(axes, weights); verdict and code describe gate_v1(axes, weights, tau).",
+  "value_tol": "Absolute tolerance on Λ for implementations other than reference/szl_lambda_v1.py, which must match value_f64 bit for bit. Error codes and verdicts are always exact.",
+  "vectors": [
+    {
+      "id": "nominal",
+      "source": "szl-math-core.md §3 differential table (nominal)",
+      "axes": ["f64:3fee666666666666", "f64:3fed70a3d70a3d71", "f64:3fec28f5c28f5c29", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.95", "0.92", "0.88", "0.9"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fed3035e27f23fe", "value_decimal": "0.9121350692522581", "verdict": "GO", "code": null}
+    },
+    {
+      "id": "hidden_weak",
+      "source": "szl-math-core.md §3 differential table (hidden_weak); admit contract hidden_weak_lock gm 0.7653",
+      "note": "the arithmetic mean 0.8125 would pass tau 0.8; the geometric mean does not",
+      "axes": ["f64:3fee666666666666", "f64:3fee666666666666", "f64:3fee666666666666", "f64:3fd999999999999a"],
+      "axes_decimal": ["0.95", "0.95", "0.95", "0.4"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe87cfdb14e60f2", "value_decimal": "0.7652576888094968", "verdict": "NO_GO", "code": "BELOW_TAU"}
+    },
+    {
+      "id": "hidden_weak_permuted",
+      "source": "szl.lambda/v1 domain: a permutation of hidden_weak gives identical bits (fsum)",
+      "axes": ["f64:3fd999999999999a", "f64:3fee666666666666", "f64:3fee666666666666", "f64:3fee666666666666"],
+      "axes_decimal": ["0.4", "0.95", "0.95", "0.95"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe87cfdb14e60f2", "value_decimal": "0.7652576888094968", "verdict": "NO_GO", "code": "BELOW_TAU"}
+    },
+    {
+      "id": "x_gt_1",
+      "source": "szl-math-core.md §3 differential table (x>1 [1.5, .9])",
+      "note": "torch and the legacy Python source clamp to 0.948683; szl-formulas and szl-khipu return 1.1619",
+      "axes": ["f64:3ff8000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["1.5", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_AXIS_OUT_OF_RANGE", "verdict": "BLOCK", "code": "LAMBDA_AXIS_OUT_OF_RANGE"}
+    },
+    {
+      "id": "nan_axis",
+      "source": "szl-math-core.md §3 differential table (NaN axis)",
+      "axes": ["f64:7ff8000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["nan", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "pos_inf_axis",
+      "source": "szl-math-core.md §3 differential table (+Inf axis)",
+      "note": "the legacy Python source treats +Inf as 1 (0.948683)",
+      "axes": ["f64:7ff0000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["inf", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "neg_inf_axis",
+      "source": "szl-math-core.md §3 differential table (-Inf axis)",
+      "axes": ["f64:fff0000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["-inf", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "negative_axis",
+      "source": "szl-math-core.md §3 differential table (negative axis)",
+      "axes": ["f64:bfb999999999999a", "f64:3feccccccccccccd"],
+      "axes_decimal": ["-0.1", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_AXIS_OUT_OF_RANGE", "verdict": "BLOCK", "code": "LAMBDA_AXIS_OUT_OF_RANGE"}
+    },
+    {
+      "id": "zero_axis",
+      "source": "szl-math-core.md §3 differential table (zero axis)",
+      "note": "a veto, not an error: log Λ = -inf gives NO_GO",
+      "axes": ["f64:0000000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.0", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:0000000000000000", "value_decimal": "0.0", "verdict": "NO_GO", "code": "ZERO_VETO"}
+    },
+    {
+      "id": "negative_zero_axis",
+      "source": "szl.lambda/v1 domain: -0.0 is a zero axis",
+      "axes": ["f64:8000000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["-0.0", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:0000000000000000", "value_decimal": "0.0", "verdict": "NO_GO", "code": "ZERO_VETO"}
+    },
+    {
+      "id": "zero_axis_min_subnormal_tau",
+      "source": "szl.lambda/v1 domain: the zero-axis veto holds for every valid tau",
+      "axes": ["f64:0000000000000000", "f64:3ff0000000000000"],
+      "axes_decimal": ["0.0", "1.0"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:0000000000000001",
+      "tau_decimal": "5e-324",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:0000000000000000", "value_decimal": "0.0", "verdict": "NO_GO", "code": "ZERO_VETO"}
+    },
+    {
+      "id": "w_unnormalised_2_2",
+      "source": "szl-math-core.md §3 differential table (unnormalised w=[2,2] on [.81,.64])",
+      "note": "never renormalised (torch returns 0.72)",
+      "axes": ["f64:3fe9eb851eb851ec", "f64:3fe47ae147ae147b"],
+      "axes_decimal": ["0.81", "0.64"],
+      "weights": ["f64:4000000000000000", "f64:4000000000000000"],
+      "weights_decimal": ["2.0", "2.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_WEIGHT_SUM", "verdict": "BLOCK", "code": "LAMBDA_WEIGHT_SUM"}
+    },
+    {
+      "id": "w_zero_weight",
+      "source": "szl-math-core.md §3 differential table (zero weight w=[1,0] on [.5,.9])",
+      "axes": ["f64:3fe0000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.5", "0.9"],
+      "weights": ["f64:3ff0000000000000", "f64:0000000000000000"],
+      "weights_decimal": ["1.0", "0.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_WEIGHT_NONPOSITIVE", "verdict": "BLOCK", "code": "LAMBDA_WEIGHT_NONPOSITIVE"}
+    },
+    {
+      "id": "empty",
+      "source": "szl-math-core.md §3 differential table (empty)",
+      "note": "never 0.0",
+      "axes": [],
+      "axes_decimal": [],
+      "weights": [],
+      "weights_decimal": [],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_EMPTY", "verdict": "BLOCK", "code": "LAMBDA_EMPTY"}
+    },
+    {
+      "id": "empty_axes_nonempty_weights",
+      "source": "szl.lambda/v1 domain: empty axes",
+      "axes": [],
+      "axes_decimal": [],
+      "weights": ["f64:3ff0000000000000"],
+      "weights_decimal": ["1.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_EMPTY", "verdict": "BLOCK", "code": "LAMBDA_EMPTY"}
+    },
+    {
+      "id": "e5_round_4dp_not_a_pass",
+      "source": "FUSION_BRIEF.md E5 (4-dp rounding before the compare)",
+      "note": "round(Λ, 4) = 0.65 would pass tau 0.65; the unrounded Λ is below it",
+      "axes": ["f64:3fe4cc660a201472"],
+      "axes_decimal": ["0.649951"],
+      "weights": ["f64:3ff0000000000000"],
+      "weights_decimal": ["1.0"],
+      "tau": "f64:3fe4cccccccccccd",
+      "tau_decimal": "0.65",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe4cc660a201472", "value_decimal": "0.649951", "verdict": "NO_GO", "code": "BELOW_TAU"}
+    },
+    {
+      "id": "e5_dropped_axis_present",
+      "source": "FUSION_BRIEF.md E5 (triage weights, integrity = 0.1 present)",
+      "note": "weights from szl-typesafe-triage src/szl_triage/data/triage_policy.v3.json",
+      "axes": ["f64:3feb26e978d4fdf4", "f64:3feb26e978d4fdf4", "f64:3fb999999999999a", "f64:3feb26e978d4fdf4"],
+      "axes_decimal": ["0.8485", "0.8485", "0.1", "0.8485"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd999999999999a", "f64:3fc999999999999a", "f64:3fc3333333333333"],
+      "weights_decimal": ["0.25", "0.4", "0.2", "0.15"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe1b4397d7da1fc", "value_decimal": "0.5532500697127598", "verdict": "NO_GO", "code": "BELOW_TAU"}
+    },
+    {
+      "id": "e5_dropped_axis_renormalised",
+      "source": "FUSION_BRIEF.md E5 (integrity axis dropped)",
+      "note": "renormalising over the present axes would give 0.8485",
+      "axes": ["f64:3feb26e978d4fdf4", "f64:3feb26e978d4fdf4", "f64:3feb26e978d4fdf4"],
+      "axes_decimal": ["0.8485", "0.8485", "0.8485"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd999999999999a", "f64:3fc999999999999a", "f64:3fc3333333333333"],
+      "weights_decimal": ["0.25", "0.4", "0.2", "0.15"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_LENGTH_MISMATCH", "verdict": "BLOCK", "code": "LAMBDA_LENGTH_MISMATCH"}
+    },
+    {
+      "id": "e5_negative_weight",
+      "source": "FUSION_BRIEF.md E5 (w = (1.5, -0.5) breaks monotonicity)",
+      "note": "the weights sum to 1; szl-formulas accepts them and returns 0.3727",
+      "axes": ["f64:3fe0000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.5", "0.9"],
+      "weights": ["f64:3ff8000000000000", "f64:bfe0000000000000"],
+      "weights_decimal": ["1.5", "-0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_WEIGHT_NONPOSITIVE", "verdict": "BLOCK", "code": "LAMBDA_WEIGHT_NONPOSITIVE"}
+    },
+    {
+      "id": "length_mismatch_extra_weight",
+      "source": "szl.lambda/v1 domain: more weights than axes",
+      "axes": ["f64:3feccccccccccccd"],
+      "axes_decimal": ["0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_LENGTH_MISMATCH", "verdict": "BLOCK", "code": "LAMBDA_LENGTH_MISMATCH"}
+    },
+    {
+      "id": "tie_exact",
+      "source": "INVENTION.md §2.3 tie band (TIE_EPS = 1e-9, log space)",
+      "axes": ["f64:3fe999999999999a"],
+      "axes_decimal": ["0.8"],
+      "weights": ["f64:3ff0000000000000"],
+      "weights_decimal": ["1.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe999999999999a", "value_decimal": "0.8", "verdict": "ABSTAIN", "code": "NUMERIC_TIE"}
+    },
+    {
+      "id": "tie_inside_above",
+      "source": "INVENTION.md §2.3 tie band (TIE_EPS = 1e-9, log space): log Λ - log tau ≈ +5e-10",
+      "axes": ["f64:3fe9999999d0935a"],
+      "axes_decimal": ["0.8000000004000001"],
+      "weights": ["f64:3ff0000000000000"],
+      "weights_decimal": ["1.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe9999999d0935a", "value_decimal": "0.8000000004000001", "verdict": "ABSTAIN", "code": "NUMERIC_TIE"}
+    },
+    {
+      "id": "tie_inside_below",
+      "source": "INVENTION.md §2.3 tie band (TIE_EPS = 1e-9, log space): log Λ - log tau ≈ -5e-10",
+      "axes": ["f64:3fe9999999629fda"],
+      "axes_decimal": ["0.7999999996"],
+      "weights": ["f64:3ff0000000000000"],
+      "weights_decimal": ["1.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe9999999629fda", "value_decimal": "0.7999999996", "verdict": "ABSTAIN", "code": "NUMERIC_TIE"}
+    },
+    {
+      "id": "tie_outside_above",
+      "source": "INVENTION.md §2.3 tie band (TIE_EPS = 1e-9, log space): log Λ - log tau ≈ +2e-9",
+      "axes": ["f64:3fe999999a758098"],
+      "axes_decimal": ["0.8000000016"],
+      "weights": ["f64:3ff0000000000000"],
+      "weights_decimal": ["1.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe999999a758098", "value_decimal": "0.8000000016", "verdict": "GO", "code": null}
+    },
+    {
+      "id": "tie_outside_below",
+      "source": "INVENTION.md §2.3 tie band (TIE_EPS = 1e-9, log space): log Λ - log tau ≈ -2e-9",
+      "axes": ["f64:3fe9999998bdb29b"],
+      "axes_decimal": ["0.7999999984"],
+      "weights": ["f64:3ff0000000000000"],
+      "weights_decimal": ["1.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe9999998bdb29b", "value_decimal": "0.7999999984", "verdict": "NO_GO", "code": "BELOW_TAU"}
+    },
+    {
+      "id": "tie_multi_axis_at_own_value",
+      "source": "INVENTION.md §2.3 tie band (TIE_EPS = 1e-9, log space): hidden_weak against tau = its own Λ",
+      "axes": ["f64:3fee666666666666", "f64:3fee666666666666", "f64:3fee666666666666", "f64:3fd999999999999a"],
+      "axes_decimal": ["0.95", "0.95", "0.95", "0.4"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": "f64:3fe87cfdb14e60f2",
+      "tau_decimal": "0.7652576888094968",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe87cfdb14e60f2", "value_decimal": "0.7652576888094968", "verdict": "ABSTAIN", "code": "NUMERIC_TIE"}
+    },
+    {
+      "id": "all_ones_thirds",
+      "source": "szl.lambda/v1 domain: weights 1/3 each (fsum within 1e-12 of 1)",
+      "axes": ["f64:3ff0000000000000", "f64:3ff0000000000000", "f64:3ff0000000000000"],
+      "axes_decimal": ["1.0", "1.0", "1.0"],
+      "weights": ["f64:3fd5555555555555", "f64:3fd5555555555555", "f64:3fd5555555555555"],
+      "weights_decimal": ["0.3333333333333333", "0.3333333333333333", "0.3333333333333333"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3ff0000000000000", "value_decimal": "1.0", "verdict": "GO", "code": null}
+    },
+    {
+      "id": "int_axes_accepted",
+      "source": "szl.lambda/v1 type contract: integers are real numbers",
+      "axes": [1, 1],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3ff0000000000000", "value_decimal": "1.0", "verdict": "GO", "code": null}
+    },
+    {
+      "id": "subnormal_axis",
+      "source": "szl.lambda/v1 domain: the smallest positive axis is not a zero axis",
+      "axes": ["f64:0000000000000001", "f64:3ff0000000000000"],
+      "axes_decimal": ["5e-324", "1.0"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:1e60000000000064", "value_decimal": "2.222758749485127e-162", "verdict": "NO_GO", "code": "BELOW_TAU"}
+    },
+    {
+      "id": "weight_sum_within_tol",
+      "source": "szl.lambda/v1 domain: |fsum(w) - 1| = 4e-13 <= 1e-12",
+      "axes": ["f64:3feccccccccccccd", "f64:3fe0000000000000"],
+      "axes_decimal": ["0.9", "0.5"],
+      "weights": ["f64:3fe0000000000e13", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5000000000004", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fe5775c544ff164", "value_decimal": "0.6708203932499086", "verdict": "NO_GO", "code": "BELOW_TAU"}
+    },
+    {
+      "id": "weight_sum_outside_tol",
+      "source": "szl.lambda/v1 domain: |fsum(w) - 1| = 3e-12 > 1e-12",
+      "axes": ["f64:3feccccccccccccd", "f64:3fe0000000000000"],
+      "axes_decimal": ["0.9", "0.5"],
+      "weights": ["f64:3fe000000000698e", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.500000000003", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_WEIGHT_SUM", "verdict": "BLOCK", "code": "LAMBDA_WEIGHT_SUM"}
+    },
+    {
+      "id": "weight_nan",
+      "source": "szl.lambda/v1 domain: NaN weight",
+      "axes": ["f64:3fe0000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.5", "0.9"],
+      "weights": ["f64:7ff8000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["nan", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_WEIGHT", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_WEIGHT"}
+    },
+    {
+      "id": "weight_pos_inf",
+      "source": "szl.lambda/v1 domain: +Inf weight",
+      "axes": ["f64:3fe0000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.5", "0.9"],
+      "weights": ["f64:7ff0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["inf", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_WEIGHT", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_WEIGHT"}
+    },
+    {
+      "id": "weight_neg_inf",
+      "source": "szl.lambda/v1 domain: -Inf weight",
+      "axes": ["f64:3fe0000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.5", "0.9"],
+      "weights": ["f64:fff0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["-inf", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_WEIGHT", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_WEIGHT"}
+    },
+    {
+      "id": "precedence_nonfinite_before_range_a",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant)",
+      "axes": ["f64:3ff8000000000000", "f64:7ff8000000000000"],
+      "axes_decimal": ["1.5", "nan"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "precedence_nonfinite_before_range_b",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant)",
+      "axes": ["f64:7ff8000000000000", "f64:3ff8000000000000"],
+      "axes_decimal": ["nan", "1.5"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "precedence_axis_before_weight",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant)",
+      "axes": ["f64:3ff8000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["1.5", "0.9"],
+      "weights": ["f64:4000000000000000", "f64:4000000000000000"],
+      "weights_decimal": ["2.0", "2.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_AXIS_OUT_OF_RANGE", "verdict": "BLOCK", "code": "LAMBDA_AXIS_OUT_OF_RANGE"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_nan_a",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:0000000000000000", "f64:7ff8000000000000"],
+      "axes_decimal": ["0.0", "nan"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_nan_b",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:7ff8000000000000", "f64:0000000000000000"],
+      "axes_decimal": ["nan", "0.0"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_pos_inf_a",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:0000000000000000", "f64:7ff0000000000000"],
+      "axes_decimal": ["0.0", "inf"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_pos_inf_b",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:7ff0000000000000", "f64:0000000000000000"],
+      "axes_decimal": ["inf", "0.0"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_NONFINITE_AXIS", "verdict": "BLOCK", "code": "LAMBDA_NONFINITE_AXIS"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_x_gt_1_a",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:0000000000000000", "f64:3ff8000000000000"],
+      "axes_decimal": ["0.0", "1.5"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_AXIS_OUT_OF_RANGE", "verdict": "BLOCK", "code": "LAMBDA_AXIS_OUT_OF_RANGE"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_x_gt_1_b",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:3ff8000000000000", "f64:0000000000000000"],
+      "axes_decimal": ["1.5", "0.0"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_AXIS_OUT_OF_RANGE", "verdict": "BLOCK", "code": "LAMBDA_AXIS_OUT_OF_RANGE"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_negative_a",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:0000000000000000", "f64:bfb999999999999a"],
+      "axes_decimal": ["0.0", "-0.1"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_AXIS_OUT_OF_RANGE", "verdict": "BLOCK", "code": "LAMBDA_AXIS_OUT_OF_RANGE"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_negative_b",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:bfb999999999999a", "f64:0000000000000000"],
+      "axes_decimal": ["-0.1", "0.0"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_AXIS_OUT_OF_RANGE", "verdict": "BLOCK", "code": "LAMBDA_AXIS_OUT_OF_RANGE"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_bool_a",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": ["f64:0000000000000000", true],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_TYPE_INVALID", "verdict": "BLOCK", "code": "LAMBDA_TYPE_INVALID"}
+    },
+    {
+      "id": "precedence_zero_does_not_mask_bool_b",
+      "source": "szl.lambda/v1 error precedence (phases, permutation-invariant): every axis is validated before the zero veto (szl-receipt#38, FF-03b)",
+      "axes": [true, "f64:0000000000000000"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe0000000000000",
+      "tau_decimal": "0.5",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_TYPE_INVALID", "verdict": "BLOCK", "code": "LAMBDA_TYPE_INVALID"}
+    },
+    {
+      "id": "type_bool_axis",
+      "source": "szl.lambda/v1 type contract: bool is not a number",
+      "axes": [true, "f64:3feccccccccccccd"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_TYPE_INVALID", "verdict": "BLOCK", "code": "LAMBDA_TYPE_INVALID"}
+    },
+    {
+      "id": "type_null_axis",
+      "source": "szl.lambda/v1 type contract: null axis",
+      "axes": [null, "f64:3feccccccccccccd"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_TYPE_INVALID", "verdict": "BLOCK", "code": "LAMBDA_TYPE_INVALID"}
+    },
+    {
+      "id": "type_string_axis",
+      "source": "szl.lambda/v1 type contract: a string is not a number",
+      "axes": ["0.9", "f64:3feccccccccccccd"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_TYPE_INVALID", "verdict": "BLOCK", "code": "LAMBDA_TYPE_INVALID"}
+    },
+    {
+      "id": "type_axes_not_array",
+      "source": "szl.lambda/v1 type contract: axes must be an array",
+      "axes": null,
+      "weights": ["f64:3ff0000000000000"],
+      "weights_decimal": ["1.0"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_TYPE_INVALID", "verdict": "BLOCK", "code": "LAMBDA_TYPE_INVALID"}
+    },
+    {
+      "id": "type_bool_weight",
+      "source": "szl.lambda/v1 type contract: bool weight",
+      "note": "the element type is checked before the weight value",
+      "axes": ["f64:3fe0000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.5", "0.9"],
+      "weights": [true, "f64:0000000000000000"],
+      "tau": "f64:3fe999999999999a",
+      "tau_decimal": "0.8",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_TYPE_INVALID", "verdict": "BLOCK", "code": "LAMBDA_TYPE_INVALID"}
+    },
+    {
+      "id": "tau_one",
+      "source": "szl.lambda/v1 tau domain (0, 1], required, checked first",
+      "axes": ["f64:3fee666666666666", "f64:3fed70a3d70a3d71", "f64:3fec28f5c28f5c29", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.95", "0.92", "0.88", "0.9"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": "f64:3ff0000000000000",
+      "tau_decimal": "1.0",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fed3035e27f23fe", "value_decimal": "0.9121350692522581", "verdict": "NO_GO", "code": "BELOW_TAU"}
+    },
+    {
+      "id": "tau_nan",
+      "source": "szl.lambda/v1 tau domain (0, 1], required, checked first",
+      "axes": ["f64:3fee666666666666", "f64:3fed70a3d70a3d71", "f64:3fec28f5c28f5c29", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.95", "0.92", "0.88", "0.9"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": "f64:7ff8000000000000",
+      "tau_decimal": "nan",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fed3035e27f23fe", "value_decimal": "0.9121350692522581", "verdict": "BLOCK", "code": "LAMBDA_TAU_INVALID"}
+    },
+    {
+      "id": "tau_zero_would_admit_veto",
+      "source": "szl.lambda/v1 tau domain (0, 1], required, checked first: tau 0 would pass a vetoed Λ = 0",
+      "axes": ["f64:0000000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.0", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:0000000000000000",
+      "tau_decimal": "0.0",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:0000000000000000", "value_decimal": "0.0", "verdict": "BLOCK", "code": "LAMBDA_TAU_INVALID"}
+    },
+    {
+      "id": "tau_above_one",
+      "source": "szl.lambda/v1 tau domain (0, 1], required, checked first",
+      "axes": ["f64:3fee666666666666", "f64:3fed70a3d70a3d71", "f64:3fec28f5c28f5c29", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.95", "0.92", "0.88", "0.9"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": "f64:3ff8000000000000",
+      "tau_decimal": "1.5",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fed3035e27f23fe", "value_decimal": "0.9121350692522581", "verdict": "BLOCK", "code": "LAMBDA_TAU_INVALID"}
+    },
+    {
+      "id": "tau_negative",
+      "source": "szl.lambda/v1 tau domain (0, 1], required, checked first",
+      "axes": ["f64:3fee666666666666", "f64:3fed70a3d70a3d71", "f64:3fec28f5c28f5c29", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.95", "0.92", "0.88", "0.9"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": "f64:bfb999999999999a",
+      "tau_decimal": "-0.1",
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fed3035e27f23fe", "value_decimal": "0.9121350692522581", "verdict": "BLOCK", "code": "LAMBDA_TAU_INVALID"}
+    },
+    {
+      "id": "tau_bool",
+      "source": "szl.lambda/v1 tau domain (0, 1], required, checked first: bool is not a number",
+      "axes": ["f64:3fee666666666666", "f64:3fed70a3d70a3d71", "f64:3fec28f5c28f5c29", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.95", "0.92", "0.88", "0.9"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": true,
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fed3035e27f23fe", "value_decimal": "0.9121350692522581", "verdict": "BLOCK", "code": "LAMBDA_TAU_INVALID"}
+    },
+    {
+      "id": "tau_null",
+      "source": "szl.lambda/v1 tau domain (0, 1], required, checked first: tau is required",
+      "axes": ["f64:3fee666666666666", "f64:3fed70a3d70a3d71", "f64:3fec28f5c28f5c29", "f64:3feccccccccccccd"],
+      "axes_decimal": ["0.95", "0.92", "0.88", "0.9"],
+      "weights": ["f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000", "f64:3fd0000000000000"],
+      "weights_decimal": ["0.25", "0.25", "0.25", "0.25"],
+      "tau": null,
+      "value_tol": 1e-12,
+      "expect": {"value_f64": "f64:3fed3035e27f23fe", "value_decimal": "0.9121350692522581", "verdict": "BLOCK", "code": "LAMBDA_TAU_INVALID"}
+    },
+    {
+      "id": "tau_precedes_axis_error",
+      "source": "szl.lambda/v1 tau domain (0, 1], required, checked first: tau is checked before Λ",
+      "axes": ["f64:3ff8000000000000", "f64:3feccccccccccccd"],
+      "axes_decimal": ["1.5", "0.9"],
+      "weights": ["f64:3fe0000000000000", "f64:3fe0000000000000"],
+      "weights_decimal": ["0.5", "0.5"],
+      "tau": "f64:7ff8000000000000",
+      "tau_decimal": "nan",
+      "value_tol": 1e-12,
+      "expect": {"error": "LAMBDA_AXIS_OUT_OF_RANGE", "verdict": "BLOCK", "code": "LAMBDA_TAU_INVALID"}
+    }
+  ]
+}

spec/szl.lambda.v1.json ADDED Viewed

	@@ -0,0 +1,133 @@

+{
+  "schema": "szl.lambda/v1",
+  "title": "Λ, the weighted geometric mean, as a validated contract",
+  "status": "ADVISORY",
+  "uniqueness": "CONJECTURE_1_NOT_USED",
+  "honesty": "Λ is an advisory, non-compensatory roll-up. Λ uniqueness is Conjecture 1 (open); nothing in this contract depends on it.",
+  "form": "weighted_geometric_mean",
+  "definition": "Λ_w(x) = ∏_k x_k^{w_k}",
+  "algorithm": {
+    "log_lambda": "-inf if some x_k == 0, else math.fsum(w_k * math.log(x_k))",
+    "lambda": "0.0 if log_lambda == -inf, else math.exp(log_lambda)",
+    "weight_sum": "math.fsum(weights)",
+    "why_fsum": "fsum is correctly rounded, so Λ is bitwise invariant under a permutation of (axes, weights)"
+  },
+  "domain": {
+    "axes": "list or tuple of real numbers (bool is not a number); every x_k finite and 0 <= x_k <= 1",
+    "weights": "list or tuple of real numbers, the same length as axes; every w_k finite and w_k > 0; |fsum(weights) - 1| <= weight_sum_tol",
+    "empty": "error LAMBDA_EMPTY, never 0.0",
+    "renormalisation": "never: weights are used as declared",
+    "clamping": "never: a non-finite or out-of-range value is an error",
+    "rounding": "never before the compare",
+    "output": "Λ in [0, 1]; exactly 0.0 iff some x_k == 0 (a veto, not an error)"
+  },
+  "weight_sum_tol": 1e-12,
+  "error_codes": [
+    {
+      "code": "LAMBDA_TYPE_INVALID",
+      "when": "axes or weights is not a list/tuple (checked first), or an element is not a real number (checked after LAMBDA_LENGTH_MISMATCH)"
+    },
+    {
+      "code": "LAMBDA_EMPTY",
+      "when": "axes or weights is empty"
+    },
+    {
+      "code": "LAMBDA_LENGTH_MISMATCH",
+      "when": "len(axes) != len(weights); a dropped axis is never renormalised away"
+    },
+    {
+      "code": "LAMBDA_NONFINITE_AXIS",
+      "when": "some x_k is NaN, +Inf or -Inf"
+    },
+    {
+      "code": "LAMBDA_AXIS_OUT_OF_RANGE",
+      "when": "some x_k < 0 or x_k > 1"
+    },
+    {
+      "code": "LAMBDA_NONFINITE_WEIGHT",
+      "when": "some w_k is NaN, +Inf or -Inf"
+    },
+    {
+      "code": "LAMBDA_WEIGHT_NONPOSITIVE",
+      "when": "some w_k <= 0"
+    },
+    {
+      "code": "LAMBDA_WEIGHT_SUM",
+      "when": "|fsum(weights) - 1| > weight_sum_tol, or the sum overflows"
+    },
+    {
+      "code": "LAMBDA_TAU_INVALID",
+      "when": "gate only: tau is not a real number, not finite, or outside (0, 1]; checked before Λ"
+    }
+  ],
+  "precedence": "Checks run in the order of error_codes, each over every element, so the reported code does not depend on axis order. The gate checks tau first.",
+  "gate": {
+    "signature": "gate_v1(axes, weights, tau) -> (verdict, code)",
+    "verdicts": [
+      "GO",
+      "NO_GO",
+      "ABSTAIN",
+      "BLOCK"
+    ],
+    "tau": {
+      "required": true,
+      "implicit_default": null,
+      "domain": "real, finite, 0 < tau <= 1 (tau = 0 would pass a vetoed Λ = 0)",
+      "error": "LAMBDA_TAU_INVALID",
+      "default_source": "frontier/model_admit_contract.v1.json#/policy_tau",
+      "policy_tau_at_authoring": 0.8
+    },
+    "compare": "log space on the unrounded value: delta = log_lambda - log(tau)",
+    "tie_eps": 1e-09,
+    "rules": [
+      {
+        "if": "tau invalid, or Λ raises",
+        "verdict": "BLOCK",
+        "code": "the error code"
+      },
+      {
+        "if": "log_lambda == -inf (some axis is 0)",
+        "verdict": "NO_GO",
+        "code": "ZERO_VETO"
+      },
+      {
+        "if": "abs(delta) <= tie_eps",
+        "verdict": "ABSTAIN",
+        "code": "NUMERIC_TIE"
+      },
+      {
+        "if": "delta > 0",
+        "verdict": "GO",
+        "code": null
+      },
+      {
+        "if": "otherwise",
+        "verdict": "NO_GO",
+        "code": "BELOW_TAU"
+      }
+    ]
+  },
+  "canonical_float": "f64:<16 lowercase hex digits of the IEEE-754 binary64 bits, big-endian>",
+  "vectors": {
+    "path": "spec/lambda_v1_vectors.json",
+    "count": 60,
+    "sha256": "61bfb0410b9f0eaab0eb9f22f29cb7cb13cfde8c083fe308d895565d6ba9ebd4",
+    "digest": {
+      "algorithm": "sha256",
+      "over": "canonical_json",
+      "sort_keys": true,
+      "separators": [
+        ",",
+        ":"
+      ],
+      "ensure_ascii": false,
+      "allow_nan": false,
+      "encoding": "utf-8"
+    }
+  },
+  "reference": "reference/szl_lambda_v1.py",
+  "legacy_not_canonical": [
+    "tests/lambda_aggregator_source.py: +Inf counts as 1, NaN leaks, empty gives 0.0, weights are renormalised",
+    "torch-ext/szl_lambda_gate/_lambda.py lambda_aggregate: clamps, routes NaN/Inf to 0, renormalises; pinned in tests/test_lambda_v1_torch_divergence.py"
+  ]
+}