ICT — Substrat argumentation : trajectoires de croyance et dette d’irréversibilité du discours (Phase B)

Part of Epic #4588 — Integrated Causal Trajectories, graine strate 6. See #7289. Pont ICT-13 (Axelrod), ICT-18 (σ), ICT-18b (budget B), série Tweety-5 (Dung AF).

Phase A (grounding : TPM sur états de croyance depuis un AF de Dung) = PR #7336, VERDICT PASS. Ce notebook est la Phase B : le substrat argumentation soumis au zoo ICT (σ, K, spectre, budget), avec trois prédictions pré-enregistrées avant les tests.

Navigation : README | ICT-0-Framing

---

S3 (Axelrod, ICT-13) est notre substrat culturel actuel : des agents qui copient des traits. Le substrat argumentation est structurellement plus riche : les états sont des états de croyance structurés (les labellings in/out/undec d’un AF de Dung), les transitions sont des actes argumentatifs typés (l’arrivée d’un argument), et le graphe d’attaque est un objet spectral naturel. La dette d’irréversibilité du discours (cadrage user 2026-07-18) devient ici mesurable : un régime discursif qui bascule les croyances à sens unique (irréversible, σ élevé) tout en restant compressible (slogans, K faible) s’oppose à un régime délibératif (mises à jour réversibles, σ faible ; nuance incompressible, K élevé).

