INTRODUCCIÓN A PROLOG

INTRODUCCIÓN La Programación Lógica es un paradigma de computación que consiste de un enfoque declarativo para escribir programas para el computador. PROLOG es un lenguaje de computación basada en ese paradigma. Los programas lógicos pueden ser entendidos y estudiados a partir de dos conceptos: verdad y deducción lógica. En programación lógica, uno puede preguntarse si un axioma de un programa es verdad bajo alguna interpretación de los símbolos del programa y si ciertas declaraciones lógicas son consecuencia del programa. Esas preguntas pueden ser respondidas independientemente de cualquier mecanismo de ejecución concreto. Por otro lado, PROLOG es un lenguaje de programación con un significado operacional preciso que toma prestado sus conceptos básicos de la programación lógica. Los programas PROLOG son instrucciones para ejecutar sobre el computador. Esas instrucciones casi siempre son leídas como instrucciones lógicas y, lo más importante, el resultado de una computación de un programa PROLOG es una consecuencia lógica de los axiomas en éste. Es ampliamente aceptado que una programación efectiva en PROLOG requiere de una comprensión de la teoría de programación lógica, por lo menos en sus aspectos fundamentales, pero también que esto redunda en un mayor dominio dominio del procesamiento de la información información usando el conmputador.

UN POCO DE HISTORIA El comienzo de la programación lógica puede ser atribuido a los profesores Kowalski y Colmerauer. R. A. Kowalski. trabajando en la Universidad de Edinburgo, formuló la interpretación procedimental de la lógica de cláusulas de Horn y mostró que el axioma A si B puede ser leído como un procedimiento de un lenguaje de programación recursivo, donde A es la cabeza del procedimiento y B su cuerpo. Al mismo tiempo, a principios de 1970, Colmerauer y su grupo en la Universidad De Marseille-Aix desarrolló un probador de teorema especializado, el cual ellos usaron para implementar sistemas de procesamiento natural. El probador de teorema, lo llamaron PROLOG (for Programation et Logique or Programming in Logic), basado en la interpretación procedimental de Kowalski. Kowa lski. El primer interpretador de PROLOG no fue tan rápido como los sistemas LISP, el lenguaje pionero propuesto por el prof. McCarthy y muy popular en los Estados Unidos. Pero esto cambió a mediados de 1970 cuando David H.D. Warren y sus colegas desarrollaron una implementación eficiente de PROLOG. El compilador, el cual fue casi completamente escrito en PROLOG, tradujo cláusulas de PROLOG hacia instrucciones de una máquina abstracta que es ahora conocida como Warren Abstract Machine (WAM). Sin embargo, la comunidad de la Inteligencia Artificial y de la computación de occidente se mantuvo aún ignorante e indiferente a la programación lógica. Esto cambió un poco con el anuncio del Proyecto de Quinta Generación Japonesa el cual claramente afirmó el rol importante de la programación lógica en la próxima generación de sistemas computarizados. No sólo los investigadores sino también el público en general comenzaron a deletrear la palabra PROLOG. Desde entonces, PROLOG está alcanzando nuevas alturas. Actualmente, una de las extensiones más prominentes es la programación lógica con restricciones (Contraint Logic Programming-CLP), con una cantidad de nuevos recursos para Ingeniería Lógica. Otras areas con desarrollos importantes son: la Programación Lógica Inductiva (ILP) y los Agentes en Programación Lógica.

PRIMEROS PASOS EN PROLOG

Trusted by over 1 million members

Try Scribd FREE for 30 days to access over 125 million titles without ads or interruptions! Start Free Trial Cancel Anytime.













En este capítulo revisaremos unos pocos ejemplos para ilustrar las ideas básicas detrás de la programación en PROLOG. Pero primero, unas notas acerca de como usar Sistemas PROLOG. Un programa PROLOG es un conjunto de procedimientos (el orden es indiferente). Cada procedimiento consiste de una o más cláusulas (ahora, el orden de las cláusulas si es importante). Hay dos tipos de cláusulas: hechos y reglas. El programa es almacenado en una base de conocimiento PROLOG. Usualmente cargas un programa dentro de la base de datos usando el comando consult , en la concha PROLOG, en la siguiente forma:

