Séance 2 — L’IA qui raisonne

Logique, inférence, résolution, unification

Dr. El Hadji Bassirou TOURÉ

Département de Mathématiques et Informatique, Faculté des Sciences et Techniques, Université Cheikh Anta Diop de Dakar

Objectifs de la séance

Ce que la séance construit

Le langage et le moteur d’un agent qui raisonne : la logique propositionnelle et la logique du premier ordre pour écrire ce qu’il sait, l’inférence pour en tirer ce qu’il ne perçoit pas. Fil rouge : Ousmane dans le Monde de Bouki, une grotte de Kédougou où la hyène Bouki et des puits ne se signalent que par une odeur et une brise.

  • Écrire des formules propositionnelles, les évaluer dans une interprétation, reconnaître un modèle.
  • Distinguer satisfiable, valide, insatisfiable ; décider \(\mathrm{KB}\models\alpha\) par vérification de modèles.
  • Mettre une formule en forme normale conjonctive ; reconnaître une clause de Horn.
  • Dérouler un chaînage avant et un chaînage arrière, et distinguer \(\vdash\) de \(\models\).
  • Conduire une preuve par réfutation jusqu’à la clause vide.
  • Formaliser en logique du premier ordre, skolémiser, unifier deux termes (unificateur le plus général, test d’occurrence).
  • Situer les systèmes experts et le calcul symbolique ; utiliser SymPy.

Le raisonnement au-delà du réflexe

En Séance 1, l’agent fondé sur un modèle suivait l’humidité du sol par une formule. Un agent qui raisonne va plus loin : il combine ce qu’il a perçu à des règles générales pour en déduire ce qu’il ne perçoit pas.

La limite du réflexe

Ousmane sent une odeur en \((2,1)\). La règle « si odeur, alors fuir » le ferait reculer, alors que Bouki peut être en \((2,2)\) comme en \((3,1)\) : seule la combinaison avec ce qu’il a perçu ailleurs tranche.

La question de la séance

Comment un agent représente-t-il ce qu’il sait, et comment en tire-t-il, de façon correcte, ce qui en découle ?

Lecture. La réponse de l’IA symbolique : un langage formel, la logique, et des règles d’inférence qui ne produisent que des conséquences.

L’agent fondé sur les connaissances

Base de connaissances, TELL, ASK

La base de connaissances (KB) est un ensemble de formules. TELL y ajoute un percept ou une règle ; ASK demande au moteur d’inférence ce qui découle de la base. À chaque pas : percevoir, TELL, ASK, agir.

C’est un agent fondé sur un modèle : le modèle du monde est la base, sa mise à jour est TELL, le choix de l’action passe par ASK.

Lecture. Le moteur d’inférence ne dépend pas du domaine : changer de domaine, c’est changer les formules de la base.

Le fil rouge : le Monde de Bouki

La grotte de Kédougou

Ousmane explore une grotte en grille \(4\times4\), à la recherche d’or. Bouki, la hyène des contes wolof, occupe une case, un puits une autre ; y entrer est mortel. Il part de \((1,1)\), case sûre ; la case \((i,j)\) est à la ligne \(i\) et à la colonne \(j\).

Perceptions dans la case courante : une odeur si Bouki est dans une case voisine (nord, sud, est, ouest), une brise si un puits est voisin, un éclat sur l’or. La figure montre la grotte entière ; Ousmane ne voit que ses percepts.

PEAS et propriétés de l’environnement

P \(+1000\) pour l’or, \(-1000\) pour la mort, \(-1\) par déplacement
E grille \(4\times4\), Bouki, un puits, l’or
A aller au nord, au sud, à l’est, à l’ouest ; ramasser l’or
S odeur, brise, éclat dans la case courante
partiellement observable percepts locaux
déterministe un déplacement réussit
séquentiel chaque pas engage la suite
statique Bouki et le puits restent
discret 16 cases, 5 actions
mono-agent Ousmane seul agit

Lecture. L’observabilité partielle impose de raisonner ; le déterminisme et la statique rendent la logique adaptée : un fait établi le reste.

Repères : l’IA qui raisonne

1854 Boole, The Laws of Thought : le calcul des propositions
1879 Frege, Begriffsschrift : les quantificateurs
1956 Logic Theorist (Newell, Shaw, Simon) : des théorèmes des Principia démontrés par programme
1960, 1962 Davis et Putnam, puis Davis, Logemann et Loveland : l’algorithme DPLL de satisfiabilité
1965 Robinson : le principe de résolution et l’unification (Journal of the ACM)
1971 Cook : SAT est NP-complet
1972 Prolog (Colmerauer, Roussel, Marseille) : la résolution SLD sur des clauses de Horn
années 1970 MYCIN (Shortliffe, Stanford) : environ 600 règles, chaînage arrière, infections bactériennes

Lecture. Des lois de la pensée de Boole à Prolog, un même projet : réduire le raisonnement à un calcul sur des symboles.

Propositions atomiques et connecteurs

Le premier langage de la base : des énoncés vrais ou faux, combinés par des connecteurs.

Proposition atomique

Un symbole qui prend la valeur vrai (V) ou faux (F). Son choix est un acte de modélisation : décider ce que l’agent représente.

\(B_{i,j}\) : Bouki est en \((i,j)\) ; \(P_{i,j}\) : un puits est en \((i,j)\) ; \(O_{i,j}\) : odeur perçue en \((i,j)\) ; \(\mathit{Br}_{i,j}\) : brise perçue en \((i,j)\). Avec 16 cases : 64 symboles.

lecture exemple
\(\neg\) non \(\neg B_{1,2}\)
\(\land\) et \(O_{2,1}\land\neg\mathit{Br}_{2,1}\)
\(\lor\) ou (inclusif) \(B_{2,2}\lor B_{3,1}\)
\(\to\) si… alors \(\neg O_{1,1}\to\neg B_{1,2}\)
\(\leftrightarrow\) ssi \(O_{1,1}\leftrightarrow(B_{1,2}\lor B_{2,1})\)

Lecture. La dernière formule est une règle du monde : odeur en \((1,1)\) si et seulement si Bouki est dans une case voisine.

Formules bien formées et priorités

Formule bien formée

(1) Un symbole est une formule ; (2) si \(\varphi\) en est une, \(\neg\varphi\) aussi ; (3) si \(\varphi\) et \(\psi\) en sont, \((\varphi\land\psi)\), \((\varphi\lor\psi)\), \((\varphi\to\psi)\), \((\varphi\leftrightarrow\psi)\) aussi ; (4) rien d’autre n’en est une.

Priorité décroissante

\(\neg\), puis \(\land\), puis \(\lor\), puis \(\to\), puis \(\leftrightarrow\) : \(\neg P\land Q\to R\) se lit \(((\neg P)\land Q)\to R\).

L’implication

\(P\to Q\) n’est fausse que si \(P\) est vraie et \(Q\) fausse ; si \(P\) est fausse, \(P\to Q\) est vraie. « Si Dakar est en Europe, alors Touba est sur la Lune » est vraie.

Lecture. La grammaire est récursive : un programme vérifie qu’une suite de symboles est une formule et l’évalue par la même récursion.

Les tables de vérité des connecteurs

Colonnes : \(P\), \(Q\), \(\neg P\), \(P\land Q\), \(P\lor Q\), \(P\to Q\), \(P\leftrightarrow Q\).

from itertools import product
def implique(p, q):
    return (not p) or q
for p, q in product([True, False], repeat=2):
    print(p, q, not p, p and q, p or q, implique(p, q), p == q)

Résultat \(\rightarrow\)

True True False True True True True
True False False False True False False
False True True False True True False
False False True False False True True

Lecture. L’implication, avant-dernière colonne, n’est fausse qu’à la deuxième ligne (\(P\) vraie, \(Q\) fausse) ; l’équivalence est l’égalité des valeurs.

Interprétation et modèle

