1 / 49

Programació lòg ica: Sicstus-Prolog

Programació lòg ica: Sicstus-Prolog. Γ  P(X)  P(f(a))  . {Γ  } [X  f(a)]. Mateu Villaret (2007). Índex. Introducció Llistes Arbre de cerca Aspectes extra-lògics Aritmètica E/S Metapredicats Constraints. Introducció 1.

marika
Download Presentation

Programació lòg ica: Sicstus-Prolog

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Programació lògica: Sicstus-Prolog Γ  P(X)  P(f(a))   {Γ  } [X  f(a)] Mateu Villaret (2007)

  2. Índex • Introducció • Llistes • Arbre de cerca • Aspectes extra-lògics • Aritmètica • E/S • Metapredicats • Constraints

  3. Introducció1 • El Prolog és un llenguatge de programació lògica que serveix per a validar fets en una teoria donada. • L’usuari defineix una Base de dades de Fets i Regles sobre els fets i Prolog respon a les preguntes que es facin sobre la teoria.

  4. Introducció 2 • Els fets poden tenir arguments o no: • plou. dona(gemma). menja(joan,poma). • Les regles, expressen el condicional: • mare(X,Y):-dona(X),progenitor(X,Y). és a dir:SiX és una dona, iX és progenitor de Y, llavorsX és la mare de Y. • La sintaxis és la següent: • Constants i predicats comencen en minúscules. Les variables amb majúscules. Els fets i les regles acaben amb “.”. La “,” vol dir “i”. Cal posar els fets/regles d’un mateix tipus seguits. Quan escrivim”_”, ens estem referint a una variable qualsevol sense nom.

  5. dona(neus). dona(gemma). dona(conxita). dona(roser). home(manel). home(lluis). home(narcis). home(lluistomas). progenitor(roser,gemma). progenitor(roser,narcis). progenitor(lluistomas,gemma). progenitor(lluistomas,narcis). progenitor(manel,roser). progenitor(conxita,roser). progenitor(lluis,lluistomas). progenitor(neus,lluistomas). avantpassat(X,Y):-progenitor(X,Y). avantpassat(X,Y):-progenitor(X,Z), avantpassat(Z,Y). Aquest és el fitxer genea.pl. Engeguem sicstus Carreguem la base de fets i regles: [genea]. . Ara podem fer preguntes acabades amb “.”. | ?- home(narcis). yes ?- progenitor(manel,roser). yes Introducció 3

  6. Introducció 4 • Afegim les regles: mare(X,Y):- dona(X), progenitor(X,Y). pare(X,Y):- home(X), progenitor(X,Y). • A part de “confirmar” fets, podem preguntar per valors que facin certs alguns fets: • | ?- mare(X,gemma). X = roser ? yes • | ?- avantpassat(X,gemma). X = roser ?; X = lluistomas ?; X = manel ? ; X = conxita? ; X = lluis ? ; X = neus ? ; no • | ?- mare(roser,X), mare(roser,Y), X\==Y. X = gemma Y = narcis ? yes

  7. Introducció 5 • La clau del funcionament és la unificació dona(X)? dona(roser) X=roser X=gemma X= neus ... • que busca solucions per a poder aplicar la resolució i tenir certesa dona(neus) dona(gemma) ¬dona(X) dona(roser) 

  8. Introducció 6Un interpretador abstracte per a programes lògics Ent: un objectiu O i un programa P Sort: una instància de O que és cons. Lòg. de P o No Inicialitza el resolent a O Mentre el resolent no sigui buit fer • escull un objectiu A del resolent • escull una clàusula: A’ <-- B1, …, Bn de P tal que A i A’ unifiquin amb l’unificador σ. (Si no es pot Surt amb NO) • substitueix A per B1, …, Bn al resolent i aplica-hi σ Torna O

  9. Introducció 7 mare(roser,X). Resolent: { mare(roser, X) } Objectiu: mare(roser, X) Clàusula: mare(X1, Y1):- dona(X1), progenitor(X1, Y1). Unifiquem: [X1->roser, Y1-> X] Resolent: { dona(roser), progenitor(roser,X) } Objectiu: dona(roser) Clàusula: dona(roser) Resolent: { progenitor(roser,X) } Objectiu: progenitor(roser,X) Clàusula: progenitor(roser,gemma) Unifiquem: [X->gemma] Resolent: { }

  10. Introducció 8 • Què passa però, quan demanem més resultats? • Què passa quan no aconsegueix la clàusula buida però podia haver seguit “altres opcions”? BACKTRACKING: recula i segueix per on troba un camí alternatiu. (mes solucions) Resolent: { progenitor(roser,X) } Objectiu: progenitor(roser,X) Clàusula: progenitor(roser,narcis) Unifiquem: [X->narcis] Resolent: { }

  11. Introducció 9 Si canviem la pregunta i agafem un “camí” que fracassa ... mare(X,narcis). Resolent: { mare(X, narcis) } Objectiu: mare(X, narcis) Clàusula: mare(X1, Y1):- dona(X1), progenitor(X1, Y1). Unifiquem: [X1->X, Y1-> narcis] Resolent: { dona(X), progenitor(X,narcis) } Objectiu: dona(X) Clàusula: dona(neus) Unifiquem: [X->neus] Resolent: { progenitor(neus,narcis) } Objectiu: progenitor(neus,narcis) Clàusula: ??? Hem de recular i trobar un camí correcte. [X->roser]

  12. Llistes 1 • La notació de les llistes amb prolog és: • [X|L], on X és el cap i L la cua. Ex: [1|[2,3]] • [], la llista buida. • [X1,X2|L], on X1 és el primer, X2 el segon i L la cua. • [X,Y,Z], on X és el primer, Y el segon i Z l’últim. • Una funció típica i ja definida: • member(X,[X|_]). • member(X,[_|XS]):-member(X,XS). • Un exemple d’us: • member(X,[1,2,3]). -member(mateu,X).

  13. Llistes 2 • Una altra funció predefinida és la de Concatenar. Que val: append(X,[1],[1,2,3,4,5|Y]).? • append([],Ys,Ys). • append([X|Xs],Ys,[X|Zs]):-append(Xs,Ys,Zs). • Comparar-los tots. Com generar llistes d’1? • totsiguals([]). • totsiguals([X]). • totsiguals([X,X|L]):-totsiguals([X|L]). • Filtrar. Que passa si demanem més solucions a: filtrar(1,[1,2,3,1,4]).? • treu(X,[],[]). • treu(X,[X|L1],L2):-treu(X,L1,L2). • treu(X,[Y|L1],[Y|L2]):-treu(X,L1,L2).

  14. Llistes 3 • Una espècie de map: • edat(gemma,24). edat(narcis, 23). • edats([X|LX],[Y,LY]):-edat(X,Y), edats(LX,LY). • | ?-Edats([gemma,narcis],L). • Permutacions: • treu1(X,[X|Xs],Xs). • treu1(X,[Y|Xs],[Y|Zs]):-treu1(X,Xs,Zs). • permutacio([],[]). • permutacio(Xs,[Y|Ys]):- treu1(Y,Xs,Zs),permutacio(Zs,Ys). • | ?-permutacio([1,2,3],P).

  15. Exemple hanoi(s(0),A,B,C,[de_a_(A, B)]). hanoi(s(N),A,B,C,Mov):- hanoi(N,A,C,B,Mov1), hanoi(N,C,B,A,Mov2), append(Mov1,[de_a_(A,B)|Mov2],Mov).

  16. L’arbre de Cerca ? q(X). La resposta ProLog | ?- q(X). X = 2 ; X = 2 ; X = 3 ; X = 1 ; X = 0 {X/0} ? p(X). p Donada la següent teoria: q(X):-p(X). q(0). p(X):-a(X),b(X). p(1). a(2). a(3). b(2). b(2). b(3). X=0 {X/1} p ? a(X),b(X). X=1 {X/2} {X/3} ? b(2). ? b(3). p p p X=2 X=2 X=3

  17. Aspectes “extra-lògics” 1 • L’ordrede les regles i dels fets, així com l’ordre dels “objectius” en el “cos” de les regles, condicionen el resultat. Així, member(X,[X|_]). member(X,[_|XS]):-member(X,XS). és diferent de: member(X,[_|XS]):-member(X,XS). member(X,[X|_]). Mireu sinó, ?-member(X,[1,2,3]).

  18. Aspectes “extra-lògics” 2(redundància) • Depèn de la definició de les regles podem tenir respostes repetides. Cal saber quan ens interessa que això passi. minim(X,Y,X):-X =< Y. O bé minim(X,Y,X):-X =< Y. minim(X,Y,Y):-Y =< X. minim(X,Y,Y):-Y < X. També tenim el cas del member. Si no volem redundància... me(X,[X|_]). me(X,[Y|YS]):-X\=Y, me(X,YS). Proveu amb me(1,[2,1,2,1]). i amb member(1,[2,1,2,1]). (\=) significa no unificables mentre que (\==) significa diferents!

  19. Aspectes “extra-lògics” 3(tall) • PROLOG ens proporcions un predicat anomenat tall: !, i que serveix per a podar l’arbre de cerca. • Això pot servir per evitar que es busquin solucions per “trossos” de l’arbre que se sap que no tenen solucions. • Millora d’eficiència • estalvi de redundància • Per exemple:(quan es pregunta minim(2,3,X). ja no pregunta per noves possibilitats) minim(X,Y,X):- X =< Y,!. minim(X,Y,Y):- Y < X,!. El predicat de tall es satisfà sempre.

  20. Aspectes “extra-lògics” 4(tall) • Donada una clàusula: C= A<- B1,…,Bk,!,Bk+1,…,Bn tal que A unifica amb l’objectiu G, i B1,…,Bk es satisfan, l’efecte de ! és: • Qualsevol altra clàusula que és pogués aplicar per resoldre G és ignorada. • Si al intentar satisfer algun Bi (n>= i >= k+1), es fracassa, només es fa BACKTRAKING fins al tall. • Si s’arriba a haver de refer el tall, es torna fins a l’elecció anterior de G i es fa BACKTRAKING a partir d’allà.

  21. Aspectes “extra-lògics” 5(tall) ? q(X). Sense el tall | ?- q(X). X = 2 ; X = 2 ; X = 3 ; X = 1 ; X = 0 {X/0} ? p(X). p Donada la següent teoria: q(X):-p(X). q(0). p(X):-a(X),!,b(X). p(1). a(2). a(3). b(2). b(2). b(3). X=0 {X/1} ? a(X),!,b(X). p X=1 {X/2} {X/3} Amb el tall | ?- q(X). X = 2 ; X = 2 ; X = 0 ? !,b(2). ? !,b(3). tall ? b(2). ? b(3). p p p X=2 X=2 X=3

  22. Aspectes “extra-lògics” 6(tall) • Un bon exemple: ordenat([]). ordenat([X]). ordenat([X,Y|Zs]):- X=<Y, ordenat([Y|Zs]). ordena(Xs,Xs):- ordenat(Xs),!. ordena(Xs,Ys):- append(As,[X,Y|Ns],Xs), X>Y, !, append(As,[Y,X|Ns],Xs1), ordena(Xs1,Ys). L’ordenació per intercanvi es pot fer en diferent ordre, però només hi ha una llista ordenada.

  23. Aspectes “extra-lògics” 7(la negació) • La negació en ProLog és \+(P) on P és un possible predicat. Es satisfà quan no pot demostrar P (i acaba és clar). Funciona així per la CWA, “assumpció del mon tancat” • Per exemple: q(a). q(b):-q(a). ? \+(q(c)). ?\+(q(b)). yes no

  24. Aritmètica 1 • Per interpretar expressions aritmètiques en Prolog s’ha de fer servir: -X is Eque significa: avalua l’expressió E fins a trobar un valor aritmètic. El predicat es satisfà si s’unifica el valor trobat amb X. • | ?- X is 3+5. X= 8 • | ?- X=3, Y is 3+X. X= 3, Y=6 • A diferència del is, l’igual “=“ unifica però no avalua. En Prolog no farem X is X+1.

  25. Aritmètica 2 • Exemples de predicats aritmètics: • parell(X):- 0 is X mod 2. • senar(X):- 1 is X mod 2. • suma(X,Y,Z):- Z is X+Y. Perquè no funcionaria suma(2,Y,5)?. • Una versió poc eficient del factorial: • fact(0,1). fact(N,F):- N>0, N1 is N-1, fact(N1,F1), F is N*F1.

  26. Aritmètica 3 • Exemples de predicats aritmètics amb llistes: • suma([],0). suma([X|Xs],S):-suma(Xs,S1), S is X + S1. • llarg([],0). llarg([X|Xs],S):-llarg(Xs,S1), S is 1 + S1. • Millorem l’eficiència d’aquests predicats: • suma(Xs,S):- sumAux(Xs,0,S). • sumAux([],S,S). sumAux([X|Xs],Sa,S):- Sparcial is X + Sa, sumAux(Xs,Sparcial,S).

  27. Alguns predicats “clàssics” 1 • Les permutacions d’una llista: permutacions(L,[X|XS]):- append( V, [X|U], L), append(V,U, W), permutacions(W, XS). permutacions([ ], [ ]). • Recordem que append ja està definida per: append([ ], L, L). append([X|XS], L, [X|YS]):-append(XS,L,YS). • Com podríem definir un predicat ordena amb permutacions?

  28. Alguns predicats “clàssics” 2 • Suposant que tenim un predicat particiona, el quicksort seria: • quicksort([ ], [ ]). quicksort([X|XS], L):- particiona(X, XS, MEN, MAJ), quicksort(MEN, MENORD), quicksort(MAJ, MAJORD), append(MENORD, [X|MAJORD], L) • El mergesort • merge([X|Xs],[Y|Ys],[X|Zs]):- X<Y,!, merge(Xs,[Y|Ys],Zs). merge([X|Xs],[Y|Ys],[X,Y|Zs]):- X==Y,!, merge(Xs,Ys,Zs). merge([X|Xs],[Y|Ys],[Y|Zs]):- X>Y,!, merge([X|Xs],Ys,Zs). merge(Xs,[],Xs):-!. merge([],Ys,Ys):-!. • El clàssic invers d’una llista: • invers([ ], [ ]). invers([X|XS], P):- invers(XS, PS), append(PS,[X], P).

  29. Termes i tipus (i) • Prolog no ens permet definir tipus nous. Per a usar altres tipus, hem de crear una definició del comportament dels termes: arrela(N, A1, A2, arbre(N, A1, A2)). node( arbre(N, _, _), N). fe(arbre(_, AE, _), AE). fd(arbre(_, _, AD), AD). preordre(arbre(N, A1, A2),[N|L]):- preordre(A1,L1), preordre(A2,L2), append(L1,L2,L). preordre(abuit,[]). • Els termes van amb minúscules.

  30. Termes i tipus (ii) • Prolog no fa comprovació de tipus (coherència dels termes) en temps de compilació, però disposa de predicats que ens permeten saber com és cada terme: • atom_chars(A,S), S és la llista de caràcters que fan A. • integer(X), float(X), number(X), X és enter, float, num. • atom(X), X és un atom: inordre, [], ‘a’, abuit. ([a,b] no) • atomic(X), X és un atom o un número. • compound(X), X és un terme compost: p(a), [a],. • var(X),X és una variable no instanciada. (nonvar) • list(L),L és una llista.

  31. Termes i tipus a Prolog (iii) • L’operador = significa unificables mentre que == significa idèntics. Semblantment amb \= i \==. • functor(Terme, Nom, Aritat) donat Terme, Nom serà el cap del terme i aritat el nombre d’arguments. • arg(N, Terme, Arg), donat un número N i un terme Terme, Arg en serà l’enèssim argument. • L’operador d’aplanar: terme=.. llista de components • ?- f(a,b) =.. X. X->[f, a, b]

  32. E/S • write(X), es satisfà sempre i escriu el valor del terme X. write(3+4). 3+4 yes • read(X), es satisfà si pot unificar X amb el valor llegit. read(X). 3+4. X = 3+4 yes • nl, és un salt de línia. • Exemple: • repeat. repeat:- repeat. • quadrats:- repeat, llegeix(X), tracta(X),!. • llegeix(X):- repeat, write(‘Numeret’), read(X), number(X), !. • tracta(0):-!. • tracta(X):- R is X*X, writeln([X, ‘^2= ‘, R), fail. • És com un bucle: repeat, cos, condició de sortida, si es satisfà surt, !. • En el manual on-line del SICSTUS hi trobareu la resta d’E/S.

  33. Modificació del Programa (i) • El ProLog permet modificar el programa dinàmicament: afegir o eliminar clàusules dels predicats dinàmics durant “l’execució” del programa: • dynamic( nompredicat / aritat ) defineix el predicat com a dinamic, • assert( ( regla_o_ fet ) ) s’afegeix la regla o el fet al programa, • retract( clausula ) s’elimina del programa la primera instancia que es trobi de clausula, • asserta, assertz, retractall, ...

  34. Modificació del Programa (ii) :-dynamic(p/1). r(X,Y):-asserta(p(X)), q(Y). q(X):-p(X). Es important adonar-se que una vegada s’ha fet l’assert, el programa queda modificat fins que s’acaba.

  35. Constraints (i) • En Prolog, les estructures que es manipulen són termes, i és la nostra interpretació que els dóna semàntica. (aritmètica?) • Els “Constraints” ens permetran manipular certs tipus d’objectes amb la semàntica desitjada com per exemple reals, racionals, booleans, enters...

  36. Constraints (ii) • Uns tipus d’objectes per a manipular amb constraints són els que tenen domini finit: CLPFD. • Un problema de resolució de constraints consisteix en: • donada una serie de variables (de domini finit) amb un conjunt finit de possibles valors (domini), i • donada una serie de relacions (constraints) entre aquestes variables, • trobar els valors possibles (de dins del domini de cada variable) per tal que se satisfacin totes les relacions. • Aplicacions en: Scheduling, planning, packing, timetabling,…

  37. Constraints (iii) • CP = Constraint Programming • Definir unes restriccions sobre les variables del problema a considerar • Trobar assignacions per a les variables que satisfacin totes les restriccions ( ! = unificacio) • Constraint = relació entre variables • Exemple: A+B=C, X>Y, N=llargada(S) … • Propietats: • Expressar informació parcial X>2 • heterogenea N=llargada(S) • no-dirigida X=Y+2: X Y+2  YX-2 • De forma declarativa “ ”

  38. Constraints (iv) • Problema: X::{1,2}, Y::{1,2}, Z::{1,2}X = Y, X  Z, Y > Z • generate & test backtracking

  39. Constraints (v) • Problem:X::{1,2}, Y::{1,2}, Z::{1,2}X = Y, X  Z, Y > Z generate & test - 7 passosbacktracking - 5 passospropagation - 2 passos

  40. Constraints (vi) ?- use_module(library(clpfd)). ? - X in 1..5, Y in 2..8, X+Y#= T. X in 1..5, Y in 2..8, T in 3..13? • El problema te solució, si tots els dominis resultants per a totes les variables tenen algun valor. • Sicstus utilitza tecniques optimitzades per a propagar i resoldre els constraints. • Consulteu el capítol 34 del manual de Sicstus Prolog per una visió detallada dels predicats que es proporcionen.

  41. Constraints (vii) • SEND + MORE = MONEY

  42. Constraints (viii) ?- menulleuger(X,Y,Z). {I>0,J>0,K>0,I+J+K <= 10} primer(X,I), segon(Y,J), postre(Z,K) {X=amanida,I=1,J>0,K>0,1+J+K <= 10} segon(Y,J), postre(Z,K) {X=amanida,Y=dorada,I=1,J=3,K>0,4+K <= 10} postre(Z,K) {X=amanida,Y=dorada,Z=fruita,I=1,J=3,K=3,7<= 10} • A cada pas es controla que el conjunt de constraints sigui satisfactible.

  43. Constraints (ix) • Problemes d’assignació/distribució • Distribució d’estands als areoports • Distribució de grues als ports • Assignació de personal • “torns” als hospitals, … • Tripulacions en avions, … • Horaris a centres educatius • Calendaris esportius • Gestió i configuració de xarxes • Planejar el cablejat per a xarxes • Distribució òptima per a l’enclavament de d’estacions pera xarxes wireless • Biologia molecular • DNA sequencing • Disseny de circuits

  44. Constraints (x) Avantatges: • Declaratiu • Concentrar-se amb descriure la natura del problema a resoldre, no pas indicar com resoldre’l! • Resolució de problemes cooperativa • Entorn idoni per a la integració de diversos algoritmes “special-purpose” • Fonaments matematics sòlids • Èxit comprovat!

  45. Constraints (xi) Inconvenients: • NP-hard problemes & tractabilitat • Comportament impredectible • Estabilitat del model, massa local • Programació ad-hoc (rescheduling) • …

  46. Interfície amb Visual Basic (i) • SICSTUSProlog proporciona una interfície per a carregar i cridar programes prolog desde Visual Basic: • passar una “query” a prolog, • avaluar la “query” en prolog, • obtenir el valor (string o enter) assignat a una variable per l’avaluació de la “query” en prolog • obtenir informació sobre excepcions a la “query”

  47. Interfície amb Visual Basic (ii) • PrologInit( ) carrega i inicialitza l’interfície amb Sicstus per al VB. (1 si ok, -1 altrament) • PrologQueryCutFail(query) troba la primera solució de la query passada com a String, talla i falla. • PrologOpenQuery(query) “obre” la query (String) i ens torna un identificador (enter). • PrologNextSolution(qid) executa la query qid (enter) i torna 1 si ok, 0 si falla i -1 si error. • PrologGetLong(qid,var,valor) posa a valor l’enter que se li ha donat a la variable var (String) durant l’execució de la query qid. (PrologGetString(qid,var,valor) ) • PrologCloseQuery(qid) “tanca” la query qid.

  48. Interfície amb Visual Basic (iii)

  49. Interfície amb Visual Basic (iv) • Consulteu el Capítol 44 del manual, així com els exemples proporcionats en la mateixa instal.lació. • Sobre la correcta utilització de les llibreries per a la interfície, necessiteu que la llibreria de Sicstus i VB (vbsp.dll) estigui al PATH del SO. Vegeu les “Release notes”.

More Related