? consult(‘Nombre_Del_archivo_Con_El_Programa’).

El comando consult agrega las cláusulas y hechos desde el archivo texto especificado a las cláusulas y hechos ya almacenados en la base de datos. Así puedes cargar más programas dentro de la base de datos a la vez, pero debes ser cuidadoso si los programas no usan los procedimientos con el mismo nombre. De otra manera, debido a la acumulación de cláusulas, esos procedimientos podrían comportarse incorrectamente. Otra forma de invocar este mismo comando es con la notacion de listas: ? [‘Nombre_Del_archivo_Con_El_Programa’].

Puedes también usar el comando reconsult para recargar un programa. ?

reconsult('Nombre_Del_Archivo_Con_El_Programa').

Este comando se comporta igual al comando consult (agrega procedimientos dentro de la base de datos) pero si hay un procedimiento en la base de datos con el mismo nombre de algún procedimiento en el archivo reconsultado, entonces el primer procedimiento es reemplazado por la nueva definición. Puedes usar el comando reconsult para cambiar un programa en la base de datos durante la depuración. El programa PROLOG es ejecutado invocando algún procedimiento del programa de la siguiente forma : ?

nombre_Del_Procedimiento(parámetros).

Nota que tu ya has llamado un procedimiento cuando tu consultastes o reconsultastes el archivo. "Llamar un procedimiento" es equivalente a "preguntando una pregunta" en PROLOG.

BASE DE DATOS GENEALÓGICA Una base de datos genealógica puede ser una buena introducción a PROLOG , pués no es exactamente un conjunto de procedimientos y tiene más elementos que una base de datos común. En ésta lección lección , presentamos un programa de PROLOG simple que captura relaciones de familia básicas. El programa demuestra algunas de las características de PROLOG como el usar hechos , reglas , variables y la recursión. Primero, expresamos la propiedad de ser un hombre o mujer usando hechos de PROLOG :















mujer(eva).

Ahora podemos agregar la relación "pariente" el cual asocia pariente y niño: pariente(adan,pedro). % Significa adan es pariente de pedro. pariente(eva,pedro). pariente(adan,paul). pariente(marry,paul).

Hasta ahora, hemos agregado sólo hechos a nuestro programa. Pero el poder real de PROLOG está en las reglas. Mientras que los hechos afirman la relación explícitamente, las reglas definen la relación en una forma más general. Cada regla tiene su cabeza (nombre de la relación definida), y su cuerpo (las condiciones de definición de la relación). Las siguientes reglas definen las relaciones de ser un padre y ser una madre usando las relaciones definidas previamente de ser un hombre o mujer y ser un pariente. padre(F,C) :-hombre(F), pariente(F,C).

madre(M,C) :- mujer(M), pariente(M,C).

Notar que usamos variables (comienzan con mayúscula) para expresar la característica que cada hombre el cual es un pariente de cualquier niño es también su padre. Si algún parámetro de la relación no es importante podemos usar variables anónimas (denotadas _) como en esas definiciones: es_padre(F) :- padre(F,_). es_madre(M) :- madre(M,_).

Antes de avanzar más, uno debería saber como ejecutar los programas PROLOG. Tu ejecutas el programa haciendo preguntas como ésta: ?-padre(X,paul) .

La cual expresa: ¿Quién es padre de Paul? (Estrictamente hablando la frase pregunta si existe "algo" que sea el padre de Paul). Paul). La respuesta es X=adan, según nuestro nuestro programa anterior. Ahora extenderemos la base de datos de hechos y trataremos de definir otras relaciones de familia como ser un hijo, tío o abuelo. También, trataremos de preguntar al sistema PROLOG diversas preguntas para ver que sucede. Tu puedes comparar tu propio programa con las siguientes reglas: hijo(S,P):-hombre(S),pariente(P,S). hija(D,P):-mujer(D),pariente(P,D).















