Fix tied specified-state bug breaking permutation symmetry in SIA

When computing system-level integration (IIT 4.0), the specified cause/effect
state can tie at multiple states with equal intrinsic information.
integration_value() previously used whichever tied state was arbitrarily
selected first, but the cut subsystem breaks the degeneracy between tied
states, causing permutation-equivalent systems to produce different phi_c
values (e.g., AND-XOR at (0,1) gave phi_c=0.5 while XOR-AND at (1,0)
gave phi_c=0.0).

Fix: integration_value() now evaluates all tied specified states and takes
the minimum integration — the "cruelest cut" principle. Among equally-
specified states, the partition is evaluated against the one it hurts most.

Tests: add permutation symmetry invariant tests (TestPermutationSymmetry)
and unit tests for tied state tracking (TestIntrinsicInformationTies).
843 existing tests pass with no regressions.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: wmayner

pyphi/new_big_phi/__init__.py

@@ -31,6 +31,7 @@
 from pyphi.models.cuts import NullCut
 from pyphi.models.cuts import SystemPartition
 from pyphi.models.mechanism import RepertoireIrreducibilityAnalysis
+from pyphi.models.mechanism import StateSpecification
 from pyphi.models.subsystem import CauseEffectStructure
 from pyphi.models.subsystem import SystemStateSpecification
 from pyphi.parallel import MapReduce
@@ -288,16 +289,15 @@ def normalization_factor(partition: Cut | GeneralKCut) -> float:
     return 1.0
 
 
