enrich(search,#13410): densite adversarial + dancing links C# — lectures de sorties chiffrees (tranche markdown + twin audits)

MyIA.AI.Notebooks/Search/Part1-Foundations/Search-06-AdversarialSearch-Csharp.ipynb

@@ -350,6 +350,19 @@
     "Console.WriteLine(\"-> Valeur 0 = partie nulle garantie avec jeu optimal des deux cotes.\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "87c008f3",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire le verdict Minimax : la valeur 0 n'est pas un échec, c'est un théorème\n",
+    "\n",
+    "Trois lignes se suivent : `Valeur Minimax depuis l'etat initial : 0`, `Meilleure action (case 0-8) : 0`, puis le commentaire imprimé `-> Valeur 0 = partie nulle garantie avec jeu optimal des deux cotes`. La lecture importante est celle du **0** : ce n'est pas « l'algorithme n'a rien trouvé », c'est la **valeur du jeu** — au Tic-Tac-Toe, deux joueurs parfaits font nulle, et le minimax qui explore l'arbre complet le constate numériquement. La « meilleure action 0 » (le coin) ne gagne rien de plus qu'une autre case : toutes les actions mènent à la valeur 0, l'algorithme rend la première. Retenir le geste : la recherche adversariale ne « résout » pas le jeu en trouvant la victoire — elle **mesure** ce que chaque camp peut garantir."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "ceba1ab6",
@@ -477,6 +490,19 @@
     "Console.WriteLine($\"Speedup    : {(t2 > 0 ? t1 / t2 : double.PositiveInfinity):F1}x  (meme valeur -> decision identique)\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "1d9db755",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire le speedup : 0,2095 s contre 0,0061 s\n",
+    "\n",
+    "La sortie aligne les deux moteurs : `Minimax : valeur=0, temps=0,2095s` puis `Alpha-Beta : valeur=0, temps=0,0061s`, et conclut `Speedup : 34,1x (meme valeur -> decision identique)`. Deux lectures. **Le speedup fait la leçon, pas les temps absolus** : 0,2095 s et 0,0061 s dépendent de la machine (convention du registre : seuls les rapports et l'ordre comptent) — mais le facteur ~34 mesure ce que l'élagage épargne : l'alpha-beta visite une fraction de l'arbre sans jamais changer la racine. **La parenthèse est la garantie de correction** : « meme valeur -> decision identique » — un élagage plus rapide qui donnait une autre décision serait un bug, pas une optimisation ; la sortie atteste que la valeur racine (0) survit à l'élagage."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "0680cb39",
@@ -621,6 +647,19 @@
     "\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "81ed8a88",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire l'iterative deepening : la même valeur obtenue par progression\n",
+    "\n",
+    "La sortie imprime `Iterative Deepening : valeur=0,00, action=0, profondeur atteinte=9` puis `-> Profondeur 9 = arbre complet du Tic-Tac-Toe (9 cases) ; valeur 0 = nul avec jeu optimal`. Deux détails à lire. **La profondeur atteinte 9** : la progression par profondeur croissante a fini par couvrir l'arbre entier — au Tic-Tac-Toe l'horizon est fini, l'iterative deepening converge donc vers le minimax exact. **La valeur 0,00** : c'est la valeur heuristique à profondeur limitée qui, à chaque palier, se rapproche de la valeur exacte — ici elle vaut exactement 0 dès que la profondeur suffit. Le geste algorithmique : dans un jeu trop profond pour l'arbre complet, la même boucle rendrait la meilleure valeur **atteignable dans le budget**, avec la garantie de toujours avoir une réponse."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "834eaea2",
@@ -754,6 +793,19 @@
     "Console.WriteLine(\"-> Valeur identique a Minimax pur (le cache ne change pas la decision, seulement la vitesse).\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "dce59eaa",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire la table de transposition : le cache ne change pas la décision\n",
+    "\n",
+    "Trois lignes : `Alpha-Beta + Transposition : valeur=0, temps=0,0091s`, `Cache : 1565 hits, 3010 misses`, et le commentaire `-> Valeur identique a Minimax pur (le cache ne change pas la decision, seulement la vitesse)`. La statistique centrale est le couple **1565 hits / 3010 misses** : un peu plus d'un tiers des recherches d'état tombent sur une position déjà calculée — le Tic-Tac-Toe contient des transpositions (jouer case 1 puis case 3 mène au même état que 3 puis 1), et la table capture cette redondance. Le temps (0,0091 s) est du même ordre que l'alpha-beta pur : sur ce petit jeu, le cache ne paie pas — c'est exactement la lecture honnête, la table de transposition est un investissement qui rapporte sur les arbres profonds (échecs), pas sur 9 cases. Et la ligne finale est le contrat d'invariance : valeur identique = le cache est transparent pour la décision."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "d5e876fc",
@@ -1071,6 +1123,19 @@
     "Console.WriteLine(\"Exercice 4 a completer : tournoi algorithmique (voir indices ci-dessus).\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "c7a3beaf",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire les quatre exercices : l'échelle des extensions\n",
+    "\n",
+    "Les quatre cellules d'exercice impriment la même invite (`Exercice N a completer`) — le contrat C.1 : le notebook s'exécute d'un bout à l'autre, la validation est l'étudiant. L'échelle se lit dans les énoncés : **Exercice 1** transpose tout ce notebook vers Connect Four (grille 7×6, victory line de 4) — le même minimimax sur un arbre qui ne tient plus en entier ; **Exercice 2** attaque l'ordonnancement des coups (move ordering) — l'ordre dans lequel alpha-beta visite les enfants détermine l'élagage, la question est de le mesurer ; **Exercice 3** unifie MAX et MIN en une seule récursion negamax — la reformulation standard des échecs ; **Exercice 4** organise le tournoi où ces variantes s'affrontent. Quatre niveaux : transférer, optimiser, reformuler, confronter."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "75215c34",

MyIA.AI.Notebooks/Search/Part1-Foundations/Search-08-DancingLinks-Csharp.ipynb

@@ -104,6 +104,19 @@
    ],
    "id": "cell-ff274a3d"
   },
