IIT - Sujets Avances : Partitionnement, Repertoires Cause-Effet et Reseaux Elargis

Plan de ce notebook

  1. Rappels et configuration - Reprise des concepts cles du notebook 1
  2. Partitionnement et MIP - Comment PyPhi cherche la coupe minimale d’information
  3. Repertoires cause-effet - Distributions de probabilites sur les causes et effets possibles
  4. MICE et concepts - Mechanismes maximalement irreductibles
  5. Big Phi vs Small Phi - Différence entre integration système et integration mécanisme
  6. Reseaux elargis - Systèmes a 4+ noeuds et interpretation
  7. Performance et coarse-graining - Stratégies pour traiter de grands systèmes
  8. Vers IIT 4.0 - Apercu des evolutions recentes de la théorie

Cadre. Ce notebook approfondit l’analyse : partitionnement du sous-système (MIP, SIA — system irreducibility analysis), répertoires cause-effet d’un mécanisme, construction des concepts (MICE/CES), et comparaison Big \(\Phi\) vs Small \(\Phi\).

Du côté ICT. Le partitionnement est précisément l’outil qui dissocie un mécanisme de ses purviews. La matrice des dissociations de l’ICT s’appuie sur cette gymnastique cause-effet pour croiser chaque notebook, claim et proxy — comprendre MIP et répertoires ici rend la matrice ICT lisible.

## 1. Rappels et configuration

Dans le notebook précédent, nous avons vu :

  • Reseau (Network) : un ensemble de noeuds binaires connectes, decrit par une TPM
  • Sous-système (Subsystem) : un sous-ensemble de noeuds dans un etat donne
  • Phi (big Phi, \(\Phi\)) : mesure de l’integration irreductible du système
  • CES (Cause-Effect Structure) : l’ensemble des concepts du système
  • Concept : un mécanisme avec son cause et son effet maximalement irreductibles

Reprenons avec notre reseau XOR et configurons PyPhi.

import warnings
warnings.filterwarnings("ignore", message=".*pkg_resources is deprecated.*", category=UserWarning)

import os
os.environ['PYPHI_WELCOME_OFF'] = 'yes'

import pyphi
import numpy as np

pyphi.config.VALIDATE_SUBSYSTEM_STATES = False

print("PyPhi version:", pyphi.__version__)
print("Configuration prete.")
PyPhi version: 1.2.0
Configuration prete.
# Creation du reseau XOR (3 noeuds) - identique au notebook 1
network = pyphi.examples.xor_network()
state = (0, 0, 0)
subsystem = pyphi.Subsystem(network, state)

print("Reseau XOR : 3 noeuds (A, B, C)")
print("Etat initial :", state)
print("Noeuds du sous-systeme :", subsystem.node_indices)
print("Connectivite (CM) :")
print(network.cm)
Reseau XOR : 3 noeuds (A, B, C)
Etat initial : (0, 0, 0)
Noeuds du sous-systeme : (0, 1, 2)
Connectivite (CM) :
[[0 1 1]
 [1 0 1]
 [1 1 0]]

Lecture. Le réseau XOR à 3 nœuds (A, B, C) est configuré avec une matrice de connectivité complète, chaque nœud étant connecté aux deux autres, ce qui permet une dynamique d’interaction totale entre les trois unités.

## 2. Partitionnement et MIP (Minimum Information Partition)

Le coeur du calcul de \(\Phi\) repose sur la recherche de la partition minimale d’information (MIP). La MIP est la facon de couper le système en deux qui detruit le moins d’information. Si cette coupe minimale detruit beaucoup d’information, c’est que le système est fortement integre.

2.1. Types de partitions

PyPhi supporte plusieurs types de partitions : - Bipartition : couper le système en 2 parties - Tripartition : couper en 3 parties - K-partition : couper en K parties

Pour chaque partition, on mesure l’information detruite par la coupe. La MIP est celle qui minimise cette perte.

# Calculer l'analyse d'irreductibilite du systeme (SIA)
sia = pyphi.compute.sia(subsystem)

print("=== System Irreducibility Analysis (SIA) ===")
print(f"Big Phi: {sia.phi}")
print(f"Coupe (MIP): {sia.cut}")
print(f"Partie from: {sia.cut.from_nodes}")
print(f"Partie to: {sia.cut.to_nodes}")
=== System Irreducibility Analysis (SIA) ===
Big Phi: 1.874999
Coupe (MIP): Cut [B] ━━/ /━━➤ [A, C]
Partie from: (1,)
Partie to: (0, 2)

2.2. Interpretation de la MIP

La MIP nous dit ou le système est le plus faiblement integre. Dans notre reseau XOR :

  • Ici, la coupe MIP separe le noeud {B} de {A, C} (cf. sortie de la cellule precedente : Cut [B] -> [A, C]) : cela signifie que l’integration de B avec le reste du systeme est le maillon le plus faible
  • Plus \(\Phi\) est eleve, plus le système est irreductiblement integre
  • Un \(\Phi = 0\) signifie que le système est completement decomposable (pas d’integration)

2.3. Complexite du partitionnement

Le calcul exact de \(\Phi\) est intractable pour de grands reseaux, à cause d’une explosion combinatoire. Pour chaque mécanisme possible (sous-ensemble d’éléments — il y en a \(2^n - 1\) pour un système à \(n\) noeuds), PyPhi doit énumérer toutes les bipartitions du purview pour trouver la coupe minimisante (la MIP). Un ensemble à \(n\) éléments admet \(2^{n-1}\) bipartitions : c’est exactement ce que compte la cellule suivante (4 pour \(n=3\)).