-def integration_value(
+def _integration_value_for_state(
     direction: Direction,
     subsystem: Subsystem,
+    cut_subsystem: Subsystem,
     partition: Cut,
-    system_state: SystemStateSpecification,
-    repertoire_distance: str | None = None,
+    specified: StateSpecification,
+    repertoire_distance: str,
 ) -> RepertoireIrreducibilityAnalysis:
-    repertoire_distance = fallback(repertoire_distance, config.REPERTOIRE_DISTANCE)
-    cut_subsystem = subsystem.apply_cut(partition)
-    # TODO(4.0) deal with proliferation of special cases for GID
+    """Compute the integration value for a single specified state."""
     mechanism = purview = subsystem.node_indices
     if repertoire_distance in [
         "GENERALIZED_INTRINSIC_DIFFERENCE",
@@ -307,22 +307,45 @@ def integration_value(
             direction,
             mechanism,
             purview,
-            system_state[direction].state,
-        ).squeeze()[system_state[direction].state]
+            specified.state,
+        ).squeeze()[specified.state]
     else:
         partitioned_repertoire = cut_subsystem.repertoire(
             direction, subsystem.node_indices, subsystem.node_indices
         )
-    ria = subsystem.evaluate_partition(
+    return subsystem.evaluate_partition(
         direction,
         subsystem.node_indices,
         subsystem.node_indices,
         partition,  # pyright: ignore[reportArgumentType] - Cut passed to Bipartition param in IIT 4.0
         partitioned_repertoire=partitioned_repertoire,
         repertoire_distance=repertoire_distance,
-        state=system_state[direction],
+        state=specified,
     )
-    return ria
+
+
+def integration_value(
+    direction: Direction,
+    subsystem: Subsystem,
+    partition: Cut,
+    system_state: SystemStateSpecification,
+    repertoire_distance: str | None = None,
+) -> RepertoireIrreducibilityAnalysis:
+    repertoire_distance = fallback(repertoire_distance, config.REPERTOIRE_DISTANCE)
+    cut_subsystem = subsystem.apply_cut(partition)
+    specified = system_state[direction]
+    tied_specs = specified.ties if specified.ties else (specified,)
+    # When there are tied specified states, evaluate all of them and take the
+    # minimum integration (the "cruelest cut"): among equally-specified states,
+    # the partition should be evaluated against the one it hurts most.
+    best_ria = None
+    for spec in tied_specs:
+        ria = _integration_value_for_state(
+            direction, subsystem, cut_subsystem, partition, spec, repertoire_distance
+        )
+        if best_ria is None or ria.phi < best_ria.phi:
+            best_ria = ria
+    return best_ria
 
 
 def intrinsic_differentiation_value(

test/example_networks.py

@@ -2,6 +2,7 @@
 
 import pyphi
 from pyphi import utils
+from pyphi.labels import NodeLabels
 from pyphi.macro import Blackbox
 from pyphi.macro import MacroSubsystem
 from pyphi.network import Network
@@ -754,3 +755,45 @@ def propagation_delay():
     return MacroSubsystem(
         network, cs, network.node_indices, time_scale=time_scale, blackbox=blackbox
     )
+
+
+# Permutation-equivalent pair for symmetry tests
+# ================================================
+
+
+def and_xor_network():
+    """AND-XOR 2-node network. Node 0: AND(0,1), Node 1: XOR(0,1).
+
+    Both nodes receive input from both nodes (all-ones CM).
+    Deterministic transitions:
+        (0,0) -> (0,0), (1,0) -> (0,1), (0,1) -> (0,1), (1,1) -> (1,0)
+    """
+    # fmt: off
+    tpm = np.array([
+        [0, 0],  # (0,0) -> (0,0)
+        [0, 1],  # (1,0) -> (0,1)
+        [0, 1],  # (0,1) -> (0,1)
+        [1, 0],  # (1,1) -> (1,0)
+    ])
+    # fmt: on
+    cm = np.ones((2, 2))
+    return Network(tpm, cm=cm, node_labels=NodeLabels(("AND", "XOR"), tuple(range(2))))
+
+
+def xor_and_network():
+    """XOR-AND 2-node network (AND-XOR with nodes 0 and 1 permuted).
+
+    Both nodes receive input from both nodes (all-ones CM).
+    Deterministic transitions:
+        (0,0) -> (0,0), (1,0) -> (1,0), (0,1) -> (1,0), (1,1) -> (0,1)
+    """
+    # fmt: off
+    tpm = np.array([
+        [0, 0],  # (0,0) -> (0,0)
+        [1, 0],  # (1,0) -> (1,0)
+        [1, 0],  # (0,1) -> (1,0)
+        [0, 1],  # (1,1) -> (0,1)
+    ])
+    # fmt: on
+    cm = np.ones((2, 2))
+    return Network(tpm, cm=cm, node_labels=NodeLabels(("XOR", "AND"), tuple(range(2))))

test/test_invariants.py

@@ -14,7 +14,9 @@
 from pyphi import config
 from pyphi import new_big_phi
 from pyphi.new_big_phi import NullSystemIrreducibilityAnalysis
+from pyphi.subsystem import Subsystem
 
+from . import example_networks
 from .conftest import skip_if_no_pyemd
 
 
@@ -320,3 +322,67 @@ def test_phi_structure_has_relations(self, example_name):
                 f"but no relations attribute"
             )
             # Relations might be None for some systems, so don't assert it's non-empty
+
+
+class TestPermutationSymmetry:
+    """Systems related by node permutation must have identical phi values.
+
+    AND-XOR and XOR-AND have the same all-ones connectivity matrix but swap
+    which node gets the AND vs XOR gate. They are related by the node
+    permutation π: 0↔1. Under this permutation, state (a,b) in AND-XOR
+    maps to (b,a) in XOR-AND.
+
+    All measures must be invariant under this permutation.
+    """
+
+    def test_system_intrinsic_information_symmetric(self):
+        """Cause/effect intrinsic information must be equal for permuted systems."""
+        sub_ax = Subsystem(example_networks.and_xor_network(), (0, 1))
+        sub_xa = Subsystem(example_networks.xor_and_network(), (1, 0))
+        ss_ax = new_big_phi.system_intrinsic_information(sub_ax)
+        ss_xa = new_big_phi.system_intrinsic_information(sub_xa)
+        assert float(ss_ax.cause.intrinsic_information) == pytest.approx(
+            float(ss_xa.cause.intrinsic_information)
+        )
+        assert float(ss_ax.effect.intrinsic_information) == pytest.approx(
+            float(ss_xa.effect.intrinsic_information)
+        )
+
+    def test_sia_phi_symmetric(self):
+        """Overall phi must be equal for permuted systems."""
+        sub_ax = Subsystem(example_networks.and_xor_network(), (0, 1))
+        sub_xa = Subsystem(example_networks.xor_and_network(), (1, 0))
+        sia_ax = new_big_phi.sia(sub_ax)
+        sia_xa = new_big_phi.sia(sub_xa)
+        assert float(sia_ax.phi) == pytest.approx(float(sia_xa.phi))
+
+    def test_sia_phi_c_symmetric(self):
+        """phi_c must be equal for permuted systems.
+
+        This is the specific invariant that was violated by the tied-state
+        bug: AND-XOR(0,1) reported phi_c=0.5 while XOR-AND(1,0) reported
+        phi_c=0.0, due to arbitrary tie-breaking in the specified cause state.
+        """
+        sub_ax = Subsystem(example_networks.and_xor_network(), (0, 1))
+        sub_xa = Subsystem(example_networks.xor_and_network(), (1, 0))
+        sia_ax = new_big_phi.sia(sub_ax)
+        sia_xa = new_big_phi.sia(sub_xa)
+        phi_c_ax = float(sia_ax.cause.phi) if sia_ax.cause else 0.0
+        phi_c_xa = float(sia_xa.cause.phi) if sia_xa.cause else 0.0
+        assert phi_c_ax == pytest.approx(phi_c_xa), (
+            f"phi_c differs for permuted systems: "
+            f"AND-XOR(0,1)={phi_c_ax}, XOR-AND(1,0)={phi_c_xa}"
+        )
+
+    def test_sia_phi_e_symmetric(self):
+        """phi_e must be equal for permuted systems."""
+        sub_ax = Subsystem(example_networks.and_xor_network(), (0, 1))
+        sub_xa = Subsystem(example_networks.xor_and_network(), (1, 0))
+        sia_ax = new_big_phi.sia(sub_ax)
+        sia_xa = new_big_phi.sia(sub_xa)
+        phi_e_ax = float(sia_ax.effect.phi) if sia_ax.effect else 0.0
+        phi_e_xa = float(sia_xa.effect.phi) if sia_xa.effect else 0.0
+        assert phi_e_ax == pytest.approx(phi_e_xa), (
+            f"phi_e differs for permuted systems: "
+            f"AND-XOR(0,1)={phi_e_ax}, XOR-AND(1,0)={phi_e_xa}"
+        )

test/test_subsystem.py

@@ -189,3 +189,36 @@ def test_concept_no_mechanism(s):
 
 def test_concept_nonexistent(s):
     assert not s.concept((0, 2))
+
+
+class TestIntrinsicInformationTies:
+    """Test that intrinsic_information() correctly tracks tied states."""
+
+    def test_tied_states_are_stored(self):
+        """intrinsic_information() should populate .ties when states tie.
+
+        AND-XOR at state (0,1): the cause GID is 0.5 for both purview states
+        (1,0) and (0,1), creating a tie. Both should appear in .ties.
+        """
+        net = example_networks.and_xor_network()
+        sub = Subsystem(net, (0, 1))
+        spec = sub.intrinsic_information(Direction.CAUSE, (0, 1), (0, 1))
+        assert len(spec.ties) == 2
+        tied_states = {t.state for t in spec.ties}
+        assert tied_states == {(0, 1), (1, 0)}
+
+    def test_tied_states_have_equal_ii(self):
+        """All tied StateSpecifications must have the same intrinsic information."""
+        net = example_networks.and_xor_network()
+        sub = Subsystem(net, (0, 1))
+        spec = sub.intrinsic_information(Direction.CAUSE, (0, 1), (0, 1))
+        ii_values = {float(t.intrinsic_information) for t in spec.ties}
+        assert len(ii_values) == 1, f"Tied states have different II: {ii_values}"
+
+    def test_no_ties_when_unique_max(self):
+        """When a single state uniquely maximizes II, ties should have length 1."""
+        net = example_networks.and_xor_network()
+        sub = Subsystem(net, (0, 1))
+        spec = sub.intrinsic_information(Direction.EFFECT, (0, 1), (0, 1))
+        # Effect direction should have a unique max (no tie)
+        assert len(spec.ties) == 1