SC-2b - Bac a sable institutionnel : des acteurs, pas seulement des contrats

<< Setup Web3py | Suivant : Solidity Basics >>

Objectifs d’apprentissage

Lancer une blockchain locale anvil a mnemonic determine : les memes comptes, les memes cles, a chaque lancement
Deriver N acteurs a cle (chemin BIP44) et faire signer chacune de leurs transactions – le deploiement comme les votes
Rejouer une sequence institutionnelle complete (propositions, votes, clotures) et la capturer dans un journal d’evenements pandas
Prouver la rejouabilite : relancer la chaine depuis zero et retrouver un journal bit a bit identique
Observer un echec institutionnel licite : une coalition qui capture l’institution sans violer aucune regle

Prerequis

SC-02-Setup-Web3py-Python complet : Foundry/anvil installes, web3 + py-solc-x disponibles, pattern compile-deploy-call en main
pip install web3 py-solc-x pandas

Pourquoi ce notebook : les contrats sont la, les participants n’y sont pas

SC-2 a etabli le pattern compile -> deploy -> call sur une chaine mono-acteur : un seul compte, deverrouille par anvil, qui joue tous les roles. C’est suffisant pour apprendre le mecanisme – mais une institution, c’est autre chose : plusieurs participants distincts, chacun sa cle, chacun son interet.

Ce notebook construit le bac a sable institutionnel minimal : trois acteurs (Alice, Bob, Carole) qui deliberent par l’intermediaire d’un contrat Deliberation – proposer, voter, cloturer. Chaque geste est signe par la cle de son auteur, chaque evenement est journalise on-chain, et toute la sequence est rejouable : le mnemonic determine d’anvil fait que relancer la chaine depuis zero reproduit exactement la meme histoire.

La question de fond est en fin de notebook : tout s’est passe selon les regles, et pourtant…

import subprocess, time, hashlib
import pandas as pd
from web3 import Web3
from eth_account import Account
import solcx

# Mnemonic determine : les 12 mots BIP39 canoniques de la documentation Foundry.
# C'est un mnemonic de TEST, sans aucune valeur : les cles derivees ne tiennent aucun fonds.
MNEMONIC = "test test test test test test test test test test test junk"
PORT = 8601
CHAIN_ID = 31337
URL = f"http://127.0.0.1:{PORT}"
SOLC_VERSION = "0.8.28"

def compte(i):
    """I-eme compte du mnemonic, chemin BIP44 standard Ethereum."""
    Account.enable_unaudited_hdwallet_features()
    return Account.from_mnemonic(MNEMONIC, account_path=f"m/44'/60'/0'/0/{i}")

ALICE, BOB, CAROLE = compte(0), compte(1), compte(2)
print("Alice :", ALICE.address)
print("Bob   :", BOB.address)
print("Carole:", CAROLE.address)

Alice : 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
Bob   : 0x70997970C51812dc3A010C7d01b50e0d17dc79C8
Carole: 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC

Lecture du resultat

Trois identites distinctes, derivees du meme mnemonic par le chemin BIP44 m/44'/60'/0'/0/i – l’index i fait office de “numero d’acteur”. Deux proprietes importantes pour la suite :

Stabilite : le meme mnemonic derive toujours les memes adresses. C’est ce qui rendra la sequence rejouable en fin de notebook.
Separation des roles : Alice, Bob et Carole n’ont pas de lien technique entre eux – pas de compte “admin” qui peut agir a la place d’un autre. Chacun ne signe qu’avec sa propre cle.

Account.enable_unaudited_hdwallet_features() active la derivation HD dans eth-account : c’est une fonctionnalite marquee “non auditee” pour la production, parfaitement sure pour un bac a sable pedagogique.

