LENGUAJE PROLOG

Indice
1. Introducción
2. Hechos
3. Variables
4. Reglas
5. El ámbito de las variables
6. Operadores
7. La resolución de objetivos
8. El mecanismo de control de PROLOG
9. Entrada / Salida
10. Historia y desarrollo de Prolog
11. Tipos de datos en Prolog
12. Estructura de un programa PROLOG
13. Funciones y Pasos de Parámetros.
14. Estructuras de Datos en Prolog
15. Desarrollo de Versiones Actuales

1. Introducción
Prolog es un lenguaje de programación hecho para representar y utilizar el conocimiento que se tiene sobre un
determinado dominio. Más exactamente, el dominio es un conjunto de objetos y el conocimiento se representa
por un conjunto de relaciones que describen las propiedades de los objetos y sus interrelaciones. Un conjunto
de reglas que describa estas propiedades y estas relaciones es un programa Prolog.

Prolog es un lenguaje de programación que es usado para resolver problemas que envuelven objetos y las
relaciones entre ellos.

2. Hechos
Expresan relaciones entre objetos. Supongamos que queremos expresar el hecho de que "un coche tiene
ruedas". Este hecho, consta de dos objetos, "coche" y "ruedas", y de una relación llamada "tiene". La forma de
representarlo en PROLOG es:

tiene(coche,ruedas).

* Los nombres de objetos y relaciones deben comenzar con una letra minúscula.

* Primero se escribe la relación, y luego los objetos separados por comas y encerrados entre paréntesis.

Al final de un hecho debe ir un punto (el carácter "."). El orden de los objetos dentro de la relación es
arbitrario, pero debemos ser coherentes a lo largo de la base de hechos.

3. Variables
Representan objetos que el mismo PROLOG determina. Una variable puede estar instanciada o no
instanciada. Esta instanciada cuando existe un objeto determinado representado por la variable. De este modo,
cuando preguntamos "Un coche tiene X ?",
PROLOG busca en los hechos cosas que tiene un coche y respondería:

X = ruedas.

instanciando la variable X con el objeto ruedas.

* Los nombres de variables comienzan siempre por una letra mayúscula.

Un caso particular es la variable anónima, representada por el carácter subrayado ("_"). Es una especie de
comodín que utilizaremos en aquellos lugares que debería aparecer una variable, pero no nos interesa darle un
nombre concreto ya que no vamos a utilizarla posteriormente.

4. Reglas
Las reglas se utilizan en PROLOG para significar que un hecho depende de uno o más hechos. Son la
representación de las implicaciones lógicas del tipo p ---> q (p implica q).

* Una regla consiste en una cabeza y un cuerpo, unidos por el signo ":-".

* La cabeza esta formada por un único hecho.

* El cuerpo puede ser uno o más hechos (conjunción de hechos), separados por una coma (","), que actúa
como el "y" lógico.

* Las reglas finalizan con un punto (".").

La cabeza en una regla PROLOG corresponde al consecuente de una implicación lógica, y el cuerpo al
antecedente. Este hecho puede conducir a errores de representación. Supongamos el siguiente razonamiento
lógico:

tiempo(lluvioso) ----> suelo(mojado)

suelo(mojado)

Que el suelo esta mojado, es una condición suficiente de que el tiempo sea lluvioso, pero no necesaria. Por lo
tanto, a partir de ese hecho, no podemos deducir mediante la implicación, que esta‚ lloviendo (pueden haber
regado las calles). La representación *correcta* en PROLOG, sería:

suelo(mojado) :- tiempo(lluvioso).
suelo(mojado).

Cabe señalar que la regla esta "al revés". Esto es así por el mecanismo de deducción hacia atrás que emplea
PROLOG. Si cometiéramos el *error* de representarla como:

tiempo(lluvioso) :- suelo(mojado).
suelo(mojado).

PROLOG, partiendo del hecho de que el suelo esta mojado, deduciría incorrectamente que el tiempo es
lluvioso. Para generalizar una relación entre objetos mediante una regla, utilizaremos variables. Por ejemplo:
Representación lógica | Representación PROLOG

