Initial support for Implicit TPMs

docs/examples/magic_cut.rst

@@ -118,15 +118,15 @@ into existence.
     >>> C = (2,)
     >>> AB = (0, 1)
 
-The cut applied to the subsystem severs the connections going to |C| from
-either |A| or |B|. In this circumstance, knowing the state of |A| or |B| does
-not tell us anything about the state of |C|; only the previous state of |C| can
-tell us about the next state of |C|. ``C_node.tpm_on`` gives us the probability
-of |C| being ON in the next state, while ``C_node.tpm_off`` would give us the
+The cut applied to the subsystem severs the connections going to |C| from either
+|A| or |B|. In this circumstance, knowing the state of |A| or |B| does not tell
+us anything about the state of |C|; only the previous state of |C| can tell us
+about the next state of |C|. ``C_node.tpm[..., 1]`` gives us the probability of
+|C| being ON in the next state, while ``C_node.tpm[..., 0]`` would give us the
 probability of |C| being OFF.
 
     >>> C_node = cut_subsystem.indices2nodes(C)[0]
-    >>> C_node.tpm_on.flatten()
+    >>> C_node.tpm[..., 1].flatten()
     array([0.5 , 0.75])
 
 This states that |C| has a 50% chance of being ON in the next state if it

pyphi/__init__.py

@@ -75,7 +75,6 @@
 from .direction import Direction
 from .network import Network
 from .subsystem import Subsystem
-from .tpm import ExplicitTPM
 
 # Skip modules that require optional dependencies
 _skip_import = ["visualize", "graphs"]

pyphi/cache/__init__.py

@@ -103,10 +103,10 @@ class DictCache:
     Intended to be used as an object-level cache of method results.
     """
 
-    def __init__(self):
-        self.cache = {}
-        self.hits = 0
-        self.misses = 0
+    def __init__(self, cache=None, hits=0, misses=0):
+        self.cache = dict() if cache is None else cache
+        self.hits = hits
+        self.misses = misses
 
     def clear(self):
         self.cache = {}
@@ -148,6 +148,11 @@ def key(self, *args, _prefix=None, **kwargs):
         if kwargs:
             raise NotImplementedError("kwarg cache keys not implemented")
         return (_prefix,) + tuple(args)
+
+    def __repr__(self):
+        return "{}(cache={}, hits={}, misses={})".format(
+            type(self).__name__, self.cache, self.hits, self.misses
+        )
 
 
 def validate_parent_cache(parent_cache):

pyphi/data_structures/array_like.py

@@ -12,10 +12,14 @@ class ArrayLike(NDArrayOperatorsMixin):
 
     # TODO(tpm) populate this list
     _TYPE_CLOSED_FUNCTIONS = (
+        np.all,
+        np.any,
         np.concatenate,
+        np.expand_dims,
         np.stack,
-        np.all,
         np.sum,
+        np.result_type,
+        np.broadcast_to,
     )
 
     # Holds the underlying array

pyphi/distribution.py

@@ -4,6 +4,7 @@
 import numpy as np
 
 from .cache import cache
+from .utils import eq
 
 
 def normalize(a):

pyphi/examples.py

@@ -1512,3 +1512,28 @@ def get_net(
     print(transition)
     account = actual.account(transition)
     print(account)
+
+@register_example
+def functionally_equivalent():
+    """The 2nd deterministic system from Figure 8 of the IIT 4.0 paper:
+    Functionally equivalent networks with different Φ-structures.
+    """
+    node_labels = ("A", "B", "C")
+    # fmt: off
+    cm = np.array([
+        [1, 1, 0,],
+        [0, 1, 1,],
+        [1, 1, 1,],
+    ])
+    tpm = np.array([
+        [1, 0, 0],
+        [0, 1, 0],
+        [1, 1, 1],
+        [0, 1, 1],
+        [0, 0, 0],
+        [1, 1, 0],
+        [0, 0, 1],
+        [1, 0, 1],
+    ])
+    # fmt: on
+    return Network(tpm, cm=cm, node_labels=node_labels)

pyphi/macro.py

@@ -14,7 +14,10 @@
 from .labels import NodeLabels
 from .network import irreducible_purviews
 from .node import expand_node_tpm, generate_nodes
+from .state_space import build_state_space
 from .subsystem import Subsystem
+
+# TODO(tpm) use ImplicitTPM type consistently throughout module
 from .tpm import ExplicitTPM
 
 # Create a logger for this module.
@@ -43,25 +46,6 @@ def rebuild_system_tpm(node_tpms):
     return ExplicitTPM(tpm, validate=True)
 
 
-# TODO This should be a method of the TPM class in tpm.py
-def remove_singleton_dimensions(tpm):
-    """Remove singleton dimensions from the TPM.
-
-    Singleton dimensions are created by conditioning on a set of elements.
-    This removes those elements from the TPM, leaving a TPM that only
-    describes the non-conditioned elements.
-
-    Note that indices used in the original TPM must be reindexed for the
-    smaller TPM.
-    """
-    # Don't squeeze out the final dimension (which contains the probability)
-    # for networks with one element.
-    if tpm.ndim <= 2:
-        return tpm
-
-    return tpm.squeeze()[..., tpm.tpm_indices()]
-
-
 def run_tpm(system, steps, blackbox):
     """Iterate the TPM for the given number of timesteps.
 
@@ -73,7 +57,8 @@ def run_tpm(system, steps, blackbox):
     # boxes.
     node_tpms = []
     for node in system.nodes:
