Chapitre 2 : Représentation des connaissances

Calcul des Prédicats

I. Introduction

Il est nécessaire de distinguer entre les schémas de représentation et le moyen de

l’implémentation. Les langages de programmation servent de moyens d’implémentation.
Dans la littérature, plusieurs schémas de représentation de connaissances ont été proposés et
implémentés.
Nous pouvons les classer en quatre catégories :
- les schémas de représentations logiques. La logique est utilisée pour représenter la
base de connaissances (des règles). Les règles d’inférence appliquent cette
connaissance aux éléments du problème. La logique du premier ordre (le calcul des
prédicats) est un exemple de cette catégorie. Prolog est un langage idéal pour
l’implémentation de ces représentations.
- les schémas de représentations procédurales. Les connaissances sont représentées par
un ensemble d’instructions pour la résolution d’un problème. Par exemple dans les
systèmes à base de connaissances chaque règle de la forme si .. alors est une
procédure qui permet de résoudre un sous but du problème.
- les schémas de représentations en réseaux sémantiques Les réseaux sémantiques
représentent les connaissances comme étant un graphe. Les nœuds correspondent aux
objets (concepts dans le domaine). Les arcs représentent les relations ou les
associations. On parle des réseaux sémantiques et de graphes conceptuels.
- les schémas de représentations en objets structurés Ces schémas de représentation
peuvent être considérés comme une extension des réseaux sémantiques, en admettant
que le nœud peut correspondre à une structure complexe qui représente un objet
encapsulant des attributs, des valeurs et encore des procédures pour effectuer des
tâches données. On parlera des Scripts, des Frames et des objets.

Dans ce chapitre, on présente les notions de base de calcul des prédicats et le principe de
langage Prolog.
II. Calcul des prédicats
Éléments de base
- les variables ( notés en majuscules, éventuellement indicées ) : U, V, X, · ·,
Nous noterons Var l’ensemble des variables utilisées,
- les constantes, représentées par les minuscules a, b, c,…,

1
 - les symboles de fonctions d’arité strictement positives (ceux d’arité nulle étant les
constantes), dénotés par les minuscules f, g, … , .
Nous noterons F l’ensemble des symboles de fonction,
- les symboles de prédicats, dénotés le plus souvent par les lettres p, q,…,
- des connecteurs, ce sont les symboles ￢, ∧, ∨, ←,↔ représentant respectivement la
négation, la conjonction, la disjonction, l’implication et l’équivalence,
- les quantificateurs universels et existentiels, ∀ et ∃.
Terme
• Toute constante est un terme.
• Toute variable est un terme.
• Si t1, t2, ..tn sont des termes et si f est une fonction n-aire, alors f(t1, t2, ..,tn) est un
terme.

Un terme est dit clos, si aucune variable n’y apparaît. Il est dit linéaire, si aucune variable
n’y apparaît deux fois.

un atome
• Si t1, t2, ..., tn sont des termes et si P est un prédicat n-aires alors P(t1, t2, .., tn) est
un atome.
Un littéral est un atome, on dit alors qu’il est positif, ou la négation d’un atome, il est
alors qualifié de négatif.

une formule (bien–formée)

• Tout atome est une formule.
• Si P et Q sont deux formules alors : Non P, P ∧ Q, P V Q, P ==> Q, P <==> Q,
∀x P(x), ∃x P(x) sont des formules.

Un langage du premier ordre d’un alphabet donné est l’ensemble de toutes les formules
construites à partir des symboles de cet alphabet.

