La Logique et l'I.A.

Programmation Fonctionnelle I, Printemps 2009 (et oui…) Cours n°12

http://deptinfo.unice.fr/~roy

• En 1956 : le Dartmouth Summer Research Project on "Artificial

Intelligence". Le terme IA est alors proposé par John McCarthy,
l'inventeur de Lisp [à l'origine de Scheme] au MIT.

Logique et • L'IA se propose en particulier de modéliser le raisonnement humain,

au moins sous sa forme logique.

Démonstation SI il fait beau

ALORS je vais à la plage
p⇒q

Automatique SI il fait beau

ALORS je vais à la plage OU à la montagne
p⇒q∨r

SI il fait beau ET je suis en forme

ALORS je vais à la plage OU à la montagne p∧q⇒r∨s
1 2
SI il ne dort pas
~p ⇒ q
ALORS il mange

• Les connecteurs logiques usuels : • John McCarthy fut le premier à remarquer que dans un langage de
programmation [Lisp], les opérateurs logiques ne sont pas des
∨ ∧ ¬ fonctions et que déjà dans p ∧ q, la valeur de p peut suffire à obtenir la
ou et non implique valeur de l'expression [par ex. Faux ∧ q ≡ Faux pour tout q]. Idem en
Java/C avec la construction p && q.
• Et leurs tables de vérité :
• Ces 4 connecteurs ne sont pas indépendants. Par exemple, la loi de De
p true false
Morgan établit que la formule p ∧ q pourrait être définie par :
¬p false true
p ∧ q := ¬(¬p ∨ ¬q)

p true true false false

L'implication
q true false true false
• De même la formule p ⇒ q est définie par ¬p ∨ q : une implication
conjonction p∧q true false false false est toujours vraie sauf si l'hypothèse est vraie et la conclusion est
disjonction p∨q true true true false fausse. La phrase suivante est donc vraie :
3 4

implication p q true false true true Si le Nil est en Russie alors Paris est la capitale de la France.
• Les électroniciens utilisent dans leurs puces • La Logique d'ordre 0 [ou Logique des Propositions] porte sur des
l'opérateur NAND défini par : propositions constantes p, q...

(nand p q) ≡ (not (and p q)) p ∧ (¬q ∨ r)

• La Logique d'ordre 1 [ou Logique des Prédicats] porte sur des
• On peut montrer que cet opérateur NAND engendre à lui tout seul propositions utilisant des variables p(x), q(x,y,z), etc. Par exemple P
tous les autres ! est vu comme un prédicat à une variable :
• Problème d'architecture des ordinateurs : minimiser le nombre de p(x) ∧ (¬q(x,y) ∨ r(y))
portes NAND pour réaliser un circuit logique donné...
• Les variables peuvent être quantifiées :
Transistor
NAND gate ∀x ∃y : p(x) ∧ (¬q(x,y) ∨ r(y))

• La Logique d'ordre 2 traiterait les prédicats eux-mêmes comme des

variables. En Scheme, c'est la programmation d'ordre supérieur pour
laquelle les fonctions sont des variables !
IC 7400
5
• Dans ce qui suit, le cadre d'étude sera celui de la logique d'ordre
6
0.