pariente(A,F),pariente(B,F), pariente(A,M),pariente(B,M), A\=B, F\=M. % hermanos completos tienen parientes comunes (ambos) % la prueba F\=M preserva que hermanos completos tienen dos diferentes parientes(padre y madre,naturalmente) hermanos2_completos(A,B):padre(A,F),padre(B,F), madre(A,M),madre(B,M), A\=B. % otra solución para "el problema hermanos completos" madre

que usa las relaciones padre y

tio(U,N):-hombre(U),hermanos(U,P),pariente(P,N). tia(A,N):-mujer(A),hermanos(A,P),pariente(P,N). abuelo(G,N):-pariente(G,X),pariente(X,N).

Ahora, usamos sólo una regla para expresar la relación definida nuevamente pero podemos también definir la relación usando dos o más reglas. Si queremos expresar que ser un humano significa ser un hombre o ser una mujer, podemos hacerlo por esas dos reglas: humano(H):-hombre(H). humano(H):-mujer(H).

El cuerpo de la regla puede también usar la relación que está siendo definida. Esta característica es llamada recursión y las siguientes reglas muestran su uso típico. descendiente(D,A) :-pariente(A,D). descendiente(D,A) :-pariente(P,D),descendiente(P,A).

Uno puede usar la característica de PROLOG de variables de entrada y salida no determinadas (algunas veces llamada modo modo variable o multimodalidad) multimodalidad) para definir la la relación ancestro. ancestro(A,D) :- descendiente(D,A) .

PRIMERAS ESTRUCTURAS DE DATOS EN PROLOG















En esta sección, introducimos una estructura de datos fecha(Dia,Mes,Año) que representa la fecha. Primero necesitamos un constructor de la estructura de datos fecha que hace la estructura de datos de día, mes y año: hacer_fecha(D,M,A,fecha(D,M,A)) .

Segundo, definimos las funciones para accesar los componentes de la estructura de datos de la siguiente forma: obtener_año(fecha(_,_,A),A). obtener_mes(fecha(_,M,_),M). obtener_dia(fecha(D,_,_),D).

obtener_xxx puede ser usado para probar o generar el componente correspondiente de la estructura de datos, pero no puede ser usado para colocar el valor de la componente. Así, tenemos que definir colocar_xxx para colocar valores a los componentes de la estructura de datos fecha. colocar_año(A,fecha(D,M,_),fecha(D,M,A)). colocar_mes(M,fecha(D,_,A),fecha(D,M,A)). colocar_dia(D,fecha(_,M,A),fecha(D,M,A)).

Ahora, es fácil encontrar el "mismo" día en año próximo o anterior respectivamente usando las funciones obtener y colocar. año_proximo(Hoy,ProximoAño):- obtener_año(Hoy,A), NA is A+1, colocar_año(NA,Hoy,ProximoAño). año_anterior(Hoy,AnteriorAño):-obtener_año(Hoy,A), PA is A-1, colocar_año(PA,Hoy,AnteriorAño).

Notar, que la definición siguiente de año_anterior usando año_proximo no es correcta. ¿Tú sabes Por Qué? año_anterior(Hoy,AnteriorAño):- año_proximo(AnteriorAño,Hoy )).

% incorrrecto

Encontrar el año próximo es relativamente fácil pero ¿Qué sucede al encontrar día próximo, es decir, mañana?. Estudiar el siguiente programa para encontrar donde los problemas posibles están ocultos. La definición de probar dia_correcto sigue en la próxima sección que cubre el trabajo con listas. mañana(Hoy,Tomorrow) :- obtener_day(Hoy,D), ND is +1,colocar_day(Hoy,ND,Tomorrow),fecha_correcta(Mañana). %el día dentro del mes,es decir,no el último día del mes















% Último día del año

Notar que también es posible y quizás más razonable encapsular la prueba fecha_correcta en las definiciones de hacer_fecha y colocar_xxx.

