moju 2.3.0__tar.gz → 2.3.2__tar.gz

{moju-2.3.0 → moju-2.3.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: moju
-Version: 2.3.0
-Summary: Physics supervision and audit tools for SciML models, with JAX-native residuals and PyTorch support.
+Version: 2.3.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>
 License: MIT
@@ -12,7 +12,7 @@ Project-URL: Paper, https://zenodo.org/records/20519331
 Project-URL: Changelog, https://github.com/IfimoAI/moju/blob/main/CHANGELOG.md
 Project-URL: Citation, https://github.com/IfimoAI/moju/blob/main/CITATION.cff
 Project-URL: Issues, https://github.com/IfimoAI/moju/issues
-Keywords: physics,jax,torch,pytorch,sciml,pinn,dimensionless,cfd,differentiable,residual
+Keywords: physics-informed machine learning,scientific machine learning,surrogate validation,verification and validation,admissibility,JAX,PyTorch,SciML,PINN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
@@ -49,7 +49,7 @@ Dynamic: license-file
 
 # moju
 
-Physics supervision and audit tools for SciML and Physics AI.
+Moju audits predicted fields against governing-law residuals, constitutive and implied-parameter checks, and optional per-region diagnostics. It reports admissibility scores, qualitative tiers, and scoring provenance so you can see how well a state satisfies the physics you stated. It is for people validating ML surrogates or simulation fields. Secondary capabilities include composing laws, models, and dimensionless groups, and using governing-law residuals as a training-time loss.
 
 ```bash
 pip install moju

{moju-2.3.0 → moju-2.3.2}/README.md

@@ -1,6 +1,6 @@
 # moju
 
-Physics supervision and audit tools for SciML and Physics AI.
+Moju audits predicted fields against governing-law residuals, constitutive and implied-parameter checks, and optional per-region diagnostics. It reports admissibility scores, qualitative tiers, and scoring provenance so you can see how well a state satisfies the physics you stated. It is for people validating ML surrogates or simulation fields. Secondary capabilities include composing laws, models, and dimensionless groups, and using governing-law residuals as a training-time loss.
 
 ```bash
 pip install moju

{moju-2.3.0 → moju-2.3.2}/moju/__init__.py

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

{moju-2.3.0 → moju-2.3.2}/moju/monitor/auditor.py

@@ -805,7 +805,9 @@ def _compute_log_step_metrics(
                     key_report["r_max"] = imp_score.get("r_max_raw")
             if id_meta is not None:
                 # Explicit per-key sidecar: never treat as passing; rollup skips this key.
+                # Score is null (not 0.0 / NaN) so JSON exports stay strict-compliant.
                 key_report["identifiability_status"] = "not_identifiable"
+                key_report["admissibility_score"] = None
                 key_report["excluded_fraction"] = id_meta.get("excluded_fraction")
                 key_report["n_identifiable"] = id_meta.get("n_identifiable")
                 key_report["n_total"] = id_meta.get("n_total")
@@ -831,6 +833,12 @@ def _compute_log_step_metrics(
             category_failed = False
             for kk in keys:
                 # Skip not-identifiable implied rows — they must not zero the category.
+                kr = per_key_report.get(kk) or {}
+                if (
+                    kr.get("identifiability_status") == "not_identifiable"
+                    or kr.get("admissibility_level") == "Not identifiable"
+                ):
+                    continue
                 if (
                     isinstance(id_map_entry, dict)
                     and kk.startswith("constitutive/")
@@ -1461,6 +1469,9 @@ def _worst_keys_table_rows(
                 row["r_max_raw"] = rep.get("r_max_raw")
         if is_ni:
             row["admissibility_level"] = "Not identifiable"
+            # Missing score → null in JSON (never NaN / 0.0).
+            row["admissibility"] = None
+            row["admissibility_score"] = None
             if rep.get("excluded_fraction") is not None:
                 row["excluded_fraction"] = rep.get("excluded_fraction")
             if rep.get("identifiability_reason"):

{moju-2.3.0 → moju-2.3.2}/moju/monitor/evaluate_batch.py

@@ -105,7 +105,10 @@ def evaluate_batched(
         resolve_implied_scoring_options,
         score_from_r_max,
     )
-    from moju.monitor.law_implied_diagnostics import _gate_params
+    from moju.monitor.law_implied_diagnostics import (
+        _gate_params,
+        materialize_identifiability_meta,
+    )
     from moju.monitor.regions import (
         DEFAULT_REGION_MIN_POINTS,
         normalize_regions,
@@ -281,6 +284,16 @@ def evaluate_batched(
                 score_from_r_max=score_from_r_max,
             )
             ms["regions"] = entry["region_results"].get("provenance")
+        # Host-side: materialise not-identifiable flags so audit rollup matches
+        # the loop / ResidualEngine path (NaN implied scores must not zero the tier).
+        if "implied_id" in out:
+            id_map: Dict[str, Any] = {}
+            for bn, nums in out["implied_id"].items():
+                compact: Dict[str, Any] = {}
+                for sk, arr in nums.items():
+                    compact[sk] = jnp.asarray(arr)[i]
+                id_map[str(bn)] = materialize_identifiability_meta(compact)
+            entry["implied_identifiability"] = id_map
         entry["monitor_settings"] = ms
         report = audit([entry], r_ref=r_ref)
         if return_residuals:
@@ -437,6 +450,8 @@ def _score_one(
     visc_fq = None
     visc_scale = None
     implied_debug: Dict[str, Dict[str, Any]] = {}
+    # Tracer-safe identifiability scalars (status strings materialised on the host).
+    implied_id: Dict[str, Dict[str, Any]] = {}
     for audit_spec in plan.audits:
         spec = audit_spec["spec"]
         reg = audit_spec["reg"]
@@ -481,6 +496,23 @@ def _score_one(
                         side[sk] = jnp.asarray(dbg[sk])
                 if side:
                     implied_debug[key] = side
+                if "identifiable" in dbg or dbg.get("status") == "not_identifiable":
+                    pack: Dict[str, Any] = {}
+                    if "identifiable" in dbg:
+                        pack["identifiable"] = jnp.asarray(dbg["identifiable"])
+                    elif dbg.get("status") == "not_identifiable":
+                        pack["identifiable"] = jnp.asarray(False)
+                    for sk in (
+                        "excluded_fraction",
+                        "n_identifiable",
+                        "n_total",
+                        "conditioning_threshold",
+                        "fit_quality_threshold",
+                    ):
+                        if dbg.get(sk) is not None:
+                            pack[sk] = jnp.asarray(dbg[sk])
+                    if pack:
+                        implied_id[str(base)] = pack
                 if (
                     dbg.get("noise_rhs") is not None
                     and dbg.get("noise_basis") is not None
@@ -550,6 +582,8 @@ def _score_one(
         "scale": dynamic_scale,
         "recipe_ok": recipe_ok,
     }
+    if implied_id:
+        out["implied_id"] = implied_id
 
     if apply_optin:
         # Global opt-in: same arithmetic as score_implied_delta_array, jit-safe.
@@ -712,9 +746,9 @@ def _assemble_region_results(
                 key_row.update(
                     {
                         "status": "insufficient_points",
-                        "admissibility_score": float("nan"),
+                        "admissibility_score": None,
                         "admissibility_level": "Insufficient points",
-                        "score_for_admissibility": float("nan"),
+                        "score_for_admissibility": None,
                         "worst_point_index": None,
                         "reason": flags.get("reason"),
                     }
@@ -728,7 +762,7 @@ def _assemble_region_results(
                 key_row.update(
                     {
                         "status": vis_status,
-                        "admissibility_score": float("nan"),
+                        "admissibility_score": None,
                         "admissibility_level": (
                             "Insufficient points"
                             if vis_status == "insufficient_points"

{moju-2.3.0 → moju-2.3.2}/moju/monitor/regions.py

@@ -671,9 +671,9 @@ def compute_region_results(
                 key_row.update(
                     {
                         "status": "insufficient_points",
-                        "admissibility_score": float("nan"),
+                        "admissibility_score": None,
                         "admissibility_level": "Insufficient points",
-                        "score_for_admissibility": float("nan"),
+                        "score_for_admissibility": None,
                         "worst_point_index": None,
                         "reason": region_reason,
                     }
@@ -692,7 +692,7 @@ def compute_region_results(
                     key_row.update(
                         {
                             "status": "insufficient_points",
-                            "admissibility_score": float("nan"),
+                            "admissibility_score": None,
                             "admissibility_level": "Insufficient points",
                             "nu_tilde": viscosity_meta.get("nu_tilde"),
                             "mu_tilde": viscosity_meta.get("mu_tilde"),
@@ -708,7 +708,7 @@ def compute_region_results(
                     key_row.update(
                         {
                             "status": "not_identifiable",
-                            "admissibility_score": float("nan"),
+                            "admissibility_score": None,
                             "admissibility_level": "Not identifiable",
                             "nu_tilde": viscosity_meta.get("nu_tilde"),
                             "mu_tilde": viscosity_meta.get("mu_tilde"),

{moju-2.3.0 → moju-2.3.2}/moju/monitor/report.py

@@ -99,29 +99,60 @@ def _group_keys_by_category(per_key: Dict[str, Any]) -> List[Tuple[str, List[Tup
     return result
 
 
-def _residual_dict_to_json_serializable(residual_dict: Dict[str, Any]) -> Dict[str, Any]:
-    """Recursively convert residual dict (JAX/NumPy arrays) to JSON-serializable lists."""
+def _json_safe_value(val: Any) -> Any:
+    """Convert arrays / nested structures to JSON-safe Python; non-finite floats → ``None``."""
     try:
         import jax
     except ImportError:
         jax = None
     import numpy as np
 
-    out: Dict[str, Any] = {}
-    for key, val in residual_dict.items():
-        if isinstance(val, dict):
-            out[key] = _residual_dict_to_json_serializable(val)
-        elif hasattr(val, "tolist"):
-            try:
-                arr = val
-                if jax is not None and hasattr(arr, "__jax_array__"):
+    if val is None or isinstance(val, (str, bool)):
+        return val
+    if isinstance(val, dict):
+        return {str(k): _json_safe_value(v) for k, v in val.items()}
+    if isinstance(val, (list, tuple)):
+        return [_json_safe_value(v) for v in val]
+    if isinstance(val, (int,)) and not isinstance(val, bool):
+        return int(val)
+    if isinstance(val, float):
+        return val if math.isfinite(val) else None
+    if hasattr(val, "tolist"):
+        try:
+            arr = val
+            if jax is not None:
+                try:
                     arr = jax.device_get(arr)
-                out[key] = np.asarray(arr).tolist()
-            except Exception:
-                out[key] = str(val)
-        else:
-            out[key] = val
-    return out
+                except Exception:
+                    pass
+            # 0-d numpy / jax scalars
+            as_np = np.asarray(arr)
+            if as_np.shape == ():
+                try:
+                    f = float(as_np.item())
+                except (TypeError, ValueError):
+                    return as_np.item()
+                return f if math.isfinite(f) else None
+            return _json_safe_value(as_np.tolist())
+        except Exception:
+            return str(val)
+    try:
+        f = float(val)
+    except (TypeError, ValueError):
+        return val
+    return f if math.isfinite(f) else None
+
+
+def _residual_dict_to_json_serializable(residual_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Recursively convert residual dict (JAX/NumPy arrays) to JSON-serializable values.
+
+    Non-finite floats (``NaN`` / ``±Inf``) become ``None`` (JSON ``null``) so
+    ``json.dumps(..., allow_nan=False)`` succeeds. Used by residual JSON writers
+    and :func:`moju.monitor.monitor_log_export.monitor_log_export_to_jsonable`.
+    """
+    if not isinstance(residual_dict, dict):
+        return _json_safe_value(residual_dict)  # type: ignore[return-value]
+    return {str(k): _json_safe_value(v) for k, v in residual_dict.items()}
 
 
 def write_residuals_json(residual_dict: Dict[str, Any], path: str) -> None:
@@ -515,7 +546,13 @@ def write_audit_pdf(
         for label, data in items:
             score = data.get("admissibility_score", 0.0)
             level = data.get("admissibility_level", "Non-Admissible")
-            score_s = format_admissibility_pct(float(score)) if level != "Not identifiable" else "N/A"
+            if (
+                level in ("Not identifiable", "Insufficient points")
+                or score is None
+            ):
+                score_s = "N/A"
+            else:
+                score_s = format_admissibility_pct(float(score))
             if level == "Not identifiable" and data.get("excluded_fraction") is not None:
                 try:
                     excl_pct = 100.0 * float(data["excluded_fraction"])

{moju-2.3.0 → moju-2.3.2}/moju.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: moju
-Version: 2.3.0
-Summary: Physics supervision and audit tools for SciML models, with JAX-native residuals and PyTorch support.
+Version: 2.3.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>
 License: MIT
@@ -12,7 +12,7 @@ Project-URL: Paper, https://zenodo.org/records/20519331
 Project-URL: Changelog, https://github.com/IfimoAI/moju/blob/main/CHANGELOG.md
 Project-URL: Citation, https://github.com/IfimoAI/moju/blob/main/CITATION.cff
 Project-URL: Issues, https://github.com/IfimoAI/moju/issues
-Keywords: physics,jax,torch,pytorch,sciml,pinn,dimensionless,cfd,differentiable,residual
+Keywords: physics-informed machine learning,scientific machine learning,surrogate validation,verification and validation,admissibility,JAX,PyTorch,SciML,PINN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
@@ -49,7 +49,7 @@ Dynamic: license-file
 
 # moju
 
-Physics supervision and audit tools for SciML and Physics AI.
+Moju audits predicted fields against governing-law residuals, constitutive and implied-parameter checks, and optional per-region diagnostics. It reports admissibility scores, qualitative tiers, and scoring provenance so you can see how well a state satisfies the physics you stated. It is for people validating ML surrogates or simulation fields. Secondary capabilities include composing laws, models, and dimensionless groups, and using governing-law residuals as a training-time loss.
 
 ```bash
 pip install moju

{moju-2.3.0 → moju-2.3.2}/moju.egg-info/SOURCES.txt

@@ -108,6 +108,7 @@ tests/test_models.py
 tests/test_monitor_log_export.py
 tests/test_nondim.py
 tests/test_nondim_inference.py
+tests/test_not_identifiable_tier.py
 tests/test_notebooks_media.py
 tests/test_operators.py
 tests/test_paper_goldens.py

{moju-2.3.0 → moju-2.3.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "moju"
-version = "2.3.0"
-description = "Physics supervision and audit tools for SciML models, with JAX-native residuals and PyTorch support."
+version = "2.3.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" }]
 maintainers = [
@@ -13,7 +13,17 @@ maintainers = [
 ]
 license = { text = "MIT" }
 requires-python = ">=3.10"
-keywords = ["physics", "jax", "torch", "pytorch", "sciml", "pinn", "dimensionless", "cfd", "differentiable", "residual"]
+keywords = [
+    "physics-informed machine learning",
+    "scientific machine learning",
+    "surrogate validation",
+    "verification and validation",
+    "admissibility",
+    "JAX",
+    "PyTorch",
+    "SciML",
+    "PINN",
+]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Science/Research",

{moju-2.3.0 → moju-2.3.2}/tests/test_evaluate_regions_batched.py

@@ -52,10 +52,13 @@ def _region_snapshot(rep: dict) -> dict:
     for name, block in rr.items():
         pk = block["per_key"][_MU_KEY]
         vis = block.get("viscosity") or {}
+        raw_score = pk.get("admissibility_score")
+        try:
+            score_f = float(raw_score) if raw_score is not None else float("nan")
+        except (TypeError, ValueError):
+            score_f = float("nan")
         out[name] = {
-            "score": float(pk["admissibility_score"])
-            if math.isfinite(float(pk.get("admissibility_score", float("nan"))))
-            else float("nan"),
+            "score": score_f if math.isfinite(score_f) else float("nan"),
             "v_eff": float(pk.get("score_for_admissibility", float("nan")))
             if pk.get("score_for_admissibility") is not None
             else float("nan"),

moju-2.3.2/tests/test_not_identifiable_tier.py

@@ -0,0 +1,247 @@
+"""Not-identifiable implied laws must not drive the overall tier (2.1 semantics / 2.3.1 fix)."""
+
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+
+import jax
+
+jax.config.update("jax_enable_x64", True)
+
+import jax.numpy as jnp
+import numpy as np
+import pytest
+
+from moju.monitor import ResidualEngine, audit, evaluate
+from moju.monitor.analytic_flows import ns_state_from_analytic, taylor_green_2d
+
+ROOT = Path(__file__).resolve().parents[1]
+GOLDEN = ROOT / "tests" / "goldens" / "not_identifiable" / "tg_re100.json"
+
+_NI_KEY = "constitutive/dynamic_viscosity_from_re/law_momentum_navier_stokes/implied_delta"
+_NI_BN = "dynamic_viscosity_from_re/law_momentum_navier_stokes"
+_LAW_KEY = "laws/momentum_navier_stokes"
+
+
+def _ns_sm():
+    return {
+        "u_t": "u_t",
+        "u": "u",
+        "u_grad": "u_grad",
+        "p_grad": "p_grad",
+        "u_laplacian": "u_laplacian",
+        "re": "re",
+    }
+
+
+def _ni_state(*, re: float = 100.0, mu: float = 0.01, n: int = 32, t: float = 0.1):
+    xs = jnp.linspace(0.0, 2.0 * jnp.pi, n, endpoint=False)
+    x, y = jnp.meshgrid(xs, xs, indexing="ij")
+    fields = taylor_green_2d(x, y, t, re=re)
+    state = ns_state_from_analytic(fields, x, y, t=t)
+    state.update({"rho": 1.0, "U": 1.0, "L": 1.0, "mu": mu, "re": re})
+    return state, x
+
+
+def _identifiable_state(*, re: float = 10.0, mu: float = 0.1, n: int = 32, t: float = 0.1):
+    return _ni_state(re=re, mu=mu, n=n, t=t)
+
+
+def _engine(**kwargs):
+    return ResidualEngine(
+        laws=[{"name": "momentum_navier_stokes", "state_map": _ns_sm()}],
+        law_implied_audits=True,
+        constants={"rho": 1.0, "U": 1.0, "L": 1.0},
+        **kwargs,
+    )
+
+
+def _assert_ni_semantics(report: dict, *, golden: dict | None = None) -> None:
+    exp = (golden or json.loads(GOLDEN.read_text()))["expected"]
+    pk = report["per_key"][_NI_KEY]
+    assert pk["admissibility_level"] == exp["implied_admissibility_level"]
+    assert pk.get("identifiability_status") == exp["identifiability_status"]
+    assert pk["admissibility_score"] is None
+    assert pk["admissibility_score"] == exp["implied_admissibility_score"]
+    assert report["per_key"][_LAW_KEY]["admissibility_level"].startswith(
+        exp["law_admissibility_level_prefix"]
+    )
+    assert report["overall_admissibility_level"].startswith(
+        exp["overall_admissibility_level_prefix"]
+    )
+    id_map = report.get("implied_identifiability") or {}
+    assert id_map[_NI_BN]["status"] == "not_identifiable"
+    cats = report.get("per_category") or {}
+    if exp["constitutive_category_absent_or_nonzero"]:
+        assert "constitutive" not in cats or (
+            math.isfinite(float(cats["constitutive"])) and float(cats["constitutive"]) != 0.0
+        )
+
+
+def test_golden_fixture_documents_expected_tier():
+    golden = json.loads(GOLDEN.read_text())
+    assert golden["keys"]["implied"] == _NI_KEY
+    assert golden["expected"]["overall_admissibility_level_prefix"] == "High"
+
+
+def test_audit_not_identifiable_matches_golden():
+    golden = json.loads(GOLDEN.read_text())
+    state, _ = _ni_state()
+    eng = _engine()
+    eng.compute_residuals(state, weighted_norms=False)
+    _assert_ni_semantics(audit(eng.log), golden=golden)
+
+
+def test_evaluate_loop_not_identifiable_matches_golden():
+    golden = json.loads(GOLDEN.read_text())
+    state, _ = _ni_state()
+    reports = evaluate(_engine(), [state], weighted_norms=False, evaluate_debug_loop=True)
+    assert reports[0].get("execution") == "loop"
+    _assert_ni_semantics(reports[0], golden=golden)
+
+
+def test_evaluate_batched_not_identifiable_matches_golden():
+    golden = json.loads(GOLDEN.read_text())
+    state, _ = _ni_state()
+    reports = evaluate(_engine(), [state], weighted_norms=False)
+    assert reports[0].get("execution") == "batched"
+    _assert_ni_semantics(reports[0], golden=golden)
+
+
+def test_evaluate_batched_with_regions_not_identifiable_matches_golden():
+    golden = json.loads(GOLDEN.read_text())
+    state, x = _ni_state()
+    near = np.asarray(x < jnp.pi)
+    regions = {"near": near, "far": ~near}
+    eng = _engine(regions=regions, region_min_points=8)
+    reports = evaluate(
+        eng, [state], weighted_norms=False, regions=regions, region_min_points=8
+    )
+    assert reports[0].get("execution") == "batched"
+    _assert_ni_semantics(reports[0], golden=golden)
+    for name, blk in reports[0]["region_results"]["regions"].items():
+        pk = blk["per_key"][_NI_KEY]
+        assert pk["admissibility_level"] == "Not identifiable", name
+        assert pk.get("status") == "not_identifiable", name
+        assert pk["admissibility_score"] is None, name
+        assert blk["viscosity"]["status"] == "not_identifiable", name
+
+
+def test_batched_vs_loop_equality_including_not_identifiable():
+    state, _ = _ni_state()
+    eng = _engine()
+    loop = evaluate(eng, [state], weighted_norms=False, evaluate_debug_loop=True)[0]
+    bat = evaluate(eng, [state], weighted_norms=False)[0]
+    assert bat["execution"] == "batched"
+    assert loop["overall_admissibility_level"] == bat["overall_admissibility_level"]
+    assert loop["overall_admissibility_score"] == pytest.approx(
+        bat["overall_admissibility_score"], rel=0, abs=1e-12
+    )
+    assert loop["per_key"][_NI_KEY]["admissibility_level"] == bat["per_key"][_NI_KEY][
+        "admissibility_level"
+    ]
+    assert loop["per_category"].keys() == bat["per_category"].keys()
+    for cat in loop["per_category"]:
+        assert loop["per_category"][cat] == pytest.approx(bat["per_category"][cat])
+
+
+def test_mixed_batch_identifiable_and_not_identifiable():
+    ni, _ = _ni_state()
+    ok, _ = _identifiable_state()
+    reports = evaluate(_engine(), [ni, ok], weighted_norms=False)
+    assert reports[0]["execution"] == "batched"
+    _assert_ni_semantics(reports[0])
+    pk_ok = reports[1]["per_key"][_NI_KEY]
+    assert pk_ok["admissibility_level"].startswith("High")
+    assert pk_ok.get("identifiability_status") in (None, "ok")
+    assert math.isfinite(float(pk_ok["admissibility_score"]))
+    assert reports[1]["overall_admissibility_level"].startswith("High")
+
+
+def test_insufficient_points_does_not_zero_overall_tier():
+    """Region insufficient_points uses NaN scores locally; global tier stays from scored keys."""
+    state, x = _identifiable_state()
+    tiny = np.zeros(np.asarray(x).shape, dtype=bool)
+    tiny.ravel()[:2] = True
+    regions = {"tiny": tiny, "rest": ~tiny}
+    eng = _engine(regions=regions, region_min_points=16)
+    eng.compute_residuals(state, weighted_norms=False)
+    rep = audit(eng.log)
+    assert rep["overall_admissibility_level"].startswith("High")
+    tiny_blk = rep["region_results"]["regions"]["tiny"]
+    assert tiny_blk["status"] == "insufficient_points"
+    assert tiny_blk["per_key"][_NI_KEY]["admissibility_level"] == "Insufficient points"
+    assert tiny_blk["per_key"][_NI_KEY]["admissibility_score"] is None
+    bat = evaluate(
+        eng, [state], weighted_norms=False, regions=regions, region_min_points=16
+    )[0]
+    assert bat["overall_admissibility_level"].startswith("High")
+    assert bat["region_results"]["regions"]["tiny"]["status"] == "insufficient_points"
+    assert bat["region_results"]["regions"]["tiny"]["per_key"][_NI_KEY][
+        "admissibility_score"
+    ] is None
+
+
+def test_json_export_ni_and_insufficient_scores_are_strict_null():
+    """JSON export must use null (allow_nan=False); never NaN or 0.0."""
+    from moju.monitor.monitor_log_export import (
+        export_monitor_log,
+        monitor_log_export_to_jsonable,
+    )
+
+    state, x = _ni_state()
+    near = np.asarray(x < jnp.pi)
+    tiny = np.zeros(np.asarray(x).shape, dtype=bool)
+    tiny.ravel()[:2] = True
+    regions = {"near": near & ~tiny, "tiny": tiny, "far": ~near}
+    eng = _engine(regions=regions, region_min_points=16)
+    eng.compute_residuals(state, weighted_norms=False)
+    export = export_monitor_log(eng.log, scope="audit", persist=False)
+    blob = monitor_log_export_to_jsonable(export)
+    text = json.dumps(blob, allow_nan=False)
+    parsed = json.loads(text)
+    pk = parsed["summary"]["per_key"][_NI_KEY]
+    assert pk["admissibility_level"] == "Not identifiable"
+    assert pk["admissibility_score"] is None
+    assert pk["admissibility_score"] != 0.0
+    # Batched evaluate export path
+    bat = evaluate(
+        eng, [state], weighted_norms=False, regions=regions, region_min_points=16
+    )[0]
+    # Re-export via a one-step log-shaped summary: dump report through jsonable helper
+    from moju.monitor.report import _residual_dict_to_json_serializable
+
+    bat_json = _residual_dict_to_json_serializable(bat)
+    bat_text = json.dumps(bat_json, allow_nan=False)
+    bat_parsed = json.loads(bat_text)
+    assert bat_parsed["per_key"][_NI_KEY]["admissibility_score"] is None
+    tiny_score = bat_parsed["region_results"]["regions"]["tiny"]["per_key"][_NI_KEY][
+        "admissibility_score"
+    ]
+    assert tiny_score is None
+
+
+def test_equivalent_to_worst_point_does_not_zero_overall_tier():
+    """percentile_status=equivalent_to_worst_point is advisory; scores stay finite."""
+    state, x = _identifiable_state()
+    small = np.zeros(np.asarray(x).shape, dtype=bool)
+    small.ravel()[:10] = True
+    regions = {"small": small, "big": ~small}
+    eng = _engine(
+        regions=regions,
+        region_min_points=8,
+        implied_metric="percentile",
+        implied_percentile=95.0,
+    )
+    eng.compute_residuals(
+        state, weighted_norms=False, implied_metric="percentile", implied_percentile=95.0
+    )
+    rep = audit(eng.log)
+    assert rep["overall_admissibility_level"].startswith("High")
+    small_blk = rep["region_results"]["regions"]["small"]
+    assert small_blk.get("percentile_status") == "equivalent_to_worst_point"
+    assert math.isfinite(float(small_blk["per_key"][_NI_KEY]["admissibility_score"]))
+    assert "constitutive" in (rep.get("per_category") or {})
+    assert float(rep["per_category"]["constitutive"]) != 0.0

{moju-2.3.0 → moju-2.3.2}/tests/test_region_aware_scoring.py

@@ -489,7 +489,9 @@ def test_evaluate_with_regions_uses_batched_jit_vmap():
     assert prov["region_min_points"] == 8
     assert set(prov["region_names"]) == {"far", "near"}
     assert "mask_sha256" in prov
-    assert prov["moju_version"] == "2.3.0"
+    import moju
+
+    assert prov["moju_version"] == moju.__version__
 
 
 def test_mask_hashes_and_region_provenance_in_report_and_json():