| |
| |
| """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 |
|
|
| |
| |
| |
| |
| |
| |
| _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 |
|
|
|
|
| |
| |
| |
| _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 |
| |
| |
| |
| |
| 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) |
|
|
| |
| |
| |
| |
| 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) |
| 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: 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" |
| ) |
| |
| |
| return lambda_gate(candidates, weights=weights, threshold=threshold) |
|
|
|
|
| |
| |
| |
| |
|
|
| 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)) |
| |
| |
| 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) |
| |
| ok = ok and bool(torch.all(bumped_val - base >= -tol)) |
| return ok |
|
|
|
|
| |
| 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 |
| |
| 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 |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| 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: 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) |
|
|
|
|
| |
| 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 |
| 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 |
|
|
| LambdaGateResult = namedtuple( |
| "LambdaGateResult", ["score", "passed", "threshold", "advisory"] |
| ) |
|
|
