Tie-breaking¶
At several points during the IIT analysis, ties may arise when integrated information values of objects (partitions, purviews, subsystems) are compared. See the following papers:
Krohn S, Ostwald D.Computing integrated information.Neuroscience of Consciousness. 2017; 2017(nix017).Moon K.Exclusion and Underdetermined Qualia.Entropy. 2019; 21(4):405.Hanson JR, Walker SI.On the Non-uniqueness Problem in Integrated Information Theory.bioRxiv. 2021;2021.04.07.438793.
This documentation is solely meant to describe how the software deals with ties. Future work is required to resolve the role of ties in the IIT formalism.
Warning
Currently, only one of the tied objects is returned (selected as described below).
An exception is the actual causation computation, which returns all tied actual causes and effects.
In general, when searching for a minimal or maximal value, the first one encountered is selected as the output and used in further analysis (see additional selection criteria below).
This arbitrary selection process was chosen for computational simplicity. It also ensures that the same purviews are selected in the intact and cut subsystem, if the purviews are not affected by the system cut. This is important because causal distinctions unaffected by the system cut should not contribute to \(\Phi\).
As a consequence, the object selected may depend on the speed at which it was
computed when performing parallel computations. This applies to tied system cuts
if PARALLEL_CUT_EVALUATION
is set to True
,
and to subsystems if PARALLEL_COMPLEX_EVALUATION
is set to True
and subsystems of the same size are tied for
pyphi.compute.network.major_complex()
(note that
pyphi.compute.network.complexes()
returns the list of all complexes within
a system). However, ties in partitions and subsystems do not have further
effects on other quantities in the computation.
Mechanism purviews are always evaluated in the same order. In principle, ties in
the \(\varphi\) values across multiple possible purivews propagate to the SystemIrreducibilityAnalysis
.
Under most choices of settings, including the default IIT 3.0 configuration, the
\(\Phi\) value of a subsystem depends on the particular purviews of its
mechanisms, not just their \(\varphi\) value (except if
USE_SMALL_PHI_DIFFERENCE_FOR_CES_DISTANCE
is set
to True
.
Warning
In case of purview ties, the cause-effect structure and \(\Phi\) value for a given subsystem are not necessarily unique.
Our expectation is that the resulting value is representative. The variance of
possible \(\Phi\) values will depend on the specific system under consideration
and the particular config settings for performing the SystemIrreducibilityAnalysis
. Deterministic
systems with symmetric inputs and outputs are generally more prone to ties than
probabilistic systems. The EMD measure used in the default IIT 3.0 settings
is also particularly prone to ties in \(\varphi\) across purviews. Moreover,
due to the numerical optimization algorithm of the EMD measure, the PRECISION
has to be set to a relatively low value (default is 6 decimal places; see
PRECISION
). Other difference measures allow for significantly higher
precision.
Selection criteria¶
MaximallyIrreducibleCause
and MaximallyIrreducibleEffect
objects can be compared using the built-in Python comparison
operators (<
, >
, etc.) First, \(\varphi\) values are compared. If
these are equal up to PRECISION
, the size of the purview is compared. If
PICK_SMALLEST_PURVIEW
is set to True
, the partition with the smallest
purview is returned; otherwise the largest purview is returned. By default, this
is set to False
(which of these should be used depends on the choice of
difference measure MEASURE
and
PARTITION_TYPE
for \(\varphi\) computations; the
default configuration settings correspond to the IIT 3.0 formalism).
SystemIrreducibilityAnalysis
objects are compared this way as well. First, \(\Phi\) values are
compared. If these are equal up to PRECISION
, then the largest subsystem is
returned. The pyphi.compute.complexes()
function computes all complexes
with \(\Phi\) > 0 and can be used to inspect ties in \(\Phi\) across
subsystems.
All remaining ties between objects of the same size are resolved in an arbitrary
but stable manner by chosing the first one encountered. That is, if there is no
unique largest (or smallest, depending on configuration) purview with maximal
\(\varphi\), the returned purview is the first one as ordered by
pyphi.subsystem.Subsystem.potential_purviews()
(lexicographical by node index).
Similarly, if there is no unique largest subsystem with maximal \(\Phi\), then
the returned subsystem is the first one as ordered by
pyphi.compute.possible_complexes()
(also lexicographical by node
index).
Below we list all instances in which ties may occur.
Comparing mechanism partitions¶
The first instance of ties can arise when finding the partition with the minimum \(\varphi\) value (MIP) for a given purview. After computing each partition’s \(\varphi\) value, it is compared to the previously minimal \(\varphi\). If less, the MIP will be updated. Therefore, the first of all minimal \(\varphi\) found will be selected.
In subsystem.py
, line 610:
if phi < mip.phi:
mip = _mip(phi, partition, partitioned_repertoire)
This is performed for both causes and effects.
Comparing purviews¶
After computing the minimum information partition, we take the max()
across
all potential purviews. In the case of a tie, Python’s builtin max()
function returns the first maximal element.
In subsystem.py
, line 703:
if not purviews:
max_mip = _null_ria(direction, mechanism, ())
else:
max_mip = max(
self.find_mip(direction, mechanism, purview) for purview in purviews
)
This is performed for both causes and effects.
Comparing system partitions¶
Next we find the system partition with minimal \(\Phi\).
Assuming we don’t short-circuit (i.e., find a SystemIrreducibilityAnalysis
with \(\Phi\) = 0), each
new SIA is compared with the previous minimum. Again the returned minimum is the
first one, as ordered by pyphi.compute.subsystem.sia_bipartitions()
.
In compute/subsystem.py
, line 191:
def process_result(self, new_sia, min_sia):
"""Check if the new SIA has smaller |big_phi| than the standing
result.
"""
if new_sia.phi == 0:
self.done = True # Short-circuit
return new_sia
elif abs(new_sia.phi) < abs(min_sia.phi):
return new_sia
return min_sia
Comparing candidate systems¶
Finally, a search is performed for the candidate system with maximal \(\Phi\).
We compare the candidate systems with the builtin max()
, returning the first
one, as ordered by pyphi.compute.networks.possible_complexes()
.
In compute/network.py
, line 149:
result = complexes(network, state)
if result:
result = max(result)
This is then the major complex of the network.