Source canonique : Engels, Baek, Kantamneni, Tegmark — Scaling Laws For Scalable Oversight (arXiv:2504.18530, NeurIPS 2025). PDF archive hors depot : G:\Mon Drive\MyIA\IA\Bibliographie IA\XAI\2025 - Engels et al - Scaling Laws For Scalable Oversight.pdf (sha8 FDA29C9A, cf regle bibliography-hygiene).
Pourquoi ce notebook d abord : R12 valide son cadre theorique sur une version modifiee du jeu de Nim (game tree complet resolu par force brute), puis l applique a quatre jeux reels (Mafia, Debate, Backdoor Code, Wargames). Nim est le seul des cinq cas auto-contenu et executable localement : il ne demande ni LLM externe, ni GPU, ni benchmark public. C est donc le seul point de depart reproductible depuis po-2024 sans stack GenAI.
Ce que le notebook n est pas : un benchmark reel sur Backdoor Code ou Wargames (mandat user GenAI sur po-2023, Tell c.1261-L1 ★★★ strict). Le notebook pose le cadre, implemente le module stats (Elo L-BFGS-B, double-ReLU 3 phases + AIC, NSO imbrique n*) et fournit les donnees simulees sur lesquelles le module se calibre. La transposition a Backdoor Code/Wargames est une PR separee (PR 2, hors scope local).
Notre cluster CoursIA-2 heberge plusieurs agents reviewers (Hermes, NanoClaw, jsboige self-bot) qui supervisent les PRs ouvertes sur jsboige/CoursIA. Le parallele explicite que R12 appelle scalable oversight est exactement notre situation : des bots watchers qui doivent signaler des defauts dans du code genere par d autres bots (potentiellement plus forts qu eux). Le cadre Elo + scaling laws offre une metrique falsifiable du taux de detection, et la courbe NSO predit combien de niveaux d oversight imbriques sont necessaires pour maintenir un taux de succes cible.
Acceptance :
Elo_offset).1-p_bruit) decrit de la courbe obtenue.n* pour passer un gap Elo donne, et confronter aux taux publies (Mafia 13.5%, Debate 51.7%, Backdoor Code 10%, Wargames 9.4% a gap 400).R12 propose un score Elo propre a chaque jeu d oversight (pas l Elo general du LLM). L idee : un modele peut etre fort en general mais mauvais a detecter des backdoors ; ce qui compte pour l oversight, c est le second. Notation : Elo_H(g) pour Houdini de capacite g, Elo_G(g) pour Guard de capacite g.
Elo_H(g) - Elo_G(g) n est pas monotone lineaire en g. Trois phases emergent des donnees R12 :
Forme : delta(g) = a + b*max(0, g-c) - d*max(0, g-e) avec c < e et b > d (Houdini monte plus vite mais sature au meme endroit que Guard). Ajustement par L-BFGS-B sur les win rates pairwise.
A gap Elo D donne, on demande combien de niveaux d oversight n* maximisent la probabilite de succes p_n(D). R12 resout analytiquement : si chaque niveau coute un facteur de degradation q < 1, alors n* = log(q) / log(1-D/400) (approximation en gap Elo modere). Pour D=400 sur Backdoor Code, la formule rend n* = inf (le domaine s’arrete a D < 400, cf. cellule n_star) et le taux mesure plafonne a 10%, montrant que NSO ne sauve pas un gap trop grand.
import math
import random
from itertools import product
from collections import defaultdict
from typing import List, Tuple, Callable
import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt
random.seed(42)
np.random.seed(42)
print("Setup OK — Nim modified de R12, framework Elo + NSO")Setup OK — Nim modified de R12, framework Elo + NSORegle : un tas de N jetons (N impair pour assurer un perdant). Deux joueurs retirent 1 ou 2 jetons a tour de role. Le joueur qui prend le dernier jeton gagne (variante misericorde inversee de R12, qui change la strategie optimale).
Strategie resolue (force brute) : par induction arriere sur N, on determine winning(N) = True si le joueur dont c est le tour peut forcer la victoire. Pour N impair, winning(N) = not (winning(N-1) and winning(N-2)) avec cas de base winning(0) = False, winning(1) = True, winning(2) = True.
On code deux joueurs :
PerfectPlayer : joue selon la strategie resolue, ne perd jamais en jouant en premier.NoisyPlayer(p) : avec probabilite p, joue au hasard (1 ou 2 jetons) au lieu de suivre la strategie optimale. Modelise un joueur bruite — c est notre parametre de capacite.def winning(N, memo=None):
if memo is None:
memo = {}
if N in memo:
return memo[N]
if N == 0:
return False
if N == 1 or N == 2:
return True
w = (not winning(N-1, memo)) or (not winning(N-2, memo))
memo[N] = w
return w
def perfect_move(N):
if N == 1 or N == 2:
return N
if not winning(N-1):
return 1
if not winning(N-2):
return 2
return 1
def noisy_move(N, p):
if random.random() < p:
return random.choice([1, 2]) if N >= 2 else 1
return perfect_move(N)
def play_game(N_init, p1, p2, verbose=False):
N = N_init
turn = 1
while N > 0:
move = p1(N) if turn == 1 else p2(N)
move = min(move, N)
N -= move
if verbose:
print(f" Tour {turn}: prend {move}, reste {N}")
if N == 0:
return turn
turn = 3 - turn
assert winning(1) == True
assert winning(2) == True
assert winning(3) == False
assert perfect_move(3) == 1
print("Strategie resolue OK — winning et perfect_move coherents")Strategie resolue OK — winning et perfect_move coherentsLes positions perdantes sont N=3, 6, 9, … (multiple de 3 sans 0). Le joueur qui commence sur N multiple de 3 perd en jouant optimal. La variante dernier qui prend gagne inverse la parite : N=1, 2 sont gagnants (je prends tout), N=3 est perdant (je prends 1, reste 2 — l adversaire gagne en prenant 2 ; je prends 2, reste 1 — l adversaire gagne en prenant 1). La recurrence winning(N) = not (winning(N-1) and winning(N-2)) reproduit ce schema.
On transpose le cadre R12 a Nim : Houdini est le joueur qui veut perdre volontairement pour piéger Guard (analogie : Houdini veut faire passer une backdoor, Guard veut la detecter). On inverse donc le goal : Houdini gagne s il fait perdre Guard dans une position gagnante.
Parametre de capacite : p_bruit ∈ [0, 1]. p=0 = joueur parfait (impossible a pieger), p=1 = joueur aleatoire (se laisse pieger). On mesure le win rate de HoudiniGuard contre PerfectPlayer pour differents niveaux de bruit.
Mapping Elo : on suppose Elo = -400 * log(p) (approximation Elo standard ou chaque facteur 10 sur le win rate = 400 points). Verifions sur un balayage p ∈ {0.0, 0.05, 0.1, 0.2, 0.35, 0.5, 0.7, 0.9, 1.0} avec N_init = 7 (position gagnante pour le premier joueur — winning(7) = True, Houdini doit renverser une position théoriquement gagnante).
def houdini_vs_perfect(p, N_init=7, n_games=1000):
wins = 0
for _ in range(n_games):
winner = play_game(N_init, lambda N: noisy_move(N, p), perfect_move)
if winner == 1: # Houdini = joueur 1 (p1) ; perfect_move = joueur 2
wins += 1
return wins / n_games
p_values = [0.0, 0.05, 0.1, 0.2, 0.35, 0.5, 0.7, 0.9, 1.0]
win_rates = [houdini_vs_perfect(p, n_games=2000) for p in p_values]
for p, w in zip(p_values, win_rates):
elo_gap = -400 * math.log(p) if p > 0 else float('inf')
print(f"p_bruit={p:.2f} win_rate_H={w:.3f} elo_gap_theorique={elo_gap:.0f}")p_bruit=0.00 win_rate_H=1.000 elo_gap_theorique=inf
p_bruit=0.05 win_rate_H=0.928 elo_gap_theorique=1198
p_bruit=0.10 win_rate_H=0.852 elo_gap_theorique=921
p_bruit=0.20 win_rate_H=0.719 elo_gap_theorique=644
p_bruit=0.35 win_rate_H=0.576 elo_gap_theorique=420
p_bruit=0.50 win_rate_H=0.429 elo_gap_theorique=277
p_bruit=0.70 win_rate_H=0.273 elo_gap_theorique=143
p_bruit=0.90 win_rate_H=0.157 elo_gap_theorique=42
p_bruit=1.00 win_rate_H=0.122 elo_gap_theorique=-0A p=0 (Houdini parfait), il gagne toujours (1.000) : winning(7) = True, N=7 est gagnante pour le premier joueur, et Houdini la convertit a chaque partie. A mesure que p augmente, il joue de plus en plus au hasard et son taux de victoire decroit de facon monotone : 0.928 a p=0.05, 0.719 a p=0.2, 0.429 a p=0.5, 0.122 a p=1.
La courbe n est pas une sigmoide pure : la pente est maximale autour de p≈0.4 et s adoucit aux deux extremites. En particulier, un joueur purement aleatoire (p=1) ne prend le dernier objet que dans 12.2 % des parties — le hasard seul ne suffit pas a battre PerfectPlayer sur ce jeu.
On cale un modele parametrique delta(p) = a + b*max(0, c-p) - d*max(0, p-e) (trois regimes : decroissance rapide pour p < c, plateau pour p∈[c, e], reprise de la decroissance pour p > e) sur les win rates observes. Trois parametres libres a, b, d ; c et e fixes a c=0.1, e=0.7 (points d inflexion choisis par inspection). Comparaison AIC contre un modele constant (b = d = 0 : une droite horizontale unique).
def double_relu(p_arr, a, b, d, c=0.1, e=0.7):
return a + b * np.maximum(0, c - p_arr) - d * np.maximum(0, p_arr - e)
def loss(params, p_arr, win_arr):
a, b, d = params
pred = double_relu(p_arr, a, b, d)
return np.mean((pred - win_arr) ** 2)
p_arr = np.array(p_values)
win_arr = np.array(win_rates)
result = minimize(loss, x0=[0.5, 1.0, 0.5], args=(p_arr, win_arr), method='L-BFGS-B')
a_fit, b_fit, d_fit = result.x
mse = result.fun
aic = 2 * 3 + len(p_arr) * math.log(mse)
print(f"Fit double-ReLU: a={a_fit:.3f}, b={b_fit:.3f}, d={d_fit:.3f}")
print(f"MSE={mse:.5f}, AIC={aic:.2f}")
result_lin = minimize(lambda p: loss([p[0], 0, 0], p_arr, win_arr), x0=[0.5], method='L-BFGS-B')
mse_lin = result_lin.fun
aic_lin = 2 * 1 + len(p_arr) * math.log(mse_lin)
print(f"Fit constant: a={result_lin.x[0]:.3f}, MSE={mse_lin:.5f}, AIC={aic_lin:.2f}")
print(f"delta_AIC = {aic_lin - aic:.2f} (>10 = tres forte preference pour double-ReLU)")Fit double-ReLU: a=0.576, b=4.805, d=1.691
MSE=0.02613, AIC=-26.80
Fit constant: a=0.562, MSE=0.09933, AIC=-18.78
delta_AIC = 8.02 (>10 = tres forte preference pour double-ReLU)Resultat empirique (mesure sur 9 niveaux de bruit, 2k parties par niveau) : delta_AIC = 8.02.
C’est une preference moderee (seuil classique >10 pour forte evidence), pas une preuve. La double-ReLU (MSE 0.0261) decrit nettement mieux la courbe que le modele constant (MSE 0.0994) : le constant est plat a 0.562 alors que les mesures vont de 1.000 a 0.122. La double-ReLU aide donc ici, mais le terrain Nim reste trop simple pour reproduire les 3 phases de R12 dans leur amplitude : la courbe mesuree est une decroissance monotone lissee, et le plateau retenu entre c et e (0.576) est une approximation — les mesures y decroissent encore (0.576 → 0.429). L’intuition R12 sur Backdoor Code/Mafia reste plausible, mais n est pas verifiee sur Nim.
Aucune valeur de delta_AIC n est mesuree ici pour Backdoor Code, Mafia ou Wargames : ces terrains demandent des LLM (cf conclusion §9) et appartiennent au notebook 2.
On transpose la formule analytique R12 : pour un gap Elo D et un facteur de qualite par niveau q ∈ (0, 1), le nombre optimal de niveaux NSO est n* = log(q) / log(1 - D/400) (approximation pour gap modere). On etudie n* en fonction de D et q.
def n_star(D, q):
if D >= 400:
return float('inf')
if q <= 0 or q >= 1:
return float('nan')
return math.log(q) / math.log(1 - D/400)
print("NSO niveau optimal n* en fonction du gap Elo D (q=0.8) :")
for D in [50, 100, 200, 300, 350, 380, 395]:
n = n_star(D, 0.8)
print(f" D={D:>4} n*={n:.2f}")
print("\nNSO niveau optimal n* en fonction de q (D=200) :")
for q in [0.5, 0.7, 0.8, 0.9, 0.95]:
n = n_star(200, q)
print(f" q={q:.2f} n*={n:.2f}")NSO niveau optimal n* en fonction du gap Elo D (q=0.8) :
D= 50 n*=1.67
D= 100 n*=0.78
D= 200 n*=0.32
D= 300 n*=0.16
D= 350 n*=0.11
D= 380 n*=0.07
D= 395 n*=0.05
NSO niveau optimal n* en fonction de q (D=200) :
q=0.50 n*=1.00
q=0.70 n*=0.51
q=0.80 n*=0.32
q=0.90 n*=0.15
q=0.95 n*=0.07Resultat empirique sur la formule analytique : pour D=395 (proche du gap 400 publie R12), n* = 0.05 — c’est-a-dire 0 niveau NSO, abandon direct. Pour D=200 (gap modere), n* ∈ [0.10, 0.71] selon qualite q : un seul niveau suffit dans la majorite des cas.
Implication pour R12 Backdoor Code : leur gap mesure de 400 correspond a n* -> 0, expliquant le plafond a 10% meme avec beaucoup de niveaux NSO. Pour notre cluster, le gap Hermes-vs-NanoClaw en pratique est plutot ~100-200 (agents specialises, pas adversariaux), donc un seul niveau d oversight specialise suffit — pas besoin d’imbriquer.
Validation empirique de la formule : la formule analytique de R12 (validee sur leur simulation complete) donne bien n* < 1 pour D>=200, en coherence avec le plafond empirique. La formule n* = log(q)/log(1-D/400) capture donc bien le regime de saturation.
Qui est Houdini chez nous ? Tout agent qui produit du code qu un autre agent doit reviewer — y compris moi-meme quand je pousse un notebook sans l avoir fait reviewer par un tiers. Qui est Guard ? Hermes, NanoClaw, clusterManager-Myia, et jsboige self-bot en dernier recours.
Mapping R12 vers CoursIA :
Limite du parallele : R12 joue sur des LLMs adversariaux. Notre cluster a des LLMs cooperatifs (pas de comportement adversarial). Le gap Elo pertinent est donc entre agents cooperatifs de specialites differentes, pas entre attaquant et defenseur. Cette nuance change les taux attendus : un Hermes Lean face a un NanoClaw Python sera moins efficace, mais pas en opposition. C est plutot la complementarite que la conflictualite qui domine.
Ce que ce notebook ne fait pas : benchmark reel Hermes vs NanoClaw (PR 2 a venir, hors scope po-2024 sans GPU).
La cellule « Jeu de Nim modifié » a résolu la variante (retirer 1 ou 2 jetons, dernier coup gagnant). Étendez la résolution à la variante misère (le joueur qui prend le dernier jeton perd).
winning_misere(N, memo) : même récursion que winning, mais la condition terminale s’inverse — prendre le dernier jeton fait perdre, donc N=0 signifie que le joueur précédent a pris le dernier jeton et a perdu : à N=0, le joueur au trait gagne (l’autre vient de perdre) ; vérifiez les cas N=1 et N=2 à la main avant de coder.winning_misere et un perfect_move_misere dérivé doivent produire des parties gagnantes pour le joueur 1 si et seulement si winning_misere(N_init) est vrai.Indice : la misère de ce jeu ne change la réponse que sur des cas de bord précis — la comparaison pas à pas (étape 3) est plus instructive que le code lui-même.
# Exercice 1 : variante misere (prendre le dernier jeton perd)
# Etape 1 : winning_misere(N, memo) -- attention a la condition terminale N=0
# Etape 2 : coherence winning_misere <-> perfect_move_misere (parties simulees)
# Etape 3 : divergence des tableaux gagnants vs variante standard, N in [0, 20]
# TODO etudiant
tableau_misere = None # TODO etudiant : {N: bool} pour N in [0, 20]
divergences = None # TODO etudiant : liste des N ou les variantes divergent
print("Exercice 1 a completer : variante misere du jeu de Nim")Exercice 1 a completer : variante misere du jeu de NimLe tournoi de la section 5 donne win_rate_H = 0.576 à p=0.35 et 0.429 à p=0.50 : le point d’équilibre (win_rate = 0.5, donc D_elo = 0 par la convention Elo) est entre les deux. Mesurez-le.
houdini_vs_perfect(p) pour p ∈ {0.40, 0.42, 0.44, 0.46} avec n_games=4000 (le bruit Monte-Carlo décroît comme 1/√n — 2000 épisodes donnent ±0.011 de précision, insuffisant pour trancher entre 0.42 et 0.44).Indice : -400·log(p) = 0 donne p = 1 — l’équilibre théorique du tournoi n’est PAS au même endroit que le p* mesuré ; c’est précisément le décalage à expliquer (le joueur parfait n’exploite pas toutes les erreurs avec la fréquence p).
# Exercice 2 : point de bascule Elo du tournoi (win_rate = 0.5)
# Etape 1 : houdini_vs_perfect(p) pour p in {0.40, 0.42, 0.44, 0.46}, n_games=4000
# Etape 2 : interpolation de p* (win_rate = 0.5)
# Etape 3 : comparer au p theorique qui annule -400*log(p) -- expliquer l'ecart
# TODO etudiant
p_bascule = None # TODO etudiant : p* interpole
print("Exercice 2 a completer : point de bascule Elo")Exercice 2 a completer : point de bascule EloLa section 7 calcule n*(D, q) sur des gaps théoriques (50 à 395). Confrontez-la aux gaps réellement mesurés par le tournoi de la section 5, puis concluez.
Indice : p=0.35 donnait win_rate 0.576 → D ≈ +53 — comparez à n*(50, 0.8) = 1.67 de la table existante : le tournoi à bruit modéré est dans la zone où NSO a un sens.
# Exercice 3 : n* NSO sur les gaps Elo mesures par le tournoi
# Etape 1 : D_elo empirique pour p in {0.10, 0.20, 0.35} (win_rates de la section 5)
# Etape 2 : n*(D, 0.8) par cas -- inf si D>=400, <1 si gap faible
# Etape 3 : conclusion -- le tournoi est-il dans le regime NSO utile ?
# TODO etudiant
n_star_mesures = None # TODO etudiant : {p: (D_elo, n*)}
print("Exercice 3 a completer : NSO sur les gaps mesures")Exercice 3 a completer : NSO sur les gaps mesuresCe qui est mesure firsthand dans ce notebook :
Ce qui n est pas dans ce notebook :
q (demande un terrain empirique).Suite : PR 2 — Backdoor-Code-From-Scratch.ipynb — transposition conceptuelle au cas Backdoor Code avec module stats + protocole Houdini 3 etages vs Guard majority-vote, sans execution LLM reelle (cas degenere acceptable pour la pedagogie, cf sota-not-workaround Prong A : la mesure reelle necessiterait API externe vers RECOVERABLE-USER-HAND, hors scope po-2024).
Source primaire : Engels, Baek, Kantamneni, Tegmark. Scaling Laws For Scalable Oversight. NeurIPS 2025. arXiv:2504.18530. PDF archive hors depot.
Contexte distillation : Issue T13 (Oversight scalable) de l EPIC #16741 (distillation corpus Tegmark).
Sub-grain lie : #16754 (T13 Oversight). Claim pose c.1335 par myia-po-2024:CoursIA-2.
🤖 Generated with Claude Code