LISTAS Una lista es estructura de datos ampliamente usada y construida en PROLOG. Es todavía un término, ejemplo, [1,2,3] es equivalente a '.'(1,'.'(2,'.'(3,nulo))). Las siguientes funciones permiten accesar los elementos de la lista. cabeza(C,[C|_]). cola(L,[_|L]). % L es una lista

Es fácil accesar el primer elemento de la lista, es decir, la cabeza. Sin embargo, encontrar el último elemento es un proceso que consume tiempo ya que uno tiene que recorrer la lista completa para encontrarlo. Notar que los siguientes "procedimientos" pueden ser usados para encontrar el primero/último elemento de la lista. Podría aún ser usado para generar una lista con el primero/último elemento dado. primero(P,[P|_]). % El mismo como cabeza ultimo(U,[U]). ultimo(U,[C|L]):- ultimo(U,L).

La misma conclusión se mantiene para encontrar prefijo y sufijo respectivamente. De nuevo, el mismo procedimiento puede ser usado para probar o generar prefijo/sufijo respectivamente también como generar una lista con el prefijo/sufijo dado. Pruébalo. prefijo([],_). prefijo([C|L1],[C|L2]):-prefijo(L1,L2). sufijo(S,S). sufijo([C|T],L):-suffix(T,L).

Probar membresía es un método importante para trabajar con listas. La definición de PROLOG de miembro puede probar la relación de membresía también como generar miembros sucesivos de una lista. Una función similar, miembro_nth, puede también ser usado para probar o generar el miembro n-th de una lista. Sin embargo, no puede ser usado para contar un número de secuencia de un elemento dado (definir la función que cuenta un número de secuencia de un elemento dado como tarea).

















Otra función popular sobre listas es agregar el cual agrega una lista a otra lista. Puede también ser usada para separar listas. (ver la siguiente definición de prefijo y sufijo). Este procedimiento es uno de los más representativos en la programación lógica. Sugerimos que se le compare con su equivalente en otros lenguajes (Note que no es solamente agregar una lista a otra). agregar([],L,L). agregar([C|T],L,[C|LT]):-agregar(T,L,LT).

Ahora, las relaciones prefijo y sufijo pueden ser fácilmente redefinidas usando agregar: prefijo(P,L):-agregar(P,_,L). sufijo(S,L):-agregar(_,S,L).

Agregar puede ser exitosamente usado en muchas otras operaciones con listas incluyendo probar (o generar) sublistas. La siguiente regla explota otra vez el carácter declarativo de PROLOG. sublista(S,L):-agregar(_,S,P),agregar(P,_,L) .

Hay (al menos) dos otras formas de como definir sublista, ejemplo, usando las relaciones prefijo y sufijo. Todas estas definiciones son equivalentes. Sin embargo, el procedimiento sublista3 es probablemente lo más cercano al estilo de programación tradicional (no declarativo) ya que usa la técnica conocida como "floating window". sublista2(S,L):-prefijo(P,L), sufijo(S,P). sublista3(S,L) :- prefijo(S,L). sublista3(S,[_|T]) :- sublista3(S,T).

REGRESO AL EJEMPLO DE FECHA Vamos a retornar a nuestro ejemplo de la estructura de datos fecha. Ahora, vamos a definir la prueba

















Finalmente, es posible probar la correctitud de fecha:

fecha_correcta(fecha(D,M,A)):mes_correcto(M), dia_correcto(D,M,A). mes_correcto(M):- M>0, M<13. dia_correcto febrero

(D,2,A):-

%

la única

diferencia entre

años bisiesto

y regular

es en

es_año_bisiesto(A), probar_dia_del_año(D,2,bisiesto). dia_correcto (D,M,A):M\=2, probar_dia_del_año(D,2,regular). probar_dia_del_año (Tipo,M,D):año(Tipo,Dias), miembro_nth(M,Dias,Max), D>0, D=
Notar, que la definición anteriorde dia_correcto asume que la única diferencia entre años regular y bisiesto es el número de días en febrero el cual es más alto en años bisiestos.

















