Systèmes de raisonnement automatique

Logique des Informations Imparfaites
Systèmes de Raisonnement Automatique pour les Informations Imparfaites
Intelligence Artificielle
Abduction Induction
\ /
Raisonnement
/ \
Interrogation Déduction
• Formalisation / théorie (logique)
• Modélisation de problème
• Développement d'un système
‣ algorithme
‣ heuristique
‣ complexité
Logique classique
‣ incertitude
‣ imprécision
‣ exceptions
LC => Raisonnement monotone
IA Raisonnement par défaut (absence d'informations contraires)
• Raisonnement typique
• Règles avec exceptions
Exemple 1
+ tous les oiseaux volent
sauf les autruches (ou les manchots, les jeunes, les oiseaux blessés…)
+ pour un oiseau quelconque
cet oiseau vole
Exemple 2
Tout accusé est présumé innocent sauf s'il est reconnu coupable.
• on saute à la conclusion par dessus un trou d'information
• si l'information se précise et invalide la déduction faite, on doit revenir sur cette conclusion
: NON MONOTONIE

II. Limites de la logique classique
( ) ⊆ Th( B)
{
{
}
}
La logique classique est monotone : A ⊆ B ⇒ Th A
{ }
{ }
A = a,¬b,¬a ∨ c
Th( A)
= a,¬b,¬a ∨ c,c,…
⎧∀X,oiseau(
X ) → vole( X ) ⎫
⎪
⎪
A = ⎨∀X,autruche(
X ) → ¬vole( X ) ⎬
⎪
⎩
oiseau( titi)
⎪
⎭
A � vole titi
( )
{ ( ) }
( ) ⎫⎪
⎬ �⊥
( )
B = A ∪ autruche titi
B � vole titi
B � ¬vole titi
⎭⎪
B = A ∪ c → e
Th( B)
= B ∪ c,e,…
{ }
C = B ∪ ¬c
Th( C)
= C ∪ { c,⊥,…}
�� � �� =⊥
inconsistant
⎧∀X,oiseau(
X ) ∧ ¬autruche( X ) → vole( X ) ⎫
⎪
⎪
A' = ⎨∀X,autruche(
X ) → ¬vole( X )
⎬
⎪
⎩
oiseau( titi)
⎪
⎭
A' � vole titi
( )
( )
A' � ¬vole titi
On n'obtient pas de conclusion "intéressante"
car on n'a pas ¬autruche titi
( )
La logique classique ne permet pas le raisonnement par défaut.
III. Limites de la programmation logique classique
Soit X = a,b,oiseau( titi),…
{ } un ensemble d'atomes.
Un programme logique défini est un ensemble de règles de la forme
b ← a 1 ,…,a n n ≥ 0 "j'ai b si j'ai a 1 et … et a n ", b et les a i sont des atomes
( )
A est un ensemble d'atomes clos par rapport à un programme P
si ∀ la règle b ← a 1 ,…,a n ∈P, a 1 ,…,a n
{ } ⊆ A ⇒ b ∈ A
Le modèle de Herbrand de P noté Cn( P)
est le plus petit ensemble d'atomes clos par rapport à P.
L'opérateur T p : 2 X → 2 X est utilisé pour construire le modèle de Herbrand.
T A p ( ) = { b / b ← a ,…,a ∈P et ∀i = 1,…,n a ∈ A
1 n i }
⎧
⎪
⎨
⎩⎪
T p
T p
0
= Ø
k+1 k
= Tp ( Tp ) ∀k ≥ 0
k ( ) = Tp Cn P
�
k≥0