-        node_tpm = node.tpm_on
+        # TODO: nonbinary nodes.
+        node_tpm = node.tpm[..., 1]
         for input_node in node.inputs:
             if not blackbox.in_same_box(node.index, input_node):
                 if input_node in blackbox.output_indices:
@@ -92,7 +77,11 @@ def run_tpm(system, steps, blackbox):
     return ExplicitTPM(convert.state_by_state2state_by_node(tpm), validate=True)
 
 
-class SystemAttrs(namedtuple("SystemAttrs", ["tpm", "cm", "node_indices", "state"])):
+class SystemAttrs(
+        namedtuple(
+            "SystemAttrs", ["tpm", "cm", "node_indices", "state"]
+        )
+):
     """An immutable container that holds all the attributes of a subsystem.
 
     Versions of this object are passed down the steps of the micro-to-macro
@@ -106,15 +95,34 @@ def node_labels(self):
         labels = list("m{}".format(i) for i in self.node_indices)
         return NodeLabels(labels, self.node_indices)
 
+    @property
+    def state_space(self):
+        state_space, _ = build_state_space(
+            self.node_labels,
+            self.tpm.shape[:-1],
+            node_states=None,
+        )
+        return state_space
+
     @property
     def nodes(self):
         return generate_nodes(
-            self.tpm, self.cm, self.state, self.node_indices, self.node_labels
+            self.tpm,
+            self.cm,
+            self.state_space,
+            self.node_indices,
+            self.node_labels,
+            network_state=self.state,
         )
 
     @staticmethod
     def pack(system):
-        return SystemAttrs(system.tpm, system.cm, system.node_indices, system.state)
+        return SystemAttrs(
+            system.tpm,
+            system.cm,
+            system.node_indices,
+            system.state,
+        )
 
     def apply(self, system):
         system.tpm = self.tpm
@@ -214,11 +222,12 @@ def _squeeze(system):
         Reindexes the subsystem so that the nodes are ``0..n`` where ``n`` is
         the number of internal indices in the system.
         """
-        assert system.node_indices == system.tpm.tpm_indices()
+        assert system.node_indices == system.tpm.tpm_indices(reconstituted=True)
 
-        internal_indices = system.tpm.tpm_indices()
+        internal_indices = system.tpm.tpm_indices(reconstituted=True)
+        tpm = system.tpm.remove_singleton_dimensions()
 
-        tpm = remove_singleton_dimensions(system.tpm)
+        # TODO(tpm): deduplicate commonalities with tpm.ImplicitTPM.squeeze.
 
         # The connectivity matrix is the network's connectivity matrix, with
         # cut applied, with all connections to/from external nodes severed,
@@ -229,10 +238,24 @@ def _squeeze(system):
 
         # Re-index the subsystem nodes with the external nodes removed
         node_indices = reindex(internal_indices)
-        nodes = generate_nodes(tpm, cm, state, node_indices)
+        node_labels = NodeLabels(None, node_indices)
+        state_space, _ = build_state_space(
+            node_labels,
+            tpm.shape[:-1],
+        )
+
+        nodes = generate_nodes(
+            tpm,
+            cm,
+            state_space,
+            node_indices,
+            node_labels,
+            network_state=state
+        )
 
         # Re-calcuate the tpm based on the results of the cut
-        tpm = rebuild_system_tpm(node.tpm_on for node in nodes)
+        # TODO: nonbinary nodes.
+        tpm = rebuild_system_tpm(node.tpm[..., 1] for node in nodes)
 
         return SystemAttrs(tpm, cm, node_indices, state)
 
@@ -242,7 +265,8 @@ def _blackbox_partial_noise(blackbox, system):
         # Noise inputs from non-output elements hidden in other boxes
         node_tpms = []
         for node in system.nodes:
-            node_tpm = node.tpm_on
+            # TODO: nonbinary nodes.
+            node_tpm = node.tpm[..., 1]
             for input_node in node.inputs:
                 if blackbox.hidden_from(input_node, node.index):
                     node_tpm = node_tpm.marginalize_out([input_node])
@@ -264,7 +288,12 @@ def _blackbox_time(time_scale, blackbox, system):
         n = len(system.node_indices)
         cm = np.ones((n, n))
 
-        return SystemAttrs(tpm, cm, system.node_indices, system.state)
+        return SystemAttrs(
+            tpm,
+            cm,
+            system.node_indices,
+            system.state,
+        )
 
     def _blackbox_space(self, blackbox, system):
         """Blackbox the TPM and CM in space.
@@ -282,7 +311,8 @@ def _blackbox_space(self, blackbox, system):
 
         assert blackbox.output_indices == tpm.tpm_indices()
 
-        tpm = remove_singleton_dimensions(tpm)
+        new_tpm = tpm.remove_singleton_dimensions()
+
         n = len(blackbox)
         cm = np.zeros((n, n))
         for i, j in itertools.product(range(n), repeat=2):
@@ -294,8 +324,12 @@ def _blackbox_space(self, blackbox, system):
 
         state = blackbox.macro_state(system.state)
         node_indices = blackbox.macro_indices
+        state_space, _ = build_state_space(
+            NodeLabels(None, node_indices),
+            tpm.shape[:-1]
+        )
 
-        return SystemAttrs(tpm, cm, node_indices, state)
+        return SystemAttrs(new_tpm, cm, node_indices, state)
 
     @staticmethod
     def _coarsegrain_space(coarse_grain, is_cut, system):