Exemple de syntaxe
• ∀x NOMBRE(x) ==> (∃y PLUSGRANDQUE(y, x)

Forme normale conjonctive

• Soient F1, F2, ...des formules :
• Si chaque Fi est uniquement sous forme disjonctive de littéraux(V), alors la forme
F1 ٨ F2 ٨.....Fn est dite une forme normale conjonctive.
Exemple : (NON P V Q V R) ٨ (NON P V NON Q) ٨ NON R est une forme
conjonctive.
Forme normale disjonctive
• Soient F1, F2, ...des formules :
• Si chaque Fi est uniquement sous forme conjonctive de littéraux(٨), alors la forme F1
V F2 V.....Fn est dite une forme normale disjonctive.
• Exemple: (P ٨ Q ٨ R) V (Q ٨ R) V P est une forme disjonctive.

2
• Il a été démontré que toute formule peut être transformée en une forme normale
disjonctive ou conjonctive.

Une clause est une formule de la forme

∀X1 · · ·∀Xn, L1 ∨ · · · ∨ Lm
o`u chaque Li est un litt´eral et X1, · · ·, Xn sont les seules variables apparaissant dans L1 ∨
· · ·∨ Lm.

On utilise habituellement une notation plus particulière pour les clauses, ainsi la clause
∀X1 · · ·∀Xn, A1 ∨ · · · ∨ Am ∨￢B1 ∨ · · · ∨ ￢Bp où les Ai et les Bi
sont des atomes, sera notée
A1, · · ·, Am ← B1, · · ·, Bp

Obtenir une forme clausale à partir d’une formule logique quelconque :

Exemple

Une clause de Horn est une clause de la forme

A ← B1, · · ·, Bn
3
 (∀X1 · · ·∀Xn, A ∨ ￢B1 ∨ · · · ∨ ￢Bn )

Une clause de Horn est une clause comportant au plus un littéral positif.

Les règles d'inférence fournissent un moyen de faire des démonstrations ou des

déductions logiques : Modus Ponens, Modus tollens, Chaînage, Substitution, Conjonction,
contraposée.
- Modus ponens
De P et P-->Q, on déduit Q, qui s'exprime :
P
P-->Q
--------- Modus Ponens
Q

- Modus Tollens
De Non Q et P -->Q, on déduit Non P.

Non Q
P ==> Q
----------Modus Tollens
Non P
- Chaînage
De P --> Q et Q --> R, on déduit P --> R
P-->Q
Q-->R
P-->R
- Substitution :
De P ٨ Q, on déduit P
P٨Q
P
- Conjonction
De P et de Q, on déduit P ٨ Q
P
Q.
P٨Q
- Contraposée
De P --> Q, on déduit Non Q --> Non P
P --> Q
Non Q --> Non P

4
III. Langage Prolog
III.1. Introduction
Le nom de Prolog a été créé à Marseille en 1972. Philippe Roussel l’a proposé comme
abréviation de « PROgrammation en LOGique », pour désigner un outil informatique conçu
pour implanter un système de communication homme machine en langage naturel, en
l’occurrence le français.

- Prolog est un langage de programmation logique qui repose sur la logique des
prédicats restreinte aux clauses de Horn.
Prolog =Programmation en logique
Programmer en logique consiste :
• à définir les hypothèses (énoncés définis dans un programme exprimant la
connaissance relative au problème à résoudre.
• à introduire la conclusion (poser le problème).
• L'interpréteur tente ensuite de réaliser la preuve du but en utilisant l'inférence
logique.

- On présente aussi Prolog comme un outil de programmation déclarative en distinguant

de l’approche procédurale et fonctionnelle ( la programmation procédurale : adaptée
aux ordinateurs pour leur fonctionnement itératif (C, Pascal, ADA, Java, ...)., la
programmation fonctionnelle : description de traitements par des fonctions, la
composition de fonctions et la récursivité (Caml, Lisp, Scheme,...)). Cette affirmation
est vraie dans certaines limites et vous verrez que l’on peut aussi voir le Prolog
procédural.
- Programmer en Prolog signifie :
Spécifier des faits (vérifiés) sur les objets et leurs relations ;
Définir des règles (règles de déduction) sur les objets et leurs relations ;
Poser des questions sur les objets et leurs relations.

Stratégie de Prolog
- comment choisir le littéral du but à unifier ? Prolog choisit le littéral le plus `a gauche.
- comment choisir la clause du programme dont la tête est unifiée avec le littéral du but
? Prolog examine d’abord les clauses du programme dans l’ordre d’écriture.
- comment constituer le nouveau but ? Prolog a une stratégie en profondeur d’abord, il
ajoute les nouveaux littéraux (obtenu `a partir de la clause), `a gauche de l’ancien but.

III.2. clauses de Horn et clauses de Prolog

Programme Prolog = ensemble de clauses de Horn

5
Exemple :
Clause de Horn Q(x) V ¬P(z, x) V ¬Q(z) qui peut s’écrit
P(z,x) ∧ Q(z) -> Q(x)
On a : ( a->b )<-> (¬a V b)
Clause de Prolog q(X) :- p (Z,X), q(Z).
pour que q(X) soit vrai, il faut que p (Z,X) et
q(Z) sont vrai.

III.3. Présentation générale du langage Prolog

Prolog manipule deux sorte d’objet (pas le même sens que l’objet d’orienté objet) :
constantes et variables.
- Constante : est un atome qui est représenté par une suite de caractères (lettre,
chiffre, _ ) qui commence avec une lettre minuscule, ou un suite de caractères y
compris le blanc et lettres majuscules mais entre ‘ ’.
- Variable : désigné un objet dont on connait l’existence mais sa valeur n’est pas
fixée. Une variable commence obligatoirement par une majuscule. Exemple :
Etudiant(X). X est une variable qui peut prendre tous les valeurs des noms des
étudiants
Prédicat (clause) : on appelle prédicat ou clause un inconnu qui composé de :
- Nom de prédicat (commence par une lettre minuscule)
- Liste des arguments, qui peut être vide
- Un point est obligatoire après chaque prédicat.
Requêtes et repenses de prolog : Prolog fonctionne en chaînage arrière et repend à
une question par
- ‘yes’ si la requête est vérifiée
- ‘no ‘ si la requête n’est pas vérifiée.
- Affiche la liste des solution si la requête contient des variables.
Exemple : soit l’ensemble des prédicats suivantes :
Specialite(math,liscence,sciences-exacte)
Specialite(physique,liscence,sciences-exacte)
Specialite(informatique,liscence,sciences-exacte)
Specialite(genie-civil,ingénieur,’Technologie’)
Specialite(informatique,ingénieur,informatique)
Requête :
6
 - ? Specilate(math,_,_) : est ce qu’il ya une spécialité math ?
Prolog : yes
- ? Specilate(X, ‘Ingenieur’, Y)
Prolog : X= informatique
Y= informatique
X= genie-civil
Y= Technologie
Règles de Prolog : Prolog utilise la notation suivante :
:- If
; Or
, And
Exemple :
Nationnalite (‘Mohammed’, ‘Algérie’).
Nationnalite(‘Amine’,’Maroc’).
Nationnalite(‘Siradj’,’Tunisie’).
Pour exprimer que les trois personnes sont de Maghreb, on peut définir par :
Ne_au_Maghreb(X) :- Nationalie(X,’Algerie’ ) ; Nationalie(X,’Tunisie’ ) ;
Nationalie(X,’Maroc’ ).
La coupure CUT : Cet opérateur permet de contrôler le retour arrière effectué par
Prolog. Si une coupure est rencontré dans une règle, le retour arrière est bloqué pour
tous ce qui est à gauche de symbole de coupure. Cet opérateur est utilisé : - pour
éliminer les solution multiple ; - pour bloquer la recherche si on sait qu’une solution a
été trouvé et qu’il ne peut ont existe d’autres.
Exemple : (expliqué dans le cours)

q(a). 1. p(X,Y) :-q(X),r(X,Y).

q(b). 2. p’X,Y) :-q(X), r(X,Y), !.
q(c). 3. p(X,Y) :-q(X) , !, r(X,Y).
r(a, x). 4. p(X,Y) :- ! q(X),r(X,Y).
r(a,y).
r(a,z).
r(b,t).
r(c,m).
p(u,t)

Les listes
Une liste L est une suite ordonnée de termes

7
 T: tête (le premier terme)
Q: queue (les autres termes)
l(T,Q) : liste (T : premier terme)
(Q : queue de liste)

Exemple : Soit le prédicat suivant

aime(samir, frites, ris, poisson).

- ? aime (samir, poisson)

No

On doit utiliser les listes. La syntaxe d’une liste est : aime(samir,[ frites, ris, poisson])

- aime (samir,Quoi)

Quoi=,[ frites, ris, poisson]

- aime(samir,[Tete|Queue])
Tête=frites
Queue=[ris,poisson]
- aime(samir[X,Y|Queue])
X=frites
Y=ris
Queue=[poisson]
- l’affichage des éléments d’une liste : afficher(), write
exemple
afficher([]).
afficher([Tete|Queue]).
write(Tete) , nl , afficher(Queue). % nl permet de sauter la ligne
Récursivité en Prolog