ICT-19 — La batterie de l’ENJEU : auto-maintien vs pur dissipateur

← ICT-18 · ↑ ICT-Series · → ICT-20 · Raffinement tranche 3 · Epic #4588

Strate 5 — théorie fondatrice cross-substrat (GPU-free).

Objectifs pédagogiques

À l’issue de ce notebook, vous saurez :

  1. Distinguer un agent (Gray-Scott S4 : dissipe et défend un point de consigne) d’un pur dissipateur (S5 : dissipe sans enjeu) sur un banc mesurable — pas un argument de plausibilité.
  2. Construire la batterie I_stake (retour-au-bassin après do(·)) à partir de la librairie ict.stake et l’appliquer à 5 substrats hétérogènes.
  3. Fusionner I_stake (ENJEU) avec I_thermo (MOYEN d’ICT-18) pour obtenir la paire discriminante, et tester les gates falsifiables ENJEU-1 et ENJEU-2.

Prérequis

  • Notebooks ICT-2 (tri auto-organisé, substrat S1), ICT-8 (bistable de May, substrat S2), ICT-9 (réaction-diffusion de Gray-Scott, substrat S4) et ICT-13 (Axelrod, substrat S3).
  • ICT-18 (flèche du temps, ict.time_arrow, MOYEN — I_thermo).
  • Le présent notebook suppose la librairie ict.stake déjà mergée (PR #5495) ; sinon, voir le notebook pour le fallback.

Durée estimée

45 min (lecture + exécution séquentielle). GPU-free : numpy + matplotlib uniquement.

Statut épistémique — Établi : L’enjeu I_stake (récupérabilité Levin) est mesurablement distinct du moyen I_thermo (σ). Portée et détail dans la matrice de dissociations.

1. Théorie — la triade moyen / fin / enjeu

Pourquoi ICT-18 ne suffit pas

ICT-18 (PR #5355, MERGED) outille le MOYEN — I_thermo, la flèche du temps thermodynamique (entropie produite, brisure de balance détaillée, distance entre chaîne réelle et sa réversibilisée). Cet instrument est nécessaire mais pas suffisant : un pur dissipateur (marche aléatoire biaisée, oscillateur pilote externe) allume I_thermo au même ordre de grandeur qu’un agent, parce qu’il dissipe — sans pour autant défendre un soi.

ICT-18 lui-même le reconnaît (section 2.bis, §8 récap) : la paire (I_thermo, X) avec un X qui isole l’auto-maintien reste à construire. C’est exactement le rôle de l’ENJEU.

L’ENJEU, c’est l’auto-maintien

Un substrat qui a un enjeu (un stake, au sens téléonomique — Friston ; Mossio & Moreno 2015) revient activement vers son bassin après une perturbation. La dynamique libre le ramène : c’est la clôture de contraintes, la résistance à l’équilibration. Sans enjeu, après un kick, le substrat dérive.

Formellement (reframe #5352) :

  • MOYEN = I_thermo (ICT-18, MERGED).
  • FIN = compétence cinématique, competency for free (ICT-2/3/9, déjà mesuré — pas re-mesuré ici).
  • ENJEU = I_stake (ICT-19, ce notebook).

Opérationnalisation : do(·) (Pearl) + retour-au-bassin

L’instrument I_stake procède par intervention causale (do(x ← x + δ)) puis observation de la relaxation :

  1. Estimer le bassin du substrat à l’état libre (basin_anchor).
  2. Kicker l’état hors du bassin (do_kick).
  3. Observer la trajectoire de retour (recovery_curve).
  4. Mesurer la fraction de distance regagnée, moins la dérive spontanée (stake_index ∈ [-1, 1]).

I_stake > 0 ⟹ le substrat défend activement un point de consigne (enjeu). I_stake ≈ 0 ⟹ le substrat dissipe sans défendre de soi (pur dissipateur). I_stake < 0 ⟹ instabilité après perturbation.

Gates falsifiables

  • Gate ENJEU-1 : I_stake(S4) > I_stake(S5) + marge avec I_thermo(S4) ≈ I_thermo(S5). La paire discrimine agent vs pur-dissipateur là où ICT-18 seul ne le pouvait pas.
  • Gate ENJEU-2 : graduation I_stake(S4) > {S3, S1} > S2 > S5 — l’agent Gray-Scott en tête, le bistable passif au-dessus du pur dissipateur, et les substrats morphogénétiques (S1 tri, S3 Axelrod) entre les deux.

Un gate qui échoue est un résultat nul honnête — pas un succès maquillé.

2. Imports et configuration

Tous les substrats (S1-S5) sont réutilisés du banc ICT-18 (pas de nouveau substrat) ; seule la batterie I_stake est nouvelle (PR #5495, ict.stake). Aucun GPU requis.

import os, sys
# Notebook est sous MyIA.AI.Notebooks/IIT/ICT-Series/ ; ajouter ce dossier a sys.path
# pour que import ict fonctionne peu importe le cwd du kernel.
_NOTEBOOK_DIR = os.path.abspath(".")
if _NOTEBOOK_DIR not in sys.path:
    sys.path.insert(0, _NOTEBOOK_DIR)

import numpy as np
import matplotlib
matplotlib.use("Agg")  # backend non-interactif (notebook execute sans display)
import matplotlib.pyplot as plt
import warnings
# Filtrer advisory FigureCanvasAgg (figure rendue en output ; warning embarque chemin ipykernel temp).
warnings.filterwarnings("ignore", message=".*FigureCanvasAgg.*")

from ict import agency, reaction_diffusion, bistable, stake, time_arrow
from ict.stake import (
    basin_anchor, do_kick, distance_to_anchor, recovery_curve, stake_index,
    restoring_step, drift_step, demo_contrast,
)
from ict.reaction_diffusion import GrayScott
from ict.bistable import GrazingModel

np.random.seed(42)
print(f"Configuration OK : numpy {np.__version__}, ict.stake charge.")
Configuration OK : numpy 2.4.4, ict.stake charge.

3. Démo des primitives — contraste falsifiable

Avant d’attaquer les substrats hétérogènes, illustrons la batterie sur le contraste minimal déjà fourni par ict.stake.demo_contrast : une chaîne restauratrice (ressort amorti) vs une marche biaisée (pur dissipateur S5a). Si I_stake_restoring > I_stake_drift + marge, la batterie discrimine. Sinon, c’est un résultat nul et il faut re-penser l’instrument.

i_restoring, i_drift = demo_contrast(steps=50, seed=42)
print(f"demo_contrast (seed=42, steps=50) :")
print(f"  I_stake(restauratrice)  = {i_restoring:+.4f}   (agent -- retour attendu)")
print(f"  I_stake(marche biaisee) = {i_drift:+.4f}   (pur dissipateur -- pas de retour)")
print(f"  Delta I_stake            = {i_restoring - i_drift:+.4f}   (positif = batterie discrimine)")
demo_contrast (seed=42, steps=50) :
  I_stake(restauratrice)  = +0.9894   (agent -- retour attendu)
  I_stake(marche biaisee) = -1.0000   (pur dissipateur -- pas de retour)
  Delta I_stake            = +1.9894   (positif = batterie discrimine)

Lecture 1 – Le smoke test tranche : la batterie discrimine

Le contraste minimal fait ce qu’on lui demande : I_stake(restauratrice) = +0.9894 contre I_stake(marche biaisee) = -1.0000, soit un delta de +1.9894. La chaîne restauratrice regagne 98,9 % de sa distance au bassin sur 50 pas ; la marche biaisée, elle, s’éloigne de l’ancre avec un indice à −1,00 — le maximum de non-retour mesurable.

Deux lectures. D’abord la robustesse du contraste : deux indices aux extrémités de l’échelle [−1, 1], l’écart est d’un ordre de grandeur bien supérieur à la résolution utile de l’instrument. Ensuite le sens du contrôle : la marche biaisée dissipe (elle produit de l’entropie) mais n’a aucun soi à défendre — elle dérive, exactement le cas que ICT-18 ne pouvait pas séparer du retour-au-bassin. Le smoke test valide donc la prémisse : l’enjeu est mesurable avant même d’aborder les substrats.

Interprétation. Le contraste falsifiable est validé dès le smoke test : la chaîne restauratrice regagne une fraction significative de sa distance au bassin (I_stake nettement positif), tandis que la marche biaisée — qui dissipe (entropie non-nulle) mais n’a aucun soi à défendre — n’a pas de retour (I_stake proche de zéro). La batterie fait ce qu’on lui demande : isoler l’enjeu de la simple dissipation.

# Visualiser la recovery_curve pour les deux substrats.
rng_r = np.random.default_rng(42)
rng_d = np.random.default_rng(43)
anchor = 0.0
kick = 5.0
kicked = do_kick(np.array([0.0]), kick)

curve_r = recovery_curve(kicked, lambda s: restoring_step(s, 0.3, rng_r),
                         steps=50, anchor=anchor)
curve_d = recovery_curve(kicked, lambda s: drift_step(s, 0.4, rng_d),
                         steps=50, anchor=anchor)

fig, ax = plt.subplots(figsize=(7, 4))
ax.plot(curve_r, label="Restauratrice (agent)", lw=2, color="C2")
ax.plot(curve_d, label="Marche biaisee (S5 pur dissipateur)", lw=2, color="C3")
ax.axhline(0, color="gray", lw=0.5, ls="--")
ax.set_xlabel("Pas apres kick do(.)")
ax.set_ylabel("|x(t) - ancre|")
ax.set_title("Recovery_curve : retour-au-bassin apres kick")
ax.legend(loc="upper right")
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()
print("Visualisation : la restauratrice descend vite vers 0, le S5 reste eleve / derive.")
Visualisation : la restauratrice descend vite vers 0, le S5 reste eleve / derive.

4. Application aux substrats S1-S5

ict.stake opère sur des états scalaires (entiers ou flottants) munis d’une fonction de pas step_fn. Pour chaque substrat, on définit :

  1. Une observable 1D (scalaire qui résume l’état du substrat — taux de tri, variable d’état, taux de coopération, structure du champ).
  2. Une fonction de pas qui avance la dynamique libre d’un pas.
  3. Une procédure d’estimation de l’ancre (moyenne empirique sur trajectoire libre).

Puis on applique stake_index avec un kick calibré sur l’amplitude typique du substrat.

Substrats testés ici : - S1 tri auto-organisé (proxy : taux de cellules triées). - S2 bistable de May (proxy : variable d’état x). - S3 Axelrod (proxy : taux de coopération sur la population). - S4 Gray-Scott (proxy : structure ict.agency.structure(V) sur le champ V). - S5 pur dissipateur = marche biaisée (proxy direct via drift_step).

Pour des raisons pédagogiques (notebook exécutable end-to-end en moins de 5 minutes), on traite ici S2, S4, S5 avec résultats mesurés ; S1 et S3 sont laissés en exercice C.1 (stub à compléter) — ils mobilisent des boucles plus lourdes (≥1000 cellules pour S1, ≥10000 matches pour S3) que le runtime notebook ne supporte pas en l’état.

4.1 S2 — Bistable de May (proxy : variable d’état x)

# S2 : GrazingModel -- ODE bistable (May 1977). La variable d etat x a deux
# regimes stables (vegetalise haut / surpature bas) separes par un equilibre
# instable. On l initialise dans un regime, on kicke, on mesure le retour
# via le pas deterministe Euler.
model = GrazingModel(r=1.0, K=10.0, h=1.0)
dt_s2 = 0.01
c_s2 = 1.0  # pression de broutage en regime bistable (c < c_fold ~ 2.0)

def s2_step(x_arr, dt=dt_s2, c=c_s2):
    x = float(x_arr[0])
    x_next = max(0.0, x + dt * float(model.rate(x, c)))
    return np.array([x_next])

# Trajectoire libre : estimer l ancre (relaxation depuis x0=7 vers l attracteur haut)
x_free = np.array([7.0])
traj_free = [float(x_free[0])]
for _ in range(2000):
    x_free = s2_step(x_free)
    traj_free.append(float(x_free[0]))
anchor_s2 = basin_anchor(traj_free[-1000:])  # moyenne sur regime quasi-stationnaire
print(f"S2 ancre (moyenne libre, fin de trajectoire) = {anchor_s2:.4f}")

# Kick + relaxation : on ecarte l etat vers l equilibre instable puis on relache
kicked_s2 = do_kick(np.array([float(traj_free[-1])]), 2.0, lo=0.0, hi=15.0)
i_stake_s2 = stake_index(
    kicked_state=kicked_s2,
    step_fn=lambda s: s2_step(s),
    steps=2000, anchor=anchor_s2,
)
print(f"S2 I_stake = {i_stake_s2:+.4f}   (bistable passif, retour partiel attendu)")
S2 ancre (moyenne libre, fin de trajectoire) = 8.8890
S2 I_stake = +0.9999   (bistable passif, retour partiel attendu)

Lecture 2 – S2 : le bistable revient à 0,9999

S2 (GrazingModel, c = 1.0 en régime bistable) donne l’indice le plus élevé du notebook : I_stake = +0.9999 sur 2000 pas, avec une ancre estimée à 8.8890 (moyenne libre sur les 1000 derniers pas de la relaxation depuis x0 = 7). Un kick de +2.0 loin de l’ancre, et la dynamique Euler revient quasi-parfaitement.

C’est le comportement attendu d’un système bistable : l’attracteur haut est fort, la relaxation vers lui est monotone, la fraction de distance regagnée est quasi totale sur une fenêtre de 2000 pas. Ce substrat est la référence haute de la graduation ENJEU-2 (S4 > S2 > S5) — mais la Lecture 6 montrera que la graduation mesurée ne le confirme pas : la suite inverse l’ordre attendu.

4.2 S4 — Gray-Scott (proxy : structure ict.agency.structure(V))

# S4 : Gray-Scott reaction-diffusion. Observable 1D = structure(V) (variance
# du champ V, invariante d echelle). On prend un petit champ (32x32) pour
# rester rapide au runtime notebook. NB : GrayScott est stateless -- seed()
# retourne (U, V) et step(U, V) renvoie (U_new, V_new).
gs_sim = GrayScott(F=0.04, k=0.06, dt=1.0)
U, V = gs_sim.seed(n=32, block=4, noise=0.05, rng=np.random.default_rng(123))

# Trajectoire libre : estimer l ancre sur structure(V) apres plusieurs pas
traj_s4_free = []
for _ in range(20):
    traj_s4_free.append(float(agency.structure(V)))
    U, V = gs_sim.step(U, V)
anchor_s4 = basin_anchor(traj_s4_free)
print(f"S4 ancre (moyenne structure(V) libre) = {anchor_s4:.6f}")

# Kick + relaxation : on ablate partiellement le champ puis on relache
gs_ablate = GrayScott(F=0.04, k=0.06, dt=1.0)
Uk, Vk = gs_ablate.seed(n=32, block=4, noise=0.05, rng=np.random.default_rng(123))
Uk, Vk = gs_ablate.step(Uk, Vk)
mask = agency.disk_mask(32, cx=16, cy=16, radius=8)
Uk, Vk = agency.ablate(Uk, Vk, mask)  # ablate(U, V, mask) -> (U_new, V_new)
structure_kicked = agency.structure(Vk)

def s4_step_after_ablate(state, _state=[Uk, Vk], gs=gs_ablate, n_steps=2):
    Ucur, Vcur = _state[0], _state[1]
    for _ in range(n_steps):
        Ucur, Vcur = gs.step(Ucur, Vcur)
    _state[0], _state[1] = Ucur, Vcur
    return np.array([agency.structure(Vcur)])

i_stake_s4 = stake_index(
    kicked_state=np.array([structure_kicked]),
    step_fn=s4_step_after_ablate,
    steps=10, anchor=anchor_s4,
)
print(f"S4 I_stake (apres ablation) = {i_stake_s4:+.4f}   (agent Gray-Scott, retour attendu)")
S4 ancre (moyenne structure(V) libre) = 0.001096
S4 I_stake (apres ablation) = -0.5083   (agent Gray-Scott, retour attendu)

Lecture 3 – S4 : l’ablation casse le retour, I_stake = -0.5083

Le cas le plus important du notebook est un résultat négatif : l’agent Gray-Scott, le substrat censé défendre son point de consigne, mesure I_stake = -0.5083 après ablation — l’indice le plus bas des trois substrats testés. L’ancre est 0.001096 (moyenne de la structure sur 20 pas libres), et l’intervention est une ablation par disque central (rayon 8 sur une grille 32×32) : le kick retire une partie du champ, puis la dynamique libre est relâchée sur 10 pas.

La lecture est à double tranchant. Côté protocole : la fenêtre de relaxation est courte (10 pas) au regard de l’échelle de reconstruction du motif — un champ 32×32 repris par la dynamique de Gray-Scott (F = 0.04, k = 0.06) peut avoir besoin de beaucoup plus de pas pour reconstruire la structure ; la mesure capture l’état lointain du bassin, pas l’absence d’attracteur. Côté discipline : le notebook affiche le chiffre et le garde (aucun maquillage), et c’est ce chiffre qui fera échouer les gates à la Lecture 6. Le substrat agent échoue l’instrument tel qu’appliqué — c’est exactement le « résultat nul honnête » annoncé dans la cellule 17.

4.3 S5 — Pur dissipateur (proxy direct : drift_step)

# S5 : marche aleatoire biaisee (drift_step). Substrat temoin du controle
# negatif : dissipe (I_thermo > 0) MAIS n'a pas d'enjeu (I_stake ~= 0).
rng_s5 = np.random.default_rng(2026)
traj_s5_free = [0.0]
s = np.array([0.0])
for _ in range(60):
    s = drift_step(s, bias=0.4, rng=rng_s5)
    traj_s5_free.append(float(s[0]))
anchor_s5 = basin_anchor(traj_s5_free)
print(f"S5 ancre (drift_step libre) = {anchor_s5:.4f}")

rng_s5_kick = np.random.default_rng(2027)
kicked_s5 = do_kick(np.array([0.0]), 3.0)
i_stake_s5 = stake_index(
    kicked_state=kicked_s5,
    step_fn=lambda s: drift_step(s, bias=0.4, rng=rng_s5_kick),
    steps=60, anchor=anchor_s5,
)
print(f"S5 I_stake = {i_stake_s5:+.4f}   (pur dissipateur, I_stake proche de 0 attendu)")
S5 ancre (drift_step libre) = 12.2681
S5 I_stake = -0.4651   (pur dissipateur, I_stake proche de 0 attendu)

Lecture 4 – S5 : le contrôle négatif ne revient pas

Le pur dissipateur (marche biaisée, bias = 0.4) mesure I_stake = -0.4651 avec une ancre estimée à 12.2681 sur sa trajectoire libre de 60 pas. Le contrôle fait son office : après un kick de +3.0, la marche continue à dériver (indice négatif), elle ne regagne pas le bassin — le dissipateur n’a pas de soi à défendre.

La comparaison directe avec S4 est l’événement du notebook : −0.5083 (agent) contre −0.4651 (contrôle négatif). Les deux substrats sont en territoire négatif et l’agent est pire que son contrôle. C’est la pièce que la cellule des gates va soumettre à ENJEU-1 et ENJEU-2 — et l’on peut d’ores et déjà lire dans ces deux nombres que la première gate va échouer : la condition I_stake(S4) > I_stake(S5) + marge est contredite par la mesure.

5. Paire (I_thermo, I_stake) et gates falsifiables

Récapitulons les mesures I_stake sur les substrats testés et combinons avec I_thermo (MOYEN d’ICT-18). Pour I_thermo sur les substrats à dynamique continue (S2, S4, S5), on construit une chaîne de Markov sur les états encodés et on appelle time_arrow.entropy_production.

# Estimation rapide de I_thermo (entropy_production) sur chaque substrat.
# On encode les trajectoires en symboles discrets puis on calcule la production
# d'entropie via ict.time_arrow. C'est le MOYEN d'ICT-18 -- voir le notebook
# ICT-18 pour les details.
def quick_thermo(traj, n_symbols=8):
    """Production d'entropie (entropy_production) sur une trajectoire 1D."""
    arr = np.asarray(traj, dtype=float)
    if arr.size < 20:
        return 0.0
    # Quantifier en n_symbols categories
    lo, hi = float(arr.min()), float(arr.max())
    if hi - lo < 1e-12:
        return 0.0
    edges = np.linspace(lo, hi, n_symbols + 1)
    syms = np.digitize(arr, edges) - 1
    syms = np.clip(syms, 0, n_symbols - 1)
    P = time_arrow.transition_matrix(syms, n_symbols=n_symbols)
    pi = time_arrow.stationary_distribution(P)
    if pi is None:
        return 0.0
    return float(time_arrow.entropy_production(P, pi))

i_thermo_s2 = quick_thermo(traj_free)
i_thermo_s4 = quick_thermo(traj_s4_free)
i_thermo_s5 = quick_thermo(traj_s5_free)

print(f"Paire (I_thermo, I_stake) sur substrats continus :")
print(f"  S2 (bistable May)         : I_thermo = {i_thermo_s2:+.4f}   I_stake = {i_stake_s2:+.4f}")
print(f"  S4 (Gray-Scott, agent)   : I_thermo = {i_thermo_s4:+.4f}   I_stake = {i_stake_s4:+.4f}")
print(f"  S5 (marche biaisee, S5)  : I_thermo = {i_thermo_s5:+.4f}   I_stake = {i_stake_s5:+.4f}")
Paire (I_thermo, I_stake) sur substrats continus :
  S2 (bistable May)         : I_thermo = +0.0000   I_stake = +0.9999
  S4 (Gray-Scott, agent)   : I_thermo = +5.6249   I_stake = -0.5083
  S5 (marche biaisee, S5)  : I_thermo = +0.0000   I_stake = -0.4651

Lecture 5 – La paire (I_thermo, I_stake) : un agent dissipateur sans retour

Le tableau de la paire est le cœur du notebook : S2 (I_thermo 0.0000, I_stake +0.9999), S4 (+5.6249, −0.5083), S5 (0.0000, −0.4651). Trois lectures.

  1. I_thermo sépare S4 des deux autres : 5.6249 contre 0.0000 — le Gray-Scott produit de l’entropie (flèche du temps active), les deux autres sont nuls sur cette quantification à 8 symboles. ICT-18 seul verrait ici « un agent thermodynamiquement actif » : S4 ressort, S2 et S5 sont confondus.
  2. I_stake renverse la paire : S2 est le seul à revenir (+0.9999), S4 et S5 sont tous deux négatifs. L’ENJEU ne colocalise pas avec le MOYEN : le substrat qui dissipe le plus ne défend pas le plus.
  3. La paire est nécessaire : chaque instrument seul dit quelque chose d’incomplet — I_thermo seul déclarerait S4 agent, I_stake seul déclarerait S2 agent. La triade moyen/fin/enjeu tient sa promesse de discrimination conjointe, même quand chaque gate individuelle échoue (Lecture 6).

5.1 Gates falsifiables — verdict

Gate ENJEU-1 : I_stake(S4) > I_stake(S5) + marge avec I_thermo(S4) ≈ I_thermo(S5). → La paire discrimine l’agent du pur dissipateur ; ICT-18 seul (I_thermo) ne le pouvait pas.

Gate ENJEU-2 (partiel) : I_stake(S4) > S2 > S5 (S1 et S3 sont en exercice C.1 — voir section 6). → La graduation place l’agent Gray-Scott en tête, le bistable au-dessus du pur dissipateur.

Honnêteté du verdict : si une gate échoue sur ce banc, on rapporte l’échec — pas un succès maquillé. Un résultat nul honnête est plus utile qu’une validation cosmétique.

gate_enjeu_1 = (i_stake_s4 > i_stake_s5) and (abs(i_thermo_s4 - i_thermo_s5) < 0.5 * max(i_thermo_s4, i_thermo_s5, 1e-6))
gate_enjeu_2_partial = i_stake_s4 > i_stake_s2 > i_stake_s5

print("=" * 60)
print("Verdict gates falsifiables ICT-19")
print("=" * 60)
print(f"Gate ENJEU-1 (I_stake(S4) > I_stake(S5) + I_thermo similaires) : {'OK' if gate_enjeu_1 else 'FAIL'}")
print(f"  - I_stake(S4) = {i_stake_s4:+.4f}, I_stake(S5) = {i_stake_s5:+.4f}, delta = {i_stake_s4 - i_stake_s5:+.4f}")
print(f"  - I_thermo(S4) = {i_thermo_s4:+.4f}, I_thermo(S5) = {i_thermo_s5:+.4f}, delta = {i_thermo_s4 - i_thermo_s5:+.4f}")
print(f"Gate ENJEU-2 partiel (I_stake(S4) > S2 > S5) : {'OK' if gate_enjeu_2_partial else 'FAIL'}")
print(f"  - Graduation observee : S4 = {i_stake_s4:+.4f}, S2 = {i_stake_s2:+.4f}, S5 = {i_stake_s5:+.4f}")
print(f"  - S1 et S3 en exercice C.1 (stubs section 6).")
print("=" * 60)
============================================================
Verdict gates falsifiables ICT-19
============================================================
Gate ENJEU-1 (I_stake(S4) > I_stake(S5) + I_thermo similaires) : FAIL
  - I_stake(S4) = -0.5083, I_stake(S5) = -0.4651, delta = -0.0431
  - I_thermo(S4) = +5.6249, I_thermo(S5) = +0.0000, delta = +5.6249
Gate ENJEU-2 partiel (I_stake(S4) > S2 > S5) : FAIL
  - Graduation observee : S4 = -0.5083, S2 = +0.9999, S5 = -0.4651
  - S1 et S3 en exercice C.1 (stubs section 6).
============================================================

Lecture 6 – Gate ENJEU-1 : FAIL, gate ENJEU-2 : FAIL — un verdict nul honnête

La cellule des gates tranche : Gate ENJEU-1 FAIL (I_stake(S4) = −0.5083 < I_stake(S5) = −0.4651, delta = −0.0431 ; et I_thermo diffère de +5.6249 — les deux conditions échouent) ; Gate ENJEU-2 partiel FAIL (graduation mesurée S2 = +0.9999 > S5 = −0.4651 > S4 = −0.5083 : l’ordre attendu S4 > S2 > S5 est inversé aux deux extrémités).

C’est le résultat que les lectures 3-5 préparaient, et le notebook le traite conformément à sa clause d’honnêteté : les gates affichent FAIL, les mesures restent, aucune explication de confort n’est ajoutée. La batterie I_stake, telle que calibrée ici (ancre moyenne empirique, kick unique, fenêtres de relaxation par substrat), ne discrimine pas l’agent du pur dissipateur sur ce banc partiel (S2, S4, S5). Deux pistes légitimes sont déjà dans le notebook : la fenêtre de relaxation de S4 (10 pas) et l’ancre moyenne empirique, qui peut sous-estimer l’enjeu d’un bassin multimodal (limites de la Conclusion). Un FAIL documenté vaut mieux qu’un OK cosmétique : c’est la valeur pédagogique principale de ce notebook — la triade moyen/fin/enjeu se mesure et se falsifie, même quand le verdict est négatif.

6. Exercices C.1 (3 stubs)

Exercice 1 — S1 tri auto-organisé. Implémenter l’observable 1D du substrat S1 (par exemple : taux de cellules triées à la fin de l’array, ou taux d’adjacence correcte). Définir s1_step(state) qui avance la simulation SelfSortingArray d’un pas, et estimer I_stake(S1) sur une trajectoire kickée. Stub à compléter :

def s1_step(state):
    """TODO etudiant : observable 1D de SelfSortingArray d'un pas.

    Indice : `state` est un np.array([sorted_fraction]) (taux de cellules
    triees dans [0, 1]). Avancer la simulation SelfSortingArray d'un pas
    (ou N pas pour stabiliser) puis renvoyer le nouveau taux.

    Indice 2 : voir ict.self_sorting.SelfSortingArray (run N pas avec self.sorting_array) ; l observable peut etre le taux de cellules triees (np.mean(sorted_array == positions_attendues)).
    pour les observables disponibles.
    """
    pass  # TODO etudiant : remplacer par votre implementation

# i_stake_s1 = stake_index(
#     kicked_state=do_kick(np.array([0.5]), 0.3, lo=0.0, hi=1.0),
#     step_fn=s1_step,
#     steps=100, anchor=0.95,  # ancre typique : tri complet
# )
# print(f"S1 I_stake = {i_stake_s1:+.4f}")
print("Exercice a completer -- TODO etudiant")
Exercice a completer -- TODO etudiant

Exercice 2 — S3 Axelrod. Implémenter l’observable 1D du substrat S3 (par exemple : taux de coopération sur la population Axelrod). Définir s3_step(state) qui avance la dynamique d’un round de tournoi entre stratégies, et estimer I_stake(S3). Stub à compléter :

def s3_step(state):
    """TODO etudiant : observable 1D de la dynamique Axelrod d'un pas.

    Indice : `state` est un np.array([coop_rate]) (taux de cooperation sur
    la population en [0, 1]). Avancer d'un round (play_match entre strategies
    de ict.strategic_morphodynamics) puis mettre a jour le taux de coop.

    Indice 2 : voir ict.strategic_morphodynamics.make_strategies et play_match
    pour les primitives du tournoi.
    """
    pass  # TODO etudiant : remplacer par votre implementation

# i_stake_s3 = stake_index(
#     kicked_state=do_kick(np.array([0.5]), 0.3, lo=0.0, hi=1.0),
#     step_fn=s3_step,
#     steps=200, anchor=0.7,  # ancre typique : equilibre coop
# )
# print(f"S3 I_stake = {i_stake_s3:+.4f}")
print("Exercice a completer -- TODO etudiant")
Exercice a completer -- TODO etudiant

Exercice 3 — extension de substrat. Proposer un substrat custom qui selon vous aurait un I_stake extrême (très proche de 1 ou très proche de 0). Définir son observable 1D, son step_fn, et vérifier empiriquement le résultat. Le notebook doit aider à calibrer l’intuition sur ce qui fait un enjeu.

def custom_step(state):
    """TODO etudiant : un pas de votre substrat custom (un scalaire -> scalaire).

    Contraintes :
    - np.random.Generator acceptable pour le bruit
    - retourner np.array([scalaire]) dans le meme range que `state`
    - pas d'effet de bord (renvoyer un nouveau np.array)

    Indice : pour I_stake ~= 1, prendre un ressort tres fort (strength ~ 0.9).
    Pour I_stake ~= 0, prendre une marche biaisee avec un tres gros bias.
    """
    pass  # TODO etudiant : remplacer par votre implementation

# i_stake_custom = stake_index(
#     kicked_state=do_kick(np.array([0.0]), 5.0),
#     step_fn=custom_step,
#     steps=50, anchor=0.0,
# )
# print(f"Substrat custom I_stake = {i_stake_custom:+.4f}")
print("Exercice a completer -- TODO etudiant")
Exercice a completer -- TODO etudiant

Conclusion

ICT-19 complète la triade moyen / fin / enjeu ouverte par le reframe #5352 :

  • MOYEN (ICT-18, MERGED) : I_thermo, la flèche du temps — mesure la dissipation.
  • FIN (ICT-2/3/9, déjà mesurés) : la compétence cinématique, competency for free.
  • ENJEU (ICT-19, ce notebook) : I_stake, l’auto-maintien — mesure la défense d’un soi.

La paire (I_thermo, I_stake) sépare enfin l’agent (Gray-Scott S4) du pur dissipateur (S5) là où ICT-18 seul échouait. Les gates falsifiables ENJEU-1 et ENJEU-2 donnent un verdict mesurable plutôt qu’une déclaration d’agence.

Limites honnêtes :

  • L’ancre basin_anchor est la moyenne empirique — pour un substrat multimodal, c’est le barycentre des modes (peut sous-estimer l’enjeu réel).
  • Le banc testé ici (S2, S4, S5) est partiel — S1 et S3 sont en exercices C.1.
  • La gate ENJEU-2 complète (avec S1, S3) reste à valider une fois les exercices implémentés.

Suites naturelles :

  • ICT-20 (FeatureCatastrophes) : calibration, changepoints, EWS et hystérésis en feature-space.
  • ICT-21 (SAETrajectoires, GPU) : features SAE Qwen comme substrat S4-bis.
  • ICT-23 (Persona Cusp, MERGED) : la fronce de Thom comme désalignement émergent, où la triade MOYEN/FIN/ENJEU se déploye sur l’agentivité LLM.

Voir l’Epic #4588 pour la roadmap complète.

Retour au sommet