Este documento describe el uso de listas en programación lógica. Las listas son una estructura de datos recursiva fundamental en Prolog. El documento explica cómo las operaciones sobre listas se definen de forma recursiva siguiendo la definición recursiva de la estructura de lista. Se proporcionan ejemplos de definiciones de predicados comunes sobre listas como longitud, miembro, prefijo y sufijo.

1. PROLOG
Programación Lógica

2. Listas
Usos
•Listas
•Composición de Programas Recursivos
•Iteración
Las listas son la estructura básica usada en la programación
lógica. Son una estructura de datos recursivas, de modo que la
recursión ocurre de manera natural en la definición de
operaciones de varias listas.

3. Listas
Cuando definimos operaciones en estructuras de datos recursivas,
la definición con mucha frecuencia sigue de manera natural la
definición recursiva de la estructura de datos.
En el caso de las listas, la lista vacía es el caso base. Así que las
operaciones sobre listas deben considerar el caso de la lista vacía.
Los otros casos implican una lista que se compone de un elemento
y una lista.

4. Listas
Aquí tenemos una definición 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 vacía:
Pair Syntax Element Syntax
[] []
[a|[ ]] [a]
[a|b|[ ]] [a,b]
[a|X] [a|X]
[a|b|X] [a,b|X]

5. Listas
Los predicados en la lista comúnmente se escriben usando
múltiples reglas. Una regla para la lista vacía (caso base) y una
segunda regla para listas no vacías. Por ejemplo, aquí está la
definición del predicado para la longitud de una lista.
% length(List,Number) <- Number is lenght of List
length([],0).
length([H|T],N) :- length(T,M), N is M+1