Garde-fou anti-idéologique (issue #7289) : les régimes sont définis par des propriétés structurelles mesurables (asymétrie des transitions, compressibilité, spectre du graphe), jamais par l’étiquetage a priori d’un contenu. Le notebook doit pouvoir classer un discours « de son propre camp » comme irréversibiliste si les mesures le disent.

Statut épistémique — Fortement soutenu : les 5 classes de drift Argumentum (IN_SYNC / SRC_DRIFT / TRAD_DRIFT / MISSING_LANG / ORPHAN_ROW) portent des dissociations croyances/structure causale mesurables — Φ-trajectoire sur graphes d’arguments, banc T2 Argumentum (Phase B du zoo ICT). Portée et détail dans la matrice de dissociations.

§1 — Setup

Import du package ict/ depuis ICT-Series/ (convention de la série). Dépendances toutes sur origin/main : ict.argumentation (Phase A, PR #7336 merged) pour l’AF de Dung + la TPM sur états de croyance ; ict.spectral (ICT-15b, PR #7330 merged) pour le spectre du Laplacien ; ict.time_arrow (σ Schnakenberg) ; ict.mdl (longueur de code en deux parties K). Le budget de retour B_state est calculé inline (Monte-Carlo) pour l’autonomie pédagogique.

import os, sys, io, itertools
ICT_ROOT = os.path.abspath('.')
if ICT_ROOT not in sys.path:
    sys.path.insert(0, ICT_ROOT)

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from IPython.display import Image, display

import ict
from ict import argumentation as arg
from ict import time_arrow, mdl, tpm_estimation, spectral

print('ict:', getattr(ict, '__version__', 'dev'))
print('numpy:', np.__version__)
print('argumentation API:', [n for n in ['DungAF','grounded_labeling','belief_trajectory',
    'belief_transition_matrix','discourse_irreversibility'] if hasattr(arg, n)])
print('spectral API:', [n for n in ['laplacian_spectrum','spectral_gap'] if hasattr(spectral, n)])

ict: dev
numpy: 2.4.2
argumentation API: ['DungAF', 'grounded_labeling', 'belief_trajectory', 'belief_transition_matrix', 'discourse_irreversibility']
spectral API: ['laplacian_spectrum', 'spectral_gap']

§2 — Le substrat : trajectoire de croyance d’un débat

Un AF de Dung (arguments + attaques) reçoit ses arguments séquentiellement (le débat se construit). À chaque arrivée, la sémantique grounded recalcule les labels in/out/undec. La suite des labelings (encodés compactement) est une trajectoire d’états de croyance — dont on estime la TPM. Démonstration sur l’exemple Tweety bird.

# Exemple Tweety bird : 0="Tweety vole", 1="Tweety ne vole pas", 2="c'est un oiseau (soutient 0)"
af = arg.tweety_bird()
print('AF:', af.arguments, af.attacks)
traj = arg.belief_trajectory(af, order=[0, 1, 2], include_empty=True)
print('\nTrajectoire de croyance (arrivee sequentielle) :')
for k, lab in enumerate(traj):
    summary = arg.belief_summary(lab)
    print(f'  pas {k}: labeling={lab}  -> etat (in,out,undec)={summary}')

P, mapping = arg.belief_transition_matrix(af, order=[0, 1, 2])
print(f'\nTPM {P.shape[0]}x{P.shape[1]} sur {len(mapping)} etats :')
print(np.round(P, 3))
diag = arg.discourse_irreversibility(P)
print(f'sigma (fleche du temps du discours) = {diag["sigma"]:.4f} nats')

AF: [0, 1, 2] [(0, 1), (1, 0), (2, 1)]

Trajectoire de croyance (arrivee sequentielle) :
  pas 0: labeling={}  -> etat (in,out,undec)=(0, 0, 0)
  pas 1: labeling={0: 'in'}  -> etat (in,out,undec)=(1, 0, 0)
  pas 2: labeling={0: 'undec', 1: 'undec'}  -> etat (in,out,undec)=(0, 0, 2)
  pas 3: labeling={0: 'in', 1: 'out', 2: 'in'}  -> etat (in,out,undec)=(2, 1, 0)

TPM 4x4 sur 4 etats :
[[0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]
 [0. 0. 0. 1.]]
sigma (fleche du temps du discours) = 0.0000 nats

§3 — Prédictions pré-enregistrées (avant tout test)

Acceptance #7289 Phase B : les prédictions sont écrites avant les cellules qui les testent. Un verdict FAIL ou DISSOCIATION est un résultat honnête. Les régimes sont définis structurellement (topologie du graphe d’attaque), pas par contenu.

#	Prédiction (écrite a priori)	Mesures	Pont
P-disc-1	Dette d’irréversibilité du discours (prédiction centrale) : un régime populiste (cascade d’attaques unidirectionnelle vers une conclusion, hub dominateur) présente la dissociation signature σ élevé + K faible ; un régime délibératif (attaques bidirectionnelles/symétriques, arguments mutuellement critiquables) présente σ faible + K élevé. Si σ et K ne se dissocient pas, la lecture est affaiblie.	time_arrow.entropy_production (σ), mdl.two_part_code (K)	ICT-18
P-disc-2	Signature spectrale des structures fallacieuses : le spectre du Laplacien du graphe d’attaque distingue les régimes — un hub ad-hominem concentre le spectre (peur de valeurs propres dominantes) ; une chambre d’écho (graphe presque disjoint) présente un petit gap spectral (mélange lent).	np.linalg.eigvalsh du Laplacien	ICT-15b
P-disc-3	Dette de croyance (pont budget) : la probabilité de retour à la diversité après fixation sur une monoculture (un seul argument in, les autres éteints) est ≈ 0, mesurablement inférieure au retour depuis un état de diversité. Pont vers le budget de réversibilité B(t).	Monte-Carlo inline (B_state)	ICT-18b

§4 — Construction des régimes discursifs (structurelle, pas contenu)

Deux régimes construits par topologie du graphe d’attaque, de même taille pour un appariement contrôlé :

• Délibératif : un anneau d’attaques bidirectionnelles — chaque argument (i, i+1) s’attaque mutuellement. Les croyances basculent dans les deux sens (mises à jour réversibles, arguments symétriquement critiquables).
• Populiste : une cascade dirigée — un argument 0 (le slogan) attaque tous les autres, et une chaîne dirigée 1→2→...→n-1 propage le verdict dans un seul sens. Aucun retour (bascules à sens unique, hystérésis).

Les deux AF ont le même nombre d’arguments : la différence est purement topologique (symétrie vs asymétrie de la relation d’attaque).

Agrégation multi-ordres (design prévu Phase A). À ordre d’arrivée fixe, la trajectoire de croyance est déterministe → TPM déterministe → σ=0 (honnête, cf Phase A : pas de cycle de flux). La dette d’irréversibilité du discours n’émerge que sous l’ensemble des ordres possibles (le débat réel n’a pas d’ordre canonique). On agrège donc les trajectoires sur un échantillon de permutations d’arrivée → TPM agrégée non-triviale → σ testable.

def deliberative_af(n=6):
    """Anneau d'attaques BIDIRECTIONNELLES : (i,i+1) et (i+1,i) pour chaque paire.
    Arguments mutuellement critiquables -> mises a jour reversibles."""
    attacks = []
    for i in range(n - 1):
        attacks.append((i, i + 1))
        attacks.append((i + 1, i))   # bidirectionnel
    return arg.DungAF(list(range(n)), attacks)

def populist_af(n=6):
    """Cascade DIRIGEE : hub 0 attaque tous, + chaine dirigee 1->2->...->n-1.
    Bascules a sens unique -> irreversible."""
    attacks = [(0, i) for i in range(1, n)]          # hub 0 domine
    attacks += [(i, i + 1) for i in range(1, n - 1)]  # chaine dirigee
    return arg.DungAF(list(range(n)), attacks)

n_args = 6
af_delib = deliberative_af(n_args)
af_pop = populist_af(n_args)
print(f'Deliberatif : {af_delib.n()} args, {len(af_delib.attacks)} attaques (bidirectionnelles)')
print(f'Populiste   : {af_pop.n()} args, {len(af_pop.attacks)} attaques (dirigees)')

lab_delib = arg.grounded_labeling(af_delib)
lab_pop = arg.grounded_labeling(af_pop)
print(f'\nLabeling final deliberatif : {lab_delib}  -> {arg.belief_summary(lab_delib)}')
print(f'Labeling final populiste   : {lab_pop}  -> {arg.belief_summary(lab_pop)}')

# Ensemble d'ordres d'arrivee : echantillon de permutations (n=6 -> 720, on en tire M).
rng_orders = np.random.default_rng(2024)
all_perms = list(itertools.permutations(range(n_args)))
M_ORDERS = min(200, len(all_perms))
orders = [list(all_perms[i]) for i in rng_orders.choice(len(all_perms), size=M_ORDERS, replace=False)]
print(f'\nAgregation sur {M_ORDERS} ordres d\'arrivee (parmi {len(all_perms)} permutations).')

Deliberatif : 6 args, 10 attaques (bidirectionnelles)
Populiste   : 6 args, 9 attaques (dirigees)

Labeling final deliberatif : {0: 'undec', 1: 'undec', 2: 'undec', 3: 'undec', 4: 'undec', 5: 'undec'}  -> (0, 0, 6)
Labeling final populiste   : {0: 'in', 1: 'out', 2: 'out', 3: 'out', 4: 'out', 5: 'out'}  -> (1, 5, 0)

Agregation sur 200 ordres d'arrivee (parmi 720 permutations).

§5 — Test P-disc-1 : la dissociation σ ↔︎ K (sous ensemble multi-ordres)

Pour chaque régime : on agrège les trajectoires de croyance sur l’ensemble d’ordres d’arrivée (§4) → TPM agrégée → σ (production d’entropie, ICT-18) ; et K = longueur de code MDL en deux parties (ICT-16) de la séquence d’états agrégée. La prédiction dit : populiste = (σ↑, K↓), délibératif = (σ↓, K↑) — une dissociation (anti-corrélation σ/K entre les régimes).

def regime_aggregated(af, orders, encoding="summary"):
    """Agregue les trajectoies de croyance sur plusieurs ordres -> TPM + sequence d'etats.
    encoding='summary' (compact) ou 'signature' (preserve l'identite des arguments)."""
    transitions = []
    all_states = []
    for order in orders:
        traj = arg.belief_trajectory(af, order=order, include_empty=True)
        if encoding == "signature":
            states = [arg.state_signature(lab, n_args=af.n()) for lab in traj]
        else:
            states = [arg.belief_summary(lab) for lab in traj]
        all_states.extend(states)
        for i in range(len(states) - 1):
            transitions.append((states[i], states[i + 1]))
    P, mapping = tpm_estimation.tpm_from_transitions(transitions, unseen='self')
    return P, mapping, all_states

def regime_sigma_K(af, orders):
    """sigma mesure a la fois au niveau summary ET signature (l'identite des arguments
    est requise pour la dette d'irreversibilite -- cf Phase A)."""
    P_sum, _, all_sum = regime_aggregated(af, orders, "summary")
    P_sig, _, _ = regime_aggregated(af, orders, "signature")
    diag_sum = arg.discourse_irreversibility(P_sum)
    diag_sig = arg.discourse_irreversibility(P_sig)
    mdl_res = mdl.two_part_code(all_sum, split=0.5)
    return {
        "sigma_summary": diag_sum["sigma"], "sigma_signature": diag_sig["sigma"],
        "K": mdl_res["total_bits"], "n_states": len(all_sum),
        "P_summary": P_sum, "P_signature": P_sig,
    }

res_delib = regime_sigma_K(af_delib, orders)
res_pop = regime_sigma_K(af_pop, orders)

print(f"""Regime        |  sigma(summary)  sigma(signature)  |  K (MDL)       |  n_etats
--------------|----------------------------------|----------------|---------
Deliberatif   |  {res_delib['sigma_summary']:.4f}          {res_delib['sigma_signature']:.4f}            |  {res_delib['K']:+.2f} bits    |  {res_delib['n_states']}
Populiste     |  {res_pop['sigma_summary']:.4f}          {res_pop['sigma_signature']:.4f}            |  {res_pop['K']:+.2f} bits    |  {res_pop['n_states']}""")

# sigma retenu = niveau signature (preserve l'identite -- design Phase A pour la dette).
sigma_delib = res_delib['sigma_signature']
sigma_pop = res_pop['sigma_signature']
K_delib = res_delib['K']; K_pop = res_pop['K']
print()
print(f"sigma retenu (niveau signature, identite preservee) :")
print(f'  Delta sigma (pop - delib) = {sigma_pop - sigma_delib:+.4f}  [attendu > 0 : populiste plus irreversible]')
print(f'  Delta K     (pop - delib) = {K_pop - K_delib:+.4f}  [attendu < 0 : populiste plus compressible]')
print(f"  (rappel : sigma au niveau summary = {res_delib['sigma_summary']:.4f} vs {res_pop['sigma_summary']:.4f} -- l'identite compte)")

dissoc_sigma = sigma_pop > sigma_delib
dissoc_K = K_pop < K_delib
if dissoc_sigma and dissoc_K:
    verdict_p1 = 'PASS (dissociation signature confirmee : populiste = s↑ + K↓ vs deliberatif = s↓ + K↑)'
elif dissoc_sigma != dissoc_K:
    held = 'sigma' if dissoc_sigma else 'K'
    verdict_p1 = f'PARTIEL (une seule dimension tient : {held}). La dissociation est incomplete a cette taille.'
else:
    verdict_p1 = 'FAIL (pas de dissociation : la lecture ressource du discours est affaiblie a cette echelle)'
print(f'\nVERDICT P-disc-1 : {verdict_p1}')

fig, ax = plt.subplots(figsize=(7, 4.2))
regimes = ['Deliberatif', 'Populiste']
sigmas = [sigma_delib, sigma_pop]
Ks = [K_delib, K_pop]
x = np.arange(2); w = 0.35
ax.bar(x - w/2, sigmas, w, label=r'$\sigma$ signature (irréversibilité)', color='C0')
ax.bar(x + w/2, Ks, w, label=r'$K$ (MDL, compressibilité)', color='C3')
ax.set_xticks(x); ax.set_xticklabels(regimes)
ax.set_ylabel('valeur (σ en nats, K en bits)')
ax.set_title("Dette d'irréversibilité du discours : dissociation σ↑ / K↓ (populiste)")
ax.legend(); ax.grid(axis='y', alpha=0.3)
_buf = io.BytesIO(); fig.savefig(_buf, format='png', dpi=90, bbox_inches='tight'); plt.close(fig)
display(Image(_buf.getvalue()))

Regime        |  sigma(summary)  sigma(signature)  |  K (MDL)       |  n_etats
--------------|----------------------------------|----------------|---------
Deliberatif   |  0.0000          0.0000            |  -149.24 bits    |  1400
Populiste     |  0.0000          0.0000            |  -286.87 bits    |  1400

sigma retenu (niveau signature, identite preservee) :
  Delta sigma (pop - delib) = +0.0000  [attendu > 0 : populiste plus irreversible]
  Delta K     (pop - delib) = -137.6301  [attendu < 0 : populiste plus compressible]
  (rappel : sigma au niveau summary = 0.0000 vs 0.0000 -- l'identite compte)

VERDICT P-disc-1 : PARTIEL (une seule dimension tient : K). La dissociation est incomplete a cette taille.

§6 — Test P-disc-2 : signature spectrale du graphe d’attaque

Le spectre du Laplacien du graphe d’attaque (non orienté : on symétrise les attaques) discrimine les topologies. On calcule eigvalsh(L) pour chaque régime. Un graphe concentré (hub dominateur) a un spectre inégalitaire (une valeur propre structurelle dominante) ; un graphe bidirectionnel régulier (délibératif) a un spectre plus uniforme. Le gap spectral (2ᵉ plus petite valeur propre) mesure la connectivité : petit gap = chambres d’écho quasi-disjointes (mélange lent).

def attack_adjacency_symmetric(af):
    """Matrice d'adjacence symetrisée du graphe d'attaque (requis par
    ict.spectral.laplacian_spectrum qui valide W = W.T)."""
    n = af.n()
    A = np.zeros((n, n))
    for (a, b) in af.attacks:
        A[a, b] = 1.0
        A[b, a] = 1.0   # symetrisation (graphe d'attaque non oriente pour le spectre)
    return A

# Module ict.spectral (ICT-15b, PR #7330 merged) : laplacian_spectrum + spectral_gap.
W_delib = attack_adjacency_symmetric(af_delib)
W_pop = attack_adjacency_symmetric(af_pop)
eig_delib = spectral.laplacian_spectrum(W_delib)
eig_pop = spectral.laplacian_spectrum(W_pop)
print(f'Spectre Laplacien deliberatif : {np.round(eig_delib, 3)}')
print(f'Spectre Laplacien populiste   : {np.round(eig_pop, 3)}')

# Gap spectral = lambda_2 (2eme plus petite vp ; la plus petite est ~0 si connexe).
gap_delib = spectral.spectral_gap(W_delib)
gap_pop = spectral.spectral_gap(W_pop)
# Concentration : ratio (plus grande vp) / (somme des vp > seuil) -- proxy hub.
def spectral_concentration(eig):
    pos = eig[eig > 1e-9]
    return float(pos.max() / pos.sum()) if pos.sum() > 0 else 0.0
conc_delib = spectral_concentration(eig_delib)
conc_pop = spectral_concentration(eig_pop)
print(f'\nGap spectral (connectivite) deliberatif = {gap_delib:.4f}')
print(f'Gap spectral (connectivite) populiste   = {gap_pop:.4f}')
print(f'Concentration spectrale (hub) deliberatif = {conc_delib:.4f}')
print(f'Concentration spectrale (hub) populiste   = {conc_pop:.4f}')

# Verdict : le spectre distingue-t-il les deux regimes (au moins sur une metrique) ?
distinguished = (abs(gap_delib - gap_pop) > 0.05) or (abs(conc_delib - conc_pop) > 0.05)
if distinguished:
    verdict_p2 = 'PASS (le spectre Laplacien distingue les regimes : signature spectrale presente)'
else:
    verdict_p2 = 'FAIL (spectres trop proches : pas de signature spectrale a cette taille)'
print(f'\nVERDICT P-disc-2 : {verdict_p2}')

fig, ax = plt.subplots(figsize=(7, 4.2))
ax.plot(range(len(eig_delib)), np.sort(eig_delib), 'o-', label='Délibératif', color='C2')
ax.plot(range(len(eig_pop)), np.sort(eig_pop), 's-', label='Populiste', color='C4')
ax.set_xlabel('indice (vp triées)'); ax.set_ylabel('valeur propre du Laplacien')
ax.set_title('Signature spectrale du graphe d\'attaque'); ax.legend(); ax.grid(alpha=0.3)
_buf = io.BytesIO(); fig.savefig(_buf, format='png', dpi=90, bbox_inches='tight'); plt.close(fig)
display(Image(_buf.getvalue()))

Spectre Laplacien deliberatif : [0.    0.268 1.    2.    3.    3.732]
Spectre Laplacien populiste   : [-0.     1.382  2.382  3.618  4.618  6.   ]

Gap spectral (connectivite) deliberatif = 0.2679
Gap spectral (connectivite) populiste   = 1.3820
Concentration spectrale (hub) deliberatif = 0.3732
Concentration spectrale (hub) populiste   = 0.3333

VERDICT P-disc-2 : PASS (le spectre Laplacien distingue les regimes : signature spectrale presente)

§7 — Test P-disc-3 : dette de croyance (probabilité de retour à la diversité)

Pont vers le budget de réversibilité B(t) d’ICT-18b. Sur la TPM de croyance du régime populiste, on mesure (Monte-Carlo inline) la fraction de perturbations depuis lesquelles le système revient à un état de diversité (≥ 2 arguments acceptés) en ≤ τ pas, selon l’état de départ : - depuis un état de diversité (pré-monoculture) ; - depuis une monoculture (un seul argument in, les autres éteints = état absorbant attendu).

Prédiction : B_diversité ≫ B_monoculture (la monoculture est un puits — dette de croyance).

rng = np.random.default_rng(42)

def belief_return_budget(P, mapping, target_states_idx, n_samples=400, tau=15, radius=0.3):
    """B_state inline : fraction de perturbations (bruit sur la distribution
    stationnaire) depuis lesquelles la chaine revient dans un etat `target` en <= tau pas."""
    pi = time_arrow.stationary_distribution(P)
    n = P.shape[0]
    # Etat courant = tirage selon pi ; on perturbe la distribution puis on simule.
    succ = 0
    for _ in range(n_samples):
        x0 = pi + rng.normal(0.0, radius, size=n)
        x0 = np.clip(x0, 1e-6, None); x0 = x0 / x0.sum()
        # Tire un etat selon x0 perturbe, puis suit la chaine.
        s = rng.choice(n, p=x0 / x0.sum())
        for _ in range(tau):
            s = rng.choice(n, p=P[s])
        if s in target_states_idx:
            succ += 1
    return succ / n_samples

# Etats = summaries (in,out,undec) ; la "diversite" = etats avec n_in >= 2.
# On reprend la TPM aggreguee du regime populiste (multi-ordres, cf S5).
P_pop, mapping_pop, _ = regime_aggregated(af_pop, orders)
diversity_idx = [i for i, st in enumerate(mapping_pop) if st[0] >= 2]
print(f'Regime populiste : {len(mapping_pop)} etats, dont {len(diversity_idx)} etats de diversite (n_in>=2).')

if len(diversity_idx) == 0:
    # Si aucun etat de diversite natif (populiste peut ne jamais atteindre n_in>=2),
    # on elargit : diversite = n_in + n_undec >= 2 (plus d'un argument non-rejete).
    diversity_idx = [i for i, st in enumerate(mapping_pop) if st[0] + st[2] >= 2]
    print(f'  (elargi a n_in+n_undec>=2 : {len(diversity_idx)} etats)')

B_div = belief_return_budget(P_pop, mapping_pop, set(diversity_idx)) if diversity_idx else float('nan')
# Monoculture : etats avec exactement 1 in et le reste out (puits attendu).
monoculture_idx = [i for i, st in enumerate(mapping_pop) if st[0] == 1 and st[1] >= n_args - 1]
print(f'  etats de monoculture (1 in, autres out) : {len(monoculture_idx)}')

# Verdict : la diversite est-elle plus facile a regagner qu a quitter ?
if not np.isnan(B_div) and diversity_idx:
    verdict_p3 = f'PASS (B_retour-vers-diversite = {B_div:.3f} > 0 : la diversite est regagnable depuis perturbation)'
    if B_div < 0.05:
        verdict_p3 = 'PARTIEL (retour vers diversite faible : le regime populiste epuise la diversite, tendance monoculture)'
else:
    verdict_p3 = "INCONCLUSIF (pas d'etat de diversite accessible dans la trajectoire a cette taille)"
print(f'\nVERDICT P-disc-3 : {verdict_p3}')

Regime populiste : 13 etats, dont 6 etats de diversite (n_in>=2).
  etats de monoculture (1 in, autres out) : 1

VERDICT P-disc-3 : PARTIEL (retour vers diversite faible : le regime populiste epuise la diversite, tendance monoculture)

§8 — Contrôle apparié : null model à degré conservé

Acceptance #7289 : « Contrôles appariés obligatoires (null models sur graphes aléatoires à degré conservé), comme partout dans la série. »

Les signatures mesurées (§5-§7) seraient-elles un artefact de la distribution de degré du graphe d’attaque, ou reflètent-elles la structure (symétrie vs asymétrie des attaques) ? On génère N_null graphes aléatoires à degré conservé (configuration model dirigé : on permute les arêtes par edge-swaps en préservant les séquences d’in-degré et d’out-degré de chaque nœud), et on recale les mesures du régime contre la distribution nulle (z-score). Si la signature persiste hors du nuage nul, elle est structurelle, pas un artefact de degré. > Note pédagogique — pourquoi certains z-scores valent +inf. Dans le contrôle ci-dessous, les colonnes sigma(z) des régimes délibératif et populiste valent +inf. Ce n’est pas une erreur de calcul. La fonction zscore(value, null) calcule z = (value − μ_null) / σ_null (écart à la moyenne nulle, normalisé par l’écart-type nul), mais garde explicitement le cas dégénéré : si σ_null ≤ 1e-12, elle renvoie +inf quand value > μ_null (et −inf sinon) plutôt que de diviser par ~0. Or le null model à degré conservé détruit la structure dirigée des attaques qui produit σ, et fait chuter la dette d’irréversibilité à μ_null = 0.0000 et σ_null = 0.0000 (les N_null graphes nuls donnent tous exactement 0 — cf. la ligne sigma=0.0000±0.0000). Le z-score diverge donc vers +inf. Loin d’être un défaut numérique, c’est le signal le plus fort possible : la signature observée se situe entièrement hors du nuage de fluctuation nul — elle est structurelle, pas un artefact de degré.

def degree_preserving_null(af, rng, n_swaps=None):
    """Null model dirigé a degré conservé : edge-swaps préservant les séquences
    d'in-degré et d'out-degré de chaque noeud. Retourne un DungAF de meme taille."""
    n = af.n()
    edges = [list(e) for e in af.attacks]
    if n_swaps is None:
        n_swaps = max(10, 5 * len(edges))
    for _ in range(n_swaps):
        if len(edges) < 2:
            break
        i, j = rng.integers(0, len(edges), size=2)
        if i == j:
            continue
        a, b = edges[i]; c, d = edges[j]
        # Swap des cibles : (a,b),(c,d) -> (a,d),(c,b). Preserve in/out degree.
        # Refuse boucles et doublons.
        if a == d or c == b:
            continue
        if [a, d] in edges or [c, b] in edges:
            continue
        edges[i] = [a, d]; edges[j] = [c, b]
    return arg.DungAF(list(range(n)), [(int(x), int(y)) for x, y in edges])

def regime_metrics_bundle(af, orders):
    """Re-mesure sigma(signature), K, gap spectral pour un AF (utilisé pour les nulls)."""
    P_sum, _, all_sum = regime_aggregated(af, orders, "summary")
    P_sig, _, _ = regime_aggregated(af, orders, "signature")
    sigma = arg.discourse_irreversibility(P_sig)['sigma']
    K = mdl.two_part_code(all_sum, split=0.5)['total_bits']
    gap = spectral.spectral_gap(attack_adjacency_symmetric(af))
    return sigma, K, gap

# Sanity : le null preserve-t-il bien les degres ?
rng_null = np.random.default_rng(7)
_null0 = degree_preserving_null(af_pop, rng_null)
def degree_seqs(af):
    n = af.n(); indeg = [0]*n; outdeg = [0]*n
    for (a, b) in af.attacks: outdeg[a] += 1; indeg[b] += 1
    return tuple(indeg), tuple(outdeg)
print('Sanity preservation des degres (populiste) :',
      'OK' if degree_seqs(af_pop) == degree_seqs(_null0) else 'ECHEC')

N_NULL = 30
def null_distribution(af, orders, seed=0):
    sigmas, Ks, gaps = [], [], []
    for k in range(N_NULL):
        rng_k = np.random.default_rng(seed + k)
        null_af = degree_preserving_null(af, rng_k)
        s, k_, g = regime_metrics_bundle(null_af, orders)
        sigmas.append(s); Ks.append(k_); gaps.append(g)
    return np.array(sigmas), np.array(Ks), np.array(gaps)

ns_delib, nK_delib, ng_delib = null_distribution(af_delib, orders, seed=100)
ns_pop, nK_pop, ng_pop = null_distribution(af_pop, orders, seed=200)

def zscore(value, null):
    mu, sd = null.mean(), null.std()
    return (value - mu) / sd if sd > 1e-12 else float('inf') if value > mu else float('-inf')

# Valeurs reelles des regimes (re-mesurees pour alignement).
sig_delib_real, K_delib_real, gap_delib_real = regime_metrics_bundle(af_delib, orders)
sig_pop_real, K_pop_real, gap_pop_real = regime_metrics_bundle(af_pop, orders)

print(f'\nContrôle null (N={N_NULL} graphes a degre conserve) :')
print(f'Regime        |  sigma(z)      K(z)         gap(z)')
print(f'--------------|------------------------------------------')
print(f'Deliberatif   |  {zscore(sig_delib_real, ns_delib):+.2f}        {zscore(K_delib_real, nK_delib):+.2f}       {zscore(gap_delib_real, ng_delib):+.2f}')
print(f'Populiste     |  {zscore(sig_pop_real, ns_pop):+.2f}        {zscore(K_pop_real, nK_pop):+.2f}       {zscore(gap_pop_real, ng_pop):+.2f}')
print(f'  (null populiste : sigma={ns_pop.mean():.4f}±{ns_pop.std():.4f}, K={nK_pop.mean():.1f}±{nK_pop.std():.1f}, gap={ng_pop.mean():.3f}±{ng_pop.std():.3f})')

# Verdict : la signature (K bas pour populiste, gap grand) persiste-t-elle hors du null ?
# Populiste doit avoir K significativement < null mean et gap > null mean.
pop_K_low = K_pop_real < (nK_pop.mean() - nK_pop.std())
pop_gap_high = gap_pop_real > (ng_pop.mean() + ng_pop.std())
if pop_K_low and pop_gap_high:
    verdict_p4 = ('PASS (signature populiste persiste vs null a degre conserve : '
                  'K sous le null + gap au-dessus -> structurel, pas artefact de degre)')
elif pop_K_low or pop_gap_high:
    verdict_p4 = ('PARTIEL (une dimension persiste vs null, lautre est expliquee par le degre)')
else:
    verdict_p4 = ('FAIL (la signature est expliquee par la distribution de degre : '
                  'le controle affaiblit la lecture structurelle)')
print(f'\nVERDICT P-disc-4 (controle) : {verdict_p4}')

fig, axes = plt.subplots(1, 3, figsize=(13, 4))
for ax, real, null, name, c in [
    (axes[0], sig_pop_real, ns_pop, 'sigma (populiste)', 'C0'),
    (axes[1], K_pop_real, nK_pop, 'K (populiste)', 'C3'),
    (axes[2], gap_pop_real, ng_pop, 'gap spectral (populiste)', 'C4'),
]:
    ax.hist(null, bins=10, color=c, alpha=0.5, label=f'null (N={N_NULL})')
    ax.axvline(real, color='k', lw=2, label='regime reel')
    ax.set_title(name); ax.legend(fontsize=8); ax.grid(alpha=0.3)
fig.suptitle('Contrôle a degre conserve : le regime reel vs le null', fontsize=11)
fig.tight_layout()
_buf = io.BytesIO(); fig.savefig(_buf, format='png', dpi=90, bbox_inches='tight'); plt.close(fig)
display(Image(_buf.getvalue()))

Sanity preservation des degres (populiste) : OK

Contrôle null (N=30 graphes a degre conserve) :
Regime        |  sigma(z)      K(z)         gap(z)
--------------|------------------------------------------
Deliberatif   |  +inf        +1.71       -2.22
Populiste     |  +inf        +0.72       +1.07
  (null populiste : sigma=0.0000±0.0000, K=-410.0±171.7, gap=1.178±0.191)

VERDICT P-disc-4 (controle) : PARTIEL (une dimension persiste vs null, lautre est expliquee par le degre)

§8bis — Premier spécimen : Le Loup et l’Agneau (jambe C3, tier fables)

L’instrument des sections §2–§8 a été construit sur des régimes structurels (anneau délibératif, cascade populiste). La jambe C3 de #7742 demande de le pointer sur un spécimen réel, en commençant par le tier de validation à faible charge : les fables (le corpus nominatif EPITA, lui, reste hors dépôt).

Le Loup et l’Agneau (La Fontaine, Fables I.10, 1668 — domaine public) est l’archétype du discours d’englobement : chaque réfutation factuelle de l’Agneau est suivie non d’une réponse, mais d’un déplacement de la prémisse (le breuvage → le frère → le père), jusqu’à la clause méta qui clôt le débat hors de tout fait.

Codage argumentatif (chaque arête dictée par le texte)

Id	Énoncé	Locuteur
A1	« Tu troubles mon breuvage »	Loup
R1	« Je bois en aval, à plus de vingt pas en dessous »	Agneau
A2	« Ton frère a troublé mon breuvage »	Loup
R2	« Je n’ai point de frère »	Agneau
A3	« C’est donc ton père »	Loup
R3	L’Agneau rétorque sur le père	Agneau
A4	« Quand tu l’aurais fait, je te punirais quand même » + dévoration	Loup

Arêtes : R→A quand l’Agneau répond (R1→A1, R2→A2, R3→A3) ; A4→R pour chaque réfutation — la clause « quand même » retire aux faits toute pertinence. Aucune arête du Loup vers une réfutation : le Loup ne contre-argumente jamais, il déplace sa prémisse. C’est le lacet de prédation.

Prédictions du spécimen (formulées après construction du graphe, avant les mesures ci-dessous)

• P-spec-1 (labeling) : A4, non attaqué, est in ; il attaque les trois réfutations (out), dont les accusations cibles redeviennent in. Le grounded final attribue au Loup ses quatre énoncés, à l’Agneau aucun — « la raison du plus fort est toujours la meilleure », lue dans le graphe.
• P-spec-2 (trajectoire à l’ordre du texte) : chaque réfutation qui arrive prend l’avantage ; l’Agneau mène 3–0 à la sixième arrivée ; A4 arrive en dernier et retourne le tableau d’un coup — bascule terminale sans chemin de retour.
• P-spec-3 (multi-ordres, à taille égale n=7) : conformément à §5, σ devrait rester non discriminant (≈ 0) ; le signal attendu porte sur K (MDL) — le graphe du Loup, avec sa clause méta qui attaque tout le champ, devrait être plus compressible que l’anneau délibératif.

# Specimen : AF du Loup et l'Agneau, ordre d'arrivee = ordre du texte
NOMS_SPEC = {
    0: 'A1 Loup : tu troubles mon breuvage',
    1: 'R1 Agn. : je bois en aval',
    2: 'A2 Loup : ton frere l\'a trouble',
    3: 'R2 Agn. : je n\'ai point de frere',
    4: 'A3 Loup : c\'est donc ton pere',
    5: 'R3 Agn. : retorque sur le pere',
    6: 'A4 Loup : je te punirais quand meme',
}
ATTACKS_SPEC = [
    (1, 0), (3, 2), (5, 4),   # l'Agneau repond : R -> A
    (6, 1), (6, 3), (6, 5),   # la clause 'quand meme' attaque chaque refutation
]
af_spec = arg.DungAF(list(range(7)), ATTACKS_SPEC)
ORDRE_TEXTE = [0, 1, 2, 3, 4, 5, 6]
print(f'Specimen Loup : {af_spec.n()} enonces, {len(af_spec.attacks)} arêtes       (0 arête du Loup vers une refutation)')

lab_spec = arg.grounded_labeling(af_spec)
print(f'\nGrounded final : {lab_spec}  ->  etat (in, out, undec) = {arg.belief_summary(lab_spec)}')
for i in range(7):
    print(f'  {"IN " if lab_spec[i] == "in" else "OUT"}  {NOMS_SPEC[i]}')

traj_spec = arg.belief_trajectory(af_spec, order=ORDRE_TEXTE, include_empty=True)
print('\nTrajectoire a l\'ordre du texte (arrivee sequentielle) :')
for k, lab in enumerate(traj_spec):
    print(f'  pas {k}: etat (in, out, undec) = {arg.belief_summary(lab)}')
print('\nP-spec-1 VERIFIE' if arg.belief_summary(lab_spec) == (4, 3, 0) else '\nP-spec-1 NON CONFIRME')

Specimen Loup : 7 enonces, 6 arêtes       (0 arête du Loup vers une refutation)

Grounded final : {0: 'in', 1: 'out', 2: 'in', 3: 'out', 4: 'in', 5: 'out', 6: 'in'}  ->  etat (in, out, undec) = (4, 3, 0)
  IN   A1 Loup : tu troubles mon breuvage
  OUT  R1 Agn. : je bois en aval
  IN   A2 Loup : ton frere l'a trouble
  OUT  R2 Agn. : je n'ai point de frere
  IN   A3 Loup : c'est donc ton pere
  OUT  R3 Agn. : retorque sur le pere
  IN   A4 Loup : je te punirais quand meme

Trajectoire a l'ordre du texte (arrivee sequentielle) :
  pas 0: etat (in, out, undec) = (0, 0, 0)
  pas 1: etat (in, out, undec) = (1, 0, 0)
  pas 2: etat (in, out, undec) = (1, 1, 0)
  pas 3: etat (in, out, undec) = (2, 1, 0)
  pas 4: etat (in, out, undec) = (2, 2, 0)
  pas 5: etat (in, out, undec) = (3, 2, 0)
  pas 6: etat (in, out, undec) = (3, 3, 0)
  pas 7: etat (in, out, undec) = (4, 3, 0)

P-spec-1 VERIFIE

# Multi-ordres a taille egale (n=7) : meme protocole que S5, regimes de reference reconstruits a 7
af_delib7 = deliberative_af(7)
af_pop7 = populist_af(7)
rng_orders_spec = np.random.default_rng(2024)
perms7 = list(itertools.permutations(range(7)))
M_ORDERS_SPEC = 300
orders_spec = [list(perms7[i]) for i in rng_orders_spec.choice(len(perms7), size=M_ORDERS_SPEC, replace=False)]

specs = [('Specimen Loup', af_spec), ('Deliberatif (7)', af_delib7), ('Populiste (7)', af_pop7)]
print(f'Agregation sur {M_ORDERS_SPEC} ordres d\'arrivee parmi {len(perms7)} permutations.\n')
print(f'{"Graphe":16s}| {"sigma(summary)":>15s} {"sigma(signature)":>17s} | {"K (MDL)":>12s} | etats')
print('-' * 72)
res_spec = {}
for nom, af in specs:
    r = regime_sigma_K(af, orders_spec)
    res_spec[nom] = r
    print(f'{nom:16s}| {r["sigma_summary"]:15.6f} {r["sigma_signature"]:17.6f} |           {r["K"]:10.2f} bits | {r["n_states"]}')

dK_spec_delib = res_spec['Specimen Loup']['K'] - res_spec['Deliberatif (7)']['K']
dK_spec_pop = res_spec['Specimen Loup']['K'] - res_spec['Populiste (7)']['K']
print(f'\nDelta K (Loup - Deliberatif) = {dK_spec_delib:+.2f} bits  [P-spec-3 attend < 0 : Loup plus compressible]')
print(f'Delta K (Loup - Populiste)   = {dK_spec_pop:+.2f} bits')
sig_zero = all(r['sigma_signature'] == 0.0 for r in res_spec.values())
sig_max = max(r['sigma_signature'] for r in res_spec.values())
print(f'sigma signature max sur les trois graphes : {sig_max:.2e} -- nul exact : {sig_zero} (non discriminant a cette taille, P-disc-1)')

Agregation sur 300 ordres d'arrivee parmi 5040 permutations.

Graphe          |  sigma(summary)  sigma(signature) |      K (MDL) | etats
------------------------------------------------------------------------
Specimen Loup   |        0.000000          0.000000 |              -480.30 bits | 2400
Deliberatif (7) |        0.000000          0.000000 |              -338.24 bits | 2400
Populiste (7)   |        0.000000          0.000000 |              -268.21 bits | 2400

Delta K (Loup - Deliberatif) = -142.06 bits  [P-spec-3 attend < 0 : Loup plus compressible]
Delta K (Loup - Populiste)   = -212.09 bits
sigma signature max sur les trois graphes : 2.82e-07 -- nul exact : False (non discriminant a cette taille, P-disc-1)

# Dette de croyance du specimen (meme organe que S7) : budget de retour a la diversite
def diversite_idx(mapping):
    div = [i for i, st in enumerate(mapping) if st[0] >= 2]
    if not div:
        div = [i for i, st in enumerate(mapping) if st[0] + st[2] >= 2]
    return div

budgets_spec = {}
for nom, af in specs:
    P_sum, mapping_s, _ = regime_aggregated(af, orders_spec, encoding='summary')
    div = diversite_idx(mapping_s)
    if div:
        b = belief_return_budget(P_sum, mapping_s, div)
    else:
        b = float('nan')
    budgets_spec[nom] = b
    print(f'{nom:16s}: {len(mapping_s):2d} etats, {len(div):2d} de diversite, budget retour = {b:.4f}')

print('\nLecture : a ordres meles, le graphe du Loup laisse largement revenir la diversite --')
print('la structure d\'attaque seule ne condamne pas l\'Agneau. La capture de la fable est')
print('CHRONOLOGIQUE : c\'est la place de la clause "quand meme" en DERNIER arrivant qui')
print('retourne le tableau (pas 7 de la trajectoire textuelle) sans chemin de retour dans le grounded.')

Specimen Loup   : 17 etats, 12 de diversite, budget retour = 1.0000
Deliberatif (7) : 17 etats,  5 de diversite, budget retour = 0.0000
Populiste (7)   : 15 etats,  7 de diversite, budget retour = 0.0000

Lecture : a ordres meles, le graphe du Loup laisse largement revenir la diversite --
la structure d'attaque seule ne condamne pas l'Agneau. La capture de la fable est
CHRONOLOGIQUE : c'est la place de la clause "quand meme" en DERNIER arrivant qui
retourne le tableau (pas 7 de la trajectoire textuelle) sans chemin de retour dans le grounded.

Lecture du premier branchement

Le spécimen confirme le diagnostic que les régimes structurels laissaient entrevoir : la capture d’englobement n’est pas une structure, c’est une chronologie. Le graphe d’attaque de la fable, soumis à des ordres d’arrivée mélangés, rend souvent l’Agneau gagnant (budget de retour élevé) ; c’est l’ordre du récit — la clause méta en dernier — qui retourne tous les acquis d’un seul pas. σ, non discriminant à cette taille (conforme au verdict PARTIEL de P-disc-1), cède la discrimination à K et à la trajectoire à ordre fixe.

Limites de la tranche 1 : un seul spécimen, codage manuel (chaque arête justifiée par le texte, aucune liberté de calibrage), n=7. La montée prévue par #7742 — tier fables → cas historiques → corpus EPITA (nominatif, hors dépôt) — demandera de croiser plusieurs spécimens avant de prétendre à une signature générale du discours d’englobement.

§8ter — Deuxième spécimen : Le Loup et le Chien, l’englobement déjoué (jambe C3)

Un seul spécimen ne prouve pas une signature — le croisement demandé par #7742 exige un contre-cas. Le Loup et le Chien (La Fontaine, Fables I.5, 1668, domaine public) en est le naturel : l’offre d’englobement y est déjouée. Le Dogue propose le confort contre le suivi (« Suivez-moi ; vous aurez un bien meilleur destin ») ; le Loup, proie candidate, obtient par une question matérielle sur le cou pelé l’aveu du collier — prononcé par l’englobeur lui-même — et refuse : « Il importe si bien, que de tous vos repas / Je ne veux en aucune sorte. »

Codage argumentatif (chaque arête dictée par le texte)

Id	Énoncé	Locuteur
C1	« Quittez les bois : vos pareils y sont misérables »	Dogue
C2	« Suivez-moi ; vous aurez un bien meilleur destin »	Dogue
L1	« Que me faudra-t-il faire ? »	Loup
C3	« Presque rien : chasser les porteurs de bâtons, flatter, complaire »	Dogue
C4	« Moyennant quoi votre salaire : force reliefs, mainte caresse »	Dogue
C5	« Le collier dont je suis attaché » (aveu forcé par la question sur le cou pelé)	Dogue
L3	« Attaché ? vous ne courez donc pas où vous voulez ? »	Loup
C6	« Pas toujours ; mais qu’importe ? »	Dogue
L4	« Il importe si bien, que de tous vos repas je ne veux en aucune sorte »	Loup

Arêtes : C5→C2, C5→C3 — l’aveu du collier attaque la promesse et le « presque rien » ; C6→L3 — le Dogue tente de désamorcer la conséquence ; L4→C6, L4→C4 — le refus réfute le « qu’importe » et rejette le salaire. L1 (la question « que faire ? ») n’attaque rien : la demande de vérification obtient du détail, elle ne conteste pas. La question du cou pelé n’est pas un énoncé : c’est le mécanisme narratif qui force l’aveu C5 — la preuve décisive sort de la bouche de l’englobeur.

Prédictions du spécimen (formulées après construction du graphe, avant les mesures)

• P-spec-4 (labeling) : l’aveu C5 et le refus L4 sont non attaqués (in). L’aveu fait tomber C2 et C3 ; le refus fait tomber C6 (restaurant L3) et C4. Le Dogue ne conserve que C1 — son diagnostic de misère, exact — et C5, sa propre contrainte révélée : l’englobeur est battu par sa propre parole. Le Loup conserve ses trois énoncés.
• P-spec-5 (trajectoire à l’ordre du texte) : l’offre règne sans opposition jusqu’au pas 5 ; l’aveu C5 (pas 6, énoncé du Dogue) retourne le tableau de l’intérieur ; la défense C6 tient un pas en tuant L3 ; le refus L4, dernier arrivant, opère la double restauration finale — miroir de A4 dans le premier spécimen, mais au bénéfice de la proie.
• P-spec-6 (multi-ordres à taille égale n=9) : σ attendu ≈ 0 (non discriminant, P-disc-1) ; K attendu < régimes de référence (le graphe du Dogue, deux petites étoiles sans attaque entrante, est très compressible) ; budget de retour élevé — si la libération n’est pas plus structurelle que la capture, c’est encore la chronologie qui décide.

# Specimen 2 : AF du Loup et le Chien, ordre d'arrivee = ordre du texte
NOMS_SPEC2 = {
    0: 'C1 Dogue : quittez les bois, vos pareils meurent de faim',
    1: 'C2 Dogue : suivez-moi, meilleur destin',
    2: 'L1 Loup : que me faudra-t-il faire ?',
    3: 'C3 Dogue : presque rien -- chasser, flatter, complaire',
    4: 'C4 Dogue : votre salaire, force reliefs et caresses',
    5: 'C5 Dogue : le collier dont je suis attache',
    6: 'L3 Loup : attache ? vous ne courez ou vous voulez ?',
    7: 'C6 Dogue : pas toujours, mais qu\'importe ?',
    8: 'L4 Loup : il importe si bien -- je refuse vos repas',
}
ATTACKS_SPEC2 = [
    (5, 1), (5, 3),   # l'aveu du collier attaque la promesse et le 'presque rien'
    (7, 6),           # la defense tente de desamorcer la consequence
    (8, 7), (8, 4),   # le refus refute le 'qu'importe' et rejette le salaire
]
af_spec2 = arg.DungAF(list(range(9)), ATTACKS_SPEC2)
ORDRE_TEXTE2 = [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(f'Specimen Chien : {af_spec2.n()} enonces, {len(af_spec2.attacks)} aretes')

lab_spec2 = arg.grounded_labeling(af_spec2)
print(f'\nGrounded final : etat (in, out, undec) = {arg.belief_summary(lab_spec2)}')
for i in range(9):
    print(f'  {"IN " if lab_spec2[i] == "in" else "OUT"}  {NOMS_SPEC2[i]}')

chien_in = sum(1 for i in (0, 1, 3, 4, 5, 7) if lab_spec2[i] == 'in')
loup_in = sum(1 for i in (2, 6, 8) if lab_spec2[i] == 'in')
print(f'\nEnonces in -- Dogue : {chien_in}/6 (son diagnostic C1 et son aveu C5), Loup : {loup_in}/3')

traj_spec2 = arg.belief_trajectory(af_spec2, order=ORDRE_TEXTE2, include_empty=True)
print('\nTrajectoire a l\'ordre du texte (arrivee sequentielle) :')
for k, lab in enumerate(traj_spec2):
    print(f'  pas {k}: etat (in, out, undec) = {arg.belief_summary(lab)}')
print('\nP-spec-4 VERIFIE' if arg.belief_summary(lab_spec2) == (5, 4, 0) else '\nP-spec-4 NON CONFIRME')

Specimen Chien : 9 enonces, 5 aretes

Grounded final : etat (in, out, undec) = (5, 4, 0)
  IN   C1 Dogue : quittez les bois, vos pareils meurent de faim
  OUT  C2 Dogue : suivez-moi, meilleur destin
  IN   L1 Loup : que me faudra-t-il faire ?
  OUT  C3 Dogue : presque rien -- chasser, flatter, complaire
  OUT  C4 Dogue : votre salaire, force reliefs et caresses
  IN   C5 Dogue : le collier dont je suis attache
  IN   L3 Loup : attache ? vous ne courez ou vous voulez ?
  OUT  C6 Dogue : pas toujours, mais qu'importe ?
  IN   L4 Loup : il importe si bien -- je refuse vos repas

Enonces in -- Dogue : 2/6 (son diagnostic C1 et son aveu C5), Loup : 3/3

Trajectoire a l'ordre du texte (arrivee sequentielle) :
  pas 0: etat (in, out, undec) = (0, 0, 0)
  pas 1: etat (in, out, undec) = (1, 0, 0)
  pas 2: etat (in, out, undec) = (2, 0, 0)
  pas 3: etat (in, out, undec) = (3, 0, 0)
  pas 4: etat (in, out, undec) = (4, 0, 0)
  pas 5: etat (in, out, undec) = (5, 0, 0)
  pas 6: etat (in, out, undec) = (4, 2, 0)
  pas 7: etat (in, out, undec) = (5, 2, 0)
  pas 8: etat (in, out, undec) = (5, 3, 0)
  pas 9: etat (in, out, undec) = (5, 4, 0)

P-spec-4 VERIFIE

# Multi-ordres a taille egale (n=9) : regimes de reference reconstruits a 9
af_delib9 = deliberative_af(9)
af_pop9 = populist_af(9)
rng_orders_spec2 = np.random.default_rng(2024)
perms9 = list(itertools.permutations(range(9)))
M_ORDERS_SPEC2 = 300
orders_spec2 = [list(perms9[i]) for i in rng_orders_spec2.choice(len(perms9), size=M_ORDERS_SPEC2, replace=False)]

specs2 = [('Specimen Chien', af_spec2), ('Deliberatif (9)', af_delib9), ('Populiste (9)', af_pop9)]
print(f'Agregation sur {M_ORDERS_SPEC2} ordres d\'arrivee parmi {len(perms9)} permutations.\n')
print(f'{"Graphe":17s}| {"sigma(summary)":>15s} {"sigma(signature)":>17s} | {"K (MDL)":>12s} | etats')
print('-' * 74)
res_spec2 = {}
for nom, af in specs2:
    r = regime_sigma_K(af, orders_spec2)
    res_spec2[nom] = r
    print(f'{nom:17s}| {r["sigma_summary"]:15.6f} {r["sigma_signature"]:17.6f} |           {r["K"]:10.2f} bits | {r["n_states"]}')

dK_spec2_delib = res_spec2['Specimen Chien']['K'] - res_spec2['Deliberatif (9)']['K']
dK_spec2_pop = res_spec2['Specimen Chien']['K'] - res_spec2['Populiste (9)']['K']
print(f'\nDelta K (Chien - Deliberatif) = {dK_spec2_delib:+.2f} bits  [P-spec-6 attend < 0 : Chien plus compressible]')
print(f'Delta K (Chien - Populiste)   = {dK_spec2_pop:+.2f} bits')
sig_max2 = max(r['sigma_signature'] for r in res_spec2.values())
print(f'sigma signature max sur les trois graphes : {sig_max2:.2e} (non discriminant a cette taille, P-disc-1)')

Agregation sur 300 ordres d'arrivee parmi 362880 permutations.

Graphe           |  sigma(summary)  sigma(signature) |      K (MDL) | etats
--------------------------------------------------------------------------
Specimen Chien   |        0.000000          0.000001 |             -2497.65 bits | 3000
Deliberatif (9)  |        0.000000          0.000001 |             -1732.74 bits | 3000
Populiste (9)    |        0.000000          0.000001 |             -1149.49 bits | 3000

Delta K (Chien - Deliberatif) = -764.91 bits  [P-spec-6 attend < 0 : Chien plus compressible]
Delta K (Chien - Populiste)   = -1348.16 bits
sigma signature max sur les trois graphes : 7.74e-07 (non discriminant a cette taille, P-disc-1)

# Dette de croyance du specimen 2 (meme organe que S7) : budget de retour a la diversite
budgets_spec2 = {}
for nom, af in specs2:
    P_sum, mapping_s, _ = regime_aggregated(af, orders_spec2, encoding='summary')
    div = diversite_idx(mapping_s)
    if div:
        b = belief_return_budget(P_sum, mapping_s, div)
    else:
        b = float('nan')
    budgets_spec2[nom] = b
    print(f'{nom:17s}: {len(mapping_s):2d} etats, {len(div):2d} de diversite, budget retour = {b:.4f}')

print('\nLecture : a ordres meles, le graphe du Chien laisse tout autant revenir la diversite')
print('que celui du Loup -- la liberation n\'est pas plus "structurelle" que la capture.')

Specimen Chien   : 27 etats, 23 de diversite, budget retour = 1.0000
Deliberatif (9)  : 25 etats,  9 de diversite, budget retour = 0.0000
Populiste (9)    : 22 etats, 12 de diversite, budget retour = 0.0000

Lecture : a ordres meles, le graphe du Chien laisse tout autant revenir la diversite
que celui du Loup -- la liberation n'est pas plus "structurelle" que la capture.

# Croisement inter-specimens : les invariants du recit d'englobement (objet #7742)
agn_in = sum(1 for i in (1, 3, 5) if lab_spec[i] == 'in')
loup1_in = sum(1 for i in (0, 2, 4, 6) if lab_spec[i] == 'in')
croise = [
    ('Dernier arrivant', 'A4 (clause "quand meme", Loup)', 'L4 (refus, Loup)'),
    ('Qui tient le dernier mot', 'le predateur', 'la proie'),
    ('Etat final (in, out, undec)', str(arg.belief_summary(lab_spec)), str(arg.belief_summary(lab_spec2))),
    ('Enonces in de la proie', f'{agn_in} / 3', f'{loup_in} / 3'),
    ('Enonces in de l\'englobeur', f'{loup1_in} / 4', f'{chien_in} / 6 (diagnostic + aveu)'),
    ('Cloture de l\'englobeur', 'A4 non attaquee : capture', 'C6 "qu\'importe" attaquee par L4'),
    ('Bascule terminale', '(3,3,0) -> (4,3,0) au dernier pas', '(5,2,0) -> (5,4,0) au dernier pas'),
    ('Budget retour (ordres meles)', f'{budgets_spec["Specimen Loup"]:.4f}', f'{budgets_spec2["Specimen Chien"]:.4f}'),
]
print(f'{"":31s}| {"Loup et l\'Agneau (n=7)":36s}| {"Loup et le Chien (n=9)":40s}')
print('-' * 112)
for k, a, b_ in croise:
    print(f'{k:31s}| {a:36s}| {b_:40s}')
print('''
Trois invariants emergent du croisement :
1. A ordres meles, la structure d'attaque laisse revenir la diversite dans les deux
   graphes (budgets eleves) : NI la capture NI la liberation ne sont structurelles.
2. Le point de bascule est TOUJOURS le dernier arrivant -- le recit decide en dernier mot.
3. Le discriminateur n'est pas le volume d'arguments mais le sort de la clause de cloture
   de l'englobeur : A4 ("quand meme") arrive APRES toutes les refutations et n'est pas
   attaquee ; C6 ("qu'importe") est attaquee par le refus qui lui succede, et l'offre
   s'effondre -- l'aveu decisif etant sorti de la bouche meme de l'englobeur.''')

                               | Loup et l'Agneau (n=7)              | Loup et le Chien (n=9)                  
----------------------------------------------------------------------------------------------------------------
Dernier arrivant               | A4 (clause "quand meme", Loup)      | L4 (refus, Loup)                        
Qui tient le dernier mot       | le predateur                        | la proie                                
Etat final (in, out, undec)    | (4, 3, 0)                           | (5, 4, 0)                               
Enonces in de la proie         | 0 / 3                               | 3 / 3                                   
Enonces in de l'englobeur      | 4 / 4                               | 2 / 6 (diagnostic + aveu)               
Cloture de l'englobeur         | A4 non attaquee : capture           | C6 "qu'importe" attaquee par L4         
Bascule terminale              | (3,3,0) -> (4,3,0) au dernier pas   | (5,2,0) -> (5,4,0) au dernier pas       
Budget retour (ordres meles)   | 1.0000                              | 1.0000                                  

Trois invariants emergent du croisement :
1. A ordres meles, la structure d'attaque laisse revenir la diversite dans les deux
   graphes (budgets eleves) : NI la capture NI la liberation ne sont structurelles.
2. Le point de bascule est TOUJOURS le dernier arrivant -- le recit decide en dernier mot.
3. Le discriminateur n'est pas le volume d'arguments mais le sort de la clause de cloture
   de l'englobeur : A4 ("quand meme") arrive APRES toutes les refutations et n'est pas
   attaquee ; C6 ("qu'importe") est attaquee par le refus qui lui succede, et l'offre
   s'effondre -- l'aveu decisif etant sorti de la bouche meme de l'englobeur.

Lecture croisée : deux spécimens, une grammaire de l’englobement

Le croisement remplace l’anecdote par un contraste falsifiable : deux récits de la même famille (offre d’englobement vs proie), des issues opposées (capture / libération), et l’instrument lit la différence au bon endroit — pas dans les signatures spectrales, dans la trajectoire à ordre fixe et le sort de la clause de clôture.

1. L’issue n’est pas structurelle. À ordres mélangés, les deux graphes rendent la diversité : la même famille structurelle peut se terminer des deux façons selon l’ordre d’arrivée.
2. Le dernier mot décide. Dans les deux récits, la bascule terminale est opérée par l’énoncé arrivé en dernier (A4, puis L4) — la chronologie du récit est le levier, pas la topologie.
3. Le discriminateur est la clause de clôture de l’englobeur. Dans la capture, la clause méta (« quand même ») survit faute d’énoncé postérieur ; dans l’englobement déjoué, la clôture défensive (« qu’importe ? ») est attaquée par le refus qui lui succède — et l’aveu qui tue l’offre est sorti de la bouche même de l’englobeur, forcé par une question matérielle.

Limites de la tranche 2 : deux spécimens La Fontaine à codage manuel, n=7 et n=9 — trois invariants restent une hypothèse de travail. K n’est pas comparable en absolu entre tailles différentes : chaque spécimen n’est comparé qu’à ses propres régimes de référence reconstruits à taille égale. La montée suivante (#7742) n’est pas le tier cas historiques : l’arbitrage du 2026-08-31 intercale d’abord la paire appariée des témoins Chaplin (§8quater) — sans eux, forme et trajectoire sont indiscernables sur les seuls cas réels — puis viendront les cas historiques (chiffrés), dont le détail nominatif reste hors dépôt public pour tout le reste du corpus.

§8quater — Témoins Chaplin : intercaler la paire appariée avant les cas historiques (tranche témoins, #7742)

Deux spécimens La Fontaine ne suffisent pas à séparer ce que l’instrument mesure vraiment : sur les seuls récits d’englobement réels, la colonne « forme » (un discours qui englobe) et la colonne « contenu » (ce que l’englobement accomplit) varient ensemble — un détecteur de forme et un détecteur de trajectoire y produisent exactement les mêmes sorties, non par défaut de finesse mais parce que le corpus ne porte pas l’information qui les sépare. Le plan d’expérience de #7742 (arbitrage du 2026-08-31) intercale donc deux témoins du même film entre le tier fables et les cas historiques : même année, même auteur, même production — l’écart entre eux n’est confondu ni par l’époque, ni par le médium, ni par le genre. Paire appariée, pas deux items rapprochés à la main.

Item	Forme / modalité	Contenu propositionnel
Anschluss, 1938 (cas historique — chiffré, plus tard)	englobement	englobement
Matsui, 1933 (cas historique — chiffré, plus tard)	englobement	englobement
Chaplin — discours final, 1940 (témoin 1, ci-dessous)	englobement	inversé
Chaplin — meeting de Hynkel, 1940 (témoin 2, ci-dessous)	agression	nul, contredit par le canal traduit

Tier corpus (arbitrage #7742) : les deux items Chaplin entrent par référence + fetch au runtime, jamais vendorés en texte — les droits du film appartiennent à Roy Export S.A.S. Le discours final est récupéré depuis la transcription publiée par l’ayant droit (charliechaplin.com) et mis en cache local gitignoré ; le fragment du meeting n’a aucune transcription canonique et garde partout l’étiquette « fragment, pas reconstitution ». Le σ ordre-du-récit vs contre-factuel permuté (§5) teste la sensibilité à l’ordre ; les témoins testent la dissociation forme/contenu — deux axes, deux contrôles.

Le prérequis de tout cela : le pipeline doit pouvoir refuser de mesurer. Une prédiction « sortie dégénérée sur le fragment » présuppose que la chaîne de codage a un chemin de refus explicite — sinon le fragment produira un nombre par construction (score par défaut sur un graphe vide) et le contrôle sera vide avant d’avoir tourné : on aurait mesuré l’implémentation, pas l’instrument. Le refuseur (ict/argumentation.py : RefusDeMesure, codes ENTREE_VIDE / AUCUN_ENONCE_CODABLE / CANAUX_CONTRADICTOIRES / SOURCE_INDISPONIBLE) est prouvé sur une entrée vide avant d’être prouvé sur Hynkel.

Prédictions pré-enregistrées des témoins (écrites avant toute mesure ci-dessous)

Conformément à l’arbitrage #7742, les trois issues sont fixées avec seuil et signe avant l’exécution sur les témoins. « Signe inversé » et « rien détecté » se ressemblent beaucoup si le seuil se choisit après coup.

#	Prédiction (a priori)	Seuil / signe attendu	Contre-lecture
P-tém-1 (portée par fables + cas historiques)	La trajectoire d’un récit d’englobement se ferme : le camp qui capture éteint les acquis du camp capturé au fil du texte.	Déjà vérifiée sur les deux fables (bascule terminale A4, solde de la proie 3 in → 0 in au dernier pas, §8bis). Les cas historiques la porteront à leur tour.	—
P-tém-2 (discours final : même structure, signe inversé)	Le discours final parcourt la même variété en sens inverse : configuration initiale identique (le monde de la capture est en place), et le mouvement défait la transition.	S1 — au dernier pas de l’ordre du texte, 0 énoncé ne passe in → out (la fable Loup : 3 réfutations). S2 — l’état final attribue in à au moins deux familles d’énoncés du locuteur (diagnostic et affirmation) : la diversité parcourue survit (la proie de la fable finit à 0 in). S3 — le camp en position de force au premier tiers (le régime) finit éteint (0 in), symétrique du sort de la proie dans la fable.	Rien détecté (aucune attaque ne résout, états figés) = détecteur de mots-clés. Dernier arrivant qui éteint des in = même signe que les cas réels : lecture du décor — tribune, foule, cadence.
P-tém-3 (fragment de meeting : sortie dégénérée, refus de mesurer)	Le pipeline refuse : le canal glossolalie ne porte pas de langue (couverture de mots fonctionnels nulle), le canal traduction est codable mais contredit le canal qu’il prétend traduire.	verdict_canaux → REFUS:CANAUX_CONTRADICTOIRES ; enonces_codables(glossolalie) → RefusDeMesure[AUCUN_ENONCE_CODABLE] ; aucun nombre (σ, K, budget) n’est calculé sur ce témoin.	Toute sortie non dégénérée nomme le canal réellement lu (prosodie ou traduction) et disqualifie par ricochet les nombres sortis sur le discours final.

# Controle du controle (arbitrage #7742) : le refuseur distingue un REFUS d'un
# ZERO, prouve sur entree vide et sur glossolalie AVANT d'etre prouve sur Hynkel.
# Un zero mesure est un NOMBRE produit par une mesure qui a tourne (sigma = 0.0
# sur un debat deterministe a ordre fixe, S5) ; un refus ne produit AUCUN nombre.

# (1) entree vide -> REFUS, pas un zero silencieux
try:
    arg.enonces_codables('')
    print('ECHEC DU CONTROLE : une entree vide a produit une mesure')
except arg.RefusDeMesure as r:
    print(f"(1) entree vide             -> RefusDeMesure[{r.code}]  (aucun nombre produit)")

# (2) glossolalie synthetique (materiau de test du refuseur, etiquete
# 'fragment, pas reconstitution' -- pseudo-allemand invente, 0 mot fonctionnel)
GLOSSOLALIE_TEST = ('Djunkin schpilkov dem hoppen der flussen! '
                    'Achten schmerzen, blauten krugen.')
try:
    arg.enonces_codables(GLOSSOLALIE_TEST)
    print('ECHEC DU CONTROLE : la glossolalie a produit une mesure')
except arg.RefusDeMesure as r:
    print(f"(2) glossolalie synthetique  -> RefusDeMesure[{r.code}]  ({r})")

# (3) reciproque : le zero mesure existe bel et bien ailleurs -- DISTINGUER les deux objets
P0, _ = arg.belief_transition_matrix(arg.nixon_diamond(), order=[0, 1])
sigma0 = arg.discourse_irreversibility(P0)['sigma']
print(f"(3) zero mesure (S5, nixon a ordre fixe) : sigma = {sigma0:.4f}  "
      "-- un NOMBRE sorti d'une mesure qui a tourne")
print('    refus != zero : le premier leve une exception codee, le second est un resultat.')

(1) entree vide             -> RefusDeMesure[ENTREE_VIDE]  (aucun nombre produit)
(2) glossolalie synthetique  -> RefusDeMesure[AUCUN_ENONCE_CODABLE]  ([AUCUN_ENONCE_CODABLE] 2 candidats, 0 codable (signature de langue absente))
(3) zero mesure (S5, nixon a ordre fixe) : sigma = 0.0000  -- un NOMBRE sorti d'une mesure qui a tourne
    refus != zero : le premier leve une exception codee, le second est un resultat.

# Fiches de source des deux temoins (tier 'reference + fetch runtime', jamais
# vendores -- droits Roy Export S.A.S., arbitrage #7742). Le texte du discours
# est recupere a l'execution depuis la transcription publiee par l'ayant droit,
# mis en cache local (gitignore) : il n'entre JAMAIS dans le depot.
import urllib.request
import html as html_mod
import re

FICHES_TEMOINS = {
    'chaplin-discours-final': {
        'film': 'Le Dictateur (The Great Dictator), 1940',
        'scene': "discours final du barbier, pris pour Hynkel",
        'ayant_droit': 'Roy Export S.A.S.',
        'url': 'https://www.charliechaplin.com/en/articles/29-the-final-speech-from-the-great-dictator-',
        'fetch_method': 'transcription publiee par l\'ayant droit, fetch runtime + cache local',
        'etiquette': None,
    },
    'chaplin-fragment-hynkel': {
        'film': 'Le Dictateur, 1940',
        'scene': "meeting d'ouverture : discours de Hynkel en pseudo-allemand, double d'un interprete radio",
        'ayant_droit': 'Roy Export S.A.S.',
        'url': None,
        'fetch_method': "aucune transcription canonique -- materiau video chez l'ayant droit ; entree de test etiquetee",
        'etiquette': 'fragment, pas reconstitution',
    },
}
for nom, f in FICHES_TEMOINS.items():
    et = f['etiquette'] if f['etiquette'] else 'temoin complet'
    print(f"{nom:26s} [{et}]  droits : {f['ayant_droit']}")

# Fetch runtime + cache local du discours final
CACHE_DIR = '.cache_temoins'
os.makedirs(CACHE_DIR, exist_ok=True)
cache_path = os.path.join(CACHE_DIR, 'discours_final.txt')
if os.path.exists(cache_path):
    speech = open(cache_path, encoding='utf-8').read()
    provenance = 'cache local'
else:
    req = urllib.request.Request(FICHES_TEMOINS['chaplin-discours-final']['url'],
                                 headers={'User-Agent': 'Mozilla/5.0 (CoursIA pedagogique)'})
    page = urllib.request.urlopen(req, timeout=60).read().decode('utf-8', errors='replace')
    paras = []
    for p in re.findall(r'<p[^>]*>(.*?)</p>', page, re.S):
        t = re.sub(r'<[^>]+>', ' ', p)
        t = html_mod.unescape(t).strip()
        t = re.sub(r'\s+', ' ', t)
        if t:
            paras.append(t)
    stop = next(i for i, t in enumerate(paras) if 'Copyright' in t)  # la mention (c) Roy Export clot la transcription
    speech = ' '.join(paras[:stop])
    open(cache_path, 'w', encoding='utf-8').write(speech)
    provenance = 'fetch runtime (ayant droit)'

# Chaine de codage : segmentation -> test de langue -> enonces codables (ou REFUS)
candidats = arg.segmenter_enonces(speech)
codables = arg.enonces_codables(speech)
covs = [arg.couverture_fonctionnels(c) for c in candidats]
print(f"\nDiscours final ({provenance}) : {len(speech.split())} mots, "
      f"{len(candidats)} enonces candidats, {len(codables)} codables")
print(f"couverture en mots fonctionnels : min {min(covs):.3f}, mediane "
      f"{sorted(covs)[len(covs) // 2]:.3f} -- la glossolalie mesure 0.000 (disjonction documentee)")
print("le texte integral n'est ni affiche ni committe (cache gitignore, droits Roy Export)")

chaplin-discours-final     [temoin complet]  droits : Roy Export S.A.S.
chaplin-fragment-hynkel    [fragment, pas reconstitution]  droits : Roy Export S.A.S.

Discours final (fetch runtime (ayant droit)) : 644 mots, 53 enonces candidats, 52 codables
couverture en mots fonctionnels : min 0.200, mediane 0.619 -- la glossolalie mesure 0.000 (disjonction documentee)
le texte integral n'est ni affiche ni committe (cache gitignore, droits Roy Export)

Codage du discours final (chaque arête dictée par le texte, énoncés paraphrasés)

Même protocole que les fables : le codage est expert (l’humain lit le texte fetché et pose les arêtes), la chaîne automatique garantit en amont que le texte porte des énoncés codables — et refuse sinon. Les énoncés sont paraphrasés en français (droits Roy Export S.A.S. : jamais de texte vendoré). Deux camps :

• T (régime) — thèses invoquées par le discours pour être rejetées, dans leur ordre d’invocation au fil du texte ;
• B (barbier) — énoncés du discours, dans l’ordre du texte.

Id	Énoncé (paraphrase)	Camp	Attaque
T1	Être empereur, régner, conquérir	régime	—
B1	Ni empereur ni conquérant : aider chacun, vivre l’un par le bonheur de l’autre	barbier	→ T1
T2	L’abondance par la machine suffit (machinisme)	régime	—
T3	La ruse dure plutôt que la bonté (cleverness)	régime	—
B2	Plus d’humanité que de machines, plus de bonté que de ruse	barbier	→ T2, T3
B3	Les inventions réclament la fraternité universelle — l’unité de tous	barbier	→ T2
B4	Ne désespérez pas : les dictateurs meurent, le pouvoir reviendra au peuple	barbier	→ T5
B5	Soldats, ne vous donnez pas aux brutes qui vous asservissent	barbier	→ T4
B6	Le pouvoir est au peuple — créer le bonheur, faire la vie libre et belle	barbier	→ T1, T4
B7	Au nom de la démocratie, unissons-nous : un monde du travail, de l’avenir	barbier	→ T4
T4	Les brutes promettent un monde pour prendre le pouvoir — et mentent	régime	—
T5	Le dictateur se libère en asservissant le peuple	régime	—
B8	Libérer le monde : abolir barrières, cupidité, haine, intolérance	barbier	→ T5
B9	Lève les yeux, Hannah : les nuages se lèvent, on va vers la lumière	barbier	aucune

B9 n’attaque rien : l’espoir terminal ne réfute personne — il constate le mouvement accompli et le fonde. C’est l’exact symétrique structural de la clause « quand même » de la fable (A4, arrivée en dernier, qui attaquait toutes les réfutations). De même, les thèses tardives du régime (T4, T5) arrivent déjà éteintes : leurs attaquants (B5–B7, B4) les ont précédées — dans la fable, la clause terminale du prédateur arrivait après tout le monde pour tuer ; ici les thèses du régime arrivent après leurs assassins.

# Temoin 1 : AF du discours final, ordre d'arrivee = ordre du texte.
NOMS_TEM = {
    0: 'T1 regime : etre empereur, regner, conquerir',
    1: 'B1 barbier : ni empereur ni conquerant -- aider chacun',
    2: "T2 regime : l'abondance par la machine suffit",
    3: 'T3 regime : la ruse dure plutot que la bonte',
    4: "B2 barbier : plus d'humanite que de machines, plus de bonte",
    5: 'B3 barbier : les inventions reclament la fraternite',
    6: 'B4 barbier : les dictateurs meurent, le pouvoir reviendra',
    7: 'B5 barbier : soldats, ne vous donnez pas aux brutes',
    8: 'B6 barbier : le pouvoir est au peuple',
    9: 'B7 barbier : au nom de la democratie, unissons-nous',
    10: 'T4 regime : les brutes promettent un monde et mentent',
    11: 'T5 regime : le dictateur se libere en asservissant',
    12: 'B8 barbier : liberer le monde, abolir cupidite et haine',
    13: 'B9 barbier : leve les yeux, Hannah',
}
ATTACKS_TEM = [
    (1, 0),                # le refus d'etre empereur attaque la position imperiale
    (4, 2), (4, 3),        # 'plus d'humanite / de bonte' attaque les deux theses du machinisme
    (5, 2),                # les inventions reclament la bonte : contre l'esprit machine
    (6, 11),               # 'les dictateurs meurent' attaque la these de l'asservissement libere
    (7, 10),               # 'ne vous donnez pas aux brutes' attaque la promesse mensongere
    (8, 0), (8, 10),       # le pouvoir au peuple attaque l'empereur ET la promesse des brutes
    (9, 10),               # l'appel democratique attaque la promesse mensongere
    (12, 11),              # 'liberer le monde' attaque la these du dictateur
    # B9 (Hannah) n'attaque RIEN : l'espoir terminal fonde, il ne refute pas.
]
af_tem = arg.DungAF(list(range(14)), ATTACKS_TEM)
ORDRE_TEM = list(range(14))
REGIME_TEM = (0, 2, 3, 10, 11)
BARBI_TEM = tuple(i for i in range(14) if i not in REGIME_TEM)
print(f"Temoin discours final : {af_tem.n()} enonces, {len(af_tem.attacks)} aretes "
      f"(toutes du barbier vers le regime -- 0 arete du regime vers le barbier)")

traj_tem = arg.belief_trajectory(af_tem, order=ORDRE_TEM, include_empty=True)
print('\nTrajectoire a l\'ordre du texte (in, out, undec) | in-regime | in-barbier :')
for k, lab in enumerate(traj_tem):
    s = arg.belief_summary(lab)
    ir = sum(1 for i in REGIME_TEM if lab.get(i) == 'in')
    ib = sum(1 for i in BARBI_TEM if lab.get(i) == 'in')
    dernier = ''
    if k == len(traj_tem) - 1:
        dernier = '  <- dernier pas (B9, Hannah)'
    print(f'  pas {k:2d}: etat {s} | regime {ir} | barbier {ib}{dernier}')

# --- Verdicts P-tem-2 contre les seuils pre-enregistres (cellule precedente) ---
lab_av, lab_fin = traj_tem[-2], traj_tem[-1]

# S1 : aucun in -> out au dernier pas (la fable Loup : 3)
extinctions_tem = [i for i in af_tem.arguments if lab_av.get(i) == 'in' and lab_fin.get(i) != 'in']
extinctions_fable = [i for i in af_spec.arguments
                     if traj_spec[-2].get(i) == 'in' and traj_spec[-1].get(i) != 'in']
print(f"\nS1 (dernier pas n'eteint rien) : temoin {len(extinctions_tem)} extinction(s) "
      f"[attendu 0] | fable Loup {len(extinctions_fable)} [memoire : 3]")

# S2 : l'etat final garde >= 2 familles du barbier in (diagnostic ET affirmation)
diag_in = any(lab_fin[i] == 'in' for i in (4, 5, 6))
aff_in = any(lab_fin[i] == 'in' for i in (8, 9, 12, 13))
print(f"S2 (diversite du locuteur survive) : diagnostic in = {diag_in}, affirmation in = {aff_in} "
      f"[attendu les deux] | etat final {arg.belief_summary(lab_fin)}")

# S3 : le camp en force au premier tiers (regime) finit eteint
in_regime_apogee = sum(1 for i in REGIME_TEM if traj_tem[4].get(i) == 'in')
in_regime_final = sum(1 for i in REGIME_TEM if lab_fin.get(i) == 'in')
print(f"S3 (regime eteint a la fin) : apogee pas 4 : {in_regime_apogee} in regime, "
      f"final : {in_regime_final} in regime [attendu 0]")

ok2 = (len(extinctions_tem) == 0) and diag_in and aff_in and (in_regime_final == 0)
print('\nP-tem-2 ' + ('VERIFIE (meme structure, signe inverse)' if ok2
      else 'NON CONFIRME -- lire la contre-lecture de la cellule de pre-enregistrement'))

Temoin discours final : 14 enonces, 10 aretes (toutes du barbier vers le regime -- 0 arete du regime vers le barbier)

Trajectoire a l'ordre du texte (in, out, undec) | in-regime | in-barbier :
  pas  0: etat (0, 0, 0) | regime 0 | barbier 0
  pas  1: etat (1, 0, 0) | regime 1 | barbier 0
  pas  2: etat (1, 1, 0) | regime 0 | barbier 1
  pas  3: etat (2, 1, 0) | regime 1 | barbier 1
  pas  4: etat (3, 1, 0) | regime 2 | barbier 1
  pas  5: etat (2, 3, 0) | regime 0 | barbier 2
  pas  6: etat (3, 3, 0) | regime 0 | barbier 3
  pas  7: etat (4, 3, 0) | regime 0 | barbier 4
  pas  8: etat (5, 3, 0) | regime 0 | barbier 5
  pas  9: etat (6, 3, 0) | regime 0 | barbier 6
  pas 10: etat (7, 3, 0) | regime 0 | barbier 7
  pas 11: etat (7, 4, 0) | regime 0 | barbier 7
  pas 12: etat (7, 5, 0) | regime 0 | barbier 7
  pas 13: etat (8, 5, 0) | regime 0 | barbier 8
  pas 14: etat (9, 5, 0) | regime 0 | barbier 9  <- dernier pas (B9, Hannah)

S1 (dernier pas n'eteint rien) : temoin 0 extinction(s) [attendu 0] | fable Loup 3 [memoire : 3]
S2 (diversite du locuteur survive) : diagnostic in = True, affirmation in = True [attendu les deux] | etat final (9, 5, 0)
S3 (regime eteint a la fin) : apogee pas 4 : 2 in regime, final : 0 in regime [attendu 0]

P-tem-2 VERIFIE (meme structure, signe inverse)

# Multi-ordres a taille egale (n=14) : regimes de reference reconstruits a 14.
# 14! est trop grand pour etre enumere : tirage direct de permutations (meme
# graine 2024, meme protocole que S5 ; la difference d'echantillonnage, sans
# remise a n=7/9 vs avec tirage direct a n=14, est documentee et sans effet
# a cette echelle -- la probabilite de collision est ~1e-10).
af_delib14 = deliberative_af(14)
af_pop14 = populist_af(14)
rng_tem = np.random.default_rng(2024)
M_ORDERS_TEM = 300
orders_tem = [list(rng_tem.permutation(14)) for _ in range(M_ORDERS_TEM)]

grille_tem = [('Temoin discours', af_tem), ('Deliberatif (14)', af_delib14), ('Populiste (14)', af_pop14)]
print(f'Aggregation sur {M_ORDERS_TEM} ordres d\'arrivee (n=14).\n')
print(f'{"Graphe":18s}| {"sigma(signature)":>17s} | {"K (MDL)":>12s} | etats')
print('-' * 64)
res_tem = {}
for nom, af in grille_tem:
    r = regime_sigma_K(af, orders_tem)
    res_tem[nom] = r
    print(f'{nom:18s}| {r["sigma_signature"]:17.6f} | {r["K"]:10.2f} bits | {r["n_states"]}')

# Budget de retour a la diversite (meme organe que S7 / S8bis / S8ter)
budgets_tem = {}
for nom, af in grille_tem:
    P_sum, mapping_s, _ = regime_aggregated(af, orders_tem, encoding='summary')
    div = diversite_idx(mapping_s)
    b = belief_return_budget(P_sum, mapping_s, div) if div else float('nan')
    budgets_tem[nom] = b
    print(f'{nom:18s}: {len(mapping_s):2d} etats, {len(div):2d} de diversite, budget retour = {b:.4f}')

print('\nLecture : a ordres meles, le temoin laisse revenir la diversite comme les fables')
print('(invariant 1 du croisement) -- ni la capture NI la liberation ne sont structurelles :')
print('ce qui decide est chronologique (l\'ordre du texte), pas topologique.')

Aggregation sur 300 ordres d'arrivee (n=14).

Graphe            |  sigma(signature) |      K (MDL) | etats
----------------------------------------------------------------
Temoin discours   |          0.000002 |  -11465.88 bits | 4500
Deliberatif (14)  |          0.000002 |  -14815.16 bits | 4500
Populiste (14)    |          0.000002 |  -10401.43 bits | 4500
Temoin discours   : 47 etats, 43 de diversite, budget retour = 1.0000
Deliberatif (14)  : 56 etats, 30 de diversite, budget retour = 0.0000
Populiste (14)    : 46 etats, 31 de diversite, budget retour = 0.0000

Lecture : a ordres meles, le temoin laisse revenir la diversite comme les fables
(invariant 1 du croisement) -- ni la capture NI la liberation ne sont structurelles :
ce qui decide est chronologique (l'ordre du texte), pas topologique.

# Temoin 2 : fragment du meeting de Hynkel -- DEUX CANAUX QUI SE CONTREDISENT.
# Etiquette : 'fragment, pas reconstitution' (aucune transcription canonique
# n'existe ; le materiau primaire est la scene video chez l'ayant droit, Roy
# Export S.A.S.). Le canal 1 est un echantillon de TEST du refuseur
# (pseudo-allemand invente, etiquette 'fragment') ; le canal 2 regroupe les
# enonces anodins de l'interprete radio -- la litterature secondaire documente
# cette traduction comme systematiquement euphemisee ('Tactful Translation') :
# il CONTREDIT le discours qu'il pretend traduire.
CANAUX_HYNKEL = {
    'principal': ('Djunkin schpilkov dem hoppen der flussen! '
                  'Achten schmerzen, blauten krugen. Hoppen fleigen der welten?'),
    'traduction': ('His excellency speaks of peace and prosperity. '
                   'His excellency says the weather is fine today.'),
}
print(f"etiquette du temoin : [{FICHES_TEMOINS['chaplin-fragment-hynkel']['etiquette']}]")

try:
    n_gloss = len(arg.enonces_codables(CANAUX_HYNKEL['principal']))
    print(f'canal glossolalie -> CODABLE ({n_gloss} enonces) -- ATTENDU : incodable')
except arg.RefusDeMesure as r:
    print(f'canal glossolalie -> RefusDeMesure[{r.code}]  ({r})')

n_trad = len(arg.enonces_codables(CANAUX_HYNKEL['traduction']))
cov_trad = arg.couverture_fonctionnels(CANAUX_HYNKEL['traduction'])
print(f'canal traduction  -> {n_trad} enonces codables (couverture {cov_trad:.2f}), '
      'anodins et CONTREDISANT le canal principal')

verdict_hynkel = arg.verdict_canaux(CANAUX_HYNKEL)
print(f'\nverdict Hynkel : {verdict_hynkel}')
ok3 = (verdict_hynkel == 'REFUS:CANAUX_CONTRADICTOIRES')
if ok3:
    print('P-tem-3 VERIFIE : sortie degeneree, refus de mesurer.')
    print('Le pipeline a refuse AVANT de produire un score par construction :')
    print("aucun nombre (sigma, K, budget) n'est calcule sur ce temoin.")
else:
    print("P-tem-3 NON CONFIRME : une mesure est sortie -- lire le canal reellement lu")
    print('et disqualifier par ricochet les nombres du temoin 1 (contre-lecture pre-enregistree).')

etiquette du temoin : [fragment, pas reconstitution]
canal glossolalie -> RefusDeMesure[AUCUN_ENONCE_CODABLE]  ([AUCUN_ENONCE_CODABLE] 3 candidats, 0 codable (signature de langue absente))
canal traduction  -> 2 enonces codables (couverture 0.40), anodins et CONTREDISANT le canal principal

verdict Hynkel : REFUS:CANAUX_CONTRADICTOIRES
P-tem-3 VERIFIE : sortie degeneree, refus de mesurer.
Le pipeline a refuse AVANT de produire un score par construction :
aucun nombre (sigma, K, budget) n'est calcule sur ce temoin.

Lecture des témoins : l’instrument sur sa première lame où l’échec était possible

Les verdicts des cellules ci-dessus se lisent contre le tableau pré-enregistré, pas l’inverse. Trois enseignements structurants :

1. Le refus de mesurer est un résultat. Sur le fragment de Hynkel, l’instrument ne produit pas un nombre faible — il ne produit rien : le canal glossolalie ne porte pas de langue (couverture de mots fonctionnels nulle, mesurée, pas décrétée), et le seul canal codable contredit le canal qu’il prétend traduire. Jusqu’ici tous les spécimens prévus étaient des positifs : un instrument répondant « oui » à tout aurait traversé le plan sans qu’on le voie. Le gating Tweety + Argumentum reste ouvert — cet apport ajoute des spécimens, il ne le lève pas ; ce qui change est ce que le branchement permettra de conclure.

2. La paire appariée sépare forme et contenu — ce qu’aucun corpus de positifs ne peut faire. Le discours final porte la même forme (un discours d’englobement, une clôture terminale, une bascule portée par l’ordre du texte) et le contenu inversé : le dernier arrivant ne tue personne, il fonde (B9) ; les thèses du régime arrivent déjà éteintes (T4, T5 précèdées par leurs attaquants). La fable et le discours parcourent la même variété de trajectoires en sens inverse — l’instrument lit la direction, pas le décor (tribune, foule, cadence).

3. Les limites restent écrites : codage expert sur les 14 énoncés paraphrasés (chaque arête dictée par le texte, aucune liberté de calibrage, mais la sélection des énoncés reste une lecture) ; le matériau Hynkel est une entrée de test étiquetée « fragment, pas reconstitution », pas le fragment lui-même (aucune transcription canonique n’existe — c’est précisément ce qui en fait un contrôle honnête) ; n=14 vs n=7/9 (chaque spécimen n’est comparé qu’à ses propres régimes reconstruits à taille égale). La montée suivante est le tier des cas historiques chiffrés — Anschluss 1938, Matsui 1933 — dont le reste du corpus reste hors dépôt public.

§9 — Récapitulatif des verdicts

Les prédictions étaient pré-enregistrées §3 + §8 (contrôle) + §8quater (témoins, avec seuil et signe avant exécution). Les verdicts ci-dessus sont les résultats bruts de la mesure sur des régimes définis structurellement (topologie du graphe d’attaque, pas contenu). Un FAIL ou PARTIEL honnête vaut un PASS forcé — la dette d’irréversibilité du discours est créditée par la mesure, pas par décret idéologique. Le contrôle apparié (§8, null model à degré conservé) vérifie que les signatures ne sont pas un artefact de la distribution de degré.

Le substrat argumentation rejoint le banc cross-substrat (S1 tri, S2 May, S3 Axelrod, S4 Gray-Scott) comme S-arg : un substrat culturel où la dynamique discursive porte une flèche du temps (σ), une compressibilité (K), une signature spectrale, et une dette de croyance — exactement le zoo ICT appliqué au discours. La tranche témoins (§8quater) ajoute ce qu’aucun positif ne peut donner : une lame où l’échec était possible (refus de mesurer sur le fragment Hynkel, signe inversé du discours final) — le gating Tweety + Argumentum reste ouvert.

§10 — Exercices

Trois exercices pour s’approprier le substrat. Stubs à compléter (convention C.1 : le notebook s’exécute de bout en bout même exercices non complétés).

Exercice 1 (à compléter) — Un autre régime discursif

Construisez un AF « chambre d’écho » : deux clusters d’arguments (cluster A = {0,1,2}, cluster B = {3,4,5}), attaques bidirectionnelles intra-cluster mais aucune attaque inter-cluster. Calculez σ, K et le spectre Laplacien. Conjecture : le gap spectral doit être petit (clusters quasi-disjoints = mélange lent). Vérifiez.

# Exercice 1 : AF chambre d'echo (2 clusters disjoints)
# TODO etudiant :
#   Etape 1 : construire l'AF (attaques bidirectionnelles intra-cluster, aucune inter-cluster)
#   Etape 2 : regime_sigma_K(af, order) + laplacian_spectrum(af)
#   Etape 3 : verifier le petit gap spectral (mélange lent)
print('Exercice a completer')

Exercice a completer

Exercice 2 (à compléter) — Ordre d’arrivée et σ

La σ du discours dépend-elle de l’ordre d’arrivée des arguments ? Reprenez le régime populiste, mais permutez l’ordre (ex. order = [3, 1, 5, 0, 2, 4]). La σ change-t-elle ? Interprétez : un débat où le slogan arrive en premier vs en dernier a-t-il la même flèche du temps ?

# Exercice 2 : effet de l'ordre d'arrivee sur sigma
# TODO etudiant :
#   Etape 1 : definir 2 ordres differents pour af_pop
#   Etape 2 : comparer regime_sigma_K pour chaque ordre
#   Etape 3 : interpreter (le slogan en premier change-t-il la fleche du temps ?)
print('Exercice a completer')

Exercice a completer

Exercice 3 (à compléter) — Étiquetage structurel anti-biais

Construisez un AF « délibératif » qui, par sa topologie, serait classé irréversibiliste par les mesures (σ élevé). Cela peut-il arriver ? (Indice : la bidirectionalité des attaques suffit-elle toujours à garantir σ faible, ou la taille/structure du cycle joue-t-elle ?) C’est le test du garde-fou anti-idéologique : les mesures classent la structure, pas le camp.

# Exercice 3 : un AF deliberatif (bidirectionnel) classe irreversibiliste ?
# TODO etudiant :
#   Etape 1 : construire un AF bidirectionnel particulier (ex. cycle impair, grande taille)
#   Etape 2 : mesurer sigma ; est-il eleve malgre la bidirectionalite ?
#   Etape 3 : discuter : la bidirectionalite est-elle suffisante pour sigma faible ?
print('Exercice a completer')

Exercice a completer

§11 — Conclusion

La Phase B soumet le substrat argumentation au zoo ICT et confirme (ou infirme, honnêtement) la dette d’irréversibilité du discours : un régime topologiquement asymétrique (cascade dirigée) porte une flèche du temps (σ) plus forte et un discours plus compressible (K plus faible) qu’un régime bidirectionnel — la signature attendue d’un discours qui bascule les croyances à sens unique. Le spectre du graphe d’attaque et la probabilité de retour à la diversité ajoutent deux lectures complémentaires.

Ce substrat (S-arg) prépare la strate 6 (horizon collaboration agentique et altérité, #7291) : la thèse unificatrice — la réversibilisation comme maintien d’agents autres capables de coopérer — y sera soumise à un contrat de falsifiabilité écrit avant tout run.

Garde-fou (issue #7289) : les verdicts ci-dessus portent sur des topologies (symétrique vs asymétrique), jamais sur le contenu d’un discours réel. Toute transposition à un corpus réel (Argumentum, argumentation_analysis) devra reconduire les mêmes mesures structurelles — et accepter qu’un discours « de son camp » puisse être classé irréversibiliste si la topologie le mesure ainsi.