# Partial Information Decomposition¶

The *partial information decomposition* (PID), put forth by Williams & Beer [WB10], is a framework for decomposing the information shared between a set of variables we will refer to as *inputs*, \(X_0, X_1, \ldots\), and another random variable we will refer to as the *output*, \(Y\). This decomposition seeks to partition the information \(\I{X_0,X_1,\ldots : Y}\) among the antichains of the inputs.

## Background¶

It is often desirable to determine how a set of inputs influence the behavior of an output. Consider the exclusive or logic gates, for example:

```
In [1]: from dit.pid.distributions import bivariates, trivariates
In [2]: xor = bivariates['synergy']
In [3]: print(xor)
Class: Distribution
Alphabet: ('0', '1') for all rvs
Base: linear
Outcome Class: str
Outcome Length: 3
RV Names: None
x p(x)
000 1/4
011 1/4
101 1/4
110 1/4
```

We can see from inspection that either input (the first two indexes) is independent of the output (the final index), yet the two inputs together determine the output. One could call this “synergistic” information. Next, consider the giant bit distribution:

```
In [4]: gb = bivariates['redundant']
In [5]: print(gb)
Class: Distribution
Alphabet: ('0', '1') for all rvs
Base: linear
Outcome Class: str
Outcome Length: 3
RV Names: None
x p(x)
000 1/2
111 1/2
```

Here, we see that either input informs us of exactly what the output is. One could call this “redundant” information. Furthermore, consider the coinformation of these distributions:

```
In [6]: from dit.multivariate import coinformation as I
In [7]: I(xor)
Out[7]: -1.0
In [8]: I(gb)
Out[8]: 1.0
```

This could lead one to intuit that negative values of the coinformation correspond to synergistic effects in a distribution, while positive values correspond to redundant effects. This intuition, however, is at best misleading: the coinformation of a 4-variable giant bit and 4-variable parity distribution are both positive:

```
In [9]: I(dit.example_dists.giant_bit(4, 2))
Out[9]: 1.0
In [10]: I(dit.example_dists.n_mod_m(4, 2))
Out[10]: 1.0
```

This, as well as other issues, lead Williams & Beer [WB10] to propose the *partial information decomposition*.

## Framework¶

The goal of the partial information is to assign to each some non-negative portion of \(\I{\{X_i\} : Y}\) to each antichain over the inputs. An antichain over the inputs is a set of sets, where each of those sets is not a subset of any of the others. For example, \(\left\{ \left\{X_0, X_1\right\}, \left\{X_1, X_2\right\} \right\}\) is an antichain, but \(\left\{ \left\{X_0, X_1\right\}, \left\{X_0 X_1, X_2\right\} \right\}\) is not.

The antichains for a lattice based on this partial order:

From here, we wish to find a redundancy measure, \(\Icap{\bullet}\) which would assign a fraction of \(\I{\{X_i\} : Y}\) to each antichain intuitively quantifying what portion of the information in the output could be learned by observing any of the sets of variables within the antichain. In order to be a viable measure of redundancy, there are several axioms a redundancy measure must satisfy.

### Bivariate Lattice¶

Let us consider the special case of two inputs. The lattice consists of four elements: \(\left\{\left\{X_0\right\}, \left\{X_1\right\}\right\}\), \(\left\{\left\{X_0\right\}\right\}\), \(\left\{\left\{X_1\right\}\right\}\), and \(\left\{\left\{X_0, X_1\right\}\right\}\). We can interpret these elements as the *redundancy* provided by both inputs, the information *uniquely* provided by \(X_0\), the information *uniquely* provided by \(X_1\), and the information *synergistically* provided only by both inputs together. Together these for elements decompose the input-output mutual information:

Furthermore, due to the self-redundancy axiom (described ahead), the single-input mutual informations decomposed in the following way:

Colloquially, from input \(X_0\) one can learn what is redundantly provided by either input, plus what is uniquely provided by \(X_0\), but not what is uniquely provided by \(X_1\) or what can only be learned synergistically from both inputs.

### Axioms¶

The following three axioms were provided by Williams & Beer.

#### Symmetry¶

The redundancy \(\Icap{X_{0:n} : Y}\) is invariant under reorderings of \(X_i\).

#### Self-Redundancy¶

The redundancy of a single input is its mutual information with the output:

#### Monotonicity¶

The redundancy should only decrease with in inclusion of more inputs:

with equality if \(\mathcal{A}_{k-1} \subseteq \mathcal{A}_k\).

There have been other axioms proposed following from those of Williams & Beer.

## Measures¶

We now turn our attention a variety of methods proposed to flesh out this partial information decomposition.

```
In [11]: from dit.pid import *
```

### \(\Imin{\bullet}\)¶

\(\Imin{\bullet}\)[WB10] was Williams & Beer’s initial proposal for a redundancy measure. It is given by:

However, this measure has been criticized for acting in an unintuitive manner [GK14]:

