enrich(search,#13410): densite g82-search-7 — 12 lectures ancrees (App-1b-NQueens, Search-03d-WeightedAstar)

MyIA.AI.Notebooks/Search/Applications/CSP/App-1b-NQueens-CSharp.ipynb

@@ -89,7 +89,6 @@
        "        The below script needs to be able to find the current output cell; this is an easy method to get it.\r\n",
        "    </div>\r\n",
        "    <script type='text/javascript'>\r\n",
-
        "    function timeout(ms, promise) {\r\n",
        "        return new Promise(function (resolve, reject) {\r\n",
        "            setTimeout(function () {\r\n",
@@ -99,10 +98,7 @@
        "        })\r\n",
        "    }\r\n",
        "\r\n",
-
-
        "\r\n",
-
        "\r\n",
        "            if (!rootUrl.endsWith('/')) {\r\n",
        "                rootUrl = `${rootUrl}/`;\r\n",
@@ -117,7 +113,6 @@
        "                    headers: {\r\n",
        "                        'Content-Type': 'text/plain'\r\n",
        "                    },\r\n",
-
        "                }));\r\n",
        "\r\n",
        "                if (response.status == 200) {\r\n",
@@ -129,8 +124,6 @@
        "    }\r\n",
        "}\r\n",
        "\r\n",
-
-
        "        .then((root) => {\r\n",
        "        // use probing to find host url and api resources\r\n",
        "        // load interactive helpers and language services\r\n",
@@ -179,13 +172,11 @@
        "    \r\n",
        "    \r\n",
        "    require_script.onload = function() {\r\n",
-
        "    };\r\n",
        "\r\n",
        "    document.getElementsByTagName('head')[0].appendChild(require_script);\r\n",
        "}\r\n",
        "else {\r\n",
-
        "}\r\n",
        "\r\n",
        "    </script>\r\n",
@@ -231,6 +222,14 @@
     "Show(\"Setup OK — représentation queens[col]=row, helper IsSafe défini.\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "bcf3b7ee-b076-4e6c-aa9c-a41f07a85292",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** Le « Setup OK » acte un choix d'encodage structurant : le plateau est un tableau 1D `queens[col] = row` — une valeur par colonne rend les conflits de colonne **impossibles par construction**, et `IsSafe` ne vérifie plus que lignes et diagonales. L'encodage a déjà tué un tiers des contraintes avant que la recherche ne commence."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "b3206d27-1ad7-4b13-8572-7903925e53dc",
@@ -337,6 +336,14 @@
     "Show(BoardString(q));\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "9d1a6397-c89a-4bb4-b640-3bfa17a2d566",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** Le backtracking simple explore **113 nœuds** avant sa première solution N=8 — l'arbre vivant encore des branches entières qu'une reine en colonne 2 condamne déjà. La grille affichée est la première solution dans l'ordre lexicographique du balayage colonne par colonne, ligne par ligne."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "aaf2df63-f1f5-453f-88de-5508e50ba2e0",
@@ -421,6 +428,14 @@
     "Show(\"Backtracking MRV, N = \" + n + \" -> \" + FI(_mrvNodes) + \" nœuds explorés (vs simple ci-dessus).\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "79e36142-3e91-4353-9dce-a19898825558",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** MRV divise l'arbre par deux d'un seul geste (**52 nœuds** contre 113) : au lieu de remplir les colonnes de gauche à droite, il place toujours la reine dans la colonne **la plus contrainte** — traiter d'abord ce qui va mal découvre les impasses tôt, quand il reste encore de la place pour les contourner."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "5ed56bf7-b226-4402-b72c-59290601c103",
@@ -533,6 +548,14 @@
     "Show(BoardString(q));\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "00ba196e-63e4-4c1e-b116-a1f8b228e3cb",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** Forward-Checking clôt la série à **51 nœuds** contre 52 pour MRV et 113 pour le simple : chaque placement ampute les domaines futurs, et les colonnes sans candidat coupent la branche sans exploration. Noter la grille : **identique** à celle du simple — les trois variantes complètes trouvent la même première solution ; tout le gain est dans le compteur de nœuds, pas dans la réponse."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "49229e2b-745b-43f1-a06a-5c00e1dc42f0",
@@ -697,6 +720,14 @@
     "Show(\"l'ordonnancement de MRV coupent l'arbre différemment). Le gain dominant vient de l'heuristique vs simple.\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "826294e6-8e29-4ddc-bbbd-f38f6abe034e",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** La lecture en nœuds cache une contre-lecture en **temps** : à N=8, le simple est le plus rapide (0,053 ms contre 0,155 pour MRV et 0,255 pour FC) — tenir les domaines et scorer les colonnes coûte plus que ce que ça économise sur un arbre minuscule. Le crossover arrive vers N=14 : l'heuristique n'est pas gratuite, elle se paie d'abord et ne rapporte qu'au-delà d'une taille d'instance. Le tableau creuse l'écart à mesure que N croît : à N=16, le simple brûle **10 052 nœuds** là où MRV en visite **37** — un facteur ~271 — et le temps s'inverse (7,3 ms pour le simple contre 0,337 pour MRV). L'interprétation imprimée dit l'essentiel : MRV et FC alternent les victoires selon l'instance (N=12 : 107 vs 84 ; N=14 : 91 vs 105) — propagation et ordonnancement coupent l'arbre par des bouts différents, le gain dominant reste l'heuristique contre le simple.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "bce02a5c-0337-45ab-a84d-4582816ae6e8",
@@ -821,6 +852,14 @@
     "if (ok) Show(BoardString(sol));\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "b8f69b2f-82f3-48a4-9e81-d888847cf392",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** Le « ok=True » n'est pas un détail d'affichage : la marche de réparations se termine par une **vérification complète** des contraintes — la recherche locale propose, la validation dispose. C'est ce contrôle final qui distingue une solution prouvée d'un arrangement qui « a l'air bon ». Min-Conflicts termine en **17 itérations** sans jamais construire d'arbre : il déplace la reine la plus conflictuelle et marche de réparation en réparation. La grille diffère de celles du backtracking — aucun ordre lexicographique ne la contraint, c'est la trajectoire de réparations qui l'a produite.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "decbd520-4352-4697-9311-76d4cc1cc440",
@@ -956,6 +995,14 @@
     "Show(\"Interprétation : N = 1000 résolu en quelques centaines d'itérations — inaccessible au backtracking.\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "bbfa45ad-c4e4-4906-9001-1b1532b51503",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** Le « miracle » tient dans la colonne itérations : de 34 (N=8) à **735 (N=1000)** alors que la taille croît de ×125 — la recherche locale passe à l'échelle en 9,1 ms là où le backtracking simple exigeait déjà 7 ms pour le seul N=16. Résolu « oui » sur toute la colonne : aucune instance du banc ne l'a pris en défaut."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "04ef871e-f6a5-41d3-818f-3405ab54f858",
@@ -1036,6 +1083,14 @@
     "Show(\"Référence OEIS A000170 : N=1..8 = 1, 0, 0, 2, 10, 4, 40, 92.\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "297380a5-6939-40eb-a72e-a395badcd42c",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** L'énumération exhaustive retourne **92**, et la référence OEIS A000170 sert de contrôle croisé : N=1..8 = 1, 0, 0, 2, 10, 4, 40, 92. Les deux zéros (N=2 et N=3) sont pédagogiquement précieux — l'énumération ne dit pas seulement « combien », elle prouve aussi l'**impossibilité** sur les petites tailles."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "afcd8a39-2d5e-4c72-98bc-c81490e201c9",
@@ -1146,6 +1201,14 @@
     "Show(\"Les \" + (all.Count - canonicals.Count) + \" autres s'obtiennent par symétrie du carré (groupe D4, ordre 8).\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "b40fd1fe-83a0-4ab5-b3d2-629a4b2e374f",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** La brisure de symétrie condense les 92 solutions en **12 fondamentales**, et l'arithmétique du groupe D4 se vérifie toute seule : 11 orbites pleines de taille 8 plus une orbite de taille 4 (une solution invariante sous un demi-tour) = 88 + 4 = **92**. Compter les orbites plutôt que les solutions divise l'espace par ~8 sans perdre une miette d'information."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "536687e6-3a23-4e9a-a24c-c74e496eeee8",
@@ -1478,6 +1541,22 @@
     "}\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "7fec7da4-7764-44d1-b331-4e48f2d94016",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** La « Solution (ligne par colonne) : [4, 7, 3, 0, 6, 1, 5, 2] » est littéralement l'encodage `queens[col] = row` de la section 1 — le moteur CP-SAT rend la même **forme d'encodage** que le backtracking (un tableau `queens[col] = row`), pas la même solution : les solutions diffèrent (la première du backtracking commence à queens[0]=0, CP-SAT rend [4, 7, 3, 0, 6, 1, 5, 2]), seule la fabrique change. Et la dernière table borne le mur de cette encoding naïve : N=100 TROUVÉ en 1 690,8 ms, N=500 **Unknown** — l'effondrement se loge entre les deux.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "adf84cd0-b555-4634-9382-f28755800826",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** Deux chiffres échappent au commentaire de la cellule ci-dessus : le premier appel coûte **2 589 ms** quand l'énumération des 92 solutions n'en prend que **68,4** — la recherche d'une seule solution paie l'amorçage (apprentissage de clauses, propagation) que l'énumération réutilise ; et à N=500 l'encodage naïf rend **Unknown** après 60 s, là où Min-Conflicts traitait N=500 en **2,8 ms** — déléguer au moteur ne dispense pas de choisir son encodage.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "app1-tranche2-md-2",

MyIA.AI.Notebooks/Search/Part1-Foundations/Search-03d-WeightedAstar-Csharp.ipynb

@@ -187,6 +187,14 @@
     "Console.WriteLine(\"Coûts contrastés (route=1, herbe=3, marécage=8) -> A* va explorer, Greedy va se tromper : terrain non-dégénéré.\");\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "77fe4758-4dc4-4127-a1a4-ff02a6c5021d",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée.** Le banc est volontairement non-dégénéré : 91 murs (15 % de la grille) et des coûts contrastés (route 1, herbe 3, marécage 8) font de chaque pas un arbitrage coût/distance — un terrain à coût uniforme rendrait A*, Greedy et Weighted A* indiscernables, et le seed .NET 43 rend l'instance reproductible à l'identique."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "87be1bff",

scripts/notebook_tools/twin_pairs.d/app-1-nqueens/0009-2026-09-21-myia-po-2025-CoursIA.yaml

@@ -0,0 +1,15 @@
+date: '2026-09-21'
+by: myia-po-2025:CoursIA
+python_sha: b4340188b2bad3f9c05b78a5f658838116fee768
+csharp_sha: 5b736e279fd9712c71c7b80e4aff4992fe06240d
+content_python_sha: 9a4d60c485a287b4b90d79240438bdfce044d567c3f085290d861e7b7f63c1a4
+content_csharp_sha: 72ea9feafab922f3faf3289e1f49c677a66f84968c77349993b8acc90612fefd
+reason: >-
+  Mouvement unilateral du cote C# (tranche densite #13410) : +13 cellules
+  markdown d'un cote, l'autre cote inchange. Controle mesure des DEUX cotes
+  (base origin/main -> tete) : cellules de code python 23->23 et c# 14->14,
+  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.

scripts/notebook_tools/twin_pairs.d/app-1-nqueens/0010-2026-09-22-myia-po-2025-CoursIA.yaml

@@ -0,0 +1,6 @@
+date: '2026-09-22'
+by: myia-po-2025:CoursIA
+python_sha: b4340188b2bad3f9c05b78a5f658838116fee768
+csharp_sha: e6c62c1317dbdeb0349d04665e4b54abd7fe2550
+content_python_sha: 9a4d60c485a287b4b90d79240438bdfce044d567c3f085290d861e7b7f63c1a4
+content_csharp_sha: d8d6fa493b944a3d417e0449335885f3b70dc1225c15e076f978c287fa64b8a6

scripts/notebook_tools/twin_pairs.d/search-14-weighted-a/0008-2026-09-21-myia-po-2025-CoursIA.yaml

@@ -0,0 +1,15 @@
+date: '2026-09-21'
+by: myia-po-2025:CoursIA
+python_sha: ec9d88aaa9c3ed3eb3b0f12534e0c8b0d4d06636
+csharp_sha: 0b1cb09b47694c1ff3552553923bea673b687a8f
+content_python_sha: 9da03367b8539cc3ab4f15db67dacc44673b998593db12ff0347219536ce7592
+content_csharp_sha: bc9855b7233126e18a008a2738ad571e961f7da94d6d566a6ed217c051223511
+reason: >-
+  Mouvement unilateral du cote C# (tranche densite #13410) : +1 cellules
+  markdown d'un cote, l'autre cote inchange. Controle mesure des DEUX cotes
+  (base origin/main -> tete) : cellules de code python 7->7 et c# 7->7, 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.