Inférence en logique du premier ordre

Présentation au sujet: "Inférence en logique du premier ordre"— Transcription de la présentation:

1 Inférence en logique du premier ordre
Chap. 9

2 Plan Réduire l’inférence de la logique du premier ordre en celle de la logique propositionnelle Unification Modus Ponens généralisé Chaînage avant et arrière Résolution

3 Instanciation universelle (UI)
Chaque instanciation d’une phrase universellement quantifiée est entraînée par cette dernière: v α Subst({v/g}, α) pour toute variable v et tout terme instancié (grounded) g E.g., x King(x)  Greedy(x)  Evil(x) peut entraîner: King(John)  Greedy(John)  Evil(John) King(Richard)  Greedy(Richard)  Evil(Richard) King(Father(John))  Greedy(Father(John))  Evil(Father(John))

4 Instanciation existentielle (EI)
Pour toute phrase α et variable v, et un symbole de constante k qui n’apparaît pas dans la base de connaissances: v α Subst({v/k}, α) E.g., x Crown(x)  OnHead(x,John) entraîne: Crown(C1)  OnHead(C1,John) en supposant que C1 est un nouveau symbole de constante jamais utilisé dans la base de connaissances. Cette constante est appelée constante Skolem

5 Réduction en inférence propositionnelle
Supposons que la KB contient les phrases suivantes: x King(x)  Greedy(x)  Evil(x) King(John) Greedy(John) Brother(Richard,John) Instancier la phrase universelle de toutes les façns possibles: King(John)  Greedy(John)  Evil(John) King(Richard)  Greedy(Richard)  Evil(Richard) La nouvelle KB est propositionnalisée: les symboles de propositions sont: King(John), Greedy(John), Evil(John), King(Richard), etc.

6 Réduction contd. Chaque base de connaissances en LPO peut être propositionnalisée pour préserver l’entraînement (Une phrase instanciée est entraînée par la nouvelle KB ssi elle est entraînée par la KB originale) Idée: propositionnaliser KB et requête, appliquer la résolution, et retourner le résultat Problème: avec le symbole de fonction, il y a un nombre infini de termes instanciés: e.g., Father(Father(Father(John)))

7 Réduction contd. Théorème: Herbrand (1930). Si une phrase α est entraînée par une KB en LPO, alors elle est aussi entraînée par un sous-ensemble de KB propositionnalisée Idée: Pour n = 0 à ∞ do créer la KB propositionnalisée en instanciant les termes à la profondeur n vérifier si α est entraînée par cette KB Problème: fonctionne si α est entraînée. Mais boucle infini sinon. semidécidable (des algorithmes existent pour répondre “oui” à toute phrase entraînée, mais il n’y a pas d’algorithme pour répondre “non” à toute phrase non-entraînée)

8 Problèmes avec la propositionnalisation
La propositionnalisation peut générer beaucoup de phrases non pertinentes. E.g., à partir de: x King(x)  Greedy(x)  Evil(x) King(John) y Greedy(y) Brother(Richard,John) Il semble évident que Evil(John), mais la propositionnalisation produit beaucoup de faits tels que Greedy(Richard) qui n’est pas pertinente Avec un nombre p de prédicats à k arguments et n constantes, il y a p·nk instanciations.

9 Unification On peut obtenir l’inférence immédiatement si on peut trouver une substitution θ telle que King(x) et Greedy(x) match King(John) et Greedy(y) θ = {x/John,y/John} fonctionne pour ça Unify(α,β) = θ si αθ = βθ p q θ Knows(John,x) Knows(John,Jane) Knows(John,x) Knows(y,OJ) Knows(John,x) Knows(y,Mother(y)) Knows(John,x) Knows(x,OJ) Standardizing apart élimine la confusion des variables, e.g., Knows(z17,OJ)

10 Unification On peut obtenir l’inférence immédiatement si on peut trouver une substitution θ telle que King(x) et Greedy(x) match King(John) et Greedy(y) θ = {x/John,y/John} fonctionne pour ça Unify(α,β) = θ si αθ = βθ p q θ Knows(John,x) Knows(John,Jane) {x/Jane}} Knows(John,x) Knows(y,OJ) Knows(John,x) Knows(y,Mother(y)) Knows(John,x) Knows(x,OJ) Standardizing apart élimine la confusion des variables, e.g., Knows(z17,OJ)

11 Unification On peut obtenir l’inférence immédiatement si on peut trouver une substitution θ telle que King(x) et Greedy(x) match King(John) et Greedy(y) θ = {x/John,y/John} fonctionne pour ça Unify(α,β) = θ si αθ = βθ p q θ Knows(John,x) Knows(John,Jane) {x/Jane}} Knows(John,x) Knows(y,OJ) {x/OJ,y/John}} Knows(John,x) Knows(y,Mother(y)) Knows(John,x) Knows(x,OJ) Standardizing apart élimine la confusion des variables, e.g., Knows(z17,OJ)

