From e5e07ddc4eaccd4b0f6e21c1a1d7859d26b02f65 Mon Sep 17 00:00:00 2001 From: jsboige Date: Fri, 25 Sep 2026 20:55:15 +0200 Subject: [PATCH] =?UTF-8?q?Add(notebooks,#15066):=20tranche=20G=20?= =?UTF-8?q?=E2=80=94=20labo=20du=20zoo=20modal=20(Tweety-02f-Modal-Zoo-Lea?= =?UTF-8?q?n-Python)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Tranche G de l'EPIC #15066, volet pedagogique. Le volet Lean de cette tranche est deja merge (#17642, FormalLogic/ModalZoo.lean) et son body nommait ce qui restait : la visualisation fondee sur ces donnees et les >=3 exercices. Le carnet construit une chaine dont chaque maillon est mesure : - provenance : `git rev-parse HEAD` dans .lake/packages confronte au lake-manifest.json, puis `lake build FormalLogic.ModalZoo` (rc == 0, 1023 jobs) ; - export : les listes du module (ModalZoo.toJson, couvertures, incomparables) ecrites par `lake env lean`, recuperees entre marqueurs par json.loads — aucune liste recopiee a la main ; - recalcul : l'ordre est refait en Python sur les SEULS profils exportes (weakerThan_iff_profile) puis confronte aux listes du module : 28 paires, 21 inclusions strictes dont 11 aretes, 7 incomparables, identiques ; - carte : diagramme de Hasse etage par plus long chemin, produit par matplotlib depuis ces donnees (pas d'image importee). Validation : execution papermill reelle (kernel python3, 400.79 s), 8/8 execution_count reels (1..8), 0 sortie d'erreur, 0 cellule vide, 0 chemin machine dans les sorties. Trois exercices (enonces + stubs C.1 qui s'executent). README de la serie mis a jour sur 14 surfaces re-derivees du disque. See #15066 Co-Authored-By: Claude Code --- MyIA.AI.Notebooks/SymbolicAI/Tweety/README.md | 23 +- .../Tweety-02f-Modal-Zoo-Lean-Python.ipynb | 1098 +++++++++++++++++ 2 files changed, 1111 insertions(+), 10 deletions(-) create mode 100644 MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-02f-Modal-Zoo-Lean-Python.ipynb diff --git a/MyIA.AI.Notebooks/SymbolicAI/Tweety/README.md b/MyIA.AI.Notebooks/SymbolicAI/Tweety/README.md index b04f0111ed..1d103237a4 100644 --- a/MyIA.AI.Notebooks/SymbolicAI/Tweety/README.md +++ b/MyIA.AI.Notebooks/SymbolicAI/Tweety/README.md @@ -29,7 +29,7 @@ Les notebooks utilisent **deux implémentations** pour exécuter TweetyProject, | Implémentation | Stack | Kernel | JVM requise ? | Notebooks | | ------------------------ | ------------------------------ | ------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | -| **Python** (originelle) | JPype (pont Java↔Python) | Python 3 | Oui (JDK téléchargé par le setup) | `Tweety-1` à `Tweety-11` (+ `Tweety-02d-FOL-Lab-Lean` labo FOL croisé, `Tweety-02e-Preuves-Hilbert-Gentzen-Lean` calculs de preuve Hilbert/LK, `Tweety-5b-Lean-Argumentation` companion Lean 4, `Tweety-5d-Stable-Synthesis-Lean` synthèse Z3→Lean, `Tweety-5e-Propositional-Lab-Lean` laboratoire propositionnel et `Tweety-3b-Modal-Lab-Lean` laboratoire modal) | +| **Python** (originelle) | JPype (pont Java↔Python) | Python 3 | Oui (JDK téléchargé par le setup) | `Tweety-1` à `Tweety-11` (+ `Tweety-02d-FOL-Lab-Lean` labo FOL croisé, `Tweety-02e-Preuves-Hilbert-Gentzen-Lean` calculs de preuve Hilbert/LK, `Tweety-5b-Lean-Argumentation` companion Lean 4, `Tweety-5d-Stable-Synthesis-Lean` synthèse Z3→Lean, `Tweety-5e-Propositional-Lab-Lean` laboratoire propositionnel, `Tweety-3b-Modal-Lab-Lean` laboratoire modal et `Tweety-02f-Modal-Zoo-Lean-Python` sous-cube modal certifie — huit systemes et leur diagramme de Hasse) | | **C#/.NET** (port natif) | IKVM 8.14 (bytecode Java→.NET) | `.net-csharp` | **Non** (runtime IKVM pur .NET) | **18 notebooks** `*-Csharp` (de `Tweety-2-Basic-Logics-Csharp` à `Tweety-11-Causal-Csharp` ; ex. `2b-Semantics`, `3-Dung`, `4-Aspic`) | Les deux implémentations couvrent les mêmes concepts fondamentaux (logique propositionnelle, sémantique des mondes possibles, logique du premier ordre, argumentation de Dung) ; le port C# les expose **sans JVM**, directement dans le runtime .NET, ce qui les rend exécutables côté .NET Interactive comme n'importe quel notebook C#. Les notebooks `-Csharp` vivent **à côté** de leurs homologues Python (pas dans un sous-dossier), pour faciliter la comparaison des deux stacks sur un même concept. Voir EPIC [#4667](https://github.com/jsboige/CoursIA/issues/4667). @@ -63,8 +63,8 @@ Cette série ne propose pas de choisir l'un ou l'autre, mais de **comprendre les | Statistique | Valeur | |-------------|--------| -| Notebooks | 37 racine (13 Python + 6 Lean companion + 18 C#) + 1 probe | -| Cellules totales | 1165 (dont 438 code) — 37 racine + 1 probe | +| Notebooks | 38 racine (13 Python + 7 Lean companion + 18 C#) + 1 probe | +| Cellules totales | 1170 (dont 446 code) — 38 racine + 1 probe | | Durée estimée | ~6h (tutorat) | | Kernel | Python 3 (JPype/Java) | | Version Tweety | 1.30 recommandée | @@ -149,6 +149,7 @@ Pour les praticiens intéressés par les applications multi-agents : | 2c | [Tweety-2c-FOL-Csharp](Tweety-02c-FOL-CSharp.ipynb) | FOL porté .NET (IKVM) | 30 min | C# BETA | | 2d | [Tweety-02d-FOL-Lab-Lean](Tweety-02d-FOL-Lab-Lean.ipynb) | Labo FOL croisé (tranche B de l'EPIC [#15066](https://github.com/jsboige/CoursIA/issues/15066)) : un même syllogisme exécuté par `SimpleFolReasoner` (six verdicts) et certifié par le noyau Lean sur le corpus **FFL épinglé** — conséquences quantifiées sur toutes les structures, contre-modèles finis exhibés ; la distinction `FALSE` ≠ « négation prouvée » y est mesurée | 45 min | Python+Lean BETA | | 2e | [Tweety-02e-Preuves-Hilbert-Gentzen-Lean](Tweety-02e-Preuves-Hilbert-Gentzen-Lean.ipynb) | Calculs de preuve (tranche D de l'EPIC [#15066](https://github.com/jsboige/CoursIA/issues/15066)) : les trois axiomes de Hilbert vérifiés par deux oracles réels, une preuve de Hilbert construite par **chaînage avant** (coût mesuré), puis le calcul des séquents **LK** — hauteur et taille d'un arbre **avant/après** élimination des coupures, le Hauptsatz étant invoqué comme **théorème du noyau** (`Derivation.Canonical.constructiveHauptsatz`, témoin `IsCutFree`) | 45 min | Python+Lean BETA | +| 2f | [Tweety-02f-Modal-Zoo-Lean-Python](Tweety-02f-Modal-Zoo-Lean-Python.ipynb) | Le **zoo modal** certifié (tranche G de l'EPIC [#15066](https://github.com/jsboige/CoursIA/issues/15066)) : huit systèmes normaux (`K`, `KD`, `KT`, `KTB`, `K4`, `S4`, `KD45`, `S5`) et **l'ordre** qui les relie. Les listes du module `FormalLogic.ModalZoo` ([#17642](https://github.com/jsboige/CoursIA/pull/17642)) sont **exportées** par `lake env lean` (`ModalZoo.toJson`), l'ordre est **recalculé** en Python sur les seuls profils exportés, puis la carte est dessinée : sur les 28 paires du cube, 21 inclusions strictes, dont 11 arêtes de couverture, et 7 paires **incomparables** — chacune certifiée par le noyau (`strict_of_mem_covers`, `incomparable_of_mem`) | 45 min | Python+Lean BETA | | 3 | [Tweety-3-Advanced-Logics](Tweety-3-Advanced-Logics.ipynb) | DL, Modale, QBF, Conditionnelle | 40 min | Python | | 3b | [Tweety-3b-Modal-Lab-Lean](Tweety-3b-Modal-Lab-Lean.ipynb) | Labo modal croisé (tranche C de l'EPIC #15066) : schémas `K`/`T`/`4`/`5` — syntaxe `MlParser` Tweety (bug SPASS #1334 documenté), balayage exhaustif des 512 cadres 3-mondes en Python (correspondances T/réflexif, 4/transitif, 5/euclidien mesurées en égalités exactes), certificats du kernel Lean sur le pont `FormalLogic.ModalBridge` (#17017) | 45 min | Python+Lean BETA | | 3c-DL | [Tweety-3-Advanced-Logics-Csharp](Tweety-3-Advanced-Logics-Csharp.ipynb) | DL/ML/QBF/CL .NET (DRAFT - conflits DLL) | 30 min | C# DRAFT | @@ -183,11 +184,11 @@ Pour les praticiens intéressés par les applications multi-agents : | 11 | [Tweety-11-Causal](Tweety-11-Causal.ipynb) | Raisonnement causal : do-calculus, interventions, contrefactuels | 50 min | Python | | 11c | [Tweety-11-Causal-Csharp](Tweety-11-Causal-Csharp.ipynb) | Twin C# moteur causal booléen from-scratch (do-operator, contrefactuel) | 35 min | C# PROD | -**Durée totale estimée** : ~13h (Python) + ~10h (C#/.NET). Le tableau ci-dessus couvre les notebooks principaux (12 Python + 18 C#/.NET + 6 Lean companion) ; voir aussi `_probes/Tweety-IKVM-Init-Probe.ipynb` (BETA smoke-test IKVM) et `argumentation_lean/` (lake Lean 4, toolchain `v4.32.1` depuis #11587, avec les fichiers `.lean` du dossier `Argumentation/` — les modules FR : Basic, Characteristic, Extensions, Fundamental, Grounded, Synthesis + leurs siblings `_en` i18n #4980). +**Durée totale estimée** : ~13h (Python) + ~10h (C#/.NET). Le tableau ci-dessus couvre les notebooks principaux (12 Python + 18 C#/.NET + 7 Lean companion) ; voir aussi `_probes/Tweety-IKVM-Init-Probe.ipynb` (BETA smoke-test IKVM) et `argumentation_lean/` (lake Lean 4, toolchain `v4.32.1` depuis #11587, avec les fichiers `.lean` du dossier `Argumentation/` — les modules FR : Basic, Characteristic, Extensions, Fundamental, Grounded, Synthesis + leurs siblings `_en` i18n #4980). ## En quoi chaque notebook est unique -Chaque notebook introduit un concept ou cadre théorique spécifique. Le tableau ci-dessous résume en une ligne l'apport pédagogique de chacun — couvrant les notebooks principaux (12 Python + 18 C#/.NET + 6 Lean companion) : +Chaque notebook introduit un concept ou cadre théorique spécifique. Le tableau ci-dessous résume en une ligne l'apport pédagogique de chacun — couvrant les notebooks principaux (12 Python + 18 C#/.NET + 7 Lean companion) : | # | Notebook | Concept clé enseigné | |----|-------------------------------|--------------------------------------------------------------------------| @@ -198,6 +199,7 @@ Chaque notebook introduit un concept ou cadre théorique spécifique. Le tableau | 2c | Basic Logics (C#) | FOL porté .NET via IKVM 8.14 : `tweetyproject.logics.fol.*` réel | | 2d | FOL Lab (Python+Lean) | Un syllogisme, deux moteurs : `SimpleFolReasoner` exécute six verdicts, le noyau Lean **certifie** conséquences (théorèmes) et non-conséquences (contre-modèles finis) — `FALSE` n'est pas « négation prouvée » | | 2e | Preuves Hilbert/LK (Python+Lean) | Deux calculs de preuve mesurés : Hilbert (axiomes + MP, recherche par chaînage avant, coût en instances/MP) et séquents LK (hauteur/taille d'arbre **avant/après** élimination des coupures, Hauptsatz = théorème du noyau) | +| 2f | Zoo modal (Python+Lean) | Huit systèmes modaux et leur **ordre partiel** : les données du module exportées par `lake env lean`, l'ordre recalculé sur les profils, puis la carte — 11 arêtes de couverture contre 7 paires **incomparables** ; « incomparable » n'est ni « un peu plus faible » ni « on ne sait pas » | | 3 | Advanced Logics | Ontologies OWL (DL) + raisonnement modale (SPASS) + QBF | | 3b | Modal Lab (Python+Lean) | Théorie de la correspondance mesurée : énumération exhaustive 512 cadres ↔ contre-modèles kernel-vérifiés (pont ModalBridge) | | 3c-DL | Advanced Logics (C#) | DL/ML/QBF/CL .NET — **DRAFT** : conflits de noms DLL entre `logics.ml` + `logics.cl` + `logics.qbf` simultanés | @@ -407,6 +409,7 @@ Tweety/ ├── Tweety-02c-FOL-CSharp.ipynb # FOL .NET (IKVM, BETA) ├── Tweety-02d-FOL-Lab-Lean.ipynb # Labo FOL croisé Tweety/Lean (tranche B #15066) ├── Tweety-02e-Preuves-Hilbert-Gentzen-Lean.ipynb # Calculs de preuve Hilbert/LK (tranche D #15066) +├── Tweety-02f-Modal-Zoo-Lean-Python.ipynb # Zoo modal certifie : 8 systemes, Hasse (tranche G #15066) ├── Tweety-3-Advanced-Logics.ipynb # DL, ML, QBF, CL ├── Tweety-3b-Modal-Lab-Lean.ipynb # Labo modal croisé Kripke/Lean (tranche C #15066) ├── Tweety-3-Advanced-Logics-Csharp.ipynb # DL/ML/QBF/CL .NET (DRAFT — conflits DLL) @@ -743,24 +746,24 @@ Le pitch de Tweety tient en un mot : **explicabilité**. Là où un LLM produit --- -**Version 1.2.5 — Septembre 2026 — entrée README de `Tweety-02e-Preuves-Hilbert-Gentzen-Lean` (tranche D de l'EPIC #15066, atelier calculs de preuve : les trois axiomes de Hilbert vérifiés par deux oracles réels, une preuve construite par chaînage avant — coût mesuré en instances/MP, plus une contre-expérience qui **réfute par la mesure** l'hypothèse d'un vivier simplement trop étroit — le syllogisme hypothétique, valide pour les deux oracles, n'est pas dérivé par le moteur, et l'élargir aux sous-formules de la cible ne suffit pas — puis le calcul des séquents LK dont la hauteur et la taille sont mesurées **avant/après** élimination des coupures, le Hauptsatz étant invoqué comme théorème du noyau `Derivation.Canonical.constructiveHauptsatz`, témoin `IsCutFree` inclus). Surfaces touchées : table Structure (+ entrée 2e), table « En quoi chaque notebook est unique » (+ entrée), arbre de structure, statistiques par sous-catégorie (Lean companion 4 → 6, total 35 → 38 — le recensement inclut désormais `Tweety-12-Grounded-Via-TweetyProject`, jusqu'ici hors comptes, avec sa maturité déclarée absente plutôt qu'inventée) et colonne Python du tableau des stacks (16 → 18). Le même geste comble un écart **non déclaré** : `Tweety-02d-FOL-Lab-Lean` (tranche B, #16877), présent sur disque depuis sa livraison mais absent des deux tables, y entre avec sa **propre** durée déclarée (45 minutes, lue dans le notebook) — aucune durée inventée. Trois écarts mesurés et corrigés au passage : les comptes de notebooks (« 32 » de la vue d'ensemble → 37 racine, dont 36 tabulés ; 34 → 36 principaux), les cellules totales (916 → 1165, mesurées sur l'ensemble des fichiers de la série) et les durées agrégées (Python ~13h, C#/.NET ~10h — la somme de la colonne C# valait déjà 585 min contre « ~7h » annoncées) ; l'arbre annonçait par ailleurs 18 assemblages .NET, `git ls-tree origin/main` en compte **19**. Résidus déclarés, non comblés ici : `Tweety-12-Grounded-Via-TweetyProject` reste absent des tables (13e notebook Python ; sa durée n'est déclarée nulle part — même résidu que v1.2.3 et v1.2.4, aucune ligne inventée) ; la ligne « Durée estimée ~6h (tutorat) » de la vue d'ensemble n'est pas re-dérivée (notion distincte de la somme par notebook, non mesurable depuis le disque) ; et le versant Lean de la tranche D reste **dans le notebook** — les deux fichiers d'index du lake (`FormalLogic/../FormalLogic.lean` et son `README.md`) sont sous claim actif d'une autre lane (`check_lane_claim.py`, verdict `BLOCKED` au 2026-09-25), aucun module de pont n'a donc été ajouté à `formal_logic_lean/`. Précédent : Version 1.2.4 — Septembre 2026 — entree README de `Tweety-3b-Modal-Lab-Lean` (tranche C de l'EPIC #15066, laboratoire modal croise Python/Kripke <-> Lean/ModalBridge #17017) : table Structure (+ entrée 3b, notebooks principaux 33 → 34), table « En quoi chaque notebook est unique » (+ entrée), arbre de structure, statistiques par sous-categorie (Lean companion 3 → 4, total 34 → 35) et colonne Python du tableau des stacks (15 → 16). Residu declare, non comble ici : `Tweety-12-Grounded-Via-TweetyProject` reste absent des tables (duree non declaree, cf. v1.2.3). Precedent : Version 1.2.3 — Septembre 2026 — entree README de `Tweety-5e-Propositional-Lab-Lean` (tranche A de l'EPIC #15066, laboratoire propositionnel Tweety/Lean) : table Structure (notebooks principaux 32 → 33), table « En quoi chaque notebook est unique » (ajout de 5d et 5e, lignes 31 → 33), arbre de structure, statistiques par sous-categorie (Lean companion 2 → 3, total 33 → 34) et colonne Python du tableau des stacks (14 → 15). Residu declare, non comble ici : `Tweety-12-Grounded-Via-TweetyProject` (13e notebook Python, kernel `python3`, execute 8/8 sans erreur) reste absent des tables — sa duree n'est declaree nulle part dans le notebook, aucune ligne n'a donc ete inventee. Precedent : Version 1.2.2 — Août 2026 — ajout Tweety-5d (synthèse certifiée Z3→Lean, Loi II #12205/#13597) : lake `argumentation_lean` 6+6 siblings `_en` (module `Synthesis`), toolchain corrigée v4.32.1 (#11587), comptes re-mesurés : notebooks 33, cellules 969 dont 390 code (périmètre : 32 `Tweety-*` + 1 probe). Précédent : Version 1.2.1 — re-audit fichier-entier §E : 18 DLLs shades, scripts/ 5+4+`_archive`, pin IKVM 8.14, limitations re-ancrées 1.30. EPIC #3975 tranche tweety.** +**Version 1.2.6 — Septembre 2026 — entrée README de `Tweety-02f-Modal-Zoo-Lean-Python` (tranche G de l'EPIC #15066, sous-cube modal certifié : le module `FormalLogic.ModalZoo` (#17642) porte huit systèmes normaux et **l'ordre** qui les relie ; le notebook **exporte** ses trois listes par `lake env lean` (`toJson`, récupéré entre marqueurs — aucune recopie), **recalcule** l'ordre en Python à partir des seuls profils exportés (le droit de le faire étant le théorème `weakerThan_iff_profile`), puis **dessine** le diagramme de Hasse — 11 arêtes de couverture et 7 paires incomparables, sur les 28 paires du cube, 21 inclusions strictes dont 10 par transitivité ; trois exercices stubs C.1). Surfaces touchées : table Structure (+ entrée 2f), table « En quoi chaque notebook est unique » (+ entrée), arbre de structure, tableau des stacks (colonne Python) et statistiques par sous-catégorie (Lean companion 6 → 7, total 38 → 39). **Écart mesuré et corrigé au passage** : la vue d'ensemble annonçait 1165 cellules pour 37 racine + 1 probe ; le disque en portait **1150** (1138 racine + 12 probe) — l'addition du notebook porte le compte à 1170 (446 code). Les 438 cellules de code, elles, étaient exactes. Résidus déclarés, non comblés ici : `Tweety-12-Grounded-Via-TweetyProject` reste absent des deux tables (13e notebook Python, durée jamais déclarée — même résidu que v1.2.3 à v1.2.5, aucune ligne inventée) ; la ligne « Durée estimée ~6h (tutorat) » n'est pas re-dérivée (notion distincte de la somme par notebook) ; et le bloc `CATALOG-STATUS` (`pedagogical_count: 36`) n'est pas réécrit à la main — il décrit `main` avant l'ajout et se résorbera à la prochaine régénération (catalog-pr-hygiene). Précédent : Version 1.2.5 — Septembre 2026 — entrée README de `Tweety-02e-Preuves-Hilbert-Gentzen-Lean` (tranche D de l'EPIC #15066, atelier calculs de preuve : les trois axiomes de Hilbert vérifiés par deux oracles réels, une preuve construite par chaînage avant — coût mesuré en instances/MP, plus une contre-expérience qui **réfute par la mesure** l'hypothèse d'un vivier simplement trop étroit — le syllogisme hypothétique, valide pour les deux oracles, n'est pas dérivé par le moteur, et l'élargir aux sous-formules de la cible ne suffit pas — puis le calcul des séquents LK dont la hauteur et la taille sont mesurées **avant/après** élimination des coupures, le Hauptsatz étant invoqué comme théorème du noyau `Derivation.Canonical.constructiveHauptsatz`, témoin `IsCutFree` inclus). Surfaces touchées : table Structure (+ entrée 2e), table « En quoi chaque notebook est unique » (+ entrée), arbre de structure, statistiques par sous-catégorie (Lean companion 4 → 6, total 35 → 38 — le recensement inclut désormais `Tweety-12-Grounded-Via-TweetyProject`, jusqu'ici hors comptes, avec sa maturité déclarée absente plutôt qu'inventée) et colonne Python du tableau des stacks (16 → 18). Le même geste comble un écart **non déclaré** : `Tweety-02d-FOL-Lab-Lean` (tranche B, #16877), présent sur disque depuis sa livraison mais absent des deux tables, y entre avec sa **propre** durée déclarée (45 minutes, lue dans le notebook) — aucune durée inventée. Trois écarts mesurés et corrigés au passage : les comptes de notebooks (« 32 » de la vue d'ensemble → 37 racine, dont 36 tabulés ; 34 → 36 principaux), les cellules totales (916 → 1165, mesurées sur l'ensemble des fichiers de la série) et les durées agrégées (Python ~13h, C#/.NET ~10h — la somme de la colonne C# valait déjà 585 min contre « ~7h » annoncées) ; l'arbre annonçait par ailleurs 18 assemblages .NET, `git ls-tree origin/main` en compte **19**. Résidus déclarés, non comblés ici : `Tweety-12-Grounded-Via-TweetyProject` reste absent des tables (13e notebook Python ; sa durée n'est déclarée nulle part — même résidu que v1.2.3 et v1.2.4, aucune ligne inventée) ; la ligne « Durée estimée ~6h (tutorat) » de la vue d'ensemble n'est pas re-dérivée (notion distincte de la somme par notebook, non mesurable depuis le disque) ; et le versant Lean de la tranche D reste **dans le notebook** — les deux fichiers d'index du lake (`FormalLogic/../FormalLogic.lean` et son `README.md`) sont sous claim actif d'une autre lane (`check_lane_claim.py`, verdict `BLOCKED` au 2026-09-25), aucun module de pont n'a donc été ajouté à `formal_logic_lean/`. Précédent : Version 1.2.4 — Septembre 2026 — entree README de `Tweety-3b-Modal-Lab-Lean` (tranche C de l'EPIC #15066, laboratoire modal croise Python/Kripke <-> Lean/ModalBridge #17017) : table Structure (+ entrée 3b, notebooks principaux 33 → 34), table « En quoi chaque notebook est unique » (+ entrée), arbre de structure, statistiques par sous-categorie (Lean companion 3 → 4, total 34 → 35) et colonne Python du tableau des stacks (15 → 16). Residu declare, non comble ici : `Tweety-12-Grounded-Via-TweetyProject` reste absent des tables (duree non declaree, cf. v1.2.3). Precedent : Version 1.2.3 — Septembre 2026 — entree README de `Tweety-5e-Propositional-Lab-Lean` (tranche A de l'EPIC #15066, laboratoire propositionnel Tweety/Lean) : table Structure (notebooks principaux 32 → 33), table « En quoi chaque notebook est unique » (ajout de 5d et 5e, lignes 31 → 33), arbre de structure, statistiques par sous-categorie (Lean companion 2 → 3, total 33 → 34) et colonne Python du tableau des stacks (14 → 15). Residu declare, non comble ici : `Tweety-12-Grounded-Via-TweetyProject` (13e notebook Python, kernel `python3`, execute 8/8 sans erreur) reste absent des tables — sa duree n'est declaree nulle part dans le notebook, aucune ligne n'a donc ete inventee. Precedent : Version 1.2.2 — Août 2026 — ajout Tweety-5d (synthèse certifiée Z3→Lean, Loi II #12205/#13597) : lake `argumentation_lean` 6+6 siblings `_en` (module `Synthesis`), toolchain corrigée v4.32.1 (#11587), comptes re-mesurés : notebooks 33, cellules 969 dont 390 code (périmètre : 32 `Tweety-*` + 1 probe). Précédent : Version 1.2.1 — re-audit fichier-entier §E : 18 DLLs shades, scripts/ 5+4+`_archive`, pin IKVM 8.14, limitations re-ancrées 1.30. EPIC #3975 tranche tweety.** ## Statistiques catalogue à jour -Statistiques détaillées de la sous-série Tweety. Le `pedagogical_count: 36` est lu depuis le marqueur `` (l. 5-10). Le détail par sous-catégorie ci-dessous est réconcilié avec les étiquettes par-notebook du tableau **Structure** (source granulaire). NB : le marqueur indique `maturity: BETA=33, ALPHA=3` — l'heuristique catalogue ne distingue pas les statuts PROD/BETA/DRAFT du tableau **Structure** (qui fait foi au niveau granulaire, DRAFT = `Tweety-3-Advanced-Logics-Csharp` BROKEN inclus) ; la prose ne s'aligne donc pas sur le marqueur (cf. catalog-pr-hygiene : ne pas s'aligner sur un catalogue faux). Un écart d'une unité subsiste, et il est **attendu** : le marqueur, régénéré par l'automatisation, décrit `main` **avant** l'ajout de `Tweety-02e` (36 racine), quand le recensement de cette page en compte **37** — le bloc `CATALOG-STATUS` n'est jamais réécrit à la main sur une branche feature (`catalog-pr-hygiene`), la résorption se fait donc à la prochaine régénération, pas ici : +Statistiques détaillées de la sous-série Tweety. Le `pedagogical_count: 36` est lu depuis le marqueur `` (l. 5-10). Le détail par sous-catégorie ci-dessous est réconcilié avec les étiquettes par-notebook du tableau **Structure** (source granulaire). NB : le marqueur indique `maturity: BETA=33, ALPHA=3` — l'heuristique catalogue ne distingue pas les statuts PROD/BETA/DRAFT du tableau **Structure** (qui fait foi au niveau granulaire, DRAFT = `Tweety-3-Advanced-Logics-Csharp` BROKEN inclus) ; la prose ne s'aligne donc pas sur le marqueur (cf. catalog-pr-hygiene : ne pas s'aligner sur un catalogue faux). Un écart d'une unité subsiste, et il est **attendu** : le marqueur, régénéré par l'automatisation, décrit `main` **avant** l'ajout de `Tweety-02e` (36 racine), quand le recensement de cette page en compte **38** — le bloc `CATALOG-STATUS` n'est jamais réécrit à la main sur une branche feature (`catalog-pr-hygiene`), la résorption se fait donc à la prochaine régénération, pas ici : | Sous-catégorie | NB | Statut | |-----------------------|-------|------------------------------| | Python (Tw-1..11) | 12 | PROD=12 | | `Tweety-12-Grounded` (non tabulé) | 1 | maturité non déclarée | -| Lean companion (2d, 2e, 3b, 5b, 5d, 5e) | 6 | BETA=6 | +| Lean companion (2d, 2e, 2f, 3b, 5b, 5d, 5e) | 7 | BETA=7 | | C#/.NET | 18 | PROD=12, BETA=5, DRAFT=1 | | Probe `_probes/` | 1 | BETA | -| Total | 38 | PROD=24, BETA=12, DRAFT=1, non déclarée=1 | +| Total | 39 | PROD=24, BETA=13, DRAFT=1, non déclarée=1 | Détails paradigmes/stacks : -- **Python (JPype, 13 nb)** : PL/FOL/DL/ML/QBF/CL/Dung/ASPIC+/AGM/MLN/do-calculus Pearl — double stack sur Tw-3 (DL+Modale+QBF), Tw-4 (Belief Revision), Tw-7b (Ranking), Tw-9 (vote/préférences), Tw-10 (MLN), Tw-11 (causal). Tous PROD. Les six companions **Lean** viennent en supplément : `Tweety-02d-FOL-Lab-Lean` (BETA, kernels Python + Lean, tranche B de l'EPIC #15066 : un même syllogisme exécuté par `SimpleFolReasoner` et certifié sur le corpus FFL épinglé — conséquences quantifiées, contre-modèles finis exhibés) et `Tweety-02e-Preuves-Hilbert-Gentzen-Lean` (BETA, kernels Python + Lean, tranche D de l'EPIC #15066 : axiomes de Hilbert vérifiés par deux oracles, preuve construite par chaînage avant, puis hauteur/taille d'une dérivation LK **avant/après** élimination des coupures par le Hauptsatz du noyau), puis `Tweety-5b-Lean-Argumentation` (BETA, kernel Lean 4, `argumentation_lean/`) et `Tweety-5d-Stable-Synthesis-Lean` (BETA, kernel Python + Z3, Loi II #12205 : spécification → générateur Z3 → témoin → certificat Lean `by decide`), ainsi que `Tweety-5e-Propositional-Lab-Lean` (BETA, kernels Python + Lean, tranche A de l'EPIC #15066 : trois formules-témoins lues par Tweety, recomptées en Python et certifiées sur Foundation (FFL) au commit épinglé) et `Tweety-3b-Modal-Lab-Lean` (BETA, kernel Python + Lean via WSL, tranche C de l'EPIC #15066 : schémas `K`/`T`/`4`/`5` parsés par `MlParser`, énumérés sur les 512 cadres Kripke 3-mondes puis certifiés par le pont `FormalLogic.ModalBridge` #17017 — réponse sémantique au bug SPASS #1334). +- **Python (JPype, 13 nb)** : PL/FOL/DL/ML/QBF/CL/Dung/ASPIC+/AGM/MLN/do-calculus Pearl — double stack sur Tw-3 (DL+Modale+QBF), Tw-4 (Belief Revision), Tw-7b (Ranking), Tw-9 (vote/préférences), Tw-10 (MLN), Tw-11 (causal). Tous PROD. Les sept companions **Lean** viennent en supplément : `Tweety-02d-FOL-Lab-Lean` (BETA, kernels Python + Lean, tranche B de l'EPIC #15066 : un même syllogisme exécuté par `SimpleFolReasoner` et certifié sur le corpus FFL épinglé — conséquences quantifiées, contre-modèles finis exhibés) et `Tweety-02e-Preuves-Hilbert-Gentzen-Lean` (BETA, kernels Python + Lean, tranche D de l'EPIC #15066 : axiomes de Hilbert vérifiés par deux oracles, preuve construite par chaînage avant, puis hauteur/taille d'une dérivation LK **avant/après** élimination des coupures par le Hauptsatz du noyau), puis `Tweety-5b-Lean-Argumentation` (BETA, kernel Lean 4, `argumentation_lean/`) et `Tweety-5d-Stable-Synthesis-Lean` (BETA, kernel Python + Z3, Loi II #12205 : spécification → générateur Z3 → témoin → certificat Lean `by decide`), ainsi que `Tweety-5e-Propositional-Lab-Lean` (BETA, kernels Python + Lean, tranche A de l'EPIC #15066 : trois formules-témoins lues par Tweety, recomptées en Python et certifiées sur Foundation (FFL) au commit épinglé) et `Tweety-3b-Modal-Lab-Lean` (BETA, kernel Python + Lean via WSL, tranche C de l'EPIC #15066 : schémas `K`/`T`/`4`/`5` parsés par `MlParser`, énumérés sur les 512 cadres Kripke 3-mondes puis certifiés par le pont `FormalLogic.ModalBridge` #17017 — réponse sémantique au bug SPASS #1334), et `Tweety-02f-Modal-Zoo-Lean-Python` (BETA, kernels Python + Lean, tranche G de l'EPIC #15066 : le sous-cube `FormalLogic.ModalZoo` — profils, couvertures et paires incomparables **exportés** par `lake env lean`, ordre recalculé en Python, diagramme de Hasse dessiné et chaque trait certifié par le noyau). - **C#/.NET (IKVM 8.14, 18 nb)** : bytecode Java→.NET downgrade Java 15→8 (post-C190 `JvmDowngrader`), sans JVM. PROD=12, BETA=5 (`Tweety-2b-Semantics-Csharp`, `Tweety-2c-FOL-Csharp`, `Tweety-4-Belief-Revision-Csharp`, `Tweety-4-Aspic-Csharp`, `Tweety-5-Abstract-Argumentation-Csharp`), DRAFT=1 = BROKEN (`Tweety-3-Advanced-Logics-Csharp`, conflits de noms sur `logics.ml` + `logics.cl` + `logics.qbf` simultanés dans la même DLL). - **Probe (`_probes/Tweety-IKVM-Init-Probe`, 1 nb)** : IKVM init smoke-test BETA. diff --git a/MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-02f-Modal-Zoo-Lean-Python.ipynb b/MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-02f-Modal-Zoo-Lean-Python.ipynb new file mode 100644 index 0000000000..4bb46bd49d --- /dev/null +++ b/MyIA.AI.Notebooks/SymbolicAI/Tweety/Tweety-02f-Modal-Zoo-Lean-Python.ipynb @@ -0,0 +1,1098 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-001", + "metadata": { + "papermill": { + "duration": 0.005197, + "end_time": "2026-09-25T18:46:24.719562+00:00", + "exception": false, + "start_time": "2026-09-25T18:46:24.714365+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "# Tweety-02f — Le zoo modal : huit systèmes, une carte dont chaque trait est prouvé\n", + "\n", + "> **Série Tweety — laboratoires croisés Java ↔ Lean (EPIC [#15066](https://github.com/jsboige/CoursIA/issues/15066), Tranche G, module [#17642](https://github.com/jsboige/CoursIA/pull/17642)).**\n", + "> Le sous-cube modal `FormalLogic.ModalZoo` du lake `formal_logic_lean` certifie **huit systèmes normaux**\n", + "> — K, KD, KT, KTB, K4, S4, KD45, S5 — et **l'ordre** qui les relie : onze arêtes de couverture et sept\n", + "> paires incomparables. Ce labo **lit ces listes dans le module lui-même**, en refait le calcul en Python,\n", + "> puis dessine la carte : chaque trait, et chaque absence de trait, a son théorème.\n", + "\n", + "Navigation : [Tweety-3b-Modal-Lab-Lean](Tweety-3b-Modal-Lab-Lean.ipynb) (cadres et formules modales, côté exécution) ·\n", + "[Tweety-02e-Preuves-Hilbert-Gentzen-Lean](Tweety-02e-Preuves-Hilbert-Gentzen-Lean.ipynb) (calculs de preuve) ·\n", + "[Tweety-02d-FOL-Lab-Lean](Tweety-02d-FOL-Lab-Lean.ipynb) (labo FOL) ·\n", + "[README](README.md)\n", + "\n", + "***\n", + "\n", + "## Objectifs pédagogiques\n", + "\n", + "1. **Exporter** les données certifiées du module (`ModalZoo.toJson`), exécutées par le noyau du lake épinglé — et non recopiées dans le carnet ;\n", + "2. **Lire les profils** des huit systèmes, et comprendre pourquoi le profil n'est pas la liste des axiomes : `KT` prouve `D`, `S5` prouve `B` et `4` ;\n", + "3. **Recalculer** l'ordre en Python à partir des seuls profils exportés, puis confronter ce calcul aux deux listes du module (onze arêtes, sept paires incomparables) ;\n", + "4. **Dessiner** le diagramme de Hasse, et distinguer les 28 paires du cube : 21 ordonnées, 7 incomparables ;\n", + "5. **Certifier** un trait (`strict_of_mem_covers`) et une **absence** de trait (`incomparable_of_mem`), puis mesurer avec `#print axioms` ce que ces preuves coûtent.\n", + "\n", + "## Prérequis\n", + "\n", + "- hôte Windows avec **WSL** et `elan` : les certificats Lean passent par WSL (règle F — on répare, on ne contourne pas) ;\n", + "- le lake [`formal_logic_lean`](../Lean/formal_logic_lean) construit (`lake exe cache get` puis `lake build FormalLogic.ModalZoo`) ;\n", + "- avoir parcouru [Tweety-02e](Tweety-02e-Preuves-Hilbert-Gentzen-Lean.ipynb) (ce qu'est un certificat) et, pour le versant modal exécuté, [Tweety-3b](Tweety-3b-Modal-Lab-Lean.ipynb).\n", + "\n", + "### Durée estimée : 45 minutes\n", + "\n", + "### Position dans la série\n", + "\n", + "Les trois labos Lean de l'arc `02` (les logiques du corpus FFL) se partagent trois gestes :\n", + "[Tweety-02d](Tweety-02d-FOL-Lab-Lean.ipynb) certifie un **raisonnement**,\n", + "[Tweety-02e](Tweety-02e-Preuves-Hilbert-Gentzen-Lean.ipynb) certifie des **calculs de preuve**,\n", + "ce labo-ci certifie une **comparaison** — huit systèmes, et la carte de leurs forces relatives.\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-002", + "metadata": { + "papermill": { + "duration": 0.003494, + "end_time": "2026-09-25T18:46:24.725236+00:00", + "exception": false, + "start_time": "2026-09-25T18:46:24.721742+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "## 1. La question du labo\n", + "\n", + "« Lequel est le plus fort ? » est la mauvaise question. Prenez `KTB` — réflexivité (`T`) et symétrie\n", + "(`B`) — et `S4` — réflexivité et transitivité (`4`). Aucun des deux ne contient l'autre : `KTB` ne\n", + "prouve pas `4`, `S4` ne prouve pas `B`. La relation « être plus faible que » n'est donc pas un ordre\n", + "total mais un **ordre partiel** — et c'est cette structure que le labo dessine.\n", + "\n", + "Le module `FormalLogic.ModalZoo` (livré par la [#17642](https://github.com/jsboige/CoursIA/pull/17642))\n", + "traite **huit** systèmes normaux :\n", + "\n", + "| Système | Générateurs (`gens`) | Profil (`profile`) |\n", + "|---|---|---|\n", + "| `K` | — | — |\n", + "| `KD` | `D` | `D` |\n", + "| `KT` | `T` | `D`, `T` |\n", + "| `KTB` | `T`, `B` | `D`, `T`, `B` |\n", + "| `K4` | `4` | `4` |\n", + "| `S4` | `T`, `4` | `D`, `T`, `4` |\n", + "| `KD45` | `D`, `4`, `5` | `D`, `4`, `5` |\n", + "| `S5` | `T`, `5` | `D`, `T`, `B`, `4`, `5` |\n", + "\n", + "Deux colonnes, et déjà l'essentiel : le **profil** n'est pas la liste des générateurs. `KT` prouve `D`\n", + "(une relation réflexive est sérielle), `S5` prouve `B` et `4` sans les avoir pour axiomes. Sur les cinq\n", + "schémas `D, T, B, 4, 5` il existe **32 profils** possibles (2⁵) ; huit seulement portent un nom d'usage —\n", + "le zoo est un *sous*-cube choisi, pas une énumération.\n", + "\n", + "> **Provenance des colonnes.** La colonne « profil » et les deux listes qui suivent sont **exportées par\n", + "> le module** et lues à la section 2 : elles ne sont pas recopiées ici. La colonne « générateurs » reflète\n", + "> la définition `Sys.gens` du module, elle aussi relue à la section 2 — la section 1 n'est qu'une carte\n", + "> de lecture, la donnée vient du lake.\n", + "\n", + "Trois lectures indépendantes, sur les mêmes données :\n", + "\n", + "1. **le module** sérialise ses listes (`toJson`) ; `lake env lean` les exécute — le carnet lit ce texte ;\n", + "2. **un recalcul Python** reconstruit l'ordre à partir des seuls profils exportés, et confronte le\n", + " résultat aux listes du module ;\n", + "3. **Lean certifie** : chaque trait dessiné est une inclusion *stricte* (`strict_of_mem_covers`), chaque\n", + " absence de trait une *incomparabilité* (`incomparable_of_mem`).\n", + "\n", + "Ce que le recalcul a le **droit** de faire — et pourquoi. Le module porte\n", + "`provable_iff_mem_profile`, qui établit pour les **40 cases** du tableau (8 systèmes × 5 schémas)\n", + "l'équivalence `s.logic ⊢ a.formula ↔ a ∈ s.profile`. Comparer des profils par inclusion est donc\n", + "exactement comparer les systèmes par dérivabilité : c'est le théorème `weakerThan_iff_profile`, et sans\n", + "lui le recalcul de la section 3 ne vaudrait rien de plus qu'un tri de listes.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cell-003", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T18:46:24.730590Z", + "iopub.status.busy": "2026-09-25T18:46:24.730354Z", + "iopub.status.idle": "2026-09-25T18:46:24.746845Z", + "shell.execute_reply": "2026-09-25T18:46:24.745841Z" + }, + "papermill": { + "duration": 0.021153, + "end_time": "2026-09-25T18:46:24.748379+00:00", + "exception": false, + "start_time": "2026-09-25T18:46:24.727226+00:00", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Serie Tweety : MyIA.AI.Notebooks/SymbolicAI/Tweety\n", + "Lake certifiant : MyIA.AI.Notebooks/SymbolicAI/Lean/formal_logic_lean\n", + "WSL : present\n", + "Python : 3.13.14\n" + ] + } + ], + "source": [ + "\n", + "# --- Initialisation : chemins du depot, helpers WSL (patron Tweety-02d / Tweety-5e) ---\n", + "# Ce labo est certifiant de bout en bout : sa seule dependance d'execution est le lake sibling\n", + "# `formal_logic_lean`. Pas de JVM ici -- le versant Java de la modale est le labo Tweety-3b.\n", + "import json\n", + "import os\n", + "import pathlib\n", + "import shutil\n", + "import subprocess\n", + "import sys\n", + "import tempfile\n", + "\n", + "TWEETY_DIR = pathlib.Path.cwd()\n", + "if TWEETY_DIR.name != \"Tweety\":\n", + " # execution hors du dossier Tweety : retour au chemin canonique, puis remontee des parents\n", + " candidat = pathlib.Path(\"MyIA.AI.Notebooks\") / \"SymbolicAI\" / \"Tweety\"\n", + " if not candidat.is_dir():\n", + " for parent in pathlib.Path.cwd().resolve().parents:\n", + " if (parent / candidat).is_dir():\n", + " candidat = parent / candidat\n", + " break\n", + " if candidat.is_dir():\n", + " os.chdir(candidat)\n", + " TWEETY_DIR = pathlib.Path.cwd()\n", + "assert TWEETY_DIR.name == \"Tweety\", f\"dossier Tweety introuvable depuis {TWEETY_DIR}\"\n", + "\n", + "LAKE_DIR = (TWEETY_DIR.parent / \"Lean\" / \"formal_logic_lean\").resolve()\n", + "assert (LAKE_DIR / \"lakefile.lean\").is_file(), f\"lake introuvable : {LAKE_DIR}\"\n", + "\n", + "\n", + "def to_wsl(p):\n", + " \"\"\"Chemin Windows -> chemin WSL /mnt/...\"\"\"\n", + " win = p.resolve().as_posix()\n", + " return \"/mnt/\" + win[0].lower() + win[2:]\n", + "\n", + "\n", + "def run_wsl(command, timeout):\n", + " \"\"\"Commande dans WSL, echec explicite si le binaire manque (patron Tweety-5e).\"\"\"\n", + " if shutil.which(\"wsl\") is None:\n", + " raise RuntimeError(\n", + " \"les certificats Lean passent par WSL (`wsl -e bash -lc`) : binaire `wsl` \"\n", + " \"introuvable. Ce labo exige un hote Windows + WSL -- reparer l'environnement \"\n", + " \"(regle F), aucun contournement.\"\n", + " )\n", + " return subprocess.run(\n", + " [\"wsl\", \"-e\", \"bash\", \"-lc\", command],\n", + " capture_output=True, text=True, encoding=\"utf-8\", errors=\"replace\",\n", + " timeout=timeout,\n", + " )\n", + "\n", + "\n", + "# Chemins RELATIFS a la racine du depot : une sortie de cellule ne doit pas\n", + "# figer le chemin d'une machine (les carnets jumeaux 02d/02e n'en portent aucun).\n", + "RACINE = TWEETY_DIR.parents[2] # \\MyIA.AI.Notebooks\\SymbolicAI\\Tweety\n", + "print(\"Serie Tweety :\", TWEETY_DIR.relative_to(RACINE).as_posix())\n", + "print(\"Lake certifiant :\", LAKE_DIR.relative_to(RACINE).as_posix())\n", + "print(\"WSL :\", \"present\" if shutil.which(\"wsl\") else \"absent\")\n", + "print(\"Python :\", sys.version.split()[0])\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-004", + "metadata": { + "papermill": { + "duration": 0.002338, + "end_time": "2026-09-25T18:46:24.753265+00:00", + "exception": false, + "start_time": "2026-09-25T18:46:24.750927+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "### Lecture : trois choses mesurées, aucune déclarée\n", + "\n", + "- le **dossier de la série** est résolu, et un échec de résolution **interrompt** le carnet (pas de\n", + " chemin par défaut silencieux qui ferait lire un autre lake) ;\n", + "- le **lake certifiant** est le sibling `../Lean/formal_logic_lean` : c'est le même lake que\n", + " [02d](Tweety-02d-FOL-Lab-Lean.ipynb) et [02e](Tweety-02e-Preuves-Hilbert-Gentzen-Lean.ipynb)\n", + " interrogent — un seul corpus FFL épinglé pour toute la série ;\n", + "- `wsl` est présent, et son absence lèverait une exception **nommée**. Le `-lc` n'est pas décoratif :\n", + " il fait charger le profil du shell WSL, donc `elan` et le `lake` du toolchain — un shell non\n", + " interactif ne les aurait pas dans son `PATH`.\n", + "\n", + "Le choix d'exécuter **tout** le versant certifiant dans WSL est un choix de moteur, pas de confort :\n", + "c'est là que `lake` dispose du toolchain du pin, et c'est le backend sur lequel les labos précédents de\n", + "l'arc ont été validés.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-005", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T18:46:24.762096Z", + "iopub.status.busy": "2026-09-25T18:46:24.761710Z", + "iopub.status.idle": "2026-09-25T18:47:08.918382Z", + "shell.execute_reply": "2026-09-25T18:47:08.917094Z" + }, + "papermill": { + "duration": 44.164146, + "end_time": "2026-09-25T18:47:08.921355+00:00", + "exception": false, + "start_time": "2026-09-25T18:46:24.757209+00:00", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Provenance mesuree (git rev-parse dans .lake/packages) :\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mathlib 0df444a360ea [pin confirme]\n", + " ModalLogic 71968137b917 [pin confirme]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Foundation 81810b9f22c4 [pin confirme]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "$ lake build FormalLogic.ModalZoo\n", + "\n", + "Note: This linter can be disabled with `set_option linter.defProp false`\n", + "Build completed successfully (1023 jobs).\n", + "\n", + "BUILD OK : le module du zoo compile sur les sources du pin.\n" + ] + } + ], + "source": [ + "\n", + "# --- Provenance mesuree (pins git REELS vs lake-manifest.json) puis build de la cible ---\n", + "\n", + "# 1) Les packages structurants : git rev-parse DANS .lake/packages, confronte au manifeste\n", + "manifest = json.loads((LAKE_DIR / \"lake-manifest.json\").read_text(encoding=\"utf-8\"))\n", + "pins_attendus = {p[\"name\"]: p[\"rev\"] for p in manifest[\"packages\"]}\n", + "print(\"Provenance mesuree (git rev-parse dans .lake/packages) :\")\n", + "for pkg in [\"mathlib\", \"ModalLogic\", \"Foundation\"]:\n", + " r = run_wsl(f\"git -C {to_wsl(LAKE_DIR)}/.lake/packages/{pkg} rev-parse HEAD\", timeout=120)\n", + " mesure = (r.stdout or \"\").strip()\n", + " if r.returncode != 0 or not mesure:\n", + " raise RuntimeError(\n", + " f\"package {pkg} illisible dans .lake/packages (exit {r.returncode}) : construire le \"\n", + " f\"lake (`lake exe cache get` puis `lake build FormalLogic.ModalZoo`) avant d'executer \"\n", + " f\"ce notebook -- aucun contournement (regle F).\"\n", + " )\n", + " statut = \"pin confirme\" if mesure == pins_attendus[pkg] else \"DERIVE\"\n", + " print(f\" {pkg:<18s} {mesure[:12]} [{statut}]\")\n", + " assert mesure == pins_attendus[pkg], f\"{pkg} a derive : {mesure[:12]}\"\n", + "\n", + "# 2) Build cible : le module du zoo doit compiler sur ces sources (idempotent)\n", + "r = run_wsl(f\"cd {to_wsl(LAKE_DIR)} && lake build FormalLogic.ModalZoo\", timeout=3600)\n", + "sortie = ((r.stdout or \"\") + (r.stderr or \"\")).strip()\n", + "print(\"\\n$ lake build FormalLogic.ModalZoo\")\n", + "print(\"\\n\".join(sortie.splitlines()[-3:]) if sortie else \"(aucune sortie : rien a recompiler)\")\n", + "assert r.returncode == 0, \"lake build FormalLogic.ModalZoo a echoue -- voir sortie ci-dessus\"\n", + "print(\"\\nBUILD OK : le module du zoo compile sur les sources du pin.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-006", + "metadata": { + "papermill": { + "duration": 0.00302, + "end_time": "2026-09-25T18:47:08.926798+00:00", + "exception": false, + "start_time": "2026-09-25T18:47:08.923778+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "### Lecture : les pins d'abord, le build ensuite\n", + "\n", + "- les **trois packages structurants** sont mesurés par `git rev-parse HEAD` **dans** `.lake/packages`\n", + " et confrontés au `lake-manifest.json`. Mesurer plutôt que déclarer : sans ce contrôle, le carnet\n", + " compilerait contre une révision inconnue tout en affichant la bonne. Cette tranche dépend de\n", + " **`ModalLogic`** — le fork `MyIntelligenceAgency/ModalLogic` (upstream `9c485ca9` + trois commits de\n", + " compatibilité `4.33.1`) : le pin mesuré dit lequel des deux le noyau a réellement chargé ;\n", + "- `lake build FormalLogic.ModalZoo` doit rendre **exit 0**. Une compilation déjà à jour n'écrit rien —\n", + " l'absence de ligne n'est donc pas un échec, et c'est `returncode` qui tranche, pas la sortie ;\n", + "- la moindre dérive (package manquant, pin décalé, build en échec) **interrompt** le carnet, avec le\n", + " message de réparation. C'est la règle F : un environnement dégradé se répare, il ne se contourne pas.\n", + "\n", + "Un mot sur `ModalZoo` lui-même : le module ne réimplémente pas la logique modale — il **assemble** les\n", + "systèmes de Hilbert déjà présents dans le lake (`Modal.K`, `Modal.KD`, …), calcule leurs profils et\n", + "prouve que ces profils décident l'ordre. Ce carnet consomme ce résultat ; il ne le refait pas.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-007", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T18:47:08.933747Z", + "iopub.status.busy": "2026-09-25T18:47:08.933309Z", + "iopub.status.idle": "2026-09-25T18:53:02.149256Z", + "shell.execute_reply": "2026-09-25T18:53:02.148081Z" + }, + "papermill": { + "duration": 353.223429, + "end_time": "2026-09-25T18:53:02.152466+00:00", + "exception": false, + "start_time": "2026-09-25T18:47:08.929037+00:00", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "$ lake env lean scratch.lean\n", + "\n", + "Charge utile exportee : 672 caracteres de JSON, 8 systemes\n", + "\n", + "Systeme Generateurs Profil Profil \\ gens\n", + "--------------------------------------------------------------------\n", + "K - - -\n", + "KD D D -\n", + "KT T D, T D\n", + "KTB T+B D, T, B D\n", + "K4 4 4 -\n", + "S4 T+4 D, T, 4 D\n", + "KD45 D+4+5 D, 4, 5 -\n", + "S5 T+5 D, T, B, 4, 5 D, B, 4\n", + "\n", + "gens_subset_profile : verifie sur les 8 systemes (aucun generateur hors profil).\n", + "\n", + "Charge utile brute (telle qu'ecrite par Lean) :\n", + "{\"axioms\": [\"D\", \"T\", \"B\", \"4\", \"5\"], \"nodes\": [{\"name\": \"K\", \"profile\": []}, {\"name\": \"KD\", \"profile\": [\"D\"]}, {\"name\": \"KT\", \"profile\": [\"D\", \"T\"]}, {\"name\": \"KTB\", \"profile\": [\"D\", \"T\", \"B\"]}, {\"name\": \"K4\", \"profile\": [\"4\"]}, {\"name\": \"S4\", \"profile\": [\"D\", \"T\", \"4\"]}, {\"name\": \"KD45\", \"profile\": [\"D\", \"4\", \"5\"]}, {\"name\": \"S5\", \"profile\": [\"D\", \"T\", \"B\", \"4\", \"5\"]}], \"covers\": [[\"K\", \"KD\"], [\"K\", \"K4\"], [\"KD\", \"KT\"], [\"KD\", \"KD45\"], [\"K4\", \"S4\"], [\"K4\", \"KD45\"], [\"KT\", \"KTB\"], [\"KT\", \"S4\"], [\"KTB\", \"S5\"], [\"S4\", \"S5\"], [\"KD45\", \"S5\"]], \"incomparables\": [[\"KD\", \"K4\"], [\"KT\", \"K4\"], [\"KT\", \"KD45\"], [\"KTB\", \"K4\"], [\"KTB\", \"S4\"], [\"KTB\", \"KD45\"], [\"S4\", \"KD45\"]]}\n" + ] + } + ], + "source": [ + "\n", + "# --- Export des donnees certifiees : le module serialise, Lean execute ---\n", + "def run_lean(source, timeout=1800):\n", + " \"\"\"Ecrit source dans un temporaire et le fait executer par le noyau du lake\n", + " (lake env lean = toolchain + LEAN_PATH du pin).\"\"\"\n", + " d = pathlib.Path(tempfile.mkdtemp(prefix=\"tweety02f_\"))\n", + " f = d / \"scratch.lean\"\n", + " f.write_text(source, encoding=\"utf-8\")\n", + " r = run_wsl(f\"cd {to_wsl(LAKE_DIR)} && lake env lean {to_wsl(f)}\", timeout=timeout)\n", + " return (r.stdout or \"\") + (r.stderr or \"\"), r.returncode\n", + "\n", + "\n", + "DEB_ZOO, FIN_ZOO = \"<<>>\", \"<<>>\"\n", + "DEB_GEN, FIN_GEN = \"<<>>\", \"<<>>\"\n", + "\n", + "export_src = f\"\"\"import FormalLogic.ModalZoo\n", + "\n", + "open FormalLogic.ModalZoo\n", + "\n", + "-- Le module serialise lui-meme les trois listes du dessin. Les marqueurs permettent\n", + "-- au carnet de recuperer exactement le texte ecrit par Lean, sans recopie.\n", + "#eval IO.println (\"{DEB_ZOO}\" ++ toJson ++ \"{FIN_ZOO}\")\n", + "\n", + "-- Les generateurs, pour mesurer l'ecart avec le profil (theoreme gens_subset_profile).\n", + "#eval IO.println (\"{DEB_GEN}\" ++ String.intercalate \"|\" (Sys.all.map (fun s =>\n", + " s.name ++ \"=\" ++ String.intercalate \"+\" (s.gens.map Ax.name))) ++ \"{FIN_GEN}\")\n", + "\"\"\"\n", + "\n", + "sortie, rc = run_lean(export_src)\n", + "print(\"$ lake env lean scratch.lean\")\n", + "assert rc == 0, f\"l'export a echoue (exit {rc}) :\\n{sortie}\"\n", + "for borne in (DEB_ZOO, FIN_ZOO, DEB_GEN, FIN_GEN):\n", + " assert sortie.count(borne) == 1, f\"marqueur {borne} absent ou en double :\\n{sortie}\"\n", + "\n", + "brut = sortie.split(DEB_ZOO, 1)[1].split(FIN_ZOO, 1)[0]\n", + "gens_brut = sortie.split(DEB_GEN, 1)[1].split(FIN_GEN, 1)[0]\n", + "zoo = json.loads(brut)\n", + "gens = {bloc.split(\"=\", 1)[0]: ([] if bloc.split(\"=\", 1)[1] == \"\" else bloc.split(\"=\", 1)[1].split(\"+\"))\n", + " for bloc in gens_brut.split(\"|\")}\n", + "\n", + "print(f\"\\nCharge utile exportee : {len(brut)} caracteres de JSON, {len(gens)} systemes\")\n", + "print()\n", + "print(f\"{'Systeme':<8}{'Generateurs':<16}{'Profil':<24}{'Profil \\\\ gens'}\")\n", + "print(\"-\" * 68)\n", + "for noeud in zoo[\"nodes\"]:\n", + " nom = noeud[\"name\"]\n", + " g, p = gens[nom], noeud[\"profile\"]\n", + " print(f\"{nom:<8}{('+'.join(g) or '-'):<16}{(', '.join(p) or '-'):<24}{', '.join(a for a in p if a not in g) or '-'}\")\n", + "\n", + "# Controle : tout generateur est dans le profil (c'est le theoreme gens_subset_profile)\n", + "ecarts = [(noeud[\"name\"], a) for noeud in zoo[\"nodes\"] for a in gens[noeud[\"name\"]]\n", + " if a not in noeud[\"profile\"]]\n", + "assert not ecarts, f\"gens_subset_profile viole : {ecarts}\"\n", + "print(\"\\ngens_subset_profile : verifie sur les 8 systemes (aucun generateur hors profil).\")\n", + "print(\"\\nCharge utile brute (telle qu'ecrite par Lean) :\")\n", + "print(brut)\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-008", + "metadata": { + "papermill": { + "duration": 0.00233, + "end_time": "2026-09-25T18:53:02.157423+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:02.155093+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "### Lecture : ce que l'export certifie, et ce qu'il ne fait pas\n", + "\n", + "La sortie n'est pas une jolie vue : c'est le texte que **le module a écrit**, récupéré entre marqueurs.\n", + "Le tableau confirme au passage une distinction que la section 1 annonçait : sa dernière colonne,\n", + "`Profil \\ gens`, montre les schémas **prouvés sans être axiomes** — `D` pour `KT`, `D` pour `KTB` et `S4`,\n", + "et `D`, `B`, `4` pour `S5`. Le nom de la colonne est repris **tel que le tableau l'imprime** : c'est une\n", + "sortie de moteur, pas un intitulé que le carnet choisit.\n", + "\n", + "Ce que les théorèmes du module garantissent, chacun pour sa part :\n", + "\n", + "| Déclaration du module | Ce qu'elle certifie |\n", + "|---|---|\n", + "| `mem_covers_iff` | la liste écrite à la main des **11 arêtes** est *exactement* la relation de couverture calculée par `isCover` |\n", + "| `incomparables_complete` | une paire non ordonnée est dans la liste des **7** si et seulement si ni `le s t` ni `le t s` |\n", + "| `weakerThan_iff_profile` | `s.logic ⪯ t.logic ↔ profil(s) ⊆ profil(t)` — la clé qui autorise le recalcul Python |\n", + "| `provable_iff_mem_profile` | le tableau des profils est exact sur ses **40 cases**, positives et négatives |\n", + "| `gens_subset_profile` | tout générateur figure au profil — le contrôle que la cellule précédente refait sur les données |\n", + "| `strict_of_mem_covers` / `incomparable_of_mem` | chaque arête est une inclusion **stricte**, chaque paire incomparable l'est **dans les deux sens** |\n", + "\n", + "Ce que l'export **ne fait pas** : il ne dit pas *pourquoi* ces listes sont les bonnes. Le module les\n", + "tient pour exactes ; c'est le rôle du recalcul de la section suivante d'en refaire le calcul depuis une\n", + "autre source (les profils), et celui de la section 5 de montrer les théorèmes qui les fondent.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cell-009", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T18:53:02.164217Z", + "iopub.status.busy": "2026-09-25T18:53:02.163949Z", + "iopub.status.idle": "2026-09-25T18:53:02.174948Z", + "shell.execute_reply": "2026-09-25T18:53:02.174005Z" + }, + "papermill": { + "duration": 0.015673, + "end_time": "2026-09-25T18:53:02.176121+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:02.160448+00:00", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Paires du cube (8 systemes) : 28\n", + " dont ordonnees (strict) : 21\n", + " dont incomparables : 7\n", + "\n", + "Aretes de couverture : recalcul == module ? True (11 aretes, couple oriente identique ? True)\n", + "Paires incomparables : recalcul == module ? True (7 paires)\n", + "\n", + "Aretes (module) : K < KD, K < K4, KD < KT, KD < KD45, K4 < S4, K4 < KD45, KT < KTB, KT < S4, KTB < S5, S4 < S5, KD45 < S5\n", + "Inclusions strictes : K < K4, K < KD, K < KD45, K < KT, K < KTB, K < S4, K < S5, K4 < KD45, K4 < S4, K4 < S5, KD < KD45, KD < KT, KD < KTB, KD < S4, KD < S5, KD45 < S5, KT < KTB, KT < S4, KT < S5, KTB < S5, S4 < S5\n", + "Incomparables : K4 || KD, K4 || KT, K4 || KTB, KD45 || KT, KD45 || KTB, KD45 || S4, KTB || S4\n" + ] + } + ], + "source": [ + "\n", + "# --- Controle croise : l'ordre recalcule en Python a partir des SEULS profils exportes ---\n", + "noms = [n[\"name\"] for n in zoo[\"nodes\"]]\n", + "profils = {n[\"name\"]: set(n[\"profile\"]) for n in zoo[\"nodes\"]}\n", + "\n", + "\n", + "def le(a, b):\n", + " \"\"\"`a` plus faible ou egal a `b` : profil(a) inclus dans profil(b).\n", + " Le module certifie cette equivalence (weakerThan_iff_profile) -- sans quoi ce\n", + " recalcul ne serait qu'un tri de listes sans rapport avec la derivabilite.\"\"\"\n", + " return profils[a] <= profils[b]\n", + "\n", + "\n", + "def couvre(a, b):\n", + " \"\"\"Couverture : inclusion stricte, sans systeme du zoo intercale.\"\"\"\n", + " return (le(a, b) and not le(b, a)\n", + " and not any(u != a and u != b and le(a, u) and le(u, b) for u in noms))\n", + "\n", + "\n", + "paires = [(a, b) for i, a in enumerate(noms) for b in noms[i + 1:]]\n", + "strictes = sorted(tuple(sorted((a, b))) for a, b in paires\n", + " if (le(a, b) or le(b, a)) and not (le(a, b) and le(b, a)))\n", + "incomparables_calc = sorted(tuple(sorted((a, b))) for a, b in paires\n", + " if not le(a, b) and not le(b, a))\n", + "covers_calc = sorted(tuple(sorted((a, b))) for a in noms for b in noms if couvre(a, b))\n", + "covers_calc_orient = {(a, b) for a in noms for b in noms if couvre(a, b)}\n", + "\n", + "covers_mod = sorted(tuple(sorted(p)) for p in zoo[\"covers\"])\n", + "covers_mod_orient = {tuple(p) for p in zoo[\"covers\"]}\n", + "incomp_mod = sorted(tuple(sorted(p)) for p in zoo[\"incomparables\"])\n", + "\n", + "print(f\"Paires du cube (8 systemes) : {len(paires)}\")\n", + "print(f\" dont ordonnees (strict) : {len(strictes)}\")\n", + "print(f\" dont incomparables : {len(incomparables_calc)}\")\n", + "print()\n", + "print(f\"Aretes de couverture : recalcul == module ? {covers_calc == covers_mod} \"\n", + " f\"({len(covers_calc)} aretes, couple oriente identique ? {covers_calc_orient == covers_mod_orient})\")\n", + "print(f\"Paires incomparables : recalcul == module ? {incomparables_calc == incomp_mod} \"\n", + " f\"({len(incomparables_calc)} paires)\")\n", + "assert covers_calc == covers_mod and covers_calc_orient == covers_mod_orient, \"ecart sur les aretes\"\n", + "assert incomparables_calc == incomp_mod, \"ecart sur les incomparables\"\n", + "print()\n", + "print(\"Aretes (module) :\", \", \".join(f\"{a} < {b}\" for a, b in zoo[\"covers\"]))\n", + "print(\"Inclusions strictes :\", \", \".join(f\"{a} < {b}\" for a, b in strictes))\n", + "print(\"Incomparables :\", \", \".join(f\"{a} || {b}\" for a, b in incomparables_calc))\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-010", + "metadata": { + "papermill": { + "duration": 0.002782, + "end_time": "2026-09-25T18:53:02.183323+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:02.180541+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "### Lecture : 28 paires, 21 ordonnées, 7 incomparables\n", + "\n", + "Le recalcul retrouve **exactement** les deux listes du module — y compris l'**orientation** des arêtes,\n", + "comparée comme ensemble de couples et non comme suite de lignes (l'ordre d'écriture d'une liste n'est\n", + "pas une donnée mathématique).\n", + "\n", + "Trois nombres à retenir, et ce qu'ils disent :\n", + "\n", + "- **28** — les paires non ordonnées du cube : `C(8,2)`. Le zoo est petit, la carte est complète ;\n", + "- **21** — les paires comparables *strictement*. Les **11** arêtes de couverture n'en sont que le squelette :\n", + " les **10** autres inclusions s'obtiennent par transitivité (`K < KT` par `K < KD < KT`, par exemple).\n", + " Une carte qui ne montrerait que ses arêtes ne montrerait donc qu'un tiers des relations ;\n", + "- **7** — les paires qu'**aucune** échelle ne peut ranger : `KD | K4`, `KT | K4`, `KT | KD45`,\n", + " `KTB | K4`, `KTB | S4`, `KTB | KD45`, `S4 | KD45`.\n", + "\n", + "L'erreur de lecture que ces sept paires interdisent est la plus répandue sur le sujet : « `KD45` est\n", + "incomparable à `S4` » ne veut pas dire « `KD45` est un peu plus faible », ni « on ne sait pas ». Cela veut\n", + "dire qu'il existe un modèle de `KD45` qui viole un théorème de `S4`, **et** un modèle de `S4` qui viole un\n", + "théorème de `KD45` — deux violations, dans deux sens, chacune exhibée par le module. La section 5 en\n", + "certifie une.\n", + "\n", + "Enfin, l'égalité des listes n'est pas une coïncidence heureuse : le recalcul compare des **profils**, et\n", + "c'est `weakerThan_iff_profile` qui donne à cette comparaison le sens de « être plus faible que ». Le\n", + "recours au profil n'est pas un raccourci de calcul — c'est le contenu du théorème central du module.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cell-011", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T18:53:02.192192Z", + "iopub.status.busy": "2026-09-25T18:53:02.191725Z", + "iopub.status.idle": "2026-09-25T18:53:03.150624Z", + "shell.execute_reply": "2026-09-25T18:53:03.149697Z" + }, + "papermill": { + "duration": 0.965203, + "end_time": "2026-09-25T18:53:03.151529+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:02.186326+00:00", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rangs (plus long chemin depuis K) : K=0, KD=1, KT=2, KTB=3, K4=1, S4=3, KD45=2, S5=4\n", + "Aretes de couverture : 11 ; inclusions strictes : 21 ; deductions par transitivite : 10\n", + "Incomparables : K4 || KD, K4 || KT, K4 || KTB, KD45 || KT, KD45 || KTB, KD45 || S4, KTB || S4\n" + ] + } + ], + "source": [ + "\n", + "# --- La carte : diagramme de Hasse des 11 aretes, et les 7 paires incomparables en pointilles ---\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Etagement : rang = plus long chemin depuis K. Un etagement par nombre d'axiomes serait faux --\n", + "# le profil de KD (1 schema) et celui de K4 (1 schema) ne sont pas comparables, et (KD, KT) relie\n", + "# deux systemes de meme taille de profil.\n", + "rang = {n: 0 for n in noms}\n", + "for _ in range(len(noms)):\n", + " for a, b in covers_calc:\n", + " rang[b] = max(rang[b], rang[a] + 1)\n", + "\n", + "par_rang = {}\n", + "for n in noms:\n", + " par_rang.setdefault(rang[n], []).append(n)\n", + "pos = {}\n", + "for r, groupe in sorted(par_rang.items()):\n", + " for i, n in enumerate(groupe):\n", + " pos[n] = ((i + 1) / (len(groupe) + 1), -r)\n", + "\n", + "fig, ax = plt.subplots(figsize=(9.5, 5.8))\n", + "for a, b in incomparables_calc: # les non-traits, dessines\n", + " (x1, y1), (x2, y2) = pos[a], pos[b]\n", + " ax.plot([x1, x2], [y1, y2], linestyle=\":\", color=\"#b0b0b0\", linewidth=1.3, zorder=1)\n", + "for a, b in covers_calc: # les traits certifies\n", + " (x1, y1), (x2, y2) = pos[a], pos[b]\n", + " ax.annotate(\"\", xy=(x2, y2 + 0.05), xytext=(x1, y1 - 0.05),\n", + " arrowprops=dict(arrowstyle=\"-|>\", color=\"#1f4e79\", linewidth=1.9), zorder=2)\n", + "for n in noms:\n", + " x, y = pos[n]\n", + " ax.plot([x], [y], marker=\"o\", markersize=18, color=\"#1f4e79\", zorder=3)\n", + " ax.text(x, y, n, color=\"white\", ha=\"center\", va=\"center\", fontsize=8.5, zorder=4,\n", + " fontweight=\"bold\")\n", + "ax.set_axis_off()\n", + "ax.set_title(\"Sous-cube modal certifie -- 11 aretes de couverture (fleches) \"\n", + " \"et 7 paires incomparables (pointilles)\", fontsize=10)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"Rangs (plus long chemin depuis K) :\", \", \".join(f\"{n}={rang[n]}\" for n in noms))\n", + "print(f\"Aretes de couverture : {len(covers_calc)} ; inclusions strictes : {len(strictes)} \"\n", + " f\"; deductions par transitivite : {len(strictes) - len(covers_calc)}\")\n", + "print(\"Incomparables :\", \", \".join(f\"{a} || {b}\" for a, b in incomparables_calc))\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-012", + "metadata": { + "papermill": { + "duration": 0.004193, + "end_time": "2026-09-25T18:53:03.159351+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.155158+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "### Lecture : lire la carte — un trait, deux significations, et une absence\n", + "\n", + "La figure porte **trois** informations, et les confondre est l'erreur que la section précédente a\n", + "chiffrée :\n", + "\n", + "1. **une flèche pleine** = une arête de couverture. `a → b` signifie `a` strictement plus faible que `b`,\n", + " **et** aucun système du zoo entre les deux. Chaque flèche est un théorème du module ;\n", + "2. **un pointillé** = une paire incomparable. Le trait est là pour être **vu et barré** : c'est la\n", + " réponse au réflexe qui relie deux nœuds voisins dans un dessin ;\n", + "3. **une absence de trait** entre deux nœuds reliés par un chemin = une inclusion **transitive**. `K` et\n", + " `S4` ne sont pas reliés directement, et pourtant `K < S4` — par `K < K4 < S4`, ou par\n", + " `K < KD < KT < S4`.\n", + "\n", + "Deux flèches traversent un étage (`K4 → S4` et `KD45 → S5`) : ce n'est pas un défaut de dessin mais une\n", + "propriété de l'ordre — sa **hauteur** est 4 (la chaîne `K < KD < KT < KTB < S5` compte cinq éléments),\n", + "et aucun étagement ne peut faire tenir toutes les arêtes entre étages voisins.\n", + "\n", + "Le compte final est le meilleur résumé du labo : **11 flèches + 10 transitives = 21 inclusions\n", + "strictes**, et **7 paires** qu'aucune flèche, dans aucun sens, ne peut relier. Sur les 28 paires du\n", + "cube, un quart échappe à toute échelle.\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-013", + "metadata": { + "papermill": { + "duration": 0.003222, + "end_time": "2026-09-25T18:53:03.165276+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.162054+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "## Exercices\n", + "\n", + "Les trois exercices reprennent les trois gestes du labo : **lire** les profils, **recalculer** l'ordre sur\n", + "une variante, **certifier** dans le lake. Les cellules de code ci-dessous sont des ébauches : elles\n", + "s'exécutent sans erreur et n'affichent que `Exercice a completer` tant qu'elles ne sont pas remplies.\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-014", + "metadata": { + "papermill": { + "duration": 0.004565, + "end_time": "2026-09-25T18:53:03.173102+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.168537+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "## Exercice 1 : prédire l'ordre avant de le calculer\n", + "\n", + "### Contexte\n", + "\n", + "Le tableau des profils suffit à trancher toute question d'ordre — mais l'intuition se trompe\n", + "systématiquement sur les paires qui ne partagent pas d'axiome, parce qu'elle lit les **générateurs** au\n", + "lieu du **profil**.\n", + "\n", + "### Objectifs\n", + "\n", + "1. **Sans exécuter** : répondre sur le papier pour les trois couples `(KD, S4)`, `(KT, K4)` et\n", + " `(KTB, KD45)` — inclusion dans un sens, inclusion réciproque, ou incomparabilité ?\n", + "2. Exécuter le contrôle : afficher, pour chaque couple, les profils des deux systèmes et les deux\n", + " verdicts `le(a, b)` / `le(b, a)`, puis comparer à vos réponses.\n", + "3. Pour chaque écart éventuel, dire s'il vient des **générateurs** ou du **profil** — et citer la case\n", + " qui décide (indice : le profil de `S4` contient un schéma que ses générateurs ne contiennent pas).\n", + "\n", + "> **Indices :**\n", + "> - `profils` et `le` sont définis à la section 3 ; `gens` est le dictionnaire construit à la section 2 ;\n", + "> - la question « `KD` est-il plus faible que `S4` ? » se lit `{D} ⊆ {D, T, 4}` — c'est une inclusion\n", + "> d'ensembles, pas une comparaison de tailles.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cell-015", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T18:53:03.179639Z", + "iopub.status.busy": "2026-09-25T18:53:03.179324Z", + "iopub.status.idle": "2026-09-25T18:53:03.184965Z", + "shell.execute_reply": "2026-09-25T18:53:03.183802Z" + }, + "papermill": { + "duration": 0.010469, + "end_time": "2026-09-25T18:53:03.186136+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.175667+00:00", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exercice a completer\n" + ] + } + ], + "source": [ + "\n", + "# --- Exercice 1 : predire puis verifier trois couples ---\n", + "# TODO etudiant\n", + "# Etape 1 : vos trois reponses sur papier -- (KD, S4), (KT, K4), (KTB, KD45)\n", + "# Etape 2 : pour chaque couple, afficher profil(a), profil(b), le(a, b) et le(b, a)\n", + "# Etape 3 : nommer le schema qui decide, et dire s'il vient des generateurs ou de la cloture\n", + "print(\"Exercice a completer\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-016", + "metadata": { + "papermill": { + "duration": 0.002744, + "end_time": "2026-09-25T18:53:03.191659+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.188915+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "## Exercice 2 : un neuvième système — `K5`\n", + "\n", + "### Contexte\n", + "\n", + "Le zoo s'arrête à huit systèmes **nommés**. Sur les cinq schémas `D, T, B, 4, 5`, il existe 32 profils ;\n", + "24 n'ont pas de nom d'usage. Ajoutez-en un au calcul : `K5`, de profil `{5}` — l'axiome d'euclidianité\n", + "seul, sans réflexivité, sans sérialté, sans transitivité.\n", + "\n", + "### Objectifs\n", + "\n", + "1. **Sans exécuter** : `K5` est-il comparable aux huit systèmes du zoo ? Auxquels, et dans quel sens ?\n", + " (indice : `{5}` est inclus dans les profils qui **contiennent** `5` — lesquels ?)\n", + "2. Ajouter `K5` au dictionnaire `profils`, recalculer `le`, la liste des arêtes de couverture et celle\n", + " des paires incomparables. De combien le nombre d'arêtes augmente-t-il, et quelles arêtes existantes\n", + " disparaissent ?\n", + "3. Le module certifie `covers` **pour ses huit systèmes**. Que faudrait-il ajouter au lake pour que la\n", + " carte à neuf systèmes soit certifiée elle aussi ? Répondre en deux phrases — c'est une question de\n", + " méthode, pas de code.\n", + "\n", + "> **Indices :**\n", + "> - `profils[\"K5\"] = {\"5\"}` ;\n", + "> - `noms`, `couvre` et la boucle d'étagement de la section 4 se réutilisent tels quels — pensez à\n", + "> reconstruire `paires` et `strictes` après l'ajout ;\n", + "> - pour la question 3 : que certifie **exactement** `mem_covers_iff`, et sur quel ensemble de systèmes ?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cell-017", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T18:53:03.203188Z", + "iopub.status.busy": "2026-09-25T18:53:03.202778Z", + "iopub.status.idle": "2026-09-25T18:53:03.207251Z", + "shell.execute_reply": "2026-09-25T18:53:03.206313Z" + }, + "papermill": { + "duration": 0.011732, + "end_time": "2026-09-25T18:53:03.208179+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.196447+00:00", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exercice a completer\n" + ] + } + ], + "source": [ + "\n", + "# --- Exercice 2 : K5 = profil {5} ---\n", + "# TODO etudiant\n", + "# Etape 1 : predire les systemes comparables a K5 (papier), et le sens de chaque inclusion\n", + "# Etape 2 : profils[\"K5\"] = {\"5\"} ; recalculer aretes de couverture et paires incomparables\n", + "# Etape 3 : comparer le compte d'aretes a celui du zoo a huit systemes, et nommer la methode\n", + "# qu'il faudrait suivre pour certifier cette carte a neuf systemes\n", + "print(\"Exercice a completer\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-018", + "metadata": { + "papermill": { + "duration": 0.002525, + "end_time": "2026-09-25T18:53:03.215113+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.212588+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "## Exercice 3 : deux certificats, et ce qu'ils coûtent\n", + "\n", + "### Contexte\n", + "\n", + "La section 3 a **calculé** l'ordre ; le module, lui, le **prouve**. Reste à relier les deux, et à mesurer\n", + "le prix des preuves.\n", + "\n", + "### Objectifs\n", + "\n", + "1. Par `run_lean`, faire vérifier par le noyau `strict_of_mem_covers` appliqué à une arête de votre choix,\n", + " et `incomparable_of_mem` appliqué à une paire incomparable de votre choix. Les deux conclusions\n", + " doivent apparaître dans la sortie.\n", + "2. Mesurer avec `#print axioms` les axiomes dont dépendent\n", + " `FormalLogic.ModalZoo.strict_of_mem_covers` et `FormalLogic.ModalZoo.incomparable_of_mem`, et\n", + " comparer au trio standard `[propext, Classical.choice, Quot.sound]`.\n", + "3. Le recalcul Python et le certificat Lean concluent la même chose sur les mêmes données : dire en une\n", + " phrase ce que le certificat ajoute au recalcul.\n", + "\n", + "> **Indices :**\n", + "> - le source Lean doit commencer par `import FormalLogic.ModalZoo` puis `open FormalLogic.ModalZoo` ;\n", + "> - `#check @strict_of_mem_covers` affiche son type ; le mettre à l'épreuve demande un `example` avec la\n", + "> preuve d'appartenance à `covers` — `by decide` suffit sur ces listes finies ;\n", + "> - les listes `covers` et `incomparables` sont dans le namespace `FormalLogic.ModalZoo`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cell-019", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-25T18:53:03.221964Z", + "iopub.status.busy": "2026-09-25T18:53:03.221553Z", + "iopub.status.idle": "2026-09-25T18:53:03.227605Z", + "shell.execute_reply": "2026-09-25T18:53:03.226393Z" + }, + "papermill": { + "duration": 0.010784, + "end_time": "2026-09-25T18:53:03.228494+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.217710+00:00", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exercice a completer\n" + ] + } + ], + "source": [ + "\n", + "# --- Exercice 3 : certifier une arete et une incomparabilite ---\n", + "# TODO etudiant\n", + "# Etape 1 : composer un source Lean qui #check les deux theoremes du module\n", + "# Etape 2 : ajouter un #print axioms sur chacun, et comparer au trio standard\n", + "# Etape 3 : executer via run_lean(...) et interpreter la sortie (conclusions + axiomes)\n", + "print(\"Exercice a completer\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-020", + "metadata": { + "papermill": { + "duration": 0.003876, + "end_time": "2026-09-25T18:53:03.235854+00:00", + "exception": false, + "start_time": "2026-09-25T18:53:03.231978+00:00", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "\n", + "## Conclusion — une carte, trois lectures\n", + "\n", + "| Ce qui est lu | Par quel moteur | Ce que cela prouve |\n", + "|---|---|---|\n", + "| les trois listes (`nodes`, `covers`, `incomparables`) | le module, exécuté par `lake env lean` | les données du dessin viennent du lake épinglé — pas d'une recopie |\n", + "| l'ordre, reconstruit sur les seuls profils | Python, une trentaine de lignes | les 11 arêtes et les 7 incomparables sont reproductibles depuis les profils |\n", + "| les traits et les non-traits | le noyau Lean | 21 inclusions strictes et 7 incomparabilités, chacune par un théorème |\n", + "\n", + "Le point à retenir n'est pas le nombre de systèmes, mais la **nature de la carte** : sur 28 paires, 7 ne\n", + "sont ordonnées dans aucun sens. Une carte mentale qui les rangerait sur une échelle serait fausse — et\n", + "c'est exactement ce que le comptage, puis le certificat, interdisent. Un ordre partiel n'est pas un ordre\n", + "total incomplet : c'est une structure d'une autre nature.\n", + "\n", + "### Ce que ce labo ne couvre pas\n", + "\n", + "- **la correspondance cadres ↔ axiomes dans le sens suffisant** : le module prouve `valid_D` … `valid_five`\n", + " (une condition de cadre valide l'axiome) et exhibe quatre cadres finis pour les réfutations ; la\n", + " **complétude** de Kripke pour ces huit systèmes n'y est pas — c'est un résultat d'une autre ampleur,\n", + " hors du périmètre de cette tranche ;\n", + "- **le versant Java** : la syntaxe modale exécutée par Tweety est le sujet de\n", + " [Tweety-3b](Tweety-3b-Modal-Lab-Lean.ipynb) ; ce labo-ci est certifiant de bout en bout, et l'absence\n", + " de JVM y est un choix, pas une dégradation ;\n", + "- **les 24 profils sans nom** : le zoo est un *sous*-cube choisi pour ses noms d'usage, pas une\n", + " énumération des 32 profils — l'exercice 2 en explore un.\n", + "\n", + "### Références\n", + "\n", + "- le module : [`FormalLogic/ModalZoo.lean`](../Lean/formal_logic_lean/FormalLogic/ModalZoo.lean) — [#17642](https://github.com/jsboige/CoursIA/pull/17642)\n", + "- l'EPIC : [#15066](https://github.com/jsboige/CoursIA/issues/15066) — Tranche G\n", + "- le labo modal côté exécution : [Tweety-3b-Modal-Lab-Lean](Tweety-3b-Modal-Lab-Lean.ipynb)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.14" + }, + "papermill": { + "default_parameters": {}, + "duration": 400.794608, + "end_time": "2026-09-25T18:53:03.686916+00:00", + "environment_variables": {}, + "exception": null, + "input_path": "Tweety-02f-Modal-Zoo-Lean-Python.ipynb", + "output_path": "Tweety-02f-Modal-Zoo-Lean-Python.ipynb", + "parameters": {}, + "start_time": "2026-09-25T18:46:22.892308+00:00", + "version": "2.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}