PROLOGProgramacin Lgica

ListasUsosListasComposicin de Programas RecursivosIteracin

Las listas son la estructura bsica usada en la programacin lgica. Son una estructura de datos recursivas, de modo que la recursin ocurre de manera natural en la definicin de operaciones de varias listas.

ListasCuando definimos operaciones en estructuras de datos recursivas, la definicin con mucha frecuencia sigue de manera natural la definicin recursiva de la estructura de datos.

En el caso de las listas, la lista vaca es el caso base. As que las operaciones sobre listas deben considerar el caso de la lista vaca.

Los otros casos implican una lista que se compone de un elemento y una lista.

ListasAqu tenemos una definicin recursiva de la estructura de datos 'Lista' como la encontramos en prolog:Lista --> [ ]Lista --> [Elemento|Lista]

Aqu hay algunos ejemplos de representaciones de listas, el primero es la lista vaca:Pair SyntaxElement Syntax[ ][ ] [a|[ ]][a] [a|b|[ ]][a,b] [a|X][a|X] [a|b|X][a,b|X]

ListasLos predicados en la lista comnmente se escriben usando mltiples reglas. Una regla para la lista vaca (caso base) y una segunda regla para listas no vacas. Por ejemplo, aqu est la definicin del predicado para la longitud de una lista.

% length(List,Number)

Listaselemento de una lista

% member(Element,List)

ListasPrefijo de una lista

% prefix(Prefix,List)

ListasSufijo de una lista

% suffix(Suffix,List)

ListasAppend (concatenar) dos listas.

% append(List1,List2,List1List2)

ListasIteracin en listasVersin Iterativa de my_length% my_length(List,Number)

ListasVersin iterativa de Reversa

% reverse(List,ReversedList)

ListasAqu tenemos algunos ejemplos simples de operaciones comunes sobre listas definidas por comparacin de patrones. La primera suma los elementos de una lista y la seguna forma el producto de los elementos de una lista.

sum([ ],0).sum([X|L],Sum) :- sum(L,SL), Sum is X + SL.

product([ ],1).product([X|L],Prod) :- product(L,PL), Prod is X * PL.

ListasLa relacin de append es muy flexible. Puede usarse para determinar si un objeto es un elemento de una lista, si una lista es prefijo de una lista y si una lista es sufijo de una lista.

member(X,L) :- append(_,[X|_],L).prefix(Pre,L) :- append(Prefix,_,L).suffix(L,Suf) :- append(_,Suf,L).

El subguin '_' en las definiciones denota una variable annima (o 'no importa') cuyo valor es irrelevante para la definicin.

ListasLa relacin member puede ser usado para derivar otras relaciones tiles.

vowel(X) :- member(X,[a,e,i,o,u]).digit(D) :- member(D,['0','1','2','3','4','5','6','7','8','9']).

IteracinLa recursin es el nico mtodo iterativo disponible en Prolog. Sin embargo, la recursin de cola puede ser con frecuencia implementada como iteracin. La siguiente definicin de la funcin factorial es una definicin iteratica porque es "recursiva de cola".

Corresponde a una implementacin usando un ciclo-while en un lenguaje de programacin imperativo.

Iteracinfac(0,1).fac(N,F) :- N > 0, fac(N,1,F).

fac(1,F,F).fac(N,PP,F) :- N > 1, NPp is N*PP, M is N-1, fac(M,NPp,F).

Note que el segundo argumento funciona como acumulador. El acumulador se usa para almacenar productos parciales tal y como se hara en un lenguaje procedural.

IteracinPor ejemplo, en Pascal, una funcin factorial iterativa se podra escribir asi:function fac(N:integer) : integer;var i : integer;begin if N >= 0 then begin fac := 1 for I := 1 to N do fac := fac * I endend;

IteracinEn la solucin Pascal 'fac' actua como una acumulador para almacenar el producto parcial. La solucin Prolog tambin ilustra el hecho de que Prolog permite diferentes relaciones definidas bajo el mismo nombre si el nmero de argumentos es diferente.

En este ejemplo las relaciones son fac/2 y fac/3. Como ejemplo adicional del uso de acumuladores aqu tenemos la versin iterativa de la funcin Fibonacci.

