Apprendre aux machines à lire la logique

Un modèle de langage moderne sait rédiger une dissertation, traduire un menu et tenir une conversation fluide. Demandez-lui si un court argument de trois lignes est valide, et quelque chose de plus délicat se produit. Cet espace délicat — entre un argument qui sonne juste et un argument qui est juste — est là où j'ai passé une grande partie de mon doctorat, et c'est le sujet de cet article.

Le texte suit deux fils entrelacés. Le premier est une question scientifique : comment les modèles de langage traitent-ils la logique, et que se passe-t-il lorsqu'on soumet à un modèle le même problème logique écrit dans un langage formel différent ? Le second est une réponse d'ingénierie : un petit paquet Python ouvert que j'ai construit, appelé Common Logic Grammar Construction (CLGC), qui rend la question mesurable et reproductible. Je tiens autant à l'un qu'à l'autre, et tous deux rejoignent ce que nous enseignons à DSTI : la discipline de la documentation et du code propre du module Clean IT du Warm-Up et nos consignes de Software Engineering (SE1/SE2) ; le réflexe de la grammaire d'un langage formel que construisent les cours The Relational Model and SQL et SQL (Structured Query Language) — où nous enseignons SQL comme une notation par-dessus l'algèbre relationnelle, et où un plan de requête se lit comme l'arbre d'opérateurs qu'un optimiseur réécrit ; la boucle « mesurer une seule chose à la fois » des Python Machine Learning Labs ; et les fondations d'entraînement des modèles des cours Artificial Neural Networks et Deep Learning, que j'ai enseignés et largement retravaillés avant de les confier à leurs professeurs actuels. Je signalerai ces liens au fil du texte, car un blog d'école gagne sa place en montrant où la recherche rejoint la salle de cours.

C'est une lecture longue, et c'est voulu — c'est le DSTI TechBlog, après tout. Nous partons de ce qu'est un syllogisme, traversons la logique du premier ordre et l'idée de notation, ouvrons l'architecture du paquet, parcourons les expériences et — la partie à laquelle je tiens le plus — exposons honnêtement ce que le travail a permis et ce qui reste à améliorer.

01 Le plus ancien test de raisonnement dont nous disposons

Logique, inférence et syllogisme

La logique, à sa racine, porte sur le bon raisonnement : la capacité à dériver de nouveaux énoncés vrais à partir de ceux que nous tenons déjà. L'unité est la proposition — une phrase qui est soit vraie, soit fausse. Un syllogisme enchaîne deux propositions ou plus (les prémisses) pour en produire une nouvelle (la conclusion). L'exemple d'école est celui que tout le monde rencontre en premier :

Tous les hommes sont mortels. Socrate est un homme. Donc Socrate est mortel.

Aristote a ouvert l'étude de la logique avec des arguments de cette forme pour une bonne raison : la validité d'un syllogisme ne dépend que de sa forme, non des mots particuliers. Remplacez les termes et une forme valide reste valide. Depuis Aristote, la logique s'est ramifiée en logique propositionnelle, en logique du premier ordre et en la logique mathématique de Frege et de ses successeurs — autant de façons d'écrire les mêmes formes sous-jacentes.

Quand les mots tirent d'un côté et la forme de l'autre

Considérons un second argument :

Toutes les voitures sont des véhicules. Aucun animal n'est une voiture. Donc aucun animal n'est un véhicule.

La conclusion paraît sensée — les animaux ne sont pas des véhicules — et pourtant l'argument est invalide : les prémisses interdisent aux animaux d'être des voitures, et ne disent rien qui interdise à un animal d'être un véhicule. La plausibilité de tous les jours penche vers « valide » tandis que la forme dit « invalide ». Cet écart porte un nom : l'effet de contenu (proche cousin du biais de croyance) — juger un argument à la crédibilité apparente de sa conclusion plutôt qu'à sa structure. Les humains le manifestent, et les modèles entraînés à prédire du texte vraisemblable le manifestent aussi, puisque la plausibilité est exactement le type de signal que l'entraînement récompense.

