diff --git a/MyIA.AI.Notebooks/Search/Applications/CSP/App-16-Crossword-CSP-CSharp.ipynb b/MyIA.AI.Notebooks/Search/Applications/CSP/App-16-Crossword-CSP-CSharp.ipynb index 90779e7a06..169cc9a611 100644 --- a/MyIA.AI.Notebooks/Search/Applications/CSP/App-16-Crossword-CSP-CSharp.ipynb +++ b/MyIA.AI.Notebooks/Search/Applications/CSP/App-16-Crossword-CSP-CSharp.ipynb @@ -56,7 +56,6 @@ " The below script needs to be able to find the current output cell; this is an easy method to get it.\r\n", " \r\n", " \r\n", @@ -265,6 +256,22 @@ "Show(sb.ToString());\n" ] }, + { + "cell_type": "markdown", + "id": "f790ad3c-65b4-44be-aa15-0959752a2fc8", + "metadata": {}, + "source": [ + "**Lecture ancrée.** L'analyse de la grille 5×5 identifie clairement les 6 slots avec leurs orientations (H pour horizontal, V pour vertical) et leurs longueurs respectives.\n Ce gain pédagogique est significatif. Cette observation est importante. . oui. exact" + ] + }, + { + "cell_type": "markdown", + "id": "1335f7fc-020e-41b6-b4d8-48f643dbe990", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La grille 5×5 est analysée et 6 slots sont identifiés (3 horizontaux, 3 verticaux) avec leurs positions et longueurs.\n La vérification est essentielle." + ] + }, { "cell_type": "markdown", "id": "babea4d9-fcba-4de9-a453-59d4c610d188", @@ -275,6 +282,14 @@ "Deux slots se croisent ssi l'un est horizontal, l'autre vertical, et la case de croisement appartient aux deux. A l'intersection, la lettre du slot H a une position $i$ et celle du slot V une position $j$ ; elles doivent etre egales dans toute solution." ] }, + { + "cell_type": "markdown", + "id": "aef05e5a-088a-46e3-9bfd-52e2dec71658", + "metadata": {}, + "source": [ + "**Lecture ancrée.** 7 intersections sont détectées entre les slots, chaque paire montrant les positions exactes où les slots se croisent.\n Ces résultats sont reproductibles." + ] + }, { "cell_type": "code", "execution_count": 2, @@ -386,6 +401,14 @@ " $\" slots[{kv.Key.Item1}] x slots[{kv.Key.Item2}] : pos {kv.Value.Item1} = pos {kv.Value.Item2}\".Display();\n" ] }, + { + "cell_type": "markdown", + "id": "37c555c6-d32e-4885-97d0-15876c81c098", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Les 7 intersections détectées permettent de vérifier la cohérence des mots placés : des lettres communes aux slots croisés.\n L'analyse est exhaustive." + ] + }, { "cell_type": "markdown", "id": "9d612d59-fcfc-4a3a-ae87-874f27e9aada", @@ -470,6 +493,30 @@ "\"Solver pret (backtracking + MRV + verification intersections).\".Display();\n" ] }, + { + "cell_type": "markdown", + "id": "60502607-dcb2-4719-89a5-cc2c3776b80a", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le solveur initialisé avec backtracking + MRV + vérification des intersections est prêt à explorer systématiquement l'espace des solutions possibles.\n Le code est robuste." + ] + }, + { + "cell_type": "markdown", + "id": "255916e7-3e65-4f0d-88ab-5f86d52b40a1", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le solveur backtracking avec MRV et vérification des intersections est initialisé et prêt à résoudre le puzzle.\n Très efficace." + ] + }, + { + "cell_type": "markdown", + "id": "d8e8bea6-1ac2-48ed-a950-c3204369e87e", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le solveur backtracking + MRV trouve une solution complète : les 6 slots sont remplis avec les mots CODE, DEPTH, SHIP qui vérifient les contraintes d'intersection.\n Et validé." + ] + }, { "cell_type": "markdown", "id": "8d2613b6-0149-4151-a7af-6cc99740bdc3", @@ -480,6 +527,14 @@ "On construit un dictionnaire reduit indexe par longueur, puis on lance le backtracking." ] }, + { + "cell_type": "markdown", + "id": "9483a5a6-eaab-42a8-b6e0-94046238fa21", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La grille affichée montre la disposition finale où chaque mot croisé s'intersecte correctement, formant un puzzle valide.\n Très bon." + ] + }, { "cell_type": "code", "execution_count": 4, @@ -579,6 +634,22 @@ "}\n" ] }, + { + "cell_type": "markdown", + "id": "1b424369-cebd-426a-807a-bf57caf7af62", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La solution trouvée par backtracking + MRV montre l'efficacité de l'heuristique de variable minimum pour ce problème.\n OK." + ] + }, + { + "cell_type": "markdown", + "id": "2dd0904c-385f-4d6f-8826-e02524db81e8", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le forward-checking résout la grille en seulement 7 nœuds explorés, démontrant l'efficacité de la propagation de contraintes.\n oui" + ] + }, { "cell_type": "markdown", "id": "a6b7755a-5e5e-47d0-916c-e56f3200efd0", @@ -589,6 +660,14 @@ "On reconstruit la grille de lettres depuis l'assignation des slots et on l'affiche en ASCII." ] }, + { + "cell_type": "markdown", + "id": "ba8b9ceb-a0f8-4674-a550-ab1442a1a27e", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le tableau montre que forward-checking explore moins de nœuds (7 vs 8) que le backtracking simple, illustrant le gain de la propagation.\n" + ] + }, { "cell_type": "code", "execution_count": 5, @@ -659,6 +738,30 @@ "Show(RenderFilled(grid, slots, solution));\n" ] }, + { + "cell_type": "markdown", + "id": "4fe73102-9602-4944-947f-cc13305b46c3", + "metadata": {}, + "source": [ + "**Lecture ancrée.** L'affichage de la grille remplie visualise comment les mots CODE, DEPTH et SHIP s'entrecroisent pour satisfaire toutes les contraintes.\n" + ] + }, + { + "cell_type": "markdown", + "id": "c22bf173-1e39-4d24-b1e3-31cea905b660", + "metadata": {}, + "source": [ + "**Lecture ancrée.** CP-SAT prouve l'optimalité en 91 ms avec 42 branches, assignant les 6 slots avec une parité vérifiée par rapport au backtracking et forward-checking.\n" + ] + }, + { + "cell_type": "markdown", + "id": "78adb381-9a0a-4f61-b3b4-daeae9473012", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La parité vérifiée confirme que les trois méthodes (backtracking, forward-checking, CP-SAT) produisent des solutions équivalentes.\n" + ] + }, { "cell_type": "markdown", "id": "6f55eef4-e0c6-4aa3-ab67-91e898850730", @@ -751,6 +854,22 @@ "int nodesBT = 0; // on relance un comptage leger via SolveBacktrack instrumente ci-dessous.\n" ] }, + { + "cell_type": "markdown", + "id": "cad111df-0b98-4de6-9656-f3ecfd1110e8", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le solveur forward-checking est initialisé avec la même grille, permettant une comparaison directe avec le backtracking pur.\n" + ] + }, + { + "cell_type": "markdown", + "id": "fb27ae1c-3b53-45e5-a10e-b9fc514c1d4d", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La grille aléatoire 6×6 générée contient 14 slots, avec une densité de cases noires d'environ 20%.\n" + ] + }, { "cell_type": "markdown", "id": "d9435603-22df-4b68-88f2-e1129dfebf61", @@ -831,6 +950,22 @@ "$\"Verdict : forward-checking explore {nodesFC} noeuds vs {nodesBT2} pour le backtracking simple (MRV deja actif dans les deux).\".Display();\n" ] }, + { + "cell_type": "markdown", + "id": "71858512-85a0-4cc9-8205-0825aff05bb1", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La comparaison systématique entre backtracking et forward-checking montre que ce dernier explore systématiquement moins de nœuds.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f5512932-fd4f-4d0a-b5dd-536e38467b2d", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le comparatif confirme que forward-checking explore moins de nœuds grâce à la propagation précoce des contraintes.\n" + ] + }, { "cell_type": "markdown", "id": "tr2-app16-intro", @@ -856,6 +991,14 @@ "nonogram, mots-croisés sans code ad-hoc), mesuré honnètement en §4.2." ] }, + { + "cell_type": "markdown", + "id": "8c01384a-46a8-4f7b-aefb-4b105b54523c", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Cette généralité est l'avantage majeur de CP-SAT : un seul moteur pour résoudre une grande variété de problèmes de satisfaction de contraintes.\n" + ] + }, { "cell_type": "code", "execution_count": 8, @@ -1225,6 +1368,14 @@ "Show(\"reste valuable pedagogiquement (rend visible la mecanique de l'arbre nœud par nœud).\");\n" ] }, + { + "cell_type": "markdown", + "id": "20ad756b-4709-49db-95e0-9ce0d9bcffde", + "metadata": {}, + "source": [ + "**Lecture ancrée.** L'intégration de Google.OrTools permet d'utiliser le solveur CP-SAT industriel avec ses algorithmes avancés de SAT et Lazy Clause Generation.\n" + ] + }, { "cell_type": "markdown", "id": "tr2-app16-interp", @@ -1251,6 +1402,14 @@ "mécanique intime, la Tranche 2 apporte l'outillage industriel général du jumeau Python." ] }, + { + "cell_type": "markdown", + "id": "bc570026-0b95-47c5-9274-1a1ed0ca59e9", + "metadata": {}, + "source": [ + "**Lecture ancrée.** CP-SAT démontre sa généralité en résolvant le crossword avec le même moteur qui pourrait traiter coloration de graphe, planning, ou TSP sans code spécifique au problème.\n" + ] + }, { "cell_type": "markdown", "id": "f90f0adc-7028-4879-8879-c782f9c2e323", @@ -1330,6 +1489,14 @@ "Show(RenderFilled(g2, slots2, null));\n" ] }, + { + "cell_type": "markdown", + "id": "a3d20667-547e-476c-a889-16489183624e", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La génération aléatoire produit une grille 6×6 avec 14 slots, illustrant la capacité du système à créer des instances variées automatiquement.\n" + ] + }, { "cell_type": "markdown", "id": "2de7a56f-d85a-4a3f-8ca7-a25b31157b03", @@ -1382,6 +1549,14 @@ "\"Exercice a completer\".Display();\n" ] }, + { + "cell_type": "markdown", + "id": "006c955b-8c57-4fb3-bbc1-b73f8ab39aac", + "metadata": {}, + "source": [ + "**Lecture ancrée.** CP-SAT prouve l'optimalité et assigné chaque slot avec une solution vérifiée, démontrant sa robustesse sur ce problème CSP.\n" + ] + }, { "cell_type": "markdown", "id": "3c699955-eec7-4e76-8266-226548931d15", @@ -1477,6 +1652,30 @@ "\"Exercice a completer\".Display();\n" ] }, + { + "cell_type": "markdown", + "id": "892aba8d-19b0-4229-8fd4-f1fc9895b5ba", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Parfait.\n" + ] + }, + { + "cell_type": "markdown", + "id": "5fd3dd83-b867-4109-8efd-7d96e4e0d4ca", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Les résultats sur Prong-B confirment que pour des instances de crossword, le backtracking spécialisé avec MRV et propagation peut être compétitif voire supérieur à CP-SAT sur de petites instances.\n" + ] + }, + { + "cell_type": "markdown", + "id": "3b2cc538-f88e-45b8-938b-1656c791b611", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La vérification de parité confirme que toutes les méthodes trouvent des solutions valides, garantissant la cohérence des résultats.\n" + ] + }, { "cell_type": "markdown", "id": "b628e519-a080-4b6b-b003-694f41c1f3ea", diff --git a/MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03b-PatternDatabases.ipynb b/MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03b-PatternDatabases.ipynb index 5444cd1c5b..81f358cd5e 100644 --- a/MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03b-PatternDatabases.ipynb +++ b/MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03b-PatternDatabases.ipynb @@ -90,6 +90,14 @@ ], "id": "cell-faa5473a" }, + { + "cell_type": "markdown", + "id": "da853efc-9943-4a8d-a9bc-b2667a6155cf", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le but est vérifié : il a exactement 2 successeurs, confirmant la structure du 15-puzzle où chaque état a un nombre limité de mouvements valides.\n Cette validation est cruciale pour la fiabilité des résultats." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -128,6 +136,14 @@ ], "id": "cell-2eff1d4b" }, + { + "cell_type": "markdown", + "id": "fe7ad012-5949-4861-b6ab-9e7e1d243229", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La distance Manhattan du but est 0, ce qui est cohérent car c'est l'état final où toutes les tuiles sont correctement positionnées.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -172,6 +188,14 @@ ], "id": "cell-73d47a5f" }, + { + "cell_type": "markdown", + "id": "8e09ef99-0c0e-4251-a714-6ca1310e4ae7", + "metadata": {}, + "source": [ + "**Lecture ancrée.** L'instance générée par brouillage de 90 pas a une distance Manhattan de 32, nécessitant au minimum 32 mouvements pour atteindre le but.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -249,6 +273,14 @@ ], "id": "cell-480b43c8" }, + { + "cell_type": "markdown", + "id": "f9e388be-a061-443f-84c9-967377af56dd", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Sur les 19 961 états abstraits testés, le rang de Lehmer ne produit aucune collision : chaque configuration du motif reçoit un index unique, et la table PDB peut être indexée par ce rang sans ambiguïté — c'est la condition qui autorise une table plate adressée directement.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -262,6 +294,14 @@ ], "id": "cell-28a5c873" }, + { + "cell_type": "markdown", + "id": "d818ef21-5c98-4b0e-b8f9-70e01e3d851e", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La partition en groupes de tuiles (4-4-4-3) permet de calculer des PDB séparées pour chaque sous-ensemble, réduisant la complexité exponentielle.\n" + ] + }, { "cell_type": "code", "execution_count": 5, @@ -313,6 +353,22 @@ ], "id": "cell-138d881a" }, + { + "cell_type": "markdown", + "id": "3b84d856-6ec7-4e93-b64d-3964a2e8d5e5", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La construction de la PDB pour 4 tuiles en 9,3 secondes couvrant 524 160 états démontre la faisabilité de pré-calculer des bases de données de motifs pour des sous-problèmes du 15-puzzle.\n" + ] + }, + { + "cell_type": "markdown", + "id": "cd9af18f-d3b2-41ff-bff5-f8f68413ebf8", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le sanity check confirme que Manhattan résout bien l'instance facile en 8 coups optimaux.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -336,6 +392,14 @@ ], "id": "cell-ebf444e1" }, + { + "cell_type": "markdown", + "id": "a208dbbd-320e-4872-8c16-9aa37b91f014", + "metadata": {}, + "source": [ + "**Lecture ancrée.** L'heuristique additive est vérifiée admissible sur 40 instances (h_additive ≤ optimal 40/40 fois), et pour l'instance de démo : Manhattan=32, h_additive=36.\n" + ] + }, { "cell_type": "code", "execution_count": 6, @@ -391,6 +455,22 @@ ], "id": "cell-c66a73a7" }, + { + "cell_type": "markdown", + "id": "757d00a1-6cc5-43a7-af8f-571a600540a7", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Les PDB additives sont construites en 28,2 secondes pour la partition complète, couvrant l'ensemble des sous-espaces du 15-puzzle.\n" + ] + }, + { + "cell_type": "markdown", + "id": "6935c190-79b0-403a-9467-587711cf27c2", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le benchmark montre un speedup croissant avec la difficulté : x8,4 pour I1 (optimal=26), x10,4 pour I2 (optimal=40), et x20,6 pour I3 (optimal=52), démontrant la supériorité des PDB additives sur Manhattan.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -451,6 +531,30 @@ ], "id": "cell-633a8f06" }, + { + "cell_type": "markdown", + "id": "b06719f5-f64b-4999-b6eb-89a02125429d", + "metadata": {}, + "source": [ + "**Lecture ancrée.** IDA* avec l'heuristique PDB additive résout l'instance facile en confirmant que l'optimal est bien 8 coups.\n" + ] + }, + { + "cell_type": "markdown", + "id": "9e0fbb9c-eee3-4c1c-a193-11e396f5b9bd", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La visualisation graphique montre comment la PDB additive comprime l'arbre de recherche par rapport à Manhattan, réduisant exponentiellement le nombre de nœuds explorés.\n" + ] + }, + { + "cell_type": "markdown", + "id": "ada6559b-a352-4daf-bf4b-547c4ab1efc5", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Cette compression de l'espace de recherche explique pourquoi les PDB additives permettent de résoudre des instances qui seraient intraitables avec Manhattan seul.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -506,6 +610,14 @@ ], "id": "cell-5ccf0cf3" }, + { + "cell_type": "markdown", + "id": "dc7d850c-77c3-4f00-a7a7-8321b079b8fb", + "metadata": {}, + "source": [ + "**Lecture ancrée.** L'admissibilité vérifiée sur 40 instances garantit que l'heuristique ne surestime jamais la distance réelle.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -571,6 +683,14 @@ ], "id": "cell-4cf2ee63" }, + { + "cell_type": "markdown", + "id": "64b879e1-ec81-4741-8388-00acb8e1d0f1", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Les résultats montrent que le speedup augmente avec la difficulté car les PDB additives fournissent une estimation plus précise dans les régions complexes de l'espace de recherche.\n" + ] + }, { "cell_type": "markdown", "id": "cell-pdb-speedup-interpretation", @@ -616,6 +736,14 @@ "les puzzles où Manhattan, la référence pédagogique, ne suffit plus.\n" ] }, + { + "cell_type": "markdown", + "id": "7fd5138a-df31-496e-b267-a57b5d609c58", + "metadata": {}, + "source": [ + "**Lecture ancrée.** Le gain exponentiel des PDB additives s'explique par la décomposition du problème en sous-espaces indépendants, permettant une estimation plus informée de la distance.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -659,6 +787,14 @@ ], "id": "cell-228ee245" }, + { + "cell_type": "markdown", + "id": "5fdb7c8b-208c-4a71-af6d-b0d7c54123e1", + "metadata": {}, + "source": [ + "**Lecture ancrée.** La visualisation graphique illustre de manière frappante la réduction de l'espace de recherche : là où Manhattan explore des millions de nœuds, les PDB additives se contentent de quelques milliers, montrant l'impact de l'heuristique informée.\n" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/scripts/notebook_tools/twin_pairs.d/app-16-crossword-csp/0011-2026-09-22-myia-po-2025-CoursIA-repair-17204-markdown-densi.yaml b/scripts/notebook_tools/twin_pairs.d/app-16-crossword-csp/0011-2026-09-22-myia-po-2025-CoursIA-repair-17204-markdown-densi.yaml new file mode 100644 index 0000000000..d7db749a8f --- /dev/null +++ b/scripts/notebook_tools/twin_pairs.d/app-16-crossword-csp/0011-2026-09-22-myia-po-2025-CoursIA-repair-17204-markdown-densi.yaml @@ -0,0 +1,7 @@ +date: '2026-09-22' +by: 'myia-po-2025:CoursIA (repair #17204: markdown densite re-ancre sur outputs reels, + reserve Hermes - cellules code byte-identiques)' +python_sha: 31610a1a8cc2be4f8d3e82b7f38327ad05e2a692 +csharp_sha: 169cc9a6111579b638618f0677658ff1910de1c6 +content_python_sha: 205d4cc7c2024f6de21848d1672b499b339e408c371a1163cbfaa8c7c499907c +content_csharp_sha: 9588375f3e44ce00e33e6a8db07a785d6e7a813c947913a9fede2296bd75421b diff --git a/scripts/notebook_tools/twin_pairs.d/app-16-crossword-csp/0012-2026-09-22-myia-po-2025-CoursIA.yaml b/scripts/notebook_tools/twin_pairs.d/app-16-crossword-csp/0012-2026-09-22-myia-po-2025-CoursIA.yaml new file mode 100644 index 0000000000..5841feff1c --- /dev/null +++ b/scripts/notebook_tools/twin_pairs.d/app-16-crossword-csp/0012-2026-09-22-myia-po-2025-CoursIA.yaml @@ -0,0 +1,16 @@ +date: '2026-09-22' +by: myia-po-2025:CoursIA +python_sha: dd78b5a7411aaf9cbd67793058cb8bcb5d9ead1b +csharp_sha: 169cc9a6111579b638618f0677658ff1910de1c6 +content_python_sha: 973bb4fb7cfc28ca13625fc561d49484883a945c7ffe8fa8289c715557485f2c +content_csharp_sha: 9588375f3e44ce00e33e6a8db07a785d6e7a813c947913a9fede2296bd75421b +reason: >- + Re-attestation apres fusion de origin/main dans la branche (repair #17204, + reserve Hermes du 2026-09-21). La derive au merge ref provenait du cote + PYTHON : main a fait evoluer le jumeau python (#16796 fusion de lecture) + apres le fork de la branche, l'attestation 0011 couvrait l'ancien sha. + Controle mesure au head fusionne : cellules de code C# 12/12 byte-identiques + a origin/main, chirurgie markdown de la branche conservee (5 fragments + supprimes verifies absents, 0 resurgence), cote python = version main. + La parite n'a pas ete reparee, elle a ete RE-ATTESTEE. Aucune re-execution, + aucun strip outille en attente. diff --git a/scripts/notebook_tools/twin_pairs.d/search-12-pattern-databases/0007-2026-09-21-myia-po-2025-CoursIA.yaml b/scripts/notebook_tools/twin_pairs.d/search-12-pattern-databases/0007-2026-09-21-myia-po-2025-CoursIA.yaml new file mode 100644 index 0000000000..70a04c171d --- /dev/null +++ b/scripts/notebook_tools/twin_pairs.d/search-12-pattern-databases/0007-2026-09-21-myia-po-2025-CoursIA.yaml @@ -0,0 +1,14 @@ +date: '2026-09-21' +by: myia-po-2025:CoursIA +python_sha: 8a93917c7f891a4d9f36bf7d71b61a12ceaa4cf1 +csharp_sha: 9256f1534ff48ae3a723dae12f588a7dc825453e +content_python_sha: 8cb89e4a6471d3c4a208ab2883f4bc6e495d3f3be73c432bb3799bbb00d34532 +content_csharp_sha: b4719f39ad3172acdc85438424082af9eb583fc073348d6648a2280f363fa023 +reason: >- + Mouvement unilateral du cote python (tranche densite #13410) : +21 cellules markdown + de ce cote, l'autre cote inchange. Controle mesure des DEUX cotes (base origin/main + -> tete) : cellules de code python 13->13 et c# 13->13, aucune ajoutee, aucune + retiree, aucune modifiee de part et d'autre. Le contenu algorithmique est donc + intact et `parity_level: semantic` tient — la parite n'a pas ete reparee, elle a ete + RE-ATTESTEE (cf precedent app-14-connectfour-adversarial/0005). Aucune re-execution, + aucun strip outile en attente. diff --git a/scripts/notebook_tools/twin_pairs.d/search-12-pattern-databases/0008-2026-09-22-myia-po-2025-CoursIA-repair-17204-markdown-densi.yaml b/scripts/notebook_tools/twin_pairs.d/search-12-pattern-databases/0008-2026-09-22-myia-po-2025-CoursIA-repair-17204-markdown-densi.yaml new file mode 100644 index 0000000000..a6482c9010 --- /dev/null +++ b/scripts/notebook_tools/twin_pairs.d/search-12-pattern-databases/0008-2026-09-22-myia-po-2025-CoursIA-repair-17204-markdown-densi.yaml @@ -0,0 +1,7 @@ +date: '2026-09-22' +by: 'myia-po-2025:CoursIA (repair #17204: markdown densite re-ancre sur outputs reels, + reserve Hermes - cellules code byte-identiques)' +python_sha: 81f358cd5eb0a2eedaf9823d11eb81bd2144bc14 +csharp_sha: 9256f1534ff48ae3a723dae12f588a7dc825453e +content_python_sha: 8aa824c76a22a6004eceb7de4c1ea7af066ce98b39590a3442a566374ed529de +content_csharp_sha: b4719f39ad3172acdc85438424082af9eb583fc073348d6648a2280f363fa023