Es un coche(X) ----> | tiene(X,ruedas) :

tiene(X,ruedas) | es un coche(X).
Con esta regla generalizamos el hecho de que cualquier objeto que sea un coche, tendrá ruedas. Al igual que
antes, el hecho de que un objeto tenga ruedas, no es una condición suficiente de que sea un coche. Por lo tanto
la representación inversa sería incorrecta.

5. El ámbito de las variables.

Cuando en una regla aparece una variable, el ámbito de esa variable es Únicamente esa regla. Supongamos las
siguientes reglas:

(1) hermana_de(X,Y) :- hembra(X), padres(X,M,P), padres(Y,M,P).

(2) puede_robar(X,P) :- ladron(X), le_gusta_a(X,P), valioso(P).

Aunque en ambas aparece la variable X (y la variable P), no tiene nada que ver la X de la regla (1) con la de
la regla (2), y por lo tanto, la instanciación de la X en (1) no implica la instanciación en (2). Sin embargo
todas las X de *una misma regla* si que se instanciaran con el mismo valor.

6. Operadores
Son predicados predefinidos en PROLOG para las operaciones matemáticas básicas. Su sintaxis depende de la
posición que ocupen, pudiendo ser infijos o prefijos. Por ejemplo el operador suma ("+"), podemos
encontrarlo en forma prefija '+(2,5)' o bien infija, '2 + 5'.

También dispone de predicados de igualdad y desigualdad.

X = Y igual

X \= Y distinto

X < Y menor

X > Y mayor

X =< Y menor o igual

X >= Y mayor o igual

Al igual que en otros lenguajes de programación es necesario tener en cuenta la precedencia y la asociatividad
de los operadores antes de trabajar con ellos.

En cuanto a precedencia, es la típica. Por ejemplo, 3+2*6 se evalúa como 3+(2*6). En lo referente a la
asociatividad, PROLOG es asociativo por la izquierda. Así, 8/4/4 se interpreta como (8/4)/4. De igual forma,
5+8/2/2 significa 5+((8/2)/2).

El operador 'is'.

Es un operador infijo, que en su parte derecha lleva un termino que se interpreta como una expresión
aritmética, contrastándose con el termino de su izquierda.

Por ejemplo, la expresión '6 is 4+3.' es falsa. Por otra parte, si la expresión es 'X is 4+3.', el resultado será la
instanciación de X:

X=7
Una regla PROLOG puede ser esta:

densidad(X,Y) :- población(X,P), área(X,A), Y is P/A.

Algunos comandos básicos

* consult.
El predicado _consult_ esta pensado para leer y compilar un programa PROLOG o bien para las situaciones
en las que se precise añadir las cláusulas existentes en un determinado fichero a las que ya están almacenadas
y compiladas en la base de datos. Su sintaxis puede ser una de las siguientes:

consult(fichero).

consult('fichero.ext').

consult('c:\ia\prolog\fichero').

* recon.
El predicado recon es muy parecido a consult, con la salvedad de que las cláusulas existentes en el fichero
consultado, reemplazan a las existentes en la base de hechos. Puede ser útil para sustituir una única cláusula
sin consultar todas las demás, situando esa cláusula en un fichero. Su sintaxis es la misma que la de consult.

*forget.
Tiene como fin eliminar de la base de datos actual aquellos
hechos consultados de un fichero determinado. Su sintaxis es:

forget(fichero).

* exitsys.
Este predicado nos devuelve al sistema operativo.

7. La resolución de objetivos
Ya hemos creado un programa PROLOG [relacion.pro] y lo hemos compilado
en nuestro interprete PROLOG [consult(relacion)]. A partir de este
momento podemos interrogar la base de datos, mediante consultas.
Una consulta tiene la misma forma que un hecho.
Consideremos la pregunta:

?-quiere_a(susana,pablo).