+  {
+   "cell_type": "markdown",
+   "id": "87d6835c",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire l'exemple canonique : la matrice 7×6 et sa vérification colonne par colonne\n",
+    "\n",
+    "La sortie pose l'instance de référence : univers `U = {1,2,3,4,5,6,7}`, six sous-ensembles S1-S6 imprimés en matrice binaire (1 = l'élément est dans le sous-ensemble), puis la solution proposée `{S2, S4, S6}` et sa vérification : `Couverture par colonne : [1, 1, 1, 1, 1, 1, 1]` et `Couverture exacte ? OUI (chaque colonne == 1)`. C'est la **définition du problème lue sur la sortie** : chaque élément de U doit être couvert **exactement une fois** — le vecteur de vérification compte, colonne par colonne, combien de sous-ensembles choisis contiennent chaque élément, et l'exactitude exige le 1 partout (un 0 = élément oublié, un 2 = élément doublé). La vérification est volontairement naïve et indépendante de l'algorithme : elle relira aussi les solutions des cellules suivantes."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -220,6 +233,19 @@
    ],
    "id": "cell-f4ca5d48"
   },
+  {
+   "cell_type": "markdown",
+   "id": "711c5629",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire l'algorithme X naïf : la solution attendue atteinte en 3,231 ms\n",
+    "\n",
+    "La sortie rend `Solution trouvée : [S2, S4, S6]` contre `Solution attendue : [S2, S4, S6]`, en `Temps : 3,231 ms`. Deux lectures. **La double impression est le protocole** : la solution attendue est imprimée à côté de la solution trouvée — sur l'exemple canonique, l'algorithme est validé par confrontation, pas par confiance. **Le temps est machine-dépendant** (convention du registre : l'ordre et les rapports font la leçon) : 3,231 ms servira de point de comparaison au DLX de la section 4 sur la même instance — c'est le rapport entre les deux qui mesurera le gain structurel. Noter aussi le warning CS8632 du compilateur (annotation nullable hors contexte) : bénin, sans effet sur l'exécution — il témoigne simplement que la cellule compile du C# réel."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -548,6 +574,19 @@
    ],
    "id": "cell-9352e61e"
   },
