moju 2.4.0__tar.gz → 2.4.2__tar.gz

{moju-2.4.0 → moju-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moju
-Version: 2.4.0
+Version: 2.4.2
 Summary: Physics admissibility auditing for ML surrogates and simulation data: scores how well predicted fields satisfy governing laws and constitutive relations, with implied-parameter checks and admissibility tiers, for JAX and PyTorch.
 Author-email: "Ifimo Lab (Ifimo Global Solutions LLC)" <lab@ifimoanalytics.com>
 Maintainer-email: "Ifimo Global Solutions LLC (dba Ifimo Lab)" <info@ifimoanalytics.com>
@@ -87,7 +87,7 @@ An evaluation mask excludes all components at each excluded spatial point.
 Audit-scope monitor-log exports preserve the non-finite policy recorded by
 `audit`, including incomplete per-key verdicts and null scores in JSON series.
 
-NaN-aware reductions may score on the finite subset of a residual. Every scored key and the aggregate now carry an evaluation-coverage record (`n_total`, `n_masked`, `n_selected`, `n_finite`, `n_nonfinite`, `coverage_status`). Default `nonfinite_policy="flag"` keeps scores and tiers unchanged; set `"strict"` to treat incomplete or empty coverage as tier **Incomplete** (not assessable — distinct from **Not identifiable**). Under `"flag"`, a NaN residual is dropped from the score while an infinite residual enters the RMS and drives the score to 0; both are reported as `coverage_status = "incomplete"`. `"strict"` treats NaN and inf identically (null score, Incomplete).
+NaN-aware reductions may score on the finite subset of a residual. Every scored key and the aggregate now carry an evaluation-coverage record (`n_total`, `n_masked`, `n_not_identifiable`, `n_selected`, `n_finite`, `n_nonfinite`, `coverage_status`). Default `nonfinite_policy="flag"` keeps scores and tiers unchanged; set `"strict"` to treat incomplete or empty coverage as tier **Incomplete** (not assessable — distinct from **Not identifiable**). Under `"flag"`, a NaN residual is dropped from the score while an infinite residual enters the RMS and drives the score to 0; both are reported as `coverage_status = "incomplete"`. `"strict"` treats NaN and inf identically (null score, Incomplete). Points excluded by implied-audit identifiability (finite required inputs where the scoring-path conditioning test fails or is undefined) are counted as `n_not_identifiable` (not `n_nonfinite`), so `n_selected = n_total − n_masked − n_not_identifiable`. A point is non-finite only when a required input (or residual component) at that point is non-finite — never because the conditioning ratio alone is non-finite.
 
 **Known limitation.** Coverage counts non-finite values in the residual array. A required input that is non-finite while the law's residual stays finite (for example, a law that applies `jnp.where` or `zeros_like` to that input) is currently reported as `coverage_status = "ok"`. Counting non-finite inputs per sample needs a mapping from input samples to residual samples that holds for scalars, parameters and broadcast shapes; this is planned for a follow-up release.
 

{moju-2.4.0 → moju-2.4.2}/README.md

@@ -38,7 +38,7 @@ An evaluation mask excludes all components at each excluded spatial point.
 Audit-scope monitor-log exports preserve the non-finite policy recorded by
 `audit`, including incomplete per-key verdicts and null scores in JSON series.
 
-NaN-aware reductions may score on the finite subset of a residual. Every scored key and the aggregate now carry an evaluation-coverage record (`n_total`, `n_masked`, `n_selected`, `n_finite`, `n_nonfinite`, `coverage_status`). Default `nonfinite_policy="flag"` keeps scores and tiers unchanged; set `"strict"` to treat incomplete or empty coverage as tier **Incomplete** (not assessable — distinct from **Not identifiable**). Under `"flag"`, a NaN residual is dropped from the score while an infinite residual enters the RMS and drives the score to 0; both are reported as `coverage_status = "incomplete"`. `"strict"` treats NaN and inf identically (null score, Incomplete).
+NaN-aware reductions may score on the finite subset of a residual. Every scored key and the aggregate now carry an evaluation-coverage record (`n_total`, `n_masked`, `n_not_identifiable`, `n_selected`, `n_finite`, `n_nonfinite`, `coverage_status`). Default `nonfinite_policy="flag"` keeps scores and tiers unchanged; set `"strict"` to treat incomplete or empty coverage as tier **Incomplete** (not assessable — distinct from **Not identifiable**). Under `"flag"`, a NaN residual is dropped from the score while an infinite residual enters the RMS and drives the score to 0; both are reported as `coverage_status = "incomplete"`. `"strict"` treats NaN and inf identically (null score, Incomplete). Points excluded by implied-audit identifiability (finite required inputs where the scoring-path conditioning test fails or is undefined) are counted as `n_not_identifiable` (not `n_nonfinite`), so `n_selected = n_total − n_masked − n_not_identifiable`. A point is non-finite only when a required input (or residual component) at that point is non-finite — never because the conditioning ratio alone is non-finite.
 
 **Known limitation.** Coverage counts non-finite values in the residual array. A required input that is non-finite while the law's residual stays finite (for example, a law that applies `jnp.where` or `zeros_like` to that input) is currently reported as `coverage_status = "ok"`. Counting non-finite inputs per sample needs a mapping from input samples to residual samples that holds for scalars, parameters and broadcast shapes; this is planned for a follow-up release.
 

{moju-2.4.0 → moju-2.4.2}/moju/__init__.py

@@ -1,3 +1,3 @@
 """Moju: Physics-AI supervision for engineering-grade simulations."""
 
-__version__ = "2.4.0"
+__version__ = "2.4.2"

{moju-2.4.0 → moju-2.4.2}/moju/monitor/auditor.py

@@ -1028,6 +1028,9 @@ def _apply_evaluation_coverage_policy(
             eval_mask_label=eval_mask_label
             or (entry.get("eval_mask") or {}).get("label"),
             mask_meta=entry.get("eval_mask") if isinstance(entry.get("eval_mask"), dict) else None,
+            closure_debug=last_residual_dict.get("closure_debug")
+            if isinstance(last_residual_dict.get("closure_debug"), dict)
+            else None,
         )
     per_key = report.get("per_key") or {}
     incomplete_keys: List[str] = []
@@ -3389,6 +3392,7 @@ class ResidualEngine:
             eval_mask_label=eval_mask_label,
             mask_meta=mask_meta or None,
             unmasked_flat=unmasked_flat,
+            closure_debug=closure_debug or None,
         )
         rms_per_key = _rms_per_key(flat, to_python=log_to_python)
         r_max_per_key = _max_per_key(flat, to_python=log_to_python, scoring=self._scoring_by_key)

