UNIVERSIDAD DE ORIENTE

NCLEO DE SUCRE
ESCUELA DE CIENCIAS
DEPARTAMENTO DE MATEMTICAS
PROGRAMA DE LA LICENCIATURA EN INFORMTICA
























Realizado por:
Hernndez B., Edson R., C.I.: 20064672.
Jimnez, Obel, C.I.:
Marcano, Daniela, C.I.:

Prof.: Manuel Centeno.
Asignatura: Introduccin a la Inteligencia Artificial

Cuman, 07/04/2014
INTRODUCCIN

Es durante los primeros aos de la dcada del 70, exactamente durante la
crisis del software, donde la creacin de nuevos programas para satisfacer las
necesidades de aquel entonces involucraba costos mayores, los cuales no podan ser
satisfechos, ya que eran superiores a los del hardware que los ejecutaba. Lo que llevo
a investigar numerosas alternativas, entre las cuales los nuevos lenguajes que se
crearan tendran que ser distintos a los lenguajes corrientes' (basados en
instrucciones algortmicas y procedimientos). Es entonces cuando surge la siguiente
interrogante: si el hombre procesa ms informacin por inferencia lgica que por
clculo, entonces podr la mquina (computador) hacer lo mismo?
En una respuesta a la crisis que ocurra en aquel entonces y producto del
avance de la lgica moderna (de tipo funcional), nace PROLOG (Programacin en
Lgica). ProLog es un lenguaje de programacin lgica cuya primera versin fue
desarrollada a principios de la dcada de 1970 por Colmerauer en la universidad de
Marsella. Contrariamente a otros lenguajes de programacin basados es estructuras
de control y definicin de funciones para calcular resultados, ProLog est orientado a
la especificacin de relaciones para responder consultas.
El objetivo del siguiente informe tiene como meta dar a conocer un tipo de
lenguaje de programacin, ms especficamente el lenguaje PROLOG; en las
siguientes pginas se mencionar y explicar los aspectos ms relevantes de este
lenguaje, adems se dar algunos ejemplos bsicos de las definiciones que
aparecern en este informe. Tambin se dar a conocer la estructura, algunos
comandos y operadores bsicos, entre otros, y por ltimo se hablar un poco de la
evolucin de PROLOG.

Definicin.

ProLog es un lenguaje de programacin lgica cuya primera versin fue
desarrollada a principios de la dcada de 1970 por Colmerauer en la universidad de
Marsella. Contrariamente a otros lenguajes de programacin basados es estructuras
de control y definicin de funciones para calcular resultados, Prolog est orientado a
la especificacin de relaciones para responder consultas. En ese sentido ProLog es
similar a un sistema de base de datos, aunque en el contexto de la inteligencia
artificial se prefiere hablar de bases de conocimiento, enfatizando la complejidad
estructural de los datos y de las deducciones que se pueden obtener de ellos.

Historia.

El desarrollo de ProLog se inici en 1970 con Alain Coulmeauer y Philippe
Roussel, quienes estaban interesados en desarrollar un lenguaje para hacer
deducciones a partir de texto. El nombre corresponde a "PROgramming in LOGic
(Programacin en lgica). ProLog fue desarrollado en Marsella, Francia, en 1972. El
principio de resolucin de Kowalski, de la Universidad de Edimburgo pareci un
modelo apropiado para desarrollar sobre el mecanismo de inferencia. Con la
limitacin de la resolucin de clusulas de Horn, la unificacin condujo a un sistema
eficaz donde el no determinismo inherente de la resolucin se manej por medio de
un proceso de exploracin a la inversa, el cual se poda implementar con facilidad.
La primera implementacin de ProLog se complet en 1972 usando el
compilador de ALGOL W de Wirth y los aspectos bsicos del lenguaje actual se
concluyeron en 1973. El uso de ProLog se extendi gradualmente entre quienes se
dedicaban a la programacin lgica principalmente por contacto personal y no a
travs de una comercializacin del producto. Existen varias versiones diferentes,
aunque bastante similares. Aunque no hay un estndar del ProLog, la versin
desarrollada en la Universidad de Edimburgo ha llegado a ser utilizada ampliamente.
El uso de este lenguaje no se extendi sino hasta los aos ochenta. La falta de
desarrollos de aplicaciones eficaces de ProLog inhibi su difusin.

Breve Perspectiva del Lenguaje.

Un programa en ProLog se compone de una serie de hechos, relaciones
concretas entre objetos de datos (hechos) y un conjunto de reglas, es decir, un patrn
de relaciones entre los objetos de la base de datos .Estos hechos y reglas se
introducen en la base de datos a travs de una operacin de consulta.
Un programa se ejecuta cuando el usuario introduce una pregunta un conjunto
de trminos que deben ser todos ciertos. Los hechos y las reglas de la base de datos
se usan para determinar cules sustituciones de variables de la pregunta (llamadas
unificacin) son congruentes con la informacin de la base de datos.
Como intrprete, ProLog solicita entradas al usuario. El usuario digita una
pregunta o un nombre de funcin. La verdad Yes o falsedad No de esa pregunta
se imprime, as como una asignacin a las variables de la pregunta que hacen cierta
la pregunta, es decir que unifican la pregunta. Si se introduce un ;, entonces se
imprime el prximo conjunto de valores que unifican la pregunta, hasta que no son
posibles ms sustituciones, momento en el que ProLog imprime No y aguarda una
nueva pregunta. Un cambio de rengln se interpreta como terminacin de la
bsqueda de soluciones adicionales.
La ejecucin de ProLog, aunque se basa en la especificacin de predicados,
opera en forma muy parecida a un lenguaje aplicativo como LISP o ML. El
desarrollo de las reglas en ProLog requiere el mismo "pensamiento recursivo" que se
necesita para desarrollar programas en esos otros lenguajes aplicativos.
ProLog tiene una sintaxis y semntica simples. Puesto que busca relaciones
entre una serie de objetos, la variable y la lista son las estructuras de datos bsicas
que se usan. Una regla se comporta en forma muy parecida a un procedimiento,
excepto que el concepto de unificacin es ms complejo que el proceso relativamente
sencillo de sustitucin de parmetros por expresiones.

