Publish verified torch-cpu kernel v1

Dedicated Kernel Hub migration from legacy model commit 70e796a774dbf1d8d06ac5f33295922768480bf2. Locally loaded with kernels 0.16.0 on CPU and passed its bounded verification.

Files changed (7) hide show

LICENSE +19 -0
README.md +172 -0
build/torch-cpu/metadata.json +10 -0
build/torch-cpu/szl_lambda_gate/__init__.py +172 -0
build/torch-cpu/szl_lambda_gate/_lambda.py +313 -0
build/torch-cpu/szl_lambda_gate/_ops.py +10 -0
build/torch-cpu/szl_lambda_gate/layers.py +51 -0

LICENSE ADDED Viewed

	@@ -0,0 +1,19 @@

+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+   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.
+   The full Apache License 2.0 text is available at the URL above.

README.md ADDED Viewed

	@@ -0,0 +1,172 @@

+---
+tags:
+- kernel
+- governance
+- lambda
+- gate
+- provenance
+- doi:10.5281/zenodo.19944926
+library_name: kernels
+license: apache-2.0
+---
+<p align="center">
+  <a href="https://huggingface.co/SZLHOLDINGS/szl-lambda-gate/tree/main/build/torch-universal/szl_lambda_gate"><img src="https://img.shields.io/badge/kernel%20hub-torch--universal-5b8dee?style=flat-square" alt="kernel hub"></a>
+  <a href="https://huggingface.co/SZLHOLDINGS/szl-lambda-gate/blob/main/MODEL_PROVENANCE.json"><img src="https://img.shields.io/badge/provenance-MODEL_PROVENANCE.json-3af4c8?style=flat-square" alt="provenance"></a>
+  <a href="https://huggingface.co/SZLHOLDINGS/szl-lambda-gate/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-7e8aa3?style=flat-square" alt="license"></a>
+</p>
+# szl-lambda-gate
+**Λ — a governance aggregator as a Hugging Face kernel.** A differentiable, torch.compile-friendly weighted-geometric-mean aggregator with an ADVISORY non-compensatory gate and runtime axiom self-checks, from [SZL Holdings](https://huggingface.co/SZLHOLDINGS).
+> Companion to [`szl-governed-norm`](https://huggingface.co/SZLHOLDINGS/szl-governed-norm). Where that kernel makes a normalization *auditable*, this one makes a *governance decision* computable and checkable at the tensor layer.
+## Interactive demo
+> **Live demos (in-browser, nothing to install)** — [`lambda-gate-holo`](https://szlholdings-lambda-gate-holo.static.hf.space) (this kernel's holographic gate demo) · [`szl-kernels-live`](https://szlholdings-szl-kernels-live.static.hf.space) (unified suite demo).
+>
+> The quickstart above runs fully locally. For a full governed-kernel suite demo, see [szl-kernels](https://huggingface.co/SZLHOLDINGS/szl-kernels). For the live a11oy substrate, see [a11oy Space](https://huggingface.co/spaces/SZLHOLDINGS/a11oy).
+## What Λ is — and is NOT (read this first)
+Λ is the **weighted geometric mean** over axis scores in [0,1]:
+\[ \Lambda(x) = \prod_i x_i^{w_i}, \quad \sum_i w_i = 1, \; w_i > 0, \; x_i \in [0,1] \]
+It is a **non-compensatory, ADVISORY** roll-up: any single zeroed (or non-finite) axis drives the whole aggregate to 0 — a conservative "one bad axis fails the gate" signal. **Λ 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**. A gate "pass" is an advisory signal, never a guarantee. We label this honestly everywhere.
+## Quickstart
+```bash
+pip install kernels torch
+```
+```python
+import torch
+from kernels import get_kernel
+# Current `kernels` (>=0.15) requires an explicit revision/version + trust flag for org kernels:
+lg = get_kernel("SZLHOLDINGS/szl-lambda-gate", revision="main", trust_remote_code=True)
+# (once a tag is published you can pin it, e.g. revision="v0.2.0")
+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)
+print(res.score, res.passed, res.advisory) # advisory is always True
+print(lg.selfcheck())                      # empirical A1–A4 checks + version
+```
+## API
+| Function | Notes |
+|---|---|
+| `lambda_aggregate(axes, weights=None)` | Λ over the last dim. Differentiable, batched, torch.compile-friendly. |
+| `lambda_gate(axes, weights=None, threshold=0.5)` | Advisory gate → `LambdaGateResult(score, passed, threshold, advisory)`. |
+| `lambda_gate_batch(candidates, weights=None, threshold=0.5)` | Score many candidate vectors `(..., N, k)` in one call; returns the advisory pass mask. |
+| `selfcheck()` | Empirical A1–A4 axiom checks + adversarial falsification search + version. NOT a uniqueness proof. |
+| `is_monotone / is_homogeneous / is_egyptian_exact / is_bounded_by_max` | The four carried axioms as real runtime checks. |
+| `yuyay_weights()`, `YUYAY_AXES`, `YUYAY_FLOORS` | Canonical 13-axis Yuyay preset (advisory). |
+| layers: `LambdaGate`, `LambdaAggregate` | Pure `nn.Module` for the Kernel Hub layer-mapping mechanism. |
+## Carried axioms (verifiable, not a proof)
+- **A1 IsMonotone** — Λ is non-decreasing in each axis.
+- **A2 IsHomogeneous (deg 1)** — Λ(t·x) = t·Λ(x).
+- **A3 IsEgyptianExact** — Λ(c,…,c) = c.
+- **A4 IsBounded** — Λ(x) ≤ maxᵢ xᵢ.
+`selfcheck()` verifies these empirically on sampled inputs and runs a random falsification search. A clean run is **evidence, not proof** — Λ-uniqueness is Conjecture 1 (open).
+## Provenance
+Backed by the Lean 4 formalization [szl-holdings/lutar-lean](https://github.com/szl-holdings/lutar-lean) (749 declarations / 14 axioms / 163 tracked sorries), DOI [10.5281/zenodo.20434308](https://doi.org/10.5281/zenodo.20434308). Λ uniqueness = Conjecture 1 (open).
+## Honesty
+- Pure-Python universal kernel — a correctness reference, not a CUDA speed record. No fabricated benchmarks (50 passing tests).
+- Λ is advisory; never "proven trust."
+- Prior art honestly attributed: the weighted geometric mean as a less-compensatory composite indicator is established practice (UN HDI 2010, OECD Composite Indicators Handbook 2008); the veto/cut-off idea is ELECTRE. The 13-axis conjunctive form is SZL's own yuyay_v3 gate.
+## Compatibility
+Python 3.9+, `torch>=2.5`, standard library + torch only.
+## License
+Apache-2.0. Copyright 2026 SZL Holdings.
+---
+## SZL Kernels Suite
+Part of the [`szl-kernels`](https://huggingface.co/SZLHOLDINGS/szl-kernels) governed-kernel suite — the hub links every member, and each member links back to the hub so no leaf is orphaned:
+| Kernel | Lane |
+|---|---|
+| [`szl-kernels`](https://huggingface.co/SZLHOLDINGS/szl-kernels) | **hub** — unified suite, cross-kernel `UnifiedReceiptChain` |
+| [`szl-governed-norm`](https://huggingface.co/SZLHOLDINGS/szl-governed-norm) | RMSNorm/LayerNorm + SHA3-256 receipts |
+| **`szl-lambda-gate`** (this repo) | **advisory Λ gate (Conjecture 1, OPEN)** |
+| [`governed-inference-meter`](https://huggingface.co/SZLHOLDINGS/governed-inference-meter) | MEASURED-joule energy accounting (NVML) |
+| [`szl-govsign`](https://huggingface.co/SZLHOLDINGS/szl-govsign) | signed governance attestation (DSSE / in-toto) |
+| [`szl-blocked`](https://huggingface.co/SZLHOLDINGS/szl-blocked) | honest-BLOCKED state + EU AI Act Annex IV DRAFT |
+| [`szl-provctl`](https://huggingface.co/SZLHOLDINGS/szl-provctl) | provenance-DAG verify + in-toto/SLSA interop |
+**Live Spaces:** [a11oy](https://huggingface.co/spaces/SZLHOLDINGS/a11oy) · [hatun-mcp](https://huggingface.co/spaces/SZLHOLDINGS/hatun-mcp).
+**Related — Governed Kernels collection:** [Governed Kernels — verifiable AI building blocks](https://huggingface.co/collections/SZLHOLDINGS/governed-kernels-verifiable-ai-building-blocks-6a41d3936cfce4fba83ce378) groups the whole family in one page. **Live console:** [a11oy](https://szlholdings-a11oy.hf.space) · [a-11-oy.com](https://a-11-oy.com) · [llm-router](https://szlholdings-llm-router-live.hf.space) · [receipt verifier](https://szlholdings-governed-receipt-verifier.static.hf.space) · [receipt spec (hub)](https://github.com/szl-holdings/governed-receipt-spec).
+---
+<sub><b>SZL Holdings</b> · Λ governance aggregator · advisory, not proven trust · <a href="https://a-11-oy.com">a-11-oy.com</a> · <a href="https://github.com/szl-holdings">github.com/szl-holdings</a> · <a href="https://huggingface.co/SZLHOLDINGS">huggingface.co/SZLHOLDINGS</a></sub>
+---
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.19944926.svg)](https://doi.org/10.5281/zenodo.19944926)
+## Citation
+**Cite this.** Part of the SZL Holdings *Ouroboros Thesis* (Governed Post-Determinism).
+Concept DOI (always-latest): [10.5281/zenodo.19944926](https://doi.org/10.5281/zenodo.19944926).
+Author: Stephen P. Lutar Jr. · [ORCID 0009-0001-0110-4173](https://orcid.org/0009-0001-0110-4173) · License CC-BY-4.0.
+Full DOI-pinned lineage (v1→v26) + the 8 papers: [szl-papers PAPERS_INDEX](https://github.com/szl-holdings/szl-papers/blob/main/PAPERS_INDEX.md).
+No artifact-specific DOI is minted for this model; the concept DOI above covers the program.
+Honesty (Doctrine v11): Λ unconditional uniqueness is **Conjecture 1** (machine-checked FALSE as stated) — never a theorem; conditional uniqueness is **Theorem U** (axiom-free). Locked-proven formulas = **exactly 8** {F1,F4,F7,F11,F12,F18,F19,F22}; ~185 experimental theorems are a separate CI-green tier; Khipu BFT safety = Conjecture 2. Trust never 100%.
+```bibtex
+@misc{lutar_szl_ouroboros,
+  author    = {Lutar, Stephen P., Jr.},
+  title     = {SZL Holdings --- The Ouroboros Thesis (Governed Post-Determinism)},
+  year      = {2026},
+  publisher = {Zenodo},
+  doi       = {10.5281/zenodo.19944926},
+  url       = {https://doi.org/10.5281/zenodo.19944926},
+  note      = {Concept DOI --- always resolves to the latest version. ORCID 0009-0001-0110-4173. CC-BY-4.0.}
+}
+```
+*Signed-off-by: Stephen Lutar <stephenlutar2@gmail.com>*
+## Files in this repo
+| Path | What it is |
+|---|---|
+| `build/torch-universal/szl_lambda_gate/__init__.py` | public API — `lambda_aggregate`, `lambda_gate`, `selfcheck()` |
+| `build/torch-universal/szl_lambda_gate/_lambda.py` | the weighted-geometric-mean aggregator + A1–A4 empirical checks |
+| `build/torch-universal/szl_lambda_gate/layers.py` | `nn.Module` wrapper |
+| `build.toml` · `metadata.json` | Kernel Hub build/metadata manifests |
+| `LICENSE` · `SECURITY.md` | Apache-2.0 · security policy |
+---
+<p align="center">
+  <a href="https://huggingface.co/SZLHOLDINGS">SZL Holdings</a> ·
+  <a href="https://a-11-oy.com">a-11-oy.com</a> ·
+  <a href="https://huggingface.co/SZLHOLDINGS/szl-kernels">szl-kernels</a>
+</p>
+<p align="center"><sub>SLSA: L1 honest · L2 attested · L3 roadmap. Λ = Conjecture 1. Trust ceiling 0.97.</sub></p>

build/torch-cpu/metadata.json ADDED Viewed

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

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

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

	@@ -0,0 +1,172 @@

+# 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)

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

	@@ -0,0 +1,313 @@

+# 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"]
+)

build/torch-cpu/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-cpu/szl_lambda_gate/layers.py ADDED Viewed

	@@ -0,0 +1,51 @@

+# 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)