Interprétation, modèle

Une interprétation \(m\) donne une valeur à chaque symbole : \(n\) symboles, \(2^n\) interprétations. \(m\) est un modèle de \(\varphi\) si \(\varphi\) est vraie dans \(m\) ; on note \(m\models\varphi\), et \(\mathrm{Mod}(\varphi)\) l’ensemble des modèles.

def regle21(m):
    # O21 <-> (B11 ou B22 ou B31) : odeur en (2,1) ssi Bouki voisin
    return m["O21"] == (m["B11"] or m["B22"] or m["B31"])
ma = {"O21": True, "B11": False, "B22": True, "B31": False}
mb = {"O21": True, "B11": False, "B22": False, "B31": False}
print(regle21(ma), regle21(mb))
print(2 ** len(ma))

Résultat \(\rightarrow\)

True False
16

Lecture. ma (odeur, Bouki en \((2,2)\)) est un modèle de la règle ; mb (odeur, aucun Bouki voisin) ne l’est pas. Quatre symboles : 16 interprétations.

Satisfiable, valide, insatisfiable

Trois statuts

\(\varphi\) est satisfiable si elle a au moins un modèle, valide (une tautologie) si toute interprétation en est un modèle, insatisfiable (une contradiction) si elle n’en a aucun.

\(P\land Q\) satisfiable, non valide
\(P\lor\neg P\) valide (tiers exclu)
\(P\land\neg P\) insatisfiable

Le lien qui fonde la réfutation

\(\varphi\) est valide \(\iff\) \(\neg\varphi\) est insatisfiable.

\(\mathrm{KB}\models\alpha\) \(\iff\) \(\mathrm{KB}\land\neg\alpha\) est insatisfiable.

Lecture. Décider une conséquence revient à décider une insatisfiabilité : c’est le principe de la preuve par réfutation.

La conséquence logique

Conséquence logique

\(\alpha\) est conséquence logique de KB, noté \(\mathrm{KB}\models\alpha\), si tout modèle de KB est un modèle de \(\alpha\) : \(\mathrm{Mod}(\mathrm{KB})\subseteq\mathrm{Mod}(\alpha)\).

\(\{P,\ P\to Q\}\models Q\) : le seul modèle des prémisses, \(P=Q=\) V, rend \(Q\) vraie.

Lecture. Plus la base contient de formules, moins elle a de modèles, plus elle a de conséquences : chaque percept élimine des mondes possibles.

Le raisonnement d’Ousmane en trois cases

\(\neg O_{1,1}\) et \(O_{1,1}\leftrightarrow(B_{1,2}\lor B_{2,1})\) donnent \(\neg B_{1,2}\land\neg B_{2,1}\) ; \(O_{2,1}\) et \(O_{2,1}\leftrightarrow(B_{1,1}\lor B_{2,2}\lor B_{3,1})\), avec \(\neg B_{1,1}\), donnent \(B_{2,2}\lor B_{3,1}\) ; de même \((1,2)\) donne \(B_{1,3}\lor B_{2,2}\). Bouki n’occupe qu’une case : \(B_{2,2}\).

Lecture. Après \((2,1)\), deux mondes restent possibles pour Bouki ; l’odeur en \((1,2)\) et l’unicité n’en laissent qu’un.

La vérification de modèles, pas à pas

Sortie \(\rightarrow\)

(False, True, False) True
True

Lecture. Initialisation (lignes 1–2, 7–8, 15) : symboles, base, appel ; aucune interprétation vue.

Lecture. Tour 1 : FFF ; \(r_1\) et \(r_2\) sont fausses (lignes 3–6) : la ligne 11 écarte cette interprétation.

Lecture. Tour 2 : FFV ; \(r_2\) est fausse (lignes 3–6) : la ligne 11 écarte cette interprétation.

Lecture. Tour 3 : FVF rend vraies \(r_1\), \(r_2\) et l’unicité : un modèle de KB ; la ligne 12 affiche \(\alpha\), vraie.

Lecture. Tour 4 : FVV ; l’unicité est fausse (lignes 3–6) : la ligne 11 écarte cette interprétation.

Lecture. Tour 5 : VFF ; \(r_1\) est fausse (lignes 3–6) : la ligne 11 écarte cette interprétation.

Lecture. Tour 6 : VFV ; l’unicité est fausse (lignes 3–6) : la ligne 11 écarte cette interprétation.

Lecture. Tour 7 : VVF ; l’unicité est fausse (lignes 3–6) : la ligne 11 écarte cette interprétation.

Lecture. Tour 8 : VVV ; l’unicité est fausse (lignes 3–6) : la ligne 11 écarte cette interprétation.

Lecture. Ligne 14 : ok est resté vrai ; \(\alpha=B_{2,2}\) est vraie dans l’unique modèle : KB \(\models B_{2,2}\).

Énumération : quoi, pourquoi, quand ça échoue

Quoi, pourquoi, quand ça échoue

Quoi : énumérer les \(2^n\) interprétations et vérifier que \(\alpha\) est vraie dans chaque modèle de KB.

Pourquoi : c’est la définition même de \(\models\) ; la méthode est correcte et complète, et termine toujours en logique propositionnelle.

Quand ça échoue : quand \(n\) grandit. Les 64 symboles de la grotte donnent \(1{,}84\times10^{19}\) interprétations.

for n in [3, 16, 32, 64]:
    print(n, f"{2 ** n:.3g}")

Résultat \(\rightarrow\)

3 8
16 6.55e+04
32 4.29e+09
64 1.84e+19

Lecture. Chaque symbole de plus double le travail : il faut une méthode qui manipule les formules au lieu d’énumérer les mondes.

Exercice : trois formules à classer

Énoncé

\(\varphi_1=P\to(Q\to P)\), \(\varphi_2=(P\to Q)\land(P\land\neg Q)\), \(\varphi_3=((P\to Q)\land(Q\to R))\to(P\to R)\). (a)–(c) Remplir la table et classer chaque formule. (d) Même question pour \((P\land Q)\to R\).

Correction

  1. \(\varphi_1=P\to(Q\to P)\) : V sur les 8 lignes ; si \(P\) est vrai, \(Q\to P\) l’est aussi : valide.
  2. \(\varphi_2=(P\to Q)\land(P\land\neg Q)\) : F partout ; \(P\land\neg Q\) est la négation de \(P\to Q\) : insatisfiable.
  3. \(\varphi_3\) (transitivité) : V sur les 8 lignes : valide ; c’est la règle du syllogisme hypothétique.
  4. \((P\land Q)\to R\) : 7 modèles sur 8, fausse seulement pour \(P=Q=\) V, \(R=\) F : satisfiable, non valide.

Les équivalences fondamentales

Pour manipuler les formules plutôt que les mondes, il faut des réécritures qui conservent les modèles : \(\varphi\equiv\psi\) si \(\mathrm{Mod}(\varphi)=\mathrm{Mod}(\psi)\).

élimination de \(\to\) \(P\to Q\equiv\neg P\lor Q\)
élimination de \(\leftrightarrow\) \(P\leftrightarrow Q\equiv(P\to Q)\land(Q\to P)\)
De Morgan \(\neg(P\land Q)\equiv\neg P\lor\neg Q\), \(\neg(P\lor Q)\equiv\neg P\land\neg Q\)
double négation \(\neg\neg P\equiv P\)
contraposition \(P\to Q\equiv\neg Q\to\neg P\)
distributivité \(P\lor(Q\land R)\equiv(P\lor Q)\land(P\lor R)\), \(P\land(Q\lor R)\equiv(P\land Q)\lor(P\land R)\)
absorption \(P\land(P\lor Q)\equiv P\), \(P\lor(P\land Q)\equiv P\)

Lecture. \(\neg(P\to Q)\equiv\neg(\neg P\lor Q)\equiv P\land\neg Q\) : une implication n’est fausse que si la prémisse est vraie et la conclusion fausse.