PROLOG buscara por toda la base de datos hechos que coincidan con el anterior. Dos hechos coinciden si sus
predicados son iguales, y cada uno de sus correspondientes argumentos lo son entre si. Si PROLOG encuentra
un hecho que coincida con la pregunta, responderá yes. En caso contrario responderá no.

Además, una pregunta puede contener variables. En este caso PROLOG buscara por toda la base de hechos
aquellos objetos que pueden ser representado por la variable. Por ejemplo:
?-quiere_a(maria, Alguien).

El resultado de la consulta es:

Alguien = enrique

More (Y/N):

El hecho 'quiere_a(maria,enrique).' coincide con la pregunta al instanciar la variable Alguien con el objeto
'enrique'. Por lo tanto es una respuesta valida, pero no la única. Por eso se nos pregunta si queremos obtener m
s respuestas. En caso afirmativo, obtendríamos:

Alguien = susana

More (Y/N):y

Alguien = ana

More (Y/N):y

No.

?-

Las consultas a una base de datos se complican cuando estas están compuestas por conjunciones o bien
intervienen reglas en su resolución. Conviene, por lo tanto, conocer cual es el mecanismo de control del
PROLOG, con el fin de comprender el porque‚ de sus respuestas.

8. El mecanismo de control de PROLOG

El mecanismo empleado por PROLOG para satisfacer las cuestiones que se le plantean, es el de
_razonamiento hacia atrás (backward) complementado con la búsqueda en profundidad (depth first) y la
vuelta atrás o reevaluación (backtracking).

Razonamiento hacia atrás: Partiendo de un objetivo a probar, busca las aserciones que pueden probar el
objetivo. Si en un punto caben varios caminos, se recorren en el orden que aparecen en el programa, esto es,
de arriba a abajo y de izquierda a derecha.

Reevaluación: Si en un momento dado una variable se instancia con determinado valor con el fin de alcanzar
una solución, y se llega a un camino no satisfactorio, el mecanismo de control retrocede al punto en el cual se
instanció la variable, la des-instancia y si es posible,

busca otra instanciación que supondrá un nuevo camino de búsqueda.

Se puede ilustrar esta estrategia sobre el ejemplo anterior:

Supongamos la pregunta:

?-puede_casarse_con(maria,X).

PROLOG recorre la base de datos en busca de un hecho que coincida con la cuestión planteada. Lo que halla
es la regla:

puede_casarse_con(X,Y) :- quiere_a(X,Y), varon(X), hembra(Y).

Produciéndose una coincidencia con la cabeza de la misma, y una instanciacion de la variable X de la regla
con el objeto 'maria'.

Tendremos por lo tanto:

(1) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), varon(maria), hembra(Y).

A continuación, se busca una instanciación de la variable Y que haga cierta la regla, es decir, que verifique los
hechos del cuerpo de la misma. La nueva meta será :

(2) quiere_a(maria,Y).

De nuevo PROLOG recorre la base de datos. En este caso encuentra un hecho que coincide con el objetivo:

quiere_a(maria,enrique).

instanciando la variable Y con el objeto 'enrique'. Siguiendo el orden dado por la regla (1), quedan por probar
dos hechos una vez instanciada la variable Y:

varon(maria), hembra(enrique).

Se recorre de nuevo la base de datos, no hallando en este caso ninguna coincidencia con el hecho
varón(maria)'. Por lo tanto, PROLOG recurre a la vuelta atrás, desistanciando valor de la variable Y, y
retrocediendo con el fin de encontrar una nueva instanciación de la misma que verifique el hecho (2). Un
nuevo recorrido de la base de hechos da como resultado la coincidencia con:

quiere_a(maria,susana).

Se repite el proceso anterior. La variable Y se instancia con el objeto 'susana' y se intentan probar los hechos
restantes:

varón(maria), hembra(susana).

De nuevo se produce un fallo que provoca la desinstanciación de la variable Y, así como una vuelta atrás en
busca de nuevos hechos que coincidan con (2).

Una nueva reevaluación da como resultado la instanciación de Y con

el objeto 'ana' (la ultima posible), y un nuevo fallo en el hecho