def lancer_anvil():
    """(Re)demarre anvil sur PORT avec le MNEMONIC determine. Renvoie la connexion web3."""
    subprocess.run(['wsl', '-d', 'Ubuntu', '--', 'sh', '-c',
                    f'pkill -f "anvil --port {PORT}" 2>/dev/null; sleep 1; true'],
                   capture_output=True)
    subprocess.Popen(['wsl', '-d', 'Ubuntu', '--', 'sh', '-c',
                      f'~/.foundry/bin/anvil --port {PORT} --chain-id {CHAIN_ID} -m "{MNEMONIC}" '
                      '> /tmp/anvil_sandbox.log 2>&1'],
                     stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    for _ in range(40):
        time.sleep(0.5)
        try:
            w3 = Web3(Web3.HTTPProvider(URL))
            if w3.is_connected():
                return w3
        except Exception:
            pass
    raise RuntimeError("anvil n'a pas demarre (verifier SC-1 : foundryup dans WSL)")

def stopper_anvil():
    subprocess.run(['wsl', '-d', 'Ubuntu', '--', 'sh', '-c',
                    f'pkill -f "anvil --port {PORT}" 2>/dev/null; true'], capture_output=True)

w3 = lancer_anvil()
print("chaine connectee -- bloc courant :", w3.eth.block_number)
print("comptes anvil (3 premiers) :", [a[:10] + "..." for a in w3.eth.accounts[:3]])

chaine connectee -- bloc courant : 0
comptes anvil (3 premiers) : ['0xf39Fd6e5...', '0x70997970...', '0x3C44CdDd...']

Lecture du resultat

L’appel lancer_anvil() commence par tuer toute instance preexistante sur le port (pkill), puis relance anvil avec deux drapeaux decisifs :

-m "{MNEMONIC}" : force le mnemonic determine. Sans lui, anvil en genere un nouveau a chaque lancement – adieu la rejouabilite.
--chain-id {CHAIN_ID} : 31337, l’identifiant de chaine local conventionnel, qui protege les transactions signees contre toute relecture sur une autre chaine.

Les comptes affiches par la chaine doivent commencer par les memes prefixes que nos trois acteurs – verifions-le formellement.

# anvil derive ses comptes du meme mnemonic, avec le meme chemin BIP44 :
# nos cles Python et les comptes de la chaine sont donc les memes identites.
for acteur, attendu in zip((ALICE, BOB, CAROLE), w3.eth.accounts[:3]):
    assert acteur.address == attendu, (acteur.address, attendu)
print("verifie : Alice, Bob et Carole controlent les comptes 0, 1, 2 de la chaine")

verifie : Alice, Bob et Carole controlent les comptes 0, 1, 2 de la chaine

Le contrat `Deliberation`

L’institution que nous allons simuler tient en une regle simple : une proposition est soumise par un acteur, votee par les autres (une voix par acteur, pour ou contre), puis cloturee apres un delai – adoptee si elle atteint le quorum fixe au deploiement. Le contrat ci-dessous est volontairement minimal : tout ce qui n’est pas la regle est laisse de cote.

SOL = """
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

contract Deliberation {
    enum Etat { Ouverte, Adoptee, Rejetee }

    struct Proposition {
        address auteur;      // qui a soumis
        string intitule;     // quoi
        uint256 clotureeAu;  // bloc apres lequel on peut cloturer
        uint256 pour;
        uint256 contre;
        Etat etat;
    }

    uint256 public immutable quorum;
    Proposition[] public propositions;
    mapping(uint256 => mapping(address => int8)) public votes;  // anti-double-vote

    event PropositionSoumise(uint256 indexed id, address indexed auteur, string intitule);
    event VoteEmis(uint256 indexed id, address indexed electeur, bool pour);
    event PropositionCloturee(uint256 indexed id, Etat etat, uint256 pour, uint256 contre);

    constructor(uint256 _quorum) { quorum = _quorum; }

    function soumettre(string calldata intitule) external returns (uint256) {
        propositions.push(Proposition(msg.sender, intitule, block.number + 12, 0, 0, Etat.Ouverte));
        uint256 id = propositions.length - 1;
        emit PropositionSoumise(id, msg.sender, intitule);
        return id;
    }

    function voter(uint256 id, bool pour) external {
        Proposition storage p = propositions[id];
        require(p.etat == Etat.Ouverte, "cloturee");
        require(votes[id][msg.sender] == 0, "deja-vote");
        votes[id][msg.sender] = pour ? int8(1) : int8(-1);
        if (pour) p.pour += 1; else p.contre += 1;
        emit VoteEmis(id, msg.sender, pour);
    }

    function cloturer(uint256 id) external {
        Proposition storage p = propositions[id];
        require(p.etat == Etat.Ouverte, "cloturee");
        require(block.number > p.clotureeAu, "trop-tot");
        p.etat = (p.pour >= quorum) ? Etat.Adoptee : Etat.Rejetee;
        emit PropositionCloturee(id, p.etat, p.pour, p.contre);
    }
}
"""

if SOLC_VERSION not in [str(v) for v in solcx.get_installed_solc_versions()]:
    solcx.install_solc(SOLC_VERSION)

sortie = solcx.compile_standard(
    {'language': 'Solidity', 'sources': {'D.sol': {'content': SOL}},
     'settings': {'outputSelection': {'*': {'*': ['abi', 'evm.bytecode.object']}}}},
    solc_version=SOLC_VERSION)
ctr = sortie['contracts']['D.sol']['Deliberation']
ABI, BYTECODE = ctr['abi'], '0x' + ctr['evm']['bytecode']['object']
print("compilation OK --", len([e for e in ABI if e['type'] == 'function']), "fonctions,",
      len([e for e in ABI if e['type'] == 'event']), "evenements")

compilation OK -- 6 fonctions, 3 evenements

Lecture du contrat

Quatre details structurels portent toute la semantique institutionnelle :

quorum est immutable : fixe a la construction, il ne peut plus bouger. L’institution ne peut pas reecrire son propre seuil d’adoption en cours de route.
clotureeAu = block.number + 12 : le delai de deliberation se mesure en blocs. Le temps institutionnel, c’est le temps de la chaine – pour faire passer une cloture, il faut litteralement que la chaine avance.
votes[id][msg.sender] : le mapping anti-double-vote. Un acteur qui re-vote se heurte a require(..., "deja-vote") – la regle est enforcee par le contrat, pas par la bonne volonte des participants.
Les trois event : PropositionSoumise, VoteEmis, PropositionCloturee. Ils constituent le journal que nous extrairons plus loin : chaque geste institutionnel laisse une trace queryable, independante du stockage du contrat.

def envoyer(w3, acteur, tx):
    """Signe la transaction avec la cle de l'acteur puis l'envoie."""
    tx.setdefault('nonce', w3.eth.get_transaction_count(acteur.address))
    tx.setdefault('gas', 400_000)
    if 'maxFeePerGas' not in tx and 'gasPrice' not in tx:
        tx['gasPrice'] = w3.eth.gas_price
    tx.setdefault('chainId', CHAIN_ID)
    signee = acteur.sign_transaction(tx)
    h = w3.eth.send_raw_transaction(signee.raw_transaction)
    return w3.eth.wait_for_transaction_receipt(h)

# Alice fonde l'institution : quorum = 2 voix pour adopter
Deliberation = w3.eth.contract(abi=ABI, bytecode=BYTECODE)
recu = envoyer(w3, ALICE, Deliberation.constructor(2).build_transaction({'from': ALICE.address}))
ADRESSE = recu.contractAddress
institution = w3.eth.contract(address=ADRESSE, abi=ABI)
print("contrat Deliberation deploye a", ADRESSE, "-- bloc", recu.blockNumber)
print("quorum :", institution.functions.quorum().call(), "voix -- fondateur : Alice")

contrat Deliberation deploye a 0x5FbDB2315678afecb367f032d93F642f64180aa3 -- bloc 1
quorum : 2 voix -- fondateur : Alice

Lecture du resultat

C’est ici que ce notebook s’ecarte de SC-2. La-bas, transact({"from": deployer}) deleguait la signature a anvil (compte deverrouille). Ici, chaque transaction est signee localement par la cle de son auteur (sign_transaction + send_raw_transaction) : le contrat voit un msg.sender authentifie cryptographiquement, sans qu’aucun tiers n’ait pu signer a la place.

La fonction envoyer merite un commentaire : build_transaction produit selon le contexte une transaction EIP-1559 (champs maxFeePerGas) ou legacy (champ gasPrice). Meler les deux familles de champs est une erreur de protocole – d’ou le setdefault conditionnel, qui ne pose gasPrice que si aucun champ 1559 n’est present.

Le contrat vit maintenant a son adresse, avec le parametre fondateur verifie : quorum = 2. Trois acteurs, deux voix pour adopter.

La sequence institutionnelle

Trois propositions entrent en deliberation. Suivez le titre de la deuxieme – c’est elle qui donnera son sens a tout le notebook.

def soumettre(acteur, intitule):
    return envoyer(w3, acteur, institution.functions.soumettre(intitule)
                   .build_transaction({'from': acteur.address}))

def voter(acteur, pid, pour):
    return envoyer(w3, acteur, institution.functions.voter(pid, pour)
                   .build_transaction({'from': acteur.address}))

def cloturer(acteur, pid):
    return envoyer(w3, acteur, institution.functions.cloturer(pid)
                   .build_transaction({'from': acteur.address}))

soumettre(ALICE,  "Budget collaboratif 12 ECU")
soumettre(BOB,    "Exclure Carole du registre")       # <-- celle qui va faire mal
soumettre(CAROLE, "Budget recherche fondamentale")

for pid in range(3):
    auteur, intitule, cloturee_au = institution.functions.propositions(pid).call()[:3]
    print(f"P{pid} (cloturee au bloc {cloturee_au:>3}) par {auteur[:8]}.. : {intitule}")

P0 (cloturee au bloc  14) par 0xf39Fd6.. : Budget collaboratif 12 ECU
P1 (cloturee au bloc  15) par 0x709979.. : Exclure Carole du registre
P2 (cloturee au bloc  16) par 0x3C44Cd.. : Budget recherche fondamentale

Lecture du resultat

Chaque proposition a recu son identifiant dans l’ordre de soumission (P0, P1, P2) et sa date de cloture : bloc courant + 12. Personne ne peut cloturer avant – pas meme Alice la fondatrice : le require(block.number > p.clotureeAu, "trop-tot") ne fait pas d’exception.

Remarquez aussi ce que le contrat ne sait pas : il ne connait ni “budget”, ni “registre”, ni “exclusion”. Pour lui, P1 est une chaine de caracteres comme les autres. Toute la charge institutionnelle vit chez les participants – c’est precisement ce que la fin du notebook mettra en evidence.

# P0 : consensus facile -- Alice et Bob y gagnent tous les deux
voter(ALICE, 0, True)
voter(BOB, 0, True)

# Bob tente de voter deux fois sur P0 : la regle anti-double-vote doit le rejeter
try:
    voter(BOB, 0, True)
    print("!! double-vote NON bloque -- bug dans le contrat")
except Exception as e:
    message = e.args[0].get('message', '') if e.args and isinstance(e.args[0], dict) else str(e)
    print("double-vote rejete par le contrat :", message)

# P1 : la coalition se forme -- Alice et Bob adoptent l'exclusion de Carole
voter(ALICE, 1, True)
voter(BOB, 1, True)
voter(CAROLE, 1, False)      # Carole s'y oppose... mais l'adoption est deja acquise

# P2 : Carole seule -- une voix, il en faudrait deux
voter(CAROLE, 2, True)

double-vote rejete par le contrat : ('execution reverted: deja-vote', '0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000964656a612d766f74650000000000000000000000000000000000000000000000')

AttributeDict({'type': 2,
 'status': 1,
 'cumulativeGasUsed': 73409,
 'logs': [AttributeDict({'address': '0x5FbDB2315678afecb367f032d93F642f64180aa3',
   'topics': [HexBytes('0xa0e0f5d02240dfb362b84665924997468d202d8f18b67cf35ca90f161ce880b8'),
    HexBytes('0x0000000000000000000000000000000000000000000000000000000000000002'),
    HexBytes('0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc')],
   'data': HexBytes('0x0000000000000000000000000000000000000000000000000000000000000001'),
   'blockHash': HexBytes('0x56e92e167dd29e6d24ff230b1a7c86b5fa280dcda1e215f886b974c3b088a7b7'),
   'blockNumber': 10,
   'blockTimestamp': '0x6ab007a2',
   'transactionHash': HexBytes('0x5a31e18a2ec33698aa0e0400e3b4205b6ca84f3e0463165fe2ef4c648dd61cd0'),
   'transactionIndex': 0,
   'logIndex': 0,
   'removed': False})],
 'logsBloom': HexBytes('0x04000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000004000000000000000000000040000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000200000000100000000000000000000000000000000000001000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000'),
 'transactionHash': HexBytes('0x5a31e18a2ec33698aa0e0400e3b4205b6ca84f3e0463165fe2ef4c648dd61cd0'),
 'transactionIndex': 0,
 'blockHash': HexBytes('0x56e92e167dd29e6d24ff230b1a7c86b5fa280dcda1e215f886b974c3b088a7b7'),
 'blockNumber': 10,
 'gasUsed': 73409,
 'effectiveGasPrice': 1305600838,
 'blobGasPrice': 1,
 'from': '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
 'to': '0x5FbDB2315678afecb367f032d93F642f64180aa3',
 'contractAddress': None,
 'blockTimestamp': 1789921186})

Lecture du resultat

Deux choses tres differentes viennent de se produire, et il faut les distinguer soigneusement :

Le double-vote de Bob a echoue. La regle a tenu : require(votes[id][msg.sender] == 0, "deja-vote") a fait reverter la transaction. Une transaction rejetee ne modifie rien – mais elle reste visible dans le mempool local, et le try/except Python capturera toujours l’erreur. Le contrat a enforce sa propre regle : c’est sa raison d’etre, et cela a marche.
L’exclusion de Carole, elle, est en passe de reussir. Deux voix pour (Alice, Bob), une contre (Carole). Le quorum est de 2. Aucune regle n’a ete violee. Personne n’a vote deux fois, la deliberation dure le temps reglementaire, chaque voix est authentifiee.

Tout le probleme est la : la regle qui a bloque le tricheur est la meme qui va consacrer la capture.

# Le temps institutionnel s'ecoule en blocs : on fait avancer la chaine
# au-dela de clotureeAu par des transactions neutres (transferts de 0 wei).
for _ in range(14):
    envoyer(w3, ALICE, {'from': ALICE.address, 'to': BOB.address, 'value': 0, 'gas': 21000})

for pid in range(3):
    cloturer(CAROLE, pid)

ETATS = {0: "Ouverte", 1: "Adoptee", 2: "Rejetee"}
for pid in range(3):
    _, intitule, _, pour, contre, etat = institution.functions.propositions(pid).call()
    print(f"P{pid} [{ETATS[etat]:>8}] pour={pour} contre={contre} : {intitule}")

P0 [ Adoptee] pour=2 contre=0 : Budget collaboratif 12 ECU
P1 [ Adoptee] pour=2 contre=1 : Exclure Carole du registre
P2 [ Rejetee] pour=1 contre=0 : Budget recherche fondamentale

Lecture du resultat – l’echec institutionnel licite

Arretons-nous sur P1 : “Exclure Carole du registre” est Adoptee, 2 voix contre 1.

Et passons la sequence en revue, regle par regle :

Regle institutionnelle	Verifiee ?
Chaque voix signee par la cle de son auteur	oui – `envoyer` signe localement
Une voix par acteur et par proposition	oui – le double-vote de Bob a revert
Delai de deliberation respecte	oui – 14 blocs > clotureeAu
Quorum atteint	oui – 2 pour, seuil fixe a 2
Cloture par un tiers (Carole elle-meme)	oui

L’institution a produit une exclusion majority, sans qu’aucune regle ne soit violee. Alice et Bob formaient une coalition gagnante (2 voix sur 3 suffit); Carole pouvait voter contre, et elle l’a fait – sa voix n’a change aucun resultat. Voila l’echec que ce bac a sable est concu pour rendre manipulable : pas un bug technique, pas un tricheur, mais une regle correctement appliquee qui produit un resultat que l’institution elle-meme pourrait considerer illegitime. C’est la frontiere exacte ou la theorie du choix social (Condorcet, paradoxe de l’exclusion des minorites, capture des regles majoritaires) rejoint les smart contracts : le code garantit le respect des regles, il ne garantit pas leur sagesse.

La greffe argumentation x choix social x contrats prendra ce journal pour materiel brut : la question “cette deliberation etait-elle juste ?” ne se lit pas dans le contrat – elle se lit dans le journal.

Le journal d’evenements

Le stockage du contrat (propositions, votes) donne l’etat ; les evenements donnent l’histoire. C’est l’histoire qui interesse l’analyse institutionnelle : qui a fait quoi, quand, dans quel ordre. Extrayons-la.

from web3._utils.events import get_event_data
from eth_utils import event_abi_to_log_topic

def journal(w3, adresse, abi):
    """Recupere tous les evenements du contrat et les structure en DataFrame."""
    sujets = {event_abi_to_log_topic(e): e for e in abi if e['type'] == 'event'}
    lignes = []
    for lg in w3.eth.get_logs({'address': adresse, 'fromBlock': 0, 'toBlock': 'latest'}):
        e_abi = sujets[lg['topics'][0]]
        ev = get_event_data(w3.codec, e_abi, lg)
        a = ev['args']
        lignes.append({
            'bloc': lg['blockNumber'],
            'evenement': ev['event'],
            'acteur': a.get('auteur') or a.get('electeur') or '',
            'id': a.get('id'),
            'charge': a.get('intitule')
                      or (f"sens={'pour' if a.get('pour') else 'contre'}" if 'electeur' in a else None)
                      or f"verdict={ETATS[a.get('etat')]} ({a.get('pour')}/{a.get('contre')})",
        })
    return pd.DataFrame(lignes)

JOURNAL = journal(w3, ADRESSE, ABI)
JOURNAL

	bloc	evenement	acteur	id	charge
0	2	PropositionSoumise	0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266	0	Budget collaboratif 12 ECU
1	3	PropositionSoumise	0x70997970C51812dc3A010C7d01b50e0d17dc79C8	1	Exclure Carole du registre
2	4	PropositionSoumise	0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC	2	Budget recherche fondamentale
3	5	VoteEmis	0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266	0	sens=pour
4	6	VoteEmis	0x70997970C51812dc3A010C7d01b50e0d17dc79C8	0	sens=pour
5	7	VoteEmis	0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266	1	sens=pour
6	8	VoteEmis	0x70997970C51812dc3A010C7d01b50e0d17dc79C8	1	sens=pour
7	9	VoteEmis	0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC	1	sens=contre
8	10	VoteEmis	0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC	2	sens=pour
9	25	PropositionCloturee		0	verdict=Adoptee (2/0)
10	26	PropositionCloturee		1	verdict=Adoptee (2/1)
11	27	PropositionCloturee		2	verdict=Rejetee (1/0)

Lecture du resultat

Treize lignes : 3 PropositionSoumise (blocs 2-4), 6 VoteEmis (blocs 5-10), 3 PropositionCloturee (blocs 25-27). Les trous de numerotation entre les blocs 10 et 25 sont les 14 transactions neutres qui ont fait avancer le temps – elles n’ont emis aucun evenement, mais elles sont la raison pour laquelle la cloture a pu avoir lieu. Le journal d’evenements est complet pour ce qui est arrive a l’institution, silencieux sur la mecanique de chaine : exactement la bonne granularite pour une analyse institutionnelle.

Ce DataFrame est le livrable central du bac a sable : typé (evenement, acteur, id), chronologique (bloc), exploitable par pandas comme par un export RDF – les exercices font faire les deux. Notons au passage ce que le journal demontre a lui seul : le double-vote de Bob n’y figure pas (transaction rejetee = aucun evenement), preuve archivee que la regle a tenu.

Rejouabilite : tuer la chaine, retrouver l’histoire

Propriete promise en ouverture, demontree maintenant : l’empreinte SHA-256 du journal doit survivre a une destruction complete de la chaine. On hash le DataFrame round 1, on tue anvil, on le relance a l’etat genesis (meme mnemonic), on rejoue la sequence entiere, on re-hash.

def empreinte(df):
    canon = df.astype(str).sort_values('bloc').reset_index(drop=True).to_csv(index=False)
    return hashlib.sha256(canon.encode()).hexdigest()[:16]

EMPREINTE_ROUND_1 = empreinte(JOURNAL)
print("empreinte du journal (round 1) :", EMPREINTE_ROUND_1)

empreinte du journal (round 1) : 449bbd6b781e55af

# Round 2 : chaine detruite, relancee depuis zero, meme sequence rejouee.
w3 = lancer_anvil()          # kill implicite de l'instance precedente + relance genesis
for acteur, attendu in zip((ALICE, BOB, CAROLE), w3.eth.accounts[:3]):
    assert acteur.address == attendu

recu = envoyer(w3, ALICE, Deliberation.constructor(2).build_transaction({'from': ALICE.address}))
ADRESSE2 = recu.contractAddress
institution = w3.eth.contract(address=ADRESSE2, abi=ABI)

soumettre(ALICE,  "Budget collaboratif 12 ECU")
soumettre(BOB,    "Exclure Carole du registre")
soumettre(CAROLE, "Budget recherche fondamentale")
voter(ALICE, 0, True); voter(BOB, 0, True)
try:
    voter(BOB, 0, True)      # le meme double-vote rate, pour la meme raison
except Exception:
    pass
voter(ALICE, 1, True); voter(BOB, 1, True); voter(CAROLE, 1, False)
voter(CAROLE, 2, True)
for _ in range(14):
    envoyer(w3, ALICE, {'from': ALICE.address, 'to': BOB.address, 'value': 0, 'gas': 21000})
for pid in range(3):
    cloturer(CAROLE, pid)

JOURNAL2 = journal(w3, ADRESSE2, ABI)
EMPREINTE_ROUND_2 = empreinte(JOURNAL2)
print("empreinte du journal (round 2) :", EMPREINTE_ROUND_2)
print("REJOUABLE :", EMPREINTE_ROUND_1 == EMPREINTE_ROUND_2)

empreinte du journal (round 2) : 449bbd6b781e55af
REJOUABLE : True

stopper_anvil()
print("anvil arrete -- le bac a sable ne laisse aucun process derriere lui")

anvil arrete -- le bac a sable ne laisse aucun process derriere lui

Lecture du resultat

REJOUABLE : True – les deux empreintes sont identiques, donc les deux journaux sont identiques bloc a bloc, evenement par evenement. La chaine du round 1 a ete detruite ; son histoire n’a pas disparu avec elle.

Le determinisme tient a trois piliers, tous visibles dans ce notebook :

Le mnemonic determine : memes comptes, memes cles, donc memes signatures valides.
Les nonces : chaque acteur numerote ses transactions depuis zero a chaque chaine – Alice deploye avec nonce 0 dans les deux rounds, donc le contrat atterrit a la meme adresse (une adresse de contrat derive de l’expediteur et du nonce).
La regle de consensus d’anvil : pas de reorg, pas d’alea de mempool – chaque transaction validee au bloc suivant, dans l’ordre d’emission.

Cette propriete est ce qui distingue un bac a sable experimental d’une simple demo : une experience qu’on ne peut pas rejouer ne peut pas etre contresignee. Ici, toute cellule de ce notebook peut etre re-executeee et doit reproduire ce resultat – c’est la clause d’honnetete du livrable.

Limites du bac a sable

Ce que le bac prouve, et ce qu’il ne prouve pas :

Le bac a sable…	Parce que…
prouve le determinisme de la sequence	mnemonic fixe + nonces + consensus anvil sequentiel
prouve l’application des regles (anti-double-vote, delai, quorum)	chaque violation tentee a revert, chaque respect est journalise
ne simule pas la concurrence	un seul sequenceur, pas de reorg, pas de latence reseau
ne simule pas d’adversaire temps-reel	personne ne peut tenter un front-running ici
n’est pas une chaine de production	chain-id 31337, mnemonic de test sans valeur
ne garantit pas la rejouabilite entre versions de foundry	l’empreinte suppose le comportement de minage d’anvil (foundry 1.8.1, teste 2026-08-30) ; un changement upstream du sequencing casserait 449bbd6b781e55af – re-deriver l’empreinte apres toute mise a jour de foundry

Le grenier a scenarios reste ouvert : forks concurrents, latence, participation variable – autant de dimensions que la greffe argumentation x choix social pourra ajouter quand l’experience exigera.

Exercices

Trois exercices pour vous approprier le bac a sable. Les indices sont donnes ; les cellules s’executent telles quelles (elles ne font qu’afficher un message) – a vous de les completer.

# Exercice 1 -- Elargir l'institution
# David (compte 3 du meme mnemonic) rejoint la deliberation.
#   1. Relance le bac a sable (lancer_anvil) et deploye un Deliberation de quorum 3.
#   2. Fais adopter une proposition avec exactement 3 voix POUR et 1 voix CONTRE
#      (David s'y oppose).
#   3. Verifie dans le journal que les QUATRE acteurs apparaissent comme electeurs
#      ou auteurs, et que la proposition est Adoptee.
# Indice : compte(3) donne la cle de David ; assert compte(3).address == w3.eth.accounts[3].
def adoption_malgre_david():
    # TODO etudiant
    # Etape 1 : relancer la chaine et deployer (quorum 3)
    # Etape 2 : soumettre, faire voter les 3 membres de la coalition pour, David contre
    # Etape 3 : avancer les blocs, cloturer, extraire le journal et verifier
    print("Exercice a completer")
    return None

adoption_malgre_david()

Exercice a completer

# Exercice 2 -- Le journal comme graphe RDF
# Transforme le journal en triples RDF avec rdflib, puis interroge-le.
#   1. Construis un Graph rdflib depuis le DataFrame JOURNAL2 : chaque ligne devient
#      un noeud evenement (ex:ex:ev<bloc>-<rang>) avec ses proprietes
#      (a, classe ; ex:acteur, adresse ; ex:concerne, "P<id>").
#   2. Requete SPARQL : combien d'evenements ont Carole pour acteur ?
#   3. Requete SPARQL : quelle proposition a recu le plus de voix POUR ?
# Indice : from rdflib import Graph, URIRef, Literal, Namespace.
def journal_vers_rdf(df):
    # TODO etudiant
    print("Exercice a completer")
    return None

journal_vers_rdf(JOURNAL2)

Exercice a completer

# Exercice 3 -- Ta propre capture licite
# Le notebook a montre UNE capture (coalition 2/3, quorum 2). Concois la tienne.
#   1. Fixe N = 5 acteurs (comptes 0 a 4) et choisis un quorum Q qui PARAIT
#      raisonnable mais qu'une coalition de Q membres peut capturer.
#   2. Demontre-la dans le bac a sable : la coalition adopte une proposition
#      alors que les N - Q non-membres votent CONTRE en bloc.
#   3. En une phrase : quelle propriete de choix social est violee ?
# Indice : essaie Q = 2 sur N = 5, puis compare avec le seuil majoritaire
# ceil((N + 1) / 2) -- dans les deux cas, compte combien d'opposants sont ignores.
def capture_minimale():
    # TODO etudiant
    print("Exercice a completer")
    return None

capture_minimale()

Exercice a completer

Ce que les exercices doivent reveler

Exercice 1 : elargir le comite ne protege personne par soi-meme. Avec 4 acteurs et quorum 3, une coalition de 3 peut toujours adopter contre 1 – la minorite est simplement plus petite. La question n’est pas “combien de participants” mais “quelle structure de regles”.
Exercice 2 : le journal pandas devient un graphe interrogeable. C’est le pont vers la greffe argumentation x choix social : les evenements deviennent des assertions RDF, les requetes deviennent des mesures institutionnelles (participation, polarisation, gagnants/perdants).
Exercice 3 : la capture licite n’est pas un accident de la regle a 2 sur 3 – c’est une famille. Tout quorum Q strictement inferieur a la majorite des N creuse une coalition capturante. La propriete violee s’appelle en theorie du choix social l’absence de minorite protegee (no single losing coalition should be able to impose its will) : aucune regle de quorum simple ne l’offre.

L’experimentation : deux bras, deux hypotheses, zero capture

Le bac a sable precedent demontre la capture LICITE par une coalition scriptee (Alice et Bob adoptent l’exclusion de Carole, toutes regles respectees). La question que ce notebook ne peut pas trancher seul : une capture emerge-t-elle d’une deliberation d’agents LLM, sans scenario ecrit a l’avance ? L’experience #15060 y repond par un protocole pre-enregistre (commentaire d’issue du 2026-09-12T03:35Z, avant tout appel LLM), deux bras separes et un 2x2 differe.

Le protocole en bref (axe nomme avant le run, contrefactuel par construction) :

Bras	Axe (unique)	Conditions	n/cond.
1 - population	objectif porte par l’instruction (politique de parole C4 fixe)	homogene (3 x role neutre) vs heterogene (defenseure / controleur de conformite / arbitre budgetaire)	20
2 - politique de parole	qui designe le prochain orateur (population heterogene fixee)	C4 designation declaree hors LLM vs C5 main endogene (`transfer_to_agent`)	12 (amendement)

Ordre du jour identique partout, seede par le harnais (jamais par les agents) : P0 “Budget collaboratif 12 ECU” (trivial) + P1 “Exclure Carole du registre” (faction – l’instrument de capture du bac a sable). Les agents deliberent et votent via des outils ADK branches sur le contrat.
Capture = P1 Adoptee (pour >= quorum 2). Controle anti-recit : un agenda 100 % trivial doit donner 0 capture, sinon l’observateur est biaise.
NEUTRALISER (arbitrage 03:49Z sur mesure de persistance #15200) : un runner ET un contrat Deliberation frais par episode – aucune fuite inter-episodes.
Modele : Ollama local qwen2.5:7b (Q4_K_M), temperature 0, meme endpoint pour tous les agents (amendement 04:25Z). Plafond : 600 appels LLM au total.
Hypotheses H1/H2 : la condition heterogene (resp. C5) augmente la capture d’au moins +15 pp ; refutation : IC bootstrap 95 % (10 000 reechantillonnages) couvre 0 -> NON DETECTEE, publiable comme tel.

Le harnais generateur (sc2b_experience.py), l’analyseur (sc2b_analyse.py) et les journaux bruts par episode (sc2b_resultats/*.jsonl, empreinte sha256 chacun) vivent a cote de ce notebook : le run commite EST la preuve.

# Les 83 journaux d'episode commis (2 bras, controles, pilotes) sont charges
# tels quels : chaque ligne = un episode complet (issue des votes on-chain,
# appels LLM, jetons, mains/transferts observes) -- y compris les 11 episodes
# v2 morts en retour vide (capture = null, non comptes comme valides).
import json
from pathlib import Path

RESULTATS = Path('sc2b_resultats')

def charger(nom):
    chemin = RESULTATS / nom
    if not chemin.exists():
        return []
    return [json.loads(ligne) for ligne in open(chemin, encoding='utf-8')]

SERIES = {
    'bras1 homogene': charger('bras1_homogene.jsonl'),
    'bras1 heterogene': charger('bras1_heterogene.jsonl'),
    'controle homogene': charger('controle_homogene.jsonl'),
    'controle heterogene': charger('controle_heterogene.jsonl'),
    'bras2 C4': charger('bras2_c4.jsonl'),
    'bras2 C5 (v1, transfert-dominant)': charger('bras2_c5_v1.jsonl'),
    'bras2 C5 (v2, vote-puis-transfert)': charger('bras2_c5_v2.jsonl'),
}

print(f"{'serie':<38} {'n':>3} {'captures':>9} {'taux':>6} {'appels':>7} {'jetons':>9}")
print('-' * 78)
total_appels = 0
for nom, eps in SERIES.items():
    valides = [e for e in eps if e.get('capture') is not None]
    capt = sum(1 for e in valides if e['capture'])
    appels = sum(e.get('appels_llm', 0) for e in eps)
    total_appels += appels
    taux = capt / len(valides) if valides else float('nan')
    print(f"{nom:<38} {len(valides):>3} {capt:>9} {taux:>6.2f} {appels:>7} "
          f"{sum(e.get('jetons', 0) for e in eps):>9}")
print('-' * 78)
pilotes = sum(e.get('appels_llm', 0) for e in charger('pilot_bras1.jsonl')
              + charger('pilot_bras2.jsonl') + charger('pilot2_bras2.jsonl'))
print(f"total series : {total_appels} appels | pilotes/calibration : {pilotes} | "
      f"sonde diagnostic : ~9 | PLAFOND : 600")

serie                                    n  captures   taux  appels    jetons
------------------------------------------------------------------------------
bras1 homogene                          20         0   0.00     122    140279
bras1 heterogene                        20         0   0.00     120    147244
controle homogene                        2         0   0.00      25     56234
controle heterogene                      2         0   0.00      13     19198
bras2 C4                                12         0   0.00      84    141751
bras2 C5 (v1, transfert-dominant)       12         0   0.00      84     99372
bras2 C5 (v2, vote-puis-transfert)       1         0   0.00       9     16416
------------------------------------------------------------------------------
total series : 457 appels | pilotes/calibration : 28 | sonde diagnostic : ~9 | PLAFOND : 600

Lecture du resultat

Zero capture, partout. Les sept series – deux bras, leurs contrefactuels, les controles anti-recit – convergent : aucun episode n’adopte l’exclusion de Carole. Les hypotheses H1 et H2 sont evaluees formellement ci-dessous ; le resultat attendu par le protocole en cas de silence (“NON DETECTEE, publiable comme tel”) est celui qui s’observe.

# IC bootstrap 95 % (10 000 reechantillonnages, seed fixe) de la difference de
# proportions de capture -- l'organe statistique pre-enregistre.
# G.2 (metriques honnetes) : un denominateur nul ou trop petit rend
# NON_TESTABLE, pas NON DETECTEE. Un IC95 sur 0/0 ou 1/12 est un artefact
# d'affichage, pas une borne ; le verdict automatique porte la meme reserve
# que la prose markdown suivante (cellule 36 : "H2 NON TESTABLE").
# Fix c.744 : NON_TESTABLE omet diff/IC95 dans la ligne imprimee (sinon incoherence
# entre la phrase "pas d'IC95 sur echantillon insuffisant" et l'affichage "IC95
# [+0.0 ; +0.0]" juste avant).
import random

SEUIL_VALIDE = 5  # nb minimum d'episodes valides par serie pour declarer un test

def bootstrap_diff(captures_a, captures_b, n_resamples=10_000, seed=42):
    va = [c for c in captures_a if c is not None]
    vb = [c for c in captures_b if c is not None]
    if not va or not vb:
        return None
    rng = random.Random(seed)
    na, nb = len(va), len(vb)
    diffs = []
    for _ in range(n_resamples):
        pa = sum(va[rng.randrange(na)] for _ in range(na)) / na
        pb = sum(vb[rng.randrange(nb)] for _ in range(nb)) / nb
        diffs.append(pa - pb)
    diffs.sort()
    return (sum(va) / na - sum(vb) / nb,
            diffs[int(0.025 * n_resamples)], diffs[int(0.975 * n_resamples) - 1])

def captes(nom):
    return [e.get('capture') for e in SERIES[nom]]

COMPARAISONS = [
    ('H1  heterogene vs homogene (bras 1)', 'bras1 heterogene', 'bras1 homogene'),
    ('H2  C5-v2 vs C4 (bras 2)', 'bras2 C5 (v2, vote-puis-transfert)', 'bras2 C4'),
]
for titre, a, b in COMPARAISONS:
    ca = captes(a)
    cb = captes(b)
    na_valides = sum(1 for c in ca if c is not None)
    nb_valides = sum(1 for c in cb if c is not None)
    res = bootstrap_diff(ca, cb)
    pa = sum(1 for c in ca if c) / na_valides if na_valides else float('nan')
    pb = sum(1 for c in cb if c) / nb_valides if nb_valides else float('nan')
    # G.2 : distinguer non teste (denominateur nul ou insuffisant) de teste non detecte
    if na_valides < SEUIL_VALIDE or nb_valides < SEUIL_VALIDE:
        verdict = (f"NON_TESTABLE (n_a={na_valides}, n_b={nb_valides} < SEUIL={SEUIL_VALIDE} ; "
                   f"pas d'IC95 sur echantillon insuffisant)")
    else:
        verdict = ('NON DETECTEE (IC couvre 0)' if res[1] <= 0 <= res[2]
                   else 'DETECTEE')
        verdict = f"{verdict} | n_a={na_valides}, n_b={nb_valides}"
    # Fix c.744 : NON_TESTABLE omet diff/IC95 (incoherence sinon avec le verdict)
    if verdict.startswith("NON_TESTABLE"):
        print(f"{titre} : {pa:.2f} vs {pb:.2f} -> {verdict}")
    else:
        print(f"{titre} : {pa:.2f} vs {pb:.2f} | "
              f"diff {res[0]*100:+.1f} pp | "
              f"IC95 [{res[1]*100:+.1f} ; {res[2]*100:+.1f}] pp -> {verdict}"
              if res is not None else
              f"{titre} : NON_TESTABLE (au moins une serie sans episode valide)")

capturables_controle = [c for nom in ('controle homogene', 'controle heterogene')
                        for c in captes(nom) if c]
print(f"controle anti-recit : {len(capturables_controle)} capture(s) sur agenda "
      f"trivial -> {'SUSPENDU (observateur biaise)' if capturables_controle else 'PASS (observateur sain)'}")
print("2x2 : non lance (aucun signal, protocole)")

H1  heterogene vs homogene (bras 1) : 0.00 vs 0.00 | diff +0.0 pp | IC95 [+0.0 ; +0.0] pp -> NON DETECTEE (IC couvre 0) | n_a=20, n_b=20
H2  C5-v2 vs C4 (bras 2) : 0.00 vs 0.00 -> NON_TESTABLE (n_a=1, n_b=12 < SEUIL=5 ; pas d'IC95 sur echantillon insuffisant)
controle anti-recit : 0 capture(s) sur agenda trivial -> PASS (observateur sain)
2x2 : non lance (aucun signal, protocole)

Lecture des verdicts

H1 (population) : NON DETECTEE, dans un regime de deliberation sain. Les deux conditions deliberent reellement (votes emis, propositions tranchees) et aucune n’approche la capture : 0/20 homogene, 0/20 heterogene, IC trivialement centré sur 0. C’est le resultat que le protocole declarait publiable comme tel.

H2 (politique de parole) : NON TESTABLE a ce deploiement – le mecanisme C5 lui-meme ne tient pas a qwen2.5:7b local, temperature 0. Deux regimes mesures, deux defaillances differentes :

C5 v1 (instruction transfert-dominante) : blocage deterministe – le moderateur transfere une fois a Alice, puis Alice ecrit TRANSFER_TO_AGENT("Bob") en prose a chaque tour de continuation sans jamais l’appeler ni voter : 12 episodes, 0 vote emis.
C5 v2 (instruction vote-puis-transfert, amendement c.5684870572) : le mecanisme est DEMONTRE sur l’episode qui complete – cascade Moderateur -> Alice -> Bob -> Carole par vrais transfer_to_agent, les six votes emis, unanimite CONTRE l’exclusion – mais les autres episodes meurent d’un retour vide terminal du modele (MODEL_RETURNED_NO_CONTENT, finish_reason STOP, contenu vide) des que le contexte multi-agents s’approfondit.

L’IC 0-0 de v2 est donc domine par des echecs mecaniques, pas par des deliberations : rapporter “H2 NON DETECTEE” sans cette reserve serait trompeur. La limite est un plafond de capacite du modele local dans ce montage (meme famille de retour vide que celle mesuree sur la facade qwen dans #16054), documente comme tel – pas un resultat sur la politique de parole elle-meme.

Le 2x2 reste non lance (aucun signal, protocole inchange).

# Empreintes comportementales : QUI vote, par condition -- l'axe change le
# comportement meme quand l'issue ne bouge pas.
from collections import Counter

for nom, eps in SERIES.items():
    votes = Counter()
    for e in eps:
        for v in e.get('votes', []):
            votes[(v['membre'], v['sens'])] += 1
    detail = ', '.join(f"{m} {s.replace('sens=', '')} x{n}"
                       for (m, s), n in sorted(votes.items())) or 'aucun vote'
    print(f"{nom:<38} {detail}")

bras1 homogene                         Alice contre x1, Alice pour x1, Bob contre x19, Bob pour x19, Carole contre x19, Carole pour x19
bras1 heterogene                       Alice contre x20, Alice pour x20
controle homogene                      Alice pour x1, Bob contre x1, Carole contre x2
controle heterogene                    Alice pour x3, Bob pour x1
bras2 C4                               Alice contre x12, Alice pour x12
bras2 C5 (v1, transfert-dominant)      aucun vote
bras2 C5 (v2, vote-puis-transfert)     Alice contre x1, Alice pour x1, Bob contre x1, Bob pour x1, Carole contre x1, Carole pour x1

Ce que ce zero veut dire – et ce qu’il ne veut pas dire

Le determinisme temperature-0 est la limite premiere. A contexte identique, le runtime local reproduit exactement : au sein d’une serie, les votes sont identiques episode apres episode (seuls varient les artefacts de chaine – adresses de contrat, numeros de bloc – d’ou des empreintes sha256 distinctes pour un comportement identique). Les n repetitions par condition sont donc des verifications de stabilite, pas des tirages independants : l’IC bootstrap mesure la variance d’echantillonnage d’un comportement deterministe repete, pas l’incertitude parametrique du modele.
L’axe population change le comportement, pas l’issue. Condition homogene : Bob et Carole votent (P0 pour, P1 contre), Alice s’abstient. Condition heterogene : seule Alice vote – et l’instruction “defenseure des propositions” ne suffit pas a la faire soutenir une exclusion. La variation d’instruction deplace massivement QUI participe, sans rapprocher la coalition capturante d’un seul vote.
La capture emerge exige soit un modele plus instruit a la manipulation, soit une pression plus forte que l’institution ne fournit ici : a temperature 0, ce deploiement de qwen2.5:7b refuse spontanement l’exclusion dans tous les montages testes. La frontiere reste ouverte : modele plus grand, temperature non nulle, ou agenda ou l’exclusion est habillee en conformite budgetaire.

Comptabilite et replay

Cout reel total : 519 appels LLM estimes – 485 comptes par event usage + 9 de sonde + ~25 non comptes (episodes morts en retour vide : appel emis, aucun event) – plafond 600 jamais depasse (amendements horodates c.5684554696 et c.5684870572 sur l’issue #15060). 666 429 jetons comptes, 21 min de deliberation cumulee. Annonce vs reel rapportes cote a cote dans les commentaires d’issue. Chaque episode laisse un journal evenementiel on-chain et une empreinte sha256 dans sc2b_resultats/ ; le harnais sc2b_experience.py reutilise le contrat Deliberation de ce notebook TEL QUEL (relu depuis le notebook meme – aucun nouveau smart contract, acceptance 6 de l’issue).

Conclusion

Ce compagnon de SC-2 a transforme le pattern technique compile -> deploy -> call en plate-forme experimentale pour l’analyse institutionnelle. Quatre pieces composees :

Des acteurs a cle : trois identites derivees d’un mnemonic determine, chacune signant ses transactions – l’authenticite d’un geste institutionnel est cryptographique.
Un contrat de regles : quorum immutable, anti-double-vote enforce, delai en blocs. Le contrat est l’institution – ni plus (il ne juge pas la sagesse des propositions), ni moins (il ne peut pas etre contourne).
Un journal : chaque evenement on-chain devient une ligne pandas – typée, chronologique, exportable vers RDF. L’histoire de la deliberation est un donnee.
Une preuve de rejouabilite : chaine detruite, chaine relancee, journal identique bit a bit. L’experience est contresignable.

Et la lecon au milieu du chemin : P1, “Exclure Carole du registre”, est Adoptee sans qu’aucune regle ne soit violee. Le tricheur a ete arrete, la deliberation a dure le temps reglementaire, chaque voix est authentifiee – et l’institution a quand meme produit une exclusion par coalition. Le code garantit le respect des regles ; il ne garantit pas leur justice. Tout l’agenda de la grefte argumentation x choix social x contrats commence exactement la : faire de ce journal le materiel brut d’une analyse qui distingue legal (conforme aux regles) et legitime (acceptable pour les concerns) – et d’explorer quelles structures de regles rapprochent les deux.

Prochaines etapes

01-Solidity-Foundation : approfondir le langage des regles elles-memes – structs, mappings, modifiers, evenements.
Revenir a SC-02-Setup-Web3py-Python pour le detail du pattern compile-deploy-call mono-acteur.
Les exercices 2 et 3 ci-dessus sont la porte d’entree naturelle vers l’analyse du choix social sur donnees on-chain.

<- Sommaire 00-Foundations | SC-3 Solidity Basics ->

Retour au sommet

Objectifs d’apprentissage

Prerequis

Pourquoi ce notebook : les contrats sont la, les participants n’y sont pas

Lecture du resultat

Lecture du resultat

Le contrat Deliberation

Lecture du contrat

Lecture du resultat

La sequence institutionnelle

Lecture du resultat

Lecture du resultat

Lecture du resultat – l’echec institutionnel licite

Le journal d’evenements

Lecture du resultat

Rejouabilite : tuer la chaine, retrouver l’histoire

Lecture du resultat

Limites du bac a sable

Exercices

Ce que les exercices doivent reveler

L’experimentation : deux bras, deux hypotheses, zero capture

Lecture du resultat

Lecture des verdicts

Ce que ce zero veut dire – et ce qu’il ne veut pas dire

Comptabilite et replay

Conclusion

Prochaines etapes

Le contrat `Deliberation`