Programació lòg ica: Sicstus-Prolog

Programació lògica: 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

• 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.

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: Si X és una

dona, i X és progenitor de Y, llavors X é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.

Introducció 3 • 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ó 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 = gemmaY = narcis ? yes

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(X) dona(roser)dona(gemma)

dona(neus)

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

Introducció 7mare(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: { }

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: { }

Introducció 9Si 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 derecular

i trobar

un camícorrecte.

[X->roser]

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).

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).

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).

L’arbre de CercaDonada 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).

? q(X).

? p(X).

? a(X),b(X).

? b(2).

{X/0}

{X/2}

{X/1}

{X/3}

? b(3).

X=1

X=0

X=2

X=2

X=3

La resposta ProLog

| ?- q(X).X = 2 ;X = 2 ;X = 3 ;X = 1 ;X = 0

Aspectes “extra-lògics” 1• L’ordre de 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]).

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!

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.


• 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à.


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).

? q(X).

? p(X).

? a(X),!,b(X).

? !,b(2).

? b(2).

{X/0}

{X/2}

{X/1}

{X/3}

? !,b(3).

? b(3).

X=1

X=0

X=2

X=2

X=3

Amb el tall| ?- q(X).X = 2 ;X = 2 ;X = 0

Sense el tall| ?- q(X).X = 2 ;X = 2 ;X = 3 ;X = 1 ;X = 0


• 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.

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

Aritmètica 1• Per interpretar expressions aritmètiques en

Prolog s’ha de fer servir:

-X is E que 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.

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.

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).

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?

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.

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.

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]

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.

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, ...

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.

?- r(b,X).

X = b

yes

?- r(b,X).

X = b ? ;

X = b

Yes

?- retract(p(X)).

X = b;

X = b

Yes

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...

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,…

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 YX-2– De forma declarativa “ ”

Constraints (iv)

• Problema:X::{1,2}, Y::{1,2}, Z::{1,2} X = Y, X Z, Y > Z

• generate & test backtracking

X Y Z test1 1 1 fail1 1 2 fail1 2 1 fail1 2 2 fail2 1 1 fail2 1 2 fail2 2 1 passed

X Y Z test1 1 1 fail

2 fail2 fail

2 1 fail2 1 passed

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

X Y Z action result1 labelling

{1} {} propagation fail2 labelling

{2} {1} propagation solution

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.

Constraints (vii)• SEND + MORE = MONEY

:- use_module(library(clpfd)).

mm([S,E,N,D,M,O,R,Y], Type):-

domain([S,E,N,D,M,O,R,Y],0,9),

S#>0, M#>0,

alldifferent([S,E,N,D,M,O,R,Y]),

sum([S,E,N,D,M,O,R,Y]),

labelling(Type, [S,E,N,D,M,O,R,Y]).

sum(S,E,N,D,M,O,R,Y):-

1000*S + 100*E + 10*N + D

+ 1000*M + 100*O + 10*R + E

#= 10000*M + 1000*O + 100*N + 10*E + Y.

?- mm([S,E,N,D,M,O,R,Y], []).

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.

:- use_module(library(clpfd)).

menulleuger(P,S,D):- I#>0, J#>0,K#>0,

I+J+K #=< 10,

primer(P,I), segon(S,J), postre(D,K).

primer(amanida,1). primer(esparrecs,2). primer(canalons,4).

segon(dorada,3). segon(paella,5). segon(parrillada,6).

postre(fruita,2). postre(flam,3). postre(pastis,4).

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

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!

Constraints (xi)

Inconvenients:

• NP-hard problemes & tractabilitat

• Comportament impredectible

• Estabilitat del model, massa local• Programació ad-hoc (rescheduling)

• …

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”

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.

Interfície amb Visual Basic (iii)…

Dim qid as Long

Dim resultat as Long

If PrologInit() <> 1 Then Goto Error

If PrologQueryCutFail(“load_files(app(maxim))”) <> 1Then Goto Error

qid=PrologOpenQuery(“maxim([1,2,3],X)”)

If qid = -1 Then Goto Error

If PrologNextSolution(qid) = 1 Then

Call PrologGetLong(qid,”X”,resultat)

End if

Call PrologCloseQuery(qid)

…

Error:

…

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”.

Programació lòg ica: Sicstus-Prolog

Documents

Transcript of Programació lòg ica: Sicstus-Prolog