Iteracinffib(0,1).fib(1,1).fib(N,F) :- N > 1, fib(N,1,1,F)

fib(2,F1,F2,F) :- F is F1 + F2.fib(N,F1,F2,F) :- N > 2, N1 is N - 1, NF1 is F1 + F2, fib(N1,NF1,F1,F).

Iteradores, Generadores y BacktrackingLos siguientes hecho y regla se pueden usar para generar nmeros naturales

nat(0).nat(N) :- nat(M), N is M + 1.

La sucesin de nmeros se genera por 'backtracking'. Por ejemplo, cuando la siguiente consulta se ejecuta, los nmeros naturales sucesivos se imprimen.

?- nat(N), write(N), nl, fail.

Iteradores, Generadores y BacktrackingEl primer nmero natural se genera e imprime. Entonces, 'fail' forza a que suceda el rastreo de retorno y la segunda regla se usa para generar la sucesin de nmeros naturales. El siguiente cdigo genera prefijos sucesivos de una lista infinita empezando con N.

natlist(N,[N]).natlist(N,[N|L]) :- N1 is N+1, natlist(N1,L).

Iteradores, Generadores y BacktrackingComo ejemplo final, aqu tenemos un cdigo para la generacin de prefijos sucesivos de la lista de nmeros primos.

primes(PL) :- natlist(2,L2), sieve(L2,PL).

sieve([ ],[ ]).sieve([P|L],[P|IDL]) :- sieveP(P,L,PL), sieve(PL,IDL).

sieveP(P,[ ],[ ]). sieveP(P,[N|L],[N|IDL]) :- N mod P > 0, sieveP(P,L,IDL).sieveP(P,[N|L], IDL) :- N mod P =:= 0, sieveP(P,L,IDL).

Iteradores, Generadores y BacktrackingOcasionalmente el backtracking y las mltiples respuestas son incmodas. Prolog nos permite usar el smbolo de corte (!) para controlar el backtracking. El codigo siguiente define un predicado donde el tercer argumento es el mximo de los primeros dos.max(A,B,M) :- A < B, M = B.max(A,B,M) :- A >= B, M = A.

El cdigo se puede simplificar quitando las condiciones de la segunda condicin.max(A,B,B) :- A < B.max(A,B,A).

Iteradores, Generadores y BacktrackingSin embargo, durante el backtracking, respuestas no correctas se pueden sucitar, como a continuacin se muestra:

?- max(3,4,M).

M = 4;

M = 3

Iteradores, Generadores y BacktrackingPara impedir el rastreo de retorno en la segunda regla, el smbolo de corte se pone en la primera regla.max(A,B,B) :- A < B.!.max(A,B,A).

Ahora la respuesta incorrecta no se va a generar.

Un consejo: Los cortes son similares a los 'goto's, en el hecho de que tienden a incrementar la complejidad del cdigo en lugar de simplificarla. En general el uso de cortes debera ser evitado, y sera mejor replantear las condiciones para que no se generen resultados incorrectos.

Entrada y SalidaEn archivos:

see(File)La entrada actual ahora es File.seeing(File)File se unifica con el nombre del archivo de entrada actualseenCierra el archivo de entrada actualtell(File)El archivo de salida actual es Filetelling(File)File se unifica con el nombre del archivo de salida actualtoldCierra el archivo de salida actual

Entrada y SalidaTrminos de entrada y salidaread(Term)Lee el trmino hasta el delimitador punto del flujo de entrada actual, si encuentra eof regresa el tomo eof.write(Term)Escribe un trmino al fluje de salida actual.print(Term)Escribe un trmino al flujo de salida actual. Usa un predicado portray/1 definido por el usuario para la escritura, o de no existir, usa write.writeq(Term)Escribe un trmino al flujo de salida actual en una forma estndar de entrada para lectura.

Entrada y SalidaCaracter de entrada y salidaget(N)N es el cdigo ASCII del siguiente caracter no nulo imprimible en el flujo de entrada actual. Si es fin de archivo, se retorna un -1put(N)Pone el caracter correspondiente al cdigo ASCII de N en el flujo de salida actual.nlEscribe una nueva lneatab(N)N espacios se ponen en el flujo de salida