Exemples
⎧a
← . ⎫
⎪ ⎪
P = ⎨b
← a. ⎬
⎪
⎩d
← c. ⎪
⎭
0
T = Ø p
1
T = Tp Ø
p
2
T = Tp a
p { }
3
= Tp a,b
T p
( ) = { a}
( ) = { a,b}
{ }
( ) = a,b
Cn( P)
= { a,b}
{ a,b,c,d } et a,b
{ a},
{ b},
c,d
{ }←⎯ ⎯ point fixe
⎧non_vole(
X ) ← autruche( X ). ⎫
⎪
⎪
P = vole X
1 ⎨ ( ) ← oiseau( X ). ⎬
⎪
⎩
oiseau( titi).
⎪
⎭
{ } sont clos par rapport à P.
{ } et Ø ne sont pas clos par rapport à P.
Cn P 1
P = P ∪ autruche titi
2 1 { ( ) } Cn( P2 ) =
⎧non_vole(
X ) ← autruche( X ). ⎫
⎪
⎪
P = vole X
3 ⎨ ( ) ← oiseau( X ),non_ autruche( X ). ⎬
⎪
⎩
oiseau( titi).
⎪
⎭
Prolog et la négation par l'échec (negation by failure)
⎧⎪
vole( X ) : − oiseau( X ),not autruche( X ) a : − b.
⎨
⎩⎪ oiseau( titi
b : − a.
).
a?
↓
vole( titi)
? OK.
b?
↓
↓
oiseau( titi)
,not autruche( titi)
a?
������� � ��������� �
OK
not OK
������������ �
↓
OK
b?
↓
…
Il existe deux formes de négation :
• la négation forte (¬ a) e.g. traverser_rails si ¬ train
• la négation faible (not a) e.g. traverser_rails si not train
{ ( ),vole( titi)
}
( ) = oiseau titi
⎧oiseau(
titi),autruche(
titi),
⎫
⎪
⎪
⎨vole(
titi),non_vole(
titi)
⎬
⎪�����������������
� ⎪
⎩
contradition ⎭
{ }
( ) = oiseau( titi)
Cn P3 Problème : il manque vole titi
⎧a
← b. ⎫
P = ⎨ ⎬
⎩b
← a. ⎭
Cn( P)
= Ø
( )
Sémantique déclarative

IV. Programmes logiques normaux et sémantique des modèles stables
M. Gelford et V. Lifschitz, 1988
Soit X un ensemble d'atomes.
Un programme logique normal pln
c
� ← a1 ,…,an �� � �� ,not b1 ,…,not b n ≥ 0, m ≥ 0, c, a , b ∈ X
m
i j ������� tête
corps +
corps −
( ) P est un ensemble de règles de la forme
"Si j'ai chaque a i et aucun b j alors je peux conclure c."
Le réduit d'un pln P par rapport à un ensemble d'atomes A est le programme linéaire défini
P A = r + / r ∈P,corps − { ( r)
∩ A = Ø}
r + : tête( r)
← corps + ( r)
i.e. la partie positive des règles de P qui ne sont pas bloquées par A.
Définition (règle bloquée)
Une règle r est bloquée par un ensemble d'atomes A si corps− r
Exemple
La règle r : c ← a,b,not e,not d est bloquée par a,e
( ) ∩ A ≠ Ø.
{ } mais n'est pas bloquée par b,k
Définition (modèle stable)
S
Soit P un pln et S un ensemble d'atomes. S est un modèle stable de P si S = Cn( P ).
Exemples
⎧a
← not b. ⎫
P = 1 ⎨ ⎬
⎩b
← not a. ⎭
S = Ø
S ⎧a
← . ⎫
P = 1 ⎨ ⎬
⎩b
← . ⎭
S = a
S
= a ← .
S = b
{ } P1 { } P1 { } P1 S = a,b
P a 2 modèles stables : a
1 { } et { b}
⎧a
← . ⎫
⎪
⎪
P = c ← a,not b.
2 ⎨
⎬
⎪
⎩d
← not c,not f. ⎪
⎭
S = { a,c}
P2 P a un seul et unique modèle stable : a,c
2 { }
S ⎧a
← . ⎫
= ⎨ ⎬
⎩c
← a. ⎭
S
Cn( P1 ) = a,b
{
{
}
}
S
Cn( P1 ) = { a}
= S
S
Cn( P1 ) = { b}
= S
{ }.
{ } ≠ S
S
= b ← .
S
= Ø
S
Cn( P1 ) = Ø ≠ S
S
Cn( P2 ) = { a,c}
= S