+  {
+   "cell_type": "markdown",
+   "id": "9453ae53",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire le DLX : la même solution, la structure en moins de millisecondes\n",
+    "\n",
+    "`Solution DLX : [S2, S4, S6]`, `Solution attendue : [S2, S4, S6]`, `Vérification : CORRECT`, `Temps : 1,697 ms`. La convergence est triple : le DLX retrouve la solution de l'algorithme naïf (section 2), la vérificateur indépendant la confirme (`CORRECT`), et le temps (~1,7 ms contre ~3,2 ms pour le naïf sur la même instance) montre déjà le gain — mesuré sur 6 sous-ensembles seulement, il grossira avec la taille. La différence structurelle est dans les gestes : le naïf **recopie** la matrice à chaque niveau de récursion, le DLX **couverte/découvre** les nœuds en O(1) — la sortie ne montre que le symptôme (le temps), la section suivante montre la cause."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -692,6 +731,19 @@
    ],
    "id": "cell-c989a575"
   },
+  {
+   "cell_type": "markdown",
+   "id": "77b86fc8",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire le pavage : 12 placements, 6 contraintes, 2 triominos\n",
+    "\n",
+    "La sortie transpose la couverture exacte en géométrie : `Matrice : 12 placements × 6 cases-contraintes`, puis `Solution : 2 placements` — les deux triominos verticaux `I@0,0|1,0|2,0` et `I@0,1|1,1|2,1`. La lecture clé est **l'encodage** : chaque ligne de la matrice n'est plus un sous-ensemble abstrait mais un **placement possible** d'une pièce (12 manières de poser un triomino dans la grille 2×3), chaque colonne une **case à couvrir** (les 6 cases de la grille). « Couvrir exactement une fois » devient « paver sans trou ni chevauchement » — le même solveur, zéro modification : seule la matrice change. La solution imprimée (les deux colonnes verticales côte à côte) est l'unique pavage de la grille 2×3 par deux I verticaux — le solveur l'a trouvée comme une couverture exacte parmi les combinaisons de placements, sans qu'aucun pavage ne soit codé à la main."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -773,6 +825,19 @@
    ],
    "id": "cell-d0d3a232"
   },
+  {
+   "cell_type": "markdown",
+   "id": "6013e541",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire la comparaison : 0,017 ms contre 0,455 ms sur 28 placements\n",
+    "\n",
+    "La sortie monte en taille : `Taille de la matrice : 28 placements × 9 contraintes` (pavage 3×3), puis `DLX : 0,017 ms → solution trouvée` contre `Backtracking : 0,455 ms`, et le commentaire imprimé : `DLX évite la recopie de matrice (cover/uncover O(1) par nœud), tandis que le backtracking classique re-vérifie la compatibilité à chaque pas`. Le rapport est de l'ordre de **27×** — à comparer au ~2× de la petite instance de la section 4 : le gain du DLX **croît avec la matrice**, c'est la signature d'un avantage structurel (complexité par nœud) et non d'un effet constant. Les temps absolus restent machine-dépendants (convention du registre) ; la leçon est la progression des rapports : 1,9× sur 6 lignes, ~27× sur 28 — et la conclusion du notebook en dessous la generalise : c'est cette structure qui tient les Sudoku 9×9 du jumeau de la famille."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

scripts/notebook_tools/twin_pairs.d/search-06-adversarialsearch/0007-2026-09-16-myia-po-2026-CoursIA.yaml

@@ -0,0 +1,6 @@
+date: '2026-09-16'
+by: myia-po-2026:CoursIA
+python_sha: 0a8c3c78da0a8489acefa1ac772002134d8700c5
+csharp_sha: d0b3e4051c6b9f964110ecb2c52adbf74802ce36
+content_python_sha: 47558871a13948d38d2ee782cb5cd7fc382b9e8f1b5517722b27744b55fc92fc
+content_csharp_sha: 58e69ce7082a72bb11a1dcdbb184461a6b66c31ac4568944a9f2924529b71a22

scripts/notebook_tools/twin_pairs.d/search-08-dancinglinks/0009-2026-09-16-myia-po-2026-CoursIA.yaml

@@ -0,0 +1,6 @@
+date: '2026-09-16'
+by: myia-po-2026:CoursIA
+python_sha: cf66eb501e8cffcbe4390b22d534d7b62950559a
+csharp_sha: 623fe31a69afc0bffd5ccf50a0d37a9cedc9591e
+content_python_sha: a2074f2fb295c474fe64c9282ae11799f85ce4bf6d2d1ae3b1006b9d5cb2197a
+content_csharp_sha: 1dd6529438722d347aef8c322aa7b2e55a54d491734491e62d8b8237119f566b