La forme normale conjonctive

Littéral, clause, FNC

Un littéral est un symbole ou sa négation ; une clause, une disjonction de littéraux ; une formule est en forme normale conjonctive (FNC) si elle est une conjonction de clauses.

Toute formule a une FNC équivalente ; la clause vide, notée \(\square\), est fausse dans toute interprétation.

Mise en FNC

  1. Éliminer \(\leftrightarrow\) : \((\varphi\to\psi)\land(\psi\to\varphi)\).
  2. Éliminer \(\to\) : \(\neg\varphi\lor\psi\).
  3. Porter les négations sur les symboles (De Morgan, double négation).
  4. Distribuer \(\lor\) sur \(\land\).

Lecture. La distribution peut faire exploser la taille : \((P_1\land Q_1)\lor\cdots\lor(P_n\land Q_n)\) donne \(2^n\) clauses.

Une règle de Bouki en FNC

\(O_{2,1}\leftrightarrow(B_{1,1}\lor B_{2,2}\lor B_{3,1})\) ; étape 1 : \((O_{2,1}\to B_{1,1}\lor B_{2,2}\lor B_{3,1})\land(B_{1,1}\lor B_{2,2}\lor B_{3,1}\to O_{2,1})\) ; étape 2 : \((\neg O_{2,1}\lor B_{1,1}\lor B_{2,2}\lor B_{3,1})\land(\neg(B_{1,1}\lor B_{2,2}\lor B_{3,1})\lor O_{2,1})\) ; étapes 3 et 4 : \(\neg(\ldots)\) devient \(\neg B_{1,1}\land\neg B_{2,2}\land\neg B_{3,1}\), que la distribution répartit en trois clauses.

from sympy import symbols, Or, And, Not, Equivalent, to_cnf
O21, B11, B22, B31 = symbols("O21 B11 B22 B31")
regle = Equivalent(O21, Or(B11, B22, B31))
print(to_cnf(regle))

Résultat \(\rightarrow\)

(O21 | ~B11) & (O21 | ~B22) & (O21 | ~B31) & (B11 | B22 | B31 | ~O21)

Lecture. Quatre clauses : une pour « odeur, donc un Bouki voisin », trois pour « un Bouki voisin, donc odeur ». SymPy trouve la même FNC.

Forme normale disjonctive et clauses de Horn

Forme normale disjonctive

Une disjonction de conjonctions de littéraux. Une FND est satisfiable si et seulement si l’une de ses conjonctions ne contient pas un littéral et sa négation.

La FND décide la satisfiabilité par un parcours de ses conjonctions, mais sa construction est en général exponentielle : ses conjonctions décrivent des familles de modèles.

Clause de Horn

Une clause d’au plus un littéral positif. Clause définie : exactement un, \(\neg P_1\lor\cdots\lor\neg P_k\lor Q\equiv(P_1\land\cdots\land P_k)\to Q\) ; un fait si \(k=0\). Clause but : aucun littéral positif.

Lecture. Sur des clauses définies, décider \(\mathrm{KB}\models q\) se fait en temps linéaire en la taille de la base : c’est le terrain des chaînages.

Exercice : quatre formules en FNC

Énoncé

Mettre en FNC, en nommant chaque étape : (a) \((P\land Q)\to R\) ; (b) \(\neg(P\lor(Q\land R))\) ; (c) \((P\leftrightarrow Q)\to R\) ; (d) \(\neg((P\to Q)\to R)\). Compter les clauses.

Correction

  1. Éliminer \(\to\) : \(\neg(P\land Q)\lor R\), puis De Morgan : une clause \(\neg P\lor\neg Q\lor R\).
  2. De Morgan deux fois : \(\neg P\land\neg(Q\land R)=\neg P\land(\neg Q\lor\neg R)\) : deux clauses.
  3. \(\neg(P\leftrightarrow Q)\lor R\), soit \(((P\land\neg Q)\lor(\neg P\land Q))\lor R\) ; la distribution donne quatre clauses, dont deux tautologies (\(P\lor\neg P\lor R\)) supprimées.
  4. \(\neg(A\to B)\equiv A\land\neg B\) avec \(A=P\to Q\) : \((\neg P\lor Q)\land\neg R\) : deux clauses.

Dérivabilité et conséquence logique

La vérification de modèles parle des mondes ; une règle d’inférence parle des formules. Le lien entre les deux est le cœur de la logique.

\(\vdash\) et \(\models\)

\(\mathrm{KB}\vdash_i\alpha\) : \(\alpha\) est dérivable de KB par les règles de la procédure \(i\), une manipulation de symboles. \(\mathrm{KB}\models\alpha\) : \(\alpha\) est conséquence logique de KB, une propriété des modèles.

Correction, complétude

La procédure \(i\) est correcte si \(\mathrm{KB}\vdash_i\alpha\) entraîne \(\mathrm{KB}\models\alpha\), complète si \(\mathrm{KB}\models\alpha\) entraîne \(\mathrm{KB}\vdash_i\alpha\).

Lecture. Une procédure correcte ne dérive que des formules vraies dans tous les modèles de la base ; une procédure complète les dérive toutes.

Règles d’inférence

modus ponens \(\dfrac{P\to Q P}{Q}\)
modus tollens \(\dfrac{P\to Q \neg Q}{\neg P}\)
élimination du \(\land\) \(\dfrac{P\land Q}{P}\)
syllogisme \(\dfrac{P\to Q Q\to R}{P\to R}\)

Modus ponens et modus tollens

« Si Amadou rate le bus Dakar Dem Dikk de 7 h, il arrive en retard ; il l’a raté » : il arrive en retard. « Si le thiéboudienne est bien cuit, le riz est tendre ; le riz n’est pas tendre » : il n’est pas bien cuit.

Correctes, non complètes

Avec le seul modus ponens, \(\{P\lor Q,\ P\to R,\ Q\to R\}\) ne dérive pas \(R\), qui en est pourtant conséquence.

Lecture. Chaque règle préserve la vérité ; à elles quatre, elles ne dérivent pas toutes les conséquences : la résolution le fera, par réfutation.

Une base de Horn pour le Monde de Bouki

R11 : ni odeur ni brise en \((1,1)\) ; O21, O12 : odeur ; C21, C12 : pas de brise (calme) ; OK\(_{i,j}\) : ni Bouki ni puits en \((i,j)\). Chaque règle est une conséquence des règles du monde (odeur, brise, un seul Bouki).

REGLES = [(["R11"], "OK12"), (["R11"], "OK21"),
          (["O21", "O12"], "B22"),
          (["B22", "C21"], "OK31"), (["B22", "C12"], "OK13")]
FAITS = ["R11", "O21", "C21", "O12", "C12"]
print(len(REGLES), len(FAITS))

Résultat \(\rightarrow\)

5 5

Lecture. Cinq clauses définies et cinq faits : « \((1,1)\) calme, donc \((1,2)\) et \((2,1)\) sûres », « deux odeurs, donc Bouki en \((2,2)\) ».

Le chaînage avant, pas à pas

agenda (tête à gauche) : R11 O21 C21 O12 C12

agenda (tête à gauche) : O21 C21 O12 C12 OK12 OK21

agenda (tête à gauche) : C21 O12 C12 OK12 OK21

agenda (tête à gauche) : O12 C12 OK12 OK21

agenda (tête à gauche) : C12 OK12 OK21 B22

agenda (tête à gauche) : OK12 OK21 B22

agenda (tête à gauche) : OK21 B22

agenda (tête à gauche) : B22

agenda (tête à gauche) : OK31 OK13

agenda (tête à gauche) : OK13

agenda (tête à gauche) : {vide}

Sortie \(\rightarrow\)

R11O21C21O12C12OK12OK21B22OK31True

Lecture. Initialisation (lignes 1–4, 18) : un compteur de prémisses par règle ; les cinq faits dans l’agenda.