{moju-2.4.0 → moju-2.4.2}/moju/monitor/evaluate_batch.py

@@ -470,6 +470,10 @@ def _score_one(
     implied_debug: Dict[str, Dict[str, Any]] = {}
     # Tracer-safe identifiability scalars (status strings materialised on the host).
     implied_id: Dict[str, Dict[str, Any]] = {}
+    # Pointwise NI masks / row-NI flags for coverage (keyed by residual basename).
+    batch_id_masks: Dict[str, Any] = {}
+    batch_ni_masks: Dict[str, Any] = {}
+    batch_id_row_ni: Dict[str, Any] = {}
     for audit_spec in plan.audits:
         spec = audit_spec["spec"]
         reg = audit_spec["reg"]
@@ -531,6 +535,19 @@ def _score_one(
                             pack[sk] = jnp.asarray(dbg[sk])
                     if pack:
                         implied_id[str(base)] = pack
+                    if dbg.get("identifiable_mask") is not None:
+                        batch_id_masks[str(base)] = jnp.asarray(dbg["identifiable_mask"])
+                    if dbg.get("not_identifiable_mask") is not None:
+                        batch_ni_masks[str(base)] = jnp.asarray(
+                            dbg["not_identifiable_mask"]
+                        )
+                    # Row-level wipe (tracer-safe 0-d bool): entire δ is NaN for scoring.
+                    if "identifiable" in dbg:
+                        batch_id_row_ni[str(base)] = jnp.logical_not(
+                            jnp.asarray(dbg["identifiable"])
+                        )
+                    elif dbg.get("status") == "not_identifiable":
+                        batch_id_row_ni[str(base)] = jnp.asarray(True)
                 if (
                     dbg.get("noise_rhs") is not None
                     and dbg.get("noise_basis") is not None
@@ -578,9 +595,23 @@ def _score_one(
     rmax = {k: r_max(v) for k, v in flat.items()}
     from moju.monitor.evaluation_coverage import coverage_counts_arrays
 
-    coverage_nums: Dict[str, Dict[str, Any]] = {
-        k: coverage_counts_arrays(v) for k, v in flat.items()
-    }
+    coverage_nums: Dict[str, Dict[str, Any]] = {}
+    for k, v in flat.items():
+        id_mask = None
+        ni_mask = None
+        row_ni: Any = False
+        if str(k).startswith("constitutive/") and str(k).endswith("/implied_delta"):
+            bn = str(k)[len("constitutive/") : -len("/implied_delta")]
+            id_mask = batch_id_masks.get(bn)
+            ni_mask = batch_ni_masks.get(bn)
+            if bn in batch_id_row_ni:
+                row_ni = batch_id_row_ni[bn]
+        coverage_nums[k] = coverage_counts_arrays(
+            v,
+            identifiable_mask=id_mask,
+            not_identifiable_mask=ni_mask,
+            row_not_identifiable=row_ni,
+        )
     dynamic_scale: Dict[str, Any] = {}
     recipe_ok: Dict[str, Any] = {}
     for key, recipe, spec, _is_user in plan.auto_scale:

{moju-2.4.0 → moju-2.4.2}/moju/monitor/evaluation_coverage.py

@@ -4,6 +4,13 @@ Evaluation coverage records for admissibility verdicts.
 Non-finite residual samples (NaN / ±inf) are tolerated by NaN-aware reductions so
 scoring can proceed on the finite subset. Coverage records make that subset
 explicit on every scored item and on the aggregate report.
+
+Identifiability exclusions for implied audits are counted via Moju's own
+identifiability mask (``n_not_identifiable``), not via NaN presence in the
+implied-δ array. A point is not identifiable when required inputs are finite but
+conditioning fails or is undefined; non-finite required inputs stay in the
+selected set and count as ``n_nonfinite``. Selected samples are those that remain
+after ``eval_mask`` and identifiability exclusions.
 """
 
 from __future__ import annotations
@@ -68,18 +75,83 @@ def _sample_flat(arr: Any) -> jnp.ndarray:
     return jnp.asarray(arr).ravel()
 
 
-def count_finite_samples(arr: Any) -> Dict[str, int]:
-    """Host counts of finite / non-finite elements in a residual array."""
+def _align_identifiable_mask(arr: Any, identifiable_mask: Any) -> Optional[jnp.ndarray]:
+    """Broadcast / reshape a spatial identifiability mask onto residual elements."""
+    if identifiable_mask is None:
+        return None
+    a = jnp.asarray(arr)
+    m = jnp.asarray(identifiable_mask).astype(bool)
+    if m.size == a.size:
+        return m.reshape(a.shape)
+    if a.ndim == m.ndim + 1 and a.shape[:-1] == m.shape:
+        return jnp.broadcast_to(m[..., None], a.shape)
+    if a.ndim > m.ndim and a.shape[: m.ndim] == m.shape:
+        trail = a.shape[m.ndim :]
+        return jnp.broadcast_to(m.reshape(m.shape + (1,) * len(trail)), a.shape)
+    return None
+
+
+def count_finite_samples(
+    arr: Any,
+    *,
+    identifiable_mask: Any = None,
+    not_identifiable_mask: Any = None,
+) -> Dict[str, int]:
+    """
+    Host counts of finite / non-finite elements in a residual array.
+
+    ``not_identifiable_mask`` (preferred) marks scoring-path exclusions where
+    required inputs are finite but conditioning fails or is undefined; those
+    points become ``n_not_identifiable``. Remaining points are selected: residual
+    non-finites count as ``n_nonfinite`` (typically non-finite required inputs).
+
+    Legacy ``identifiable_mask`` (True = scoring-identifiable) is still accepted:
+    ``n_not_identifiable`` is then ``~identifiable_mask``, which conflates NI with
+    input non-finites — prefer ``not_identifiable_mask`` when available.
+    """
     a = _sample_flat(arr)
     n = int(a.size)
     if n == 0:
-        return {"n_selected": 0, "n_finite": 0, "n_nonfinite": 0}
-    finite = jnp.isfinite(a)
-    n_finite = int(jnp.sum(finite))
+        return {
+            "n_selected": 0,
+            "n_finite": 0,
+            "n_nonfinite": 0,
+            "n_not_identifiable": 0,
+        }
+    ni_aligned = _align_identifiable_mask(arr, not_identifiable_mask)
+    if ni_aligned is not None:
+        ni = _sample_flat(ni_aligned)
+        n_ni = int(jnp.sum(ni))
+        selected = a[~ni]
+        n_sel = int(selected.size)
+        n_finite = int(jnp.sum(jnp.isfinite(selected))) if n_sel else 0
+        return {
+            "n_selected": n_sel,
+            "n_finite": n_finite,
+            "n_nonfinite": n_sel - n_finite,
+            "n_not_identifiable": n_ni,
+        }
+    # Legacy fallback: identifiable_mask True = selected.
+    aligned = _align_identifiable_mask(arr, identifiable_mask)
+    if aligned is None:
+        finite = jnp.isfinite(a)
+        n_finite = int(jnp.sum(finite))
+        return {
+            "n_selected": n,
+            "n_finite": n_finite,
+            "n_nonfinite": n - n_finite,
+            "n_not_identifiable": 0,
+        }
+    m = _sample_flat(aligned)
+    n_ni = int(jnp.sum(~m))
+    selected = a[m]
+    n_sel = int(selected.size)
+    n_finite = int(jnp.sum(jnp.isfinite(selected))) if n_sel else 0
     return {
-        "n_selected": n,
+        "n_selected": n_sel,
         "n_finite": n_finite,
-        "n_nonfinite": n - n_finite,
+        "n_nonfinite": n_sel - n_finite,
+        "n_not_identifiable": n_ni,
     }
 
 
@@ -89,12 +161,14 @@ def coverage_record_from_counts(
     n_masked: int,
     n_finite: int,
     n_nonfinite: int,
+    n_not_identifiable: int = 0,
     eval_mask_label: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Build a JSON-serialisable coverage record from integer counts."""
     n_total_i = int(n_total)
     n_masked_i = max(0, int(n_masked))
-    n_selected = n_total_i - n_masked_i
+    n_ni_i = max(0, int(n_not_identifiable))
+    n_selected = n_total_i - n_masked_i - n_ni_i
     if n_selected < 0:
         n_selected = 0
     # Prefer explicit finite/nonfinite; clamp to selected.
@@ -110,6 +184,7 @@ def coverage_record_from_counts(
     rec: Dict[str, Any] = {
         "n_total": n_total_i,
         "n_masked": n_masked_i,
+        "n_not_identifiable": n_ni_i,
         "n_selected": int(n_selected),
         "n_finite": int(n_fin),
         "n_nonfinite": int(n_non),
@@ -127,6 +202,9 @@ def coverage_from_residual(
     eval_mask_label: Optional[str] = None,
     n_total: Optional[int] = None,
     n_masked: Optional[int] = None,
+    identifiable_mask: Any = None,
+    not_identifiable_mask: Any = None,
+    row_not_identifiable: bool = False,
 ) -> Dict[str, Any]:
     """
     Coverage for one residual array.
@@ -135,31 +213,95 @@ def coverage_from_residual(
     size / excluded count; ``arr`` must already be restricted to selected points
     (as produced by :func:`moju.monitor.eval_mask.mask_flat_residuals`).
     Masked samples never count as non-finite.
+
+    ``not_identifiable_mask`` (from the scoring conditioning path) marks points that
+    are not identifiable (finite inputs, conditioning fails or undefined); residual
+    non-finites among the remaining points count as ``n_nonfinite``. When
+    ``row_not_identifiable`` is True (row-level wipe), every remaining sample after
+    ``eval_mask`` is counted as not-identifiable.
     """
-    counts = count_finite_samples(arr)
     m = _as_bool_mask(eval_mask)
     if m is not None:
         n_tot = int(n_total) if n_total is not None else int(m.size)
         n_msk = int(n_masked) if n_masked is not None else int(n_tot - int(jnp.sum(m)))
     else:
-        n_tot = int(n_total) if n_total is not None else int(counts["n_selected"])
+        base_n = int(jnp.asarray(arr).size)
+        n_tot = int(n_total) if n_total is not None else base_n
         n_msk = int(n_masked) if n_masked is not None else 0
+
+    if row_not_identifiable:
+        n_remain = max(0, n_tot - n_msk)
+        return coverage_record_from_counts(
+            n_total=n_tot,
+            n_masked=n_msk,
+            n_finite=0,
+            n_nonfinite=0,
+            n_not_identifiable=n_remain,
+            eval_mask_label=eval_mask_label,
+        )
+
+    counts = count_finite_samples(
+        arr,
+        identifiable_mask=identifiable_mask,
+        not_identifiable_mask=not_identifiable_mask,
+    )
     return coverage_record_from_counts(
         n_total=n_tot,
         n_masked=n_msk,
         n_finite=counts["n_finite"],
         n_nonfinite=counts["n_nonfinite"],
+        n_not_identifiable=counts["n_not_identifiable"],
         eval_mask_label=eval_mask_label,
     )
 
 
-def coverage_counts_arrays(arr: Any) -> Dict[str, Any]:
+def coverage_counts_arrays(
+    arr: Any,
+    *,
+    identifiable_mask: Any = None,
+    not_identifiable_mask: Any = None,
+    row_not_identifiable: Any = False,
+) -> Dict[str, Any]:
     """Tracer-safe finite / size counts for jit/vmap (0-d arrays)."""
     a = _sample_flat(arr)
     n = jnp.asarray(a.size, dtype=jnp.int32)
-    n_finite = jnp.sum(jnp.isfinite(a)).astype(jnp.int32)
-    n_nonfinite = (n - n_finite).astype(jnp.int32)
-    return {"n_selected": n, "n_finite": n_finite, "n_nonfinite": n_nonfinite}
+    zero = jnp.asarray(0, dtype=jnp.int32)
+    row_ni = jnp.asarray(row_not_identifiable, dtype=bool)
+
+    ni_aligned = _align_identifiable_mask(arr, not_identifiable_mask)
+    if ni_aligned is not None:
+        ni = _sample_flat(ni_aligned)
+        n_ni_raw = jnp.sum(ni).astype(jnp.int32)
+        selected = ~ni
+        n_sel_raw = jnp.sum(selected).astype(jnp.int32)
+        n_finite_raw = jnp.sum(jnp.isfinite(a) & selected).astype(jnp.int32)
+        n_non_raw = (n_sel_raw - n_finite_raw).astype(jnp.int32)
+    else:
+        aligned = _align_identifiable_mask(arr, identifiable_mask)
+        if aligned is None:
+            n_finite_raw = jnp.sum(jnp.isfinite(a)).astype(jnp.int32)
+            n_non_raw = (n - n_finite_raw).astype(jnp.int32)
+            n_sel_raw = n
+            n_ni_raw = zero
+        else:
+            m = _sample_flat(aligned)
+            n_ni_raw = jnp.sum(~m).astype(jnp.int32)
+            selected_finite = jnp.isfinite(a) & m
+            n_finite_raw = jnp.sum(selected_finite).astype(jnp.int32)
+            n_sel_raw = jnp.sum(m).astype(jnp.int32)
+            n_non_raw = (n_sel_raw - n_finite_raw).astype(jnp.int32)
+
+    # Row-level NI wipe: every element is not-identifiable for scoring.
+    n_sel = jnp.where(row_ni, zero, n_sel_raw)
+    n_finite = jnp.where(row_ni, zero, n_finite_raw)
+    n_nonfinite = jnp.where(row_ni, zero, n_non_raw)
+    n_ni = jnp.where(row_ni, n, n_ni_raw)
+    return {
+        "n_selected": n_sel,
+        "n_finite": n_finite,
+        "n_nonfinite": n_nonfinite,
+        "n_not_identifiable": n_ni,
+    }
 
 
 def materialize_coverage_counts(
@@ -173,16 +315,48 @@ def materialize_coverage_counts(
     n_sel = int(jnp.asarray(nums["n_selected"]).item())
     n_fin = int(jnp.asarray(nums["n_finite"]).item())
     n_non = int(jnp.asarray(nums["n_nonfinite"]).item())
-    n_tot = int(n_total) if n_total is not None else n_sel + int(n_masked)
+    n_ni = int(jnp.asarray(nums.get("n_not_identifiable", 0)).item())
+    n_tot = int(n_total) if n_total is not None else n_sel + int(n_masked) + n_ni
     return coverage_record_from_counts(
         n_total=n_tot,
         n_masked=n_masked,
         n_finite=n_fin,
         n_nonfinite=n_non,
+        n_not_identifiable=n_ni,
         eval_mask_label=eval_mask_label,
     )
 
 
+def identifiable_masks_from_closure_debug(
+    closure_debug: Optional[Mapping[str, Any]],
+) -> Dict[str, Any]:
+    """
+    Map flat implied_delta keys to pointwise identifiable masks / row-NI flags.
+
+    Returns ``{flat_key: {"mask": array|None, "row_not_identifiable": bool}}``.
+    """
+    from moju.monitor.law_implied_diagnostics import is_not_identifiable
+
+    out: Dict[str, Any] = {}
+    if not isinstance(closure_debug, Mapping):
+        return out
+    for bn, dbg in closure_debug.items():
+        if not isinstance(dbg, Mapping):
+            continue
+        flat_key = f"constitutive/{bn}/implied_delta"
+        row_ni = is_not_identifiable(dbg)
+        out[flat_key] = {
+            # Scoring-identifiable points (legacy fallback for coverage).
+            "mask": None if row_ni else dbg.get("identifiable_mask"),
+            # Finite conditioning failures from the same scoring function.
+            "not_identifiable_mask": None
+            if row_ni
+            else dbg.get("not_identifiable_mask"),
+            "row_not_identifiable": bool(row_ni),
+        }
+    return out
+
+
 def coverage_map_from_flat(
     flat: Mapping[str, Any],
     *,
@@ -190,12 +364,21 @@ def coverage_map_from_flat(
     eval_mask_label: Optional[str] = None,
     mask_meta: Optional[Mapping[str, Any]] = None,
     unmasked_flat: Optional[Mapping[str, Any]] = None,
+    identifiable_by_key: Optional[Mapping[str, Any]] = None,
+    closure_debug: Optional[Mapping[str, Any]] = None,
 ) -> Dict[str, Dict[str, Any]]:
     """Build per-key coverage for a flat residual map (post-mask if applicable).
 
     Supply ``unmasked_flat`` to count exclusions in residual-element units,
     including trailing components and keys to which the mask did not apply.
+
+    ``identifiable_by_key`` or ``closure_debug`` supplies per-key identifiability
+    masks so NI-gated NaNs are not counted as ``n_nonfinite``.
     """
+    id_info = dict(identifiable_by_key or {})
+    if closure_debug is not None:
+        id_info.update(identifiable_masks_from_closure_debug(closure_debug))
+
     n_total: Optional[int] = None
     n_masked = 0
     if mask_meta:
@@ -223,12 +406,37 @@ def coverage_map_from_flat(
         if unmasked_flat is not None and key in unmasked_flat:
             key_total = int(jnp.asarray(unmasked_flat[key]).size)
             key_masked = key_total - int(jnp.asarray(arr).size)
+
+        id_meta = id_info.get(str(key)) if id_info else None
+        id_mask = None
+        ni_mask = None
+        row_ni = False
+        if isinstance(id_meta, Mapping):
+            row_ni = bool(id_meta.get("row_not_identifiable"))
+
+            def _maybe_eval_mask(raw: Any) -> Any:
+                if raw is None or row_ni:
+                    return None
+                if eval_mask is None:
+                    return raw
+                try:
+                    from moju.monitor.eval_mask import apply_mask_to_residual
+
+                    return apply_mask_to_residual(raw, eval_mask)
+                except (ValueError, TypeError):
+                    return raw
+
+            id_mask = _maybe_eval_mask(id_meta.get("mask"))
+            ni_mask = _maybe_eval_mask(id_meta.get("not_identifiable_mask"))
         out[str(key)] = coverage_from_residual(
             arr,
             eval_mask=eval_mask,
             eval_mask_label=eval_mask_label,
             n_total=key_total,
             n_masked=key_masked,
+            identifiable_mask=id_mask,
+            not_identifiable_mask=ni_mask,
+            row_not_identifiable=row_ni,
         )
     return out
 
@@ -237,10 +445,11 @@ def aggregate_coverage(per_key: Mapping[str, Mapping[str, Any]]) -> Dict[str, An
     """Roll up per-key coverage into one aggregate record."""
     if not per_key:
         return coverage_record_from_counts(
-            n_total=0, n_masked=0, n_finite=0, n_nonfinite=0
+            n_total=0, n_masked=0, n_finite=0, n_nonfinite=0, n_not_identifiable=0
         )
     n_total = 0
     n_masked = 0
+    n_ni = 0
     n_finite = 0
     n_nonfinite = 0
     statuses = []
@@ -250,6 +459,7 @@ def aggregate_coverage(per_key: Mapping[str, Mapping[str, Any]]) -> Dict[str, An
             continue
         n_total += int(rec.get("n_total") or 0)
         n_masked += int(rec.get("n_masked") or 0)
+        n_ni += int(rec.get("n_not_identifiable") or 0)
         n_finite += int(rec.get("n_finite") or 0)
         n_nonfinite += int(rec.get("n_nonfinite") or 0)
         statuses.append(str(rec.get("coverage_status") or "ok"))
@@ -263,6 +473,7 @@ def aggregate_coverage(per_key: Mapping[str, Mapping[str, Any]]) -> Dict[str, An
         n_masked=n_masked,
         n_finite=n_finite,
         n_nonfinite=n_nonfinite,
+        n_not_identifiable=n_ni,
         eval_mask_label=label,
     )
     out["coverage_status"] = status
@@ -331,6 +542,7 @@ __all__ = [
     "coverage_record_from_counts",
     "coverage_status",
     "finite_score_or_none",
+    "identifiable_masks_from_closure_debug",
     "is_incomplete_key",
     "materialize_coverage_counts",
     "validate_nonfinite_policy",

{moju-2.4.0 → moju-2.4.2}/moju/monitor/law_implied_diagnostics.py

@@ -104,6 +104,15 @@ def _vec_norm_last(x: Any) -> jnp.ndarray:
     return jnp.sqrt(jnp.sum(a**2, axis=-1) + 1e-30)
 
 
+def _inputs_finite_at_points(arr: Any, point_ndim: int) -> jnp.ndarray:
+    """True where every component of ``arr`` is finite at each leading point index."""
+    a = jnp.asarray(arr)
+    fin = jnp.isfinite(a)
+    if a.ndim > point_ndim:
+        fin = fin.all(axis=tuple(range(point_ndim, a.ndim)))
+    return fin
+
+
 def _re_from_viscosity(
     U: Any,
     L: Any,
@@ -232,13 +241,32 @@ def _apply_viscosity_conditioning(
         tmax = jnp.maximum(tmax, _vec_norm_last(term))
     term_fraction = jnp.where(tmax > 0, pt / tmax, jnp.zeros_like(pt))
 
-    mask = (
+    # Classify by inputs first, then by the conditioning test (2.4.2):
+    # - non-finite: any required input (rhs / basis / balance terms) is non-finite
+    # - not identifiable: inputs finite, but conditioning fails *or* is undefined
+    #   (e.g. 0/0 → non-finite β / fit_quality from perfectly finite inputs)
+    # - selected: inputs finite and conditioning defined and passes thresholds
+    # β itself is *derived* and must not drive the non-finite bucket.
+    point_ndim = int(b.ndim)
+    inputs_finite = _inputs_finite_at_points(rhs_a, point_ndim) & _inputs_finite_at_points(
+        ba, point_ndim
+    )
+    for term in balance_terms:
+        if term is None:
+            continue
+        inputs_finite = inputs_finite & _inputs_finite_at_points(term, point_ndim)
+    conditioning_defined = (
         jnp.isfinite(fit_quality)
         & jnp.isfinite(term_fraction)
         & jnp.isfinite(b)
-        & (fit_quality >= float(fit_threshold))
-        & (term_fraction >= float(term_threshold))
     )
+    passes_thresholds = (fit_quality >= float(fit_threshold)) & (
+        term_fraction >= float(term_threshold)
+    )
+    # Scoring gate (same points used for β wipe / n_identifiable).
+    mask = inputs_finite & conditioning_defined & passes_thresholds
+    # Coverage NI exclusions (same function; not a parallel reimplementation).
+    not_identifiable_mask = inputs_finite & ~(conditioning_defined & passes_thresholds)
     # Keep counts / flags as JAX arrays so this path is jit/vmap-safe. Host code
     # converts with bool()/int() when building reports outside a transform.
     n_tot = int(mask.size)  # static shape → concrete Python int
@@ -260,6 +288,10 @@ def _apply_viscosity_conditioning(
         "n_identifiable": n_ok,
         "n_total": n_tot,
         "identifiable": identifiable,
+        # Scoring-identifiable points (finite inputs ∧ defined conditioning ∧ thresholds).
+        "identifiable_mask": mask,
+        # Finite inputs where conditioning fails or is undefined — n_not_identifiable.
+        "not_identifiable_mask": not_identifiable_mask,
         # Status string is derived on the host from ``identifiable`` (see
         # ``materialize_identifiability_meta``); do not branch on tracers here.
         "min_identifiable_fraction": float(min_frac),

{moju-2.4.0 → moju-2.4.2}/moju.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moju
-Version: 2.4.0
+Version: 2.4.2
 Summary: Physics admissibility auditing for ML surrogates and simulation data: scores how well predicted fields satisfy governing laws and constitutive relations, with implied-parameter checks and admissibility tiers, for JAX and PyTorch.
 Author-email: "Ifimo Lab (Ifimo Global Solutions LLC)" <lab@ifimoanalytics.com>
 Maintainer-email: "Ifimo Global Solutions LLC (dba Ifimo Lab)" <info@ifimoanalytics.com>
@@ -87,7 +87,7 @@ An evaluation mask excludes all components at each excluded spatial point.
 Audit-scope monitor-log exports preserve the non-finite policy recorded by
 `audit`, including incomplete per-key verdicts and null scores in JSON series.
 
-NaN-aware reductions may score on the finite subset of a residual. Every scored key and the aggregate now carry an evaluation-coverage record (`n_total`, `n_masked`, `n_selected`, `n_finite`, `n_nonfinite`, `coverage_status`). Default `nonfinite_policy="flag"` keeps scores and tiers unchanged; set `"strict"` to treat incomplete or empty coverage as tier **Incomplete** (not assessable — distinct from **Not identifiable**). Under `"flag"`, a NaN residual is dropped from the score while an infinite residual enters the RMS and drives the score to 0; both are reported as `coverage_status = "incomplete"`. `"strict"` treats NaN and inf identically (null score, Incomplete).
+NaN-aware reductions may score on the finite subset of a residual. Every scored key and the aggregate now carry an evaluation-coverage record (`n_total`, `n_masked`, `n_not_identifiable`, `n_selected`, `n_finite`, `n_nonfinite`, `coverage_status`). Default `nonfinite_policy="flag"` keeps scores and tiers unchanged; set `"strict"` to treat incomplete or empty coverage as tier **Incomplete** (not assessable — distinct from **Not identifiable**). Under `"flag"`, a NaN residual is dropped from the score while an infinite residual enters the RMS and drives the score to 0; both are reported as `coverage_status = "incomplete"`. `"strict"` treats NaN and inf identically (null score, Incomplete). Points excluded by implied-audit identifiability (finite required inputs where the scoring-path conditioning test fails or is undefined) are counted as `n_not_identifiable` (not `n_nonfinite`), so `n_selected = n_total − n_masked − n_not_identifiable`. A point is non-finite only when a required input (or residual component) at that point is non-finite — never because the conditioning ratio alone is non-finite.
 
 **Known limitation.** Coverage counts non-finite values in the residual array. A required input that is non-finite while the law's residual stays finite (for example, a law that applies `jnp.where` or `zeros_like` to that input) is currently reported as `coverage_status = "ok"`. Counting non-finite inputs per sample needs a mapping from input samples to residual samples that holds for scalars, parameters and broadcast shapes; this is planned for a follow-up release.
 

{moju-2.4.0 → moju-2.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "moju"
-version = "2.4.0"
+version = "2.4.2"
 description = "Physics admissibility auditing for ML surrogates and simulation data: scores how well predicted fields satisfy governing laws and constitutive relations, with implied-parameter checks and admissibility tiers, for JAX and PyTorch."
 readme = "README.md"
 authors = [{ name = "Ifimo Lab (Ifimo Global Solutions LLC)", email = "lab@ifimoanalytics.com" }]