Automatisch Redeneren in de praktijk Logisch Programmeren Automatisch Redeneren in de praktijk

Motivatie: monotoniciteit Eerste-orde logica is monotoon: G T ’ T |= F1 F2 F3 Maar: mensen redeneren zelden monotoon ! + Fred is pinguin Vogels vliegen + Fred is vogel Fred vliegt

Default redeneren: Is een redeneervorm die we voortdurend willen kunnen gebruiken anders worden de regels veel te complex ! Is typisch wat ondersteund wordt door hierarchie-en, overerving en uitzonderingen in OOP ook een vroeg AI-formalisme KAN NIET in FOL welke encodering van je kennis je ook neemt !! WEL in tal van uitbreidingen van FOL niet-monotone logica’s waarvan de eenvoudigste … …

Logisch Programmeren Resolutie-gebaseerd automatisch redeneren: beperkt tot Horn clauses beperkt tot achterwaartse lineaire resolutie MAAR: met 3 belangrijke nieuwe uitbreidingen: Het teruggeven van Antwoord Substituties Kleinste-model semantiek in plaats van standaard FOL model semantiek Uitbreiding van Horn clause logica met Negatie als Eindige Faling

Antwoord substituties De link naar programmeren

Antwoord substituties anc(x,y)  parent(x,y) (1) anc(x,y)  parent(x,z)  anc(z,y) (2) parent(A,B) (3) parent(B,C) (4) false  anc(u,v) false  anc(u,v) false  parent(x1,z1)  anc(z1,y1) (2) {u/x1,v/y1} Antwoord: Ja, u v anc(u,v) false  anc(B,y1) (3) {x1/A,z1/B} Namelijk: u = A en v = C false  parent(B,y1) (1) {x2/B, y2/y1} false  (4) {y1/C} (de samenstelling van alle mgu’s toe- gepast op de variabelen in de goal)

En berekent ALLE antwoorden anc(x,y)  parent(x,y) (1) anc(x,y)  parent(x,z)  anc(z,y) (2) parent(A,B) (3) parent(B,C) (4) false  anc(u,v) false  anc(u,v) false  parent(x1,y1) (1) {u/x1,v/y1} false  (3) {x1/A,y1/B} false  (4) {x1/B,y1/C} Derde antwoord: u = B en v = C Nog een antwoord: u = A en v = B

Logisch PROGRAMMEREN Door het berekenen van antwoord substituties vormt Logisch Programmeren de basis voor enkele “general purpose” programmeertalen. o.a.: Prolog, Mercury, XSB, … met een uitvoeringsefficiëntie vergelijkbaar met c ! Voor sommige programma’s zelfs sneller.

Practisch programmeren? Voorbeeld aritmetiek: dubbel_plus_1(x,y)  y is 2*x + 1 false  dubbel_plus_1(3,z) Yes: z=7 false  dubbel_plus_1(2,5) Yes Voorbeeld lijsten: append([], lijst, lijst)  append([x|lijst1], lijst2, [x|lijst3])  append(lijst1, lijst2, lijst3) false  append([1,2], [3,4,5], z) Yes: z= [1,2,3,4,5] false  append([1,2], y, [1,2,3]) Yes: y= [3] false  append(x, y, [1,2]) Yes: x = [], y = [1,2] x = [1], y = [2] …

Kleinste model semantiek Compacter specifieren

Kleinste model semantiek Voorbeeld: een gegevensbank: BV(Crabé) BV(Jambers) BV(Peeters) BV(Lisa) BV(Tieleman) BV(Samson) Is DeSchreye een BV ?? false  BV(DeSchreye) We krijgen geen inconsistentie bewijs ! FOL semantiek zegt: BV(DeSchreye) is geen logisch gevolg, dus: we weten niet of het waar is of niet! Kleinste model semantiek zegt: ~ BV(DeSchreye)

Formeel: het idee Wat zijn de atomaire gevolgen van theorie T? T q ~s model 2 T model 3 p ~r ~q s model 1 In FOL: Gevolgen zijn in de intersectie: p en ~r. Over waarheid van q en s weten we niets. In LP: Gevolgen zijn in de intersectie: p en ~r. Alle andere eigenschappen zijn NIET waar: ~q en ~s.

Relatie tot FOL Het logisch programma: BV(Crabé) BV(Jambers) BV(Peeters) BV(Lisa) BV(Tieleman) BV(Samson) Het logisch programma: BV(Crabé) BV(Jambers) BV(Peeters) ~BV(DeSchreye) ~BV(Janssens) … BV(Lisa) BV(Tieleman) BV(Samson) ~BV(Cobain) ~BV(Dali) is equivalent aan de oneindige FOL theorie: x BV(x)  (x = Crabé)  (x = Jambers)  (x = Peeters)  (x = Lisa)  ( x = Tieleman)  (x = Samson) of ook aan:

De “gesloten wereld” assumptie Logisch programmeren geeft een compacte manier om ‘volledige kennis’ over iets uit te drukken. Indien je niet zegt dat iets waar is, dan is het onwaar. De Gesloten Wereld Assumptie ! (= alles wat niet volgt uit de theorie is onwaar) Anders gezegd: Logisch Programmeren ondersteunt het formuleren van definities van je concepten. Niet slechts formuleren van wat er waar is betreffende die concepten (=FOL) !