varón(maria)'.

Una vez comprobadas sin éxito todas las posibles instanciaciones del hecho (2), PROLOG da por imposible la
regla (1), se produce de nuevo la vuelta atrás y una nueva búsqueda en la base de datos que tiene como
resultado la coincidencia con la regla:

(3) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), hembra(maria), varon(Y).

Se repite todo el proceso anterior, buscando nuevas instanciaciones de la variable Y que verifiquen el cuerpo
de la regla. La primera coincidencia corresponde al hecho

quiere_a(maria,enrique).

que provoca la instanciación de la variable Y con el objeto 'enrique'. PROLOG tratar de probar ahora el resto
del cuerpo de la regla con las instanciaciones actuales:
hembra(maria), varon(enrique).

Un recorrido de la base de datos, da un resultado positivo en ambos hechos, quedando probado en su totalidad
el cuerpo de la regla (3) y por lo tanto su cabeza, que no es mas que una de las soluciones al objetivo inicial.

X = enrique

PROLOG utiliza un mecanismo de búsqueda independiente de la base de datos. Aunque pueda parecer algo
ilógico, es una buena estrategia puesto que garantiza el proceso de todas las posibilidades. Es útil para el
programador conocer dicho mecanismo a la hora de depurar y optimizar los programas.

9. Entrada/Salida
PROLOG, al igual que la mayoría de lenguajes de programación modernos incorpora predicados predefinidos
para la entrada y salida de datos. Estos son tratados como reglas que siempre se satisfacen.

* write.

Su sintaxis es:

write('Hello world').

Las comillas simples encierran constantes, mientras que todo lo que se encuentra entre comillas dobles es
tratado como una lista. También podemos mostrar el valor de una variable, siempre que este instanciada:

write(X).

* nl.

El predicado nl fuerza un retorno de carro en la salida. Por ejemplo:

write('linea 1'), nl, write('linea 2').

tiene como resultado:

linea 1

linea 2

* read.

Lee un valor del teclado. La lectura del comando read no finaliza hasta que se introduce un punto ".". Su
sintaxis es:

read(X).

Instancia la variable X con el valor leido del teclado.

read(ejemplo).

Se evalúa como cierta siempre que lo tecleado coincida con la constante entre paréntesis (en este caso
'ejemplo').
10. Historia y desarrollo de Prolog
Una de las preocupaciones más tempranas de la computación de los años cincuenta fue la posibilidad de hacer
programas que llevaran a cabo demostraciones automáticas de teoremas. Así empezaron los primeros trabajos
de inteligencia artificial que más de veinte años después dieron lugar al primer lenguaje de programación que
contempla, como parte del intérprete, los mecanismos de inferencia necesarios para la demostración
automática. Este primer lenguaje está basado en el formalismo matemático de la Lógica de Primer Orden y ha
dado inicio a un nuevo y activo campo de investigación entre las matemáticas y la computación que se ha
denominado la Programación Lógica.

Estos mecanismos de prueba fueron trabajados con mucho entusiasmo durante una época, pero, por su
ineficiencia, fueron relegados hasta el nacimiento de PROLOG, ocurrido en 1970 en la Universidad de
Marsella, Francia, en el seno de un grupo de investigación en el campo de la Inteligencia Artificial.

La Programación Lógica tiene sus orígenes más cercanos en los trabajos de prueba automática de teoremas de
los años sesenta. J. A. Robinson propone en 1965 una regla de inferencia a la que llama resolución, mediante
la cual la demostración de un teorema puede ser llevada a cabo de manera automática.

La resolución es una regla que se aplica sobre cierto tipo de fórmulas del Cálculo de Predicados de Primer
Orden, llamadas cláusulas y la demostración de teoremas bajo esta regla de inferencia se lleva a cabo por
reducción al absurdo.