{ } S = Ø P S
= a ← .
3
P 3 = a ← not a.
S = a
{ } P 3
P 3 n'a pas de modèle stable.
⎧b
← not aa. ⎫
⎪
⎪
P = c ← b,not bb.
4 ⎨
⎬
⎪
⎩aa
← c,not cc. ⎪
⎭
P 4 n'a pas de modèle stable.
S
{ } Cn( P3 ) = a
S
= Ø
{ } ≠ S
S
Cn( P3 ) = Ø ≠ S
S
S = Ø P = 4
S = { b,c,aa}
P4 ⎧b
← . ⎫
⎪ ⎪
⎨c
← b. ⎬
⎪
⎩aa
← c. ⎪
⎭
S ⎧c
← b. ⎫
= ⎨ ⎬
⎩aa
← c. ⎭ Cn P S ( 4 ) = Ø ≠ S
⎧⎪
vole( X ) ← oiseau( X ),not autruche( X ). ⎫⎪
P = 5 ⎨
⎬
⎩⎪ oiseau( titi).
⎭⎪
⎧
S ⎪vole
S = { oiseau( titi),vole(
titi)
}
( X ) ← oiseau( X ). ⎫⎪
P = 5 ⎨
⎬
⎩⎪ oiseau( titi).
⎭⎪
P a un unique modèle stable : oiseau titi
5 ( ),vole( titi)
{ }
P = P ∪ autruche titi
6 ( )
{ }
⎧
S ⎪oiseau
S = { oiseau( titi),autruche(
titi)
}
( titi).
⎫⎪
P = 6 ⎨
⎬
⎩⎪ autruche( titi).
⎭⎪
P a un unique modèle stable : oiseau titi
6 ( ),autruche titi
=> NON MONOTONE
{ ( ) }
S
Cn( P4 ) = { b,c,aa}
≠ S
S
Cn( P5 ) =
( ) =
S
Cn P6 ( )
⎧⎪
oiseau titi ⎫⎪
⎨ ⎬ = S
⎩⎪ vole( titi)
⎭⎪
( )
( )
⎧⎪
oiseau titi ⎫⎪
⎨
⎬ = S
⎩⎪ autruche titi
⎭⎪
Extension de Gelford Lifschitz, 1991 — Programmes logiques étendus (ple)
cf. Answer set semantics
Soit X un ensemble de littéraux a ou ¬a
( ).
On peut se ramener à un programme logique normal :
1. on remplace tout littéral négatif ¬x par non_ x
2. on ajoute les règles bug ← x,non_ x,not bug bug est un nouveau symbole
( )
On obtiendra les modèles stables qui correspondent aux ensembles de réponses consistants
du ple d'origine
ple -> pln
|
s1 -> as1
sn -> asn