La même cellule affiche aussi les nombres de Bell, qui comptent toutes les partitions (en 2, 3, 4… parties), pas seulement les bipartitions. C’est pourquoi, pour \(n=3\), on observe 4 bipartitions mais 5 partitions de Bell : la partition en trois singletons \(\{0\}|\{1\}|\{2\}\) est comptée par Bell mais n’est pas une bipartition (une coupe sépare le système en deux parties, pas davantage). Les nombres de Bell croissent plus vite que les bipartitions, mais le MIP de l’IIT 3.0 ne parcourt que des bipartitions — l’intractabilité réelle provient surtout du produit « nombre de mécanismes \(\times\) bipartitions », répété pour chaque mécanisme.

# Enumerer toutes les bipartitions possibles du sous-systeme
from pyphi.partition import bipartition

nodes = subsystem.node_indices
all_biparts = list(bipartition(nodes))
print(f"Nombre de bipartitions pour {len(nodes)} noeuds : {len(all_biparts)}")
print("\nBipartitions possibles :")
for i, bp in enumerate(all_biparts):
    print(f"  {i+1}. {bp[0]} | {bp[1]}")

# Nombre de Bell pour les 6 premiers entiers
bell = [1, 1, 2, 5, 15, 52, 203]
print(f"\nNombres de Bell (nombre total de partitions):")
for n in range(len(bell)):
    print(f"  {n} noeuds -> {bell[n]} partitions")
Nombre de bipartitions pour 3 noeuds : 4

Bipartitions possibles :
  1. () | (0, 1, 2)
  2. (0,) | (1, 2)
  3. (1,) | (0, 2)
  4. (0, 1) | (2,)

Nombres de Bell (nombre total de partitions):
  0 noeuds -> 1 partitions
  1 noeuds -> 1 partitions
  2 noeuds -> 2 partitions
  3 noeuds -> 5 partitions
  4 noeuds -> 15 partitions
  5 noeuds -> 52 partitions
  6 noeuds -> 203 partitions

Lecture. Pour 3 nœuds, il existe 4 bipartitions possibles, et le nombre de Bell pour le nombre total de partitions est de 5, illustrant la croissance combinatoire rapide des partitions possibles avec la taille du système.

## 3. Repertoires cause-effet

Les repertoires cause et effet sont les distributions de probabilite qui decrivent comment un mécanisme contraint les etats passes (cause) et futurs (effet) d’un purview.

3.1. Repertoire cause

Le repertoire cause repond a la question : etant donne le mécanisme dans son etat actuel, quelles sont les probabilites des etats anterieurs possibles du purview ?

# Calculer le repertoire cause pour le mecanisme {A, B} et le purview {A}
mechanism = (0, 1)
purview = (0,)

cause_rep = subsystem.cause_repertoire(mechanism, purview)
print(f"Repertoire cause pour mecanisme {mechanism} -> purview {purview}:")
print(f"  Shape: {cause_rep.shape}")
print(f"  Valeurs: {cause_rep.flatten()}")
print(f"  Somme: {cause_rep.sum():.4f} (doit etre 1.0)")
Repertoire cause pour mecanisme (0, 1) -> purview (0,):
  Shape: (2, 1, 1)
  Valeurs: [0.5 0.5]
  Somme: 1.0000 (doit etre 1.0)
# Calculer le repertoire effet pour le meme mecanisme
effect_rep = subsystem.effect_repertoire(mechanism, purview)
print(f"Repertoire effet pour mecanisme {mechanism} -> purview {purview}:")
print(f"  Shape: {effect_rep.shape}")
print(f"  Valeurs: {effect_rep.flatten()}")
print(f"  Somme: {effect_rep.sum():.4f} (doit etre 1.0)")

print("\nComparaison cause vs effet:")
for i, label in enumerate(['A=0', 'A=1']):
    c_val = cause_rep.flatten()[i]
    e_val = effect_rep.flatten()[i]
    print(f"  {label}: cause={c_val:.3f}, effet={e_val:.3f}")
Repertoire effet pour mecanisme (0, 1) -> purview (0,):
  Shape: (2, 1, 1)
  Valeurs: [0.5 0.5]
  Somme: 1.0000 (doit etre 1.0)

Comparaison cause vs effet:
  A=0: cause=0.500, effet=0.500
  A=1: cause=0.500, effet=0.500

Interpretation : un mécanisme qui ne specifie aucune information

Les deux repertoires sont uniformes ([0.5, 0.5]) : le mécanisme {A, B} dans son etat actuel ne contraint ni le passe ni le futur du purview {A}.

  • En cause, savoir que {A, B} = (0, 0) ne modifie pas la probabilite des etats anterieurs de A : les deux restent equiprobables.
  • En effet, ce même mécanisme ne biaise pas davantage l’etat futur de A.

Autrement dit, ce couple (mécanisme, purview) ne specifie aucune information : son repertoire contraint est identique au repertoire non-perturbe (uniforme). C’est exactement ce que la section suivante va quantifier — la distance EMD entre le repertoire contraint et le repertoire non-perturbe sera nulle, confirmant l’absence d’information specifiee.

A l’inverse, un purview informatif produirait une distribution non uniforme (par exemple [0.75, 0.25]), revelant que le mécanisme penche vers un etat particulier du purview. C’est ce contraste qui fonde la notion de small phi (\(\varphi\)) etudiee plus loin.

3.2. Repertoire non-perturbe (unconstrained)

Le repertoire non-perturbe est la distribution uniforme - ce qu’on attendrait sans aucune contrainte. La différence entre le repertoire contraint et le repertoire non-perturbe mesure l’information specifiee par le mécanisme.