12 Unification On peut obtenir l’inférence immédiatement si on peut trouver une substitution θ telle que King(x) et Greedy(x) match King(John) et Greedy(y) θ = {x/John,y/John} fonctionne pour ça Unify(α,β) = θ si αθ = βθ p q θ Knows(John,x) Knows(John,Jane) {x/Jane}} Knows(John,x) Knows(y,OJ) {x/OJ,y/John}} Knows(John,x) Knows(y,Mother(y)) {y/John,x/Mother(John)}} Knows(John,x) Knows(x,OJ) Standardizing apart élimine la confusion des variables, e.g., Knows(z17,OJ)

13 Unification On peut obtenir l’inférence immédiatement si on peut trouver une substitution θ telle que King(x) et Greedy(x) match King(John) et Greedy(y) θ = {x/John,y/John} fonctionne pour ça Unify(α,β) = θ si αθ = βθ p q θ Knows(John,x) Knows(John,Jane) {x/Jane}} Knows(John,x) Knows(y,OJ) {x/OJ,y/John}} Knows(John,x) Knows(y,Mother(y)) {y/John,x/Mother(John)}} Knows(John,x) Knows(x,OJ) {fail} Standardizing apart élimine la confusion des variables, e.g., Knows(z17,OJ)

14 Unification Pour unifier Knows(John,x) et Knows(y,z),
θ = {y/John, x/z } ou θ = {y/John, x/John, z/John} La première est plus générale que la seconde. Il y a une seule unification la plus générale (most general unifier - MGU) qui est unique, excepté la rénomination des variables MGU = { y/John, x/z }

15 Algorithme d’unification

16 Algorithme d’unification

17 Modus Ponens généralisé (GMP)
p1', p2', … , pn', ( p1  p2  …  pn q) qθ p1' est King(John) p1 est King(x) θ1={x/John} p2' est Greedy(y) p2 est Greedy(x) θ2={x/y} ou θ={y/x} θ est {x/John,y/John q est Evil(x) q θ est Evil(John) GMP utilisé avec KB de clauses définies (definite clauses) (exactement un littéral positif) ( p1  p2  …  pn q) (p1  p2 …  pn  q) Toute variable est supposée être avec quantificateur universel où pi'θ = pi θ pour tout i

18 Adéquation de GMP On a besoin de prouver
p1', …, pn', (p1  …  pn  q) ╞ qθ en supposant que pi'θ = piθ pour tout i Lemma: Pour une phrase quelconque p, nous avons p ╞ pθ par UI (instanciation universelle) (p1  …  pn  q) ╞ (p1  …  pn  q)θ = (p1θ  …  pnθ  qθ) p1', …, pn' ╞ p1'  …  pn' ╞ p1'θ  …  pn'θ De 1 et 2, qθ suit en utilisant Modus Ponens ordinaire

19 Exemple de base de connaissances
(La loi dit que c’est un crime pour un américain de vendre des armes aux pays hostiles. Le pays Nono, un ennemie de l’Amérique, a des missiles, et tous ses missiles étaient vendus par Colonel West, qui est un américain.) Prove that Col. West is a criminal

20 Exemple de base de connaissances
... it is a crime for an American to sell weapons to hostile nations: American(x)  Weapon(y)  Sells(x,y,z)  Hostile(z)  Criminal(x) Nono … has some missiles, i.e., x Owns(Nono,x)  Missile(x): Owns(Nono,M1) and Missile(M1) … all of its missiles were sold to it by Colonel West Missile(x)  Owns(Nono,x)  Sells(West,x,Nono) Missiles are weapons: Missile(x)  Weapon(x) An enemy of America counts as "hostile“: Enemy(x,America)  Hostile(x) West, who is American … American(West) The country Nono, an enemy of America … Enemy(Nono,America)

21 Chaînage avant

22 Chaînage avant

23 Chaînage avant

24 Chaînage avant

25 Propriétés du chaînage avant
Adéquat et complet pour les clauses définies du premier ordre Datalog = clauses définies du premier ordre + sans fonctions Ch. avant termine pour Datalog en un nombre fini d’itérations Peut ne pas terminer en général si α n’et pas entraîné Ceci est inévitable: l’entraînement avec les clauses définies est semidécidable

26 Efficacité du chaînage avant
Chaînage avant incrémental: pas besoin de matcher une règle à l’itération k si une prémise n’était pas ajoutée à l’itération k-1 Matcher chaque règle don’t la prémise contient un ittéral positif nouvellement ajouté Matching peut être coûteux: Indexation de base de données (Database indexing) permet O(1) pour retrouver des faits connus e.g., requête Missile(x) retrouve Missile(M1) Ch. avant est largement utilisé dans les bases de données déductives