Lecture. Tour 1 : R11 sort ; règles 1, 2 à 0 (ligne 14) ; la ligne 16 ajoute OK12 et OK21.

Lecture. Tour 2 : O21 sort, est inféré ; la ligne 14 décrémente la règle 3, qui attend encore une prémisse.

Lecture. Tour 3 : C21 sort, est inféré ; la ligne 14 décrémente la règle 4, qui attend encore une prémisse.

Lecture. Tour 4 : O12 sort ; règle 3 à 0 (ligne 14) ; la ligne 16 ajoute B22.

Lecture. Tour 5 : C12 sort, est inféré ; la ligne 14 décrémente la règle 5, qui attend encore une prémisse.

Lecture. Tour 6 : OK12 sort, est inféré (ligne 10) ; aucune règle ne l’a en prémisse : rien ne change.

Lecture. Tour 7 : OK21 sort, est inféré (ligne 10) ; aucune règle ne l’a en prémisse : rien ne change.

Lecture. Tour 8 : B22 sort ; règles 4, 5 à 0 (ligne 14) ; la ligne 16 ajoute OK31 et OK13.

Lecture. Tour 9 : OK31 sort, est inféré (ligne 10) ; aucune règle ne l’a en prémisse : rien ne change.

Lecture. Tour 10 : OK13 sort, égal au but \(q\) (ligne 7) : la ligne 8 rend True ; OK13 n’est jamais traité.

Chaînage avant : quoi, pourquoi, quand ça échoue

Quoi, pourquoi, quand ça échoue

Quoi : partir des faits, et chaque fois que toutes les prémisses d’une règle sont connues, ajouter sa conclusion à l’agenda ; un compteur par règle évite de les revérifier.

Pourquoi : chaque ajout est un modus ponens, donc correct ; sur des clauses définies, il est complet pour les symboles conséquences de la base, en temps linéaire en la taille de la base.

Quand ça échoue : une règle à conclusion disjonctive, \(O_{2,1}\to B_{2,2}\lor B_{3,1}\), n’est pas une clause de Horn ; hors de ce cadre, il est incomplet. Dirigé par les données, il infère aussi l’inutile : OK12, OK21 et OK31 pour prouver OK13.

Lecture. Le chaînage avant convient à un agent qui surveille : chaque percept nouveau déclenche les déductions qu’il permet.

Le chaînage arrière, pas à pas

but q : {aucun}pile : {vide}

but q : OK13 pile : {vide}

but q : B22 pile : OK13

but q : O21 pile : OK13 B22

but q : O12 pile : OK13 B22

but q : C12 pile : OK13

but q : {aucun}pile : {vide}

Sortie \(\rightarrow\) 

but : OK13but : B22but : O21
but : O12but : C12True

Lecture. Initialisation (ligne 1, 14) : appel sur le but OK13, pile vide.

Lecture. Appel 1 : OK13 n’est pas un fait ; règle 5 (lignes 7–9), la ligne 11 appelle ses prémisses.

Lecture. Appel 2 : B22 n’est pas un fait ; règle 3 (lignes 7–9), la ligne 11 appelle ses prémisses.

Lecture. Appel 3 : le but O21 s’affiche (ligne 2) ; c’est un fait (ligne 3), la ligne 4 rend True.

Lecture. Appel 4 : O12 est un fait (lignes 3–4) ; O21 l’était : B22 est prouvé (ligne 12).

Lecture. Appel 5 : le but C12 s’affiche (ligne 2) ; c’est un fait (ligne 3), la ligne 4 rend True.

Lecture. Retour : C12 et B22 prouvés, OK13 l’est (ligne 12) ; la ligne 14 affiche True.

Chaînage avant et chaînage arrière comparés

chaînage avant chaînage arrière
direction des faits vers les conclusions du but vers les faits
dirigé par les données le but
sur la base de Bouki 9 symboles traités avant OK13 5 buts examinés
coût linéaire en la taille de la base souvent bien moins, limité aux buts utiles
risque conclusions inutiles boucles, d’où la pile des buts
usage surveillance, systèmes de production Prolog, diagnostic (MYCIN)

La pile des buts

Avec \(P\to Q\) et \(Q\to P\), prouver \(P\) demande \(Q\), qui demande \(P\) : sans le test de la ligne 5, la récursion ne termine pas.

Lecture. Les deux sont corrects et, sur des clauses définies, complets pour les symboles ; ils diffèrent par ce qu’ils calculent en route.

Exercice : le passage de Fatou en année supérieure

Énoncé

Faits I (inscrite), R (examens réussis) ; règles \(I\land R\to V\) (année validée), \(V\to A\) (attestation), \(V\to P\) (passage). (a)–(c) Dérouler le chaînage avant pour le but P (agenda, compteurs). (d) Dérouler le chaînage arrière.

Correction

  1. Agenda I, R : I fait passer la règle 1 à 1, R à 0 : V entre dans l’agenda.
  2. V fait passer les règles 2 et 3 à 0 : A puis P entrent ; A est inféré au tour suivant.
  3. Ordre de sortie : I, R, V, A, P ; P sort au tour 5, égal au but : succès. A est un fait inféré inutile au but.
  4. Chaînage arrière : buts P, V, I, R (4 buts) ; A n’est jamais établi : la recherche part du but.

La règle de résolution

Résolution

\(\dfrac{\ell\lor A\qquad\neg\ell\lor B}{A\lor B}\)

\(A\), \(B\) : disjonctions, éventuellement vides ; \(A\lor B\) est la résolvante.

\(\dfrac{P\qquad\neg P}{\square}\) : la clause vide.

def neg(l):
    return l[1:] if l.startswith("~") else "~" + l
def fmt(c):
    tri = sorted(c, key=lambda l: l.lstrip("~"))
    return " | ".join(tri) or "[]"
def resolvantes(ci, cj):
    out = []
    for l in sorted(ci):
        if neg(l) in cj:
            r = (ci - {l}) | (cj - {neg(l)})
            if not any(neg(x) in r for x in r):
                out.append(r)
    return out
def noter(r, c, d):
    print(fmt(r), ":", fmt(c), "+", fmt(d))
print([fmt(r) for r in resolvantes(frozenset({"~O21", "B22"}),
                                    frozenset({"O21"}))])

Résultat \(\rightarrow\)

['B22']

Lecture. \(\neg O_{2,1}\lor B_{2,2}\) et \(O_{2,1}\) donnent \(B_{2,2}\) : le modus ponens est une résolution. Les résolvantes tautologiques sont écartées.

La preuve par réfutation

Théorème de réfutation

\(\mathrm{KB}\models\alpha\) si et seulement si \(\mathrm{KB}\land\neg\alpha\) est insatisfiable.

Prouver \(\mathrm{KB}\models\alpha\)

  1. Mettre \(\mathrm{KB}\land\neg\alpha\) en FNC.
  2. Résoudre des paires de clauses, ajouter les résolvantes nouvelles.
  3. \(\square\) obtenue : \(\mathrm{KB}\models\alpha\). Plus aucune résolvante nouvelle : \(\mathrm{KB}\not\models\alpha\).
KB = [frozenset(c) for c in [
    {"B22", "B31"}, {"B13", "B22"},        # odeurs
    {"~B13", "~B22"}, {"~B13", "~B31"},    # un seul Bouki
    {"~B22", "~B31"}]]
print([fmt(c) for c in KB])

Résultat \(\rightarrow\)

['B22 | B31', 'B13 | B22', '~B13 | ~B22', '~B13 | ~B31', '~B22 | ~B31']

But \(\alpha=B_{2,2}\) ; but nié : \(\neg B_{2,2}\).

Ensemble de support

Ne résoudre que des paires dont une clause vient du but nié ou de ses descendantes. Si KB est satisfiable, la réfutation reste complète (Wos, Robinson, Carson, 1965).