# Repertoire non-perturbe (uniforme)
unconstrained = subsystem.unconstrained_cause_repertoire(purview)
print(f"Repertoire non-perturbe pour purview {purview}:")
print(f"  Valeurs: {unconstrained.flatten()}")

from pyphi.distance import hamming_emd
distance = hamming_emd(cause_rep, unconstrained)
print(f"\nDistance EMD (cause contrainte vs non-perturbe): {distance:.4f}")
print("Cette valeur mesure l'information cause specifiee par le mecanisme.")
Repertoire non-perturbe pour purview (0,):
  Valeurs: [0.5 0.5]

Distance EMD (cause contrainte vs non-perturbe): 0.0000
Cette valeur mesure l'information cause specifiee par le mecanisme.

Lecture. « Distance EMD (cause contrainte vs non-perturbe): 0.0000 » — répertoire contraint [0.5 0.5] et non-perturbé [0.5 0.5] : identiques. Distance nulle, information nulle : pour le purview (0,) seul, le mécanisme (0, 1) ne spécifie rien au-delà du répertoire de base — l’information spécifiée vit sur les purviews plus larges (le MICE cause retient (0, 1, 2) avec phi=0.5).

Exercice 1 : Explorer les repertoires d’un mécanisme différent

Calculez les repertoires cause et effet pour le mécanisme {A, C} (noeuds 0 et 2) avec le purview {B, C} (noeuds 1 et 2).

Objectifs : 1. Calculer le repertoire cause et le repertoire effet 2. Verifier que chaque repertoire somme a 1.0 3. Identifier quel etat du purview est le plus probable en cause et en effet

Indices : - Utilisez subsystem.cause_repertoire(mechanism, purview) et subsystem.effect_repertoire(mechanism, purview) - Les noeuds sont indices par des tuples d’entiers : (0, 2) pour {A, C} - Pour identifier l’etat le plus probable, utilisez np.argmax(rep.flatten())

# Exercice 1 : Repertoires cause-effet pour le mecanisme {A, C} et purview {B, C}
# TODO etudiant : remplacez les valeurs None par votre code

mechanism_ex1 = None  # TODO : definir le mecanisme {A, C}
purview_ex1 = None    # TODO : definir le purview {B, C}

if mechanism_ex1 is not None and purview_ex1 is not None:
    cause_rep_ex1 = subsystem.cause_repertoire(mechanism_ex1, purview_ex1)
    effect_rep_ex1 = subsystem.effect_repertoire(mechanism_ex1, purview_ex1)
    
    print(f"Repertoire cause: {cause_rep_ex1.flatten()}")
    print(f"Somme cause: {cause_rep_ex1.sum():.4f}")
    print(f"Etat le plus probable (cause): {np.argmax(cause_rep_ex1.flatten())}")
    print(f"\nRepertoire effet: {effect_rep_ex1.flatten()}")
    print(f"Somme effet: {effect_rep_ex1.sum():.4f}")
    print(f"Etat le plus probable (effet): {np.argmax(effect_rep_ex1.flatten())}")
else:
    print("Exercice a completer : definissez mechanism_ex1 et purview_ex1")
Exercice a completer : definissez mechanism_ex1 et purview_ex1

## 4. MICE et Concepts

Un MICE (Maximally Irreducible Cause or Effect) est un couple (mécanisme, purview) qui maximise l’information irreductible. Un concept est forme d’un MICE cause et d’un MICE effet pour le même mécanisme.

4.1. Trouver le MICE pour un mécanisme

# Trouver le MICE (cause et effet) pour le mecanisme {A, B}
mechanism = (0, 1)

mice_cause = subsystem.find_mice(pyphi.Direction.CAUSE, mechanism)
mice_effect = subsystem.find_mice(pyphi.Direction.EFFECT, mechanism)

print("=== MICE pour le mecanisme {A, B} ===")
print("\nMICE Cause:")
print(f"  Purview: {mice_cause.purview}")
print(f"  Phi (small): {mice_cause.phi}")
print(f"  Direction: {mice_cause.direction}")
print("\nMICE Effet:")
print(f"  Purview: {mice_effect.purview}")
print(f"  Phi (small): {mice_effect.phi}")
print(f"  Direction: {mice_effect.direction}")
=== MICE pour le mecanisme {A, B} ===

MICE Cause:
  Purview: (0, 1, 2)
  Phi (small): 0.5
  Direction: CAUSE

MICE Effet:
  Purview: (2,)
  Phi (small): 0.5
  Direction: EFFECT

Lecture. Le MICE Cause pour {A, B} couvre tout le système comme purview avec Φ=0.5, tandis que le MICE Effet se concentre sur le nœud C seul, révélant une asymétrie entre l’intégration causale vers l’avant et vers l’arrière.

# Construire les concepts a partir de la CES
ces = pyphi.compute.ces(subsystem)
print(f"Nombre total de concepts dans la CES: {len(ces)}")
print("\nDetails de chaque concept :")
for i, concept in enumerate(ces):
    print(f"\n  Concept {i+1}:")
    print(f"    Mecanisme: {concept.mechanism}")
    if concept.cause:
        print(f"    Cause purview: {concept.cause.purview}, phi={concept.cause.phi:.4f}")
    if concept.effect:
        print(f"    Effet purview: {concept.effect.purview}, phi={concept.effect.phi:.4f}")
    print(f"    Phi du concept: {concept.phi:.4f}")
Nombre total de concepts dans la CES: 3

