enrich(sudoku,#13410): densite statistiques/strategies humaines — lectures de sorties chiffrees (tranche markdown)

MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb

@@ -901,6 +901,19 @@
     "print(\"Methodes Naked Pair ajoutees.\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "d7c8d63d",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lecture : le contrat de sortie minimal du Naked Pair\n",
+    "\n",
+    "La cellule ne produit qu'une ligne (`Methodes Naked Pair ajoutees`) : le contrat de cette étape est l'ajout de la méthode, pas son diagnostic. Ce qui rend la lecture non triviale, c'est ce que la ligne ne dit pas et que la suite du notebook commitera : sur les cinq puzzles du benchmark (cellule de la section 8), la technique est appliquée **15 fois** — la preuve qu'elle est bien déclenchée, et non un code mort. Le Naked Pair exploite une unité (ligne, colonne ou bloc) où **deux cases n'ont exactement que les deux mêmes candidats** : ces deux valeurs ne peuvent plus apparaître ailleurs dans l'unité, donc on les retire des autres cases. C'est une déduction du « deuxième niveau » : elle ne place pas une valeur directement, elle réduit le candidat des cases voisines, ce qui ravive la chasse aux singles des sections précédentes."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "cell-05be24e4",
@@ -1092,6 +1105,19 @@
     "print(\"Methodes Pointing Pair ajoutees.\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "af8a8e5c",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lecture : le Pointing Pair, un candidat verrouillé dans une unité\n",
+    "\n",
+    "La sortie minimaliste (`Methodes Pointing Pair ajoutees`) encode une étape d'architecture, pas un calcul : les techniques s'ajoutent par paquet, chacune avec son propre prédicat de recherche, et le solveur complet les compose (section 7). Le Pointing Pair — ou *locked candidates* — survient quand un candidat n'apparaît que dans une seule ligne (ou colonne) d'un bloc : puisqu'il doit nécessairement occuper cette ligne dans le bloc, il est éliminé des **autres blocs de la même ligne**. C'est la première technique où l'observation se fait sur deux unités croisées (bloc × ligne), ce qui la rend plus coûteuse à coder que les singles. Son utilité est mesurée plus bas, dans le benchmark : **17 applications** sur 5 puzzles faciles — derrière les singles, devant le X-Wing — soit une technique de milieu de gamme, fréquente sans être triviale."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "6ad47806",
@@ -1197,6 +1223,19 @@
     "print(\"Methodes X-Wing ajoutees.\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "0b6efb70",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lecture : le X-Wing, première structure en croix\n",
+    "\n",
+    "Comme pour les deux sections précédentes, la sortie (`Methodes X-Wing ajoutees`) ne valide que l'ajout ; la mesure d'usage viendra du benchmark : **5 applications** sur les cinq puzzles — le X-Wing est la technique la moins utilisée de la section 8, ce qui est cohérent avec sa définition. Un X-Wing se produit quand une valeur n'a que **deux positions possibles dans deux lignes distinctes, alignées sur les deux mêmes colonnes** : les quatre cases forment un rectangle, et la valeur ne peut occuper que deux coins opposés — elle est donc éliminée des deux colonnes en dehors du rectangle. La structure est symétrique (lignes ↔ colonnes), ce qui explique les paires de méthodes row/col dans le code. Le benchmark le montre rarement utile sur des grilles faciles, mais c'est la technique qui devient indispensable sur les puzzles moyens : sa présence dans la panoplie évite au solveur de tomber dans le backtracking de la section 9."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "530a3bec",
@@ -1454,6 +1493,19 @@
     "print(solver)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "eaa1bcce",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lecture du test : la grille facile se résout toute seule, en 1,54 ms\n",
+    "\n",
+    "La sortie aligne le puzzle d'origine, sa solution complète, et les statistiques des techniques qui y sont parvenues. Premier fait, en haut : **Resolu: True, Temps: 1,54 ms** — ce puzzle dit « facile » est résolu sans le moindre appel au backtracking : aucune ligne d'appels récursifs n'apparaît, le solveur a tout déduit. Deuxième fait, le relevé des techniques : **Naked Single : 14, Hidden Single : 22** — sur cette grille, la déduction cachée (un chiffre n'a qu'une seule case possible dans son unité) fait plus de travail que la déduction évidente (une case n'a qu'un candidat) ; le ratio 22/14 = 1,6 est l'inverse de l'ordre habituellement présenté dans les tutoriaux (le Naked Single d'abord, le Hidden Single ensuite), d'où l'importance de ces compteurs pour la pédagogie. Troisième fait : la solution elle-même, première ligne `9 6 2 | 1 8 5 | 4 7 3` — les huit autres lignes permutent les mêmes chiffres, chaque ligne/colonne/bloc contenant exactement une fois 1 à 9 ; la vérification visuelle de ces 27 contraintes est l'exercice de lecture le plus direct du notebook."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "d02a2e63",
@@ -1564,6 +1616,19 @@
     "benchmark_human(easy_puzzles, num_puzzles=5)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "d2c71161",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire les chronos du benchmark : cinq puzzles, un rythme et des écarts\n",
+    "\n",
+    "La sortie donne enfin des chiffres que les interprétations qualitatives de la section 8 n'avaient pas encore cités. **Puzzle 1 : 0,65 ms — Puzzle 4 : 3,62 ms** : entre le plus rapide et le plus lent des cinq, le rapport atteint **5,6x** — même parmi des puzzles « faciles », la structure fait varier les temps d'un ordre de grandeur modeste, exactement le comportement que le notebook 18b quantifie sur 8 grilles comparables. Le bilan cité est cohérent : **5/5 résolus, total 11,93 ms, moyenne 2,39 ms** — une moyenne qui a du sens ici parce que tous les puzzles partagent la même fourchette (pas de valeur aberrante au-delà de 3,62 ms). Le dernier bloc donne la « balance » des techniques sur les cinq grilles confondues : **Hidden Single : 149, Naked Single : 91, Pointing Pair : 17, Naked Pair : 15, X-Wing : 5** (total 277 déductions). Trois lectures : (1) les singles font ~87 % du travail (240/277), confirmant la hiérarchie des sections 2-3 ; (2) le X-Wing, à 5, est presque de l'ordre du bruit sur des grilles faciles ; (3) la hiérarchie 149 > 91 > 17 > 15 > 5 est la courbe de fréquence à retenir : la rareté d'une technique croît avec sa complexité, de la déduction unitaire à la structure en croix."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "13a9c814",
@@ -1793,6 +1858,19 @@
     "    print(f\"  Backtracking: {solved_bt}, {t_bt*1000:.2f}ms, {bt.call_count} appels\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "170c545a",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire la comparaison appariée : l'écart se creuse avec la difficulté\n",
+    "\n",
+    "La sortie compare les deux solveurs **puzzle par puzzle**, ce qui permet trois lectures exactes. La première : les chronos appariés — P1 : **0,75 ms contre 1,54 ms**, P2 : **3,14 ms contre 7,55 ms**, P3 : **2,16 ms contre 10,95 ms**. Les ratios par puzzle sont 2,1x, 2,4x puis 5,1x : l'avantage des stratégies humaines **grandit avec la difficulté** du puzzle, puisque le backtracking paie chaque retour-arrière en appels récursifs pendant que les déductions logiques coûtent un balayage de candidats. La deuxième lecture : la colonne des appels — **49, 201, 295** — croît dans le même ordre : le backtracking « simple » de la section 9 confirme être le point de comparaison honnête du notebook, celui qui justifie les stratégies humaines sans triomphalisme (sur un puzzle qu'il résout aussi, en 10,95 ms quand même). La troisième : les deux solveurs affichent tous **True** — la comparaison ne porte pas sur la résolubilité (les deux sont complets sur ces grilles), mais sur le chemin : des déductions allant de 0,75 ms (P1) à 3,14 ms (P2), contre 545 appels d'essai-erreur cumulés (49 + 201 + 295)."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "4a913e27",
@@ -2002,6 +2080,19 @@
     "print(\"Methode definie : find_hidden_pairs\")\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "5ce66baf",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lecture de l'exemple résolu : Hidden Pair, la première brique avancée\n",
+    "\n",
+    "La sortie (`Methode definie : find_hidden_pairs`) valide que la cellule d'exemple guide est bien un ajout fonctionnel — l'apport de la lecture vient de la cellule de test de la section 10 : le motif détecté y est imprimé, `Hidden Pairs trouves: 1` avec `(0,7) et (1,6) = {8, 7} dans block`. Cette ligne est la lecture complète de l'exemple : deux cases dans le même bloc (intersection des lignes 0-1 et des colonnes 6-7, coin supérieur droit de la grille) sont les **seules** positions où les valeurs 8 et 7 peuvent aller dans ce bloc ; elles gardent leurs autres candidats éventuels, mais 8 et 7 sont confisquées — tout autre candidat dans ces deux cases devient éliminable. C'est le miroir exact du Naked Pair (deux cases avec deux candidats seulement → éliminer des voisins) décrit en section 3."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "08e62f62",
@@ -2197,6 +2288,19 @@
     "print(\"Methode definie : find_swordfish\")\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "e454852f",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lecture de l'exemple résolu : Swordfish, un X-Wing à trois arêtes\n",
+    "\n",
+    "La sortie (`Methode definie : find_swordfish`) valide l'ajout, et le test de la section 10 la fait parler : `Swordfish trouves: 1` avec `Valeur 7, lignes=(0, 1, 3), colonnes=(1, 6, 7), orientation=row`. La ligne se lit comme une généralisation du X-Wing : au lieu de deux lignes et deux colonnes, le Swordfish aligne **trois lignes dont le candidat 7 n'occupe que trois colonnes** (1, 6 et 7) ; la valeur doit donc occuper une colonne différente à chaque ligne, et elle peut être éliminée des trois colonnes en dehors des trois lignes visées. L'orientation `row` dit le sens du balayage (le motif existe aussi par colonnes — l'exercice 2b fera coder le transposé). Sur la grille de test, la détection d'un seul motif suffit pour la cellule de validation : la rareté du Swordfish (un motif à trois niveaux sur une grille facile) est elle-même l'information — comme le X-Wing du benchmark, ces structures ne paient leur code que sur les puzzles moyens."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "a83851d6",
@@ -2431,6 +2535,19 @@
     "print(\"Methodes definies : _are_peers, find_xy_wings\")\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "e55b3e3d",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lecture de l'exemple résolu : trois XY-Wing, un cycle de paires\n",
+    "\n",
+    "La sortie ne dit pas seulement « 3 trouvés », elle imprime les pivots : **Pivot=(7, 1), Aile1=(7, 5), Aile2=(7, 7)**, puis les deux permutations symétriques — les trois pivots forment un cycle sur la ligne 7 de la grille, chacun servant d'aile aux deux autres. Le mécanisme XY-Wing se lit dans les valeurs éliminées : **elimine=8, puis 1, puis 6** — trois valeurs distinctes, une par pivot. Un XY-Wing fonctionne avec trois cases bivaluées (deux candidats chacune) : un pivot {X, Y} et deux ailes {X, Z} et {Y, Z} ; tout candidat commun aux deux ailes (ici leur valeur partagée) peut être retiré de leurs cases voisines communes. Sur la ligne 7 de la grille de test, les trois cases (7,1), (7,5), (7,7) s'échangent ainsi leurs candidats — une chaîne fermée qui élimine trois chiffres, un par pivot ; c'est la plus coûteuse des trois structures de la section 10, et la seule qui exige de superposer trois objets bivalués pour déduire une élimination."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "d46ade0f",
@@ -2649,6 +2766,19 @@
     "print(solver2)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "d961b952",
+   "metadata": {
+    "papermill": {},
+    "tags": []
+   },
+   "source": [
+    "### Lire le test des techniques avancées : quatre faits, une grille résolue\n",
+    "\n",
+    "La cellule de validation répète les trois exemplettes précédentes sur une grille unique et imprime chaque détection — c'est le bilan chiffré de la section 10. **Hidden Pairs : 1** (le couple {(0,7), (1,6)} = {8, 7} déjà relevé), **Swordfish : 1** (valeur 7, lignes (0, 1, 3) — un seul motif suffit sur la grille de test), **XY-Wings : 3** (le cycle de pivots de la ligne 7). La deuxième moitié de la sortie change de grille : `Puzzle avant resolution` montre une grille vierge (première ligne `2 . . | . 8 . | 3 . .`) que le solveur complet attaque — et `Resolu: True` avec les neuf lignes de solution complètes, dont la première `2 4 5 | 9 8 1 | 3 7 6`. La leçon de cette lecture est la composition : les techniques de la section 10 ne servent pas seules — c'est le solveur de la section 7 qui les enchaîne (Hidden Pair d'abord, puis Swordfish, puis les XY-Wing) jusqu'à la résolution complète. Le test prouve ainsi l'objectif du notebook : un solveur « humain » qui remplace l'essai-erreur par une liste ordonnée de déductions."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "7f7e6a12",