PROLOG tiene su propia representación de los números. Sin embargo, para propósito de éste tutorial, definiremos otra representación de los números naturales. Ésta simple representación unaria nos ayudará a presentar un flujo de datos durante la recursión. Notar que es un ejemplo típico de definición recursiva donde la "semilla" (cero) es definida y otros elementos (números) son sucesivamente creados de elementos definidos previamente.

0 es representado como 0 N+1 es representado como s(X),donde X es una representación de N

La recursión puede ser naturalmente expresada en PROLOG (¿recuerdas la definición de último o miembro en la lección anterior?). Así, es fácil definir una prueba si una estructura dada es un número unario. Notar otra vez que el mismo procedimiento, es decir, num_unario, puede también ser usado para sucesivamente generar "todos" los número naturales. Intentalo.

num_unario(0). num_unario(s(X)):-num_unario(X).

Ahora, la suma de dos números usando el predicado recursivo suma(X,Y,Z) (X+Y=Z).

suma(0,X,X).

% 0+X=X

suma(s(X),Y,Z) :- suma(X,s(Y),Z). % (X+1)+Y=Z <== X+(Y+1)=Z

















?-suma( 0 ,s(s(s(s(0)))),Sum).

| Sum=s(s(s(s(0))))

?-suma( 0 ,s(s(s(s(0)))),s(s(s(s(0))))). %copia acumulador a resultado. ^-- el resultado es acumulado aquí

Es también posible definir la operación suma sin acumulador usando composición de sustituciones.

suma2(0,X,X).

% 0+X=X

suma2(s(X),Y,s(Z)): - suma(X,Y,Z). % (X+1)+Y=Z+1 <== X+Y=Z ^--- composición de sustituciones

Mira el siguiente rastro (trace) de ejecución para ver la diferencia entre acumulador y composición de sustituciones.

?-suma2(s(s(s(0))),s(0),S1). ^ S1=s(S2)=s(s(s(s(0)))) ?-suma2( s(s(0)) ,s(0),S2).

| S2=s(S3)=s(s(s(0)))

?-suma2( s(0) ,s(0),S3).

| S3=s(S4)=s(s(0))

?-suma2( 0 ,s(0),S4).

| S4=s(0)

?-suma2( 0 ,s(0),s(0)).______| las sustituciones son compuestas aquí ----^

















resta1b(X,Y,Z):-suma(Z,Y,X). resta2a(X,Y,Z):-suma2(Y,Z,X). resta2b(X,Y,Z):-suma2(Z,Y,X).

Por supuesto, resta puede también ser definida desde cero usando recursión.

resta(X,0,X).

% X-0=X

resta(s(X),s(Y),Z) :- resta(X,Y,Z). % (X+1)-(Y+1)=Z <== X-Y=Z

Compáralo con el próximo procedimiento resta2 el cual está basado sobre otra característica de la operación resta. Notar que resta2 requiere la existencia de solución (intenta ?-resta2(0,s(0),Z). ¿Qué sucede?)

resta2(X,X,0).

% X-X=0

resta2(X,Y,s(Z)) :- resta(X,s(Y),Z). % X-Y=Z+1 <== X-(Y+1)=Z

LISTAS (continuación)

Lista es otra estructura de datos recursiva típica. Puede ser definida de la siguiente manera:



















borrar(X,[Y|T],[Y|NT]) :- borrar(X,T,NT).

borrar2(X,L,DL) :- del2(X,L,[],DL).

del2(X,[X|T],A,DL) :- agregar(A,T,DL). del2(X,[Y|T],A,DL) :- del2(X,T,[Y|A],DL).

En este caso particular, la definición de borrar es también más efectiva que borrar2 (omitimos agregar). Los ejemplos de agregar y borrar no implican que la técnica de acumulador no es útil. Lo opuesto es verdad y, en muchos casos, es más natural y efectivo usar acumulador. El siguiente ejemplo es el caso donde usar acumulador es más efectivo computacionalmente que la composición de sustituciones. El procedimiento revertir revierte una lista dada. La definición de revertir parece natural pero no es efectivo debido a que agrega un elemento al final de la lista usando agregar en cada paso. revertir2, el cual usa acumulador, es más eficiente.