Details de chaque concept :

  Concept 1:
    Mecanisme: (0, 1)
    Cause purview: (0, 1, 2), phi=0.5000
    Effet purview: (2,), phi=0.5000
    Phi du concept: 0.5000

  Concept 2:
    Mecanisme: (0, 2)
    Cause purview: (0, 1, 2), phi=0.5000
    Effet purview: (1,), phi=0.5000
    Phi du concept: 0.5000

  Concept 3:
    Mecanisme: (1, 2)
    Cause purview: (0, 1, 2), phi=0.5000
    Effet purview: (0,), phi=0.5000
    Phi du concept: 0.5000

4.2. Interpretation des MICE

Chaque concept decrit une unite d’information cause-effet : - Le mécanisme est l’ensemble de noeuds qui specifie de l’information - Le purview cause est l’ensemble de noeuds dont le mécanisme contraint les etats passes - Le purview effet est l’ensemble de noeuds dont le mécanisme contraint les etats futurs - Le small phi (\(\varphi\)) mesure la quantite d’information irreductible du concept

Un concept avec \(\varphi > 0\) existe dans la CES du système. La somme de tous les \(\varphi\) des concepts ne donne PAS le big \(\Phi\).

## 5. Big Phi vs Small Phi

La distinction entre big Phi (\(\Phi\)) et small phi (\(\varphi\)) est fondamentale :

Big Phi (\(\Phi\)) Small phi (\(\varphi\))
Niveau Système entier Mécanisme individuel
Mesure Integration irreductible du système Information irreductible d’un concept
Question Le système est-il integre ? Ce mécanisme specifie-t-il de l’information ?
Calcul SIA sur toutes les partitions EMD entre repertoire contraint et partitionne 
# Comparaison Big Phi vs Small Phi
print("=== Big Phi (niveau systeme) ===")
print(f"  Phi du systeme (SIA): {sia.phi:.4f}")
print(f"  Coupe minimale: {sia.cut}")

print("\n=== Small Phi (niveau concept) ===")
total_small_phi = sum(c.phi for c in ces)
print(f"  Nombre de concepts: {len(ces)}")
print(f"  Somme des small phi: {total_small_phi:.4f}")
for i, c in enumerate(ces):
    print(f"    Concept {i+1}: mecanisme={c.mechanism}, phi={c.phi:.4f}")

print(f"\nBig Phi ({sia.phi:.4f}) != somme des small phi ({total_small_phi:.4f})")
print("Ce sont deux mesures differentes a des niveaux differents.")
=== Big Phi (niveau systeme) ===
  Phi du systeme (SIA): 1.8750
  Coupe minimale: Cut [B] ━━/ /━━➤ [A, C]

=== Small Phi (niveau concept) ===
  Nombre de concepts: 3
  Somme des small phi: 1.5000
    Concept 1: mecanisme=(0, 1), phi=0.5000
    Concept 2: mecanisme=(0, 2), phi=0.5000
    Concept 3: mecanisme=(1, 2), phi=0.5000

Big Phi (1.8750) != somme des small phi (1.5000)
Ce sont deux mesures differentes a des niveaux differents.

Lecture. La sortie corrige l’intuition elle-même : « Big Phi (1.8750) != somme des small phi (1.5000) » puis « Ce sont deux mesures differentes a des niveaux differents. » — le Big Phi n’est pas la somme des concepts (3 × 0.5 = 1.5 ≠ 1.875) : il mesure l’irréductibilité du système entier après la coupe minimale, les small phi mesurent les concepts un à un.

Exercice 2 : Comparer Phi pour deux etats du reseau

Calculez le big Phi et la CES pour le reseau XOR dans l’etat (1, 1, 1) et comparez avec l’etat (0, 0, 0).

Objectifs : 1. Créer un nouveau sous-système pour l’etat (1, 1, 1) 2. Calculer le SIA (big Phi) et la CES (concepts) 3. Comparer les résultats avec l’etat (0, 0, 0)

Indices : - pyphi.Subsystem(network, state) pour créer le sous-système - pyphi.compute.sia(subsystem) pour le big Phi - pyphi.compute.ces(subsystem) pour les concepts

# Exercice 2 : Comparer Phi pour deux etats
# TODO etudiant : remplacez les valeurs None par votre code

state_2 = None  # TODO : definir l'etat (1, 1, 1)

if state_2 is not None:
    subsystem_2 = pyphi.Subsystem(network, state_2)
    sia_2 = pyphi.compute.sia(subsystem_2)
    ces_2 = pyphi.compute.ces(subsystem_2)
    
    print(f"Etat {state}: Big Phi = {sia.phi:.4f}, Concepts = {len(ces)}")
    print(f"Etat {state_2}: Big Phi = {sia_2.phi:.4f}, Concepts = {len(ces_2)}")
    print(f"\nDifference Big Phi: {abs(sia.phi - sia_2.phi):.4f}")
else:
    print("Exercice a completer : definissez state_2 = (1, 1, 1)")
Exercice a completer : definissez state_2 = (1, 1, 1)

6.1. Reseau recurrent non-lineaire (4 noeuds)

Nous construisons un reseau a 4 noeuds en anneau ou chaque noeud depend de ses voisins via des portes non-lineaires (AND, OR). C’est l’occasion d’illustrer un point theorique central de l’IIT.

Pourquoi munir le 4-noeuds de portes AND/OR ? Écartons d’abord une idee recue : « un reseau purement XOR implique \(\Phi = 0\) » n’est pas une regle generale. L’anneau XOR a 3 noeuds du §1 est bien une application lineaire sur \(GF(2)\) (le XOR = addition modulo 2), mais il est recurrent et entierement connecte, donc non decomposable : PyPhi lui attribue \(\Phi = 1{,}875\) (cf. cellule 5 et le notebook IIT-1). La linearite sur \(GF(2)\) n’implique donc pas mecaniquement \(\Phi = 0\).