La réfutation, pas à pas

support (tête à gauche) : \(\neg\)B22

support (tête à gauche) : B31 B13

support (tête à gauche) : B13 \(\neg\)B13

support (tête à gauche) : \(\neg\)B13 \(\neg\)B31

support (tête à gauche) : \(\neg\)B31 B22

Sortie \(\rightarrow\) 

B31 : ~B22 + B22 | B31B13 : ~B22 + B13 | B22~B13 : B31 + ~B13 | ~B31
~B31 : B13 + ~B13 | ~B31B22 : ~B13 + B13 | B22[] : ~B13 + B13
True

Lecture. Initialisation (lignes 1–3, 16) : cinq clauses de KB traitées ; le support contient le but nié \(\neg B_{2,2}\).

Lecture. Tour 1 : \(\neg B_{2,2}\) sort du support ; la ligne 12 y ajoute \(B_{3,1}\) et \(B_{1,3}\) ; la ligne 14 la range.

Lecture. Tour 2 : \(B_{3,1}\) sort du support ; la ligne 12 y ajoute \(\neg B_{1,3}\) ; la ligne 14 la range.

Lecture. Tour 3 : \(B_{1,3}\) sort du support ; la ligne 12 y ajoute \(\neg B_{3,1}\) ; la ligne 14 la range.

Lecture. Tour 4 : \(\neg B_{1,3}\) donne \(B_{2,2}\) avec la clause 2, puis la clause vide avec \(B_{1,3}\) (ligne 8) : KB \(\models B_{2,2}\).

Résolution : quoi, pourquoi, quand ça échoue

Quoi, pourquoi, quand ça échoue

Quoi : saturer \(\mathrm{KB}\land\neg\alpha\), mise en clauses, par résolution, jusqu’à la clause vide ou jusqu’à ce que plus rien de nouveau n’apparaisse.

Pourquoi : la résolution est correcte (toute résolvante est conséquence de ses deux parents, donc \(\square\) prouve l’insatisfiabilité) et complète pour la réfutation : tout ensemble de clauses insatisfiable mène à \(\square\) (Robinson, 1965). En propositionnel, le nombre de clauses possibles est fini : la saturation termine.

Quand ça échoue : la saturation peut produire un nombre exponentiel de clauses ; sur la même base, toutes les paires produisent 9 clauses nouvelles avant \(\square\), l’ensemble de support 5.

Complète pour la réfutation, pas pour la génération

La résolution ne dérive pas toute conséquence : de \(P\), elle ne tire pas \(P\lor Q\). Elle réfute \(\neg(P\lor Q)\), c’est-à-dire \(\neg P\) et \(\neg Q\), avec \(P\).

Le problème SAT et les solveurs

SAT

Décider si une formule en FNC est satisfiable : le premier problème démontré NP-complet (Cook, 1971) ; la validité est co-NP-complète.

DPLL (1962) combine retour arrière, propagation unitaire et littéraux purs ; les solveurs actuels y ajoutent l’apprentissage de clauses de conflit et traitent des millions de variables (vérification de circuits, planification).

from sympy import satisfiable
B13 = symbols("B13")
base = And(Or(B22, B31), Or(B13, B22), Not(And(B13, B22)),
           Not(And(B13, B31)), Not(And(B22, B31)))
for m in satisfiable(base, all_models=True):
    print(sorted(m.items(), key=str))
print(satisfiable(And(base, Not(B22))))

Résultat \(\rightarrow\)

[(B13, False), (B22, True), (B31, False)]
False

Lecture. SymPy énumère un seul modèle pour la base de Bouki, \(B_{2,2}\) vrai ; KB \(\land\neg B_{2,2}\) est insatisfiable : KB \(\models B_{2,2}\).

Exercice : quatre clauses

Énoncé

C1 : \(P\lor Q\), C2 : \(\neg P\lor R\), C3 : \(\neg Q\lor R\), C4 : \(\neg R\). (a)–(c) Dériver de nouvelles clauses jusqu’à \(\square\) ; la base est-elle satisfiable ? (d) Et sans C4 ?

Correction

  1. C2 et C4 sur \(R\) : C5 \(=\neg P\) ; C3 et C4 sur \(R\) : C6 \(=\neg Q\) (deux résolutions unitaires).
  2. C1 et C5 sur \(P\) : C7 \(=Q\).
  3. C6 et C7 sur \(Q\) : la clause vide \(\square\). La base est insatisfiable : aucune interprétation ne rend vraies les quatre clauses.
  4. Sans C4, la base est satisfiable (\(R=\) V) : \(\{C_1,C_2,C_3\}\models R\), la preuve par cas que C4 contredit.

Les limites de la logique propositionnelle

La logique propositionnelle ne parle que de faits particuliers : elle n’a ni objets, ni relations, ni « pour tout ».

Une règle par case

La règle de l’odeur s’écrit 16 fois, une par case ; l’unicité de Bouki demande \(\binom{16}{2}=120\) clauses \(\neg B_{i,j}\lor\neg B_{k,l}\). Une grotte \(10\times10\) : 100 règles, 4 950 clauses.

À l’UCAD

« Tout étudiant inscrit paie ses droits » : une implication par étudiant, \(\mathit{InscritFatou}\to\mathit{PaieFatou}\), … ; en logique du premier ordre, une seule formule :

\(\forall x\,(\mathit{Inscrit}(x)\to\mathit{Paie}(x))\).

Lecture. La logique du premier ordre ajoute des objets, des propriétés et relations entre objets, et des quantificateurs.

Le vocabulaire de la logique du premier ordre

constantes \(\mathit{Fatou}\), \(\mathit{Dakar}\), \(\mathit{IA}\)
variables \(x\), \(y\), \(z\)
fonctions \(\mathit{pere}(x)\), \(\mathit{encadrant}(x)\)
prédicats \(\mathit{Etudiant}(x)\), \(\mathit{Enseigne}(x,y)\)
quantificateurs \(\forall\) (pour tout), \(\exists\) (il existe)
connecteurs \(\neg,\land,\lor,\to,\leftrightarrow\), et \(=\)

Terme, atome

Un terme désigne un objet : une constante, une variable, ou \(f(t_1,\ldots,t_n)\) avec des termes \(t_i\). Un atome applique un prédicat à des termes : \(\mathit{Enseigne}(\mathit{DrToure},\mathit{IA})\), vrai ou faux.

Une fonction rend un objet, un prédicat une valeur de vérité : \(\mathit{pere}(\mathit{Fatou})\) est une personne, \(\mathit{Etudiant}(\mathit{Fatou})\) un énoncé.

Les quantificateurs

\(\forall\) et \(\exists\)

\(\forall x\,\varphi\) est vraie si \(\varphi\) est vraie pour tout objet du domaine ; un contre-exemple la rend fausse. \(\exists x\,\varphi\) est vraie si \(\varphi\) l’est pour au moins un objet ; un témoin la rend vraie.

Une variable est liée sous la portée d’un quantificateur, libre sinon ; une formule sans variable libre est close.

\(\forall\) avec \(\to\), \(\exists\) avec \(\land\)

\(\forall x\,(\mathit{Etudiant}(x)\to\mathit{Paie}(x))\) : tout étudiant paie. Avec \(\land\) : tout objet du domaine, salle ou cours compris, serait un étudiant qui paie.

\(\exists x\,(\mathit{Etudiant}(x)\land\mathit{Boursier}(x))\) : un étudiant boursier existe. Avec \(\to\) : vraie dès qu’un objet n’est pas étudiant.

Ordre des quantificateurs et dualité

\(\forall x\,\exists y\,\mathit{Inscrit}(x,y)\) : chacun suit un cours, pas forcément le même. \(\exists y\,\forall x\,\mathit{Inscrit}(x,y)\) : un même cours pour tous ; la seconde entraîne la première, pas l’inverse.

Dualité des quantificateurs