Evaluacin del Lenguaje.

ProLog ha alcanzado una medida razonable de xito como lenguaje para
resolver problemas de relaciones, como el procesamiento de consultas a bases de
datos. Ha alcanzado un xito limitado en otros dominios.
El objetivo original de poder especificar un programa sin proporcionar sus
detalles algortmicos no se ha alcanzado realmente. Los programas en ProLog se leen
secuencialmente, aunque el desarrollo de reglas sigue un estilo aplicativo. Se usan
cortes con frecuencia para limitar el espacio de bsqueda para una regla, con el
efecto de hacer el programa tan lineal en cuanto a ejecucin como un programa
tpico de C o Pascal. Aunque las reglas se suelen expresar en forma aplicativa, el
lado derecho de cada regla se procesa de manera secuencial. Esto sigue un patrn
muy similar al de los programas en ML.

Sintaxis.
Trminos: Al igual que en Lgica de Primer Orden, los trminos en ProLog
se clasifican en tres categoras: constantes, variables y trminos compuestos o
estructuras.
o Constantes. ProLog distingue dos tipos de constantes:
Nmeros: Este tipo de constantes se utilizan para representar tanto
nmeros enteros como nmeros reales y poder realizar con ellos
operaciones aritmticas.
- La representacin ms corriente de los nmeros enteros es la
notacin decimal habitual (por ejemplo 0, 1, -320, 539, etc.)
aunque tambin se pueden representar en otras bases no
decimales.
- Los nmeros reales se pueden representar tanto en notacin
decimal (por ejemplo 1.0, -3.14) como en notacin
exponencial (por ejemplo 4.5E6, -0.12e+3, 12.0e-2). En ambos
casos debera haber siempre por lo menos un dgito a cada lado
del punto.
Los nmeros reales no son muy utilizados en programas
de ProLog. La razn de esto es que ProLog es principalmente
utilizado como un lenguaje simblico, no de computacin
numrica. En la computacin simblica, los enteros son
utilizados, por ejemplo, para contar el nmero de elementos en
una lista; por lo que los nmeros reales son poco utilizados.

tomos: Los tomos (no confundir con las frmulas atmicas
de la LPO) se utilizan para dar nombre a objetos especficos,
es decir, representan individuos concretos. Existen tres clases
principales de tomos:
- Cadenas formadas por letras, dgitos y el smbolo de
subrayado, que deben empezar necesariamente por una
letra minscula.
Cadenas vlidas: f, pepe1, libro33a, libro_blanco.
Cadenas no vlidas: 1libro, libro-blanco, _hola, Libro.
- Cualquier cadena de caracteres encerrada entre comillas
simples.
Ejemplos: 'SICStus ProLog', 'Libro-blanco', '28003
Madrid'.
Estos tomos son tiles cuando se necesita trabajar con
constantes que empiecen por una letra mayscula o por un
dgito.
- Existe adems otro tipo de tomos, compuestos por
combinaciones especiales de signos, de uso menos comn.
Ejemplo: <---->, =====>, .
Nota: en algunos compiladores, en vez de utilizar apstrofes
se utilizan comillas " " como en el caso de ProLog.
o Variables.
Las variables son cadenas de letras, dgitos y el signo '_'. Estas
empiezan con una letra mayscula o el smbolo '_':
X
Objeto2
_23
Resultado
_x23
Lista_Participantes
Cuando una variable aparece en una clusula sola, no se necesita
inventar un nombre para ella. Se usa llamarla variable "annima", cuando
es escrito nicamente el signo '_'. Por ejemplo, consideremos la siguiente
regla:
hijo(X) :- padre (X,Y).
La regla dice: para toda X, X tiene un hijo si X es el padre de alguna Y.
Nosotros estamos definiendo la propiedad hijo el cual, no depende del
nombre del hijo. Entonces, aqu hay un lugar en donde podemos usar una
variable annima. Si rescribimos la clusula:
hijo(X) :- padre(X,_).

o Estructuras.
Los objetos estructurados (o simplemente estructuras) son objetos
que tienen varios componentes. Los componentes pueden ser a su vez
estructuras. Por ejemplo, la fecha, puede ser vista como una estructura
con 3 componentes: da, mes y ao. Las estructuras son tratadas en el
programa como objetos simples, aunque estn formadas por muchos
componentes. El orden en que se combinan los componentes dentro de
un objeto simple, es la forma en que escogemos un functor. Un functor
conveniente para nuestro ejemplo es fecha. Entonces la fecha 1ro. de
Enero 1975 puede escribirse:
fecha(1, enero, 1975)
Todos los componentes en este ejemplo son constantes (2 enteros y
un tomo). En la siguiente figura vemos como se representa en forma de
rbol, y a su vez cmo est escrito en ProLog:
Ahora bien, cualquier da de enero de 1975 puede representarse
mediante la estructura:
fecha(Da, enero, 1975)
Donde Da es una variable que puede ser instanciada por cualquier
objeto en cualquier momento de la ejecucin del programa.
Sintcticamente, todos los objetos de datos en ProLog son trminos. Por
ejemplo, enero y date(1,enero,1975) son trminos.