27 Exemple de match difficile
Diff(wa,nt)  Diff(wa,sa)  Diff(nt,q)  Diff(nt,sa)  Diff(q,nsw)  Diff(q,sa)  Diff(nsw,v)  Diff(nsw,sa)  Diff(v,sa)  Colorable() Diff(Red,Blue) Diff (Red,Green) Diff(Green,Red) Diff(Green,Blue) Diff(Blue,Red) Diff(Blue,Green) Colorable() est inféré ssi CSP a une solution CSPs contiennent 3SAT comme cas spécial, donc matching est NP-difficile

28 Chaînage arrière SUBST(COMPOSE(θ1, θ2), p) = SUBST(θ2, SUBST(θ1, p))

29 Chaînage arrière: Exemple

30 Chaînage arrière: Exemple

31 Chaînage arrière: Exemple

32 Chaînage arrière: Exemple

33 Chaînage arrière: Exemple

34 Chaînage arrière: Exemple

35 Chaînage arrière: Exemple

36 Chaînage arrière: Exemple

37 Propriétés du chaînage arrière
Preuve en recherche en profondeur récursive: espace de taille linéaire Incomplet à cause de boucles infinis possibles Fixer le problème en examinant le but courant avec tout le stack de buts Inefficace dû aux sous-buts répétés (réussis ou échoués)  Fixer le prob. en utilisant le cashe (espace additionnel) Largement utilisé en programmation logique (Prolog)

38 Programmation logique: Prolog
Algorithme = Logique + Contrôle Base: chaînage arrière avec clauses Horn + certains gadgets Répandu en Europe, Japon (base du projet de 5ième génération) Technique de compilation  60 million LIPS Programme = ensemble de clauses = head :- literal1, … literaln. criminal(X) :- american(X), weapon(Y), sells(X,Y,Z), hostile(Z). Recherche en profondeur, de gauche à droite, chaînage arrière Prédicats prédéfinis (Built-in) pour des opérations arithmétiques. etc., e.g., X is Y*Z+3 Prédicats prédéfinis pour entrée-sortie, assertion/retract, … Hypothèse du monde clos (Closed-world assumption) ("negation as failure") e.g., avec alive(X) :- not dead(X). alive(joe) réussi si dead(joe) échoue

39 Prolog Concaténer 2 listes pour produire la 3ième: append([],Y,Y).
append([X|L],Y,[X|Z]) :- append(L,Y,Z). Équivalent en logique: append([],Y,X) append(L,Y,Z)  append([X|L],Y,[X|Z]) requête: append(A,B,[1,2]) ? réponse: A=[] B=[1,2] A=[1] B=[2] A=[1,2] B=[]

40 Règle de Résolution Version complète du premier ordre:
l1  ···  lk, m1  ···  mn (l1  ···  li-1  li+1  ···  lk  m1  ···  mj-1  mj+1  ···  mn)θ avec Unify(li, mj) = θ. Exemple Rich(x)  Unhappy(x) Rich(Ken) Unhappy(Ken) avec θ = {x/Ken} Appliquer la résolution sur CNF(KB  α); complet pour LPO

41 Factoring Une application binaire de la règle de résolution
Combiner 2 clauses chaque fois Non complète seule Ajouter le factoring Si 2 éléments dans la clause sont unifiables, alors réduire la clause en unifiant les éléments Application binaire + factoring = complet

42 Uitliser la preuve de résolution par contradiction
Convertir la KB en clauses (CNF) Convertir la négation de la conclusion en clause Appliquer la règle de résolution Si on produit une clause vide (contradiction), alros la conclusion est prouvée

43 Conversion en CNF Everyone who loves all animals is loved by someone:
x [y Animal(y)  Loves(x,y)]  [y Loves(y,x)] 1. Éliminner biconditionnels et implications x [y Animal(y)  Loves(x,y)]  [y Loves(y,x)] 2. bouger  vers l’intérieur (x p ≡ x p,  x p ≡ x p) x [y (Animal(y)  Loves(x,y))]  [y Loves(y,x)] x [y Animal(y)  Loves(x,y)]  [y Loves(y,x)] x [y Animal(y)  Loves(x,y)]  [y Loves(y,x)]

44 Conversion en CNF contd.
Standardiser les variables: chaque quantificateur utilise une variable différente x [y Animal(y)  Loves(x,y)]  [z Loves(z,x)] Skolemiser: Chaque variable existancielle est remplacé par une Fonction Skolem des variables universelles reliées: x [Animal(F(x))  Loves(x,F(x))]  Loves(G(x),x) Enlever les quantificateurs universels [Animal(F(x))  Loves(x,F(x))]  Loves(G(x),x) Distribuer  sur  : [Animal(F(x))  Loves(G(x),x)]  [Loves(x,F(x))  Loves(G(x),x)]

45 Preuve avec la résolution par contradiction

46 Sommaire Généralisation des procédures d’inférence: Logique propositionnelle  LPO Unification pour traiter des variables Règle de résolution (avec contradiction) Adéquat et complet pour LPO Prolog