C'est ce qui fait des syllogismes un instrument aussi net. Ils sont petits ; leur validité est décidable par la forme ; et ils nous laissent mesurer dans quelle mesure un raisonneur s'appuie sur le contenu plutôt que sur la structure. La question moderne devient alors précise et testable : lorsqu'un modèle étiquette correctement un syllogisme, raisonne-t-il sur la forme, ou s'appuie-t-il sur la familiarité des mots ? La série en deux parties Logic in the Era of Artificial Intelligence pose exactement cela (Partie 1) et y répond avec un outil (Partie 2).

02 La même pensée, écrite de bien des façons

La logique du premier ordre : mettre la forme par écrit

Pour étudier la forme, on l'écrit d'abord. L'outil standard est la logique du premier ordre (FOL) : quantificateurs (∀ « pour tout », ∃ « il existe »), connecteurs (→, ∧, ∨, ⊕ « ou exclusif », ¬), variables et prédicats. L'argument de Socrate devient :

∀x (Human(x) → Mortal(x))
Human(socrates)
∴ Mortal(socrates)

La traduction retire le ton et la connotation et garde le squelette. Quiconque a transformé une demande métier vague en un SELECT … WHERE … précis a effectué le même geste : du langage naturel en entrée, une expression formelle exacte en sortie. SQL est lui-même un langage formel doté d'une grammaire — et sous sa surface se trouve l'algèbre relationnelle, un ensemble fermé d'opérateurs sur des ensembles de lignes (σ sélection, Π projection, ⋈ jointure …). Écrite un opérateur par étape, une requête est un arbre : le même plan logique qu'une base de données construit à partir de votre SQL. Cet arbre peut ensuite être réécrit en arbres dont l'équivalence est démontrable — pousser une sélection sous une jointure pour filtrer tôt, réordonner les jointures parce que ⋈ est commutative et associative — tant que vous ne projetez jamais hors d'une colonne dont une étape ultérieure a encore besoin. Sébastien et moi enseignons l'algèbre d'abord, à dessein, pour que les étudiants lisent SQL comme une notation par-dessus cette forme et un plan de requête comme un arbre d'opérateurs : l'algèbre fixe ce qui est correct et quelles réécritures restent licites, tandis que l'optimiseur de requête, qui chiffre les plans d'après les statistiques des tables, décide à quelle vitesse. C'est le même mouvement grammaire → arbre → transformation auquel cet article ne cesse de revenir — l'optimiseur n'est qu'une passe de plus sur un arbre syntaxique.

Un spectre de notations

FOL est une façon d'écrire le squelette, et loin d'être la seule. Le même contenu logique vit dans de nombreuses notations de représentation des connaissances (KR), et John Sowa — dont les travaux sur Common Logic que le nom CLGC honore — a passé une carrière à soutenir que ces notations sont la véritable interface humain-machine. Les familles avec lesquelles le projet travaille :

• Suite Common Logic (CL) — CLIF (Common Logic Interchange Format) et CGIF (Conceptual Graph Interchange Format) : proches de FOL, conçues pour rester lisibles.
• Algèbre Plus-Minus — TFL / TFL+ (Term Functor Logic) : très abstraite, encodant un syllogisme avec les opérateurs + et - et des prédicats désignés par première lettre et indice. « Tout Athénien est un Grec ; tout Grec est mortel ; donc tout Athénien est mortel » devient l'expression fusionnée unique -(+A0-+G0)-(+G0-+M0)-(+A0-+M0).
• Answer Set Programming (ASP) — CLINGO, le langage d'entrée d'un solveur ASP.
• Prolog (PROLOG) — le langage de programmation logique classique. CLGC ne génère pas Prolog ; il valide des énoncés contre une grammaire Prolog et les fait passer dans un moteur Prolog (Pytholog), de sorte que Prolog est une cible d'interopération et de validation plutôt qu'une sortie de traduction.
• MINIFOLx — une famille de variantes de FOL délibérément compactes et délibérément non familières, introduites pour tester une idée précise (voir plus bas).

