Saturate the over-size subset sum and the boundary case of the subset-minimum sum

sum_of_minimum_over_size_among_subsets raised OverflowError once a
shared-atom group exceeded 1023 values: its Python-int coefficient
2**(a+1) exceeds float64 range at the division. The coefficient now
saturates to +inf — the same uninformative ceiling as
sum_of_minimum_among_subsets — with zero values contributing nothing.

In sum_of_minimum_among_subsets, every count can fit float64 while
their sum does not (exactly at 1024 values); the summation now runs
under the same errstate so the total saturates to inf instead of
escalating an overflow warning under warning-as-error configurations.

Also adds the changelog fragments and roadmap record for the full set
of condor smoke-test fixes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015f42ka7k2RhfsyKFLqyLdv

Author: wmayner

ROADMAP.md

@@ -744,6 +744,26 @@ item), mutation testing (N3/N17 ← T2), and the matching exact-oracle/standard-
   above a feasibility bound, and `collect` warns before computing a missing
   resolution state past ~12 units.
 
+### 2026-07-23 CHTC smoke-test fixes
+
+> The first real condor submission (13 shards on a production pool; the collected
+> structure matched the local run exactly) surfaced six bugs. Two were already fixed
+> (submit-file task-id padding via `$INT(task_id,%04d)`; the `request_memory` column,
+> landed with the 2026-07-21 follow-ups — the report was written against an older
+> checkout). **The other four landed 2026-07-23:** `preserve_relative_paths = true` in
+> the submit template (HTCondor flattens single transferred files to the scratch root,
+> so every job died on `FileNotFoundError`; invisible to the local runner, which
+> bypasses the submit file); int64 wraparound in
+> `combinatorics.sum_of_minimum_among_subsets` past 63 shared distinctions — silent
+> Σφ_r corruption in `AnalyticalRelations.sum_phi()` and the scope report — now exact
+> through int64's range and saturating to `inf` beyond float64's, with the same
+> saturation in `sum_of_minimum_over_size_among_subsets` (which raised `OverflowError`
+> past 1023 values); the measured bounds' `2.0**k` weight saturating to the documented
+> `inf` ceiling instead of raising past 1023 shared distinctions (crashed `collect`'s
+> scope report at production scale); and a clear `OverflowError` from
+> `AnalyticalRelations.__len__` pointing at `.num_relations()` when the closed-form
+> count exceeds `sys.maxsize` (the MCP result summary falls back accordingly).
+
 ## Context
 
 PyPhi is a scientific library implementing Integrated Information Theory (IIT). It has

changelog.d/analytical-len-overflow.fix.md

@@ -0,0 +1,4 @@
+`len()` on `AnalyticalRelations` whose closed-form relation count
+exceeds `sys.maxsize` now raises an `OverflowError` that points at
+`.num_relations()`, instead of the bare protocol failure; the MCP
+result summary falls back accordingly.

changelog.d/condor-preserve-relative-paths.fix.md

@@ -0,0 +1,5 @@
+The generated condor submit file sets `preserve_relative_paths = true`.
+Without it, HTCondor flattens the transferred task file to the scratch
+root while `run_task.sh` expects it under `tasks/`, so every job on a
+real pool failed with `FileNotFoundError` (the local runner bypasses
+the submit file and never saw it).

changelog.d/measured-bound-large-groups.fix.md

@@ -0,0 +1,5 @@
+`sum_phi_relations_measured_bound` (and `big_phi_measured_bound`) raised
+`OverflowError` when more than 1023 distinctions shared a purview atom —
+crashing `collect`'s scope report at production scale. The 2^k weight
+now saturates to the documented `inf` ceiling, and zero-density groups
+contribute nothing regardless of size.

changelog.d/subset-sum-overflow.fix.md