\(\neg\forall x\,\varphi\equiv\exists x\,\neg\varphi\) \(\neg\exists x\,\varphi\equiv\forall x\,\neg\varphi\)

ETUDIANTS = ["Fatou", "Amadou", "Awa"]
COURS = ["IA", "ML"]
INSCRIT = {("Fatou", "IA"), ("Amadou", "IA"), ("Awa", "ML")}
# pour tout x, il existe y : Inscrit(x, y)
print(all(any((x, y) in INSCRIT for y in COURS) for x in ETUDIANTS))
# il existe y, pour tout x : Inscrit(x, y)
print(any(all((x, y) in INSCRIT for x in ETUDIANTS) for y in COURS))

Résultat \(\rightarrow\)

True
False

Lecture. Sur un domaine fini, \(\forall\) est un all et \(\exists\) un any : Fatou suit IA, Amadou IA, Awa ML ; aucun cours n’est commun aux trois.

Interprétation en logique du premier ordre

Structure

Une interprétation fixe un domaine \(D\) non vide, un objet de \(D\) pour chaque constante, une fonction \(D^n\to D\) pour chaque fonction, une relation \(\subseteq D^n\) pour chaque prédicat. \(\models\) se définit comme avant : tout modèle de KB est un modèle de \(\alpha\).

Une structure de l’UCAD

\(D=\{\mathit{Fatou},\mathit{Amadou},\mathit{DrToure},\mathit{IA},\mathit{ML}\}\) ; \(\mathit{Enseigne}=\{(\mathit{DrToure},\mathit{IA})\}\) : \(\mathit{Enseigne}(\mathit{DrToure},\mathit{IA})\) est vraie, \(\mathit{Enseigne}(\mathit{Fatou},\mathit{ML})\) fausse.

Lecture. Les domaines peuvent être infinis : on ne peut plus énumérer les modèles, il faut raisonner sur les formules.

Le Monde de Bouki en logique du premier ordre

Les cases deviennent des objets, \([i,j]\) ; trois formules remplacent les 16 règles et les 120 clauses.

odeur \(\forall c\,(\mathit{Odeur}(c)\leftrightarrow\exists d\,(\mathit{Voisine}(c,d)\land\mathit{Bouki}(d)))\)
brise \(\forall c\,(\mathit{Brise}(c)\leftrightarrow\exists d\,(\mathit{Voisine}(c,d)\land\mathit{Puits}(d)))\)
unicité \(\forall c\,\forall d\,((\mathit{Bouki}(c)\land\mathit{Bouki}(d))\to c=d)\)
voisinage \(\forall i\,\forall j\,\forall k\,\forall l\,(\mathit{Voisine}([i,j],[k,l])\leftrightarrow |i-k|+|j-l|=1)\)
percepts \(\neg\mathit{Odeur}([1,1])\), \(\mathit{Odeur}([2,1])\), \(\mathit{Odeur}([1,2])\)

Lecture. La taille de la base ne dépend plus de la grille ; le prix est la perte de la décision par énumération.

Exercice : formalisation et évaluation à l’UCAD

Énoncé

Formaliser, puis évaluer dans la structure : (1) tout étudiant est inscrit à au moins un cours ; (2) un cours réunit tous les étudiants ; (3) aucun professeur n’est étudiant ; (4) un étudiant réussit tous ses cours. \(E\), \(C\), \(I\), \(P\), \(R\) : Etudiant, Cours, Inscrit, Prof, Reussit.

Correction

  1. \(\forall x\,(E(x)\to\exists c\,(C(c)\land I(x,c)))\) : vraie, Fatou suit IA, Amadou ML. Avec \(\land\) au lieu de \(\to\), fausse : DrToure n’est pas étudiant.
  2. \(\exists c\,(C(c)\land\forall x\,(E(x)\to I(x,c)))\) : fausse, aucun cours commun ; l’ordre des quantificateurs change le sens.
  3. \(\forall x\,(P(x)\to\neg E(x))\), ou \(\neg\exists x\,(P(x)\land E(x))\) : vraie.
  4. \(\exists x\,(E(x)\land\forall c\,((C(c)\land I(x,c))\to R(x,c)))\) : vraie, témoin Fatou.

Forme prénexe et skolémisation

Pour résoudre au premier ordre, il faut des clauses : les quantificateurs doivent disparaître.

Forme prénexe

Tous les quantificateurs en tête, puis une matrice sans quantificateur : \((\forall x\,P(x))\to(\exists y\,Q(y))\) devient \(\exists x\,\exists y\,(\neg P(x)\lor Q(y))\), après élimination de \(\to\) et dualité.

Skolémisation

Chaque \(\exists y\) est remplacé par une fonction de Skolem nouvelle des variables universelles qui le précèdent : \(\forall x\,\exists y\,\mathit{Aime}(x,y)\) devient \(\forall x\,\mathit{Aime}(x,f(x))\) ; sans \(\forall\) devant, une constante de Skolem : \(\exists y\,\forall x\,\mathit{Aime}(x,y)\) devient \(\forall x\,\mathit{Aime}(x,c)\).

Équisatisfiable, pas équivalente

La formule skolémisée est satisfiable si et seulement si l’originale l’est ; elles ne sont pas équivalentes. C’est ce que demande la réfutation, qui ne teste que l’insatisfiabilité.

La forme clausale en logique du premier ordre

Mise en clauses

  1. Éliminer \(\leftrightarrow\) et \(\to\).
  2. Porter les négations (De Morgan, dualité).
  3. Renommer : une variable par quantificateur.
  4. Mettre en forme prénexe.
  5. Skolémiser.
  6. Supprimer les \(\forall\).
  7. Distribuer \(\lor\) sur \(\land\).
  8. Séparer les clauses.

Tout étudiant a un encadrant professeur

\(\forall x\,(\mathit{Etudiant}(x)\to\exists y\,(\mathit{Prof}(y)\land\mathit{Encadre}(y,x)))\)

1–4 : \(\forall x\,\exists y\,(\neg\mathit{Etudiant}(x)\lor(\mathit{Prof}(y)\land\mathit{Encadre}(y,x)))\)

5–6 : \(y\) dépend de \(x\), \(y\mapsto f(x)\) : \(\neg\mathit{Etudiant}(x)\lor(\mathit{Prof}(f(x))\land\mathit{Encadre}(f(x),x))\)

7–8 : \(C_1=\neg\mathit{Etudiant}(x)\lor\mathit{Prof}(f(x))\)

\(C_2=\neg\mathit{Etudiant}(x)\lor\mathit{Encadre}(f(x),x)\)

Lecture. \(f(x)\) est « l’encadrant de \(x\) » : le témoin de l’existentielle devient un terme calculé à partir de \(x\).

Substitution et unificateur le plus général

Substitution, unificateur

Une substitution \(\theta=\{x_1/t_1,\ldots,x_n/t_n\}\) remplace simultanément chaque \(x_i\) par \(t_i\) ; \(E\theta\) est le résultat. \(\theta\) unifie \(E_1\) et \(E_2\) si \(E_1\theta=E_2\theta\).

\(\mathit{Inscrit}(x,\mathit{IA})\) et \(\mathit{Inscrit}(\mathit{Awa},y)\) : \(\{x/\mathit{Awa},y/\mathit{IA}\}\).

Unificateur le plus général (UPG)

\(\theta\) est un UPG de \(E_1\) et \(E_2\) si tout unificateur \(\sigma\) s’écrit \(\sigma=\theta\lambda\) (\(\theta\), puis une substitution \(\lambda\)). Deux termes unifiables ont un UPG, unique à un renommage des variables près (Robinson, 1965).

\(P(x)\) et \(P(y)\) : \(\{x/y\}\) est un UPG ; \(\{x/\mathit{Fatou},y/\mathit{Fatou}\}\) unifie aussi, mais il s’obtient de \(\{x/y\}\) par \(\{y/\mathit{Fatou}\}\).