Acceso y manipulacin de programas y sistemaclause(Head,Body) assert(Clause) agrega la clusula al final de la base de datosasserta(Clause) retract(Clause_Head) consult(File_Name)

system(Command) Ejecuta Command en el sistema operativo

AplicacionesGramticas Independientes de Contexto y Gramticas de Clusulas Definidas

Prolog se origin de intentos de usar la lgica para expresar reglas gramaticales y formalizar los procesos de parseo. Prolog tiene reglas de sintxis especiales llamadas Gramtica de Clusulas Definidas, que son una generalizacin de las gramticas libres de contexto.

AplicacionesLos no terminales se expresan como tomos Prolog, los elementos en el cuerpo se separan con comas y secuencias de smbolos terminales se escriben como listas de tomos. Para cada no terminal, S, una gramtica define un lenguaje que se obtiene por la aplicacin no determinista de reglas gramaticales iniciando en S.

s --> [a],[b].s --> [a],s,[b].

AplicacionesUna ilustracin de como se usan estas DCGs, la cadena [a,a,b,b] se le proporciona a la gramtica para su parsing.

?- s([a,a,b,b],[]). yes

Vea los ejemplos anexos para la formacin de oraciones, sin y con control de nmero.

AplicacionesEstructuras de Datos incompletas.

Una estructura de datos incompleta es una estructura de datos que contiene una variable. Tal estructura se dice estar 'parcialmente instanciada' o 'incompleta'. Aqu ilustramos la programacin con estructuras de datos incompletas modificando el cdigo para un rbol de bsqueda binaria. El cdigo resultante permite la relacin inserted_in_is para definir tanto la relacin de insercin como la de membresa.

AplicacionesProgramacin de Meta Nivel

Los meta programas tratan otros programas como datos. Analizan, transforman y simulan otros programas. Las clusulas Prolog pueden pasarse como argumentos, ser agregadas y eliminadas de la base de datos, y ser construidas y ejecutadas por un programa prolog. Las implementaciones pueden requerir que el functor y aridad de la clusula est previamente declarado como tipo dinmico

AplicacionesAssert/Retract

El siguiente ejemplo muestra como las clusulas pueden ser agregadas y removidas de la base de datos Prolog. Muestra como simular una sentencia de asignacin usando assert y retract para modificar la asociacin entre una variable y un valor.

Aplicaciones:- dynamic x/1 .% this may be required in some Prologs x(0). % An initial value is required in this exampleassign(X,V) :- Old =..[X,_], retract(Old), New =..[X,V], assert(New).

Aqu hay un ejemplo del uso del predicado assign?- x(N).N = 0yes?- assign(x,5).yes?- x(N).N = 5

AplicacionesSistemas expertos

Los sistemas expertos se pueden programar en uno de dos modos en Prolog. Uno es construir una base de conocimiento usando hechos y reglas Prolog y usar la mquina de inferencia empotrada para responder consultas.

La otra es construir una mquina de inferencia ms poderosa en prolog y usarla para implementar un sistema experto.

AplicacionesComparacin de patrones: Diferenciacin simblicad(X,X,1) :- !. d(C,X,0) :- atomic(C). d(-U,X,-A) :- d(U,X,A). d(U+V,X,A+B) :- d(U,X,A), d(V,X,B). d(U-V,X,A-B) :- d(U,X,A), d(V,X,B). d(C*U,X,C*A) :- atomic(C), CX, d(U,X,A),!. d(U*V,X,B*U+A*V) :- d(U,X,A), D(V,X,B). d(U/V,X,A) :- d(U*V^-1,X,A) d(U^C,X,C*U^(C-1)*W) :- atomic(C), CX, d(U,X,W). d(log(U),X,A*U^(-1)) :- d(U,X,A).

AplicacionesProgramacin Orientada a Objetos.

Otra de las aplicaciones de prolog es la evaluacin de estructuras de datos de tipo objeto. Como sabemos un tipo objeto tiene inherentes mtodos y datos que se instancan en el momento de su declaracin.

En el ejemplo de prolog podemos ver una propuesta de la definicin de estas relaciones.

Gracias...