Actualmente, la programación lógica ha despertado un creciente interés que va mucho más allá del campo de
la Inteligencia Artificial(IA) y sus aplicaciones. Los japoneses, con su proyecto de máquinas de la quinta
generación, dieron un gran impulso a este paradigma de programación. Sin embargo, antes que ellos existían
ya en Estados Unidos y en Europa grupos de investigación en este campo, en países como Inglaterra,
Holanda, Suecia y, desde luego, Francia.

A principios de los años ochentas los japoneses comienzan a invertir recursos en un proyecto que denominan
la Quinta Generación, para lucrar con la buena fama de los 4GL. Con este ambicioso proyecto Japón busca
obtener el liderazgo en computación, usando como base la Programación Lógica y la Inteligencia Artificial.

La programación lógica tiene sus raíces en el cálculo de predicados, que es una teoría matemática que
permite, entre otras cosas, lograr que un computador pueda realizar inferencias, capacidad que es requisito
para que un computador sea una "máquina inteligente". La realización del paradigma de la programación
lógica es el lenguaje Prolog.

El Prolog estuvo un tiempo diseñado para ejecutarse en minicomputadoras o estaciones de trabajo,

actualmente hay versiones en Prolog que pueden instalarse en computadores personales como IBM-PC y PC-
Compatibles.

Un programa escrito en PROLOG puro, es un conjunto de clausulas.

Sin embargo, PROLOG, como lenguaje de programación moderno, incorpora

mas cosas, como instrucciones de Entrada/Salida, etc.

Una clausula puede ser una conjunción de hechos positivos o una implicación con un único consecuente (un
único termino a la derecha). La negación no tiene representación en PROLOG, y se asocia con la falta de una
afirmación (negación por fallo), según el modelo de suposición de un mundo cerrado solo es cierto lo que
aparece en la base de conocimiento o bien se deriva de esta.

Las diferencias sintácticas entre las representaciones lógicas y las representaciones PROLOG son las
siguientes:

1. En PROLOG todas las variables están implícitamente cuantificadas universalmente.

2. En PROLOG existe un símbolo explicito para la conjunción "y" (,), pero no existe uno para la disyunción
"o", que se expresa como una lista de sentencias alternativas.

3. En PROLOG, las implicaciones p --> q se escriben al reves q :- p, ya que el interprete siempre trabaja hacia
atrás sobre un objetivo.

11. Tipos de datos en Prolog

Symbol

Hay dos tipos de símbolos:

Un grupo de caracteres consecutivos (letras, números y signos de subrayado) que comienzan con un carácter
en minúscula
Ejemplo: Alto,Alto_edificio,El_alto_edificio_en_la_ciudad

