def test_coarsegrain_spatial_degenerate():
# TODO: move to docs?
# macro-micro examples from Hoel2016
# Example 2 - Spatial Degenerate
# The micro system has a full complex, and big_phi = 0.19
# The optimal coarse-graining groups AB, CD and EF, each with state
# mapping ((0, 1), (2))
nodes = 6
tpm = np.zeros((2**nodes, nodes))
for psi, ps in enumerate(utils.all_states(nodes)):
cs = [0 for i in range(nodes)]
if ps[0] == 1 and ps[1] == 1:
cs[2] = 1
cs[3] = 1
if ps[2] == 1 and ps[3] == 1:
cs[4] = 1
cs[5] = 1
if ps[4] == 1 and ps[5] == 1:
cs[0] = 1
cs[1] = 1
tpm[psi, :] = cs
cm = np.array([
[0, 0, 1, 1, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 1, 1],
[1, 1, 0, 0, 0, 0],
[1, 1, 0, 0, 0, 0]
])
state = (0, 0, 0, 0, 0, 0)
net = Network(tpm, cm)
mc = compute.major_complex(net, state)
assert mc.phi == 0.194445
partition = ((0, 1), (2, 3), (4, 5))
grouping = (((0, 1), (2,)), ((0, 1), (2,)), ((0, 1), (2, )))
coarse = macro.CoarseGrain(partition, grouping)
sub = macro.MacroSubsystem(net, state, range(net.size),
coarse_grain=coarse)
sia = compute.sia(sub)
assert sia.phi == 0.834183
def test_rule152_complexes_no_caching(rule152):
net = rule152
# Mapping from index of a PyPhi subsystem in network.subsystems to the
# index of the corresponding subsystem in the Matlab list of subsets
perm = {0: 0, 1: 1, 2: 3, 3: 7, 4: 15, 5: 2, 6: 4, 7: 8, 8: 16, 9: 5, 10:
9, 11: 17, 12: 11, 13: 19, 14: 23, 15: 6, 16: 10, 17: 18, 18: 12,
19: 20, 20: 24, 21: 13, 22: 21, 23: 25, 24: 27, 25: 14, 26: 22, 27:
26, 28: 28, 29: 29, 30: 30}
with open('test/data/rule152_results.pkl', 'rb') as f:
results = pickle.load(f)
# Don't use concept caching for this test.
constants.CACHE_CONCEPTS = False
for state, result in results.items():
# Empty the DB.
_flushdb()
# Unpack the state from the results key.
# Generate the network with the state we're testing.
net = Network(rule152.tpm, state, cm=rule152.cm)
# Comptue all the complexes, leaving out the first (empty) subsystem
# since Matlab doesn't include it in results.
complexes = list(compute.complexes(net))[1:]
# Check the phi values of all complexes.
zz = [(sia.phi, result['subsystem_phis'][perm[i]]) for i, sia in
list(enumerate(complexes))]
diff = [utils.eq(sia.phi, result['subsystem_phis'][perm[i]]) for
i, sia in list(enumerate(complexes))]
assert all(utils.eq(sia.phi, result['subsystem_phis'][perm[i]])
for i, sia in list(enumerate(complexes))[:])
# Check the major complex in particular.
major = compute.major_complex(net)
# Check the phi value of the major complex.
assert utils.eq(major.phi, result['phi'])
# Check that the nodes are the same.
assert (major.subsystem.node_indices ==
complexes[result['major_complex'] - 1].subsystem.node_indices)
# Check that the concept's phi values are the same.
result_concepts = [c for c in result['concepts']
if c['is_irreducible']]
z = list(zip([c.phi for c in major.ces],
[c['phi'] for c in result_concepts]))
diff = [i for i in range(len(z)) if not utils.eq(z[i][0], z[i][1])]
assert all(list(utils.eq(c.phi, result_concepts[i]['phi']) for i, c
in enumerate(major.ces)))
# Check that the minimal cut is the same.
assert major.cut == result['cut']
def test_coarsegrain_spatial_degenerate():
# TODO: move to docs?
# macro-micro examples from Hoel2016
# Example 2 - Spatial Degenerate
# The micro system has a full complex, and big_phi = 0.19
# The optimal coarse-graining groups AB, CD and EF, each with state
# mapping ((0, 1), (2))
nodes = 6
tpm = np.zeros((2**nodes, nodes))
for psi, ps in enumerate(utils.all_states(nodes)):
cs = [0 for i in range(nodes)]
if ps[0] == 1 and ps[1] == 1:
cs[2] = 1
cs[3] = 1
if ps[2] == 1 and ps[3] == 1:
cs[4] = 1
cs[5] = 1
if ps[4] == 1 and ps[5] == 1:
cs[0] = 1
cs[1] = 1
tpm[psi, :] = cs
cm = np.array([[0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0]])
state = (0, 0, 0, 0, 0, 0)
net = Network(tpm, cm)
mc = compute.major_complex(net, state)
assert mc.phi == 0.194445
partition = ((0, 1), (2, 3), (4, 5))
grouping = (((0, 1), (2, )), ((0, 1), (2, )), ((0, 1), (2, )))
coarse = macro.CoarseGrain(partition, grouping)
sub = macro.MacroSubsystem(net,
state,
range(net.size),
coarse_grain=coarse)
sia = compute.sia(sub)
assert sia.phi == 0.834183
def time_L1_approximation(self, distance):
compute.major_complex(self.network, self.state)
def test_soup():
# An first example attempting to capture the "soup" metaphor
#
# The system will consist of 6 elements 2 COPY elements (A, B) input to an
# AND element (C) AND element (C) inputs to two COPY elements (D, E) 2 COPY
# elements (D, E) input to an AND element (F) AND element (F) inputs to two
# COPY elements (A, B)
#
# For the soup example, element B receives an additional input from D, and
# implements AND logic instead of COPY
nodes = 6
tpm = np.zeros((2**nodes, nodes))
for psi, ps in enumerate(utils.all_states(nodes)):
cs = [0 for i in range(nodes)]
if ps[5] == 1:
cs[0] = 1
if ps[3] == 1 and ps[5] == 1:
cs[1] = 1
if ps[0] == 1 and ps[1]:
cs[2] = 1
if ps[2] == 1:
cs[3] = 1
cs[4] = 1
if ps[3] == 1 and ps[4] == 1:
cs[5] = 1
tpm[psi, :] = cs
cm = np.array([[0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0],
[0, 1, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [1, 1, 0, 0, 0, 0]])
network = Network(tpm, cm)
# State all OFF
state = (0, 0, 0, 0, 0, 0)
assert compute.major_complex(network, state).phi == 0.125
# With D ON (E must also be ON otherwise the state is unreachable)
state = (0, 0, 0, 1, 1, 0)
assert compute.major_complex(network, state).phi == 0.215278
# Once the connection from D to B is frozen (with D in the ON state), we
# recover the degeneracy example
state = (0, 0, 0, 1, 1, 0)
partition = ((0, 1, 2), (3, 4, 5))
output_indices = (2, 5)
blackbox = macro.Blackbox(partition, output_indices)
time = 2
sub = macro.MacroSubsystem(network,
state, (0, 1, 2, 3, 4, 5),
blackbox=blackbox,
time_scale=time)
assert compute.phi(sub) == 0.638888
# When the connection from D to B is frozen (with D in the OFF state),
# element B is inactivated and integration is compromised.
state = (0, 0, 0, 0, 0, 0)
partition = ((0, 1, 2), (3, 4, 5))
output_indices = (2, 5)
blackbox = macro.Blackbox(partition, output_indices)
time = 2
sub = macro.MacroSubsystem(network,
state, (0, 1, 2, 3, 4, 5),
blackbox=blackbox,
time_scale=time)
assert compute.phi(sub) == 0
def test_soup():
# An first example attempting to capture the "soup" metaphor
#
# The system will consist of 6 elements 2 COPY elements (A, B) input to an
# AND element (C) AND element (C) inputs to two COPY elements (D, E) 2 COPY
# elements (D, E) input to an AND element (F) AND element (F) inputs to two
# COPY elements (A, B)
#
# For the soup example, element B receives an additional input from D, and
# implements AND logic instead of COPY
nodes = 6
tpm = np.zeros((2 ** nodes, nodes))
for psi, ps in enumerate(utils.all_states(nodes)):
cs = [0 for i in range(nodes)]
if ps[5] == 1:
cs[0] = 1
if ps[3] == 1 and ps[5] == 1:
cs[1] = 1
if ps[0] == 1 and ps[1]:
cs[2] = 1
if ps[2] == 1:
cs[3] = 1
cs[4] = 1
if ps[3] == 1 and ps[4] == 1:
cs[5] = 1
tpm[psi, :] = cs
cm = np.array([
[0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 1, 0],
[0, 1, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 1],
[1, 1, 0, 0, 0, 0]
])
network = Network(tpm, cm)
# State all OFF
state = (0, 0, 0, 0, 0, 0)
assert compute.major_complex(network, state).phi == 0.125
# With D ON (E must also be ON otherwise the state is unreachable)
state = (0, 0, 0, 1, 1, 0)
assert compute.major_complex(network, state).phi == 0.215278
# Once the connection from D to B is frozen (with D in the ON state), we
# recover the degeneracy example
state = (0, 0, 0, 1, 1, 0)
partition = ((0, 1, 2), (3, 4, 5))
output_indices = (2, 5)
blackbox = macro.Blackbox(partition, output_indices)
time = 2
sub = macro.MacroSubsystem(network, state, (0, 1, 2, 3, 4, 5),
blackbox=blackbox, time_scale=time)
assert compute.phi(sub) == 0.638888
# When the connection from D to B is frozen (with D in the OFF state),
# element B is inactivated and integration is compromised.
state = (0, 0, 0, 0, 0, 0)
partition = ((0, 1, 2), (3, 4, 5))
output_indices = (2, 5)
blackbox = macro.Blackbox(partition, output_indices)
time = 2
sub = macro.MacroSubsystem(network, state, (0, 1, 2, 3, 4, 5),
blackbox=blackbox, time_scale=time)
assert compute.phi(sub) == 0
def time_major_complex(self, mode, network, cache):
# Do it!
compute.major_complex(self.network, self.state)