Hoe relevant is de verandering in semantiek? In FOL: {slim(Kelly)} impliceert noch sterk(Kelly) noch ~sterk(Kelly) In LP: {slim(Kelly)} impliceert ~sterk(Kelly) In het bijzonder: LP is een niet-monotone logica !! In {slim(Kelly), sterk(Kelly)} is ~sterk(Kelly) geen gevolg meer. Kennis wordt verschillend voorgesteld in de 2 formalismen. Ook: sommige concepten kunnen volledig axiomatizeerd worden in LP en niet in FOL. Vb.: de natuurlijke getallen !

Negatie als eindige faling

Negatie als eindige faling Het basis-idee: uitbreiding van de representatiekracht van Logisch Programmeren voorbij Horn clause logica Hoe? equivalent: laat disjuncties in de hoofden toe laat negatie voor de body-atomen toe beide geven volledige predicaten logica ! (maar: door de kleinste model semantiek zullen we toch iets verschillends van FOL krijgen!) Hier: Introductie van negaties in bodies !

Betekenis van negatie als eindige faling Is niet de betekenis van standaard negatie Als alle pogingen om B te bewijzen, gebruik makend van lineaire LP-resolutie, na eindige tijd allemaal falen, besluit dan not(B) not(B) betekent: Dit is alleen zinvol onder de kleinste model semantiek (waar alles wat niet bewijsbaar ‘waar’ is, toch ‘onwaar’ is)

Het ancestor voorbeeld anc(x,y)  parent(x,y) (1) anc(x,y)  parent(x,z)  anc(z,y) (2) parent(A,B) (3) parent(B,C) (4) false  anc(u,v) Probeer te bewijzen dat “anc(John,B)” geldt! false  anc(John,B) false  parent(John,B) (1) {x/John,y/B} faalt false  parent(John,z)  anc(z,B) (2) {x/John,y/B} faalt Besluit: not anc(John,B)

Een ander voorbeeld even(0) even(s(s(x)))  even(x) oneven(y)  not even(y) false  oneven(s(s(s(0)))) false  oneven(s(s(s(0)))) false  not even(s(s(s(0)))) false  even(s(s(s(0)))) false  even(s(0)) {x/s(0)} Bewijs voor even(s(s(s(0)))) faalt: besluit not even(s(s(s(0)))) false  faalt

Nog een voorbeeld q  q p  not q false  p false  p false  not q false  q false  q … Bewijs voor q gaat in een oneindige afleiding: geen conclusie voor not q geen antwoord Maar ~q is wel waar volgens kleinste model semantiek !

Default redeneren in LP (1): locomotion(x,Fly)  isa(x,Bird), not abnormal1(x) locomotion(x,Walk)  isa(x,Ostrich), not abnormal2(x) isa(x,Bird)  isa(x,Ostrich) abnormal1(x)  isa(x,Ostrich) Ook gegeven: isa(Fred,Bird) , Bewijs: x locomotion(Fred,x) {x/Fly} false <- locomotion(Fred,x) false <- isa(Fred,Bird), not abnormal1(Fred) false <- not abnormal1(Fred) false <- abnormal1(Fred) false <- false <- isa(Fred,Ostrich) faalt

Default redeneren in LP (2): locomotion(x,Fly)  isa(x,Bird), not abnormal1(x) locomotion(x,Walk)  isa(x,Ostrich), not abnormal2(x) isa(x,Bird)  isa(x,Ostrich) abnormal1(x)  isa(x,Ostrich) isa(Fred,Bird) Ook gegeven: isa(Fred,Ostrich) , Bewijs: x locomotion(Fred,x) {x/Fly} false <- locomotion(Fred,x) false <- isa(Fred,Bird), not abnormal1(Fred) false <- not abnormal1(Fred) false <- abnormal1(Fred) faalt (voor deze tak) backtracking: 2de tak false <- isa(Fred,Ostrich) false <-

Default redeneren (3): Ook gegeven: isa(Fred,Ostrich) , Bewijs: x locomotion(Fred,x) locomotion(x,Fly)  isa(x,Bird), not abnormal1(x) locomotion(x,Walk)  isa(x,Ostrich), not abnormal2(x) isa(x,Bird)  isa(x,Ostrich) abnormal1(x)  isa(x,Ostrich) isa(Fred,Bird) {x/Walk} false <- locomotion(Fred,x) false <- isa(Fred,Ostrich), not abnormal2(Fred) false <- not abnormal2(Fred) false <- abnormal2(Fred) false <- faalt

Prolog Een specifieke programmeertaal gebaseerd op LP. Gebruikt een diepte-eerst strategie voor het doorzoeken van de lineaire resolutie bewijzen. niet volledig kan in oneindige takken terecht komen Heeft een boel builtin predicaten (soms zonder logische betekenis) voor: numerisch berekeningen, input-output, beinvloeden van het zoekmechanisme, meta-programmatie, enz. Meer recente LP talen: Goedel, Mercury, Hal, ..

Voorbij FOL en Logisch Programmeren Logisch Programmeren is heel nuttig als je VOLLEDIGE kennis hebt over je predicaten FOL is heel nuttig als je ONVOLLEDIGE kennis hebt Combineer ! Open Logisch Programmeren LP-definities voor het gedeelte waarover je volledige kennis hebt, FOL formules voor de rest.

Constraint Logic Programming Integreer constraint processing technieken (consistentie, forward checking, looking ahead, …) met Logisch Programmeren. Voordelen van Logica voor kennisrepresentatie Voordelen van Constraint solving voor problem solving efficientie Heel wat talen: CHIP, Prolog III, Eclipse, Sicsus, enz.