Le même syllogisme — celui d'Athénien/Grec/mortel montré ci-dessus en Plus-Minus — rend la chose concrète lorsque CLGC le génère réellement. Les cellules ci-dessous sont la sortie effective fol_to_* de l'outil (chaque saut de ligne d'énoncé rendu par un retour à la ligne, espaces environnants supprimés), et non une version idéalisée à la main :

Le contenu est identique dans chaque ligne ; seule la notation change — et sa forme avec elle. CLIF, CLINGO et MINIFOL gardent un énoncé par ligne ; TFL, TFL+ et CGIF fusionnent tout l'argument en une seule expression, et CLGC met les noms de prédicats en minuscules lors de la traduction. Prolog n'est pas une cible de génération : le paquet valide les énoncés contre une grammaire Prolog et les remet à un moteur Prolog (Pytholog) plutôt que d'émettre du Prolog.

Une mélodie est le même air au piano, au synthétiseur ou au marimba ; l'instrument change ce qu'un auditeur remarque. L'hypothèse scientifique de tout le projet est l'analogue linguistique : soumettez à un modèle le même syllogisme dans une notation différente, et son comportement de raisonnement se déplace — parfois vers le haut, parfois non, et toujours d'une manière qui vaut la peine d'être mesurée. Il existe un fort a priori en ce sens depuis mon étude de 2025, qui a constaté qu'un petit modèle pouvait conserver de solides performances de raisonnement lorsqu'on remplaçait le langage naturel par un langage logique plus compact (hal-05248053). CLGC est l'outil qui a transformé cette observation en quelque chose de systématique.

03 CLGC comme ingénierie

La science ne prend son sens que si l'instrument est solide, aussi je veux consacrer un vrai temps à la construction. C'est la partie qui s'appuie le plus sur les habitudes d'ingénierie logicielle que nous enseignons.

Une bonne abstraction : une notation est un objet

La décision de conception centrale est petite, et je crois que c'est le bon genre de petitesse. Une notation est un objet. Il y a une seule classe de base abstraite, Notation ; chaque langage formel — FOL, CLIF, CGIF, TFL+, CLINGO, PROLOG, MINIFOL — est une classe fille, et chacune est définie par sa grammaire Backus–Naur Form (BNF), la manière standard d'écrire comment se construisent les expressions valides d'un langage. FOL est la première classe concrète, car elle est largement utilisée et lisible par l'humain, et toutes les autres notations en dérivent.

Deux conséquences en découlent, toutes deux délibérées :

1. Ajouter une notation, c'est écrire une grammaire, pas modifier le moteur. Un contributeur fournit la BNF d'une nouvelle notation et CLGC peut alors générer et traduire des syllogismes dans celle-ci. C'est le principe ouvert/fermé en pratique — ouvert à l'extension, fermé à la modification — le genre de chose dont parle vraiment SE1/SE2.
2. Les syllogismes sont aussi des objets. Un FOLSyllogism détient des prémisses et une conclusion, et sait se catégoriser, se traduire et se valider lui-même. À notre connaissance, CLGC est le premier paquet à traiter les syllogismes comme des objets de première classe plutôt que comme de simples chaînes de caractères.

Comment une traduction est réellement générée

L'algorithme de génération est le cœur d'ingénierie. Partant d'un syllogisme en FOL (qui possède une grammaire BNF définie), CLGC :

1. analyse l'énoncé FOL contre la grammaire FOL pour construire un arbre de syntaxe abstraite (AST) — le même intermédiaire en forme d'arbre qu'un compilateur construit à partir du code source ;
2. construit un arbre équivalent dans la notation cible au moyen de la grammaire BNF de cette notation ;
3. reconstruit l'énoncé dans la notation cible à partir de l'arbre, en appliquant les règles syntaxiques de la cible (espacement, parenthèses, symboles d'opérateurs).

Parce que tout passe par une grammaire explicite et un arbre explicite, une traduction est reconstructible et vérifiable plutôt qu'une édition de chaîne opaque. Quiconque a écrit un analyseur syntaxique, ou réfléchi soigneusement à la façon dont SQL est analysé, en reconnaîtra la forme immédiatement.

À voir aussi — un motif maison. Ce grammaire → arbre → émission, associé à générer-puis-vérifier, n'est pas propre à CLGC ; je le reconnais dans la façon dont Sébastien a conçu le nouveau système web de DSTI à partir de juin 2026. Cette construction expédie une feuille de style élaguée par page en analysant le CSS (Cascading Style Sheets) en un arbre récursif et en revérifiant chaque page élaguée par rapport à l'originale avant expédition ; son vérificateur schema.org est construit à partir du vocabulaire même de schema.org plutôt que codé règle par règle à la main ; et son pipeline de traduction gouverné traite une traduction comme une transformation préservant la structure, confirmée par un validateur déterministe. Des problèmes différents, une seule manière de penser — définir la cible formellement, travailler sur l'arbre, et prouver la sortie avant qu'elle ne parte. Cette cohérence à travers l'ingénierie de l'école — racontée en entier dans le TechBlog d'ingénierie en deux parties, Partie 1 et Partie 2 — plus que tout outil isolé, est ce que je trouve digne d'être montré.

Les quatre questions à poser à toute nouvelle notation

Pour définir une nouvelle notation, le projet recommande quatre critères directeurs — qui font aussi une jolie loupe sur toute la question de recherche :

• Verbosité — la notation est-elle compacte ou verbeuse ? (Plus de verbosité laisse plus de place à l'ambiguïté.)
• Fréquence — la notation, ou quelque chose de semblable, a-t-elle vraisemblablement été vue par un modèle lors du pré-entraînement ? (Langage naturel : souvent. CLIF : rarement.)
• Abstraction — se situe-t-elle près du langage naturel ou près des mathématiques (comme TFL) ?
• Finitude — a-t-elle un vocabulaire fini et une grammaire définissable ? (Une exigence stricte.)

La famille MINIFOLx existe précisément pour sonder le critère de Fréquence. Chaque variante apporte un petit changement délibéré à FOL : MINIFOL remplace les symboles d'opérateurs (∀, ⊕, →, ¬, ∃, ∧, ∨) par les chaînes all, ^, :-, -, some, &, | ; MINIFOL2 abandonne le quantificateur existentiel ; MINIFOL3 écrit not pour ¬ ; MINIFOL4 écrit , pour ∧. Ce sont des variantes légères, et par conception non familières — une façon de demander ce qui se passe quand un modèle rencontre une syntaxe qu'il n'a presque jamais vue.

Ce que fait le paquet, en quatre verbes

• Manipuler — les syllogismes étant des objets, on peut ajouter, remplacer ou retirer des propositions (add_statements, add_premises, add_conclusion).
• Traduire — de FOL vers n'importe quelle notation prise en charge.
• Valider — vérifier un énoncé contre la grammaire d'une notation (validate(grammar='PROLOG')).
• Catégoriser — assigner un syllogisme à un type structurel (les catégories du Syllogism Evaluation Framework (SEF), détaillé en Partie 4).

Un court exemple réel tiré du dépôt :

from clgc.__base import *

syllogism = FOLSyllogism(
    "∀x (Bikes(x) → ¬Calledcars(x))\n"
    " ∀x (Bike(x) → Vehicle(x))\n"
    " ∃x (Vehicles(x) ∧ Bikes(x))\n"
)

print(syllogism.categorize())               # -> categorical
tfl_plus = FOLSyllogism.fol_to_tfl_plus(syllogism.syllogism)
print(tfl_plus)                             # -> -(+B0--+C0)-(+B0-+V0)+(+V1++B1)

Cette dernière ligne est la même pensée portant un habit très différent.

Bien s'entendre avec les autres

Parce que CLGC valide contre des grammaires, il coopère avec l'outillage logique existant au lieu de le réinventer. Le dépôt montre CLGC remettant des énoncés validés à Pytholog, un moteur Prolog pour Python : chaque fait candidat est validé comme PROLOG par CLGC avant d'être ajouté à une base de connaissances et interrogé. La validation-avant-insertion est la version programmation-logique du contrôle des entrées à la frontière — le même instinct qui garde un pipeline de données honnête.

La dimension Clean IT

CLGC s'installe avec pip install clgc, porte un README qui documente son architecture et chaque notation prise en charge, et est archivé avec un enregistrement citable sur HAL et Software Heritage. Rien de tout cela n'est glorieux ; tout cela fait la différence entre un script qui tourne sur un seul ordinateur portable et un outil sur lequel d'autres peuvent bâtir. Le module Clean IT du Warm-Up existe pour rendre ce second point ordinaire, et un paquet que d'autres chercheurs peuvent installer et citer est la preuve visible que l'habitude a pris.

04 Les expériences, complètes et à découvert

L'instrument construit, la science devient traitable. La question centrale : le choix de la notation change-t-il la qualité avec laquelle un modèle raisonne sur des syllogismes — et le bon cadrage peut-il aider un petit modèle à s'attacher davantage à la structure et moins au contenu ?

La tâche, les données, les modèles

Les études s'appuient sur deux jeux de données de raisonnement publics et constitués par des humains, FOLIO et P-FOLIO, qui donnent déjà les syllogismes en langage naturel (NL) et en FOL. CLGC étend chacun à travers les notations prises en charge pour produire FOLIO-KR et P-FOLIO-KR, tous deux publiés en libre accès sur Hugging Face. La tâche est une classification à trois issues : étiqueter chaque conclusion Vraie (valide), Fausse (invalide) ou Inconnue (non concluante). Les jeux de données sont honnêtement déséquilibrés — dans les étiquettes de vérité, et dans les catégories SEF aussi (dans FOLIO-KR, la catégorie categorical est largement dominée par disjunctive et complex) — aussi les articles rapportent-ils le score F1 plutôt que l'exactitude brute là où le déséquilibre des étiquettes de vérité importe.

Le volet SEF du pipeline range chaque syllogisme dans l'une de quatre catégories structurelles, chacune avec une définition précise que l'on peut montrer au modèle :

• Hypothétique — contient une implication.
• Disjonctif — contient une disjonction.
• Catégorique — exactement deux prémisses, et aucune des précédentes.
• Complexe — aucune des précédentes.

Ces quatre catégories sont le SEF tel que les articles le définissent conceptuellement. La méthode categorize() livrée est une heuristique légère par mots-clés et par forme qui approxime ce schéma plutôt que de le calculer exactement : elle étiquette un syllogisme comme disjunctive lorsque le texte contient un symbole de disjonction (∨ ou ⊕) ; sinon complex lorsqu'il compte plus de trois énoncés ; sinon categorical lorsque le texte en minuscules contient l'un d'un petit ensemble de quantificateurs (all, any, some, no, few, most, none, several) en sous-chaîne ; et hypothetical par défaut. Elle est rapide et suffisante pour trier un jeu de données à grande échelle, mais c'est une heuristique qui tient lieu des définitions formelles ci-dessus, non une ré-implémentation — bon à garder en tête en lisant les résultats par catégorie.

Deux régimes de modèles sont comparés. En Supervised Fine-Tuning (SFT), le modèle s'entraîne sur des syllogismes dans une notation donnée avec leurs étiquettes, puis prédit sur des exemples réservés ; les chevaux de trait sont les petits modèles encodeur-décodeur Flan-T5 (small et large), choisis pour leur frugalité et leur reproductibilité. En Zero-Shot (ZS), on interroge le modèle à froid, avec deux scénarios de prompt : le Scénario 1 donne le syllogisme plus la grammaire BNF de la notation ; le Scénario 2 ajoute la catégorie SEF, sa définition et un exemple résolu, pour voir si dire au modèle de quel type d'argument il s'agit aide. Les modèles ZS sont de petits systèmes à base de décodeur sous les dix milliards de paramètres — Gemma-2-2b-it, Llama-3.2-3b-instruct, Phi-3.5-mini-instruct. Les Python ML Labs fonctionnent exactement sur cette forme de travail : fixer une métrique, changer une seule chose, lire le résultat honnêtement.

Ce que montrent les résultats

Plusieurs constats traversent les études, et je les énoncerai tels quels.

La taille du modèle relève les performances, en grande partie indépendamment de la notation. À mesure que Flan-T5 passe de small à large, la plupart des notations s'améliorent ensemble. Cela donne une base de référence propre : l'échelle aide partout, aussi les effets intéressants sont-ils ceux qui subsistent une fois l'échelle prise en compte.

La notation gagnante dépend du modèle et du jeu de données. Sur P-FOLIO-KR, avec le petit modèle et très peu de données d'entraînement, TFL+, compacte et abstraite, s'est étonnamment bien comportée — ses jetons +/- sont déjà familiers au tokeniseur, aussi une notation courte a-t-elle donné au petit modèle un appui ferme. Avec le modèle plus grand, le NL a repris la tête. Lire cela honnêtement, c'est résister à un unique titre bien net : l'effet est réel, et il est conditionnel.

Un cadrage hybride rend le raisonnement plus prudent. Associer le NL à une notation formelle compacte a déplacé les modèles vers des jugements plus conservateurs. Dans l'étude RuleML+RR, NL + CLIF en particulier a amélioré le raisonnement par réfutation — repérer les cas invalides — et a été systématiquement le plus fort sur l'étiquette la plus difficile, Inconnue ; dans l'étude SemEval, NL + FOL a abaissé l'effet de contenu par rapport au NL seul. Pour des systèmes qui, sinon, tendent à répondre avec assurance quand ils devraient s'abstenir, un cadrage qui pousse vers « Inconnue » à bon escient est une propriété réellement utile.

Les notations compactes s'exécutent plus vite. Dans le chronométrage ZS, le NL était la notation la plus coûteuse à traiter, tandis que des notations compactes comme TFL+ et CLIF allaient plus vite ; CLIF se situait à un point d'équilibre entre vitesse et qualité. Là où une notation conserve l'exactitude tout en raccourcissant l'entrée, on gagne de la vitesse d'inférence gratuitement — une bonne nouvelle pour quiconque fait tourner des modèles avec un budget serré.

Les descriptions de catégorie aident, sous conditions. Ajouter la catégorie SEF à un prompt ZS (Scénario 2) a relevé les performances pour plusieurs couples modèle/notation et en a laissé d'autres inchangés. Le gain dépend de la sensibilité d'un modèle donné à la notation, ce qui est en soi un résultat intéressant sur la façon dont ces modèles exploitent une structure supplémentaire.

Le pendant SemEval a chiffré le biais. Dans l'étude SemEval (Semantic Evaluation) 2026 Task 11 (Sous-tâche 1 : Disentangling Content and Formal Reasoning), le plus fort petit modèle — un Flan-T5-large pré-affiné sur FOLIO puis affiné sur la tâche, lisant NL + FOL — a atteint 90,57 % d'exactitude avec un Content Score (CS) de 27,80 % sur l'ensemble d'évaluation à l'aveugle, se classant 10e sur l'exactitude et 7e sur la métrique d'effet de contenu. Le Content Score récompense délibérément l'exactitude tout en pénalisant l'effet de contenu — CS = ACC / (1 + log(1 + CE)), où ACC est l'exactitude et CE l'effet de contenu — aussi un score élevé est-il difficile à obtenir, et en obtenir un compétitif avec un modèle sous le milliard de paramètres, tout en abaissant l'effet de contenu par rapport au NL seul, est la partie dont je me réjouis. L'étape langage-naturel-vers-FOL de ce pipeline a utilisé un modèle commercial, avec des traductions vérifiées à la main sur un échantillon de 20 % du jeu d'entraînement et sur l'intégralité de l'ensemble d'évaluation.

Ce qui reste à améliorer

Une expérience honnête rapporte les parties qui ont résisté, et celles-ci pointent droit vers le travail suivant.

Attraper les arguments invalides est la compétence la plus difficile. Les modèles reconnaissaient volontiers les syllogismes valides et faisaient l'essentiel de leurs erreurs sur les invalides, tendant à accepter un argument invalide comme valide (un schéma de faux positifs). Confirmer qu'une chose s'accorde est plus facile que prouver qu'elle est brisée ; les prochains gains se trouvent dans le renforcement de la réfutation, et le cadrage conservateur NL + CLIF en est une voie prometteuse.

Les jeux de données sont déséquilibrés. Les syllogismes catégoriques dominent les ensembles de travail, ce qui rend certaines conclusions au niveau des catégories provisoires. Équilibrer les catégories SEF est une tâche concrète pour un prochain jeu de données, et les articles la nomment comme telle.

Une étape s'appuie sur un modèle commercial. La traduction langage-naturel-vers-FOL utilise actuellement un système commercial hébergé. Cela garde l'avant du pipeline solide aujourd'hui, et cela crée aussi une dépendance : si le modèle externe change, le premier maillon peut bouger sous l'expérience. Nommer cela ouvertement est tout l'enjeu — la reproductibilité est une propriété que l'on protège à dessein.

Le résultat que je défends est la forme du constat, qui a tenu à travers plus d'une étude et d'un lieu : la façon dont un problème est formulé change la façon dont un petit modèle raisonne à son sujet, et un cadrage hybride bien choisi l'aide à s'attacher à la structure et à s'abstenir quand il le devrait. Les chiffres précis vivent dans les articles, et le code et les jeux de données ouverts permettent à quiconque de les rejouer.

05 Les preuves, à découvert

Tout ce qui se trouve derrière cet article est public.

• Code : le paquet CLGC — github.com/HannaAbiAkl/clgc, installable avec pip install clgc (sur le Python Package Index (PyPI), pypi.org/project/clgc), archivé et citable via HAL / Software Heritage (hal-05608340).
• Jeux de données : FOLIO-KR et P-FOLIO-KR, publiés sur Hugging Face (FOLIO-KR, P-FOLIO-KR) ; les poids des meilleures configurations NL-CLIF et NL sont publiés, le modèle NL-FOL devant suivre.
• Le cadre, en langage clair : Logic in the Era of AI — Partie 1 (Syllogismes) et Partie 2 (Cadre CLGC).
• L'étude évaluée par les pairs : Are you Talking Logic to Me? Assessing Language Models Syllogistic Reasoning Capabilities, acceptée à RuleML+RR 2026, la 10e International Joint Conference on Rules and Reasoning (hal-05700643).
• L'étude de tâche partagée : SEF-CLGC at SemEval-2026 Task 11 (hal-05606250 ; texte intégral sur arXiv).

Le travail a grandi au sein de l'équipe Wimmics (Inria, CNRS, I3S, Université Côte d'Azur), dont je suis membre depuis début 2023, et il est le cœur de mon doctorat avec le Pr Fabien Gandon et la Pr Catherine Faron, avec Pierre Monnin comme collaborateur proche. Il a été soutenu, dans le cadre du plan France 2030, par l'Agence nationale de la recherche (ANR), l'Initiative d'excellence de l'Université Côte d'Azur, l'institut 3IA Côte d'Azur (l'un des Instituts interdisciplinaires d'intelligence artificielle de France), le centre de calcul haute performance de l'université, et DSTI School of Engineering. Nommer la lignée compte : ces idées s'inscrivent dans un programme plus large sur les graphes de connaissances, le web sémantique et l'IA neuro-symbolique.

06 Vers où cela pointe

La direction en est une que je trouve vraiment digne d'être poursuivie. Si un petit modèle frugal peut être aidé à raisonner sur la structure — en choisissant comment un problème est écrit, et en lui disant de quel genre de problème il s'agit — alors deux portes s'ouvrent.

La première est l'ingénierie des ontologies. Construire les vocabulaires et règles formels qui permettent aux machines de partager du sens est un travail soigneux et coûteux ; un modèle qui raisonne de façon fiable sur une notation formelle compacte pourrait prendre en charge une plus grande part de l'échafaudage, une personne gardant le jugement sur le résultat. C'est la question de doctorat que CLGC a été construit pour servir.

La seconde est le raisonnement traçable. Parce que CLGC garde la forme logique explicite à chaque étape — grammaire, arbre, traduction, catégorie, validation — le chemin d'une question en langage naturel jusqu'à la réponse d'une machine reste inspectable. Un système de raisonnement dont on peut lire les étapes est un système dont on peut trouver les erreurs, ce qui, pour tout ce qui compte, vaut plus qu'un point d'exactitude. La dichotomie entre notations naturelles et abstraites pointe vers des pipelines neuro-symboliques multi-étapes qui utilisent le langage naturel comme première étape et affinent dans une notation formelle compacte — une piste concrète de travaux futurs.

Il reste beaucoup à faire : équilibrer les jeux de données, renforcer la détection des arguments invalides, et réduire la dépendance du pipeline à un quelconque modèle externe unique. Chacun est une prochaine expérience précise, et chacun est plus facile à mener parce que l'outil en dessous est propre.

Si vous êtes un étudiant de DSTI en train de lire ceci, le fil qui va d'un exercice de Warm-Up sur la documentation de votre code, à une classe de base Notation avec une grammaire soignée, jusqu'à un article à une conférence de raisonnement, est plus court et plus droit qu'il n'y paraît en première semaine. Je peux le dire avec une certaine assurance : j'étais assis là où vous êtes, achevant mon propre MSc in Data Science & AI ici en 2018. Construisez bien la petite chose, écrivez ce qu'elle fait, mesurez honnêtement, et partagez les preuves. Le reste tend à suivre.

Corrections et pull requests sont les bienvenues — le dépôt est le meilleur endroit pour ces dernières.