Lecture. L’UPG fixe le moins possible : la résolution garde ainsi les conclusions les plus générales.

L’unification : lier une variable

Une variable est une chaîne qui commence par une minuscule, une constante commence par une majuscule, un terme composé est un tuple (symbole, arguments).

def est_var(t):
    return isinstance(t, str) and t[0].islower()
def compose(t):
    return isinstance(t, tuple)
def lier(v, t, s):
    if v in s:
        return unifier(s[v], t, s)
    if est_var(t) and t in s:
        return unifier(v, s[t], s)
    if apparait(v, t, s):
        return None            # test d'occurrence
    return {**s, v: t}
def apparait(v, t, s):
    if t == v:
        return True
    if est_var(t) and t in s:
        return apparait(v, s[t], s)
    if compose(t):
        return any(apparait(v, u, s)
                   for u in t[1:])
    return False

Lecture. lier suit les liaisons déjà posées, puis refuse \(v/t\) si \(v\) apparaît dans \(t\) : c’est le test d’occurrence.

L’unification, pas à pas

substitution \(s\) : {vide}

substitution \(s\) : {vide}

substitution \(s\) : x/Fatou

substitution \(s\) : x/Fatou z/pere(x)

substitution \(s\) : x/Fatou z/pere(x)

substitution \(s\) : x/Fatou z/pere(x) y/pere(x)

substitution \(s\) : x/Fatou z/pere(x) y/pere(x)

Sortie \(\rightarrow\)

{'x': 'Fatou', 'z': ('pere', 'x'), 'y': ('pere', 'x')}

Lecture. Initialisation (lignes 1, 17–19) : appel sur E1 et E2 avec la substitution vide.

Lecture. Appel 1 : deux termes composés, même symbole, même arité (ligne 12) ; la ligne 15 unifie les arguments un à un.

Lecture. Appel 2 : \(x\) est une variable (ligne 6) ; la ligne 7 la lie : \(x/\mathit{Fatou}\).

Lecture. Appel 3 : \(z\) est une variable (ligne 8) ; la ligne 9 la lie à \(\mathit{pere}(x)\), après le test d’occurrence.

Lecture. Appel 4 : \(y\) face à \(z\), déjà lié : lier reprend avec la valeur de \(z\), \(\mathit{pere}(x)\).

Lecture. Appel 5 : \(y\) variable (ligne 6) ; \(y\) n’apparaît pas dans \(\mathit{pere}(x)\) : la ligne 7 lie \(y\).

Lecture. Retour : la ligne 16 rend \(s\) ; \(s\) appliquée jusqu’au bout donne l’UPG, avec \(\mathit{pere}(\mathit{Fatou})\).

L’application de la substitution

Le dictionnaire rendu est triangulaire : \(z/\mathit{pere}(x)\) contient \(x\), lui-même lié. L’appliquer jusqu’au bout donne l’UPG.

def appliquer(t, s):
    if est_var(t) and t in s:
        return appliquer(s[t], s)
    if isinstance(t, tuple):
        return (t[0],) + tuple(appliquer(x, s) for x in t[1:])
    return t
s = unifier(E1, E2, {})
print({v: appliquer(v, s) for v in sorted(s)})
print(appliquer(E1, s) == appliquer(E2, s))

Résultat \(\rightarrow\)

{'x': 'Fatou', 'y': ('pere', 'Fatou'), 'z': ('pere', 'Fatou')}
True

Lecture. UPG : \(\{x/\mathit{Fatou},\ y/\mathit{pere}(\mathit{Fatou}),\ z/\mathit{pere}(\mathit{Fatou})\}\) ; les deux termes deviennent \(\mathit{Accompagne}(\mathit{Fatou},\mathit{pere}(\mathit{Fatou}),\mathit{pere}(\mathit{Fatou}))\).

Les échecs de l’unification

print(unifier(("Aime", "x", "x"), ("Aime", "Awa", "Fatou"), {}))
print(unifier(("Parent", "x", ("f", "x")), ("Parent", "y", "y"), {}))
print(unifier(("Inscrit", "x", "IA"), ("Inscrit", "Awa", "y"), {}))

Résultat \(\rightarrow\)

None
None
{'x': 'Awa', 'y': 'IA'}

Conflit de symboles

\(\mathit{Aime}(x,x)\) et \(\mathit{Aime}(\mathit{Awa},\mathit{Fatou})\) : \(x/\mathit{Awa}\), puis \(\mathit{Awa}\) face à \(\mathit{Fatou}\), deux constantes distinctes. Ce n’est pas le test d’occurrence.

Test d’occurrence

\(\mathit{Parent}(x,f(x))\) et \(\mathit{Parent}(y,y)\) : \(x/y\), puis \(y\) face à \(f(y)\). \(y\) apparaît dans \(f(y)\) : aucune substitution finie ne convient (\(y=f(f(f(\ldots)))\)).

Lecture. Prolog omet le test d’occurrence par défaut, pour la vitesse : il peut alors « prouver » une conclusion qui n’est pas conséquence de la base.

La résolution au premier ordre

Résolution avec unification

Deux clauses sans variable commune (renommées), \(\ell\lor A\) et \(\neg m\lor B\), avec \(\theta\) UPG de \(\ell\) et \(m\) : la résolvante est \((A\lor B)\theta\).

\(\neg\mathit{Etudiant}(x)\lor\mathit{Prof}(f(x))\) et \(\mathit{Etudiant}(\mathit{Awa})\), \(\theta=\{x/\mathit{Awa}\}\) : \(\mathit{Prof}(f(\mathit{Awa}))\), l’encadrant d’Awa est professeur.

Complétude et semi-décidabilité

Avec la factorisation (unifier deux littéraux d’une même clause), la résolution est correcte et complète pour la réfutation (Robinson, 1965). Mais \(\models\) n’est que semi-décidable (Church, Turing, 1936) : si \(\mathrm{KB}\models\alpha\), la réfutation finit par trouver \(\square\) ; sinon, elle peut ne jamais s’arrêter.

Lecture. Les démonstrateurs automatiques comme Vampire ou E, et Prolog sur les clauses de Horn, reposent sur cette règle et sur l’unification.

Exercice : six paires à unifier

Énoncé

\(E\), \(I\), \(A\) : Enseigne, Inscrit, Aime ; \(x\), \(y\), \(z\) variables ; Dakar, IA, ML, Fatou, Amadou, DrToure constantes. Unifier chaque paire : UPG ou cause de l’échec.

Correction

  1. Paires 1 et 2 : \(\{x/\mathit{DrToure},y/\mathit{IA}\}\) ; puis \(x/y\), et \(y\) face à \(x\) devient \(y\) face à \(y\) : \(\{x/y\}\), \(\mathit{Pere}(y,y)\).
  2. Paire 3 : \(\{y/\mathit{Fatou},x/\mathit{ML}\}\) : \(\mathit{Inscrit}(\mathit{Fatou},\mathit{ML})\).
  3. Paire 4 : \(x/\mathit{Amadou}\), puis \(\mathit{Amadou}\) face à \(\mathit{Fatou}\) : deux constantes distinctes, échec par conflit (pas un test d’occurrence).
  4. Paires 5 et 6 : \(\{x/g(\mathit{Dakar}),z/g(y)\}\) ; \(x/y\), puis \(y\) face à \(f(y)\) : \(y\) apparaît dans \(f(y)\), le test d’occurrence échoue.

Les systèmes experts

L’application la plus connue de l’IA symbolique : un agent fondé sur les connaissances dont la base contient le savoir d’un expert.

MYCIN (Stanford, années 1970)

Thèse d’Edward Shortliffe : environ 600 règles sur les infections bactériennes, un moteur en chaînage arrière, des facteurs de certitude entre \(-1\) et \(+1\). Sur des méningites, évaluées à l’aveugle par huit infectiologues, ses prescriptions ont été jugées acceptables dans 65 % des 80 évaluations (10 cas, 8 évaluateurs), contre 42,5 à 62,5 % pour cinq médecins de la faculté.