# Reseau 4 noeuds en anneau avec portes NON-LINEAIRES (AND/OR).
# NB : un anneau purement XOR serait lineaire sur GF(2) -> parfaitement
# decomposable -> Big Phi = 0 a tous les etats. Les portes AND/OR melangent
# l'information et rendent le reseau irreductiblement integre (Big Phi > 0).
tpm_4 = np.zeros((16, 4))
for i in range(16):
    bits = [(i >> j) & 1 for j in range(3, -1, -1)]  # bits = [A, B, C, D]
    A, B, C, D = bits
    a_next = int(B and C)   # porte AND (non-lineaire)
    b_next = int(A or D)    # porte OR  (non-lineaire)
    c_next = int(A and D)   # porte AND (non-lineaire)
    d_next = int(B or C)    # porte OR  (non-lineaire)
    tpm_4[i] = [a_next, b_next, c_next, d_next]

cm_4 = np.array([
    [0, 1, 1, 0],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [0, 1, 1, 0],
])

labels_4 = ('A', 'B', 'C', 'D')
net_4 = pyphi.Network(tpm_4, cm_4, node_labels=labels_4)

print("Reseau 4 noeuds en anneau (portes AND/OR, non-lineaire)")
print("Labels:", labels_4)
print("Connectivite:")
print(cm_4)
Reseau 4 noeuds en anneau (portes AND/OR, non-lineaire)
Labels: ('A', 'B', 'C', 'D')
Connectivite:
[[0 1 1 0]
 [1 0 0 1]
 [1 0 0 1]
 [0 1 1 0]]

Lecture du reseau 4 noeuds : un anneau NON-LINEAIRE

La matrice de connectivite decrit un anneau a 4 noeuds : chaque noeud a exactement deux voisins (A est relie a {B, C}, B a {A, D}, C a {A, D}, D a {B, C}). La subtilite est dans le choix des portes logiques :

  • A et C utilisent une porte AND (a_next = B and C, c_next = A and D)
  • B et D utilisent une porte OR (b_next = A or D, d_next = B or C)

Pourquoi pas du XOR pur ? Un anneau XOR est lineaire sur GF(2) : chaque sortie est une combinaison lineaire des entrees, le reseau est alors parfaitement decomposable et son Big \(\Phi\) vaut 0 a tous les etats. Les portes AND/OR introduisent de la non-linearite : elles melangent l’information de facon irreductible, ce qui garantit un Big \(\Phi > 0\). C’est ce que nous allons mesurer maintenant, en deux temps : d’abord la structure cause-effet (CES = l’ensemble des concepts du systeme), puis le Big \(\Phi\) (l’integration irreductible du systeme entier, via la partition MIP).

# Analyser le reseau 4 noeuds. On choisit un etat NON fixe (1, 1, 0, 0) :
# au pas suivant le reseau evolue vers (0, 1, 0, 1), ce qui illustre concretement
# la dynamique recurrente de l'anneau (la "recurrence"). Etat fixe ou non, les
# portes non-lineaires AND/OR garantissent un Big Phi > 0 (cf. §6.1).
state_4 = (1, 1, 0, 0)
sub_4 = pyphi.Subsystem(net_4, state_4)

print(f"Sous-systeme 4 noeuds, etat {state_4}")
print(f"Noeuds: {sub_4.node_indices}")

ces_4 = pyphi.compute.ces(sub_4)
print(f"\nNombre de concepts: {len(ces_4)}")
for i, c in enumerate(ces_4):
    cause_p = c.cause.purview if c.cause else None
    effect_p = c.effect.purview if c.effect else None
    print(f"  Concept {i+1}: mech={c.mechanism}, cause_p={cause_p}, "
          f"effect_p={effect_p}, phi={c.phi:.4f}")
Sous-systeme 4 noeuds, etat (1, 1, 0, 0)
Noeuds: (0, 1, 2, 3)

Computing concepts:   0%|          | 0/15 [00:00<?, ?it/s]
                                                          
Nombre de concepts: 4
  Concept 1: mech=(0,), cause_p=(1, 2), effect_p=(1, 2), phi=0.2500
  Concept 2: mech=(1,), cause_p=(0, 3), effect_p=(0, 3), phi=0.1667
  Concept 3: mech=(2,), cause_p=(0, 3), effect_p=(0, 3), phi=0.1667
  Concept 4: mech=(3,), cause_p=(1, 2), effect_p=(1, 2), phi=0.2500

Lecture. Le réseau : « Reseau 4 noeuds en anneau (portes AND/OR, non-lineaire) », chaque nœud relié à ses deux voisins — mais la comparaison mesurée réserve une leçon : Big Phi 4 nœuds = 0.2569 contre 1.8750 pour le XOR à 3 nœuds. La non-linéarité n’achète pas l’intégration : plus de mécanismes à évaluer, moins de Phi mesuré.

# Big Phi pour le reseau 4 noeuds
sia_4 = pyphi.compute.sia(sub_4)
print(f"Big Phi (4 noeuds): {sia_4.phi:.4f}")
print(f"Coupe MIP: {sia_4.cut}")
print(f"\nComparaison:")
print(f"  3 noeuds (XOR): Big Phi = {sia.phi:.4f}")
print(f"  4 noeuds (anneau non-lineaire): Big Phi = {sia_4.phi:.4f}")

Computing concepts:   0%|          | 0/15 [00:00<?, ?it/s]
                                                          

Evaluating Φ cuts:   0%|          | 0/14 [00:00<?, ?it/s]

Computing concepts:   0%|          | 0/11 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/11 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/13 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/11 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/13 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/13 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/11 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/11 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/13 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/13 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/11 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/13 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/11 [00:00<?, ?it/s]

                                                          