revertir([],[]). revertir([H|T],Rev):-revertir(T,RT),agregar(RT,[H],Rev)



















hv(L,L,[],L). hv([H|T],Acc,[H|L],B) :- hv(T,[_|Acc],L,B).

La siguiente definición de partir2 es más eficiente que el partir original. partir2 también usa unificación para distribuir la lista en dos mitades pero es hecho una vez al final del calculo solamente. Compare partir y partir2 sobre ejemplos grandes (una lista con 100 000+ miembros) para ver la diferencia real.

partir2(L,A,B) :- hv2(L,L,A,B).

hv2([],R,[],R). hv2([_,_|T],[X|L],[X|L1],R) :- hv2(T,L,L1,R).

¿ Sabes como hacer el procedimiento hv2 aún más eficiente? Hay un cambio pequeño. Para terminar la lección de hoy, hay dos ejemplos de "vacaciones". Esperamos que estén claros cada uno de ellos. Compare subpart con la definición de sublista de la sección anterior .



















par_impar2([],[],[]). par_impar2([H|T],E,[H|O]):-par_impar2(T,O,E).

La Recursión es poder. EJECUCIÓN DE ARRIBA HACIA ABAJO (Top Down) VS. EJECUCIÓN DE ABAJO HACIA ARRIBA (Bottom Up)

En el capítulo anterior, estudiamos la recursión, un poderoso método para resolver problemas usando la descomposición a problemas más pequeños del mismo tipo. La recursión en PROLOG usa el método de ejecución de arriba hacia abajo (top down) típicamente.

EJECUCIÓN DE ARRIBA HACIA ABAJO (Top Down)



















Notar, que la complejidad de procedimiento de arriba es lineal, es decir, necesitamos N+1 llamadas del procedimiento fact_td.

FIBONACCI

El siguiente programa calcula los números de Fibonacci usando el método de arriba hacia abajo (Top Down), es decir, si estamos buscando el número de Fibonacci de N>1, primero calculamos los números de Fibonacci de N-1 y N-2 (usando el mismo procedimiento) y, entonces, componemos el número de Fibonacci de N partiendo de los subresultados. En este caso, la recursión para tan pronto como el número de Fibonacci de 0 o 1 es computado.

fibo_td(0,0). fibo_td(1,1). fibo_td(N,F) :N>1, N1 is N-1, N2 is N-2, fibo_td(N1,F1), fibo_td(N2,F2), F is F1+F2.



















FACTORIAL

Ahora, calculamos el factorial usando el método de abajo hacia arriba (Bottom Up) comenzando con el problema trivial de calcular el factorial de 0 y continuar con el factorial de 1,2 y así sucesivamente hasta que el factorial de N es conocido. Ya que no queremos cambiar la conducta estándar de PROLOG, que es por naturaleza top down, necesitamos simular el cálculo de abajo hacia arriba (Bottom Up), es decir, tenemos que almacenar los hechos calculados usando parámetros adicionales. En este caso, recordamos sólo el último "hecho" calculado a saber el factorial de M en el paso M-th.

fact_bu(N,F) :- fact_bu1(0,1,N,F).

fact_bu1(N,F,N,F). fact_bu1(N1,F1,N,F) :N1
Notar, que la complejidad del procedimiento de arriba es lineal otra vez, es decir, necesitamos N+1 llamadas del procedimiento fact_bu1. Sin embargo, el procedimiento fact_bu1 es más eficiente que fact_td porque puede ser traducido usando iteración, es decir, sin una pila la cual es requerida para la recursión en





















El número de Fibonacci de El número de Fibonacci de El número de Fibonacci de N>1 es F(N)=F(N-1)+F(N-2)

0 1

es es

F(0)=0 F(1)=1

ESTRUCTURAS DE DATOS DE PROLOG