Exemple
⎧vole(
X ) ← oiseau( X ),not autruche( X ). ⎫
⎪
⎪
⎪¬vole(
X ) ← autruche( X ).
⎪
⎪
⎪
P = ⎨oiseau(
titi).
⎬
⎪oiseau(
toto
⎪
).
⎪
⎪
⎩⎪
autruche( titi).
⎭⎪
P ′ =
Exercice
⎧vole(
X ) ← oiseau( X ),not autruche( X ). ⎫
⎪
⎪
⎪non_vole(
X ) ← autruche( X ).
⎪
⎪oiseau(
titi).
⎪
⎨
⎬
⎪oiseau(
toto).
⎪
⎪autruche(
titi).
⎪
⎪
⎪
⎩⎪
bug( X ) ← vole( X ),non_vole( X ),not bug( X ).
⎭⎪
⎧p
: − q,not np. ⎫
⎪np
: − r,not p. ⎪
⎪
⎪
Quels sont les modèles stables de P = ⎨q
: − a. ⎬ ?
⎪r
: − a. ⎪
⎪
⎩a.
⎪
⎭
A = Cn P A ( ) P A ⊇
A = { a,q,r,p,np }?
⎧q
: − a. ⎫
⎪ ⎪
⎨r
: − a. ⎬
⎪
⎩a.
⎪
⎭
A = a,q,r,p
1 { } P A ⎧p
: − q. ⎫
⎪q
: − a. ⎪
1 = ⎨ ⎬
⎪
r : − a.
⎪
⎩⎪
a. ⎭⎪
A est un modèle stable de P.
1
A = a,q,r,np
2 { } P A ⎧np
: − r. ⎫
⎪q
: − a. ⎪
2 = ⎨ ⎬
⎪
r : − a.
⎪
⎩⎪
a. ⎭⎪
A est un modèle stable de P.
2
P ′ a un modèle stable unique :
⎧oiseau(
titi),oiseau(
toto),
⎫
⎪
⎪
⎨autruche(
titi),vole(
toto),
⎬
⎪
⎩
non_vole( titi)
⎪
⎭
Cn P A
⎛ ⎧q
: − a. ⎫⎞
( ) ⊇ Cn⎜
⎪ ⎪
⎨r
: − a. ⎬
⎟
⎜
⎝ ⎪
⎩a.
⎪
⎟
⎭⎠
Cn P A1 ( ) = { a,q,r,p } = A1 Cn P A2 ( ) = { a,q,r,np } = A2 = { a,q,r}

Représentation (Nixon diamond, paradoxe de Nixon)
• p : pacifiste
• np : non pacifiste
• q : quaker
• r : républicain
• a : américain
L’intersection des modèles stables est un ensemble de conclusions sceptiques (prudentes).
Chaque modèle stable est un ensemble de conclusions crédules.
“Il existe une transformation modulaire de tout problème SAT en un programme logique
normal. L’inverse n’est pas vrai.”
Démonstration
Une transformation τ de pln vers SAT
( ) est modulaire si pour un pln P donné
( ) ∪ F est satisfiable.
et tout ensemble d'atomes de faits F, P ∪ F a un modèle stable ssi τ P
pln
P
P ∪ F
τ
⎯ →⎯
SAT
τ P
( )
( ) ∪ F
τ P
Contre-exemple
Soit P = { a : − not a}.
Supposons que τ soit modulaire.
P n'a pas de modèle stable ⇒ τ ( P)
n'a pas de modèle ( i.e. non satisfiable).
⎧a
: − not a⎫
Or P ∪ { a}
= ⎨ ⎬ a un modèle stable : { a}
mais τ ( P)
∪ a
⎩a.
⎭
Donc ∃ de transformation modulaire de pln vers SAT.
Inversement, de SAT vers pln
{ } n'est pas satisfiable.
Tout ensemble de formules de la logique propositionnelle peut se mettre sous la forme
d’un ensemble de clauses Σ = c ∧ … ∧ c où ∀i = 1…n, c 1 n i =
1
x
�i ∨ … ∨ x k−i
i
Exemple
⎧a
∨ b ∨ ¬c ⎫
⎪
⎪
Σ = ⎨¬a
∨ b ∨ ¬d ⎬
⎪
⎩¬b
∨ c ∨ d ⎪
⎭
Σ
?
⎯ →⎯ P( Σ)
une solution est ( a,b,c,d ) = ( T,T,T,T )
littéral a ou ¬a
Toute clause a 1 ∨ … ∨ a n ∨ ¬b 1 ∨ … ∨ ¬b m , n + m > 0 est transformée en une règle
faux : − b 1 ,…,b m ,not a 1 ,…,not a n

