# Apprendre aux machines à lire la logique

Canonical HTML: https://dsti.school/fr/techblog/apprendre-aux-machines-a-lire-la-logique

This Markdown copy is generated from the same DSTI static-site build as the canonical HTML page. It is intended for machine readability and concise retrieval.

[DSTI TechBlog](https://dsti.school/fr/techblog) / AI is tech

Corps enseignant AI is tech

Un modèle de langage moderne sait traduire un menu et tenir une conversation fluide, et pourtant il hésite à dire si un court argument est réellement valide. Le directeur académique Hanna Abi Akl a passé une grande partie de son doctorat dans cet écart — entre un argument qui sonne juste et un argument qui est juste — et a construit un petit paquet Python ouvert, [Common Logic Grammar Construction](https://github.com/HannaAbiAkl/clgc) (CLGC), pour rendre la question mesurable. Voici la science, l’ingénierie qui la porte, et un compte rendu honnête de ce que le travail a permis et de ce qui reste à améliorer.

![Hanna Abi Akl](https://media.dsti.school/wp-content/uploads/2024/10/11160155/DSTI-Hanna-Chief-Academic-Officer-1024x1024.avif)

Par Hanna Abi Akl Directeur académique, DSTI · ancien élève de DSTI (MSc in Data Science & AI, 2018) · doctorant, Wimmics (Inria, CNRS, I3S, Université Côte d’Azur)

12 septembre 2026 22 min de lecture AI is tech

syllogistic-reasoning first-order-logic knowledge-representation neuro-symbolic-ai semantic-web small-language-models open-science

Figure — l’effet de contenu

**Figure:** Un syllogisme invalide représenté par un diagramme d’Euler. Voitures est un sous-ensemble de Véhicules ; Animaux est disjoint de Voitures mais recoupe Véhicules. Le recouvrement étoilé — un animal qui est aussi un véhicule — satisfait les deux prémisses tout en contredisant la conclusion, l’argument est donc invalide.

> **Figure caption:** Pourquoi la conclusion ne suit pas : un animal peut être un véhicule sans être une voiture ; les prémisses laissent donc la conclusion ouverte — l’argument est invalide.

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](https://dsti.school/fr/msc-data-science-ai#course-clean-it) du Warm-Up et nos consignes de
Software Engineering ([SE1](https://dsti.school/fr/msc-data-analytics-ai#course-software-engineering-part-1)/[SE2](https://dsti.school/fr/msc-data-analytics-ai#course-software-engineering-part-2)) ;
le réflexe de la grammaire d'un langage formel que construisent les cours
[The Relational Model and SQL](https://dsti.school/fr/bsc-informatique-ingenierie#course-the-relational-model-and-sql)
et [SQL](https://dsti.school/fr/bsc-informatique-ingenierie#course-the-relational-model-and-sql) (Structured Query Language) — où nous
enseignons SQL comme une notation par-dessus l'[algèbre relationnelle](https://fr.wikipedia.org/wiki/Alg%C3%A8bre_relationnelle),
et où un plan de requête se lit comme l'arbre d'opérateurs qu'un
[optimiseur](https://fr.wikipedia.org/wiki/Optimisation_de_requ%C3%AAte) réécrit ; la boucle « mesurer une
seule chose à la fois » des
[Python Machine Learning Labs](https://dsti.school/fr/msc-data-science-ai#course-python-machine-learning-labs) ;
et les fondations d'entraînement des modèles des cours
[Artificial Neural Networks](https://dsti.school/fr/msc-data-science-ai#course-artificial-neural-networks)
et [Deep Learning](https://dsti.school/fr/msc-data-science-ai#course-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](https://fr.wikipedia.org/wiki/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](https://fr.wikipedia.org/wiki/Calcul_des_propositions), en
[logique du premier ordre](https://fr.wikipedia.org/wiki/Calcul_des_pr%C3%A9dicats) et en la
[logique mathématique](https://fr.wikipedia.org/wiki/Logique_math%C3%A9matique) 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](https://en.wikipedia.org/wiki/Belief_bias)) — 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](https://hal.science/hal-05709316)) et y répond avec un outil
([Partie 2](https://hal.science/hal-05709317)).

## 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 :

```text
∀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](https://dsti.school/fr/enseignants#prof-CORNIGLION) 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](https://fr.wikipedia.org/wiki/Repr%C3%A9sentation_des_connaissances)
(KR) , et John Sowa — dont les travaux sur [Common Logic](https://en.wikipedia.org/wiki/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](https://en.wikipedia.org/wiki/Conceptual_graph) Interchange Format) : proches de FOL, conçues pour rester lisibles.

- Algèbre Plus-Minus — TFL / TFL+ ([Term Functor Logic](https://en.wikipedia.org/wiki/Term_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](https://fr.wikipedia.org/wiki/Answer_set_programming) (ASP) — CLINGO, le langage d'entrée d'un solveur ASP.

- [Prolog](https://fr.wikipedia.org/wiki/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.

- MINIFOL x — 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 :

Notation | Le syllogisme, exactement tel que CLGC l'émet

Langage naturel | Tout Athénien est un Grec. Tout Grec est mortel. Donc tout Athénien est mortel.

FOL (source) | `∀x (Athenian(x) → Greek(x))`
`∀x (Greek(x) → Mortal(x))`
`∀x (Athenian(x) → Mortal(x))`

CLIF | `forall x (athenian(x) implies greek(x))`
`forall x (greek(x) implies mortal(x))`
`forall x (athenian(x) implies mortal(x))`

CGIF | `[@every *x [(athenian[(?x)] greek[(?x)])]`
`@every *x [(greek[(?x)] mortal[(?x)])]`
`@every *x [(athenian[(?x)] mortal[(?x)])]`
`]`

TFL | `-+A1-+G1-+G2-+M2-+A3-+M3`

TFL+ | `-(+A0-+G0)-(+G0-+M0)-(+A0-+M0)`

CLINGO (ASP) | `forall (athenian(x) -: greek(x))`
`forall (greek(x) -: mortal(x))`
`forall (athenian(x) -: mortal(x))`

MINIFOL | `all:x (athenian(x) :- greek(x))`
`all:x (greek(x) :- mortal(x))`
`all:x (athenian(x) :- mortal(x))`

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](https://inria.hal.science/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](https://fr.wikipedia.org/wiki/Forme_de_Backus-Naur) (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 :

- 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é](https://fr.wikipedia.org/wiki/Principe_ouvert/ferm%C3%A9) en pratique — ouvert à l'extension, fermé à la modification — le genre de chose dont parle vraiment SE1/SE2.

- 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 :

- analyse l'énoncé FOL contre la grammaire FOL pour construire un [arbre de syntaxe abstraite](https://fr.wikipedia.org/wiki/Arbre_de_la_syntaxe_abstraite) (AST) — le même intermédiaire en forme d'arbre qu'un compilateur construit à partir du code source ;

- construit un arbre équivalent dans la notation cible au moyen de la grammaire BNF de cette notation ;

- 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).

Figure — grammaire → arbre → émission

**Figure:** Le pipeline grammaire-vers-arbre-vers-émission. Une chaîne source en logique du premier ordre est analysée contre la grammaire FOL en un arbre de syntaxe abstraite, mappée en un arbre équivalent dans la notation cible au moyen de la grammaire cible, puis émise comme chaîne dans la syntaxe cible. La chaîne émise est revalidée contre la grammaire cible avant expédition.

> **Figure caption:** Le pipeline grammaire → arbre → émission : FOL est analysé en un AST, mappé vers l’arbre de la notation cible, émis comme texte, puis revalidé contre la grammaire cible avant expédition.

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](https://dsti.school/fr/techblog/refonte-dsti-school-printemps-2026) en analysant le
[CSS](https://fr.wikipedia.org/wiki/Feuilles_de_style_en_cascade) (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](https://dsti.school/fr/techblog/ingenierie-dsti-school-partie-2) 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](https://dsti.school/fr/techblog/refonte-dsti-school-printemps-2026) et
[Partie 2](https://dsti.school/fr/techblog/ingenierie-dsti-school-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 MINIFOL x 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 :

```text
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](https://fr.wikipedia.org/wiki/Hyper_articles_en_ligne) et
[Software Heritage](https://fr.wikipedia.org/wiki/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](https://fr.wikipedia.org/wiki/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](https://fr.wikipedia.org/wiki/F-score) 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

![Logo du projet Common Logic Grammar Construction (CLGC)](https://media.dsti.school/assets/clgc-logo.png)

> **Figure caption:** CLGC — ouvert sur GitHub et PyPI, archivé et citable sur HAL et Software Heritage.

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

- Code : le paquet CLGC — [github.com/HannaAbiAkl/clgc](https://github.com/HannaAbiAkl/clgc), installable avec `pip install clgc` (sur le [Python Package Index](https://fr.wikipedia.org/wiki/Python_Package_Index) (PyPI), [pypi.org/project/clgc](https://pypi.org/project/clgc/)), archivé et citable via HAL / Software Heritage ([hal-05608340](https://hal.science/hal-05608340)).

- Jeux de données : FOLIO-KR et P-FOLIO-KR, publiés sur Hugging Face ([FOLIO-KR](https://huggingface.co/datasets/HannaAbiAkl/FOLIO-KR), [P-FOLIO-KR](https://huggingface.co/datasets/HannaAbiAkl/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)](https://hal.science/hal-05709316) et [Partie 2 (Cadre CLGC)](https://hal.science/hal-05709317).

- 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](https://hal.science/hal-05700643)).

- L'étude de tâche partagée : SEF-CLGC at SemEval-2026 Task 11 ([hal-05606250](https://hal.science/hal-05606250) ; texte intégral sur [arXiv](https://arxiv.org/abs/2606.09157)).

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](https://fr.wikipedia.org/wiki/Intelligence_artificielle_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](https://fr.wikipedia.org/wiki/Ing%C3%A9nierie_ontologique) .
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](https://github.com/HannaAbiAkl/clgc) est le
meilleur endroit pour ces dernières.

---

© DSTI School of Engineering 2026 - Tous droits réservés. Établissement privé d’enseignement supérieur - V2026.389 - 12 septembre 2026