Computing concepts:   0%|          | 0/11 [00:00<?, ?it/s]

                                                          
                                                         
Big Phi (4 noeuds): 0.2569
Coupe MIP: Cut [A, B] ━━/ /━━➤ [C, D]

Comparaison:
  3 noeuds (XOR): Big Phi = 1.8750
  4 noeuds (anneau non-lineaire): Big Phi = 0.2569

6.2. Interpreter les résultats

Quelques observations importantes :

  1. Plus de noeuds ne signifie pas plus de Phi : la valeur de \(\Phi\) depend de la structure causale (non-linearite, integration), pas de la taille brute
  2. Les reseaux feed-forward ont Phi = 0 : pas de boucle causale = pas d’integration (voir l’Exercice 3)
  3. Les reseaux recurrents peuvent avoir Phi > 0 : notre anneau non-lineaire exhibe une integration irreductible — CES non-vide, \(\Phi > 0\), et une vraie coupe MIP (pas un NullCut)
  4. Decomposabilite topologique et effondrement de \(\Phi\) : a l’inverse du 3-noeuds (\(\Phi = 1{,}875\)), l’anneau 4-noeuds de cette section a une connectivite bipartite ({A, D} d’un cote, {B, C} de l’autre). Muni de portes XOR pures, cette topologie serait lineaire sur GF(2) et donc parfaitement decomposable : son Big Phi s’effondrerait theoriquement a 0, sans information irreductible. C’est precisement pour eviter ce piege que cette section emploie des portes AND/OR non-lineaires, qui preservent l’irreductibilite (Big Phi empirique = 0,2569, calcule ci-dessus). La lecon : ce n’est pas la linearite en soi qui detruit l’integration (le XOR 3-noeuds l’atteint a 1.875), c’est la decomposabilite topologique qu’elle autorise sur certaines structures — d’ou l’interet des portes non-lineaires AND/OR sur ce 4-noeuds.
  5. La symetrie de la connectivite influence la distribution des concepts

Lecture : non-lineaire OUI, mais faiblement integre

Les trois cellules ci-dessus livrent un resultat contre-intuitif, qu’il faut decomposer en deux niveaux.

1. La non-linearite a bien fait son travail. Le reseau 4 noeuds a un Big \(\Phi = 0.2569 > 0\) : contrairement a un anneau XOR pur (lineaire sur GF(2), \(\Phi = 0\)), les portes AND/OR rendent le systeme irreductiblement integre. La prediction de la cellule de definition est confirmee — il y a bien de l’integration.

2. Mais cette integration est faible — environ 7× inferieure au reseau XOR 3 noeuds. Le contraste est frappant :

Reseau Topologie Big \(\Phi\) Coupe MIP
3 noeuds (XOR, triangle complet) chaque noeud liee aux 2 autres 1.8750 {B} ─ {A,C}
4 noeuds (anneau AND/OR) cycle a 4 0.2569 {A,B} ─ {C,D}

Comment un reseau non-lineaire peut-il etre si peu integre face a un reseau lineaire (le XOR 3 noeuds) ? La reponse est dans la coupe MIP. Pour le 4-noeuds, la partition qui detruit le moins d’information separe proprement {A,B} de {C,D} : l’anneau a 4 admet une bipartition naturelle en deux moities symetriques qui interagissent peu entre elles. Le Big \(\Phi\) mesure le cout de la coupe la moins couteuse ; ici ce cout est faible, donc \(\Phi\) est faible. Le triangle 3-noeuds, lui, n’a pas de telle bipartition equitable — toute coupe isole un noeud unique du reste, ce qui detruit beaucoup d’information, d’ou un \(\Phi\) eleve.

3. La CES confirme cette symetrie. Les 4 concepts se groupent en deux paires identiques : les concepts de A et D (mecanismes \((0,)\) et \((3,)\)) ont tous deux \(\varphi = 0.25\) avec cause et effect portes sur {B, C} ; ceux de B et C (\((1,)\) et \((2,)\)) ont \(\varphi = 0.1667\) avec cause et effect portes sur {A, D}. Cette symetrie {A, D} \(\leftrightarrow\) {B, C} est la ligne de faille geometrique que la MIP exploite pour couper le reseau a bas cout.

Lecon IIT : plus de noeuds n’implique pas plus d’integration. Ce n’est ni la taille du reseau, ni meme la non-linearite de ses portes, qui determine \(\Phi\), mais la robustesse de l’integration face au partitionnement. Un petit reseau densement connecte peut etre bien plus integre qu’un grand reseau a topologie d’anneau, ou une bipartition naturelle existe. C’est pourquoi IIT definit \(\Phi\) comme le minimum sur toutes les partitions possibles : la MIP revele le maillon le plus faible, et c’est ce maillon qui borne l’integration du systeme entier.

## 7. Performance et coarse-graining

Le calcul exact de \(\Phi\) croit de maniere super-exponentielle avec la taille du reseau. Pour des reseaux de plus de ~6-8 noeuds, le calcul devient intractable.

7.1. Stratégies de gestion de la complexite

Stratégie Principe Utilite
Coarse-graining Grouper les noeuds en macro-noeuds Reduire la dimensionnalite
Blackboxing Ignorer certains noeuds Se concentrer sur les noeuds pertinents
Parallelisation Repartir les calculs Accelerer sur multi-coeur
Caching Stocker les résultats intermediaires Eviter les recalculs 
# Demonstration du module macro
print("=== Module pyphi.macro ===")
print("Le module macro offre des outils pour le coarse-graining et blackboxing.")
print("\nFonctions disponibles:")
macro_funcs = [f for f in dir(pyphi.macro) if not f.startswith('_')]
for f in macro_funcs[:12]:
    print(f"  - {f}")