6. Listas
elemento de una lista
% member(Element,List) <- Element is an element of the list List
member(X,[X|List).
member(X,[Element|List]) :- member(X,List).

7. Listas
Prefijo de una lista
% prefix(Prefix,List) <- Prefix is a prefix of list List
prefix([],List).
prefix([X|Prefix],[X|List]) :- prefix(Prefix,List).

8. Listas
Sufijo de una lista
% suffix(Suffix,List) <- Suffix is a suffix of list List
suffix(Suffix,Suffix).
prefix(Suffix,[X|List]) :- suffix(Suffix,List).

9. Listas
Append (concatenar) dos listas.
% append(List1,List2,List1List2) <-
% List1List2 is the result of concatenating List1 and List2.
append([],List,List).
append([Element|List1],List2,[Element|List1List2]) :-
append(List1,List2,List1List2).

10. Listas
Iteración en listas
Versión Iterativa de my_length
% my_length(List,Number) <- Number is lenght of List
% Iterative version.
my_length(List,LenghtofList) :- my_length(List,0,LengthofList).
% my_length(SufixList,LengthofPrefix,LengthofList) <-
% LengthofList is LengthofPrefix + length of SufixList
my_length([],LenghtofPrefix,LengthofPrefix).
my_length([Element|List],LengthofPrefix,LengthofList) :-
PrefixPlus1 is LengthofPrefix + 1,
my_length(List,PrefixPlus1,LengthofList).

11. Listas
Versión iterativa de Reversa
% reverse(List,ReversedList) <- ReversedList is List reversed.
% Iterative version.
reverse(List,RList) :- reverse(List,[],RList).
% length(SufixList,LengthofPrefix,LengthofList) <-
% LengthofList is LengthofPrefix + length of SufixList
reverse([],RL,RL).
reverse([Element|List],RevPrefix,RL) :-
reverse(List,[Element|RevPrefix],RL).

12. Listas
Aquí tenemos algunos ejemplos simples de operaciones comunes
sobre listas definidas por comparación 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.

13. Listas
La relación 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 subguión '_' en las definiciones denota una variable anónima (o
'no importa') cuyo valor es irrelevante para la definición.

14. Listas
La relación 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']).

15. Iteración
La recursión es el único método iterativo disponible en Prolog. Sin
embargo, la recursión de cola puede ser con frecuencia
implementada como iteración. La siguiente definición de la
función factorial es una definición iteratica porque es "recursiva
de cola".
Corresponde a una implementación usando un ciclo-while en un
lenguaje de programación imperativo.

16. Iteración
fac(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 haría en un lenguaje procedural.

17. Iteración
Por ejemplo, en Pascal, una función factorial iterativa se podría
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
end
end;

18. Iteración
En la solución Pascal 'fac' actua como una acumulador para
almacenar el producto parcial. La solución Prolog también ilustra
el hecho de que Prolog permite diferentes relaciones definidas
bajo el mismo nombre si el número 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 versión
iterativa de la función Fibonacci.

19. Iteración
ffib(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).

20. Iteradores, Generadores y Backtracking
Los siguientes hecho y regla se pueden usar para generar números
naturales
nat(0).
nat(N) :- nat(M), N is M + 1.
La sucesión de números se genera por 'backtracking'. Por ejemplo,
cuando la siguiente consulta se ejecuta, los números naturales
sucesivos se imprimen.
?- nat(N), write(N), nl, fail.

21. Iteradores, Generadores y Backtracking
El primer número natural se genera e imprime. Entonces, 'fail'
forza a que suceda el rastreo de retorno y la segunda regla se usa
para generar la sucesión de números naturales. El siguiente
código genera prefijos sucesivos de una lista infinita empezando
con N.
natlist(N,[N]).
natlist(N,[N|L]) :- N1 is N+1, natlist(N1,L).

22. Iteradores, Generadores y Backtracking
Como ejemplo final, aquí tenemos un código para la generación de
prefijos sucesivos de la lista de números 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).

23. Iteradores, Generadores y Backtracking
Ocasionalmente el backtracking y las múltiples respuestas son
incómodas. Prolog nos permite usar el símbolo de corte (!) para
controlar el backtracking. El codigo siguiente define un predicado
donde el tercer argumento es el máximo de los primeros dos.
max(A,B,M) :- A < B, M = B.
max(A,B,M) :- A >= B, M = A.
El código se puede simplificar quitando las condiciones de la
segunda condición.
max(A,B,B) :- A < B.
max(A,B,A).

24. Iteradores, Generadores y Backtracking
Sin embargo, durante el backtracking, respuestas no correctas se
pueden sucitar, como a continuación se muestra:
?- max(3,4,M).
M = 4;
M=3

25. Iteradores, Generadores y Backtracking
Para impedir el rastreo de retorno en la segunda regla, el símbolo
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 código en lugar de
simplificarla. En general el uso de cortes debería ser evitado, y
sería mejor replantear las condiciones para que no se generen
resultados incorrectos.

26. Entrada y Salida
En archivos:
see(File) La entrada actual ahora es File.
seeing(File) File se unifica con el nombre del archivo de entrada
actual
seen Cierra el archivo de entrada actual
tell(File) El archivo de salida actual es File
telling(File) File se unifica con el nombre del archivo de salida
actual
told Cierra el archivo de salida actual

27. Entrada y Salida
Términos de entrada y salida
read(Term)
Lee el término hasta el delimitador punto del flujo de
entrada actual, si encuentra eof regresa el átomo eof.
write(Term)
Escribe un término al fluje de salida actual.
print(Term)
Escribe un término 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 término al flujo de salida actual en una forma
estándar de entrada para lectura.

28. Entrada y Salida
Caracter de entrada y salida
get(N)
N es el código ASCII del siguiente caracter no nulo
imprimible en el flujo de entrada actual. Si es fin de archivo, se
retorna un -1
put(N)
Pone el caracter correspondiente al código ASCII de N en el
flujo de salida actual.
nl
Escribe una nueva línea
tab(N)
N espacios se ponen en el flujo de salida

29. Acceso y manipulación de programas y sistema
clause(Head,Body)
assert(Clause)
agrega la cláusula al final de la base de datos
asserta(Clause)
retract(Clause_Head)
consult(File_Name)
system(Command)
Ejecuta Command en el sistema operativo

30. Aplicaciones
Gramáticas Independientes de Contexto y Gramáticas de
Cláusulas Definidas
Prolog se originó de intentos de usar la lógica para expresar
reglas gramaticales y formalizar los procesos de parseo. Prolog
tiene reglas de sintáxis especiales llamadas Gramática de
Cláusulas Definidas, que son una generalización de las gramáticas
libres de contexto.

31. Aplicaciones
Los no terminales se expresan como átomos Prolog, los elementos
en el cuerpo se separan con comas y secuencias de símbolos
terminales se escriben como listas de átomos. Para cada no
terminal, S, una gramática define un lenguaje que se obtiene por la
aplicación no determinista de reglas gramaticales iniciando en S.
s --> [a],[b].
s --> [a],s,[b].

32. Aplicaciones
Una ilustración de como se usan estas DCGs, la cadena [a,a,b,b]
se le proporciona a la gramática para su parsing.
?- s([a,a,b,b],[]).
yes
Vea los ejemplos anexos para la formación de oraciones, sin y con
control de número.

33. Aplicaciones
Estructuras 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
programación con estructuras de datos incompletas modificando
el código para un árbol de búsqueda binaria. El código resultante
permite la relación inserted_in_is para definir tanto la relación de
inserción como la de membresía.

34. Aplicaciones
Programación de Meta Nivel
Los meta programas tratan otros programas como datos. Analizan,
transforman y simulan otros programas. Las cláusulas 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 cláusula esté previamente declarado como tipo
dinámico

35. Aplicaciones
Assert/Retract
El siguiente ejemplo muestra como las cláusulas pueden ser
agregadas y removidas de la base de datos Prolog. Muestra como
simular una sentencia de asignación usando assert y retract para
modificar la asociación entre una variable y un valor.

36. Aplicaciones
:- dynamic x/1 .% this may be required in some Prologs
x(0). % An initial value is required in this example
assign(X,V) :- Old =..[X,_], retract(Old), New =..[X,V], assert(New).
Aquí hay un ejemplo del uso del predicado assign
?- x(N).
N=0
yes
?- assign(x,5).
yes
?- x(N).
N=5

37. Aplicaciones
Sistemas 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 máquina de inferencia empotrada
para responder consultas.
La otra es construir una máquina de inferencia más poderosa en
prolog y usarla para implementar un sistema experto.

38. Aplicaciones
Comparación de patrones: Diferenciación simbólica
d(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).

39. Aplicaciones
Programación Orientada a Objetos.
Otra de las aplicaciones de prolog es la evaluación de estructuras
de datos de tipo objeto. Como sabemos un tipo objeto tiene
inherentes métodos y datos que se instancían en el momento de
su declaración.
En el ejemplo de prolog podemos ver una propuesta de la
definición de estas relaciones.

40. Gracias...