Operadores.
Los operadores de ProLog estn divididos en 2 clases: aritmticos y
relacionales.
Los operadores aritmticos incluyen los smbolos para suma, resta,
multiplicacin y divisin. En ProLog, si dos enteros son sumados, restados o
multiplicados, el resultado ser un entero. Siempre que uno de los operandos,
en cualquiera de estas operaciones sea un nmero real, el resultado siempre
ser un real. El resultado de una divisin, siempre que los operandos sean
enteros o reales, ser siempre real.
o Aritmticos:
Todas las versiones de ProLog soportan los siguientes
operadores aritmticos, listados en el orden de prioridad de ejecucin.
+ SUMA
- RESTA
* MULTIPLICACIN
/ DIVISIN
// DIVISION ENTERA
MOD RESIDUO
^ POTENCIA
Los parntesis se pueden utilizar para dar preferencia de ejecucin en
una expresin compuesta. ProLog utiliza la precedencia de operadores con la
regla de la mano izquierda.
A continuacin se muestran algunas operaciones ms complejas que
ProLog provee:









o Relacionales.
ProLog soporta los siguientes operadores relacionales:
= IGUAL QUE
> MAYOR QUE
>= MAYOR O IGUAL QUE
>= MENOR O IGUAL QUE
<> DESIGUAL QUE
=/= DIFERENTE QUE
is EVALUADOR DE EXPRESIN
seed GENERADOR DE NMEROSALEATORIOS
Cuando dos objetos que son smbolos o cadenas de caracteres son
comparados, los caracteres son convertidos a su equivalente ASCII. El
valor de cada carcter es examinado a partir del operador relacional,
de izquierda a derecha.

Predicados.
Un predicado es la relacin directa con una expresin. Cada predicado
usado en una clusula de ProLog debe ser declarado, basado en la declaracin
de los tipos de dominios para cada uno de los nombres de los objetos.
paciente(nombre, edad, peso, presion_sangunea).
mercado(encargado, vendedor).

Consultas.
Para plantear una consulta en ProLog, el usuario simplemente prueba
sta, para ver si sta es verdadera. Si la prueba es positiva, ProLog contesta:
YES, de lo contrario responde NO, o tambin se usa TRUE o FALSE,
dependiendo del programa que se use para la programacin del lenguaje.
paciente ("ana", femenino).
yes

Comentarios.
Cuando se quiere hacer un comentario que cuenta con ms de una
lnea, se hace de la siguiente manera:
/*
Comentario x
Comentario y
*/
Si el comentario es de una solo lnea simplemente se antecede el signo
de % al comentario. Es importante saber que los comentarios no tienen efecto
en la ejecucin del programa.
% Comentario

Clusulas y Relaciones.
La programacin lgica est basada en la nocin de relacin. Debido a
que en la relacin es un concepto ms general de una aplicacin. La
programacin lgica es potencialmente de alto nivel.
Considerar 2 conjuntos de valor S y T, R es la Relacin entre S y T,
para toda X que pertenece a S y Y que pertenece a T y R(X,Y) es verdadero o
falso.
Dado a, determinar el valor m(a). En la programacin Lgica se
implementa las relaciones. Sea R una relacin:
Dado a y b, determinar cundo R(a,b) es verdadero.
Dado a, encontrar todos los Y/R(a,y) es verdadero.
Dado b, encontrar todos los X/R(x,b) es verdadero.
Encontrar X y Y/R(x,y) es verdadero.

o Tipos de Relaciones:
Si R(x) entonces relacin unitaria.
Si R(x ,y) entonces relacin binaria.
Si R(x, y, z) entonces relacin ternaria.
Un programa en PROLOG define una coleccin de relaciones. Cada
relacin es definida por una o ms clusulas.

o Interpretacin de una Clusula en ProLog.
A:- A
1
,..., A
n
.
:- Es equivalente "Si" o "si".
, Es equivalente "AND".
; Es equivalente a "OR".