=== Module pyphi.macro ===
Le module macro offre des outils pour le coarse-graining et blackboxing.

Fonctions disponibles:
  - Blackbox
  - CoarseGrain
  - ConditionallyDependentError
  - MacroNetwork
  - MacroSubsystem
  - NodeLabels
  - StateUnreachableError
  - Subsystem
  - SystemAttrs
  - all_blackboxes
  - all_coarse_grains
  - all_coarse_grains_for_blackbox
# Pourquoi le calcul exact de Phi est-il si couteux ? Explosion combinatoire.
#
# Le calcul de la CES (Cause-Effect Structure, concepts / petit phi) confronte,
# pour un sous-systeme de n elements :
#   - chaque MECANISME (tous les sous-ensembles non vides : 2^n - 1)
#   - a chaque PURVIEW (idem : 2^n - 1),
#   en calculant un phi de cause ET d'effet (EMD sur les partitions du purview).
# Le Big Phi (SIA) repete en plus ce calcul sur les DEUX cotes de CHAQUE
# bipartition du systeme (2^(n-1) - 1 coupes). Les comptes explosent :
print("Explosion combinatoire du calcul exact de Phi (comptes deterministes) :")
print(f"{'n':>3} | {'mecanismes (2^n-1)':>20} | {'paires mec/purv':>16} | {'bipartitions (2^(n-1)-1)':>26}")
print("-" * 72)
comptes = {}
for n in range(1, 9):
    mechs = 2**n - 1
    paires = mechs * mechs
    bipart = 2**(n - 1) - 1
    comptes[n] = (mechs, paires, bipart)
    print(f"{n:>3} | {mechs:>20} | {paires:>16} | {bipart:>26}")

# Verification empirique sur un reseau REEL (4 noeuds AND/OR). Le timing est
# honnete mais TROP PETIT pour etre lisible : ~0.01s = overhead Python (import,
# allocation), pas le cout combinatoire. C'est precisement pourquoi on illustre
# le cout par les COMPTES ci-dessus plutot que par un chronometre (le ratio entre
# deux reseaux de 3-4 noeuds est du bruit de demarrage).
import time
sub_demo = pyphi.Subsystem(net_4, (0, 0, 0, 0))
t0 = time.time()
_ = pyphi.compute.ces(sub_demo)
t4 = time.time() - t0
print(f"\nTiming reel sur le reseau 4-noeuds : {t4:.3f}s (= overhead Python, sous le seuil")
print("ou le cout combinatoire domine ; la courbe ne devient lisible qu'a n >= 5-6).")

# Conclusion tiree des donnees reelles (pas en dur) :
p7, p8 = comptes[7][1], comptes[8][1]
print(f"\nDe n=7 a n=8, les paires mecanisme/purview passent de {p7} a {p8} (facteur x{p8 / p7:.0f}) :")
print("croissance super-lineaire, confirmee par les comptes combinatoires (source reelle du cout).")
Explosion combinatoire du calcul exact de Phi (comptes deterministes) :
  n |   mecanismes (2^n-1) |  paires mec/purv |   bipartitions (2^(n-1)-1)
------------------------------------------------------------------------
  1 |                    1 |                1 |                          0
  2 |                    3 |                9 |                          1
  3 |                    7 |               49 |                          3
  4 |                   15 |              225 |                          7
  5 |                   31 |              961 |                         15
  6 |                   63 |             3969 |                         31
  7 |                  127 |            16129 |                         63
  8 |                  255 |            65025 |                        127