Une formule logique est un ARBRE (define (atome? x)

(symbol? x)
; le reconnaisseur d'atomes [symboles p, q, r...]

(define (make-fbf1 r Ag) ; le constructeur de molécule à 1 seul fils (négation)

(if (equal? r 'non) (list r Ag) (error 'make-fbf1 "Mauvaise formule !"))
GRAMMAIRE DES FORMULES
(define (make-fbf2 r Ag Ad) ; le constructeur de molécule binaire (et, ou, =>)
• Une formule bien formée est un atome ou et (if (not (member r '(et ou =>))
ou une molécule. (error 'make-fbf2 "Mauvais connecteur" r
(list Ag r Ad))) ; représentation interne infixée
• Un atome sera un symbole p, q, r... p q non s
(define (connecteur mol) ; on suppose que mol est une molécule
(if (= (length mol) 2
• Une molécule portera un opérateur et : (first mol) ; non
r
- un seul fils [noeud unaire non] (second mol))) ; et, ou, =
p ∨ q ⇒ ¬r ∧ s "f
- ou bien deux fils [noeuds binaires ou et ] or T
(define (arg1 mol) ; mol est une molécule m ype
N.B. Les fils sont aussi des formules ! (if (= (length mol) 2 ul a
(second mol eb b
en fait (first mol)) ie stra
des arbres 1-2 n
fo it
(define (arg2 mol) ; mol est une molécule rm
fbf ::= ATOME | MOLECULE (if (= (length mol) 2 ée
ATOME ::= p | q | r | ..
7
(error 'arg2 "Molécule unaire" mol
8
"
(third mol)))
MOLECULE ::= (fbf et fbf) | (fbf ou fbf) | (fbf => fbf) | (non fbf)
)

>

• Il s'agit maintenant d'utiliser ce type abstrait pour analyser ou

construire des fbf, bref programmer avec des arbres logiques.
L'algorithme de Wang
• Il s'agit d'un algorithme du Calcul des Propositions [donc en Logique
UNE FORMULE UNE FORMULE
d'ordre 0] permettant de décider si une formule est un théorème.
EST UNE LISTE EST UN ARBRE
Donc en quelque sorte un démonstrateur automatique [prover]...

• Une formule bien formée [fbf] fait intervenir :

• Pour les tests uniquement, il y a deux manières de définir un arbre : - des formules atomiques p, q, r, ... et deux constantes true et false
- soit en syntaxe abstraite : - des connecteurs binaires et, ou, =>

(define AT (make-fbf2 '=> (make-fbf2 'ou 'p 'q) 'r))

- le connecteur unaire non
ou r
- soit en syntaxe concrète en violant le type abstrait : • La syntaxe concrète est analogue à celle de Scheme mais infixée :
(define AT '((p ou q) => r)) fbf ::= ATOME | MOLECULE
p q
car je sais qu'une formule est une liste ! ATOME ::= p | q | r | ..
MOLECULE ::= (fbf et fbf) | (fbf ou fbf) | (fbf => fbf) | (non fbf)

• Nous avons vu au cours 10 des algorithmes sur les arbres.

9
• Exemple : p ∧ (q => r) => p ∨ ¬q sera représentée 10par :
((p et (q => r)) => (p ou (non q)))

• Une formule est un théorème si elle est toujours vérifiée, quelles que • La forme générale d'un théorème est :
soient les valeurs des variables. Exemples de théorèmes : si HYPOTHESES alors CONCLUSION

(p ou (non p)) • Wang utilise le calcul des séquents. Un séquent est représenté
((p et (p => q)) => q)
symboliquement par :

H1 ... Hn ├ C1 ... Ck
• Mais la formule (p => (p et q)) n'est pas un théorème, elle est fausse
si par exemple p = true et q = false ! qui se lit intuitivement : "Si toutes les hypothèses H1 ,..., Hn sont vérifiés,
• L'algorithme de Wang permet de décider si une formule est un alors au moins l'une des conclusions C1 ,..., Ck est vérifiée".
théorème, sans utiliser de table de vérité ! • Le calcul des séquents permet de modifier l'ordre des formules dans
• Il consiste à appliquer une série de règles jusqu'à réduction à une un séquent sans changer sa validité. Par exemple, on peut changer de
forme irréductible où l'on peut décider à vue. côté une formule atomique en prenant sa négation :
p (p q) ├ q
Toward Mechanical Mathematics
équivaut à :
Hao Wang
IBM Journal, January 1960 11
p q ├ ¬p q 12
(IBM 704 : 220 theorems in 3 minutes...)
d'où la validité puisque p ⇒ q est défini comme valant ¬p ou q
.

• Règle R1 : une négation peut être changée de côté en enlevant le • Règle R5 : un séquent λ ├ ζ est un théorème si une même formule
connecteur ¬ : apparaît de chaque côté de la flèche !
ζ ├ φ, ¬λ, ρ ↝ ζ, λ ├ φ, ρ • Le jeu consiste donc à éliminer peu à peu toutes les molécules jusqu'à
la preuve par R5, ou l'échec si plus rien ne s'applique !
• Règle R2 : dissolution d'un ou sur la droite, et d'un et sur la gauche.
φ ├ λ, ρ∨π ↝ φ ├ λ, ρ, π • Exemple. On cherche à prouver la formule [p ∧ (p ⇒ q)] ⇒ q

φ, ζ∧ρ ├ λ ↝ φ, ζ, ρ ├ λ On considère l'embryon de séquent : ∅ ├ [p ∧ (p ⇒ q)] ⇒ q

dont la partie gauche est vide, et on va le travailler pour converger sur

• Règle R3 : dédoublement des lignes lors d'un ou sur la gauche. une forme décidable. On commence par éliminer les implications :
├ λ ├ ¬[p ∧ (¬p ∨ q)] ∨ q
φ, ζ∨ρ ├ λ ↝ ⎨ φ,φ, ζρ ├ λ On applique les règles : ├ ¬[p ∧ (~p ∨ q)] , q (R2)

• Règle R4 : dédoublement des lignes lors d'un et sur la droite. p ∧ (¬p ∨ q) ├ q (R1)
p , ¬p ∨ q ├ q (R2)
├ λ, ζ
φ ├ λ, ζ∧ρ ↝ ⎨ φφ ├ λ, ρ 13 (R3)
⎨ p , ¬p ├ q devient p ├ p , q
14
(R1)
p , q ├ q
CQFD !... VALIDES par (R5)

• Un exemple de formule qui n'est pas un théorème : (p ⇒ q) ⇒ p

Une implémentation de l'algorithme de Wang
├ (p ⇒ q) ⇒ p
VIII. A COMPLETE LISP PROGRAM - THE WANG ALGORITHM
├ ¬(¬p ∨ q) ∨ p (élimination des )
FOR THE PROPOSITIONAL CALCULUS
├ ¬(¬p ∨ q) , p (R2) (LISP 1.5 Programmer's Manuel, MIT PRESS, 1958, p.44)
¬p ∨ q ├ p (R1)
• Tout naturellement avec des listes.
¬p ├ p
⎨ q ├ p
(R3) • Reconnaissance des formules bien formées [fbf?] :

> (fbf? '((a et (non b)) => a)) > (fbf? 'p
├ p, p Je suis coincé, INVALIDE ! #t #
⎨ q ├ p > (fbf? '(a => non b))
#f
> (fbf? '()
#f

• Laissons-nous guider par la grammaire des fbf [page 6] :

• Nous allons programmer une fonction (valide? fbf) prenant une
fbf ::= ATOME | MOLECULE
formule fbf et retournant true si c'est un théorème... ATOME ::= p | q | r | ..
15 MOLECULE ::= (fbf et fbf) | (fbf ou fbf) | (fbf => fbf) | (non
16 fbf)
.

 • Prélude : élimination des implications dans une formule. On travaille en • Le moteur de Wang. Il va essayer de saturer sur les règles jusqu'à ce
profondeur pour rechercher les symboles que (R5) s'applique ou que plus rien ne s'applique !

(define (reformat fbf (define (wang LHS RHS) ; LHS et RHS sont des listes de fbf sans implications
(if (intersection? LHS RHS)
(if (atome? fbf)
tru GAGNE !
fb
(local [(define fbf (first-molecule LHS))] ; on cherche une molécule à gauche
(local [(define r (connecteur fbf)) (if (not (equal? fbf false)
(cond ((equal? r 'non) ... (local [(define r (connecteur fbf))
((member r '(et ou)) ... (cond ((equal? r 'non) (wang ...) négation à gauche
(else ...))))) ((equal? r 'ou) (and (wang ...) (wang ...)) disjonction à gauche
> (reformat '((p => q) => p) ((equal? r 'et) (wang ...) conjonction à gauche
((non ((non p) ou q)) ou p) (else (error "Syntaxe incorrecte" fbf)))
cf TP !
(local [(define fbf (first-molecule RHS))) ; sinon on cherche à droite
(if (not (equal? fbf false)
(local [(define r (connecteur fbf))
• But : la règle R5. La même formule apparaît-elle de chaque côté de la (cond ((equal? r 'non) (wang ...)
((equal? r 'ou) (wang ...)
flèche d'un séquent ? L'intersection de deux listes est-elle non vide ? ((equal? r 'et) (and (wang ...) (wang ...))
(else (error 'wang "Syntaxe incorrecte")))
(define (intersection? L1 L2) ; au moins un élément en commun ? false))))) ECHEC
(cond ...))
> (intersection? '(a b c d e) '(g h k m)
cf TP ! # 17 cf TP ! 18
> (intersection? '(a b c d e) '(g h b k)
#t

• La fonction (théorème? fbf) se contente d'initialiser un séquent sans

implications dont la partie gauche [lhs] est vide, et passe la main au Lisp et l'I.A.
moteur de Wang : • Le langage LISP [LISt Processor] est né vers 1958 pour :
- les besoins de l'Intelligence Artificielle naissante [1956]
(define (théorème? fbf)
(if (not (fbf? fbf) - disposer d'un modèle exécutable du λ-calcul [1940]
(error ...
(wang ...))) cf TP ! • L'I.A. privilégie les problèmes symboliques sur les problèmes
numériques. Manipuler des concepts plutôt que des nombres !
• L'idée de mécaniser la Logique remonte à Leibniz et à Boole. Mais
> (théorème? 'p c'est avec les premiers logiciels d'I.A. que sont apparus des
fals
> (théorème? '(p => p)
démonstrateurs de théorèmes, comme le "Logic Theorist" de Newell &
tru Simon en 1956. L'algorithme de Wang en Logique des Propositions
> (théorème? '(p => (p ou q))
tru
[logique d'ordre 0] est décrit dans le manuel cité de LISP 1.5 [1958].
> (théorème? '((p et (p => q)) => (p et q))
• La démonstration automatique fut ensuite étendue à la Logique des
true
> (théorème? '(p => (p et q)) 19 Prédicats [l'ordre 1] où les propositions contiennent des variables
20 :
false
création du langage PROLOG à Marseille en 1972.
f

 21

https://fr.wikipedia.org/wiki/Intelligence_artificielle 24