@@ -0,0 +1,8 @@
+`combinatorics.sum_of_minimum_among_subsets` computed its subset counts
+in int64, silently wrapping once more than 63 values shared an atom —
+corrupting `AnalyticalRelations.sum_phi()` (and the campaign scope
+report's Σφ_r) on large structures. Counts now stay exact through
+int64's range and saturate to `inf` beyond float64's, with zero values
+contributing nothing at any size.
+`sum_of_minimum_over_size_among_subsets` likewise saturates instead of
+raising `OverflowError` past 1023 values.

pyphi/combinatorics.py

@@ -123,8 +123,10 @@ def sum_of_minimum_among_subsets(values: Sequence[float]) -> float:
             # shared by that many distinctions.
             counts = 2.0**exponents - 1.0
         terms = sorted_values * counts
-    terms[sorted_values == 0.0] = 0.0  # a zero value contributes 0, not 0*inf=nan
-    return float(np.sum(terms))
+        terms[sorted_values == 0.0] = 0.0  # a zero value contributes 0, not 0*inf=nan
+        # Each term can fit float64 while their sum does not; an overflowed
+        # sum is exactly the saturated infinite total.
+        return float(np.sum(terms))
 
 
 def sum_of_minimum_over_size_among_subsets(values: Sequence[float]) -> float:
@@ -149,8 +151,17 @@ def sum_of_minimum_over_size_among_subsets(values: Sequence[float]) -> float:
     for i in range(n):
         a = n - 1 - i
         if a > 0:
-            coefficients[i] = (2 ** (a + 1) - 1 - (a + 1)) / (a + 1)
-    return float(np.sum(sorted_values * coefficients))
+            if a + 1 >= 1024:
+                # 2**(a + 1) exceeds float64 range (the division would raise);
+                # the coefficient saturates to +inf, the same uninformative
+                # ceiling as in :func:`sum_of_minimum_among_subsets`.
+                coefficients[i] = math.inf
+            else:
+                coefficients[i] = (2 ** (a + 1) - 1 - (a + 1)) / (a + 1)
+    with np.errstate(over="ignore", invalid="ignore"):
+        terms = sorted_values * coefficients
+        terms[sorted_values == 0.0] = 0.0  # a zero value contributes 0, not 0*inf=nan
+        return float(np.sum(terms))
 
 
 def sum_of_minimum_of_size_among_subsets(values: Sequence[float], size: int) -> float:

test/test_combinatorics.py

@@ -293,3 +293,33 @@ def ref(values):  # exact via Python big ints
     assert math.isclose(f(v70), ref(v70), rel_tol=1e-9) and f(v70) > 1e18
     assert f([0.1] * 1100) == math.inf  # saturates, no raise
     assert f([0.0] * 1100 + [0.2]) == 0.0  # zeros give 0, not 0*inf=nan
+
+
+def test_sum_of_minimum_among_subsets_boundary_sum_saturates():
+    """At n=1024 every count fits float64 but their sum does not; the total
+    saturates to inf instead of escalating an overflow warning."""
+    import numpy as np
+
+    assert combinatorics.sum_of_minimum_among_subsets(np.ones(1024)) == math.inf
+
+
+def test_sum_of_minimum_over_size_among_subsets_saturates_to_inf():
+    """Raised OverflowError once a group exceeded 1023 values."""
+    import numpy as np
+
+    values = np.ones(1100)
+    assert combinatorics.sum_of_minimum_over_size_among_subsets(values) == math.inf
+
+
+def test_sum_of_minimum_over_size_among_subsets_zero_values_contribute_nothing():
+    """Zero values carry the overflowing coefficients but contribute 0, so
+    the total reduces to the nonzero tail's."""
+    import numpy as np
+
+    values = np.concatenate([np.zeros(300), np.ones(1000)])
+    result = combinatorics.sum_of_minimum_over_size_among_subsets(values)
+    assert math.isfinite(result)
+    assert result == pytest.approx(
+        combinatorics.sum_of_minimum_over_size_among_subsets(np.ones(1000)),
+        rel=1e-12,
+    )