From e4fa6711fec16f3756f96cef831ddb00728fdd34 Mon Sep 17 00:00:00 2001 From: jsboige Date: Wed, 16 Sep 2026 13:25:47 +0200 Subject: [PATCH 1/6] =?UTF-8?q?enrich(sudoku,#13410):=20tranche=20densite?= =?UTF-8?q?=20statistiques/strategies=20humaines=20=E2=80=94=20lectures=20?= =?UTF-8?q?de=20sorties=20chiffrees=20(markdown=20uniquement)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5 --- .../Sudoku-08-HumanStrategies-Python.ipynb | 130 ++++++++++++++++++ ...ku-18b-Statistical-Comparison-Python.ipynb | 78 +++++++++++ 2 files changed, 208 insertions(+) diff --git a/MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb b/MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb index e38c86a017..cd06b94b57 100644 --- a/MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb +++ b/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 : moins de 1 ms de déductions contre un millier d'appels d'essai-erreur." + ] + }, { "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", diff --git a/MyIA.AI.Notebooks/Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb b/MyIA.AI.Notebooks/Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb index b3c8df9c80..14605e8e55 100644 --- a/MyIA.AI.Notebooks/Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb +++ b/MyIA.AI.Notebooks/Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb @@ -181,6 +181,19 @@ "print(\"Un seul chronométrage n'est PAS une mesure fiable.\")" ] }, + { + "cell_type": "markdown", + "id": "cff52472", + "metadata": { + "papermill": {}, + "tags": [] + }, + "source": [ + "### Lire le bruit : 4 % de coefficient de variation, 1,2x entre les extrêmes\n", + "\n", + "Les trois chiffres de la sortie se complètent pour quantifier le bruit de mesure. **min=0,678 ms, max=0,832 ms** : deux chronos d'un même solveur déterministe sur un même puzzle s'écartent déjà de 22 % — le bruit vient du système et du processeur, pas de l'algorithme. **moyenne=0,726 ms, écart-type=0,029 ms** : le coefficient de variation qui s'affiche (4 %) est l'écart-type divisé par la moyenne, la métrique sans dimension qui permet de comparer ce niveau de bruit d'une mesure à l'autre, même quand les échelles changent. Enfin **ratio max/min = 1,2x** : même en prenant seulement deux extrêmes parmi 30, on ne peut pas prétendre à mieux qu'un ordre de grandeur grossier. La consigne du notebook est pédagogique : un seul chronométrage ne décrirait jamais ces trois faits — la répétition (30 runs) est ce qui transforme « le solveur prend 0,7 ms » en « le solveur prend entre 0,68 et 0,83 ms, avec un bruit de 4 % ». Gardez ce chiffre (1,2x) en tête : c'est le niveau de bruit que la section 4 devra faire dépasser à une vraie différence entre solveurs." + ] + }, { "cell_type": "markdown", "id": "cell-76f29524", @@ -301,6 +314,19 @@ "print(\" Les puzzles lents (queue) tirent la moyenne vers le haut.\")" ] }, + { + "cell_type": "markdown", + "id": "cbee70b4", + "metadata": { + "papermill": {}, + "tags": [] + }, + "source": [ + "### Lire le tableau : la difficulté nominale ne dit rien du temps\n", + "\n", + "Le tableau mesure huit puzzles au même nombre de clues (37), donc de même difficulté nominale — et les médianes affichées s'étalent de **0,273 ms (P4) à 2,800 ms (P3)**, soit un facteur **10** entre le plus rapide et le plus lent. C'est le chiffre clé de la section : la structure du puzzle (la position des clues, le nombre de cases forcées tôt dans la recherche) domine largement le nombre de clues. La deuxième lecture du tableau, plus subtile, vient de la colonne de droite : **rapport moy/méd ≈ 1,00-1,02 pour chaque puzzle**. Dans un même puzzle, moyenne et médiane coïncident presque (les 15 répétitions sont resserrées, la distribution intra-puzzle est symétrique) — alors que la sortie agrégée en bas de la même cellule affiche moyenne 1,187 ms pour médiane 0,800 ms sur le pool entier. Le contraste est la leçon : la moyenne ne ment que lorsqu'on mélange des puzzles de structures différentes ; à l'intérieur d'un puzzle, elle est un résumé fiable." + ] + }, { "cell_type": "markdown", "id": "cell-fa845acc", @@ -417,6 +443,19 @@ "print(\"qui dit l'incertitude. Doubler la taille d'échantillon réduit l'IC d'environ √2.\")" ] }, + { + "cell_type": "markdown", + "id": "9f831633", + "metadata": { + "papermill": {}, + "tags": [] + }, + "source": [ + "### Lire l'intervalle : trois chiffres qui disent l'incertitude\n", + "\n", + "La ligne centrale, `Intervalle de confiance à 95 % (bootstrap, 5000 tirages) = [1,027, 1,347] ms`, se lit comme suit : si l'on répétait la mesure, 95 fois sur 100 la vraie moyenne attendue tomberait dans cette plage. De la moyenne affichée au-dessus (1,187 ms), l'intervalle s'écarte de **-13,5 % à +13,5 %** — les deux bornes sont presque symétriques ici, mais le bootstrap ne l'a pas supposé : il a mesuré la forme réelle de la distribution. La largeur (0,321 ms, soit 27 % de la moyenne) joue le rôle d'une barre d'erreur que le point seul ne possède pas : « 1,2 ms » n'aurait pas dit si la vraie valeur pouvait être 1,0 ou 1,5 ms. La mention √2 de la sortie est la règle d'échantillonnage : doubler le nombre de mesures rétrécit l'intervalle d'environ 1/√2 ≈ 0,71 — c'est le rendement décroissant de l'échantillonnage, utile à l'étudiant pour dimensionner son propre benchmark." + ] + }, { "cell_type": "markdown", "id": "cell-e3c8e58e", @@ -556,6 +595,19 @@ "plt.show()\n" ] }, + { + "cell_type": "markdown", + "id": "1ba997c9", + "metadata": { + "papermill": {}, + "tags": [] + }, + "source": [ + "### Lire le test : huit paires, une p-value, un sens\n", + "\n", + "La sortie range les faits dans l'ordre du protocole. D'abord l'unité expérimentale : **n = 8** — pas 120, malgré les 15 répétitions — parce que chaque puzzle ne fournit qu'UNE paire de médianes. Puis les deux chiffres par solveur : **médiane des médianes 1,181 ms (naïf) contre 8,842 ms (MRV)**, et des moyennes 1,870 contre 8,807 — même image, moyenne et médiane proches, la distribution de MRV étant aussi resserrée que celle du naïf. La p-value affichée (7,81 × 10⁻³) est la plus petite valeur que Wilcoxon puisse produire pour n=8 (elle vaut exactement 2/2⁸, comme l'explique la section 5.1) : la différence passe donc le seuil de 5 %, mais sans marge. Le sens du résultat est l'intérêt pédagogique de la cellule : sur ces puzzles faciles, le MRV est **plus lent** — l'overhead de sélection du meilleur candidat coûte plus qu'il ne rapporte quand la recherche n'a presque aucun retour-arrière à épargner. On ne choisit pas un heuristique sur sa réputation, on le mesure — et on mesure dans un plan apparié." + ] + }, { "cell_type": "markdown", "id": "cell-1908be22", @@ -636,6 +688,19 @@ "print(\"c'est pourquoi on précise TOUJOURS le pool testé — ici 8 unités expérimentales.\")\n" ] }, + { + "cell_type": "markdown", + "id": "786c8717", + "metadata": { + "papermill": {}, + "tags": [] + }, + "source": [ + "### Lire la taille d'effet : un r parfait, un verdict borné\n", + "\n", + "La première ligne, `MRV est 7.5x plus lent que le naïf en médiane sur ce jeu de puzzles`, dit la taille d'effet dans l'unité des médianes (8,842 ÷ 1,181 ≈ 7,5). La seconde donne le coefficient apparié : **r = 1,000**, la valeur maximale du rank-bisérial — cela signifie que les 8 paires votent toutes dans le même sens : sur chacun des 8 puzzles pris séparément, sans exception, le naïf gagne. La note `|r| < 0,1 : négligeable ... > 0,5 : grand` ancre l'échelle : avec r = 1,0, la « significativité » de la section 4 n'est pas un artefact de puissance, c'est une séparation parfaite. Reste la borne que la sortie rappelle : ce verdict vaut pour un pool de puzzles faciles, posés en début de résolution — sur des puzzles difficiles, où le backtracking naïf explore des millions de nœuds, le rapport des temps s'inverse. La taille d'effet est donc à lire avec son cadre : 8 unités expérimentales, 37 clues, médianes de 15 répétitions." + ] + }, { "cell_type": "markdown", "id": "cell-2ad2dd63", @@ -746,6 +811,19 @@ "print(\"ici le test est déjà apparié et agrégé par puzzle ; les deux se cumulent.\")\n" ] }, + { + "cell_type": "markdown", + "id": "274bcb82", + "metadata": { + "papermill": {}, + "tags": [] + }, + "source": [ + "### Lire les trois comparaisons : une seule survit à Bonferroni\n", + "\n", + "Beaucoup de choses à voir dans le tableau, dans l'ordre des colonnes. **p-values brutes** : seule la paire naïf vs MRV est significative (7,81e-03) ; naïf vs reverse (6,41e-01) et MRV vs reverse (1,48e-01) ne le sont pas. **p corrigées** : la multiplication par 3 (Bonferroni) transforme 7,81e-03 en 2,34e-02 — toujours sous 0,05, donc le verdict « OUI » tient ; les deux autres restent très au-dessus. Le sens de la ligne reverse est essentiel : le solveur qui essaie les chiffres dans l'ordre inverse est statistiquement **indistinguable** du naïf sur ce pool — l'ordre de parcours des chiffres n'y change rien, ce qui confirme que la difficulté vient de la structure du puzzle, pas du choix lexical des valeurs. La dernière note de la sortie (multiplicité + indépendance) rappelle que la correction ne répare pas une pseudo-réplication : elle s'ajoute au test apparié, elle ne le remplace pas." + ] + }, { "cell_type": "markdown", "id": "cell-pseudoreplication", From 319f15f7e54d9e1339feef014bdb97078667d799 Mon Sep 17 00:00:00 2001 From: jsboige Date: Fri, 18 Sep 2026 04:43:25 +0200 Subject: [PATCH 2/6] fix(16398): rebaseline twin pair sudoku-08 after markdown-only density tranche MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pair attested: Sudoku-08 HumanStrategies. Sudoku-18b edited in the same tranche is not a twin pair member; verified markdown-only too. Paraphyte-preservant verification (python-compare vs origin/main): all code cells byte-identical (source + outputs + execution_count) — Sudoku-08 22/22, Sudoku-18b 9/9; changes are markdown-only additions (+10/+6 cells). Command run: python scripts/notebook_tools/check_twin_parity.py --update --pair "Sudoku-08 HumanStrategies" --by "myia-po-2026:CoursIA" Co-Authored-By: Claude Sonnet 5 --- .../0007-2026-09-18-myia-po-2026-CoursIA.yaml | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies/0007-2026-09-18-myia-po-2026-CoursIA.yaml diff --git a/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies/0007-2026-09-18-myia-po-2026-CoursIA.yaml b/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies/0007-2026-09-18-myia-po-2026-CoursIA.yaml new file mode 100644 index 0000000000..294c4c8096 --- /dev/null +++ b/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies/0007-2026-09-18-myia-po-2026-CoursIA.yaml @@ -0,0 +1,6 @@ +date: '2026-09-18' +by: myia-po-2026:CoursIA +python_sha: cd06b94b57cf4c78cd082f12ec1490e57b74ab10 +csharp_sha: 52f2308a75b2d73aaa3c6a330720d25cfd38f164 +content_python_sha: 82b77cb0eb2afe151d7118172aab8e574472d2b1c2a22c5a308e888c16a3331b +content_csharp_sha: 670cfa497b37661fc2e50f7918425fa5d4fe14b61682404a18e0477a93285fb9 From 59eea53865422234b5bfd99221eb3a4a9f2171e5 Mon Sep 17 00:00:00 2001 From: jsboige Date: Sat, 19 Sep 2026 03:54:07 +0200 Subject: [PATCH 3/6] =?UTF-8?q?fix(16398):=20known=5Fdifferences=20sudoku-?= =?UTF-8?q?08=20=E2=80=94=20recompte=2040=20md=20Python=20(levee=20ai-01?= =?UTF-8?q?=2004:26Z)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Le body annoncait la ligne known_differences documentant l'asymetrie markdown Python-only, mais le registre parent n'etait pas dans le diff (seul l'audit 0007 --update l'etait). Recompte au disque au head : Python 40 md / 22 code (base main : 30 md), C# 30 md / 19 code. Co-Authored-By: Claude Sonnet 5 --- .../notebook_tools/twin_pairs.d/sudoku-08-humanstrategies.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies.yaml b/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies.yaml index 1c01b0a17b..7857ba1827 100644 --- a/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies.yaml +++ b/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies.yaml @@ -8,4 +8,4 @@ known_differences: - "Socle pedagogique commun : strategies de resolution humaines (techniques d'inference -- naked/hidden singles, pointing pairs, box-line) appliquees au Sudoku, meme concept (simuler le raisonnement humain par couches d'inference successives plutot qu'un backtracking brut), meme arc pedagogique (theorie -> implementation -> benchmark)." - "Divergence d'implementation : le Python implemente les techniques d'inference from scratch + visualisation networkx du graphe de contraintes ; le C# implemente les memes strategies d'inference en stdlib avec un benchmark comparatif. Idiomes de visualisation differents (networkx cote Python)." - - "Asymetrie structurelle : Python 22 cellules code / 30 markdown ; C# 19 cellules code / 30 markdown. Arc identique (techniques d'inference + mesure de performance)." + - "Asymetrie structurelle : Python 22 cellules code / 40 markdown (recompte au disque apres la tranche densite #13410 : 30 -> 40 md, markdown-only) ; C# 19 cellules code / 30 markdown. Arc identique (techniques d'inference + mesure de performance)." From 6ede445644d95a67627558c4468f292529064872 Mon Sep 17 00:00:00 2001 From: jsboige Date: Sun, 20 Sep 2026 13:57:24 +0200 Subject: [PATCH 4/6] fix(sudoku,#13410): repair 2 false generalizations in Sudoku-08 lecture (retraction c.5749126592) Cell 170c545a closing line: "un millier d'appels" -> 545 cumulative calls (49 + 201 + 295, per committed output); "moins de 1 ms de deductions" -> bounded honestly 0.75 ms (P1) to 3.14 ms (P2), P3 at 2.16 ms. Markdown-only, execution counts and outputs byte-identical. Co-Authored-By: Claude Sonnet 5 --- MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb b/MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb index cd06b94b57..4d1d25d14e 100644 --- a/MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb +++ b/MyIA.AI.Notebooks/Sudoku/Sudoku-08-HumanStrategies-Python.ipynb @@ -1868,7 +1868,7 @@ "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 : moins de 1 ms de déductions contre un millier d'appels d'essai-erreur." + "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)." ] }, { From 8dde4ce552dc2301840f1bc66e03872f005ab854 Mon Sep 17 00:00:00 2001 From: jsboige Date: Sun, 20 Sep 2026 16:06:33 +0200 Subject: [PATCH 5/6] fix(sudoku,#16398): retirer les 4 conclusions paraphrasant les sorties (Sudoku-18b) Review adjointe 12:19Z : les cellules cff52472/9f831633/1ba997c9/786c8717 referment chacune leur analyse en repetant la lecon deja imprimee par la sortie precedente (fiabilite du chronometrage unique, reduction IC 1/sqrt2, overhead MRV, inversion sur puzzles difficiles). Nombres et ancres conserves, conclusions retirees. Code cells et outputs inchanges. Co-Authored-By: Claude Sonnet 5 --- .../Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/MyIA.AI.Notebooks/Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb b/MyIA.AI.Notebooks/Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb index 14605e8e55..3ca4ed766d 100644 --- a/MyIA.AI.Notebooks/Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb +++ b/MyIA.AI.Notebooks/Sudoku/Sudoku-18b-Statistical-Comparison-Python.ipynb @@ -191,7 +191,7 @@ "source": [ "### Lire le bruit : 4 % de coefficient de variation, 1,2x entre les extrêmes\n", "\n", - "Les trois chiffres de la sortie se complètent pour quantifier le bruit de mesure. **min=0,678 ms, max=0,832 ms** : deux chronos d'un même solveur déterministe sur un même puzzle s'écartent déjà de 22 % — le bruit vient du système et du processeur, pas de l'algorithme. **moyenne=0,726 ms, écart-type=0,029 ms** : le coefficient de variation qui s'affiche (4 %) est l'écart-type divisé par la moyenne, la métrique sans dimension qui permet de comparer ce niveau de bruit d'une mesure à l'autre, même quand les échelles changent. Enfin **ratio max/min = 1,2x** : même en prenant seulement deux extrêmes parmi 30, on ne peut pas prétendre à mieux qu'un ordre de grandeur grossier. La consigne du notebook est pédagogique : un seul chronométrage ne décrirait jamais ces trois faits — la répétition (30 runs) est ce qui transforme « le solveur prend 0,7 ms » en « le solveur prend entre 0,68 et 0,83 ms, avec un bruit de 4 % ». Gardez ce chiffre (1,2x) en tête : c'est le niveau de bruit que la section 4 devra faire dépasser à une vraie différence entre solveurs." + "Les trois chiffres de la sortie se complètent pour quantifier le bruit de mesure. **min=0,678 ms, max=0,832 ms** : deux chronos d'un même solveur déterministe sur un même puzzle s'écartent déjà de 22 % — le bruit vient du système et du processeur, pas de l'algorithme. **moyenne=0,726 ms, écart-type=0,029 ms** : le coefficient de variation qui s'affiche (4 %) est l'écart-type divisé par la moyenne, la métrique sans dimension qui permet de comparer ce niveau de bruit d'une mesure à l'autre, même quand les échelles changent. Enfin **ratio max/min = 1,2x** : même en prenant seulement deux extrêmes parmi 30, on ne peut pas prétendre à mieux qu'un ordre de grandeur grossier. Gardez ce chiffre (1,2x) en tête : c'est le niveau de bruit que la section 4 devra faire dépasser à une vraie différence entre solveurs." ] }, { @@ -453,7 +453,7 @@ "source": [ "### Lire l'intervalle : trois chiffres qui disent l'incertitude\n", "\n", - "La ligne centrale, `Intervalle de confiance à 95 % (bootstrap, 5000 tirages) = [1,027, 1,347] ms`, se lit comme suit : si l'on répétait la mesure, 95 fois sur 100 la vraie moyenne attendue tomberait dans cette plage. De la moyenne affichée au-dessus (1,187 ms), l'intervalle s'écarte de **-13,5 % à +13,5 %** — les deux bornes sont presque symétriques ici, mais le bootstrap ne l'a pas supposé : il a mesuré la forme réelle de la distribution. La largeur (0,321 ms, soit 27 % de la moyenne) joue le rôle d'une barre d'erreur que le point seul ne possède pas : « 1,2 ms » n'aurait pas dit si la vraie valeur pouvait être 1,0 ou 1,5 ms. La mention √2 de la sortie est la règle d'échantillonnage : doubler le nombre de mesures rétrécit l'intervalle d'environ 1/√2 ≈ 0,71 — c'est le rendement décroissant de l'échantillonnage, utile à l'étudiant pour dimensionner son propre benchmark." + "La ligne centrale, `Intervalle de confiance à 95 % (bootstrap, 5000 tirages) = [1,027, 1,347] ms`, se lit comme suit : si l'on répétait la mesure, 95 fois sur 100 la vraie moyenne attendue tomberait dans cette plage. De la moyenne affichée au-dessus (1,187 ms), l'intervalle s'écarte de **-13,5 % à +13,5 %** — les deux bornes sont presque symétriques ici, mais le bootstrap ne l'a pas supposé : il a mesuré la forme réelle de la distribution. La largeur (0,321 ms, soit 27 % de la moyenne) joue le rôle d'une barre d'erreur que le point seul ne possède pas : « 1,2 ms » n'aurait pas dit si la vraie valeur pouvait être 1,0 ou 1,5 ms." ] }, { @@ -605,7 +605,7 @@ "source": [ "### Lire le test : huit paires, une p-value, un sens\n", "\n", - "La sortie range les faits dans l'ordre du protocole. D'abord l'unité expérimentale : **n = 8** — pas 120, malgré les 15 répétitions — parce que chaque puzzle ne fournit qu'UNE paire de médianes. Puis les deux chiffres par solveur : **médiane des médianes 1,181 ms (naïf) contre 8,842 ms (MRV)**, et des moyennes 1,870 contre 8,807 — même image, moyenne et médiane proches, la distribution de MRV étant aussi resserrée que celle du naïf. La p-value affichée (7,81 × 10⁻³) est la plus petite valeur que Wilcoxon puisse produire pour n=8 (elle vaut exactement 2/2⁸, comme l'explique la section 5.1) : la différence passe donc le seuil de 5 %, mais sans marge. Le sens du résultat est l'intérêt pédagogique de la cellule : sur ces puzzles faciles, le MRV est **plus lent** — l'overhead de sélection du meilleur candidat coûte plus qu'il ne rapporte quand la recherche n'a presque aucun retour-arrière à épargner. On ne choisit pas un heuristique sur sa réputation, on le mesure — et on mesure dans un plan apparié." + "La sortie range les faits dans l'ordre du protocole. D'abord l'unité expérimentale : **n = 8** — pas 120, malgré les 15 répétitions — parce que chaque puzzle ne fournit qu'UNE paire de médianes. Puis les deux chiffres par solveur : **médiane des médianes 1,181 ms (naïf) contre 8,842 ms (MRV)**, et des moyennes 1,870 contre 8,807 — même image, moyenne et médiane proches, la distribution de MRV étant aussi resserrée que celle du naïf. La p-value affichée (7,81 × 10⁻³) est la plus petite valeur que Wilcoxon puisse produire pour n=8 (elle vaut exactement 2/2⁸, comme l'explique la section 5.1) : la différence passe donc le seuil de 5 %, mais sans marge." ] }, { @@ -698,7 +698,7 @@ "source": [ "### Lire la taille d'effet : un r parfait, un verdict borné\n", "\n", - "La première ligne, `MRV est 7.5x plus lent que le naïf en médiane sur ce jeu de puzzles`, dit la taille d'effet dans l'unité des médianes (8,842 ÷ 1,181 ≈ 7,5). La seconde donne le coefficient apparié : **r = 1,000**, la valeur maximale du rank-bisérial — cela signifie que les 8 paires votent toutes dans le même sens : sur chacun des 8 puzzles pris séparément, sans exception, le naïf gagne. La note `|r| < 0,1 : négligeable ... > 0,5 : grand` ancre l'échelle : avec r = 1,0, la « significativité » de la section 4 n'est pas un artefact de puissance, c'est une séparation parfaite. Reste la borne que la sortie rappelle : ce verdict vaut pour un pool de puzzles faciles, posés en début de résolution — sur des puzzles difficiles, où le backtracking naïf explore des millions de nœuds, le rapport des temps s'inverse. La taille d'effet est donc à lire avec son cadre : 8 unités expérimentales, 37 clues, médianes de 15 répétitions." + "La première ligne, `MRV est 7.5x plus lent que le naïf en médiane sur ce jeu de puzzles`, dit la taille d'effet dans l'unité des médianes (8,842 ÷ 1,181 ≈ 7,5). La seconde donne le coefficient apparié : **r = 1,000**, la valeur maximale du rank-bisérial — cela signifie que les 8 paires votent toutes dans le même sens : sur chacun des 8 puzzles pris séparément, sans exception, le naïf gagne. La note `|r| < 0,1 : négligeable ... > 0,5 : grand` ancre l'échelle : avec r = 1,0, la « significativité » de la section 4 n'est pas un artefact de puissance, c'est une séparation parfaite." ] }, { From b512faa1f2043fad7e7db81e35e43e9721344da0 Mon Sep 17 00:00:00 2001 From: jsboige Date: Sun, 20 Sep 2026 16:07:04 +0200 Subject: [PATCH 6/6] chore(twin,#16398): re-attester Sudoku-08 HumanStrategies au blob courant (0008) Derniere operation apres le fix markdown Sudoku-18b : l'attestation 0007 portait le blob Python cd06b94b du head precedent, le blob courant est 4d1d25d1 (commit 6ede44564). Voir #8057. Co-Authored-By: Claude Sonnet 5 --- .../0008-2026-09-20-myia-po-2026-CoursIA.yaml | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies/0008-2026-09-20-myia-po-2026-CoursIA.yaml diff --git a/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies/0008-2026-09-20-myia-po-2026-CoursIA.yaml b/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies/0008-2026-09-20-myia-po-2026-CoursIA.yaml new file mode 100644 index 0000000000..e27ccd7a8e --- /dev/null +++ b/scripts/notebook_tools/twin_pairs.d/sudoku-08-humanstrategies/0008-2026-09-20-myia-po-2026-CoursIA.yaml @@ -0,0 +1,6 @@ +date: '2026-09-20' +by: myia-po-2026:CoursIA +python_sha: 4d1d25d14effbcfc5059b0651871b89d43bf4b7e +csharp_sha: 52f2308a75b2d73aaa3c6a330720d25cfd38f164 +content_python_sha: a1296853faf0ffc6bee56ffcb423a47c1c6697db71d092b31c62839d3cfca8a8 +content_csharp_sha: 670cfa497b37661fc2e50f7918425fa5d4fe14b61682404a18e0477a93285fb9