Lecture. Chaque règle se négocie avec un expert : c’est le goulot d’étranglement de l’acquisition des connaissances, que le Machine Learning contourne en apprenant des données.

Un système expert au centre de santé de la Médina

REGLES_M = [(["fievre", "frissons", "pluies"], "suspect_palu"),
            (["fievre", "toux", "rhinite"], "suspect_grippe"),
            (["suspect_palu"], "TDR"), (["suspect_grippe"], "repos")]
def diagnostic(faits):
    connus = set(faits)
    nouveau = True
    while nouveau:
        nouveau = False
        for pr, c in REGLES_M:
            if set(pr) <= connus and c not in connus:
                connus.add(c)
                nouveau = True
    return sorted(connus - set(faits))
palu = ["fievre", "frissons", "pluies"]
print("Fatou :", diagnostic(palu))
print("Moussa :", diagnostic(palu + ["toux", "rhinite"]))

Résultat \(\rightarrow\)

Fatou : ['TDR', 'suspect_palu']
Moussa : ['TDR', 'repos', 'suspect_grippe', 'suspect_palu']

Lecture. Moussa déclenche les deux règles : paludisme et grippe, sans dire lequel est le plus probable ; la logique classique n’a pas de degré (Séance 5).

Calcul symbolique et calcul numérique

Le calcul symbolique, ou calcul formel, applique des règles de réécriture aux expressions (dérivée d’un produit, d’un sinus) : un raisonnement sur des symboles, exact pour tout \(x\).

from sympy import sin, cos, diff, integrate, simplify, solve, Eq
x = symbols("x")
f = x**2 + sin(x)
print(diff(f, x))
print(integrate(f, x))
g = lambda t: float(f.subs(x, t))
num = (g(0.501) - g(0.5)) / 0.001
exact = float(diff(f, x).subs(x, 0.5))
print(round(num, 6), round(exact, 6))

Résultat \(\rightarrow\)

2*x + cos(x)
x**3/3 - cos(x)
1.878343 1.877583

Lecture. La dérivée formelle donne \(2x+\cos x\) ; en \(x=0{,}5\), elle vaut \(1{,}877583\), le quotient différentiel avec \(h=0{,}001\) donne \(1{,}878343\) : une erreur de l’ordre de \(h\).

SymPy : algèbre et logique

print(simplify((x + 1)**2 - x**2 - 1))
print(solve(x**2 - 5*x + 6, x))
t, r = symbols("t r")
eqs = [Eq(t + r, 50000), Eq(2*t + r, 80000)]
sol = solve(eqs, [t, r])
print(sol[t], sol[r])

Résultat \(\rightarrow\)

2*x
[2, 3]
30000 20000

Transport \(t\) et repas \(r\) d’un étudiant : \(t+r=50\,000\) francs CFA ; si le transport doublait, \(2t+r=80\,000\).

from sympy import simplify_logic, Implies
P, Q, R = symbols("P Q R")
print(simplify_logic(Or(And(P, Q), And(P, Not(Q)))))
print(simplify_logic(Implies(P, Implies(Q, P))))
phi = Implies(Or(P, Q), And(R, Not(P)))
print(to_cnf(phi))
print(to_cnf(phi, simplify=True))
print(satisfiable(And(P, Implies(P, Q), Not(Q))))

Résultat \(\rightarrow\)

P
True
~P & (R | ~P) & (R | ~Q) & (~P | ~Q)
~P & (R | ~Q)
False

Lecture. simplify_logic réduit \((P\land Q)\lor(P\land\neg Q)\) à \(P\) ; to_cnf rend une FNC, non simplifiée par défaut ; \(P\land(P\to Q)\land\neg Q\) est insatisfiable.

Les méthodes de la séance, côte à côte

méthode correcte, complète coût sur Bouki
vérification de modèles oui, oui \(2^n\) interprétations 8 interprétations, 1 modèle
chaînage avant oui, oui sur des clauses de Horn linéaire 9 symboles traités
chaînage arrière oui, oui sur des clauses de Horn limité aux buts utiles 5 buts
résolution oui, complète pour la réfutation exponentiel au pire 5 clauses, puis \(\square\)
premier ordre (unification) oui, semi-décidable sans borne UPG \(\{x/\mathit{Fatou},\ldots\}\)

Lecture. Plus le langage est expressif, plus la décision coûte : énumérable en propositionnel, semi-décidable au premier ordre.

Le choix d’une méthode d’inférence

Quelle méthode pour quelle base ?

  1. Peu de symboles, une question ponctuelle ? La vérification de modèles, directe et sûre.
  2. Des règles « si conditions, alors conclusion » ? Une base de Horn : chaînage avant pour réagir à chaque fait nouveau, chaînage arrière pour répondre à une question.
  3. Des disjonctions, des contraintes générales ? FNC et résolution par réfutation, ou un solveur SAT.
  4. Des objets, des relations, des « pour tout » ? Logique du premier ordre : forme clausale, unification, résolution.
  5. Des perceptions incertaines ? Aucune de ces méthodes : les probabilités (Séance 5).

À retenir

À retenir

  • Un agent fondé sur les connaissances : une base de formules, TELL pour ajouter, ASK pour inférer.
  • Interprétation, modèle ; satisfiable, valide, insatisfiable ; \(\mathrm{KB}\models\alpha\) ssi \(\mathrm{Mod}(\mathrm{KB})\subseteq\mathrm{Mod}(\alpha)\) ssi \(\mathrm{KB}\land\neg\alpha\) insatisfiable.
  • \(\vdash\) est syntaxique, \(\models\) sémantique ; correcte : \(\vdash\) entraîne \(\models\) ; complète : \(\models\) entraîne \(\vdash\).
  • FNC en quatre étapes ; clauses de Horn : chaînage avant (dirigé par les données, linéaire) et chaînage arrière (dirigé par le but).
  • La résolution est correcte et complète pour la réfutation ; SAT est NP-complet.
  • Premier ordre : quantificateurs (\(\forall\) avec \(\to\), \(\exists\) avec \(\land\)), skolémisation équisatisfiable, UPG, test d’occurrence ; \(\models\) semi-décidable.
  • Ousmane déduit Bouki en \((2,2)\) de deux odeurs et de l’unicité ; SymPy vérifie, calcule et simplifie.

Prochaine séance

Séance 3 — L’IA qui cherche

Ousmane sait désormais quelles cases sont sûres ; la logique ne lui dit pas quel chemin prendre jusqu’à l’or. La Séance 3 formule un problème de recherche (états, actions, coûts, but) et le résout par les algorithmes BFS, DFS, UCS, A* et la recherche locale, sur la route de Dakar à Touba. La question de la séance : comment un agent trouve-t-il une suite d’actions qui mène à son but ?

Références

  • Russell, Norvig — Artificial Intelligence: A Modern Approach, 4e éd., Pearson, 2020 (chap. 7 à 9 : agents logiques, logique du premier ordre, inférence).
  • Poole, Mackworth — Artificial Intelligence: Foundations of Computational Agents, 3e éd., Cambridge University Press, 2023.
  • Robinson — « A Machine-Oriented Logic Based on the Resolution Principle », Journal of the ACM, 12(1), 1965.
  • Davis, Logemann, Loveland — « A Machine Program for Theorem-Proving », Communications of the ACM, 5(7), 1962.
  • Buchanan, Shortliffe — Rule-Based Expert Systems: The MYCIN Experiments, Addison-Wesley, 1984.
  • Ben-Ari — Mathematical Logic for Computer Science, 3e éd., Springer, 2012.
  • Meurer et al. — « SymPy: Symbolic Computing in Python », PeerJ Computer Science, 3, 2017.