```
In [12]: d = dit.Distribution(['000', '011', '102', '113'], [1/4]*4)
In [13]: PID_WB(d)
Out[13]:
+--------+--------+--------+
| I_min | I_r | pi |
+--------+--------+--------+
| {0:1} | 2.0000 | 1.0000 |
| {0} | 1.0000 | 0.0000 |
| {1} | 1.0000 | 0.0000 |
| {0}{1} | 1.0000 | 1.0000 |
+--------+--------+--------+
```

We have constructed a distribution whose inputs are independent random bits, and whose output is the concatenation of those inputs. Intuitively, the output should then be informed by one bit of unique information from \(X_0\) and one bit of unique information from \(X_1\). However, \(\Imin{\bullet}\) assesses that there is one bit of redundant information, and one bit of synergistic information. This is because \(\Imin{\bullet}\) quantifies redundancy as the least amount of information one can learn about an output given any single input. Here, however, the one bit we learn from \(X_0\) is, in a sense, orthogonal from the one bit we learn from \(X_1\). This observation has lead to much of the follow-on work.

### \(\Immi{\bullet}\)¶

One potential measure of redundancy is the *minimum mutual information* [BROJ13]:

This measure, though crude, is known to be correct for multivariate gaussian variables [OBR15].

### \(\Ida{\bullet}\)¶

Drawing inspiration from information-theoretic cryptography, this PID quantifies unique information using the Intrinsic Mutual Information:

While this seems intuitively plausible, it turns out that this leads to an inconsistent decomposition [BROJ13]; namely, in the bivariate case, if one were to compute redundancy using either unique information subtracted from that inputs mutual information with the output the value should be the same. There are examples where this is not the case:

```
In [14]: d = bivariates['prob 2']
In [15]: PID_downarrow(d)
Out[15]:
+--------+--------+--------+
| [31mI_da[0m | I_r | pi |
+--------+--------+--------+
| {0:1} | 1.0000 | 0.1887 |
| {0} | 0.3113 | 0.1887 |
| {1} | 0.5000 | 0.5000 |
| {0}{1} | 0.1226 | 0.1226 |
+--------+--------+--------+
```

Interestingly, compared to other measures the intrinsic mutual information seems to *overestimate* unique information. Since \(\I{X_0 : Y \downarrow X_1} \leq \min\left\{ \I{X_0 : Y | X_1}, \I{X_0 : Y} \right\} = \min\left\{ U_0 + S, U_0 + R\right\}\), where \(R\) is redundancy, \(U_0\) is unique information from input \(X_0\), and \(S\) is synergy, this implies that the optimization performed in computing the intrinsic mutual information is unable to completely remove either redundancy, synergy, or both.

### \(\Iwedge{\bullet}\)¶

Redundancy seems to intuitively be related to common information Common Informations. This intuition lead to the development of \(\Iwedge{\bullet}\) [GCJ+14]:

That is, redundancy is the information the Gács-Körner Common Information of the inputs shares with the output. This measure is known to produce negative partial information values in some instances.

### \(\Iproj{\bullet}\)¶

Utilizing information geometry, Harder et al [HSP13] have developed a strictly bivariate measure of redundancy, \(\Iproj{\bullet}\):

where

where \(C_{cl}(\bullet)\) denotes closure. Intuitively, this measures seeks to quantify redundancy as the minimum of how much \(p(Y | X_0)\) can be expressed when \(X_0\) is projected on to \(X_1\), and vice versa.

### \(\Ibroja{\bullet}\)¶

In a very intuitive effort, Bertschinger et al (henceforth BROJA) [BRO+14][GK14] defined unique information as the minimum conditional mutual informations obtainable while holding the input-output marginals fixed:

Note

In the bivariate case, Griffith independently suggested the same decomposition but from the viewpoint of synergy [GK14].

The BROJA measure has recently been criticized for behaving in an unintuitive manner on some examples. Consider the *reduced or* distribution:

```
In [16]: bivariates['reduced or']
Out[16]:
Class: Distribution
Alphabet: ('0', '1') for all rvs
Base: linear
Outcome Class: str
Outcome Length: 3
RV Names: None
x p(x)
000 1/2
011 1/4
101 1/4
In [17]: print(PID_BROJA(bivariates['reduced or']))
+---------+--------+--------+
| I_broja | I_r | pi |
+---------+--------+--------+
| {0:1} | 1.0000 | 0.6887 |
| {0} | 0.3113 | 0.0000 |
| {1} | 0.3113 | 0.0000 |
| {0}{1} | 0.3113 | 0.3113 |
+---------+--------+--------+
```

We see that in this instance BROJA assigns no partial information to either unique information. However, it is not difficult to argue that in the case that either input is a 1, that input then has unique information regarding the output.

#### \(\Iproj{\bullet}\) and \(\Ibroja{\bullet}\) are Distinct¶

In the BROJA paper [BRO+14] the only example given where their decomposition differs from that of Harder et al. is the `dit.example_dists.summed_dice()`

. We can find a simpler example where they differ using hypothesis:

```
In [18]: from hypothesis import find
In [19]: from dit.utils.testing import distributions
In [20]: find(distributions(3, 2, True), lambda d: PID_Proj(d) != PID_BROJA(d))
TypeErrorTraceback (most recent call last)
<ipython-input-20-e7c30edab0eb> in <module>()
----> 1 find(distributions(3, 2, True), lambda d: PID_Proj(d) != PID_BROJA(d))
TypeError: distributions() takes at most 2 arguments (3 given)
```

### \(\Iccs{\bullet}\)¶

Taking a pointwise point of view, Ince has proposed a measure of redundancy based on the coinformation [Inc17a]:

While this measure behaves intuitively in many examples, it also assigns negative values to some partial information atoms in some instances.

This decomposition also displays an interesting phenomena, that of *subadditive redundancy*. The **gband** distribution is an independent mix of a giant bit (redundancy of 1 bit) and the **and** distribution (redundancy of 0.1038 bits), and yet **gband** has 0.8113 bits of redundancy:

```
In [21]: PID_CCS(bivariates['gband'])
Out[21]:
+--------+--------+--------+
| I_ccs | I_r | pi |
+--------+--------+--------+
| {0:1} | 1.8113 | 0.0000 |
| {0} | 1.3113 | 0.5000 |
| {1} | 1.3113 | 0.5000 |
| {0}{1} | 0.8113 | 0.8113 |
+--------+--------+--------+
```

### \(\Idep{\bullet}\)¶

James et al [JEC17] have developed a method of quantifying unique information based on the Dependency Decomposition. Unique information from variable \(X_i\) is evaluated as the least change in sources-target mutual information when adding the constraint \(X_i Y\).

```
In [22]: PID_dep(bivariates['not two'])
Out[22]:
+--------+--------+--------+
| I_dep | I_r | pi |
+--------+--------+--------+
| {0:1} | 0.5710 | 0.5364 |
| {0} | 0.0200 | 0.0146 |
| {1} | 0.0200 | 0.0146 |
| {0}{1} | 0.0054 | 0.0054 |
+--------+--------+--------+
```

### \(\Ipm{\bullet}\)¶

Also taking a pointwise view, Finn & Lizier’s \(\Ipm{\bullet}\) [FL17] instead splits the pointwise mutual information into two components:

They then define two partial information lattices, one quantified locally by \(h(s)\) and the other by \(h(s|t)\). By averaging these local lattices and then recombining them, we arrive at a standard Williams & Beer redundancy lattice.

```
In [23]: PID_PM(bivariates['pnt. unq'])
Out[23]:
+--------+--------+--------+
| I_pm | I_r | pi |
+--------+--------+--------+
| {0:1} | 1.0000 | 0.0000 |
| {0} | 0.5000 | 0.5000 |
| {1} | 0.5000 | 0.5000 |
| {0}{1} | 0.0000 | 0.0000 |
+--------+--------+--------+
```

### \(\Irav{\bullet}\)¶

Taking a functional perspective as in \(\Iwedge\), \(\Irav\) defines bivariate redundancy as the maximum coinformation between the two sources \(X_0, X_1', a target :math:`Y\), and a deterministic function of the inputs \(f(X_0,X_1)\).

This measure is designed to exploit the conflation of synergy and redundancy in the three variable coinformation: \(\I{X_0\!:\!X_1\!:\!Y} = R - S\).

```
In [24]: PID_RAV(bivariates['pnt. unq'])
Out[24]:
+--------+--------+--------+
| I_RAV | I_r | pi |
+--------+--------+--------+
| {0:1} | 1.0000 | 0.0000 |
| {0} | 0.5000 | 0.5000 |
| {1} | 0.5000 | 0.5000 |
| {0}{1} | 0.0000 | 0.0000 |
+--------+--------+--------+
```

## Partial Entropy Decomposition¶

Ince [Inc17b] proposed applying the PID framework to decompose multivariate entropy (without considering information about a separate target variable). This *partial entropy decomposition* (PED), seeks to partition a mutlivariate entropy \(\H{X_0,X_1,\ldots}\) among the antichains of the variables. The PED perspective shows that bivariate mutual information is equal to the difference between redundant entropy and synergistic entropy.

### \(\Hcs{\bullet}\)¶

Taking a pointwise point of view, following \(\Iccs{\bullet}\), Ince has proposed a measure of redundant entropy based on the coinformation [Inc17b]:

While this measure behaves intuitively in many examples, it also assigns negative values to some partial entropy atoms in some instances. However, Ince [Inc17b] argues that concepts such as mechanistic information redundnacy (non-zero information redundancy between independent predictors, c.f. AND) necessitate negative partial entropy terms.

Like \(\Iccs{\bullet}\), \(\Hcs{\bullet}\) is also subadditive.

```
In [25]: PED_CS(dit.Distribution(['00','01','10','11'],[0.25]*4))
Out[25]:
+--------+--------+--------+
| H_cs | H_r | H_d |
+--------+--------+--------+
| {0:1} | 2.0000 | 0.0000 |
| {0} | 1.0000 | 1.0000 |
| {1} | 1.0000 | 1.0000 |
| {0}{1} | 0.0000 | 0.0000 |
+--------+--------+--------+
```