En este punto podemos hablar más formalmente de las estructuras de datos (suponiendo que las secciones anteriores han sido cubiertas). El término (term) es la estructura de datos básica en PROLOG. Es decir, todas las cosas incluyendo un programa y los datos puede ser expresados en forma de término. Hay cuatro tipos básicos de términos en PROLOG: variables, términos compuestos, átomos y números. El siguiente diagrama muestra la correlación entre ellos también como ejemplos de los términos correspondientes:





















- construye el nombre desde la lista de códigos (name(X,[97,98,99]) -> X=abc)

Si alguien necesita copiar un término (copiar tiene la misma estructura como el término original pero introduce nuevas variables), es posible usar el predicado copiar_term/2 el cual está incorporado en la mayoría de los sistemas PROLOG. Sin embargo, es directo escribir un código de copiar_term en PROLOG usando los predicados mencionados arriba.

copiar_term(A,B)

:-

cp(A,Vars,A,Vars)

cp(A,[],B,_).

:-

atómico(A). cp(V,Vars,NV,NVars)

:-

var(V),registrar_var(V,Vars,NV,NVars).





















f(X,g(X)) es copia de f(Y,g(Y)) pero no de f(U,g(V)).

UNIFICACIÓN

Unificación es un mecanismo fundamental en todos los lenguajes de programación lógica y crucial en el PROLOG. Con unificación se trata de encontrar la mayoría de sustituciones generales de variables en dos términos tal que después de aplicar ésta sustitución a ambos términos, los términos lleguen a ser iguales. Para unificar los términos A y B, uno puede fácilmente invocar la unificación incorporada A=B. Tratar de unificar términos diferentes para ver lo que la noción de "unificación" realmente significa. Otra vez, es directo escribir código PROLOG de unificación (usamos '=' para probar la igualdad de dos términos atómicos o para unificar la





















OPERADORES

Escribir términos en la forma funcion(arg1,arg2,...) no es frecuentemente apropiado desde el punto de vista humano. Sólo compara las siguientes dos transcripciones de la misma cláusula PROLOG:

p(X,Z) '

:-

:-

q(X,Y),r(Y,Z),s(Z).

'(p(X,Z),(','(q(X,Y),','(r(Y,Z),s(Z))))).

¿Cuál prefieres?





















Nota que los números indicando prioridad pueden ser diferentes en diversas implementaciones de PROLOG ( Los números en el ejemplo de arriba son tomados desde el PROLOG abierto para Macintosh).

Importante! La definición de operador no es un nuevo programa para operador sino la "llamada" del objetivo op. Así, si tu quieres definir un operador en el programa, debes escribir :- op(400,yfx,'*').























Una lista diferencial consiste de dos partes A-B y representa la lista que es obtenida desde A removiendo la cola B, ejemplo, [1,2,3,4]-[3,4] representa la lista [1,2]. Por supuesto, si ambas listas A y B son básicas, entonces no hay ventaja de usar listas diferenciales, pero si ésta técnica es combinada con las ventajas de variables libres y unificación, podemos obtener resultados impresionantes. A saber, la lista [1,2] puede ser representada por la lista diferencial [1,2|X]-X. Si estandarizamos las listas diferenciales en la última forma, podemos escribir procedimientos en un sólo





















Una combinación es un subconjunto arbitrario del conjunto que contiene un número dado de elementos. El orden de los elementos es irrelevante.





















varia(0,_,[]). varia(N,L,[H|Varia]) :- N>0,N1 is N -1, borrar(H,L,Rest),varia(N1,Rest,Varia).





















esta_ordenado([X,Y|T]) :- X<=Y,esta_ordenado([Y|T]).

El ordenamiento ingenuo (Naive sort) usa el enfoque generar y probar para resolver problemas, el cual es usualmente utilizado en el caso que todas las demás cosas fallen. Sin embargo, en ordenamiento hay varias otras, muy eficientes, estrategias.





















ORDENAMIENTO DE MEZCLA (merge sort)

El ordenamiento de mezcla (Merge sort) es usualmente usado para ordenar grandes archivos pero su idea























































































































































































































































































































INTRODUCCIÓN A PROLOG

Recommend Documents