Back-propagate MIP-resolved specified states to system_state on SIA

After integration_value() resolves tied specified states by selecting the
one most vulnerable to the partition ("cruelest cut"), that resolution was
recorded on the MIP's cause/effect RIAs (via specified_state) but not on
sia.system_state, which still held the arbitrary initial choice. This
matters because system_state is used downstream by phi_structure() for
congruence filtering.

Add resolve_system_state() method to SystemIrreducibilityAnalysis that
back-propagates the winning specified states from the MIP's RIAs into
system_state. Called in sia() after the MIP is found, for all tied MIPs.
Ties are preserved on the updated system_state.

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

Author: wmayner

pyphi/new_big_phi/__init__.py

@@ -5,6 +5,7 @@
 
 from collections.abc import Iterable
 from dataclasses import dataclass
+from dataclasses import replace
 from enum import Enum
 from enum import auto
 from enum import unique
@@ -144,6 +145,31 @@ def ties(self):
     def set_ties(self, ties):
         self._ties = ties
 
+    def resolve_system_state(self) -> None:
+        """Update system_state to reflect the specified states resolved by the MIP.
+
+        When the system has tied specified states, the MIP resolves the tie by
+        selecting the state most vulnerable to the winning partition. This
+        back-propagates that resolution into system_state so that downstream
+        consumers (e.g., congruence filtering in phi_structure) see the correct
+        specified states.
+        """
+        if self.system_state is None:
+            return
+        new_cause = self.system_state.cause
+        new_effect = self.system_state.effect
+        if self.cause is not None and self.cause.specified_state is not None:
+            new_cause = self.cause.specified_state
+        if self.effect is not None and self.effect.specified_state is not None:
+            new_effect = self.effect.specified_state
+        if (
+            new_cause is not self.system_state.cause
+            or new_effect is not self.system_state.effect
+        ):
+            self.system_state = replace(
+                self.system_state, cause=new_cause, effect=new_effect
+            )
+
     def __eq__(self, other):
         return cmp.general_eq(self, other, self._sia_attributes)
 
@@ -571,6 +597,7 @@ def is_disconnecting_partition(partition):
         elif candidate_key == mip_key:
             ties.append(candidate_mip_sia)
     for tied_mip in ties:
+        tied_mip.resolve_system_state()
         tied_mip.set_ties(ties)
 
     if config.CLEAR_SUBSYSTEM_CACHES_AFTER_COMPUTING_SIA:

test/test_invariants.py

@@ -386,3 +386,39 @@ def test_sia_phi_e_symmetric(self):
             f"phi_e differs for permuted systems: "
             f"AND-XOR(0,1)={phi_e_ax}, XOR-AND(1,0)={phi_e_xa}"
         )
+
+    def test_system_state_reflects_mip_resolution(self):
+        """system_state should reflect the specified state chosen by the MIP.
+
+        When tied specified states are resolved by the MIP, the winning state
+        (most vulnerable to the partition) should be back-propagated to
+        system_state, so downstream consumers see the correct state.
+        """
+        sub = Subsystem(example_networks.and_xor_network(), (0, 1))
+        sia = new_big_phi.sia(sub)
+        if sia.cause and sia.cause.specified_state:
+            assert sia.system_state.cause.state == sia.cause.specified_state.state
+        if sia.effect and sia.effect.specified_state:
+            assert sia.system_state.effect.state == sia.effect.specified_state.state
+
+    def test_system_state_preserves_ties_after_resolution(self):
+        """system_state should still record all tied states after resolution."""
+        sub = Subsystem(example_networks.and_xor_network(), (0, 1))
+        sia = new_big_phi.sia(sub)
+        # The cause direction had 2 tied states
+        assert len(sia.system_state.cause.ties) == 2
+        tied_states = {t.state for t in sia.system_state.cause.ties}
+        assert tied_states == {(0, 1), (1, 0)}
+
+    def test_system_state_symmetric(self):
+        """system_state.cause.state should be permutation-equivalent."""
+        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)
+        ax_state = sia_ax.system_state.cause.state
+        xa_state = sia_xa.system_state.cause.state
+        assert ax_state == tuple(reversed(xa_state)), (
+            f"system_state.cause.state not permutation-equivalent: "
+            f"AND-XOR={ax_state}, XOR-AND={xa_state}"
+        )

test/test_subsystem.py

@@ -222,3 +222,10 @@ def test_no_ties_when_unique_max(self):
         spec = sub.intrinsic_information(Direction.EFFECT, (0, 1), (0, 1))
         # Effect direction should have a unique max (no tie)
         assert len(spec.ties) == 1
+
+    def test_null_sia_resolve_system_state_safe(self):
+        """resolve_system_state should be a no-op for NullSIA."""
+        from pyphi.new_big_phi import NullSystemIrreducibilityAnalysis
+
+        null_sia = NullSystemIrreducibilityAnalysis()
+        null_sia.resolve_system_state()  # Should not raise