Pour toute variable propositionnelle x, on crée 2 règles :
⎧x
: − not nx
⎨
⎩nx
: − not x
On ajoute une règle qui interdit les interprétations qui ne satisfont pas toutes les clauses :
bug : – condition_ incorecte( i.e. faux),
not bug.
Soit A un modèle stable de P( Σ)
alors x ∈ A ⇒ i( x)
= V et
⎧⎪
x ∉ A ⇒ i x
⎨
⎩⎪ nx ∈ A ⇒ i x
Démonstration
− ∀A le modèle stable de P( Σ),
faux ∉ A à cause de la règle bug : – faux,not bug
– on a x ∈ A et nx ∉ A
( ) = F
( ) = F
( )
( ) ou ( x ∉ A et nx ∈ A)
( à cause des règles x : − not nx, nx : - not x)
– Soit A un modèle stable de P Σ
∃i ∈ 1…m
( ). ∀ la règle faux : − b 1 ,…,b m ,not a 1 ,…,not a n on a
{ } tel que b ∉ A ou ∃j ∈ 1…n
i { } tel que a ∉ A j
⇒ ∃i ∈{ 1…m}
tel que nb ∈ A ou ∃j ∈ 1…n
i { } tel que a ∈ A j
⇒ ∃i ∈{ 1…m}
tel que v ( bi ) = faux ou ∃j ∈{ 1…n}
tel que v aj ⇒ i( a ∨ … ∨ a ∨ ¬b ∨ … ∨ ¬b 1 n 1 m ) = vrai
⇒ ∀ la clause c ∈ Σ, v ( c)
= vrai
⇒ v est un modèle de Σ
– Soit v un modèle de Σ. On définit A = x / v x
Σ
Σ ∪ a
∀ la clause a 1 ∨ … ∨ a n ∨ ¬b 1 ∨ … ∨ ¬b m ∈ Σ
{ ( ) = vrai}
∪ nx / v ( x)
= faux
{ }
( ) = faux
∃i ∈{ 1,…,n } tel que v ( ai ) = vrai ou ∃j ∈{ 1,…,m } tel que v bj ⇒ ∃i ∈{ 1,…,n } tel que a ∈ A ou ∃j ∈ 1,…,m
i { } tel que nb ∈ A j
⇒ ∃i ∈{ 1,…,n } tel que a ∈ A ou ∃j ∈ 1,…,m
i { } tel que b ∉ A j
P( Σ)
A { x / x ∈ A}
∪ { nx / nx ∈ A}
= �{
faux : − b ,…,b / ∃j ∈ 1,…,m
1 m { } b ∉ A j } ∪ { bug : − faux. }
Cn P( Σ)
A
= A ⇒ A est un modèle stable de P( Σ)
{ }
{ }
Σ ∪ ¬b
( )
⎯ →⎯
P( Σ)
( ) ∪ { faux : − not a. }
P( Σ)
∪ { faux : − b. }
P Σ
( ) = vrai
Résultat
Déterminer si un pln possède (ou non) un modèle stable est un problème NP-complet.
Comme on peut le “coder”, il existe une transformation polynomiale de SAT vers un pln.