Programas.
Los programas ProLog son programas lgicos definidos, y estn por
lo tanto compuestos por una serie de clusulas de Horn positivas, esto es,
hechos y reglas. Hay que tener en cuenta sin embargo las siguientes
diferencias en cuanto a la notacin empleada en la Programacin Lgica
Definida:
Los smbolos de predicado se denotan mediante tomos, por lo
que no pueden empezar, como ocurre en Programacin
Lgica, mediante una letra mayscula. Obsrvese por lo tanto
que el lenguaje ProLog no distingue entre smbolos de
predicado, smbolos de funcin y constantes, puesto que todos
ellos se representan mediante tomos (el compilador distingue
unos de otros dependiendo del contexto en el que aparecen).
Para referirse a un predicado nombre_predicado se suele
emplear la notacin nombre_predicado/n, donde n indica el
nmero de argumentos del predicado.
Los hechos deben terminar con un punto y omitir el smbolo
utilizado en Programacin Lgica. As, el hecho A
se escribe en ProLog de la forma A..
Las reglas deben tambin terminar con un punto y sustituir el
smbolo de la Programacin Lgica por el smbolo :-.
As, la regla AA
1
,,A
n
se escribe en ProLog de la forma
A :- A
1
,, A
n.
.
Nota: Al trabajar en ProLog se suele aplicar un convenio estndar para
describir el uso de los predicados (tanto predefinidos como definidos
por el programador): en los programas, las clusulas de cada
predicado debern ir precedidas de un comentario incluyendo una
lnea que describa su uso, as como una descripcin en lengua je
natural de su cometido. El convenio para describir el uso de un
predicado es el siguiente:
nombre_predicado(#NomVar_1, ...., #NomVar_n)
donde NomVar_1,..., NomVar_n son nombres de variables y el
smbolo #, que sirve para indicar cmo debe usarse el argumento
correspondiente al realizarse una consulta, puede tomar uno de los tres
siguientes valores:
+ para indicar que el argumento correspondiente debe estar, en
la consulta, instanciado con un trmino no variable (este tipo de
argumentos se corresponden por lo tanto con parmetros de entrada).
- para indicar que el argumento correspondiente no debe estar
instanciado en la consulta, es decir, debe ser una variable (este tipo de
argumentos se corresponden por lo tanto con parmetros de salida).
? para indicar que el argumento puede estar tanto instanciado
como no instanciado (es decir, se trata de parmetros que se pueden
usar tanto para entrada como para salida).
Por ejemplo, el predicado predefinido sort/2, que sirve para ordenar
listas de elementos, se describe como sort(+Lista1, ?Lista2),
indicando as que para utilizarlo el primer argumento debe estar
instanciado (debe ser una lista concreta). Por lo tanto, el predicado
sort/2 se podr utilizar en consultas de la forma \ ?- sort([c,v,a], X)." o
\ ?- sort([c,v,a], [a,c,v]).", pero si se intenta hacer una consulta en la
que el primer argumento no est instanciado, como por ejemplo \?-
sort(X, [c,v,a]).", se producir un error.

Semntica.
El mecanismo de demostracin automtica utilizado por ProLog es el sistema
de Resolucin SLD estudiado en el tema anterior, pero implementado de acuerdo con
las siguientes pautas:
Unificacin. ProLog usa el algoritmo de unificacin estndar pero, por
razones de eficiencia, no suele incluir el test de ocurrencia. Aunque la
omisin de este test puede llevar a la obtencin de resultados errneos, esto
ocurre raramente. ProLog permite al programador la utilizacin directa de su
algoritmo de unificacin mediante los dos siguientes predicados predefinidos,
que se pueden usar en notacin infija:
- El predicado =, que devuelve cierto si las dos expresiones que se le pasan
resultan ser, omitiendo el test de ocurrencia, unificables.
- El predicado \=, que devuelve cierto si el predicado = falla y falso en
caso contrario.
Ejemplos:
?- f(X, g(b,c)) = f(Z, g(Y,c)).
Y = b, Z = X ?
yes

?- f(X, g(b,c)) = f(Z, g(Y,d)).
No

?- [a,b,[c,d]] = [X|Y].
X = a, Y = [b,[c,d]] ?
yes

?- 3+5 = 8.
no % 3+5 no es ms que el trmino compuesto +(3,5)

?- X = f(X).
X = f(f(f(f(f(f(f(f(f(f(...)))))))))) ?
yes % no se realiza el test de ocurrencia

Nota: algunas implementaciones de ProLog, como por ejemplo SICStus
ProLog, incorporan un predicado predefinido especial que permite
unificar con test de ocurrencia. En SICStus ProLog este predicado se
denomina unify_with_occurs_check.

?- unify_with_occurs_check(X,f(X)).
no % s se realiza el test de ocurrencia
Funcin de seleccin. Selecciona siempre el literal ms a la izquierda.
Regla de ordenacin. Elige las clusulas de acuerdo con el orden en el que
stas aparecen en el programa.
Estrategia de bsqueda : bsqueda en profundidad (se recuerda que esta
estrategia es muy eficiente pero tiene el inconveniente de que no es completa,
esto es, puede conducir a una computacin infinita an en el caso de que
exista una solucin).

Por lo tanto, cuando, una vez cargado un programa lgico, se realiza una
consulta, ProLog construye el rbol de Resolucin SLD correspondiente, de acuerdo
con la funcin de seleccin y la regla de ordenacin citadas, haciendo un recorrido en
profundidad. As, las posibles respuestas del sistema ante una consulta son las
siguientes:
Si todas las ramas del rbol SLD son ramas fallo, la respuesta del sistema ser
no.
Si el rbol SLD tiene alguna r ama infinita ms a la izquierda que cualquier
posible rama xito, la reaccin del sistema depender de la implementacin
concreta de ProLog que se est utilizando. Algunos sistemas, como por
ejemplo SWI-ProLog, presentan un mensaje de error. Otros, como es el caso
de SICStus ProLog, no responden, por lo que es necesario interrumpir la
ejecucin de la consulta mediante CONTROL-C (si se est usando SICStus
ProLog a travs de Emacs, la composicin de teclas CONTROL-C deber
efectuarse dos veces seguidas). Una vez interrumpida la ejecucin, el sistema
muestra por pantalla el mensaje:
Prolog interruption (h for help)?
y acepta a continuacin una letra que determine la accin a seguir. Las
posibles acciones se pueden consultar pulsando la tecla h, aunque lo ms
habitual ser contestar con la letra a, cuya accin asociada es abortar la
ejecucin de la consulta.
En otro caso (es decir, cuando el rbol de Resolucin tiene por lo menos una
rama xito ms a la izquierda que cualquier posible rama infinita):
- Si la consulta realizada no tiene variables (o las que tiene son annimas),
la respuesta del sistema ser yes, terminndose as la ejecucin de la
consulta.
- Si la consulta realizada tiene alguna variable no annima, el sistema
muestra por pantalla los v alores de las variables que se corresponden con
la primera rama xito encontrada al buscar en profundidad en el rbol de
Resolucin, y queda a la espera de nuevas instrucciones por parte del
usuario:
o Si se introduce un retorno de carro, el sistema contesta yes y
abandona la bsqueda de posibles nuevas soluciones.
o Si se introduce un punto y coma seguido de un retorno de carro, el
sistema continua la bsqueda de nuevas soluciones en el rbol de
Resolucin, con lo que el proceso se vuelve a repetir, dependiendo
la respuesta del resultado de la bsqueda (no si termina de
recorrer el rbol sin encontrar ninguna nueva solucin ni ninguna
rama infinita, computacin infinita si encuentra una rama infinita o
valor de las variables correspondientes en caso de encontrarse otra
solucin).

Como ya se coment, resulta claro que tanto el orden en el que aparecen las
clusulas en los programas como el orden de los literales dentro de las clusulas
pueden influir no slo en el orden en el que aparecen las soluciones sino tambin en
la terminacin de las consultas que se realizan.
Ejemplo: Considrese el siguiente programa (ancestros.pl), que incluye,
adems de un predicado progenitor(X,Y) que es cierto cuando X es progenitor de Y ,
cuatro versiones distintas del predicado ancestro(X,Y), cierto cuando X es un
ancestro de Y . Las cuatro versiones varan dependiendo del orden de sus clusulas y
del orden en el que se colocan los literales dentro de ellas.
% progenitor(?X, ?Y): cierto si X es progenitor de Y
progenitor(pepa, pepito).
progenitor(pepito, pepin).
% ancestro(?X, ?Y): cierto si X es un ancestro de Y

% VERSION 1
ancestro1(X, Y) :- progenitor(X, Y).
ancestro1(X, Y) :- progenitor(X, Z), ancestro1(Z, Y).

% VERSIN 2
ancestro2(X, Y) :- progenitor(X, Z), ancestro2(Z, Y).
ancestro2(X, Y) :- progenitor(X, Y).

% VERSIN 3
ancestro3(X, Y) :- progenitor(X, Y).
ancestro3(X, Y) :- ancestro3(Z, Y), progenitor(X, Z).

% VERSIN 4
ancestro4(X, Y) :- ancestro4(Z, Y), progenitor(X, Z).
ancestro4(X, Y) :- progenitor(X, Y).

Aunque las cuatro definiciones anteriores del predicado ancestro son iguales
desde el punto de vista lgico, su comportamiento en ProLog es distinto, ya que
darn lugar a rboles de Resolucin distintos. Por ejemplo, si se intenta averiguar de
quin es ancestro pepa, resulta lo siguiente (comprubense estos resultados mediante
la construccin de los rboles de resolucin SLD correspondientes):

Consulta con ancestro1: ofrece las dos posibles soluciones y termina.
?- ancestro1(pepa, D).
D = pepito ? ;
D = pepin ? ;
No

Consulta con ancestro2: ofrece las dos posibles soluciones (en orden
inverso al caso anterior) y termina.
?- ancestro2(pepa, D).
D = pepin ? ;
D = pepito ? ;
No

Consulta con ancestro3: ofrece las dos posibles soluciones, en el mismo
orden que ancestro1, pero si se piden m as soluciones la consulta no
termina.
?- ancestro3(pepa, D).
D = pepito ? ;
D = pepin ? ;
% el sistema entra en un bucle, que se interrumpe con CTRL-C CTRL-C
ProLog interruption (h for help)? a
{Execution aborted}

Consulta con ancestro4: no produce ninguna solucin, porque entra
directamente en una rama infinita.
?- ancestro4(pepa, D).
% el sistema entra en un bucle, que se interrumpe con CTRL-C CTRL-C
ProLog interruption (h for help)? a
{Execution aborted}

Aunque no existe ninguna regla general que establezca el orden ptimo de las
clusulas ni el orden ptimo de los literales dentro de ellas, s suelen ser
recomendables los siguientes principios bsicos, basados en la idea de hacer antes lo
ms sencillo:
1. Colocar las clusulas que expresan las condiciones de parada de la
recursividad antes que las otras (esto se cumple en las versiones 1 y 3 del
ejemplo anterior).
2. Evitar las reglas con recursin a la izquierda, es decir, las reglas tales que el
primer literal de su cuerpo es una llamada recursiva al mismo predicado de la
cabeza de la regla (las versiones 3 y 4 del ejemplo anterior presentan
recursin a la izquierda).

De las cuatro versiones del ejemplo anterior, la nica que cumple estas dos
recomendaciones es la primera.
Es por otro lado necesario evitar deniciones circulares del estilo:
progenitor(X,Y) :- hijo(Y,X).
hijo(A,B) :- progenitor(B,A).
puesto que cualquier consulta a uno de los dos predicados anteriores provocar
necesariamente un bucle infinito.

Control: El Corte.
Los predicados de control son predicados predefinidos que permiten al
programador intervenir en el mecanismo de bsqueda de soluciones de
ProLog. En este apartado se va a introducir exclusivamente uno de ellos, el
denominado predicado de corte.

o Definicin y propiedades
El corte es un predicado predefinido que se denota mediante un
punto de exclamacin (!), no tiene argumentos, y cuya evaluacin es
siempre cierta. Se puede incluir, como un predicado ms, en el cuerpo
de las reglas o en las consultas (por ejemplo a:- b , c, ! , d.).
Los cortes permiten al programador intervenir en el control del
programa, puesto que su presencia hace que el sistema ignore ciertas
ramas del rbol SLD correspondiente. En concreto, el efecto de los
cortes en la construccin y recorrido de los rboles de resolucin SLD
se produce cuando el sistema llega a un nodo del rbol cuyo primer
predicado es un corte, es decir, un nodo de la forma ? - !,a1,..,an..
En estos casos ocurre lo siguiente (siendo N el nodo anterior):

1. El predicado de corte siempre se evala como cierto, por lo que
el nodo N tendr un nico hijo, que ser igual a N pero sin el corte,
es decir, ser de la forma ?- a1,..,an.. La expansin de este nodo
se realiza igual que la expansin de cualquier otro nodo del rbol.
2. Tanto para cada uno de los nodos ascendientes de N que
contengan el corte como para el primer ascendiente que no lo
contiene (sea N' dicho nodo) se ignoran todas sus posibles ramas
situadas ms a la derecha de la rama que lleva a N.
La siguiente figura ilustra lo anterior. Las ramas tachadas con una raya
son aquellas que se ignoran como consecuencia del corte.












Listas.
Una lista en PROLOG es un conjunto de nombres de objetos, o
tomos, separados por comas y encerrados en parntesis cuadrados.
[member1,member2,...,memberN]
Los miembros de una lista deben ser nombres vlidos de objetos,
pero todos los miembros deben ser declaraciones de un mismo dominio.
Ejemplo:
["Maria","Ana","Juan"]
[33,25.51,20,10,7]
[a,b,c,d,e,f,g]

La lista puede ser vista, como un objeto de dos partes: [Cabeza|Cola]
La cabeza de la lista, conformada por el primer elemento.
La cola, es la parte restante de la lista.

En la ltima lista del ejemplo, la cabeza es a, mientras que la cola de la lista
es la lista es [b,c,d,e,f,g,].
Partes de una Lista.



Elementos de una Lista.
El siguiente cdigo es para saber si un elemento se encuentra dentro
de una lista y/o para sacar a la cabecera de la lista. Elemento (X,R). es verdadero si
X es una lista y R es elemento de esa lista.
As tambin veremos el uso de la recursividad y el caso base en prolog.
Cdigo:
elemento([X|R],X). %A esto se le llama el caso base.
elemento([X|R],Y):-elemento(R,Y).
Consulta:
:?-elemento([a,b,c,d],c).
yes
:?-elemento([a,b,c,d],e).
no

Anlisis del Ejemplo Anterior.
Nivel 1.-X=a, R=[b,c,d],Y=c
elemento([X|R],X). Aqu dira que s, si Y fuera igual a a o sea el primer
elemento.
elemento([X|R],Y):-elemento(R,Y). Todo coincide as que entra al
siguiente nivel.
Nivel 2.-X=b, R=[c,d],Y=c
elemento([X|R],X). no.
elemento([X|R],Y):-elemento(R,Y). Todo coincide as que entra al
siguiente nivel.
Nivel 3.-X=c,R=[d], Y=c
elemento([X|R],X).
X con X, s. R con R, s. X con X, si, puesto que X (el primer elemento
dela lista coincide con el elemento que se busca). Por lo tanto la consola dir
que si.

Si observamos lo que se hace en este ejemplo no es ms que
recursividad. Primero se separa la lista en dos partes, el primer elemento X y el resto
R, y sea el elemento que se busca, o sea, la letra c tambin se le asigna una variable
X, si las dos X son iguales, entonces la respuesta es si, y si no se
sigue con la siguiente lnea.
En la segunda lnea el primer elemento vuelve a ser X, R el
resto y Y el elemento que se busca. En este caso la sintaxis si coincide, por lo
que entra a la primera accin de esta lnea que es otra consulta elemento(R,Y).
Entonces volvemos a empezar, X es igual al resto del nivel
anterior, si recordamos R incluye todos los elementos de la lista a excepcin
del primero, por lo que vemos que hace una recursividad eliminando uno
a uno los elementos de la lista hasta que el que esta primero, llamado X, coincida
con el que se busca en el caso base. De no coincidir en ninguno de los casos,
ProLog responde que no.
Pero hay un punto que se debe de notar para no confundirnos,
en ProLog, aunque haya varias variables con el mismo nombre, no quiere
decir que tienen que tener el mismo valor, esto depende del nivel y de los estados.
Aridad.
Aridad es el nmero de elementos de una lista.
Cdigo:
aridad([ ],0). %Caso base
aridad([X|R],N) :-aridad(R,Z),N is Z+1.
Consulta:
: ?-aridad([a,b,c,d,e],N).
N=5.

Anlisis del Ejemplo Anterior
Nivel 1.- X=a, R=[b,c,d,e],N=N
aridad([ ],0). Aqu tenemos una lista vaca, as que contina a la siguiente
lnea.
aridad([X|R],N):-aridad(R,Z),N is Z+1.
Aqu todo coincide, pues son variables, as que pasa a la primera
accin, que es volver a empezar pero sin el primer elemento de la lista y
as hasta llegar a la e.
Nivel 2.- X=b, R=[c,d,e],N=N
Nivel 3.- X=c,R=[d,e],N=N
Nivel 4.- X=d, R=[e], N=N
Nivel 5.- X=e, R=[ ],N=N
En este nivel vemos que la lista vaca y la variable N coincidirn
con el caso base, as que se dar por terminada la accin
aridad(R,Z) por lo que se continuara con la segunda accin del Nivel5,
N is Z+1
Nivel 5.- N=1
Al terminar con esto, terminara con el nivel 4 y continuara con
la segunda accin del nivel anterior.
Nivel 4.- N=2
Nivel 3.- N=3
Nivel 2.- N=4
Nivel 1.- N=5
Y as es como conseguimos la respuesta de la consola.
Concatenar
Concatenar no es ms que unir dos elementos o listas. Lo cual se podra
decir que es unir 2 listas, pues una lista puede contener solo un elemento.
De esto concluimos que concatenar es unir la lista L1 yL2 en una lista L3.
Cdigo:
conc([ ],L2,L2).
conc([X|R],L2,[X|Z]):-conc(R,L2,Z).
Consulta:
: ?-conc([a,b,c,d,e],[1,2,3],R).
R=[a,b,c,d,e,1,2,3]

Anlisis del Ejemplo Anterior.
conc([ ],L2,L2). No entra por que no se tiene un arreglobacio.
conc([X|R],L2,[X|Z]):-
Aqu lo que se hace es estar eliminando el primer elemento de
la lista hasta lograr una lista vaca para as poder entrar al caso base.
Nivel 1.- X=a, R=[b,c,d,e],L2=[1,2,3]
Nivel 2.- X=b, R=[c,d,e],L2=[1,2,3]
Nivel 3.- X=c,R=[d,e],L2=[1,2,3]
Nivel 4.- X=d, R=[e], L2=[1,2,3]
Nivel 5.- X=e, R=[ ],L2=[1,2,3]
En este nivel entrara al caso base.
Nivel 6.- L2=[1,2,3]
Aqu comenzara a regresar cerrando los niveles y as ir concatenando todos
los elementos en la lista R, terminando as con la conclusin.
R=[a,b,c,d,e,1,2,3]
Inverso de una Lista
El inverso de (X, L) es verdadero si X es una lista y Y es el inverso de la lista
X. Si tenemos L=[a,b,c], su inverso es Li=[c,b,a].
Cdigo:
inverso([ ],[ ]).
inverso([X],[X]).
inverso([X,Y],[Y,X]).
inverso([X|R],E):-inverso(R,Z), con c(Z,[X],E).
Consulta:
:?-inverso([a,b,c],L).
L=[c,b,a].

Anlisis del Ejemplo Anterior
Nivel 1.- X=a, R=[b,c], inverso([b,c],Z)
Nivel 2.- X=b, R=[c], inverso([c],Z)
Nivel 3.- X=c,R=[ ], inverso([ ],Z)
Aqu entrara al caso base y regresndose para entrar a la segunda accin que
es con c(Z,[X],E) que estar concatenando primero c, luego b y al final a.
Duplicar Elementos de una Lista.
El siguiente cdigo duplicara a cada uno de los elementos
pertenecientes a la lista X. duplicar(X,Y). es verdadero si X es una lista y Y
es las lista X pero con los elementos duplicados.
Lx=[1,2,3] Ly=[1,1,2,2,3,3]
Cdigo:
duplicar([ ],[ ]).
duplicar([X],[X,X]).
duplicar([C|L1],[C,C|L2]):-duplicar(L1,L2).
Consulta:
:?-duplicar ([a,b,c],R).
R=[a,a,b,b,c,c]

Anlisis del Ejemplo Anterior.
Nivel 1.- C=a, L1=[b,c],duplicar([b,c],[a,a,b,c])
Nivel 2.- C=b, L1=[c],duplicar([c],[a,a,b,b,c])
Nivel 3.- C=c, L1=[ ],duplicar([],[a,a,b,b,c,c])
R=[a,a,b,b,c,c]
Quitar Ultimo Elemento de la Lista
La clusula quitar(A,B) es verdadero si A es una lista y B es la
misma lista sin el ltimo elemento de la lista A.
L1=[a,b,c,d] Lq=[a,b,c]
Cdigo:
quitar([A],[ ]).
quitar([C|P1],[C|P2]):-quitar(P1,P2).
Consulta:
?-quitar([a,b,c,d],X).
X=[a,b,c]

Anlisis del Ejemplo Anterior.
Nivel 1.- C=a, P1=[b,c,d], quitar([b,c,d],X)
Nivel 2.- C=b, P1=[c,d], quitar([c,d],X)
Nivel 3.- C=c, P1=[d], quitar([d],X)
De regreso:
Nivel 3.- X=[a]
Nivel 2.- X=[a,b]
Nivel 1.- X=[a,b,c]
Quitar los dos ltimos Elementos de la Lista.
quitardos(X,Y) . Es verdadero si X es una lista y Y es la misma lista, sin los
dos ltimos elementos.
L1=[a,b,c,d] Lq=[a,b]
Cdigo:
quitar([A,B],[ ]).
quitar([C|P1],[C|P2]):-quitar(P1,P2).
Consulta:
?-quitar([a,b,c,d],X).
X=[a,b]

Anlisis del Ejemplo Anterior.
Nivel 1.- C=a, P1=[b,c,d], quitar([b,c,d],X)
Nivel 2.- C=b, P1=[c,d], quitar([c,d],X)
De regreso:
Nivel 3.- X=[a]
Nivel 2.- X=[a,b]
Borrar un Elemento Cualquiera de la Lista.
borrar (X,Y,Z).es verdadero si Xes un elemento de la lista Y,y Z es la lista Y
sin el elemento X.
L1=[a,b,c,d] Lq=[a,b,d]
Cdigo:
borrar(X,[ ],[ ]).
borrar(X,[X|R],L):- borrar(X,R,L).
borrar(X,[Y|R],[Y|L]):-X\==Y,borrar(X,R,L).
Consulta:
?- borrar(d,[a,b,c,d],L).
Algoritmos de Ordenacin de Listas.
BubleSort.
El algoritmo de la burbuja (BubleSort) consiste en comparar pares
de elementos adyacentes e intercambiarlos entre s hasta que estn todos
ordenados. Con el arreglo anterior, {40,21,4,9,10,35}:
Primera pasada:
{21,40,4,9,10,35} Se cambia el 21por el 40.
{21,4,40,9,10,35} Se cambia el 40por el 4.
{21,4,9,40,10,35} Se cambia el 9 por el 40.
{21,4,9,10,40,35} Se cambia el 40por el 10.
{21,4,9,10,35,40} Se cambia el 35por el 40.
Segunda pasada:
{4,21,9,10,35,40} Se cambia el 21por el 4.
{4,9,21,10,35,40} Se cambia el 9 por el 21.
{4,9,10,21,35,40} Se cambia el 21por el 10.
Cdigo:
burbuja([],[]).
burbuja(Xs,Ys):-comparar(Ws,[A,B|Zs],Xs),B<A,
comparar(Ws,[B,A|Zs],Vs),
burbuja(Vs,Ys),!.
burbuja(Xs,Xs).
comparar([],Ys,Ys).
comparar([X|Xs],Ys,[X|Zs]):-comparar(Xs,Ys,Zs).
Consulta:
?-burbuja([10,1,0,4,21,9],B).
B=[0,1,4,9,10,21]
QuickSort.
Este mtodo se basa en la tctica "divide y vencers", que
consiste en ir subdividiendo el arreglo en arreglos ms pequeos, y
ordenar stos. Para hacer esta divisin, se toma un valor del arreglo
como pivote, y se mueven todos los elementos menores de este pivote a su
izquierda, y los mayores a su derecha.
La tcnica de diseo de algoritmos llamada "divide y vencers"
(divide and conquer) consiste en descomponer el problema original en
varios sub-problemas ms sencillos, para luego resolver stos mediante
un clculo sencillo.
Por ltimo, se combinan los resultados de cada sub-problema para
obtener la solucin del problema original.
Cdigo:
suma([ ],L,L). % caso base para la unin de listas.
suma([C|L1],L2,[C|L3]):-suma(L1,L2,L3). % saca el resto de la lista
uno y la lista dos para unir las tres listas.
dividir(_,[],[],[]). % caso base para la divisin de listas.
dividir(E,[C|R],[C|Men],May):-E >= C, % divide y compara el
elemento con la otra lista para insertarlos con los mayores.
dividir(E,R,Men,May). % hace la divisin de las listas menores y mayores.
dividir(E,[C|R],Men,[C|May]):-E < C, % divide y compara el
elemento con la otra lista para insertarlos con los menores.
dividir(E,R,Men,May).
qsort([],[]). % caso baso cuando la lista est vaca.
qsort([C|R],L):-dividir(C,R,Men,May),qsort(Men,MenM), % saca la
cabecera y el resto de la lista para empezar a dividir la lista con
los mayores y menores.
qsort(May,MayM),suma(MenM,[C|MayM],L). % tiene los elementos
menores y mayores en sus respectivas listas, hace la concatenacin o unin.
Consulta:
?-qsort([1,20,6,5,3,0],Q).
Q = [0,1,3,5,6,20]
MergeSort.
Puede verse claramente que el algoritmo mergesort requiere de dos pasadas a
los vectores a mergear, una para realizar el merge y otra para copiar
del vector auxiliar al vector original. El tiempo del algoritmo de merge es T(n) =2n
Merge: T(n) = Q (n)
La recurrencia del algoritmo de MergeSort Completo es:
T(n)=1 Si n=1
T(n) = T(n/2)+(n)
Esta es una recurrencia conocida. Aplicando el teorema podemos obtener que:
MergeSort = Q (n logn).
Por lo tanto el algoritmo de MergeSort.
T(n) = Q ( n*log(n))
Es estable. Requiere de un vector auxiliar para realizar el ordenamiento.
Cdigo:
mergesort([],[]). % caso base cuando las listas estn vacas.
mergesort([A],[A]). % se introducir una lista, y arrojara un resultado
con esa misma lista, pero ordenado.
mergesort([A,B|R],S):-partir([A,B|R],L1,L2), % separa cada elemento de la
lista y lo mete en S.
mergesort(L1,S1), % coloca la lista 1 en S1.
mergesort(L2,S2), % coloca la lista 2 en S2.
merge(S1,S2,S). % manda llamar a merge donde hace las particiones.
partir([],[],[]). % hace las tres particiones.
partir([A],[A],[]). % tiene las dos listas y una vaca donde pondr la
lista ordenada.
partir([A,B|R],[A|Ra],[B|Rb]):-partir(R,Ra,Rb).
merge(A,[],A). % si la segunda lista es vaca, el resultado sera los elementos
de la lista 1.
merge([],B,B). % si la primera lista es vaca, el resultado sera los elementos
de la lista 2.
merge([A|Ra],[B|Rb],[A|M]):-A =< B,merge(Ra,[B|Rb],M). % compara un
elemento de la lista A si es menor o igual al elemento de la
lista B.
merge([A|Ra],[B|Rb],[B|M]):-A > B,merge([A|Ra],Rb,M). % compara un
elemento de la lista A si es mayor al elemento de la lista B.
Consulta:
?-mergesort([2,5,3,7],R).
R=[2,3,5,7]

Ventajas de ProLog.
ProLog, y en general los lenguajes de programacin lgica, tienen las
siguientes ventajas frente a los lenguajes clsicos (procedimentales):
Expresividad: un programa (base de conocimiento) escrito en
ProLog puede ser ledo e interpretado intuitivamente. Son, por
tanto, ms entendibles, manejables y fciles de mantener.
Ejecucin y bsqueda incorporada en el lenguaje: dada una
descripcin ProLog vlida de un problema, automticamente se
obtiene cualquier conclusin vlida.
Modularidad: cada predicado (procedimiento) puede ser ejecutado,
validado y examinado independiente e individualmente. ProLog no
tiene variables globales, ni asignacin. Cada relacin est auto
contenida, lo que permite una mayor modularidad, portabilidad y
reusabilidad de relaciones entre programas.
Polimorfismo: se trata de un lenguaje de programacin sin tipos, lo que
permite un alto nivel de abstraccin e independencia de los datos
(objetos).
Manejo dinmico y automtico de memoria.

Desventajas de ProLog.
La resolucin automtica no siempre es eficiente, por lo que eventualmente
se podra dar una respuesta incorrecta a una consulta.
Ciertos problemas estn ligados a la representacin del conocimiento, que
ProLog no posee.
ProLog es algunas veces es incapaz de reconocer que un problema es (para su
propio conocimiento) inaplicable o insuficiente. Si el programa no contiene
suficiente informacin para contestar una consulta, es incapaz de reconocerlo
y responde no. En esta situacin sera ms eficiente conocer que la respuesta
no es negativa, sino que no es posible inferir un resultado.
Los motores de inferencia poseen algunos lmites.




















CONCLUSIN.
Segn el presente informe, se puede establecer que el lenguaje ProLog est
orientado a la Inteligencia Artificial, usando la programacin lgica. Gracias a su
facilidad de programar y su sencilla sintaxis gramatical y numrica, se pueden
escribir rpidamente y con pocos errores programas claramente lebles, adems
cualquier usuario puede acceder a l si lo desea y sin problemas de entendimiento.
Tambin utiliza pocos comandos en comparacin con otros lenguajes de
programacin.
Por otra parte en este lenguaje al igual que otros, hay que tener en cuenta la
asociatividad de los operadores antes de trabajar con l.

BIBLIOGRAFA.
Tutorial:
http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/contents.html

ColinBaker home page:
http://perso.wanadoo.fr/colin.barker/index.htm

Swin-Prolog:
http://www.swi-prolog.org/

StrawberryProlog:
http://www.dobrev.com/

El club de los caminantes:
http://caminantes.metropoliglobal.com/web/informatica/prolog.htm

Programacinlgica:
http://www.geocities.com/v.iniestra/apuntes/pro_log/

Programing in Prolog:
http://cwis.kub.nl/~fdl/general/people/rmuskens/courses/prolog/

Tecnolgicode MonterreyProlog:
http://w3.mor.itesm.mx/~esucar/IA/prolog.html

Ingenierosen infomatica.og:
http://ingenieroseninformatica.org/recursos/tutoriales/sist_exp/cap5.php