1.
Introducción
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
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.
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.
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.
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.
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:iaprologfichero').
* 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.
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.
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.
Autor:
Eddy Tuckler
35 años
Lic. en Ciencias de la
Computación
etuckler[arroba]credomatic.com