Un grupo de caracteres consecutivos(letras y números) que comienzan y terminan con dobles comillas(").
Este tipo es útil cuando se quiere comenzar el símbolo con un carácter en mayúscula o si se quieres agregar
espacios entre los caracteres del símbolo.
Ejemplo:"alto","alto edificio"

String

Cualquier grupo de caracteres consecutivos (letras y números) que comience y termine con dobles
comillas("). Es igual a símbolo pero Prolog los trata de forma distinta.

Ejemplo:"alto","alto edificio"

Integer

Cualquier numero comprendido entre (-32.768 y 32.768). El limite esta determinado porque los enteros se
almacenan como valores de 16 bits, este limite puede variar según la versión de Prolog.

Ejemplo:4,-300,3004

Real

Cualquier numero real en el rango +/- 1E-307 a +/-1E+308. El formato incluye estas opciones: signo, numero,
punto decimal, fracción, E(exponente), signo para el exponente, exponente.

Ejemplo:3,3.1415

Char

Cualquier carácter de la lista ASCII estándar, posicionado entre dos comillas sencillas(‘).

Ejemplos:‘t’,‘X’,‘f’
12. Estructura de un programa PROLOG
Un programa Prolog está formado por una secuencia de enunciados: hechos, reglas y comentarios.

Una relación puede estar especificada por hechos, simplemente estableciendo objetos que satisfacen la
relación o por reglas establecidas acerca de la relación.

Cada regla está formada por un primer miembro (o la cabeza de la regla), un segundo miembro (o cola de la
regla) ligados por " :- " y termina con el carácter " . ".

código del programa

** Hechos **

mujer(maria).

hombre(pedro).

hombre(manuel).

hombre(arturo).

** Relaciones **

padre(pedro,manuel).

padre(pedro,arturo).

padre(pedro,maria).

** Reglas **

nino(X,Y):- padre(Y,X)

hijo(X,Y):-nino(X,Y),hombre(X).

hija(X,Y):-nino(X,Y),mujer(X).

hermano_o_hermana(X,Y):-padre(Z,X),padre(Z,Y).

hermano(X,Y):-hermano_o_hermana(X,Y),hombre(X).

hermana(X,Y):-hermano_o_hermana(X,Y),mujer(X).

13. Funciones y Pasos de Parámetros.

La recursividad es un mecanismo que da bastante potencia a cualquier lenguaje de programación. A
continuación un ejemplo de programación recursiva que nos permitirá determinar si un tomo es miembro de
una lista dada:

(1) miembro(X,[X|_]).

(2) miembro(X,[_|Y]) :- miembro(X,Y).

La regla (1) es el caso base de la recursion. Se evaluar como cierta
siempre que coincida la variable X con la cabeza de la lista que se pasa

como argumento. En la regla (2) est la definición recursiva. X es miembro de una lista si lo es de la cola de
esa lista (la cabeza se comprueba en la regla (1)).

La regla (1) es una simplificación de la regla:

miembro(X,[Y|_]) :- X = Y.

La traza para el caso de 'miembro(b,[a,b,c]).' es la siguiente:

(1) miembro(b,[a,b,c]) :- b = a. ---> no.

(2) miembro(b,[a,b,c]) :- miembro(b,[b,c]).

(1) miembro(b,[b,c]) :- b = b. ---> yes.

Si necesitamos conocer la longitud de una lista, emplearemos una función

recursiva como la siguiente:

longitud([],0).

longitud([_|Y],L1) :- longitud(Y,L2), L1 is L2 + 1.

Otro ejemplo muy típico de función recursiva es el del factorial de un

numero:

factorial(0,1) :- !.

factorial(X,Y) :- X1 is X-1, factorial(X1,Y1), Y is X*Y1.

La definición de una función esta en los hechos que adoptemos para inferir sobre la base de conocimiento de
Prolog, el paso de parámetros debe definirse en las reglas a través de los predicados que los invoquen, ya sea
por el mismo o por otro predicado.

Para que los predicados definidos como función, no retornen un valor errado, el tipo de dato de la variable del
predicado llamador debe ser igual al del predicado llamado. Esto es debido a que los predicados aritméticos
propios de Prolog no identifican entre un numero real o entero.

14. Estructuras de Datos en Prolog

La lista es una estructura de datos muy común en la programación no numérica. Es una secuencia ordenada de
elementos que puede tener cualquier longitud. Ordenada significa que el orden de cada elemento es
significativo. Un elemento puede ser cualquier termino e incluso otra lista. Se representa como una serie de
elementos separados por comas y encerrados entre corchetes.

El valor de las listas en un programa Prolog disminuye si no es posible identificar los elementos individuales
que habrán de integrarlas. Debido a ello, es necesario tener en cuenta el concepto de su división en dos partes:
cabeza y cola. La cabeza de la lista es el primer elemento de la misma. La cola es el resto de la lista, sin
importar lo que pueda contener.
Para hacer uso practico de la capacidad de dividir listas en cabeza y cola, el Prolog proporciona una notación
especial con la que se definen las listas en los programas. Existen dos símbolos especiales que se utilizan:

El corchete abierto/cerrado. Se usa para denotar el inicio y el final de una lista

El separador. Su símbolo es | y se usa para permitir que una lista se represente como una cabeza y una cola.
Para procesar una lista, la dividimos en dos partes: la cabeza y

la cola. Por ejemplo:

Lista Cabeza Cola

----- ------ ----

[a,b,c,d] a [b,c,d]

[a] a [] (lista vacia)

[] no tiene no tiene

[[a,b],c] [a,b] [c]

[a,[b,c]] a [[b,c]]

[a,b,[c,d]] a [b,[c,d]]

Para dividir una lista, utilizamos el símbolo "|". Una expresión con la forma [X | Y] instanciar X a la cabeza
de una lista e Y a la cola. Por ejemplo:

p([1,2,3]).

p([el,gato,estaba,[en,la,alfombra]]).

?-p([X|Y]).

X = 1,

Y = [2,3]

X = el,

Y = [gato,estaba,[en,la,alfombra]]

Lista de listas, se pueden hacer estructuras tan complejas como se quiera en Prolog. Se pueden poner listas
dentro de listas.

Ejemplo:

animales([[mono,bufalo,rata], [serpiente,iguana,cocodrilo], [paloma,pingüino]])

15. Desarrollo de Versiones Actuales

Antes de que existieran sistemas expertos, sistemas inteligentes adaptables o cualquier otro tipo de programa
capaz de funcionar con inteligencia artificial, se necesito crear los lenguajes para desarrollarlo. Para ello, se
consideraron algunos requerimientos básicos como la posibilidad de procesar símbolos de todo tipo y la
capacidad de hacer inferencias asociadas con el lenguaje, todo dentro de un ambiente flexible que permitiera
escribir el programa de forma interactiva.

Uno de los lenguajes que más éxito ha tenido es Prolog. Por tal razón son muchas las compañías de software
que han creado sus propias versiones del mismo.

La diferencia es mínima entre versiones ya que su sintaxis y semántica es la misma, la variación que más
resalta son el cambio de plataforma para el cual fueron desarrollados.

Nuestro trabajo de investigación no pretende abarcarlos todos, pero si hablar de los mas usados y conocidos
por el ámbito informático.

PROLOG1- Esta versión la ofrece Expert Systems International, se utiliza en maquinas que trabajan con los
sistemas operativos MS-DOS, CP/M-86, RSX-11M y RT-11.

Su mayor fortaleza radica en su interprete PROLOG86, este interprete contiene un editor de cláusulas del
sistema. Tiene un mejor manejo de los tipos de datos entero y real, y además posee mas predicados integrados
por lo cual el programador ya no requiere de definirlos.

PROLOG QUINTUS- Es una versión avanzada del lenguaje. El objetivo de sus diseñadores era producir una
versión que pudiera ofrecer velocidades rápidas de ejecución, así como la capacidad de comunicación con
otros programas. Esta versión funciona en los sistemas operativo UNIX y VMS. Una de las características
interesantes es la interface al editor EMACS, esto provocara que la pantalla se parta en dos ventanas, en una
estará el código del archivo fuente en la parte superior, mientras prolog correrá en la parte inferior, esto brinda
una ayuda ya que cualquier cambio en las cláusulas del archivo, podría ser probada inmediatamente,
solamente interactuando entre ventanas.

MACPROLOG- Esta versión esta diseñada totalmente para correr en maquinas MAC. Esta versión combina
sofisticadas técnicas de programación de inteligencia artificial en ambientes Macintosh. Al integrar el
compilador Prolog con las herramientas de MAC (ratón, menú, ventanas y gráficos), Prolog ofrece un entorno
de programación sofisticado que antes solo se podía obtener con hardware costoso y muy especializado.

SWI-PROLOG- Es una implementación de Prolog basada en un subconjunto del WAM(Warren Abstract

Machine). SWI-Prolog ha sido diseñado e implementado de tal modo que puede ser empleado fácilmente para
experimentar con la lógica de la programación y con las relaciones que esta mantiene con otros paradigmas de
la programación, tales como el entorno PCE orientado al objeto. Posee un rico conjunto de predicados
incorporados que hacen posible el desarrollo de aplicaciones robustas. Además ofrece una interfaz para el
lenguaje C.

Trabajo enviado por:

Eddy Tuckler
35 años
Lic. en Ciencias de la Computación
etuckler@credomatic.com