Timing reel sur le reseau 4-noeuds : 0.013s (= overhead Python, sous le seuil
ou le cout combinatoire domine ; la courbe ne devient lisible qu'a n >= 5-6).

De n=7 a n=8, les paires mecanisme/purview passent de 16129 a 65025 (facteur x4) :
croissance super-lineaire, confirmee par les comptes combinatoires (source reelle du cout).

Lecture : pourquoi on mesure des comptes (et non un simple chronometre)

La cellule precedente illustre le cout du calcul exact de \(\Phi\) par l’explosion combinatoire (comptes de mecanismes, de paires mecanisme/purview, de bipartitions) plutot que par un simple chronometrage. C’est un choix honnête :

  • Sur des reseaux-jouets de 3-4 noeuds, le temps de calcul est domine par l’overhead Python (import, allocation), pas par le cout combinatoire. Le rapport entre deux tels reseaux est alors du bruit de demarrage (un reseau de 4 noeuds peut apparaitre plus rapide qu’un reseau de 3), ce qui rend la courbe de chronometrage illisible a cette echelle.
  • Le vrai cout vient de la structure combinatoire : chaque mecanisme (\(2^n - 1\) sous-ensembles) doit etre confronte a chaque purview, et le Big Phi (SIA) repete l’operation sur les deux cotes de chaque bipartition (\(2^{n-1} - 1\) coupes). Les paires mecanisme/purview croissent deja de maniere exponentielle (\(\approx \times 4\) a chaque noeud ajoute – de \(16129\) a \(65025\) entre \(n=7\) et \(n=8\)). Et ce n’est qu’un debut : chaque paire declenche en plus un calcul sur les partitions du purview, dont le nombre suit les nombres de Bell (cf. section 2), de croissance super-exponentielle. Le cout total est donc bien super-exponentiel.
  • Consequence : au-dela de ~6-8 noeuds, le calcul exact devient intractable (des minutes, puis des heures). C’est ce qui motive les strategies de la section 7.1 (coarse-graining, blackboxing) et, en neuroscience, les approximations cliniques comme le PCI.

Honnêteté methodologique : affirmer une croissance « super-exponentielle » en s’appuyant sur le chronometrage de jouets dont le rapport est du bruit serait trompeur. Les comptes combinatoires ci-dessus sont la source reelle et mesurable du cout ; ils justifient rigoureusement l’intractabilite evoquee dans l’introduction de cette section.

7.2. Implications pour la recherche en neuroscience

Cette complexite computationnelle a des implications directes :

  • Le cerveau humain (~86 milliards de neurones) ne peut pas etre analyse avec le calcul exact
  • Les approximations (coarse-graining, echantillonnage) sont necessaires
  • Le Perturbational Complexity Index (PCI) est une approximation clinique inspiree de \(\Phi\)
  • Le debat entre exactitude mathematique et applicabilite pratique est central

## 8. Vers IIT 4.0

8.1. D’IIT 3.0 a IIT 4.0

Aspect IIT 3.0 (PyPhi) IIT 4.0 (2024+)
Identite Le complexe maximise \(\Phi\) Le système EST sa structure cause-effet
Existence intrinseque Via les concepts Axiome fondamental
Coupes Bipartitions Coupes directionnelles
Extension Potentiel a Phi maximal Ensemble des systèmes qui existent 
# Apercu : le concept-style (vers IIT 4.0)
try:
    cs_sia = pyphi.compute.sia_concept_style(subsystem)
    print("=== Concept-Style SIA (vers IIT 4.0) ===")
    print(f"Phi (concept-style): {cs_sia.phi:.4f}")
    print(f"Phi (classique 3.0): {sia.phi:.4f}")
    diff = abs(cs_sia.phi - sia.phi)
    print(f"Difference: {diff:.4f}")
    print("Le concept-style utilise un schema de partition different.")
except Exception as e:
    print(f"Concept-style non disponible: {e}")
=== Concept-Style SIA (vers IIT 4.0) ===
Phi (concept-style): 0.6250
Phi (classique 3.0): 1.8750
Difference: 1.2500
Le concept-style utilise un schema de partition different.

Exercice 3 : Explorer un reseau feed-forward

Construisez un reseau feed-forward a 3 noeuds (A -> B -> C) et verifiez que son big Phi est egal a 0.

Objectifs : 1. Créer la TPM d’un reseau ou A influence B et B influence C (pas de boucle) 2. Créer le reseau PyPhi avec la connectivite appropriee 3. Calculer le big Phi et verifier qu’il vaut 0

Indices : - La matrice de connectivite est triangulaire : [[0,1,0], [0,0,1], [0,0,0]] - Pour la TPM : B_next = A, C_next = B, A_next = A (ou une constante) - Utilisez pyphi.compute.sia(subsystem) pour calculer big Phi

# Exercice 3 : Reseau feed-forward (Phi attendu = 0)
# TODO etudiant : construisez le reseau et verifiez Phi = 0

# Etape 1 : Definir la TPM (8 etats -> 3 noeuds)
tpm_ff = None  # TODO : construire la TPM du reseau feed-forward

# Etape 2 : Matrice de connectivite
cm_ff = None   # TODO : A->B, B->C (pas de connexion C->A)

if tpm_ff is not None and cm_ff is not None:
    net_ff = pyphi.Network(tpm_ff, cm_ff)
    sub_ff = pyphi.Subsystem(net_ff, (0, 0, 0))
    sia_ff = pyphi.compute.sia(sub_ff)
    print(f"Big Phi du reseau feed-forward: {sia_ff.phi:.4f}")
    print(f"Phi = 0 confirme: {sia_ff.phi == 0.0}")
    print("Un reseau sans boucle causale n'a pas d'integration.")
else:
    print("Exercice a completer : definissez tpm_ff et cm_ff")
Exercice a completer : definissez tpm_ff et cm_ff

8.2. Limites et debats

L’IIT est une théorie active et debattue :

  • Lettre ouverte de 2023 : ~120 signataires qualifiant l’IIT de pseudoscience
  • Reponse des partisans : l’IIT fait des predictions falsifiables (PCI, activations)
  • Programme Templeton : tests adversariaux IIT vs Global Workspace Theory
  • Enjeu IA : l’IIT predit que les reseaux feed-forward (comme les LLMs) ont \(\Phi = 0\)

Ces debats illustrent la tension entre rigueur mathematique et applicabilite empirique.

Bilan et perspectives

Dans ce deuxieme notebook, nous avons approfondi :

  1. Le partitionnement MIP - la recherche de la coupe minimale d’information
  2. Les repertoires cause-effet - les distributions de probabilite au coeur de l’analyse IIT
  3. Les MICE et concepts - les unites d’information irreductible dans la CES
  4. Big Phi vs Small Phi - deux niveaux de mesure complementaires
  5. Les reseaux elargis - comment la complexite croit avec la taille du système
  6. Le coarse-graining - stratégies pour gerer l’intractabilite du calcul
  7. IIT 4.0 - les evolutions recentes de la théorie

Pour aller plus loin

  • Documentation PyPhi : pyphi.readthedocs.io
  • Article fondateur : Oizumi, Albantakis, Tononi (2014). From the Phenomenology to the Mechanisms of Consciousness
  • IIT 4.0 : Albantakis et al. (2023). Integrated information theory (IIT) 4.0
  • Series connexes : Probas, GameTheory

Où va la suite. IIT-3 passe à l’échelle : coarse-graining, blackboxing, et la question de savoir si \(\Phi\) survit au changement de résolution. Côté ICT, la cartographie en tresse articule Thom / Grothendieck / Schmidhuber / Friston — les quatre lentilles entre lesquelles le partitionnement navigue.

Retour au sommet