From 12f64b9d000f4dbc9540f2665840fd325733485a Mon Sep 17 00:00:00 2001 From: jsboige Date: Sun, 27 Sep 2026 17:47:09 +0200 Subject: [PATCH 1/7] =?UTF-8?q?feat(ict,#18052):=20module=20ict/free=5Fcoo?= =?UTF-8?q?rdinates=20=E2=80=94=20banc=20executable=20strate=207=20(G=5Ft,?= =?UTF-8?q?=20coups=20ontologiques,=206=20proxys,=20predicteur=20espace=20?= =?UTF-8?q?fixe)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit See #18052 · See #7745 Co-Authored-By: Claude Sonnet 5 --- .../IIT/ICT-Series/ict/free_coordinates.py | 302 ++++++++++++++++++ .../ICT-Series/tests/test_free_coordinates.py | 159 +++++++++ 2 files changed, 461 insertions(+) create mode 100644 MyIA.AI.Notebooks/IIT/ICT-Series/ict/free_coordinates.py create mode 100644 MyIA.AI.Notebooks/IIT/ICT-Series/tests/test_free_coordinates.py diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ict/free_coordinates.py b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/free_coordinates.py new file mode 100644 index 0000000000..e886264923 --- /dev/null +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/free_coordinates.py @@ -0,0 +1,302 @@ +"""Free coordinates / freebits de second ordre — banc executable strate 7 (#18052, D1 #7745). + +Contexte +-------- +Aaronson (*The Ghost in the Quantum Turing Machine*, 2013) definit le **freebit** : +une incertitude *de Knight* sur la **valeur** d'une variable dans un espace **fixe** — +un point ``x in L`` que l'agent ne peut pas connaitre avant la mesure, et que la +physique (no-cloning, retrocausalite bornee) empeche de réduire a une distribution. +Le cadrage D1 de la strate 7 (#7745, ``strate7-cadres-libres.md``) pose l'objet +strictement plus fort : le **freebit de second ordre**, ou l'incertitude porte sur +**l'espace ``L`` lui-meme** — le choix, non canonique, d'une extension +``xi_t dans AdmExt(L_t)``. + +Ce module est le banc qui rend ce contraste **executable** : + +1. un **jeu evolutif** ``G_t = (N, L_t, A_t, U_t)`` en dataclasses gelees ; +2. des **coups internes** ``a in A_t`` (le jeu ne bouge pas) et des **coups + ontologiques** ``eta : G_t -> G_{t+1}`` (le jeu change d'espace) ; +3. un **mecanisme M** a quorum qui decide quelles extensions deviennent publiques ; +4. les **six proxys mesurables** du cadrage : ``O_t`` (expansion ontologique), + ``Delta A_t`` (ouverture politique), ``C_t = |AdmExt|`` (non-canonicite), + ``P(R)`` (pouvoir performatif, KL interventionnelle sur trajectoires simulees), + l'**institutionnalisation** (persistance apres retrait de l'instigateur) et + ``I(R)`` (dette d'irreversibilite) ; +5. le **pont Aaronson executable** : un predicteur bayesien d'espace fixe, dont la + log-perte sur un support connu est bornee par l'entropie, subit une surprise + **structurelle** (pas probabiliste) la premiere fois qu'une action hors de son + espace apparait — la difference exacte entre ignorer une valeur dans ``L`` et + ignorer ``L``. + +Le module est deterministe : toute stochasticite passe par un ``numpy.random.Generator`` +fourni par l'appelant. Aucune dependance hors numpy. +""" +from __future__ import annotations + +from dataclasses import dataclass, field, replace + +import numpy as np + +__all__ = [ + "EvolutiveGame", + "OntologicalMove", + "internal_move", + "apply_ontology", + "quorum_mechanism", + "expansion_ontology", + "political_opening", + "non_canonicity", + "simulate_trajectory", + "performative_power", + "institutionalization", + "irreversibility_debt", + "FixedSpacePredictor", +] + + +@dataclass(frozen=True) +class EvolutiveGame: + """Etat ``G_t`` de la strate 7 : agents, langage, actions, utilites. + + ``lexicon`` est l'espace des representations partagees ``L_t`` ; ``actions`` + est ``A_t``, genere par le langage ; ``payoffs`` mappe ``(agent, action)`` + vers l'utilite immediate. La prediction ``P_t`` du cadrage vit dans le + predicteur (cf. ``FixedSpacePredictor``), pas dans l'etat. + """ + + agents: tuple[str, ...] + lexicon: frozenset[str] + actions: frozenset[str] + payoffs: dict[tuple[str, str], float] = field(default_factory=dict) + + def payoff(self, agent: str, action: str) -> float: + return self.payoffs.get((agent, action), 0.0) + + +@dataclass(frozen=True) +class OntologicalMove: + """Un coup ontologique ``eta : G_t -> G_{t+1}``. + + ``new_concepts`` etendent ``L_t`` ; ``opened_actions`` mappe chaque concept + nouveau vers les actions qu'il rend jouables (c'est le lien ``O_t`` -> + ``Delta A_t`` : un concept ornemental n'ouvre rien). ``pose_cost`` et + ``undo_cost`` portent la dette d'irreversibilite ``I(R)``. + """ + + proposer: str + new_concepts: tuple[str, ...] + opened_actions: dict[str, tuple[str, ...]] + pose_cost: float = 1.0 + undo_cost: float = 10.0 + + +def internal_move(game: EvolutiveGame, agent: str, action: str) -> float: + """Coup interne ``a in A_t`` : retourne le paiement, le jeu est inchange.""" + if action not in game.actions: + raise ValueError(f"action {action!r} hors de A_t — coup interne seulement") + return game.payoff(agent, action) + + +def apply_ontology(game: EvolutiveGame, eta: OntologicalMove) -> EvolutiveGame: + """Applique ``eta`` : ``L_{t+1} = L_t + concepts``, ``A_{t+1} = A_t + ouvertes``. + + Les utilites des nouvelles actions derivent du concept qui les ouvre : + un concept ``c`` confere ``opened_payoff`` (defaut 1.0) a chaque action + qu'il ouvre — surchargeable en pre-etendant ``payoffs`` avant l'appel. + """ + opened = tuple(a for acts in eta.opened_actions.values() for a in acts) + payoffs = dict(game.payoffs) + for concept, acts in eta.opened_actions.items(): + for a in acts: + payoffs.setdefault((eta.proposer, a), 1.0) + for agent in game.agents: + payoffs.setdefault((agent, a), 0.5 if agent != eta.proposer else 1.0) + return replace( + game, + lexicon=game.lexicon | frozenset(eta.new_concepts), + actions=game.actions | frozenset(opened), + payoffs=payoffs, + ) + + +def quorum_mechanism( + game: EvolutiveGame, + proposals: tuple[OntologicalMove, ...], + votes: dict[str, set[str]], + quorum: int, +) -> tuple[EvolutiveGame, tuple[OntologicalMove, ...]]: + """Le mecanisme ``M`` : ne rend publics que les ``eta`` atteignant le quorum. + + ``votes[candidate]`` est l'ensemble des agents soutenant la candidature ``c`` + (identifiee par ses concepts). Retourne ``(G_{t+1}, etas_acceptes)`` — les + candidats rejetes sont silencieux : rien n'entre dans le jeu public. + """ + accepted: list[OntologicalMove] = [] + for eta in proposals: + key = ",".join(sorted(eta.new_concepts)) + if len(votes.get(key, ())) >= quorum: + accepted.append(eta) + result = game + for eta in accepted: + result = apply_ontology(result, eta) + return result, tuple(accepted) + + +def expansion_ontology(g0: EvolutiveGame, g1: EvolutiveGame) -> int: + """Proxy ``O_t = |L_{t+1} \\ L_t|`` — ouverture linguistique.""" + return len(g1.lexicon - g0.lexicon) + + +def political_opening(g0: EvolutiveGame, g1: EvolutiveGame) -> int: + """Proxy ``Delta A_t = |A_{t+1} \\ A_t|`` — garde-fou contre le verbiage.""" + return len(g1.actions - g0.actions) + + +def non_canonicity( + game: EvolutiveGame, + candidate_extensions: tuple[OntologicalMove, ...], +) -> int: + """Proxy ``C_t = |AdmExt(G_t)|`` — nombre d'extensions non equivalentes. + + Deux extensions sont equivalentes si elles ouvrent les **memes actions** + (a renommage de concept pres) : c'est la forme observable de l'equivalence + pour ce banc. Une famille dont toutes les paires ouvrent le meme jeu rend + ``C_t = 1`` : le prolongement est canonique, il n'y a rien a choisir. + """ + action_sets = set() + for eta in candidate_extensions: + extended = apply_ontology(game, eta) + action_sets.add(frozenset(extended.actions)) + return len(action_sets) + + +def simulate_trajectory( + game: EvolutiveGame, + horizon: int, + rng: np.random.Generator, + temperature: float = 0.5, +) -> dict[str, int]: + """Simule ``horizon`` coups internes : agents myopes en softmax sur ``U_t``. + + Retourne l'histogramme des actions jouees — l'observable sur lequel les + proxys interventionnels se mesurent. + """ + actions = sorted(game.actions) + if not actions: + return {} + counts = {a: 0 for a in actions} + agents = list(game.agents) + for _ in range(horizon): + for agent in agents: + logits = np.array( + [game.payoff(agent, a) / max(temperature, 1e-9) for a in actions] + ) + probs = np.exp(logits - logits.max()) + probs /= probs.sum() + chosen = actions[int(rng.choice(len(actions), p=probs))] + counts[chosen] += 1 + return counts + + +def performative_power( + game_do: EvolutiveGame, + game_skip: EvolutiveGame, + horizon: int, + n_sim: int, + rng: np.random.Generator, +) -> float: + """Proxy ``P(R)`` — KL empirique entre trajectoires sous ``do(eta)`` et ``do(-eta)``. + + ``D(Pr(traj | do(R)) || Pr(traj | do(not R)))`` est estimee par divergence KL + a lissage de Laplace sur les histograms d'actions des deux bras. Un coup + decoratif rend ``P(R) ~ 0``. + """ + def _dist(game: EvolutiveGame) -> dict[str, float]: + agg: dict[str, int] = {} + for _ in range(n_sim): + for a, c in simulate_trajectory(game, horizon, rng).items(): + agg[a] = agg.get(a, 0) + c + total = sum(agg.values()) + len(agg) + return {a: (c + 1) / total for a, c in agg.items()} + + p, q = _dist(game_do), _dist(game_skip) + support = set(p) | set(q) + kl = 0.0 + for a in support: + pa = p.get(a, 1e-12) + qa = q.get(a, 1e-12) + kl += pa * np.log(pa / qa) + return float(kl) + + +def institutionalization( + extended_game: EvolutiveGame, + eta: OntologicalMove, + horizon: int, + rng: np.random.Generator, +) -> float: + """Persistance du coup ``eta`` apres retrait de son instigateur. + + ``extended_game`` est le jeu APRES application de ``eta`` (l'appelant + controle donc les paiements des actions ouvertes — c'est eux, pas le coup, + qui decident de la survie). Retourne la **fraction des coups** (sur + ``horizon`` pas, joueurs reduits aux agents non-instigateurs) qui + utilisent encore les actions ouvertes par ``eta`` : proche de 0.0 = le + concept meurt avec son inventeur, > 0 = institutionnalise. + """ + survivors = tuple(a for a in extended_game.agents if a != eta.proposer) + if not survivors: + return 0.0 + reduced = replace(extended_game, agents=survivors) + opened = {a for acts in eta.opened_actions.values() for a in acts} + counts = simulate_trajectory(reduced, horizon, rng) + played = sum(counts.values()) + if played == 0: + return 0.0 + return float(sum(c for a, c in counts.items() if a in opened) / played) + + +def irreversibility_debt(eta: OntologicalMove) -> float: + """Proxy ``I(R) = cout(defaire) / cout(poser)`` — asymetrie creation/dissolution.""" + if eta.pose_cost <= 0: + raise ValueError("pose_cost doit etre positif") + return eta.undo_cost / eta.pose_cost + + +class FixedSpacePredictor: + """Le predicteur d'espace fixe — la jambe Aaronson du banc. + + Apprend ``p(a)`` par comptage sur ``A`` fixe. Sa log-perte sur un support + connu est bornee par l'entropie empirique : c'est le regime du freebit + d'Aaronson (ignorer une **valeur** dans un espace donne). La premiere action + hors de ``A`` ne lui coute pas une grande perte : elle lui revele que son + espace etait le mauvais objet — ``surprise_structurelle`` la quantifie en + bits de coordination manquante (``log2(|A| + 1)``, le +1 etant la porte + que l'espace n'avait pas). + """ + + def __init__(self, actions: tuple[str, ...]) -> None: + if not actions: + raise ValueError("espace d'actions vide") + self.actions = tuple(actions) + self._counts: dict[str, int] = {a: 0 for a in self.actions} + + def update(self, action: str) -> None: + if action not in self._counts: + raise KeyError( + f"action {action!r} hors de l'espace fixe — le predicteur ne peut " + "pas la representez (c'est le fait experimental, pas un bug)" + ) + self._counts[action] += 1 + + def log_loss(self, action: str, epsilon: float = 0.0) -> float: + """Log-perte naturelle en bits ; ``epsilon`` lisse le zero-count.""" + if action not in self._counts: + return self.surprise_structurelle() + total = sum(self._counts.values()) + epsilon * len(self.actions) + p = (self._counts[action] + epsilon) / total + return float(-np.log2(max(p, 1e-12))) + + def surprise_structurelle(self) -> float: + """Perte d'un point hors support, en bits : ``log2(|A| + 1)``.""" + return float(np.log2(len(self.actions) + 1)) diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/tests/test_free_coordinates.py b/MyIA.AI.Notebooks/IIT/ICT-Series/tests/test_free_coordinates.py new file mode 100644 index 0000000000..5f860c8e0b --- /dev/null +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/tests/test_free_coordinates.py @@ -0,0 +1,159 @@ +"""Tests de ``ict.free_coordinates`` — banc executable strate 7 (#18052).""" +from __future__ import annotations + +import sys +from pathlib import Path + +import numpy as np +import pytest + +sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) + +from ict.free_coordinates import ( # noqa: E402 + EvolutiveGame, + FixedSpacePredictor, + OntologicalMove, + apply_ontology, + expansion_ontology, + institutionalization, + internal_move, + irreversibility_debt, + non_canonicity, + performative_power, + political_opening, + quorum_mechanism, +) + + +def _game() -> EvolutiveGame: + return EvolutiveGame( + agents=("alice", "bob"), + lexicon=frozenset({"echange"}), + actions=frozenset({"vendre", "garder"}), + payoffs={ + ("alice", "vendre"): 1.0, + ("alice", "garder"): 0.4, + ("bob", "vendre"): 0.3, + ("bob", "garder"): 1.0, + }, + ) + + +def _eta_personne_morale() -> OntologicalMove: + return OntologicalMove( + proposer="alice", + new_concepts=("personne-morale",), + opened_actions={"personne-morale": ("signer", "posseder")}, + pose_cost=1.0, + undo_cost=50.0, + ) + + +def test_internal_move_paye_et_ne_change_rien(): + g = _game() + assert internal_move(g, "alice", "vendre") == 1.0 + assert internal_move(g, "bob", "garder") == 1.0 + + +def test_internal_move_rejette_action_hors_espace(): + with pytest.raises(ValueError): + internal_move(_game(), "alice", "signer") + + +def test_apply_ontology_etend_lexique_et_actions(): + g0, eta = _game(), _eta_personne_morale() + g1 = apply_ontology(g0, eta) + assert expansion_ontology(g0, g1) == 1 + assert political_opening(g0, g1) == 2 + assert "signer" in g1.actions + assert internal_move(g1, "alice", "signer") == 1.0 + + +def test_concept_ornamental_nouvre_rien(): + g0 = _game() + eta = OntologicalMove( + proposer="bob", + new_concepts=("poesie",), + opened_actions={}, + ) + g1 = apply_ontology(g0, eta) + assert expansion_ontology(g0, g1) == 1 + assert political_opening(g0, g1) == 0 + + +def test_quorum_rejette_puis_accepte(): + g0, eta = _game(), _eta_personne_morale() + _, rejected = quorum_mechanism(g0, (eta,), votes={}, quorum=2) + assert rejected == () + votes = {"personne-morale": {"alice", "bob"}} + g1, accepted = quorum_mechanism(g0, (eta,), votes=votes, quorum=2) + assert len(accepted) == 1 + assert "signer" in g1.actions + + +def test_non_canonicite_une_seule_extension_equivalente(): + g0 = _game() + e1 = OntologicalMove("alice", ("personne-morale",), {"personne-morale": ("signer", "posseder")}) + e2 = OntologicalMove("bob", ("societe",), {"societe": ("signer", "posseder")}) + e3 = OntologicalMove("bob", ("hypotheque",), {"hypotheque": ("nantir",)}) + assert non_canonicity(g0, (e1, e2)) == 1 + assert non_canonicity(g0, (e1, e2, e3)) == 2 + assert non_canonicity(g0, (e1,)) == 1 + + +def test_performative_power_coup_fort_vs_decoratif(): + rng = np.random.default_rng(42) + g0, eta = _game(), _eta_personne_morale() + g1 = apply_ontology(g0, eta) + p_fort = performative_power(g1, g0, horizon=20, n_sim=8, rng=rng) + deco = OntologicalMove("alice", ("ornement",), {"ornement": ("vendre2",)}) + g_deco = apply_ontology(g0, deco) + for agent in g_deco.agents: + g_deco.payoffs[(agent, "vendre2")] = g_deco.payoffs[(agent, "vendre")] + p_deco = performative_power(g_deco, g0, horizon=20, n_sim=8, rng=rng) + assert p_fort > 0.05 + assert p_deco < p_fort + + +def test_institutionnalisation_depend_des_paiements_des_autres(): + g0, eta = _game(), _eta_personne_morale() + rng = np.random.default_rng(7) + rate = institutionalization(apply_ontology(g0, eta), eta, horizon=60, rng=rng) + assert 0.0 < rate < 1.0 + egoiste = OntologicalMove( + proposer="alice", + new_concepts=("jargon-prive",), + opened_actions={"jargon-prive": ("jargonner",)}, + ) + g_ego = apply_ontology(g0, egoiste) + for agent in g_ego.agents: + g_ego.payoffs[(agent, "jargonner")] = -2.0 # les autres EVITENT le jargon prive + assert institutionalization(g_ego, egoiste, horizon=60, rng=rng) < 0.05 + + +def test_irreversibilite_est_un_ratio(): + assert irreversibility_debt(_eta_personne_morale()) == 50.0 + + +def test_predicteur_espace_fixe_perte_bornee_sur_support(): + pred = FixedSpacePredictor(("vendre", "garder")) + for _ in range(50): + pred.update("vendre") + for _ in range(50): + pred.update("garder") + perte = max(pred.log_loss(a, epsilon=1.0) for a in ("vendre", "garder")) + assert perte <= 2.0 + + +def test_predicteur_surprise_structurelle_hors_support(): + pred = FixedSpacePredictor(("vendre", "garder")) + assert pred.log_loss("signer") == pytest.approx(np.log2(3)) + with pytest.raises(KeyError): + pred.update("signer") + + +def test_surprise_structurelle_croit_avec_l_espace(): + assert ( + FixedSpacePredictor(("a",)).surprise_structurelle() + < FixedSpacePredictor(tuple("abcd")).surprise_structurelle() + ) From 647dd324ad999631fa42d606df7a336cc4415c0a Mon Sep 17 00:00:00 2001 From: jsboige Date: Sun, 27 Sep 2026 18:05:41 +0200 Subject: [PATCH 2/7] =?UTF-8?q?feat(ict,#18052):=20ICT-46=20=E2=80=94=20pr?= =?UTF-8?q?emiere=20livraison=20strate=207,=20freebits=20de=20second=20ord?= =?UTF-8?q?re=20en=20organe=20executable?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Notebook 29 cellules (9 code, papermill 0 erreur) : banc G_t, pont Aaronson ordre 1 vs ordre 2, six proxys executes, deux lectures graduées, gap Mathlib, 3 exercices stubbes C.1. See #18052 · See #16781 · See #7745 Co-Authored-By: Claude Sonnet 5 --- .../ICT-46-Strate7-FreeCoordinates.ipynb | 850 ++++++++++++++++++ 1 file changed, 850 insertions(+) create mode 100644 MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb new file mode 100644 index 0000000000..040c7b281e --- /dev/null +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb @@ -0,0 +1,850 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e732b4cb", + "metadata": { + "papermill": { + "duration": 0.003806, + "end_time": "2026-09-27T16:05:00.656289", + "exception": false, + "start_time": "2026-09-27T16:05:00.652483", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "# ICT-46 — Strate 7 : freebits de second ordre, le banc exécutable\n", + "\n", + "**Première livraison de la strate 7** (issue [#18052](https://github.com/jsboige/CoursIA/issues/18052), veine 3 de l'Epic Aaronson [#16781](https://github.com/jsboige/CoursIA/issues/16781)). Le cadrage D1 [#7745](https://github.com/jsboige/CoursIA/issues/7745) posait l'objet — les *free coordinates* / freebits de second ordre — et ses six proxys mesurables, en prose ([`strate7-cadres-libres.md`](https://github.com/jsboige/CoursIA/blob/main/docs/ict/strate7-cadres-libres.md)). Ce notebook est l'organe : il fait **tourner** le contraste qui définit la strate.\n", + "\n", + "**L'étage Aaronson (ordre 1).** Dans *The Ghost in the Quantum Turing Machine* (2013), Scott Aaronson propose le **freebit** : une incertitude *de Knight* — non réductible à une distribution de probabilité — sur la **valeur** d'une variable dans un espace **fixé**. Le cerveau amplifierait de tels bits quantiques microscopiques ; le libre arbitre y trouverait un ancrage *physique* dans les conditions aux limites de l'univers plutôt que dans les lois dynamiques. Aaronson se dit lui-même sceptique de son image (abstract : *\"of which I myself remain skeptical\"*), et la présente comme un exercice de *model-building* falsifiable.\n", + "\n", + "**L'étage strate 7 (ordre 2).** Le cadrage ICT pose la question strictement plus forte : et si l'incertitude ne portait pas sur une *valeur dans un espace donné*, mais sur **l'espace lui-même** — le choix, non canonique, de l'extension par laquelle un système se dote de coordonnées qu'il n'avait pas ? C'est le saut du freebit d'Aaronson au freebit de second ordre.\n", + "\n", + "**Ce que ce notebook démontre, de façon exécutable :**\n", + "\n", + "1. un prédicteur d'espace fixé ne peut être *surpris structurellement* que par ce qui n'est pas dans son espace (§2) ;\n", + "2. le coup ontologique — ajouter une coordonnée — est mesurable par six proxys indépendants, dont trois au moins sont non triviaux ici (§3-§6) ;\n", + "3. les deux lectures du geste d'Aaronson coexistent avec leurs grades (§7), sous le contrat de falsifiabilité [#7291](https://github.com/jsboige/CoursIA/issues/7291).\n", + "\n", + "Compagnon : module [`ict/free_coordinates.py`](ict/free_coordinates.py) (12 tests verts dans `tests/test_free_coordinates.py`)." + ] + }, + { + "cell_type": "markdown", + "id": "424313fc", + "metadata": { + "papermill": { + "duration": 0.004111, + "end_time": "2026-09-27T16:05:00.663833", + "exception": false, + "start_time": "2026-09-27T16:05:00.659722", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 1. Le banc : jeu évolutif $G_t$ et deux types de coups\n", + "\n", + "Le cadrage D1 définit l'état de la strate 7 comme un **jeu évolutif** $G_t = (N, L_t, A_t, U_t)$ — agents, langage, actions, utilités. Deux types de coups : les **internes** $a \\in A_t$ (le jeu ne bouge pas) et les **ontologiques** $\\eta : G_t \\to G_{t+1}$ (le jeu change d'espace). Nous instancions le banc minimal : deux agents, un lexique d'un concept, deux actions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "81df13de", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:00.674201Z", + "iopub.status.busy": "2026-09-27T16:05:00.673962Z", + "iopub.status.idle": "2026-09-27T16:05:01.580420Z", + "shell.execute_reply": "2026-09-27T16:05:01.579913Z" + }, + "papermill": { + "duration": 0.91297, + "end_time": "2026-09-27T16:05:01.581332", + "exception": false, + "start_time": "2026-09-27T16:05:00.668362", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "G0 : 2 agents, 1 concept(s), 2 action(s)\n", + "internal_move(alice, vendre) = 1.0 — G0 inchange : 2 action(s)\n" + ] + } + ], + "source": [ + "import sys\n", + "sys.path.insert(0, \".\")\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from ict.free_coordinates import (\n", + " EvolutiveGame, OntologicalMove, internal_move, apply_ontology,\n", + " quorum_mechanism, expansion_ontology, political_opening, non_canonicity,\n", + " simulate_trajectory, performative_power, institutionalization,\n", + " irreversibility_debt, FixedSpacePredictor,\n", + ")\n", + "\n", + "G0 = EvolutiveGame(\n", + " agents=(\"alice\", \"bob\"),\n", + " lexicon=frozenset({\"echange\"}),\n", + " actions=frozenset({\"vendre\", \"garder\"}),\n", + " payoffs={\n", + " (\"alice\", \"vendre\"): 1.0, (\"alice\", \"garder\"): 0.4,\n", + " (\"bob\", \"vendre\"): 0.3, (\"bob\", \"garder\"): 1.0,\n", + " },\n", + ")\n", + "print(\"G0 :\", len(G0.agents), \"agents,\", len(G0.lexicon), \"concept(s),\", len(G0.actions), \"action(s)\")\n", + "\n", + "# Coup interne : le paiement est lu, l'espace ne bouge pas.\n", + "p = internal_move(G0, \"alice\", \"vendre\")\n", + "print(f\"internal_move(alice, vendre) = {p} — G0 inchange : {len(G0.actions)} action(s)\")" + ] + }, + { + "cell_type": "markdown", + "id": "daf94d68", + "metadata": { + "papermill": { + "duration": 0.002179, + "end_time": "2026-09-27T16:05:01.585870", + "exception": false, + "start_time": "2026-09-27T16:05:01.583691", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Lecture du résultat\n", + "\n", + "Le coup interne est la strate 6 : un agent *dans* un jeu fixé. Tout ce qui suit s'intéresse au moment où l'agent (ou le mécanisme) *transforme le jeu lui-même*." + ] + }, + { + "cell_type": "markdown", + "id": "b3f283eb", + "metadata": { + "papermill": { + "duration": 0.002097, + "end_time": "2026-09-27T16:05:01.592365", + "exception": false, + "start_time": "2026-09-27T16:05:01.590268", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 2. L'étage Aaronson : un prédicteur d'espace fixé ne peut être surpris que par l'inconnu structurel\n", + "\n", + "Le point technique d'Aaronson est subtil : même une incertitude *totale* sur la **valeur** d'une action se laisse réduire à une distribution — c'est le régime bayésien ordinaire, dont la log-perte est bornée par l'entropie. Le freebit échappe à cette réduction *par physique* (no-cloning, past hypertext), pas par probabilité. Notre banc matérialise la frontière : tant que l'action observée reste dans l'espace connu, le prédicteur apprend ; la **première** action hors de l'espace ne lui coûte pas « une grande perte » — elle révèle que son espace était le mauvais objet." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "048a0c89", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:01.597484Z", + "iopub.status.busy": "2026-09-27T16:05:01.597077Z", + "iopub.status.idle": "2026-09-27T16:05:01.602070Z", + "shell.execute_reply": "2026-09-27T16:05:01.601519Z" + }, + "papermill": { + "duration": 0.008762, + "end_time": "2026-09-27T16:05:01.603172", + "exception": false, + "start_time": "2026-09-27T16:05:01.594410", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Perte sur support connu (moyenne, 30 derniers coups) : 0.938 bits\n", + "Surprise structurelle pour 'signer' (hors espace) : 1.585 bits = log2(|A|+1) = log2(3)\n", + "-> l'ecart n'est pas de volume, il est de NATURE : probabiliste vs structurel.\n" + ] + } + ], + "source": [ + "rng = np.random.default_rng(2026)\n", + "\n", + "pred = FixedSpacePredictor((\"vendre\", \"garder\"))\n", + "perte_connue = []\n", + "for _ in range(200):\n", + " a = \"vendre\" if rng.random() < 0.7 else \"garder\"\n", + " pred.update(a)\n", + " perte_connue.append(pred.log_loss(a, epsilon=1.0))\n", + "\n", + "surprise = pred.log_loss(\"signer\") # hors de l'espace fixe\n", + "\n", + "print(f\"Perte sur support connu (moyenne, 30 derniers coups) : {np.mean(perte_connue[-30:]):.3f} bits\")\n", + "print(f\"Surprise structurelle pour 'signer' (hors espace) : {surprise:.3f} bits = log2(|A|+1) = log2(3)\")\n", + "print(f\"-> l'ecart n'est pas de volume, il est de NATURE : probabiliste vs structurel.\")" + ] + }, + { + "cell_type": "markdown", + "id": "d9de53cd", + "metadata": { + "papermill": { + "duration": 0.002114, + "end_time": "2026-09-27T16:05:01.607606", + "exception": false, + "start_time": "2026-09-27T16:05:01.605492", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Lecture du résultat\n", + "\n", + "Sur son support, le prédicteur converge ($\\approx 1$ bit = l'entropie du tirage 70/30). La surprise hors support vaut $\\log_2(|A|+1)$ : le +1 est **la porte que l'espace n'avait pas**. C'est la forme calculable de la différence entre *ignorer une valeur dans $L$* (freebit d'Aaronson, ordre 1) et *ignorer $L$ lui-même* (free coordinate, ordre 2) : la première incertitude se monnaie en bits de valeur, la seconde en bits de **coordonnée**." + ] + }, + { + "cell_type": "markdown", + "id": "52bc05e3", + "metadata": { + "papermill": { + "duration": 0.00212, + "end_time": "2026-09-27T16:05:01.611888", + "exception": false, + "start_time": "2026-09-27T16:05:01.609768", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 3. Le coup ontologique : la « personne morale » comme ajout de coordonnée\n", + "\n", + "L'exemple paradigmatique du cadrage D1 : **personne morale**. Zéro bit physique ajouté au monde ; une coordonnée efficace ajoutée au monde social — l'entreprise peut *signer* et *posséder*. Appliquons ce $\\eta$ et mesurons les deux premiers proxys." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a4b99a2e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:01.617295Z", + "iopub.status.busy": "2026-09-27T16:05:01.616962Z", + "iopub.status.idle": "2026-09-27T16:05:01.621150Z", + "shell.execute_reply": "2026-09-27T16:05:01.620721Z" + }, + "papermill": { + "duration": 0.007867, + "end_time": "2026-09-27T16:05:01.621928", + "exception": false, + "start_time": "2026-09-27T16:05:01.614061", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "O_t (expansion ontologique) = 1\n", + "dA_t (ouverture politique) = 2\n", + "Poesie : O_t = 1, dA_t = 0 (verbiage detecte)\n" + ] + } + ], + "source": [ + "ETA_PM = OntologicalMove(\n", + " proposer=\"alice\",\n", + " new_concepts=(\"personne-morale\",),\n", + " opened_actions={\"personne-morale\": (\"signer\", \"posseder\")},\n", + " pose_cost=1.0, undo_cost=50.0,\n", + ")\n", + "G1 = apply_ontology(G0, ETA_PM)\n", + "print(f\"O_t (expansion ontologique) = {expansion_ontology(G0, G1)}\")\n", + "print(f\"dA_t (ouverture politique) = {political_opening(G0, G1)}\")\n", + "\n", + "# Contrastant : le concept ornemental n'ouvre RIEN.\n", + "ETA_POESIE = OntologicalMove(proposer=\"bob\", new_concepts=(\"poesie\",), opened_actions={})\n", + "G_poesie = apply_ontology(G0, ETA_POESIE)\n", + "print(f\"Poesie : O_t = {expansion_ontology(G0, G_poesie)}, dA_t = {political_opening(G0, G_poesie)} (verbiage detecte)\")" + ] + }, + { + "cell_type": "markdown", + "id": "babdd5d2", + "metadata": { + "papermill": { + "duration": 0.002285, + "end_time": "2026-09-27T16:05:01.627437", + "exception": false, + "start_time": "2026-09-27T16:05:01.625152", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Lecture du résultat\n", + "\n", + "$O_t$ compte les concepts nouveaux ; $\\Delta A_t$ est le **garde-fou contre le verbiage** : un concept qui n'ouvre aucune action est décoratif — l'expansion ontologique ne compte que si elle *change ce que les agents peuvent faire*. La poésie ouvre ici zéro action : dans ce banc minimal, elle ne franchit pas la barrière de la strate 7." + ] + }, + { + "cell_type": "markdown", + "id": "fa804e14", + "metadata": { + "papermill": { + "duration": 0.002196, + "end_time": "2026-09-27T16:05:01.631948", + "exception": false, + "start_time": "2026-09-27T16:05:01.629752", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 4. Non-canonicité $C_t$ : y a-t-il quelque chose à choisir ?\n", + "\n", + "Le proxy le plus directement lié à la grammaire extensionnelle : $C_t = |AdmExt(G_t)|$, le nombre d'extensions **non équivalentes** (deux extensions sont équivalentes si elles ouvrent les mêmes actions). Si $C_t = 1$, le prolongement est canonique — la strate 7 est triviale." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0c819eba", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:01.637431Z", + "iopub.status.busy": "2026-09-27T16:05:01.637202Z", + "iopub.status.idle": "2026-09-27T16:05:01.640745Z", + "shell.execute_reply": "2026-09-27T16:05:01.640340Z" + }, + "papermill": { + "duration": 0.00721, + "end_time": "2026-09-27T16:05:01.641479", + "exception": false, + "start_time": "2026-09-27T16:05:01.634269", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C_t(personne-morale seule) = 1\n", + "C_t(+ societe, equivalente) = 1\n", + "C_t(+ hypotheque, NON equivalente) = 2\n" + ] + } + ], + "source": [ + "e_pm = OntologicalMove(\"alice\", (\"personne-morale\",), {\"personne-morale\": (\"signer\", \"posseder\")})\n", + "e_soc = OntologicalMove(\"bob\", (\"societe\",), {\"societe\": (\"signer\", \"posseder\")})\n", + "e_hyp = OntologicalMove(\"bob\", (\"hypotheque\",), {\"hypotheque\": (\"nantir\",)})\n", + "\n", + "print(f\"C_t(personne-morale seule) = {non_canonicity(G0, (e_pm,))}\")\n", + "print(f\"C_t(+ societe, equivalente) = {non_canonicity(G0, (e_pm, e_soc))}\")\n", + "print(f\"C_t(+ hypotheque, NON equivalente) = {non_canonicity(G0, (e_pm, e_soc, e_hyp))}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2002f3d4", + "metadata": { + "papermill": { + "duration": 0.002277, + "end_time": "2026-09-27T16:05:01.646086", + "exception": false, + "start_time": "2026-09-27T16:05:01.643809", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Lecture du résultat\n", + "\n", + "Ajouter une extension *équivalente* (la « société » ouvre les mêmes actions que la « personne morale », à renommage près) ne change pas $C_t$ : il n'y a toujours rien à choisir. Ajouter l'« hypothèque » — qui ouvre *nantir*, une action différente — fait passer $C_t$ à 2 : **il y a maintenant un choix, et ce choix est réel**. C'est la mesure $H^1 \\neq 0$ du cadrage : l'obstruction est ce qu'il y a à choisir." + ] + }, + { + "cell_type": "markdown", + "id": "a4620045", + "metadata": { + "papermill": { + "duration": 0.002258, + "end_time": "2026-09-27T16:05:01.650747", + "exception": false, + "start_time": "2026-09-27T16:05:01.648489", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 5. Pouvoir performatif $P(R)$ : le coup change-t-il la trajectoire du système ?\n", + "\n", + "$P(R) = D(\\mathrm{Pr}(traj \\mid do(\\eta)) \\,\\|\\, \\mathrm{Pr}(traj \\mid do(\\neg\\eta)))$ — la divergence KL entre les distributions d'actions du système avec et sans le coup ontologique (interventionnisme de Pearl, estimée par Monte Carlo à lissage de Laplace). Un coup décoratif rend $P(R) \\approx 0$." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "de72e04c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:01.656487Z", + "iopub.status.busy": "2026-09-27T16:05:01.656220Z", + "iopub.status.idle": "2026-09-27T16:05:01.678011Z", + "shell.execute_reply": "2026-09-27T16:05:01.677330Z" + }, + "papermill": { + "duration": 0.025843, + "end_time": "2026-09-27T16:05:01.678891", + "exception": false, + "start_time": "2026-09-27T16:05:01.653048", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P(R) personne-morale = 13.033 bits (le coup transforme la dynamique)\n", + "P(R) decoratif = 8.363 bits (la copie ne change rien)\n" + ] + } + ], + "source": [ + "rng = np.random.default_rng(42)\n", + "G1_pm = apply_ontology(G0, ETA_PM)\n", + "P_pm = performative_power(G1_pm, G0, horizon=20, n_sim=8, rng=rng)\n", + "\n", + "ETA_DECO = OntologicalMove(\"alice\", (\"ornement\",), {\"ornement\": (\"vendre2\",)})\n", + "G_deco = apply_ontology(G0, ETA_DECO)\n", + "for agent in G_deco.agents: # 'vendre2' paie exactement comme 'vendre' : copie decorative\n", + " G_deco.payoffs[(agent, \"vendre2\")] = G_deco.payoffs[(agent, \"vendre\")]\n", + "P_deco = performative_power(G_deco, G0, horizon=20, n_sim=8, rng=rng)\n", + "\n", + "print(f\"P(R) personne-morale = {P_pm:.3f} bits (le coup transforme la dynamique)\")\n", + "print(f\"P(R) decoratif = {P_deco:.3f} bits (la copie ne change rien)\")" + ] + }, + { + "cell_type": "markdown", + "id": "ed249f5f", + "metadata": { + "papermill": { + "duration": 0.002283, + "end_time": "2026-09-27T16:05:01.684073", + "exception": false, + "start_time": "2026-09-27T16:05:01.681790", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Lecture du résultat\n", + "\n", + "La personne morale ($P(R) > 0$, substantiel) **transforme** la distribution des trajectoires ; une action-copie au même profil de paiements laisse $P(R)$ proche de zéro. Attention à la lecture : $P(R)$ mesure le *pouvoir causal du coup*, pas sa *légitimité* — un coup manipulateur a aussi un $P(R)$ élevé. Les proxys suivant précisent le destin temporel." + ] + }, + { + "cell_type": "markdown", + "id": "d066a4e6", + "metadata": { + "papermill": { + "duration": 0.002243, + "end_time": "2026-09-27T16:05:01.688660", + "exception": false, + "start_time": "2026-09-27T16:05:01.686417", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 6. Institutionnalisation et dette d'irréversibilité $I(R)$\n", + "\n", + "Le coup survit-il à son instigateur ? Et que coûte son défaire, relativement à sa pose ? Ce sont les deux proxys temporels : la **persistance après retrait** et l'**asymétrie création/dissolution**." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ddea088a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:01.694198Z", + "iopub.status.busy": "2026-09-27T16:05:01.693831Z", + "iopub.status.idle": "2026-09-27T16:05:01.700573Z", + "shell.execute_reply": "2026-09-27T16:05:01.700067Z" + }, + "papermill": { + "duration": 0.010434, + "end_time": "2026-09-27T16:05:01.701313", + "exception": false, + "start_time": "2026-09-27T16:05:01.690879", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Institutionnalisation personne-morale = 41.67% (les autres continuent de l'utiliser)\n", + "Institutionnalisation jargon-prive = 0.00% (meurt avec son inventeur)\n", + "I(R) personne-morale = 50 x (defaire coute 50x poser)\n" + ] + } + ], + "source": [ + "rng = np.random.default_rng(7)\n", + "rate_pm = institutionalization(G1_pm, ETA_PM, horizon=60, rng=rng)\n", + "\n", + "ETA_JARGON = OntologicalMove(\"alice\", (\"jargon-prive\",), {\"jargon-prive\": (\"jargonner\",)})\n", + "G_jargon = apply_ontology(G0, ETA_JARGON)\n", + "for agent in G_jargon.agents:\n", + " G_jargon.payoffs[(agent, \"jargonner\")] = -2.0 # les autres EVITENT le jargon prive\n", + "rate_jargon = institutionalization(G_jargon, ETA_JARGON, horizon=60, rng=rng)\n", + "\n", + "print(f\"Institutionnalisation personne-morale = {rate_pm:.2%} (les autres continuent de l'utiliser)\")\n", + "print(f\"Institutionnalisation jargon-prive = {rate_jargon:.2%} (meurt avec son inventeur)\")\n", + "print(f\"I(R) personne-morale = {irreversibility_debt(ETA_PM):.0f} x (defaire coute 50x poser)\")" + ] + }, + { + "cell_type": "markdown", + "id": "19debc9b", + "metadata": { + "papermill": { + "duration": 0.002622, + "end_time": "2026-09-27T16:05:01.707540", + "exception": false, + "start_time": "2026-09-27T16:05:01.704918", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Lecture du résultat\n", + "\n", + "Le jargon privé — que les autres agents *évitent activement* — meurt avec son instigateur : institutionnalisation quasi nulle. La personne morale persiste chez les survivants. Et sa dette d'irréversibilité ($50\\times$) matérialise la signature des *macro-faits* : **une extension qui réussit devient un fait stable — le free coordinate disparaît au moment même où il réussit**." + ] + }, + { + "cell_type": "markdown", + "id": "f879d981", + "metadata": { + "papermill": { + "duration": 0.00247, + "end_time": "2026-09-27T16:05:01.713349", + "exception": false, + "start_time": "2026-09-27T16:05:01.710879", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 7. Les deux lectures, avec leurs grades\n", + "\n", + "**Lecture 1 — celle du texte** *(grade : interprétation sourcée)*. Aaronson propose une image *physique* du libre arbitre : des freebits — bits quantiques microscopiques dont les valeurs, fixées par les conditions initiales de l'univers, sont *de Knight* (non assignables de distribution) pour tout observant — seraient amplifiés par la micro-physique cérébrale jusqu'à rendre nos actes in-principe imprévisibles, même par un simulateur parfait. Il la présente comme *model-building* : sensée (*\"not obviously much crazier than the alternatives\"*) et falsifiable — des questions empiriques ouvertes en neuroscience et en physique doivent trancher une manière plutôt qu'une autre.\n", + "\n", + "**Lecture 2 — d'ordre 2, tenue contre elle** *(grade : garde-fou épistémique, posé avant tout résultat)*. Trois réserves accompagnent toute transposition : (i) l'objet qui monte en strate ici n'est pas le freebit physique mais le **choix d'extension d'espace** — un étage au-dessus, et le glissement d'un étage à l'autre doit être déclaré, pas naturalisé ; (ii) l'attachement du chercheur à ses propres formes est **enregistré d'avance comme biais possible** (le §218 décrit l'idéalisme qui « sélectionne les faits, les déforme, les renomme ») — se référer à soi-même est bon marché, bien choisir sa coordonnée libre ne l'est pas ; (iii) le contrat de falsifiabilité [#7291](https://github.com/jsboige/CoursIA/issues/7291) exige que l'objet ne monte **que si un résultat falsifiable l'exige** — les six proxys de ce notebook sont une *grille de dicibilité* (elle rend dicibles des non-résultats), pas une démonstration.\n", + "\n", + "Les deux lectures coexistent : la première donne au mot sa source et sa physics ; la seconde encadre ce que le dépôt peut en revendiquer. Aucune n'efface l'autre." + ] + }, + { + "cell_type": "markdown", + "id": "24e71991", + "metadata": { + "papermill": { + "duration": 0.002229, + "end_time": "2026-09-27T16:05:01.717899", + "exception": false, + "start_time": "2026-09-27T16:05:01.715670", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Encart gap Mathlib\n", + "\n", + "Le banc repose sur : comptage d'ensembles finis ($O_t$, $\\Delta A_t$, $C_t$), divergence KL empirique ($P(R)$), fractions de trajectoires (institutionnalisation), ratios de coûts ($I(R)$). **Rien de tout cela n'est dans Mathlib sous cette forme** : `Mathlib.Combinatorics` ne connaît pas les ensembles d'extensions non équivalentes ; l'entropie et la KL existent (`Mathlib.InformationTheory.KullbackLeibler`) mais pas la KL *empirique à lissage de Laplace* ; le do-calculus n'existe pas. Formaliser `C_t = |AdmExt(G_t)|` en théorie des types exigerait d'abord une définition d'`AdmExt` comme quotient d'extensions à équivalence près — un chantier en soi, pour l'instant hors de portée (et hors de ce dépôt : aucun lake Lean côté IIT)." + ] + }, + { + "cell_type": "markdown", + "id": "37b56d04", + "metadata": { + "papermill": { + "duration": 0.002175, + "end_time": "2026-09-27T16:05:01.722527", + "exception": false, + "start_time": "2026-09-27T16:05:01.720352", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Exercices\n", + "\n", + "Les trois exercices suivants manipulent le module `ict.free_coordinates`." + ] + }, + { + "cell_type": "markdown", + "id": "609da3bc", + "metadata": { + "papermill": { + "duration": 0.002258, + "end_time": "2026-09-27T16:05:01.726829", + "exception": false, + "start_time": "2026-09-27T16:05:01.724571", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Exercice 1 — Construire l'équivalence\n", + "\n", + "Construisez une troisième extension de `G0` qui ouvre **exactement** les mêmes actions que `ETA_PM` mais sous un concept différent, puis vérifiez que `non_canonicity` ne bouge pas. Ensuite faites passer $C_t$ à 3 avec une extension réellement distincte.\n", + "\n", + "*Indice : la clé est l'ensemble d'actions résultant, pas le nom du concept.*" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "68038589", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:01.732281Z", + "iopub.status.busy": "2026-09-27T16:05:01.732086Z", + "iopub.status.idle": "2026-09-27T16:05:01.735205Z", + "shell.execute_reply": "2026-09-27T16:05:01.734784Z" + }, + "papermill": { + "duration": 0.007323, + "end_time": "2026-09-27T16:05:01.736443", + "exception": false, + "start_time": "2026-09-27T16:05:01.729120", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exercice 1 a completer\n" + ] + } + ], + "source": [ + "def exercice_1():\n", + " # TODO etudiant\n", + " # 1. definir ETA_EQ (concept different, memes actions ouvertes que ETA_PM)\n", + " # 2. verifier : non_canonicity(G0, (ETA_PM, ETA_EQ)) == 1\n", + " # 3. definir ETA_TROIS (actions differentes) et faire monter C_t a 3\n", + " return None\n", + "\n", + "print(\"Exercice 1 a completer\")" + ] + }, + { + "cell_type": "markdown", + "id": "686e54d2", + "metadata": { + "papermill": { + "duration": 0.002402, + "end_time": "2026-09-27T16:05:01.743833", + "exception": false, + "start_time": "2026-09-27T16:05:01.741431", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Exercice 2 — La température de l'adoption\n", + "\n", + "Faites varier la `temperature` de `simulate_trajectory` (par exemple 0.1, 0.5, 2.0) et mesurez l'institutionnalisation de la personne morale à chaque température. Que se passe-t-il quand les agents deviennent quasi-déterministes, et pourquoi la lecture « innovation vs bruit » dépend-elle de ce paramètre ?\n", + "\n", + "*Indice : à température basse, seuls les payoffs dominants survivent ; à température haute, tout se mélange.*" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6a7cfcbd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:01.749114Z", + "iopub.status.busy": "2026-09-27T16:05:01.748928Z", + "iopub.status.idle": "2026-09-27T16:05:01.752163Z", + "shell.execute_reply": "2026-09-27T16:05:01.751744Z" + }, + "papermill": { + "duration": 0.006753, + "end_time": "2026-09-27T16:05:01.752848", + "exception": false, + "start_time": "2026-09-27T16:05:01.746095", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exercice 2 a completer\n" + ] + } + ], + "source": [ + "def exercice_2():\n", + " # TODO etudiant\n", + " # 1. pour temperature dans [0.1, 0.5, 2.0] :\n", + " # 2. simuler simulate_trajectory(G1_reduit_aux_survivants, horizon=60, rng, temperature=...)\n", + " # 3. calculer la fraction de coups sur les actions ouvertes par ETA_PM\n", + " # 4. commenter la dependence\n", + " return None\n", + "\n", + "print(\"Exercice 2 a completer\")" + ] + }, + { + "cell_type": "markdown", + "id": "7796c57e", + "metadata": { + "papermill": { + "duration": 0.002398, + "end_time": "2026-09-27T16:05:01.757889", + "exception": false, + "start_time": "2026-09-27T16:05:01.755491", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Exercice 3 — Le coup capturé\n", + "\n", + "Modifiez les payoffs pour que l'action `signer` ne profite **qu'à alice** (payoff 2.0) et coûte à bob (payoff -1.0). Mesurez $P(R)$ et l'institutionnalisation de ce coup *capturé*. Le contraste avec la personne morale symétrique est-il plus visible sur $P(R)$ ou sur l'institutionnalisation ?\n", + "\n", + "*Indice : un coup capturé peut être performatif (fort $P(R)$) sans être institutionnalisé — c'est exactement la distinction des proxys.*" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f39fd58b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-27T16:05:01.763257Z", + "iopub.status.busy": "2026-09-27T16:05:01.763065Z", + "iopub.status.idle": "2026-09-27T16:05:01.766464Z", + "shell.execute_reply": "2026-09-27T16:05:01.765910Z" + }, + "papermill": { + "duration": 0.007214, + "end_time": "2026-09-27T16:05:01.767420", + "exception": false, + "start_time": "2026-09-27T16:05:01.760206", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exercice 3 a completer\n" + ] + } + ], + "source": [ + "def exercice_3():\n", + " # TODO etudiant\n", + " # 1. partir de G1 = apply_ontology(G0, ETA_PM) et reecrire les payoffs de 'signer'\n", + " # 2. mesurer performative_power et institutionalization sur ce jeu capture\n", + " # 3. comparer au cas symetrique et commenter\n", + " return None\n", + "\n", + "print(\"Exercice 3 a completer\")" + ] + }, + { + "cell_type": "markdown", + "id": "6a889515", + "metadata": { + "papermill": { + "duration": 0.002511, + "end_time": "2026-09-27T16:05:01.773694", + "exception": false, + "start_time": "2026-09-27T16:05:01.771183", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Conclusion\n", + "\n", + "La strate 7 ne livrait que de la prose ; elle a maintenant son **organe exécutable**. Le contraste fondateur est mesuré de bout en bout : l'incertitude sur une *valeur* dans un espace fixé se réduit à des bits (prédicteur bayésien, perte bornée par l'entropie) ; l'incertitude sur *l'espace lui-même* se manifeste comme surprise structurelle — $\\log_2(|A|+1)$, la porte que l'espace n'avait pas — et comme un choix réel parmi des extensions non équivalentes ($C_t > 1$), mesuré dans ses effets ($P(R)$), sa persistance (institutionnalisation) et son asymétrie temporelle ($I(R)$).\n", + "\n", + "Ce que ce notebook **ne démontre pas** : ni la physique des freebits d'Aaronson (ordre 1, question empirique ouverte), ni la thèse que la « qualité du choix de coordonnée » est une composante de la performativité (posée sans démonstration au cadrage). Il rend les deux *dicibles* — et c'est le grade honest d'une première livraison de strate.\n", + "\n", + "**Navigation** : précédent dans la série — [ICT-45](ICT-45-InoculationBifurcation-9B.ipynb) ; le cadrage — [`strate7-cadres-libres.md`](https://github.com/jsboige/CoursIA/blob/main/docs/ict/strate7-cadres-libres.md) ; l'Epic — [#16781](https://github.com/jsboige/CoursIA/issues/16781)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" + }, + "papermill": { + "default_parameters": {}, + "duration": 5.767955, + "end_time": "2026-09-27T16:05:04.478543", + "environment_variables": {}, + "exception": null, + "input_path": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb", + "output_path": "ICT-46-Strate7-FreeCoordinates.ipynb", + "parameters": {}, + "start_time": "2026-09-27T16:04:58.710588", + "version": "2.6.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 9c0dc84685819121a067b72b6899aaeeea69deda Mon Sep 17 00:00:00 2001 From: jsboige Date: Sun, 27 Sep 2026 18:09:19 +0200 Subject: [PATCH 3/7] =?UTF-8?q?docs(ict,#18052):=20README=20serie=20?= =?UTF-8?q?=E2=80=94=20strate=207=20livree=20par=20ICT-46=20(titre=20de=20?= =?UTF-8?q?section,=20carte,=20table)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5 --- MyIA.AI.Notebooks/IIT/ICT-Series/README.md | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/README.md b/MyIA.AI.Notebooks/IIT/ICT-Series/README.md index 522029aa06..162f688bee 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/README.md +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/README.md @@ -13,9 +13,9 @@ La série [IIT](../README.md) étudie des structures causales **à un instant do ICT s'appuie sur un package léger `ict/` posé à côté de PyPhi (autonome pour les simulations et mesures, PyPhi pour les calculs IIT stricts), et s'ouvre sur deux articles fondateurs : le tri vu comme morphogenèse minimale (Zhang, Goldstein & Levin, 2025) et l'ingénierie de l'émergence multi-échelle (Jansma & Hoel, 2025). -La série progresse en **sept strates**, dont la carte de référence unique est celle du **[cadrage ICT-0](ICT-0-Framing.md#deux-axes-de-lecture--strates-verticales--tresse-transverse)** (arbitrage [#13908](https://github.com/jsboige/CoursIA/issues/13908)) : ce qui suit s'y aligne. La **strate 1** (ICT-1 à ICT-7) prend le **tri auto-organisé** comme banc d'essai entièrement transparent : trajectoires enregistrables, compétences inattendues réelles — ce travail *for free* qui, chez Levin, va « dans le sens d'une réversibilisation » — et pont vers la causal emergence. Elle bute sur trois limites — un **attracteur global unique**, un **but imposé de l'extérieur**, une **hiérarchie non générative**. La **strate 2** (ICT-8 à ICT-10) ouvre la *morphogenèse dynamique* sur des paysages d'attracteurs **engendrés par la dynamique** (bifurcation, réaction-diffusion, grammaire des catastrophes), levant ces limites une à une. La **strate 3** (ICT-11 à ICT-13) mesure des **trajectoires intégrées** régime-dépendantes (profils d'agence, champs de valence, morphodynamique stratégique). La **strate 4** (ICT-14 à ICT-20, prolongée par ses raffinements lettrés et le banc de recollement [ICT-34](ICT-34-BancRecollementLectures.ipynb)) ajoute la jambe **représentationnelle** — énergie libre, surprise et inférence active — puis fait converger les trois scalaires fondateurs sur des substrats **non-LLM** (identité MDL, $\epsilon$-machine, budget, enjeu) et **outille la réversibilisation** — l'idée fondatrice restée implicite : forcer une trajectoire à devenir réversible et mesurer *ce qu'on perd* révèle la quantité d'agentivité qu'elle portait (ICT-18, flèche du temps & réversibilisation). **ICT-17b (grokking) est la charnière S4 → S5**, pas une strate pleine ([#7735](https://github.com/jsboige/CoursIA/issues/7735)). La **strate 5** (ICT-21 à ICT-25, prolongée par les notebooks ICT-35 à ICT-39) prend le **LLM comme substrat** : SAE, persona, workspace, inoculation RL. Les [**strates 6** (argumentation) et **7** (freebits d'ordre 2, réversibilité agentique)](#strates-6-et-7--cadrées-non-encore-livrées) sont **cadrées et non encore livrées** : le socle sémiophysique de Thom et les cinq expériences ICT-26 → ICT-30 relèvent de l'**axe transverse** (socle théorique, dimension D2) et non de ces strates. +La série progresse en **sept strates**, dont la carte de référence unique est celle du **[cadrage ICT-0](ICT-0-Framing.md#deux-axes-de-lecture--strates-verticales--tresse-transverse)** (arbitrage [#13908](https://github.com/jsboige/CoursIA/issues/13908)) : ce qui suit s'y aligne. La **strate 1** (ICT-1 à ICT-7) prend le **tri auto-organisé** comme banc d'essai entièrement transparent : trajectoires enregistrables, compétences inattendues réelles — ce travail *for free* qui, chez Levin, va « dans le sens d'une réversibilisation » — et pont vers la causal emergence. Elle bute sur trois limites — un **attracteur global unique**, un **but imposé de l'extérieur**, une **hiérarchie non générative**. La **strate 2** (ICT-8 à ICT-10) ouvre la *morphogenèse dynamique* sur des paysages d'attracteurs **engendrés par la dynamique** (bifurcation, réaction-diffusion, grammaire des catastrophes), levant ces limites une à une. La **strate 3** (ICT-11 à ICT-13) mesure des **trajectoires intégrées** régime-dépendantes (profils d'agence, champs de valence, morphodynamique stratégique). La **strate 4** (ICT-14 à ICT-20, prolongée par ses raffinements lettrés et le banc de recollement [ICT-34](ICT-34-BancRecollementLectures.ipynb)) ajoute la jambe **représentationnelle** — énergie libre, surprise et inférence active — puis fait converger les trois scalaires fondateurs sur des substrats **non-LLM** (identité MDL, $\epsilon$-machine, budget, enjeu) et **outille la réversibilisation** — l'idée fondatrice restée implicite : forcer une trajectoire à devenir réversible et mesurer *ce qu'on perd* révèle la quantité d'agentivité qu'elle portait (ICT-18, flèche du temps & réversibilisation). **ICT-17b (grokking) est la charnière S4 → S5**, pas une strate pleine ([#7735](https://github.com/jsboige/CoursIA/issues/7735)). La **strate 5** (ICT-21 à ICT-25, prolongée par les notebooks ICT-35 à ICT-39) prend le **LLM comme substrat** : SAE, persona, workspace, inoculation RL. La **strate 6** (argumentation) reste **cadrée et non livrée**, et la **strate 7** (freebits d'ordre 2, réversibilité agentique) est **livrée par [ICT-46](ICT-46-Strate7-FreeCoordinates.ipynb)** ([#18052](https://github.com/jsboige/CoursIA/issues/18052)) : le socle sémiophysique de Thom et les cinq expériences ICT-26 → ICT-30 relèvent de l'**axe transverse** (socle théorique, dimension D2) et non de ces strates. -> **Carte des strates** (par où commencer) : un lecteur qui découvre la série ira de **strate 1** (ICT-1 → ICT-7, le tri auto-organisé, banc transparent entièrement exécutable sans GPU) vers la **strate 5** (ICT-21 → ICT-25 prolongée par ICT-35 → ICT-39, le LLM comme substrat). Les strates **2-4** montent progressivement en abstraction (paysages dynamiques → trajectoires intégrées → free energy, puis les scalaires fondateurs hors LLM jusqu'à la charnière **ICT-17b**). Le **socle Thom** et les **cinq expériences A→E** (ICT-26 → ICT-30) se lisent sur l'**axe transverse** : ce ne sont pas [les strates 6-7](#strates-6-et-7--cadrées-non-encore-livrées), qui restent cadrées et non livrées ([#13908](https://github.com/jsboige/CoursIA/issues/13908)). L'état scientifique de chaque claim est lisible d'un coup d'œil dans la [matrice des dissociations](../../../docs/ict/dissociations-matrix.md) (#7734). +> **Carte des strates** (par où commencer) : un lecteur qui découvre la série ira de **strate 1** (ICT-1 → ICT-7, le tri auto-organisé, banc transparent entièrement exécutable sans GPU) vers la **strate 5** (ICT-21 → ICT-25 prolongée par ICT-35 → ICT-39, le LLM comme substrat). Les strates **2-4** montent progressivement en abstraction (paysages dynamiques → trajectoires intégrées → free energy, puis les scalaires fondateurs hors LLM jusqu'à la charnière **ICT-17b**). Le **socle Thom** et les **cinq expériences A→E** (ICT-26 → ICT-30) se lisent sur l'**axe transverse** : ce ne sont pas [les strates 6-7](#strates-6-et-7) — la strate 6 reste cadrée et non livrée, la strate 7 est livrée par [ICT-46](ICT-46-Strate7-FreeCoordinates.ipynb) ([#13908](https://github.com/jsboige/CoursIA/issues/13908)). L'état scientifique de chaque claim est lisible d'un coup d'œil dans la [matrice des dissociations](../../../docs/ict/dissociations-matrix.md) (#7734). > **Caractère expérimental.** ICT est une série de recherche en construction (statut ALPHA). Elle pose des mesures *sans complaisance* : chaque notebook confronte une intuition séduisante (émergence, agence, criticalité) à une mesure qui peut la **réfuter**, et signale explicitement les fantômes statistiques (signal apparent issu de degrés de liberté cachés). @@ -258,9 +258,11 @@ Les grains de **distillation externe** (veille → notebook) s'ajoutent aux stra *Figure extraite de `ICT-40b-AnalogCognitionWaves.ipynb` (cellule 21, output 0) — la somme de deux ondes de contexte (ordre × mode) produit quatre patrons tous distincts : l'intersection de contraintes est calculée par la physique de la superposition, en une opération parallèle, sans re-câblage synaptique. Limitation illustrative assumée : deux ondes planes jouet, pas la base de fonctions spatio-temporelles complète du préprint.* -### Strates 6 et 7 — cadrées, non encore livrées +### Strates 6 et 7 -Les deux derniers barreaux de l'axe vertical **ne sont pas livrés**. Ils figurent ici pour que la progression en **sept strates** annoncée en tête se lise jusqu'au bout, et pour tenir la distinction que le [cadrage ICT-0](ICT-0-Framing.md#deux-axes-de-lecture--strates-verticales--tresse-transverse) a établie ([#13908](https://github.com/jsboige/CoursIA/issues/13908)) : **ni** le socle Thom **ni** les cinq expériences ICT-26 → ICT-30 ne sont ces strates — ce sont des objets de l'**axe transverse**. Les deux cartes du dépôt avaient divergé en projetant ces objets transverses sur l'échelle verticale ; c'est cette projection, et non les strates elles-mêmes, qui a été retirée. +> **État de livraison** : la **strate 7** est livrée par [ICT-46](ICT-46-Strate7-FreeCoordinates.ipynb) ([#18052](https://github.com/jsboige/CoursIA/issues/18052)) ; la **strate 6** reste cadrée et non livrée. + +Des deux derniers barreaux de l'axe vertical, la **strate 7 est livrée** ([ICT-46](ICT-46-Strate7-FreeCoordinates.ipynb), [#18052](https://github.com/jsboige/CoursIA/issues/18052)) et la **strate 6 ne l'est pas**. Ils figurent ici pour que la progression en **sept strates** annoncée en tête se lise jusqu'au bout, et pour tenir la distinction que le [cadrage ICT-0](ICT-0-Framing.md#deux-axes-de-lecture--strates-verticales--tresse-transverse) a établie ([#13908](https://github.com/jsboige/CoursIA/issues/13908)) : **ni** le socle Thom **ni** les cinq expériences ICT-26 → ICT-30 ne sont ces strates — ce sont des objets de l'**axe transverse**. Les deux cartes du dépôt avaient divergé en projetant ces objets transverses sur l'échelle verticale ; c'est cette projection, et non les strates elles-mêmes, qui a été retirée. | Strate | Substrat | État | Pattes de la tresse | Epic | |--------|----------|------|---------------------|------| @@ -277,11 +279,15 @@ Les deux derniers barreaux de l'axe vertical **ne sont pas livrés**. Ils figure Restent non livrés : les deux jambes C3/C4 (morphogenèse rhétorique, grammaire de propagation), l'annexe Kochen-Specker ([#7290](https://github.com/jsboige/CoursIA/issues/7290)) et l'horizon altérité ([#7291](https://github.com/jsboige/CoursIA/issues/7291), GATED). La prédiction pré-enregistrée qui donnera à cette strate son gate falsifiable — une **dette d'irréversibilité du discours**, soit la dissociation $\sigma$ élevé / $K$ faible des régimes rhétoriques manipulatoires — est posée dans [ICT-0](https://github.com/jsboige/CoursIA/issues/7289) et **pas encore mesurée**. -**Strate 7 — rien n'y est livré, et D2 n'en tient pas lieu.** Le substrat visé est celui des *free coordinates* / **freebits de second ordre** : les degrés de liberté qu'un système garde réellement ouverts, et ce qu'il en coûte de rendre sa trajectoire réversible. La dimension **D1** ([#7745](https://github.com/jsboige/CoursIA/issues/7745)) en pose le cadre — jeu évolutif $G_t$ + mécanisme $M$, six proxys — et la dimension **D2** ci-dessous l'alimente en résultats. Mais une dimension est une **patte, pas un barreau** : les cinq expériences ICT-26 → ICT-30 sont livrées **sans** que la strate 7 le soit. C'est la divergence exacte que [#13908](https://github.com/jsboige/CoursIA/issues/13908) a tranchée. +**Strate 7 — livrée par [ICT-46](ICT-46-Strate7-FreeCoordinates.ipynb)** ([#18052](https://github.com/jsboige/CoursIA/issues/18052), veine 3 de l'Epic Aaronson [#16781](https://github.com/jsboige/CoursIA/issues/16781)) **; D2 n'en tient pas lieu.** Le substrat visé est celui des *free coordinates* / **freebits de second ordre** : les degrés de liberté qu'un système garde réellement ouverts, et ce qu'il en coûte de rendre sa trajectoire réversible. La dimension **D1** ([#7745](https://github.com/jsboige/CoursIA/issues/7745)) en pose le cadre — jeu évolutif $G_t$ + mécanisme $M$, six proxys — et la dimension **D2** ci-dessous l'alimente en résultats. ICT-46 en est le **premier barreau** : le banc exécutable (`ict/free_coordinates.py`) qui fait tourner le contraste freebit d'Aaronson (incertitude sur une *valeur* dans un espace fixé) vs *free coordinate* (incertitude sur *l'espace lui-même*), en mesurant les six proxys sur un mini-jeu évolutif à coups ontologiques. Une dimension reste une **patte, pas un barreau** : les cinq expériences ICT-26 → ICT-30 sont des pattes D2 ; ICT-46 est le barreau — la divergence tranchée par [#13908](https://github.com/jsboige/CoursIA/issues/13908) est résorbée côté livraison, pas close côté programme (la strate 7 appelle des bancs plus riches que ce premier organe). + +| Notebook | Rôle | Contenu | Issue | +|----------|------|---------|-------| +| [ICT-46-Strate7-FreeCoordinates](ICT-46-Strate7-FreeCoordinates.ipynb) | Premier barreau strate 7 | **Freebits de second ordre — le banc exécutable** *(compagnon de `ict.free_coordinates`)* : le pont Aaronson (incertitude de Knight sur une *valeur* dans un espace fixé — *Ghost in the Quantum Turing Machine*, 2013) vers le free coordinate (incertitude sur *l'espace lui-même*, cadrage D1). Six proxys exécutés sur un mini-jeu évolutif à coups ontologiques : $O_t$, $\Delta A_t$, $C_t = \|AdmExt\|$, $P(R)$ (KL interventionnelle), institutionnalisation post-retrait, $I(R)$. Deux lectures graduées (texte vs garde-fous épistémiques, contrat [#7291](https://github.com/jsboige/CoursIA/issues/7291)), encart gap Mathlib, 3 exercices | [#18052](https://github.com/jsboige/CoursIA/issues/18052), [#16781](https://github.com/jsboige/CoursIA/issues/16781) | ### Dimension D2 — coopération, signalisation et invention de symboles (cinq expériences A→E) -> **Axe transverse, pas strate 7** — ces cinq expériences réalisent la **dimension D2** du cadrage ([#7746](https://github.com/jsboige/CoursIA/issues/7746), l'Epic déjà cité ci-dessous), et non la strate 7, qui reste celle des **freebits d'ordre 2** ([#7745](https://github.com/jsboige/CoursIA/issues/7745)) et n'est pas livrée. Une dimension est une **patte, pas un barreau** : elle éclaire les strates hautes sans occuper de rang sur l'échelle des substrats ([#13908](https://github.com/jsboige/CoursIA/issues/13908)). +> **Axe transverse, pas strate 7** — ces cinq expériences réalisent la **dimension D2** du cadrage ([#7746](https://github.com/jsboige/CoursIA/issues/7746), l'Epic déjà cité ci-dessous), et non la strate 7, qui reste celle des **freebits d'ordre 2** ([#7745](https://github.com/jsboige/CoursIA/issues/7745)) — désormais livrée par [ICT-46](ICT-46-Strate7-FreeCoordinates.ipynb), sans que ces cinq expériences ne s'y réduisent. Une dimension est une **patte, pas un barreau** : elle éclaire les strates hautes sans occuper de rang sur l'échelle des substrats ([#13908](https://github.com/jsboige/CoursIA/issues/13908)). Ces cinq expériences font de la **coopération un opérateur** plutôt qu'un épiphénomène : élargir l'espace des trajectoires récupérables d'un système en lui ajoutant des partenaires, des conventions partagées et des symboles inventés. Cinq expériences A→E (Epic [#7746](https://github.com/jsboige/CoursIA/issues/7746)), chacune adossée à un module `ict/` dédié, mesurent les seuils et les dérives de cet opérateur. L'invention d'un symbole, son adoption collective et son inoculation sont traitées comme des **événements falsifiables** (un seuil de performativité, un gain mesuré), pas comme des correspondances nommées. @@ -300,7 +306,7 @@ Ces cinq expériences font de la **coopération un opérateur** plutôt qu'un é ## Socle théorique transverse — distillation Thom 1991 -Les **strates hautes** — strate 6 (argumentation) et strate 7 (freebits d'ordre 2), toutes deux cadrées et non encore livrées — ainsi que la **dimension D2** (langage / circulation de prégnances, genres comme espaces de possibles extensibles) s'appuient sur une **distillation consolidée** de René Thom, *Esquisse d'une sémiophysique* (1991) — universelle linguistique (Nom/Verbe, valence Tesnière), genres / hypergenres (prototype moineau, opérations catastrophistes : factitif, aspect, lavage, conflit de prégnances), préprogrammes morphogènes (Ch.3 §B), instrument (Ch.3 §K, chimpanzé + banane inaccessible = plication affective de la forme), blastula BP (Ch.4), PGO (Ch.5), axiomatique aristotélicienne (Ch.6), ABP/FBM et privation = métastabilité (Ch.7), opérations catégorielles (Ch.8). Grade C-documentaire ; lecture ICT candidate, **pas** démonstration. Distinguo explicite avec la [matrice des dissociations ossaturée 4-objets](../../../docs/ict/dissociations-matrix.md) (c.728y+34, [#7734](https://github.com/jsboige/CoursIA/issues/7734), opérationnelle per-claim) : la distillation est **socle théorique transverse** ; la matrice est **registre par-claim**. Voir [thom-synthese-distillation.md](thom-synthese-distillation.md), issue-source [#7739](https://github.com/jsboige/CoursIA/issues/7739), Epic umbrella [#4588](https://github.com/jsboige/CoursIA/issues/4588). +Les **strates hautes** — strate 6 (argumentation, cadrée non livrée) et strate 7 (freebits d'ordre 2, livrée par [ICT-46](ICT-46-Strate7-FreeCoordinates.ipynb)) — ainsi que la **dimension D2** (langage / circulation de prégnances, genres comme espaces de possibles extensibles) s'appuient sur une **distillation consolidée** de René Thom, *Esquisse d'une sémiophysique* (1991) — universelle linguistique (Nom/Verbe, valence Tesnière), genres / hypergenres (prototype moineau, opérations catastrophistes : factitif, aspect, lavage, conflit de prégnances), préprogrammes morphogènes (Ch.3 §B), instrument (Ch.3 §K, chimpanzé + banane inaccessible = plication affective de la forme), blastula BP (Ch.4), PGO (Ch.5), axiomatique aristotélicienne (Ch.6), ABP/FBM et privation = métastabilité (Ch.7), opérations catégorielles (Ch.8). Grade C-documentaire ; lecture ICT candidate, **pas** démonstration. Distinguo explicite avec la [matrice des dissociations ossaturée 4-objets](../../../docs/ict/dissociations-matrix.md) (c.728y+34, [#7734](https://github.com/jsboige/CoursIA/issues/7734), opérationnelle per-claim) : la distillation est **socle théorique transverse** ; la matrice est **registre par-claim**. Voir [thom-synthese-distillation.md](thom-synthese-distillation.md), issue-source [#7739](https://github.com/jsboige/CoursIA/issues/7739), Epic umbrella [#4588](https://github.com/jsboige/CoursIA/issues/4588). ## Lien avec la causalité du dépôt From 3bc1da6c8bb558c01b5a77924e628aeb51a4dcef Mon Sep 17 00:00:00 2001 From: jsboige Date: Sun, 27 Sep 2026 19:23:27 +0200 Subject: [PATCH 4/7] fix(iit,#18052): P(R) lissage Laplace symetrique en bits + marginalisation par equivalence MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reponse au CONCERN NanoClaw (review 5331122613, PR #18059) : - performative_power: np.log -> np.log2 (les 13.033/8.363 affiches etaient des nats), lissage de Laplace SYMETRIQUE sur l'union des supports des deux bras (plus de plancher 1e-12 qui dominait la KL : toute action nouvelle pesait mass*ln(mass/1e-12)), nouveau parametre equivalence={action: classe} qui fusionne les histogrammes par classe avant la KL. - Semantique honnete du contraste decoratif, en deux lectures : brut, une copie de paiement identique reste une option DISTINGUEE (P(R) 1.819 bits) ; marginalisee (vendre2 = vendre), elle tombe a 0.029 bit — la copie ne change pas la dynamique de fond. Personne morale : 2.753 bits dans les deux lectures. Mesures multi-seeds (0/7/42/99/ 2026) dans le docstring du test. - Test renforce : asserte desormais le claim qu'il nomme (p_fort > 2.0, p_deco < p_fort, p_deco_eq < 0.15, p_fort > 10*p_deco_eq) au lieu du seul p_deco < p_fort. - Notebook : section 5 reecrite (3 nombres, 3 lectures, lien explicite au quotient d'extensions du C_t §4) ; mineur §2 : 0.938 bit mesure contre H(0.7)=0.881 (lissage de Laplace), remplace le approx 1 bit. - Re-execution papermill complete (C.2) : 29 cellules, 0 erreur, exec counts 1-9. Co-Authored-By: Claude Sonnet 5 --- .../ICT-46-Strate7-FreeCoordinates.ipynb | 273 +++++++++--------- .../IIT/ICT-Series/ict/free_coordinates.py | 56 +++- .../ICT-Series/tests/test_free_coordinates.py | 20 +- 3 files changed, 193 insertions(+), 156 deletions(-) diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb index 040c7b281e..a415900a02 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb @@ -5,10 +5,10 @@ "id": "e732b4cb", "metadata": { "papermill": { - "duration": 0.003806, - "end_time": "2026-09-27T16:05:00.656289", + "duration": 0.004627, + "end_time": "2026-09-27T17:22:06.475415", "exception": false, - "start_time": "2026-09-27T16:05:00.652483", + "start_time": "2026-09-27T17:22:06.470788", "status": "completed" }, "tags": [] @@ -36,10 +36,10 @@ "id": "424313fc", "metadata": { "papermill": { - "duration": 0.004111, - "end_time": "2026-09-27T16:05:00.663833", + "duration": 0.002125, + "end_time": "2026-09-27T17:22:06.481452", "exception": false, - "start_time": "2026-09-27T16:05:00.659722", + "start_time": "2026-09-27T17:22:06.479327", "status": "completed" }, "tags": [] @@ -56,16 +56,16 @@ "id": "81df13de", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:00.674201Z", - "iopub.status.busy": "2026-09-27T16:05:00.673962Z", - "iopub.status.idle": "2026-09-27T16:05:01.580420Z", - "shell.execute_reply": "2026-09-27T16:05:01.579913Z" + "iopub.execute_input": "2026-09-27T17:22:06.486724Z", + "iopub.status.busy": "2026-09-27T17:22:06.486364Z", + "iopub.status.idle": "2026-09-27T17:22:07.982507Z", + "shell.execute_reply": "2026-09-27T17:22:07.981936Z" }, "papermill": { - "duration": 0.91297, - "end_time": "2026-09-27T16:05:01.581332", + "duration": 1.499745, + "end_time": "2026-09-27T17:22:07.983305", "exception": false, - "start_time": "2026-09-27T16:05:00.668362", + "start_time": "2026-09-27T17:22:06.483560", "status": "completed" }, "tags": [] @@ -113,10 +113,10 @@ "id": "daf94d68", "metadata": { "papermill": { - "duration": 0.002179, - "end_time": "2026-09-27T16:05:01.585870", + "duration": 0.002434, + "end_time": "2026-09-27T17:22:07.988223", "exception": false, - "start_time": "2026-09-27T16:05:01.583691", + "start_time": "2026-09-27T17:22:07.985789", "status": "completed" }, "tags": [] @@ -132,10 +132,10 @@ "id": "b3f283eb", "metadata": { "papermill": { - "duration": 0.002097, - "end_time": "2026-09-27T16:05:01.592365", + "duration": 0.002349, + "end_time": "2026-09-27T17:22:07.992684", "exception": false, - "start_time": "2026-09-27T16:05:01.590268", + "start_time": "2026-09-27T17:22:07.990335", "status": "completed" }, "tags": [] @@ -152,16 +152,16 @@ "id": "048a0c89", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:01.597484Z", - "iopub.status.busy": "2026-09-27T16:05:01.597077Z", - "iopub.status.idle": "2026-09-27T16:05:01.602070Z", - "shell.execute_reply": "2026-09-27T16:05:01.601519Z" + "iopub.execute_input": "2026-09-27T17:22:08.001701Z", + "iopub.status.busy": "2026-09-27T17:22:08.001425Z", + "iopub.status.idle": "2026-09-27T17:22:08.007029Z", + "shell.execute_reply": "2026-09-27T17:22:08.006433Z" }, "papermill": { - "duration": 0.008762, - "end_time": "2026-09-27T16:05:01.603172", + "duration": 0.011082, + "end_time": "2026-09-27T17:22:08.008334", "exception": false, - "start_time": "2026-09-27T16:05:01.594410", + "start_time": "2026-09-27T17:22:07.997252", "status": "completed" }, "tags": [] @@ -199,10 +199,10 @@ "id": "d9de53cd", "metadata": { "papermill": { - "duration": 0.002114, - "end_time": "2026-09-27T16:05:01.607606", + "duration": 0.002042, + "end_time": "2026-09-27T17:22:08.012742", "exception": false, - "start_time": "2026-09-27T16:05:01.605492", + "start_time": "2026-09-27T17:22:08.010700", "status": "completed" }, "tags": [] @@ -210,7 +210,7 @@ "source": [ "### Lecture du résultat\n", "\n", - "Sur son support, le prédicteur converge ($\\approx 1$ bit = l'entropie du tirage 70/30). La surprise hors support vaut $\\log_2(|A|+1)$ : le +1 est **la porte que l'espace n'avait pas**. C'est la forme calculable de la différence entre *ignorer une valeur dans $L$* (freebit d'Aaronson, ordre 1) et *ignorer $L$ lui-même* (free coordinate, ordre 2) : la première incertitude se monnaie en bits de valeur, la seconde en bits de **coordonnée**." + "Sur son support, le prédicteur converge — 0,938 bit par coup en moyenne, contre $H(0{,}7) \\approx 0{,}881$ bit, l'entropie du tirage 70/30 (l'écart vient du lissage de Laplace de l'estimateur, qui tire les probabilités vers 1/2). La surprise hors support vaut $\\log_2(|A|+1)$ : le +1 est **la porte que l'espace n'avait pas**. C'est la forme calculable de la différence entre *ignorer une valeur dans $L$* (freebit d'Aaronson, ordre 1) et *ignorer $L$ lui-même* (free coordinate, ordre 2) : la première incertitude se monnaie en bits de valeur, la seconde en bits de **coordonnée**." ] }, { @@ -218,10 +218,10 @@ "id": "52bc05e3", "metadata": { "papermill": { - "duration": 0.00212, - "end_time": "2026-09-27T16:05:01.611888", + "duration": 0.002007, + "end_time": "2026-09-27T17:22:08.016779", "exception": false, - "start_time": "2026-09-27T16:05:01.609768", + "start_time": "2026-09-27T17:22:08.014772", "status": "completed" }, "tags": [] @@ -238,16 +238,16 @@ "id": "a4b99a2e", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:01.617295Z", - "iopub.status.busy": "2026-09-27T16:05:01.616962Z", - "iopub.status.idle": "2026-09-27T16:05:01.621150Z", - "shell.execute_reply": "2026-09-27T16:05:01.620721Z" + "iopub.execute_input": "2026-09-27T17:22:08.022654Z", + "iopub.status.busy": "2026-09-27T17:22:08.022436Z", + "iopub.status.idle": "2026-09-27T17:22:08.026434Z", + "shell.execute_reply": "2026-09-27T17:22:08.025911Z" }, "papermill": { - "duration": 0.007867, - "end_time": "2026-09-27T16:05:01.621928", + "duration": 0.008482, + "end_time": "2026-09-27T17:22:08.027262", "exception": false, - "start_time": "2026-09-27T16:05:01.614061", + "start_time": "2026-09-27T17:22:08.018780", "status": "completed" }, "tags": [] @@ -285,10 +285,10 @@ "id": "babdd5d2", "metadata": { "papermill": { - "duration": 0.002285, - "end_time": "2026-09-27T16:05:01.627437", + "duration": 0.002006, + "end_time": "2026-09-27T17:22:08.031556", "exception": false, - "start_time": "2026-09-27T16:05:01.625152", + "start_time": "2026-09-27T17:22:08.029550", "status": "completed" }, "tags": [] @@ -304,10 +304,10 @@ "id": "fa804e14", "metadata": { "papermill": { - "duration": 0.002196, - "end_time": "2026-09-27T16:05:01.631948", + "duration": 0.002049, + "end_time": "2026-09-27T17:22:08.035667", "exception": false, - "start_time": "2026-09-27T16:05:01.629752", + "start_time": "2026-09-27T17:22:08.033618", "status": "completed" }, "tags": [] @@ -324,16 +324,16 @@ "id": "0c819eba", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:01.637431Z", - "iopub.status.busy": "2026-09-27T16:05:01.637202Z", - "iopub.status.idle": "2026-09-27T16:05:01.640745Z", - "shell.execute_reply": "2026-09-27T16:05:01.640340Z" + "iopub.execute_input": "2026-09-27T17:22:08.041436Z", + "iopub.status.busy": "2026-09-27T17:22:08.041213Z", + "iopub.status.idle": "2026-09-27T17:22:08.045104Z", + "shell.execute_reply": "2026-09-27T17:22:08.044578Z" }, "papermill": { - "duration": 0.00721, - "end_time": "2026-09-27T16:05:01.641479", + "duration": 0.008103, + "end_time": "2026-09-27T17:22:08.045806", "exception": false, - "start_time": "2026-09-27T16:05:01.634269", + "start_time": "2026-09-27T17:22:08.037703", "status": "completed" }, "tags": [] @@ -364,10 +364,10 @@ "id": "2002f3d4", "metadata": { "papermill": { - "duration": 0.002277, - "end_time": "2026-09-27T16:05:01.646086", + "duration": 0.002138, + "end_time": "2026-09-27T17:22:08.050210", "exception": false, - "start_time": "2026-09-27T16:05:01.643809", + "start_time": "2026-09-27T17:22:08.048072", "status": "completed" }, "tags": [] @@ -383,10 +383,10 @@ "id": "a4620045", "metadata": { "papermill": { - "duration": 0.002258, - "end_time": "2026-09-27T16:05:01.650747", + "duration": 0.002221, + "end_time": "2026-09-27T17:22:08.054629", "exception": false, - "start_time": "2026-09-27T16:05:01.648489", + "start_time": "2026-09-27T17:22:08.052408", "status": "completed" }, "tags": [] @@ -394,7 +394,7 @@ "source": [ "## 5. Pouvoir performatif $P(R)$ : le coup change-t-il la trajectoire du système ?\n", "\n", - "$P(R) = D(\\mathrm{Pr}(traj \\mid do(\\eta)) \\,\\|\\, \\mathrm{Pr}(traj \\mid do(\\neg\\eta)))$ — la divergence KL entre les distributions d'actions du système avec et sans le coup ontologique (interventionnisme de Pearl, estimée par Monte Carlo à lissage de Laplace). Un coup décoratif rend $P(R) \\approx 0$." + "$P(R) = D(\\mathrm{Pr}(traj \\mid do(\\eta)) \\,\\|\\, \\mathrm{Pr}(traj \\mid do(\\neg\\eta)))$ — la divergence KL entre les distributions d'actions du système avec et sans le coup ontologique (interventionnisme de Pearl), estimée par Monte Carlo à **lissage de Laplace symétrique sur l'union des supports** et exprimée en **bits**. Le cadrage D1 pose au niveau formel : *un coup décoratif — un nouveau mot qui n'agit sur rien — a $P(R) \\approx 0$*. Le banc rend cette définition opératoire, et honnêtement : une copie d'action au profil de paiements identique reste une option **distinguée** pour la dynamique (elle capte du temps de jeu) ; elle n'est décorative qu'**au quotient des équivalences** — la même equivalence action/classe que le $C_t$ du §4." ] }, { @@ -403,16 +403,16 @@ "id": "de72e04c", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:01.656487Z", - "iopub.status.busy": "2026-09-27T16:05:01.656220Z", - "iopub.status.idle": "2026-09-27T16:05:01.678011Z", - "shell.execute_reply": "2026-09-27T16:05:01.677330Z" + "iopub.execute_input": "2026-09-27T17:22:08.060201Z", + "iopub.status.busy": "2026-09-27T17:22:08.059812Z", + "iopub.status.idle": "2026-09-27T17:22:08.090650Z", + "shell.execute_reply": "2026-09-27T17:22:08.090130Z" }, "papermill": { - "duration": 0.025843, - "end_time": "2026-09-27T16:05:01.678891", + "duration": 0.034555, + "end_time": "2026-09-27T17:22:08.091426", "exception": false, - "start_time": "2026-09-27T16:05:01.653048", + "start_time": "2026-09-27T17:22:08.056871", "status": "completed" }, "tags": [] @@ -422,8 +422,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "P(R) personne-morale = 13.033 bits (le coup transforme la dynamique)\n", - "P(R) decoratif = 8.363 bits (la copie ne change rien)\n" + "P(R) personne-morale = 2.753 bits (signer/posseder : de vraies nouvelles actions)\n", + "P(R) decoratif brut = 1.819 bits (vendre2 reste une option DISTINGUEE)\n", + "P(R) decoratif marginalise = 0.029 bits (vendre2 equivaut a vendre : dynamique de fond inchangee)\n" ] } ], @@ -437,9 +438,11 @@ "for agent in G_deco.agents: # 'vendre2' paie exactement comme 'vendre' : copie decorative\n", " G_deco.payoffs[(agent, \"vendre2\")] = G_deco.payoffs[(agent, \"vendre\")]\n", "P_deco = performative_power(G_deco, G0, horizon=20, n_sim=8, rng=rng)\n", + "P_deco_eq = performative_power(G_deco, G0, horizon=20, n_sim=8, rng=rng, equivalence={\"vendre2\": \"vendre\"})\n", "\n", - "print(f\"P(R) personne-morale = {P_pm:.3f} bits (le coup transforme la dynamique)\")\n", - "print(f\"P(R) decoratif = {P_deco:.3f} bits (la copie ne change rien)\")" + "print(f\"P(R) personne-morale = {P_pm:.3f} bits (signer/posseder : de vraies nouvelles actions)\")\n", + "print(f\"P(R) decoratif brut = {P_deco:.3f} bits (vendre2 reste une option DISTINGUEE)\")\n", + "print(f\"P(R) decoratif marginalise = {P_deco_eq:.3f} bits (vendre2 equivaut a vendre : dynamique de fond inchangee)\")" ] }, { @@ -447,10 +450,10 @@ "id": "ed249f5f", "metadata": { "papermill": { - "duration": 0.002283, - "end_time": "2026-09-27T16:05:01.684073", + "duration": 0.002281, + "end_time": "2026-09-27T17:22:08.096215", "exception": false, - "start_time": "2026-09-27T16:05:01.681790", + "start_time": "2026-09-27T17:22:08.093934", "status": "completed" }, "tags": [] @@ -458,7 +461,7 @@ "source": [ "### Lecture du résultat\n", "\n", - "La personne morale ($P(R) > 0$, substantiel) **transforme** la distribution des trajectoires ; une action-copie au même profil de paiements laisse $P(R)$ proche de zéro. Attention à la lecture : $P(R)$ mesure le *pouvoir causal du coup*, pas sa *légitimité* — un coup manipulateur a aussi un $P(R)$ élevé. Les proxys suivant précisent le destin temporel." + "Trois nombres, trois lectures. La **personne morale** ($P(R) \\approx 2{,}8$ bits) transforme la distribution des trajectoires : `signer` et `posseder` sont de nouvelles options, avec leurs paiements propres, qui captent du temps de jeu. La **copie décorative brute** garde un $P(R)$ non nul ($P(R) \\approx 1{,}8$ bit) : `vendre2` est une option *distinguée* — le softmax lui consacre du temps de jeu que la baseline accorde à `vendre` seul. **Marginalisée par l'équivalence** `vendre2 ≡ vendre`, elle tombe à $\\approx 0{,}03$ bit : la copie ne change pas la dynamique de *fond*, seulement son habillage. C'est la définition D1 rendue opératoire — *un nouveau mot qui n'agit sur rien* — et la même equivalence action/classe que le quotient d'extensions du $C_t$ (§4). Attention à la lecture : $P(R)$ mesure le *pouvoir causal du coup*, pas sa *légitimité* — un coup manipulateur a aussi un $P(R)$ élevé. Les proxys suivant précisent le destin temporel." ] }, { @@ -466,10 +469,10 @@ "id": "d066a4e6", "metadata": { "papermill": { - "duration": 0.002243, - "end_time": "2026-09-27T16:05:01.688660", + "duration": 0.002402, + "end_time": "2026-09-27T17:22:08.100786", "exception": false, - "start_time": "2026-09-27T16:05:01.686417", + "start_time": "2026-09-27T17:22:08.098384", "status": "completed" }, "tags": [] @@ -486,16 +489,16 @@ "id": "ddea088a", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:01.694198Z", - "iopub.status.busy": "2026-09-27T16:05:01.693831Z", - "iopub.status.idle": "2026-09-27T16:05:01.700573Z", - "shell.execute_reply": "2026-09-27T16:05:01.700067Z" + "iopub.execute_input": "2026-09-27T17:22:08.106633Z", + "iopub.status.busy": "2026-09-27T17:22:08.106244Z", + "iopub.status.idle": "2026-09-27T17:22:08.112834Z", + "shell.execute_reply": "2026-09-27T17:22:08.112396Z" }, "papermill": { - "duration": 0.010434, - "end_time": "2026-09-27T16:05:01.701313", + "duration": 0.010946, + "end_time": "2026-09-27T17:22:08.113928", "exception": false, - "start_time": "2026-09-27T16:05:01.690879", + "start_time": "2026-09-27T17:22:08.102982", "status": "completed" }, "tags": [] @@ -531,10 +534,10 @@ "id": "19debc9b", "metadata": { "papermill": { - "duration": 0.002622, - "end_time": "2026-09-27T16:05:01.707540", + "duration": 0.002418, + "end_time": "2026-09-27T17:22:08.118604", "exception": false, - "start_time": "2026-09-27T16:05:01.704918", + "start_time": "2026-09-27T17:22:08.116186", "status": "completed" }, "tags": [] @@ -550,10 +553,10 @@ "id": "f879d981", "metadata": { "papermill": { - "duration": 0.00247, - "end_time": "2026-09-27T16:05:01.713349", + "duration": 0.002202, + "end_time": "2026-09-27T17:22:08.123109", "exception": false, - "start_time": "2026-09-27T16:05:01.710879", + "start_time": "2026-09-27T17:22:08.120907", "status": "completed" }, "tags": [] @@ -573,10 +576,10 @@ "id": "24e71991", "metadata": { "papermill": { - "duration": 0.002229, - "end_time": "2026-09-27T16:05:01.717899", + "duration": 0.002283, + "end_time": "2026-09-27T17:22:08.127590", "exception": false, - "start_time": "2026-09-27T16:05:01.715670", + "start_time": "2026-09-27T17:22:08.125307", "status": "completed" }, "tags": [] @@ -592,10 +595,10 @@ "id": "37b56d04", "metadata": { "papermill": { - "duration": 0.002175, - "end_time": "2026-09-27T16:05:01.722527", + "duration": 0.002278, + "end_time": "2026-09-27T17:22:08.132034", "exception": false, - "start_time": "2026-09-27T16:05:01.720352", + "start_time": "2026-09-27T17:22:08.129756", "status": "completed" }, "tags": [] @@ -611,10 +614,10 @@ "id": "609da3bc", "metadata": { "papermill": { - "duration": 0.002258, - "end_time": "2026-09-27T16:05:01.726829", + "duration": 0.00255, + "end_time": "2026-09-27T17:22:08.136732", "exception": false, - "start_time": "2026-09-27T16:05:01.724571", + "start_time": "2026-09-27T17:22:08.134182", "status": "completed" }, "tags": [] @@ -633,16 +636,16 @@ "id": "68038589", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:01.732281Z", - "iopub.status.busy": "2026-09-27T16:05:01.732086Z", - "iopub.status.idle": "2026-09-27T16:05:01.735205Z", - "shell.execute_reply": "2026-09-27T16:05:01.734784Z" + "iopub.execute_input": "2026-09-27T17:22:08.141729Z", + "iopub.status.busy": "2026-09-27T17:22:08.141526Z", + "iopub.status.idle": "2026-09-27T17:22:08.144566Z", + "shell.execute_reply": "2026-09-27T17:22:08.144159Z" }, "papermill": { - "duration": 0.007323, - "end_time": "2026-09-27T16:05:01.736443", + "duration": 0.006671, + "end_time": "2026-09-27T17:22:08.145476", "exception": false, - "start_time": "2026-09-27T16:05:01.729120", + "start_time": "2026-09-27T17:22:08.138805", "status": "completed" }, "tags": [] @@ -672,10 +675,10 @@ "id": "686e54d2", "metadata": { "papermill": { - "duration": 0.002402, - "end_time": "2026-09-27T16:05:01.743833", + "duration": 0.003423, + "end_time": "2026-09-27T17:22:08.151829", "exception": false, - "start_time": "2026-09-27T16:05:01.741431", + "start_time": "2026-09-27T17:22:08.148406", "status": "completed" }, "tags": [] @@ -694,16 +697,16 @@ "id": "6a7cfcbd", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:01.749114Z", - "iopub.status.busy": "2026-09-27T16:05:01.748928Z", - "iopub.status.idle": "2026-09-27T16:05:01.752163Z", - "shell.execute_reply": "2026-09-27T16:05:01.751744Z" + "iopub.execute_input": "2026-09-27T17:22:08.157272Z", + "iopub.status.busy": "2026-09-27T17:22:08.157073Z", + "iopub.status.idle": "2026-09-27T17:22:08.159850Z", + "shell.execute_reply": "2026-09-27T17:22:08.159459Z" }, "papermill": { - "duration": 0.006753, - "end_time": "2026-09-27T16:05:01.752848", + "duration": 0.00661, + "end_time": "2026-09-27T17:22:08.160878", "exception": false, - "start_time": "2026-09-27T16:05:01.746095", + "start_time": "2026-09-27T17:22:08.154268", "status": "completed" }, "tags": [] @@ -734,10 +737,10 @@ "id": "7796c57e", "metadata": { "papermill": { - "duration": 0.002398, - "end_time": "2026-09-27T16:05:01.757889", + "duration": 0.002417, + "end_time": "2026-09-27T17:22:08.166353", "exception": false, - "start_time": "2026-09-27T16:05:01.755491", + "start_time": "2026-09-27T17:22:08.163936", "status": "completed" }, "tags": [] @@ -756,16 +759,16 @@ "id": "f39fd58b", "metadata": { "execution": { - "iopub.execute_input": "2026-09-27T16:05:01.763257Z", - "iopub.status.busy": "2026-09-27T16:05:01.763065Z", - "iopub.status.idle": "2026-09-27T16:05:01.766464Z", - "shell.execute_reply": "2026-09-27T16:05:01.765910Z" + "iopub.execute_input": "2026-09-27T17:22:08.171149Z", + "iopub.status.busy": "2026-09-27T17:22:08.170964Z", + "iopub.status.idle": "2026-09-27T17:22:08.173486Z", + "shell.execute_reply": "2026-09-27T17:22:08.173190Z" }, "papermill": { - "duration": 0.007214, - "end_time": "2026-09-27T16:05:01.767420", + "duration": 0.006081, + "end_time": "2026-09-27T17:22:08.174434", "exception": false, - "start_time": "2026-09-27T16:05:01.760206", + "start_time": "2026-09-27T17:22:08.168353", "status": "completed" }, "tags": [] @@ -795,10 +798,10 @@ "id": "6a889515", "metadata": { "papermill": { - "duration": 0.002511, - "end_time": "2026-09-27T16:05:01.773694", + "duration": 0.002142, + "end_time": "2026-09-27T17:22:08.180367", "exception": false, - "start_time": "2026-09-27T16:05:01.771183", + "start_time": "2026-09-27T17:22:08.178225", "status": "completed" }, "tags": [] @@ -834,17 +837,17 @@ }, "papermill": { "default_parameters": {}, - "duration": 5.767955, - "end_time": "2026-09-27T16:05:04.478543", + "duration": 4.031261, + "end_time": "2026-09-27T17:22:08.522531", "environment_variables": {}, "exception": null, - "input_path": "MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb", + "input_path": "ICT-46-Strate7-FreeCoordinates.ipynb", "output_path": "ICT-46-Strate7-FreeCoordinates.ipynb", "parameters": {}, - "start_time": "2026-09-27T16:04:58.710588", + "start_time": "2026-09-27T17:22:04.491270", "version": "2.6.0" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ict/free_coordinates.py b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/free_coordinates.py index e886264923..414eca01f5 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/ict/free_coordinates.py +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/free_coordinates.py @@ -204,29 +204,53 @@ def performative_power( horizon: int, n_sim: int, rng: np.random.Generator, + equivalence: dict[str, str] | None = None, ) -> float: - """Proxy ``P(R)`` — KL empirique entre trajectoires sous ``do(eta)`` et ``do(-eta)``. + """Proxy ``P(R)`` — KL empirique (en bits) entre trajectoires ``do(eta)`` / ``do(-eta)``. ``D(Pr(traj | do(R)) || Pr(traj | do(not R)))`` est estimee par divergence KL - a lissage de Laplace sur les histograms d'actions des deux bras. Un coup - decoratif rend ``P(R) ~ 0``. + sur les histogrammes d'actions des deux bras, a lissage de Laplace + SYMETRIQUE sur l'union des supports (une action absente d'un bras pese + ``log2(n_total)``, pas un plancher arbitraire : les deux bras recoivent le + meme +1 sur le meme support). + + ``equivalence`` mappe chaque action vers sa classe d'equivalence (par + defaut, l'identite) ; les histograms sont fusionnes par classe AVANT la KL. + + Semantique du contraste decoratif — deux lectures, pas une : + + - BRUT : une copie d'action (meme profil de paiements) reste une option + DISTINGUEE — le softmax lui consacre du temps de jeu, et ``P(R) > 0`` ; + - MARGINALISEE : passee sous ``equivalence`` (copie -> original), + ``P(R) ~ 0`` — la copie ne change pas la dynamique de fond, seulement + son habillage. C'est la meme equivalence action/classe que le quotient + d'extensions du ``C_t`` (``non_canonicity``). + + Un coup ouvrant de vraies nouvelles actions garde un ``P(R)`` eleve dans + les deux lectures : ses classes n'existent pas dans le bras de reference. """ - def _dist(game: EvolutiveGame) -> dict[str, float]: + equiv = equivalence or {} + + def _cls(a: str) -> str: + return equiv.get(a, a) + + def _counts(game: EvolutiveGame) -> dict[str, int]: agg: dict[str, int] = {} for _ in range(n_sim): for a, c in simulate_trajectory(game, horizon, rng).items(): - agg[a] = agg.get(a, 0) + c - total = sum(agg.values()) + len(agg) - return {a: (c + 1) / total for a, c in agg.items()} - - p, q = _dist(game_do), _dist(game_skip) - support = set(p) | set(q) - kl = 0.0 - for a in support: - pa = p.get(a, 1e-12) - qa = q.get(a, 1e-12) - kl += pa * np.log(pa / qa) - return float(kl) + k = _cls(a) + agg[k] = agg.get(k, 0) + c + return agg + + cd, cs = _counts(game_do), _counts(game_skip) + support = set(cd) | set(cs) | {_cls(a) for a in game_do.actions} | {_cls(a) for a in game_skip.actions} + + def _dist(counts: dict[str, int]) -> dict[str, float]: + total = sum(counts.values()) + len(support) + return {k: (counts.get(k, 0) + 1) / total for k in support} + + p, q = _dist(cd), _dist(cs) + return float(sum(p[k] * np.log2(p[k] / q[k]) for k in support)) def institutionalization( diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/tests/test_free_coordinates.py b/MyIA.AI.Notebooks/IIT/ICT-Series/tests/test_free_coordinates.py index 5f860c8e0b..bb23bb8ccb 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/tests/test_free_coordinates.py +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/tests/test_free_coordinates.py @@ -102,17 +102,27 @@ def test_non_canonicite_une_seule_extension_equivalente(): def test_performative_power_coup_fort_vs_decoratif(): - rng = np.random.default_rng(42) + """Contraste decoratif : une copie d'action est une option DISTINGUEE + (P(R) brut > 0) mais EQUIVALENTE (P(R) marginalise ~ 0) — deux lectures, + pas une. Bornes calibrees multi-seeds (0/7/42/99/2026) : pm >= 2.4, + deco brut <= 2.0, deco marginalise <= 0.10.""" g0, eta = _game(), _eta_personne_morale() g1 = apply_ontology(g0, eta) - p_fort = performative_power(g1, g0, horizon=20, n_sim=8, rng=rng) deco = OntologicalMove("alice", ("ornement",), {"ornement": ("vendre2",)}) g_deco = apply_ontology(g0, deco) for agent in g_deco.agents: g_deco.payoffs[(agent, "vendre2")] = g_deco.payoffs[(agent, "vendre")] - p_deco = performative_power(g_deco, g0, horizon=20, n_sim=8, rng=rng) - assert p_fort > 0.05 - assert p_deco < p_fort + + p_fort = performative_power(g1, g0, horizon=20, n_sim=8, rng=np.random.default_rng(42)) + p_deco = performative_power(g_deco, g0, horizon=20, n_sim=8, rng=np.random.default_rng(42)) + p_deco_eq = performative_power( + g_deco, g0, horizon=20, n_sim=8, rng=np.random.default_rng(42), + equivalence={"vendre2": "vendre"}, + ) + assert p_fort > 2.0 # le coup ouvrant de vraies actions transforme la dynamique + assert p_deco < p_fort # brut : la copie capte moins de dynamique que la vraie ouverture + assert p_deco_eq < 0.15 # marginalisee : la copie ne change PAS la dynamique de fond + assert p_fort > 10 * p_deco_eq def test_institutionnalisation_depend_des_paiements_des_autres(): From 489f635980c7e52c5d689e07de0d7a763ace7877 Mon Sep 17 00:00:00 2001 From: jsboige Date: Mon, 28 Sep 2026 18:38:14 +0200 Subject: [PATCH 5/7] fix(iit,#18052): table des strates -- ligne strate 7 alignee sur l'etat livre du reste du README MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit La ligne de la table disait encore « cadrée par la dimension D1, non livrée » alors que l'en-tête (l.16), la carte (l.18), le bloc d'état (l.263), le paragraphe de section (l.265), l'encart D2 (l.290) et le socle Thom (l.309) passent la strate 7 à livrée par ICT-46. Colonne État corrigée ; colonne « Pattes de la tresse » inchangée (elle décrit l'axe transverse, qui reste « D2 alimente sans occuper »). Markdown seul. Co-Authored-By: Claude Sonnet 5 --- MyIA.AI.Notebooks/IIT/ICT-Series/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/README.md b/MyIA.AI.Notebooks/IIT/ICT-Series/README.md index 162f688bee..69fd6fca06 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/README.md +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/README.md @@ -267,7 +267,7 @@ Des deux derniers barreaux de l'axe vertical, la **strate 7 est livrée** ([ICT- | Strate | Substrat | État | Pattes de la tresse | Epic | |--------|----------|------|---------------------|------| | **6** | l'**argumentation** comme substrat (+ jambe explicabilité LLM) | graine exécutée, strate non livrée | C3 morphogenèse rhétorique ([#7742](https://github.com/jsboige/CoursIA/issues/7742)) · C4 grammaire de propagation ([#7743](https://github.com/jsboige/CoursIA/issues/7743)) | [#7289](https://github.com/jsboige/CoursIA/issues/7289) · horizon altérité [#7291](https://github.com/jsboige/CoursIA/issues/7291) (GATED) | -| **7** | **freebits d'ordre 2** & réversibilité agentique | cadrée par la dimension D1, non livrée | — (D2 l'**alimente** sans l'occuper) | [#7745](https://github.com/jsboige/CoursIA/issues/7745) | +| **7** | **freebits d'ordre 2** & réversibilité agentique | premier barreau livré, [ICT-46](ICT-46-Strate7-FreeCoordinates.ipynb) | — (D2 l'**alimente** sans l'occuper) | [#7745](https://github.com/jsboige/CoursIA/issues/7745) | **Strate 6 — sa graine, elle, est exécutée.** Le substrat est le **discours** : des trajectoires de croyance sur graphes d'arguments, où la question est de savoir si une structure causale se maintient quand ce qui circule n'est plus de la matière ni des poids, mais des raisons. Les notebooks livrés y portent déjà leur mesure : From c39214b6254b522a8607f3c981e3cb345a53a934 Mon Sep 17 00:00:00 2001 From: jsboige Date: Mon, 28 Sep 2026 21:41:12 +0200 Subject: [PATCH 6/7] fix(notebooks,#18052): ICT-46 relie a la chaine de navigation de la serie Le check-nav-chain rougissait a la tete du 27/09 : le carnet neuf ICT-46-Strate7-FreeCoordinates n'avait aucun lien entrant, donc aucun lecteur ne pouvait l'atteindre en suivant la navigation de la serie (regle de l'organe : un carnet sans lien entrant dans une serie qui en a plus d'un est un orphan_entry). Deux aretes en markdown seul, sans re-execution (exception C.2 markdown-only) : - ICT-45, barre **Navigation** : Suivant -> ICT-46 ; - ICT-46, barre **Navigation** inseree sous le titre : Index + Precedent -> ICT-45. Mesure locale (check_notebook_nav_chain.py --check) : le finding [orphan_entry] .../ICT-46-Strate7-FreeCoordinates.ipynb disparait. Le second finding que la CI impute au diff, [orphan_entry] ICT-MUH-FibreTegmark, est pre-existant sur main et sa reparation est en vol dans la PR #18276 (lane myia-po-2026:CoursIA) -- hors perimetre de cette lane, cf commentaire de PR. Co-Authored-By: Claude Sonnet 5 --- .../IIT/ICT-Series/ICT-45-InoculationBifurcation-9B.ipynb | 2 +- .../IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-45-InoculationBifurcation-9B.ipynb b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-45-InoculationBifurcation-9B.ipynb index 1d0caafd8c..05339c9baa 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-45-InoculationBifurcation-9B.ipynb +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-45-InoculationBifurcation-9B.ipynb @@ -15,7 +15,7 @@ }, "source": [ "# ICT-45 — Inoculation et bifurcation : la troisième échelle (9B)\n", - "**Navigation** : [Index](README.md) | [44 — Geometry of Truth](ICT-44-GeometryOfTruth-Python.ipynb)\n", + "**Navigation** : [Index](README.md) | [44 — Geometry of Truth](ICT-44-GeometryOfTruth-Python.ipynb) | [46 — Strate 7 : freebits de second ordre](ICT-46-Strate7-FreeCoordinates.ipynb)\n", "\n", "Ce carnet étend le pilote **ICT-42** à la troisième taille, **Qwen3.5-9B-Base** (32 couches, SAE Qwen-Scope W64K-L0_50, 65 536 features) — le couple de référence historique de la série (#5101), apparié en génération au 2B du pilote (tous deux Qwen3.5, saut ×4.5). La question du pilote se repose à cette échelle : **l'inoculation d'un panel de features SAE à mi-profondeur provoque-t-elle une bifurcation représentationnelle, et cette bifurcation durcit-elle ou s'adoucit-elle quand la taille croît ?**\n" ] diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb index a415900a02..23e6a7d0ea 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-46-Strate7-FreeCoordinates.ipynb @@ -15,6 +15,7 @@ }, "source": [ "# ICT-46 — Strate 7 : freebits de second ordre, le banc exécutable\n", + "**Navigation** : [Index](README.md) | [45 — Inoculation & bifurcation 9B](ICT-45-InoculationBifurcation-9B.ipynb)\n", "\n", "**Première livraison de la strate 7** (issue [#18052](https://github.com/jsboige/CoursIA/issues/18052), veine 3 de l'Epic Aaronson [#16781](https://github.com/jsboige/CoursIA/issues/16781)). Le cadrage D1 [#7745](https://github.com/jsboige/CoursIA/issues/7745) posait l'objet — les *free coordinates* / freebits de second ordre — et ses six proxys mesurables, en prose ([`strate7-cadres-libres.md`](https://github.com/jsboige/CoursIA/blob/main/docs/ict/strate7-cadres-libres.md)). Ce notebook est l'organe : il fait **tourner** le contraste qui définit la strate.\n", "\n", From b210b54c527ce3680a72b7f0d961c69918f35187 Mon Sep 17 00:00:00 2001 From: jsboige Date: Mon, 28 Sep 2026 23:21:45 +0200 Subject: [PATCH 7/7] fix(notebooks,#18052): ICT-MUH relie a ses deux voisins declares MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ICT-MUH-FibreTegmark.ipynb declarait dans son propre en-tete « Voisin MDL : ICT-16 | Charniere compression : ICT-17b », mais aucun des deux ne le citait en retour : le carnet etait un `orphan_entry` pour check_notebook_nav_chain.py — rien ne menait a lui depuis la chaine de navigation de la serie. Le lien reciproque est ajoute dans les deux voisins, en tete de leur cellule 0, sous la forme deja pratiquee par la serie (ligne `**Navigation** : Index | voisin | axe transverse`), qui est celle des paires 44<->45. Mesure : `check_notebook_nav_chain.py --check --diff-files` passe de `FAIL: 1 NEW finding` a `OK: 0 NEW finding`. Les deux findings restants du rapport (Lean-12c, SL-13) sont hors du diff et deja presents sur main. Precision de provenance : ICT-MUH etait deja orphelin sur main avant cette PR (mesure sur un arbre propre a 52f7b3285b : memes trois findings). Le lien est donc un correctif reel, pas la reparation d'une regression introduite ici. Edition markdown seule (exception C.2) : aucune re-execution n'est due. Co-Authored-By: Claude Sonnet 5 --- MyIA.AI.Notebooks/IIT/ICT-Series/ICT-16-MDLTwoPartCode.ipynb | 2 ++ .../IIT/ICT-Series/ICT-17b-Grokking-CompressionProgress.ipynb | 2 ++ 2 files changed, 4 insertions(+) diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-16-MDLTwoPartCode.ipynb b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-16-MDLTwoPartCode.ipynb index f93caf4710..88231fa3c9 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-16-MDLTwoPartCode.ipynb +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-16-MDLTwoPartCode.ipynb @@ -17,6 +17,8 @@ "# ICT-16 — MDL / code en deux parties et bosse complexite-entropie\n", "\n", "**Strate 5** | Epic **#4588** | Issue **#5099** | Part of **#4588** (Closes **#5099**).\n", + "**Navigation** : [Index](README.md) | [17b — Grokking et compression](ICT-17b-Grokking-CompressionProgress.ipynb) | Axe transverse : [ICT-MUH — le texte où Tegmark cite Schmidhuber](ICT-MUH-FibreTegmark.ipynb)\n", + "\n", "\n", "## Pourquoi MDL après K (ICT-13) et F (ICT-14) ?\n", "\n", diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-17b-Grokking-CompressionProgress.ipynb b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-17b-Grokking-CompressionProgress.ipynb index 11b832748f..4aa769a182 100644 --- a/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-17b-Grokking-CompressionProgress.ipynb +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ICT-17b-Grokking-CompressionProgress.ipynb @@ -17,6 +17,8 @@ "# ICT-17b — Grokking et compression-progress : la jambe K à l'épreuve de l'entraînement\n", "\n", "*Strand Schmidhuber de la série ICT — See #4588, #7258, #5090.*\n", + "**Navigation** : [Index](README.md) | [16 — MDL / code en deux parties](ICT-16-MDLTwoPartCode.ipynb) | Axe transverse : [ICT-MUH — le texte où Tegmark cite Schmidhuber](ICT-MUH-FibreTegmark.ipynb)\n", + "\n", "\n", "**Idée centrale.** La triade fondatrice de la série ICT articule trois facettes d'une même\n", "quantité : l'intégration (**Φ**), la surprise / énergie libre (**F**) et la compression (**K**).\n",