La complexité est au moins celle de SAT.
Soit A l’ensemble des atomes apparaissant dans un pln. ∀A ∈2 A ( ∀A ⊆ A),
tester si A est un modèle stable de P, i.e. si A = Cn P A ( ), se réalise en temps polynomial.
La complexité du problème est au moins NP.
Variables dans les règles
Les symboles de fonctions ne sont pas permis.
e.g. f ( 0),
g( f ( 0),f
( 0)
), succ 0
( ) = 1, succ succ( 0)
( ) = 2 ne sont pas permis.
Garder un ensemble fini de constantes pour garder la décidabilité
Toute règle avec des variables est remplacée par un ensemble de règles instanciées
(ground) où chaque variable est remplacée par l’une des constantes du langages.
⎧q(
1),
q( 2),
r( 1,3)
⎫
⎪
⎪
⎪p(
1)
: − q( 1),not
r( 1,1)
⎪
⎪p(
1)
: − q( 1),not
r( 1,2)
⎪
⎪
⎪
⎧p(
X ) : − q( X ),not r( X,Y ) ⎫ ⎪p(
1)
: − q( 1),not
r( 1,3)
⎪ ⎧⎪
q( 1),q
( 2),r
( 1,3)
⎫⎪
⎪
⎪
⎪q(
1).
⎪
⎪
⎪p(
2)
: − q( 2),not
r( 2,1)
⎪ ⎨
⎬
⎪
P = ⎨
⎬ ⎯ →⎯ P = ⎨
⎬ ⇒ ⎩⎪ p( 1),p
( 2)
⎭⎪
⎪r(
1,3).
⎪ ⎪p(
2)
: − q( 2),not
r( 2,2)
⎪ est le modèle
⎪
⎩
q( 2).
⎪ ⎪
⎭
p( 2)
: − q( 2),not
r( 2,3)
⎪ stable de P
⎪
⎪
⎪p(
3)
: − q( 3),not
r( 3,1)
⎪
⎪p(
3)
: − q( 3),not
r( 3,2)
⎪
⎪
⎪
⎩⎪
p( 3)
: − q( 3),not
r( 3,3)
⎭⎪
Answer Set Programming
Coder un problème combinatoire par un programme logique normal.
Exemple : 3-coloration d’un graphe (syntaxe lparse)
vert(1), rouge(4), bleu(2), vert(3)
• Règles : décrivant les données du problème
sommet(1..4). arete(1,2). arete(2,3). arete(3,4). arete(1,4).
• Espace de recherche : toutes les combinaisons possibles
rouge(X ) : − sommet(X ), not bleu(X ), not vert(X ).
vert(X ) : − sommet(X ), not rouge(X ), not bleu(X ).
bleu(X ) : − sommet(X ), not vert(X ), not rouge(X ).
• Contraintes à satisfaire
bug : − arete(X,Y ), rouge(X ), rouge(Y ), not bug.
bug : − arete(X,Y ), vert(X ), vert(Y ), not bug.
bug : − arete(X,Y ), bleu(X ), bleu(Y ), not bug.

Algorithmes pour solveur ASP
pln → SAT et utiliser un solveur SAT
Algorithme de type backtrack sur un arbre de recherche binaire où les points de choix sont
les “atomes” (cf. smodels, dlv). Après chaque choix, on a des phases de propagation :
{ } et la règle c : − r, not b.
alors c doit être ajouté et la branche not c n’a pas à être explorée { a, c, not b}
− Si on a a, not b
{ } et une seule règle d : − not a.
alors on peut choisir la branche not d et ignorer la branche d.
− Si on a a, not b
Points de choix sur les règles
r est bloquée par A si corps – ( r)
∩ A ≠ Ø
r est supportée par A si corps + ( r)
⊆ A
R est un ensemble de règles enracinées si R = ri i∈I
( { } )
tel que ∀i ∈I, r i est supportée par Tête r i ,…,r i−1
Exemple
R1 R2 R3 R4 R i i=1…4
a.
b : − a, not c.
1
b : − a, not d.
2
e : − b , b . 1 2
est enraciné
Soit P un programme logique normal et A un ensemble d’atomes.
L’ensemble des règles génératrices de P par rapport à A est :
GR( P,A)
= { r ∈P / r est supportée par A et non bloquée par A}
Résultat
( ) est enraciné
( ) +
⎧GR
P,A
⎪
A est un modèle stable de P ⇔ ⎨
A = Cn GR P,A
⎩
⎪
( )
Algorithme
Construire un ensemble maximal enraciné de règles qui ne se bloquent pas.
Tête R
( ) = modèle stable cherché