ergodic 0.3.1__tar.gz → 0.3.2__tar.gz

{ergodic-0.3.1 → ergodic-0.3.2}/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.2] - 2026-10-24
+
+### Fixed
+- Linear and GCM use `erfc` for normal tails: e.g. z=9 now gives approximately
+  2.26e-19 instead of zero. Values below binary64 range still underflow (z=40);
+  they are not floored or presented as accurately representable probabilities.
+  PCMCI can change its test count: the documented time-series fixture retains
+  all five links, while its unconstrained CI queries change from 49 to 47
+  (the knowledge-constrained run remains at 37).
+- `GraphSamples.top(k)` groups numerical weight ties at relative tolerance 1e-12,
+  then log-target ties at absolute tolerance 1e-9, anchored at each group's largest
+  value, and sorts final ties by named directed-edge tuples. Weights are unchanged.
+- MMPC forward associations within absolute p-value distance 1e-15 now tie by
+  variable name; alpha decisions keep unrounded p-values. This stabilizes greedy
+  admission when tiny tails split, without claiming invariance to variable renaming.
+  On 150 registered seven-node worlds, the tie change alone changed no skeletons
+  (137 total skeleton errors before and after); PC/FCI/RFCI were also unchanged.
+
+### Documentation
+- GCM's default KNN remains uncalibrated. A registered direct-CI study (200 paired
+  seeds per family/sample size) found 7.5–12% null rejection at nominal 5%.
+  OLS failed on nonlinear conditional means, so neither qualified as a general
+  default. Discover and graph-testing guides now disclose the measured limits.
+
 ## [0.3.1] - 2026-10-20
 
 Correctness and inference safeguards from the pre-release audit (API-179 through
@@ -982,7 +1006,8 @@ inference, discovery, process, SCM, and forecast pillars.
   silently with single-graph semantics; it now dispatches on the face, and
   mixed graphs raise instead of being misread.
 
-[Unreleased]: https://github.com/ergodic-ai/ergodic/compare/v0.3.1...HEAD
+[Unreleased]: https://github.com/ergodic-ai/ergodic/compare/v0.3.2...HEAD
+[0.3.2]: https://github.com/ergodic-ai/ergodic/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/ergodic-ai/ergodic/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/ergodic-ai/ergodic/compare/v0.2.1...v0.3.0
 [0.2.1]: https://github.com/ergodic-ai/ergodic/compare/v0.2.0...v0.2.1

{ergodic-0.3.1 → ergodic-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ergodic
-Version: 0.3.1
+Version: 0.3.2
 Summary: Causal AI: causal discovery, causal inference, and process intelligence.
 Project-URL: Homepage, https://docs.ergodic.dev
 Project-URL: Documentation, https://docs.ergodic.dev

{ergodic-0.3.1 → ergodic-0.3.2}/docsite/pages/choose-a-method.md

@@ -171,3 +171,17 @@ and restrict the search to the screen (see
 - [Python reference](reference-discovery.md): every method, test and score.
 
 </div>
+
+!!! caution "GCM learner calibration"
+    The default GCM learner remains KNN; it is not a generally calibrated CI test.
+    A paired 200-seed direct-CI diagnostic at alpha 0.05 found null rejection rates
+    of 9.5%/7.5% (linear), 12%/10% (quadratic), and 10%/9% (sine), at n=200/1000.
+    OLS gave 7.5%/5%, 100%/100%, and 99%/100%, respectively: replacing KNN with
+    OLS would fail badly for these nonlinear conditional means. Neither qualified
+    across all cells of the registered 2–8% investigation band, so the default
+    is unchanged. All cells used 200 trials with zero refusals; 95% Wilson intervals
+    for the KNN rates span roughly 4.6–17.2%. These are direct-CI results, distinct
+    from the earlier ~30% rejection of true graphs by Fisher's combined test.
+    Learner choice must match the conditional mean; these diagnostics do not
+    establish calibration for arbitrary data or guarantee detection of dependence.
+    The reproducible protocol is in `scripts/audits/qualify_gcm.py`.

{ergodic-0.3.1 → ergodic-0.3.2}/docsite/pages/discover-a-graph.md

@@ -150,3 +150,17 @@ decodes the model's edge probabilities locally. See
 - [Python reference](reference-discovery.md): every method and its options.
 
 </div>
+
+!!! caution "GCM learner calibration"
+    The default GCM learner remains KNN; it is not a generally calibrated CI test.
+    A paired 200-seed direct-CI diagnostic at alpha 0.05 found null rejection rates
+    of 9.5%/7.5% (linear), 12%/10% (quadratic), and 10%/9% (sine), at n=200/1000.
+    OLS gave 7.5%/5%, 100%/100%, and 99%/100%, respectively: replacing KNN with
+    OLS would fail badly for these nonlinear conditional means. Neither qualified
+    across all cells of the registered 2–8% investigation band, so the default
+    is unchanged. All cells used 200 trials with zero refusals; 95% Wilson intervals
+    for the KNN rates span roughly 4.6–17.2%. These are direct-CI results, distinct
+    from the earlier ~30% rejection of true graphs by Fisher's combined test.
+    Learner choice must match the conditional mean; these diagnostics do not
+    establish calibration for arbitrary data or guarantee detection of dependence.
+    The reproducible protocol is in `scripts/audits/qualify_gcm.py`.

{ergodic-0.3.1 → ergodic-0.3.2}/docsite/pages/evaluate-a-graph.md

@@ -525,3 +525,10 @@ Nothing touches numpy's global random state, and the same `seed` gives the same
 - [Python reference](reference-discovery.md): `graph_posterior`, `evaluate_graph`, `GraphSamples`.
 
 </div>
+
+`GraphSamples.top(k)` lists the heaviest DAGs first. Weight ties within 1e-12
+relative to the group's maximum are ordered by log target; log-target ties
+within absolute 1e-9 are ordered by sorted named directed edges. Groups are
+anchored at their maximum, not chained through approximate pairwise equality.
+This removes floating-point noise from equivalent-graph ordering without
+rounding returned masses or changing the posterior.

{ergodic-0.3.1 → ergodic-0.3.2}/docsite/pages/install.md

@@ -72,7 +72,7 @@ for module, use in optional.items():
 ```
 
 ```output from="install_check.py" lines="1"
-ergodic 0.3.1 writes ergodic.graph/1
+ergodic 0.3.2 writes ergodic.graph/1
 ```
 
 - **Step 1.** The version, and `ergodic.graph/1`: the format `MixedGraph.to_dict()`

{ergodic-0.3.1 → ergodic-0.3.2}/docsite/pages/test-a-graph.md

@@ -210,3 +210,23 @@ own variables, and they hold in the margin over those variables.
 - [Python reference](reference-discovery.md): `test_graph` and `GraphTest` in full.
 
 </div>
+
+!!! caution "GCM learner calibration"
+    The default GCM learner remains KNN; it is not a generally calibrated CI test.
+    A paired 200-seed direct-CI diagnostic at alpha 0.05 found null rejection rates
+    of 9.5%/7.5% (linear), 12%/10% (quadratic), and 10%/9% (sine), at n=200/1000.
+    OLS gave 7.5%/5%, 100%/100%, and 99%/100%, respectively: replacing KNN with
+    OLS would fail badly for these nonlinear conditional means. Neither qualified
+    across all cells of the registered 2–8% investigation band, so the default
+    is unchanged. All cells used 200 trials with zero refusals; 95% Wilson intervals
+    for the KNN rates span roughly 4.6–17.2%. These are direct-CI results, distinct
+    from the earlier ~30% rejection of true graphs by Fisher's combined test.
+    Learner choice must match the conditional mean; these diagnostics do not
+    establish calibration for arbitrary data or guarantee detection of dependence.
+    The reproducible protocol is in `scripts/audits/qualify_gcm.py`.
+
+Linear and GCM compute two-sided normal tails with `erfc`, so strong statistics
+such as z=9 retain their nonzero p-values (about 2.26e-19). Tails below binary64's
+representable range still become zero, for example z=40. Graph-test aggregation
+retains its existing safeguards for zero tails; no finite float can represent
+those smaller probabilities accurately.

{ergodic-0.3.1 → ergodic-0.3.2}/docsite/pages/time-series-discovery.md

@@ -54,14 +54,14 @@ print(f"{pruned} links pruned; {tests[0]} tests instead of {tests[1]}")
 
 ```output from="time_series.py"
 TimeSeriesDiscoveryResult(pcmci/linear: dag on 9 window nodes, max_lag=2, 5 lagged links, 0 contemporaneous, alpha=0.05, n=496)
-ads[t-1] -> ads[t]  p=0
-ads[t-1] -> visits[t]  p=0
-sales[t-1] -> sales[t]  p=0
-visits[t-2] -> sales[t]  p=4.4e-15
-visits[t-1] -> visits[t]  p=0
+ads[t-1] -> ads[t]  p=1.9e-38
+ads[t-1] -> visits[t]  p=6.1e-35
+sales[t-1] -> sales[t]  p=6.1e-34
+visits[t-2] -> sales[t]  p=4.5e-15
+visits[t-1] -> visits[t]  p=1.5e-26
 granger: [('ads', 'visits'), ('visits', 'sales')]
 True
-9 links pruned; 37 tests instead of 49
+9 links pruned; 37 tests instead of 47
 ```
 
 - **Step 2.** The result holds a window graph over nodes such as `ads[t-1]`. With

{ergodic-0.3.1 → ergodic-0.3.2}/docsite/site.toml

@@ -31,7 +31,7 @@ commands = [
 
 [versions]
 # Published versions older than this build that stay in the picker (v<version>/), oldest first.
-previous = ["0.2.0", "0.2.1", "0.3.0"]
+previous = ["0.2.0", "0.2.1", "0.3.0", "0.3.1"]
 
 [[products]]
 name = "ergodic"

ergodic-0.3.2/scripts/audits/qualify_ci_discovery.py

@@ -0,0 +1,49 @@
+"""Frozen DEC-104 paired discovery diagnostic. Run separately on baseline and candidate."""
+
+from __future__ import annotations
+
+import json
+
+import numpy as np
+
+from ergodic import discover, tabular
+
+
+def main() -> None:
+    for seed in range(150):
+        rng = np.random.default_rng(seed)
+        names = tuple("ABCDEFG")
+        coefficients = np.zeros((7, 7))
+        for i in range(7):
+            for j in range(i + 1, 7):
+                if rng.random() < 0.35:
+                    coefficients[i, j] = rng.choice([-1, 1]) * rng.uniform(0.8, 1.5)
+        values = rng.normal(size=(2000, 7))
+        for j in range(7):
+            values[:, j] += values[:, :j] @ coefficients[:j, j]
+        data = tabular(dict(zip(names, values.T, strict=True)))
+        reverse = tabular(dict(zip(names[::-1], values.T[::-1], strict=True)))
+        truth = {
+            tuple(sorted((names[i], names[j])))
+            for i, j in zip(*np.nonzero(coefficients), strict=True)
+        }
+        for method in ("mmpc", "pc", "fci", "rfci"):
+            graph = discover(data, method=method, test="linear").graph
+            pairs = {tuple(sorted((e.u, e.v))) for e in graph.edges}
+            permuted = discover(reverse, method=method, test="linear").graph
+            print(
+                json.dumps(
+                    {
+                        "seed": seed,
+                        "method": method,
+                        "edges": sorted(pairs),
+                        "errors": len(pairs ^ truth),
+                        "permutation_equal": graph == permuted,
+                    }
+                ),
+                flush=True,
+            )
+
+
+if __name__ == "__main__":
+    main()

ergodic-0.3.2/scripts/audits/qualify_gcm.py

@@ -0,0 +1,51 @@
+"""Frozen API-167 diagnostic; see Welt API DEC-104. JSON output goes outside Git."""
+
+from __future__ import annotations
+
+import json
+
+import numpy as np
+
+from ergodic.discovery import GCM
+
+
+def main() -> None:
+    records = []
+    for family in ("linear", "quadratic", "sine"):
+        for n in (200, 1000):
+            for learner in ("knn", "ols"):
+                rejected = [0, 0]
+                refused = [0, 0]
+                for seed in range(200):
+                    rng = np.random.default_rng(seed)
+                    z, ex, ey = rng.normal(size=(3, n))
+                    f = (
+                        z
+                        if family == "linear"
+                        else z**2
+                        if family == "quadratic"
+                        else np.sin(2 * z)
+                    )
+                    x = (f + ex)[:, None]
+                    for alternative in (0, 1):
+                        y = (f + 0.5 * alternative * ex + ey)[:, None]
+                        try:
+                            _, p, _ = GCM(learner=learner).statistic(x, y, z[:, None])
+                            rejected[alternative] += int(p <= 0.05)
+                        except ValueError:
+                            refused[alternative] += 1
+                records.append(
+                    {
+                        "family": family,
+                        "n": n,
+                        "learner": learner,
+                        "rejected": rejected,
+                        "refused": refused,
+                        "trials": 200,
+                    }
+                )
+                print(json.dumps(records[-1]), flush=True)
+
+
+if __name__ == "__main__":
+    main()

{ergodic-0.3.1 → ergodic-0.3.2}/src/ergodic/__init__.py

@@ -144,7 +144,7 @@ from .scm import (
     Sensitivity,
 )
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"
 
 __all__ = [
     "GRAPH_FORMAT",

{ergodic-0.3.1 → ergodic-0.3.2}/src/ergodic/discovery/_posterior.py

@@ -218,9 +218,47 @@ class GraphSamples:
         return _to_dag(self.variables, self.adjacency[index])
 
     def top(self, k: int = 5) -> list[tuple[MixedGraph, float]]:
-        """The ``k`` heaviest DAGs and their weights, heaviest first (ties by log target)."""
-        order = np.lexsort((-self.log_targets, -self.weights))[:k]
-        return [(self.graph(int(i)), float(self.weights[i])) for i in order]
+        """The ``k`` heaviest DAGs, with canonical ordering for numerical ties.
+
+        Weight ties span at most 1e-12 times their group's largest weight.
+        Within each weight group, log-target ties span at most 1e-9 (absolute).
+        Each group is anchored at its largest value, avoiding nontransitive
+        pairwise approximate comparisons. Final ties sort by the tuple of named
+        directed edges, independent of variable or storage order. Returned
+        weights are unchanged; sampled frequencies outside tolerance stay ranked.
+        """
+
+        def graph_key(i: int) -> tuple[tuple[str, str], ...]:
+            sources, targets = np.nonzero(self.adjacency[i])
+            return tuple(
+                sorted(
+                    (self.variables[s], self.variables[t])
+                    for s, t in zip(sources, targets, strict=True)
+                )
+            )
+
+        remaining = sorted(range(len(self.weights)), key=lambda i: -float(self.weights[i]))
+        order: list[int] = []
+        start = 0
+        while start < len(remaining):
+            anchor = float(self.weights[remaining[start]])
+            end = start + 1
+            while end < len(remaining) and anchor - self.weights[remaining[end]] <= 1e-12 * anchor:
+                end += 1
+            group = sorted(remaining[start:end], key=lambda i: -float(self.log_targets[i]))
+            log_start = 0
+            while log_start < len(group):
+                log_anchor = float(self.log_targets[group[log_start]])
+                log_end = log_start + 1
+                while log_end < len(group):
+                    value = float(self.log_targets[group[log_end]])
+                    if value != log_anchor and log_anchor - value > 1e-9:
+                        break
+                    log_end += 1
+                order.extend(sorted(group[log_start:log_end], key=graph_key))
+                log_start = log_end
+            start = end
+        return [(self.graph(i), float(self.weights[i])) for i in order[:k]]
 
     @property
     def best_graph(self) -> MixedGraph:

{ergodic-0.3.1 → ergodic-0.3.2}/src/ergodic/discovery/_stats.py

@@ -19,6 +19,15 @@ def _norm_cdf(x: float) -> float:
     return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
 
 
+def _norm_two_sided(stat: float) -> float:
+    """Two-sided normal tail without CDF cancellation.
+
+    Tails below binary64's representable range still round to zero (e.g. |z|=40).
+    Unlike 2*(1-cdf), representable tails beyond |z|=8.3 remain positive.
+    """
+    return math.erfc(abs(stat) / math.sqrt(2.0))
+
+
 def _lower_series(s: float, x: float) -> float:
     """Regularized lower incomplete gamma P(s, x) by series; needs x < s + 1."""
     if x <= 0.0:

{ergodic-0.3.1 → ergodic-0.3.2}/src/ergodic/discovery/algorithms/_mmpc.py

@@ -69,6 +69,11 @@ class MMPC:
     sinks) do not constrain an undirected adjacency and are left to the
     search that runs inside the support.
 
+    Forward associations within absolute p-value distance 1e-15 of the
+    strongest eligible candidate tie and are admitted by variable name. The
+    significance decision uses the unrounded p-value. This stabilizes numerical
+    tails, but does not make the greedy search invariant to variable renaming.
+
     ``fit(data, knowledge)`` returns a :class:`DiscoveryResult` whose graph
     holds one tail-tail edge per surviving pair, with the ``mixed`` face.
     """
@@ -191,7 +196,8 @@ def _parents_children(
     never tested, never removed. Each forward round recomputes every
     remaining candidate's worst-case p-value against the current CPC (the
     oracle caches, so revisited subsets cost a lookup) and admits the
-    smallest, ties broken by name, while it stays at or below ``alpha``.
+    smallest, numerical ties within 1e-15 broken by name, while it stays
+    at or below ``alpha``.
     The backward phase is the classic single sweep in sorted order: a
     member leaves when some subset of the current CPC without it tests
     independent, and later members see the shrunken set.
@@ -200,15 +206,13 @@ def _parents_children(
     pool = sorted(candidates)
     n_added = 0
     while pool:
-        best_p = float("inf")
-        best_x: str | None = None
-        for x in pool:
-            worst = _worst_p(oracle, x, target, cpc, alpha=alpha, cap=cap)
-            if worst < best_p:
-                best_p = worst
-                best_x = x
-        if best_x is None or best_p > alpha:
+        associations = [(x, _worst_p(oracle, x, target, cpc, alpha=alpha, cap=cap)) for x in pool]
+        eligible = [(x, p) for x, p in associations if p <= alpha]
+        if not eligible:
             break
+        best_p = min(p for _, p in eligible)
+        # Anchor ties at the minimum: pairwise isclose comparisons are not transitive.
+        best_x = min(x for x, p in eligible if p - best_p <= 1e-15)
         cpc.add(best_x)
         pool.remove(best_x)
         n_added += 1

{ergodic-0.3.1 → ergodic-0.3.2}/src/ergodic/discovery/ci/_gcm.py

@@ -28,7 +28,7 @@ import numpy as np
 from ...inference import KNNRegressor
 from ...inference._learner import _as_learner, _fresh
 from .._ci import CITest
-from .._stats import _norm_cdf
+from .._stats import _norm_two_sided
 
 if TYPE_CHECKING:
     import numpy.typing as npt
@@ -51,6 +51,11 @@ class GCM(CITest):
     a plain covariance test. Constant endpoints, exact or numerically exact
     fits, and constant residual products raise ``ValueError``: the normal
     reference statistic is undefined, so no independence decision is returned.
+    The default KNN learner is not generally calibrated: in a 200-seed
+    direct-CI diagnostic it rejected 7.5-12% of nulls at nominal 5% across
+    linear, quadratic and sine conditional means (n=200/1000). OLS was not
+    a safe general replacement. See the discovery guide for the protocol.
+
     An in-sample learner must leave nondegenerate residual variation; this
     check alone does not establish calibration for an arbitrary learner.
 
@@ -63,6 +68,7 @@ class GCM(CITest):
             first use.
     """
 
+    # Two-sided tails use erfc; below binary64 range (e.g. |z|=40), p is zero.
     name: ClassVar[str] = "gcm"
     needs: ClassVar[str] = "numeric"
 
@@ -107,7 +113,7 @@ class GCM(CITest):
                 "GCM residual product has zero or numerically degenerate variance; no valid p-value"
             )
         stat = math.sqrt(n) * mean_r / math.sqrt(var_r)
-        p = 2.0 * (1.0 - _norm_cdf(abs(stat)))
+        p = _norm_two_sided(stat)
         return stat, p, None
 
     # -- internals -----------------------------------------------------------

{ergodic-0.3.1 → ergodic-0.3.2}/src/ergodic/discovery/ci/_linear.py

@@ -17,7 +17,7 @@ from typing import TYPE_CHECKING, ClassVar
 import numpy as np
 
 from .._ci import CITest
-from .._stats import _norm_cdf
+from .._stats import _norm_two_sided
 
 if TYPE_CHECKING:
     import numpy.typing as npt
@@ -40,9 +40,11 @@ class Linear(CITest):
     Residualizes x and y on ``[1, z]``, computes the correlation ``r`` of the
     residuals, and reports ``sqrt(n - dz - 3) * atanh(r)`` against the
     standard normal, two-sided. The sign of ``r`` survives in the statistic;
-    the p-value does not depend on it.
+    the p-value does not depend on it. Tails use erfc to avoid CDF subtraction
+    cancellation; below binary64 range (e.g. |z|=40), p still becomes zero.
     """
 
+    # Two-sided tails use erfc; below binary64 range (e.g. |z|=40), p is zero.
     name: ClassVar[str] = "linear"
     needs: ClassVar[str] = "numeric"
 
@@ -69,5 +71,5 @@ class Linear(CITest):
         r = float(rx @ ry) / denom if denom > 0.0 else 0.0
         r = min(_CLIP, max(-_CLIP, r))
         stat = math.sqrt(n - dz - 3) * math.atanh(r)
-        p = 2.0 * (1.0 - _norm_cdf(abs(stat)))
+        p = _norm_two_sided(stat)
         return stat, p, None

{ergodic-0.3.1 → ergodic-0.3.2}/tests/test_discovery_ci.py

@@ -457,3 +457,38 @@ def test_gcm_statistic_does_not_depend_on_measurement_units(given: list[str], sc
 def test_gcm_refuses_a_single_observation() -> None:
     with pytest.raises(ValueError, match="at least two complete observations"):
         GCM(tabular({"X": [1.0], "Y": [2.0]})).test("X", "Y")
+
+
+@pytest.mark.parametrize(
+    ("z", "expected"),
+    [
+        (8.0, 1.2441921148543568e-15),
+        (9.0, 2.2571768119076845e-19),
+        (20.0, 5.507248237212467e-89),
+        (30.0, 9.813427854296374e-198),
+        (38.0, 5.7708567e-316),
+        (40.0, 0.0),
+    ],
+)
+def test_normal_tail_preserves_representable_extreme_probabilities(
+    z: float, expected: float
+) -> None:
+    from ergodic.discovery._stats import _norm_two_sided
+
+    for sign in (-1, 1):
+        p = _norm_two_sided(sign * z)
+        assert p == pytest.approx(expected, rel=1e-7, abs=0.0)
+        assert (p > 0) == (z < 40)
+
+
+@pytest.mark.parametrize("test_class", [Linear, GCM])
+def test_ci_consumers_use_survival_tail_for_strong_signal(test_class: type) -> None:
+    import math
+
+    rng = np.random.default_rng(14)
+    x = rng.normal(size=400)
+    y = x + rng.normal(size=400)
+    stat, p, _ = test_class().statistic(x[:, None], y[:, None], np.empty((400, 0)))
+    assert 8.5 < abs(stat) < 38
+    assert p > 0.0
+    assert p == pytest.approx(math.erfc(abs(stat) / math.sqrt(2)), rel=1e-14, abs=0.0)

{ergodic-0.3.1 → ergodic-0.3.2}/tests/test_discovery_graphtest.py

@@ -454,9 +454,9 @@ def test_zero_dof_claims_are_vacuous_and_left_out_of_k() -> None:
     assert len(result.to_dict()["vacuous"]) == 2
 
 
-def test_claims_that_underflow_to_zero_rank_by_their_statistic() -> None:
+@pytest.mark.parametrize("n", [1500, 40000])
+def test_strong_claims_rank_by_strength_even_when_tails_underflow(n: int) -> None:
     rng = np.random.default_rng(6)
-    n = 1500
     a = rng.normal(size=n)
     b = a + 2.0 * rng.normal(size=n)
     c = b + 3.0 * rng.normal(size=n)
@@ -464,8 +464,14 @@ def test_claims_that_underflow_to_zero_rank_by_their_statistic() -> None:
     result = test_graph(dag(["a -> b"], nodes=["c"]), tabular({"a": a, "b": b, "c": c}))
     p = [i.p_value for i in result.implications]
     stats = [abs(i.statistic) for i in result.implications]
-    # Both |z| are above 8.3, where Linear's p-value underflows to exactly 0.
-    assert p == [0.0, 0.0]
+    # Representable tails survive beyond z=8.3; true binary64 underflow still
+    # needs the graph-test statistic tie-break (above z=40 in the larger world).
+    if n == 1500:
+        assert all(value > 0.0 for value in p)
+        assert p == sorted(p)
+    else:
+        assert min(stats) > 40.0
+        assert p == [0.0, 0.0]
     assert min(stats) > 9.0
     assert stats == sorted(stats, reverse=True)
     top = result.implications[0]

{ergodic-0.3.1 → ergodic-0.3.2}/tests/test_discovery_mmpc.py

@@ -182,3 +182,32 @@ def test_diagnostics_count_the_phases() -> None:
     assert d["n_backward_removed"] >= 0.0
     assert result.alpha == 0.05
     assert result.n == data.n_rows
+
+
+def test_mmpc_is_invariant_to_every_column_permutation() -> None:
+    from itertools import permutations
+
+    rng = np.random.default_rng(42)
+    a, ex, ey, ez = rng.normal(size=(4, 500))
+    frame = pd.DataFrame({"A": a, "B": a + ex, "C": a + ey, "D": a + ex + ez})
+    expected = MMPC().fit(tabular(frame)).graph
+    for columns in permutations(frame.columns):
+        assert MMPC().fit(tabular(frame[list(columns)])).graph == expected
+
+
+@pytest.mark.parametrize("small_tail", [0.0, 1e-30, 1e-16])
+def test_forward_numerical_ties_use_names_without_rounding_alpha(small_tail: float) -> None:
+    from ergodic.discovery._ci import CIResult, CITest
+    from ergodic.discovery.algorithms._mmpc import _parents_children
+
+    class TailOracle(CITest):
+        def test(self, x: str, y: str, given: object = ()) -> CIResult:
+            # A and B explain the same signal; whichever enters first excludes the other.
+            p = 1.0 if given else small_tail if x == "A" else 0.0
+            return CIResult(9.0, p)
+
+    result, _, _ = _parents_children(TailOracle(), "T", ["B", "A"], frozenset(), alpha=0.05, cap=3)
+    assert result == {"A"}
+    # A genuinely above alpha must not enter just because it is within tie tolerance.
+    result, _, _ = _parents_children(TailOracle(), "T", ["B", "A"], frozenset(), alpha=1e-32, cap=3)
+    assert result == ({"A"} if small_tail == 0.0 else {"B"})

{ergodic-0.3.1 → ergodic-0.3.2}/tests/test_graph_posterior.py

@@ -371,3 +371,46 @@ def test_exact_refuses_where_it_does_not_apply() -> None:
     with warnings.catch_warnings():
         warnings.simplefilter("error")
         assert graph_posterior(probs, max_exact=6, samples=4000, seed=0).method == "mcmc"
+
+
+def test_top_numerical_ties_are_canonical_across_storage_and_variable_order() -> None:
+    from dataclasses import replace
+    from itertools import permutations
+
+    base = graph_posterior(_probs(3, 0))
+    adjacency = np.zeros((3, 3, 3), dtype=bool)
+    adjacency[0, 0, 1] = True  # A -> B
+    adjacency[1, 1, 0] = True  # B -> A
+    adjacency[2, 0, 2] = True  # A -> C
+    expected = [dag(["A -> B"], nodes=NAMES[:3]), dag(["A -> C"], nodes=NAMES[:3])]
+    for order in permutations(range(3)):
+        for variables in ((0, 1, 2), (2, 0, 1)):
+            for sign in (-1, 1):
+                weights = np.array([1 / 3, 1 / 3 + sign * 1e-14, 1 / 3 - sign * 1e-14])
+                logs = np.array([-2.0, -2.0 + sign * 1e-13, -2.0 - sign * 1e-13])
+                samples = replace(
+                    base,
+                    variables=tuple(NAMES[i] for i in variables),
+                    adjacency=adjacency[list(order)][:, list(variables)][:, :, list(variables)],
+                    weights=weights[list(order)],
+                    log_targets=logs[list(order)],
+                )
+                result = samples.top(2)
+                assert [g for g, _ in result] == expected
+                assert [w for _, w in result] == [weights[0], weights[2]]
+
+
+def test_top_preserves_distinct_weights_and_log_targets() -> None:
+    from dataclasses import replace
+
+    base = graph_posterior(_probs(3, 0))
+    weights = np.arange(1, len(base.weights) + 1, dtype=float)
+    weights /= weights.sum()
+    samples = replace(base, weights=weights)
+    assert samples.top(1)[0] == (samples.graph(len(weights) - 1), weights[-1])
+    equal = np.ones(len(weights)) / len(weights)
+    logs = np.arange(len(weights), dtype=float)
+    samples = replace(base, weights=equal, log_targets=logs)
+    assert samples.top(1)[0][0] == samples.graph(len(weights) - 1)
+    assert samples.top(0) == []
+    assert len(samples.top(len(weights) + 1)) == len(weights)