Your SlideShare is downloading. ×
Programacion logica
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Programacion logica

973
views

Published on


0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
973
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
58
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. PROLOGProgramació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. ListasAquí tenemos una definición recursiva de la estructura de datosLista como la encontramos en prolog:Lista --> [ ]Lista --> [Elemento|Lista]Aquí hay algunos ejemplos de representaciones de listas, elprimero 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. ListasLos predicados en la lista comúnmente se escriben usandomúltiples reglas. Una regla para la lista vacía (caso base) y unasegunda regla para listas no vacías. Por ejemplo, aquí está ladefinición del predicado para la longitud de una lista.% length(List,Number) <- Number is lenght of Listlength([],0).length([H|T],N) :- length(T,M), N is M+1
  • 6. Listaselemento de una lista% member(Element,List) <- Element is an element of the list Listmember(X,[X|List).member(X,[Element|List]) :- member(X,List).
  • 7. ListasPrefijo de una lista% prefix(Prefix,List) <- Prefix is a prefix of list Listprefix([],List).prefix([X|Prefix],[X|List]) :- prefix(Prefix,List).
  • 8. ListasSufijo de una lista% suffix(Suffix,List) <- Suffix is a suffix of list Listsuffix(Suffix,Suffix).prefix(Suffix,[X|List]) :- suffix(Suffix,List).
  • 9. ListasAppend (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. ListasVersió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 SufixListreverse([],RL,RL).reverse([Element|List],RevPrefix,RL) :-reverse(List,[Element|RevPrefix],RL).
  • 12. ListasAquí tenemos algunos ejemplos simples de operaciones comunessobre listas definidas por comparación de patrones. La primerasuma los elementos de una lista y la seguna forma el producto delos 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. ListasLa relación de append es muy flexible. Puede usarse paradeterminar si un objeto es un elemento de una lista, si una lista esprefijo 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 (ono importa) cuyo valor es irrelevante para la definición.
  • 14. ListasLa 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ónLa recursión es el único método iterativo disponible en Prolog. Sinembargo, la recursión de cola puede ser con frecuenciaimplementada como iteración. La siguiente definición de lafunción factorial es una definición iteratica porque es "recursivade cola".Corresponde a una implementación usando un ciclo-while en unlenguaje de programación imperativo.
  • 16. Iteraciónfac(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. Elacumulador se usa para almacenar productos parciales tal y comose haría en un lenguaje procedural.
  • 17. IteraciónPor ejemplo, en Pascal, una función factorial iterativa se podríaescribir 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;
  • 18. IteraciónEn la solución Pascal fac actua como una acumulador paraalmacenar el producto parcial. La solución Prolog también ilustrael hecho de que Prolog permite diferentes relaciones definidasbajo el mismo nombre si el número de argumentos es diferente.En este ejemplo las relaciones son fac/2 y fac/3. Como ejemploadicional del uso de acumuladores aquí tenemos la versióniterativa de la función Fibonacci.
  • 19. Iteraciónffib(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 BacktrackingLos siguientes hecho y regla se pueden usar para generar númerosnaturalesnat(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 naturalessucesivos se imprimen.?- nat(N), write(N), nl, fail.
  • 21. Iteradores, Generadores y BacktrackingEl primer número natural se genera e imprime. Entonces, failforza a que suceda el rastreo de retorno y la segunda regla se usapara generar la sucesión de números naturales. El siguientecódigo genera prefijos sucesivos de una lista infinita empezandocon N.natlist(N,[N]).natlist(N,[N|L]) :- N1 is N+1, natlist(N1,L).
  • 22. Iteradores, Generadores y BacktrackingComo ejemplo final, aquí tenemos un código para la generación deprefijos 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 BacktrackingOcasionalmente el backtracking y las múltiples respuestas sonincómodas. Prolog nos permite usar el símbolo de corte (!) paracontrolar el backtracking. El codigo siguiente define un predicadodonde 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 lasegunda condición.max(A,B,B) :- A < B.max(A,B,A).
  • 24. Iteradores, Generadores y BacktrackingSin embargo, durante el backtracking, respuestas no correctas sepueden sucitar, como a continuación se muestra:?- max(3,4,M).M = 4;M=3
  • 25. Iteradores, Generadores y BacktrackingPara impedir el rastreo de retorno en la segunda regla, el símbolode 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 gotos, en el hecho deque tienden a incrementar la complejidad del código en lugar desimplificarla. En general el uso de cortes debería ser evitado, ysería mejor replantear las condiciones para que no se generenresultados incorrectos.
  • 26. Entrada y SalidaEn archivos:see(File) La entrada actual ahora es File.seeing(File) File se unifica con el nombre del archivo de entradaactualseen Cierra el archivo de entrada actualtell(File) El archivo de salida actual es Filetelling(File) File se unifica con el nombre del archivo de salidaactualtold Cierra el archivo de salida actual
  • 27. Entrada y SalidaTérminos de entrada y salidaread(Term) Lee el término hasta el delimitador punto del flujo deentrada 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 unpredicado portray/1 definido por el usuario para la escritura, o deno existir, usa write.writeq(Term) Escribe un término al flujo de salida actual en una formaestándar de entrada para lectura.
  • 28. Entrada y SalidaCaracter de entrada y salidaget(N) N es el código ASCII del siguiente caracter no nuloimprimible en el flujo de entrada actual. Si es fin de archivo, seretorna un -1put(N) Pone el caracter correspondiente al código ASCII de N en elflujo de salida actual.nl Escribe una nueva líneatab(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. AplicacionesLos no terminales se expresan como átomos Prolog, los elementosen el cuerpo se separan con comas y secuencias de símbolosterminales se escriben como listas de átomos. Para cada noterminal, S, una gramática define un lenguaje que se obtiene por laaplicación no determinista de reglas gramaticales iniciando en S.s --> [a],[b].s --> [a],s,[b].
  • 32. AplicacionesUna 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],[]). yesVea los ejemplos anexos para la formación de oraciones, sin y concontrol de número.
  • 33. AplicacionesEstructuras de Datos incompletas.Una estructura de datos incompleta es una estructura de datosque contiene una variable. Tal estructura se dice estarparcialmente instanciada o incompleta. Aquí ilustramos laprogramación con estructuras de datos incompletas modificandoel código para un árbol de búsqueda binaria. El código resultantepermite la relación inserted_in_is para definir tanto la relación deinserción como la de membresía.
  • 34. AplicacionesProgramación de Meta NivelLos meta programas tratan otros programas como datos. Analizan,transforman y simulan otros programas. Las cláusulas Prologpueden pasarse como argumentos, ser agregadas y eliminadas dela base de datos, y ser construidas y ejecutadas por un programaprolog. Las implementaciones pueden requerir que el functor yaridad de la cláusula esté previamente declarado como tipodiná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 Prologsx(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
  • 37. AplicacionesSistemas expertosLos sistemas expertos se pueden programar en uno de dos modosen Prolog. Uno es construir una base de conocimiento usandohechos y reglas Prolog y usar la máquina de inferencia empotradapara responder consultas.La otra es construir una máquina de inferencia más poderosa enprolog y usarla para implementar un sistema experto.
  • 38. AplicacionesComparación de patrones: Diferenciación simbólicad(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. AplicacionesProgramación Orientada a Objetos.Otra de las aplicaciones de prolog es la evaluación de estructurasde datos de tipo objeto. Como sabemos un tipo objeto tieneinherentes métodos y datos que se instancían en el momento desu declaración.En el ejemplo de prolog podemos ver una propuesta de ladefinición de estas relaciones.
  • 40. Gracias...