unidad vi - paradigma logico

7/31/2019 Unidad VI - Paradigma LOGICO

1/64

Universidad Tecnolgica Nacional Paradigmas de ProgramacinFacultad Regional Crdoba Programacin Lgica ao 2009

Programacin Lgica

Indice

PROGRAMACIN LGICA ........................................................................................................................................ 1

INDICE ............................................................................................................................................................................11.INTRODUCCIONALAPROGRAMACIONLOGICA........................................................................................... 22.LOGICAPROPOSICIONAL.....................................................................................................................................33.INTRODUCCIONAPROLOG.................................................................................................................................44.CALCULODERELACIONES .................................................................................................................................64.1RELACIONES.........................................................................................................................................................84.2RELACIONESENPROLOG..................................................................................................................................8

5.BUSCANDOLASSOLUCIONES.......................................................................................................................... 155.1.ELCONTROLENPROLOG................................................................................................................................165.2.ELBACKTRACKING ......................................................................................................................................... 175.3.ELCORTE(!) ....................................................................................................................................................... 235.4.LANEGACINCOMOFRACASO ....................................................................................................................265.5.REALIZANDOELSEGUIMIENTODEUNPROGRAMA................................................................................ 266.ESTRUCTURADEUNPROGRAMAENPROLOG.............................................................................................267.OBJETOSCOMPUESTOS...................................................................................................................................... 368.RECURSIVIDAD.................................................................................................................................................... 379.LISTAS .................................................................................................................................................................... 40PARTEPRACTICA .................................................................................................................................................... 45SOLUCIONES.............................................................................................................................................................50REFERENCIAS Y FUENTES..............................................................................................................................................64

Autor: Ing. Silvio Serra


2/64

Universidad Tecnolgica Nacional Paradigmas de ProgramacinFacultad Regional Crdoba Programacin Lgica

Pag.2

1. INTRODUCCION A LA PROGRAMACION LOGICAUna forma de razonar para resolver problemas en matemticas se fundamentaen la lgica de primer orden. El conocimiento bsico de las matemticas sepuede representar en la lgica en forma de axiomas, a los cuales se aadenreglas formales para deducir cosas verdaderas (teoremas) a partir de losaxiomas. Gracias al trabajo de algunos matemticos de finales del siglo pasadoy principios de ste, se encontr la manera de automatizar computacionalmenteel razonamiento lgico, particularmente para un conjunto significativo de la lgicade primer orden, que permiti que la lgica matemtica diera origen a otros

tipos de lenguajes de programacin, conocidos como lenguajes lgicos.Tambin se conoce a estos lenguajes como lenguajes declarativos, porque todolo que el programador tiene que hacer para solucionar un problema esdescribirlo va axiomas y reglas de deduccin.

En los lenguajes lgicos se utiliza el formalismo de la lgica de primer ordenpara representar el conocimiento sobre un problema y para hacer preguntasque, si se demuestra que se pueden deducir a partir del conocimiento dado enforma de axiomas y de las reglas de deduccin estipuladas, se vuelventeoremas. As se encuentran soluciones a problemas formulados como

preguntas. Con base en la informacin expresada dentro de la lgica de primerorden, se formulan las preguntas sobre el dominio del problema y el intrpretedel lenguaje lgico trata de encontrar la respuesta automticamente. Elconocimiento sobre el problema se expresa en forma de predicados (axiomas)que establecen relaciones sobre los smbolos que representan los datos deldominio del problema.

Este concepto de programacin lgica est ligado histricamente a un lenguajellamado Prolog, que proviene de PROgrammation en LOGique (programacin enlgica), que fue el primer lenguaje de programacin lgico y el ms conocido yutilizado. Este lenguaje fue desarrollado por el Grupo de Inteligencia Artificial dela Universidad de Marseille, dirigido por Alain Colmerauer, en 1972. Prolog esutilizado para el desarrollo de aplicaciones de inteligencia artificial debido a suforma de representar el conocimiento, facilitando las

bsquedas en bases de datos, la escritura de compiladores, la construccin desistemas expertos, el procesamiento de lenguaje natural y la programacinautomtica. Tambin es muy adecuado para las aplicaciones que implicanbsqueda de patrones, bsqueda con rastreo inverso o informacin incompleta.

Asimismo es el lenguaje escogido por Japn como piedra angular de lossistemas de computacin de quinta generacin.


3/64


Pag.3

Dice Alain Colmerauer en [1]: "Se suele preguntar cul es la diferencia entreProlog y los otros lenguajes de programacin y de dnde viene su supuestopoder. Prolog naci de un desafo: crear un lenguaje de muy alto nivel, aun

cuando fuera ineficiente para los informticos de la poca. La eficiencia consistaentonces en que una mquina ejecutara muy rpidamente programaslaboriosamente escritos. El reto consista en poder escribir rpidamente losprogramas dejando a la mquina su laboriosa ejecucin.

Una vez liberados de esa obsesin por la eficiencia, se pudo recurrir a los

formalismos y mecanismos de inferencia de la lgica matemtica; mecanismosciertamente ineficientes, pero poderosos sin lugar a dudas. De ah viene elnombre de Prolog Programacin en lgica. Ahora bien, si se considera lo quesucede a nivel de la mquina, resulta que sta deber ser mucho ms inteligente

de lo normal: debe ser no-determinista, es decir, capaz de explorar muchasposibilidades y debe poder resolver miles y miles de pequeas ecuaciones.

Estas ecuaciones introducen incgnitas, que no son otra cosa que las variablesdel programa, pero distan mucho de ser las variables habituales que designanlocalidades de memoria. El programador que llega a Prolog desde un lenguajeclsico, experimenta una revelacin semejante a la del escolar que pasa de laaritmtica a los primeros rudimentos del lgebra. Puede representar comoincgnitas aquellas entidades cuyos valores busca, establecer ciertas relacionesentre esas incgnitas y, sin tener que detallarlos, dejar que la mquina consideretodos los casos posibles y aportar todas las posibles soluciones...

Qu ms se puede pedir?"

2. LOGICA PROPOSICIONAL

La programacin lgica tiene sus orgenes en los trabajos de prueba automticade teoremas. Para esto se utiliza una nica regla de inferencia llamada principiode resolucin1, mediante la cual la prueba de un teorema puede ser llevada acabo en forma automtica. La resolucin es una regla que se aplica sobre lasfrmulas surgidas de la lgica de primer orden y la demostracin de teoremasmediante esta regla de inferencia se lleva a cabo por reduccin al absurdo.

La lgica de primer orden o lgica proposicional es uno de los formalismos ms

utilizados para representar conocimiento en Inteligencia Artificial. Esta lgica esla que utiliza proposiciones y nexos entre stas para expresar sus verdades. Lasproposiciones equivalen a frases u oraciones del lenguaje hablado, mientras quelos nexos a travs de los cuales puede relacionar estas proposiciones son laconjuncin (y), la disyuncin (o) y la implicacin (si). Cuenta con un lenguajeformal mediante el cual es posible representar frmulas llamadas axiomas opredicados, que permiten describir fragmentos del conocimiento, y adems


4/64


Pag.4

consta de un conjunto de reglas de inferencia que aplicadas a los axiomas,permiten derivar nuevo conocimiento.

El lenguaje formal de la lgica proposicional o lgica de primer orden es elLenguaje de Primer Orden (LPO). En realidad ste no es un lenguaje simple,sino que es una familia de lenguajes, donde todos sus miembros tienen unagramtica similar y comparten ciertos tems importantes de su vocabulario. Detodos modos nuestro estudio se centrar en un lenguaje genrico de primerorden, que es el que luego podremos aplicar en los programas de Prolog.

Los enunciados ms bsicos de LPO son los enunciados atmicos. Estos secorresponden a los enunciados ms simples del espaol, enunciados queconsisten en algunos nombres conectados por algn predicado. Ejemplos deeste tipo son Juan corri, Juan vio a Ana y Ana regal flores a Juan. En LPO, los

enunciados atmicos son formados tambin combinando nombres (o constantesindividuales, tal como suelen llamarse) y predicados, aunque comoposteriormente veremos difieren un poco en el modo en que son combinados.

3. INTRODUCCION A PROLOG

Prolog es un lenguaje de programacin declarativo basado en la lgica de primerorden, particularmente en una restriccin de la forma clausal de la lgica. Fuedesarrollado por Alain Colmerauer en 1972 en la Universidad de Marseille,Francia. Usa como regla de inferencia el principio de resolucin propuesto por

Robinson en 1965. La representacin del dominio se realiza a travs de hechosy reglas.

Decimos que es declarativo porque no es imperativo. Es decir, cada lnea deprograma Prolog es una declaracin, no una orden. Se tiene as un conjunto deaseveraciones expresadas simblicamente, que expresan conocimientos de unasituacin real o ficticia. Para esto se usa la lgica de predicados de primer ordenque se expuso anteriormente.

Prolog es un lenguaje de programacin hecho para representar y utilizar elconocimiento que se tiene sobre un determinado dominio. Ms exactamente, eldominio es un conjunto de objetos y el conocimiento se representa por unconjunto de relaciones que describen las propiedades de los objetos y susinterrelaciones.

En Prolog, el programa (las reglas que definen las propiedades y relacionesentre los objetos) est muy alejado del modelo Von Newman que posee lamquina en la que tienen que ser interpretados. Debido a esto, la eficiencia en laejecucin no puede ser comparable con la de un programa equivalente escritoen algn lenguaje imperativo o procedural. El beneficio es que aqu ya no esnecesario definir el algoritmo de solucin, como en la programacin imperativa,


5/64


Pag.5

sino que lo fundamental es expresar bien el conocimiento que se tenga sobre elproblema que se est enfrentando.

Prolog forma su lenguaje a partir de un alfabeto que contiene slo dos tipos desmbolos:

1. smbolos lgicos, entre los que se encuentran los smbolos de constantes

proposicionales true y false (verdadero y falso); los smbolos para la negacin, laconjuncin, la disyuncin y la implicacin (que en Prolog se denota con loscaracteres :-); los smbolos de cuantificadores; y los smbolos auxiliares deescritura como corchetes [,], parntesis (,) y coma.

2. smbolos no lgicos, agrupados en el conjunto de smbolos constantes; elconjunto de smbolos de variables individuales (identificadores); el conjunto desmbolos de relaciones n-arias; y el conjunto de smbolos de funciones n-arias.

A partir de estos smbolos se construyen las expresiones vlidas en el LPO deProlog: los trminos (nombres) y las frmulas (predicados). Este LPO posee unamplio poder de expresin, ya que los trminos permiten hacer referencia(nombrar) todos los objetos del universo, mientras que las frmulas (predicados)permiten afirmar o negar propiedades de estos o bien establecer relacionesentre los objetos del universo.

Existen muchas versiones de Prolog, algunas de las ms conocidas para PC semuestran en la tabla 1. En Prolog de Edimburgo, versin de Prolog diseada porDavid Warren que se ha convertido en estndar, un trmino es cualquiera de lastres expresiones siguientes: una constante, como el nmero "100"; la palabra"antonio" y la letra "c"; o una variable, por ejemplo "X" (notar que losidentificadores que comienzan con mayscula representan, siempre, variables).En cambio, un predicado atmico o elemental es una expresin de la forma"R(a1, a2,..., an)" donde R es un smbolo de predicado n-ario que como vimos,denota alguna relacin entre objetos o alguna propiedad de un objeto, y a1,a2,..., an son trminos funcionando como argumentos.

Los conceptos generales de este apunte los explicaremos con Turbo Prolog,

basado ste en Prolog de Edimburgo.

TABLA 1. ALGUNAS VERSIONES DE LENGUAJE PROLOG PARA PC

SISTEMA EMPRESA ENTORNO

ALS Prolog (Applied LogicSystems Inc.)

DOS / Unix / Xenix


6/64


Pag.6

Arity Prolog (Arity Corp) DOS / Windows /OS 2

Cogent Prolog (Amziod) DOS

IF Prolog (InterFaceComputer Inc.)

UNIX

Quintus Prolog (Quintus Corp.) DOS / Windows /OS 2

Turbo Prolog (BorlandInternational)

DOS

PIE Prolog (versin shareware) DOS

4. CALCULO DE RELACIONES

La programacin lgica trabaja ms con relaciones que con funciones. Se basaen la premisa de que programar con relaciones es ms flexible que programarcon funciones, debido a que las relaciones tratan de forma uniforme a losargumentos y a los resultados.

De manera informal, las relaciones no tienen sentido de direccin ni prejuicioalguno acerca de qu se calcula a partir de qu.

En Prolog se utiliza slo un tipo determinado de reglas para definir relaciones,llamadas clusulas de Horn2, llamadas as en honor al lgico Alfred Horn, quienlas estudi. Estas reglas estn compuestas por dos partes: el consecuente y elantecedente. El consecuente, que es la primera parte de la clusula, es lo quese quiere probar, la conclusin de la regla. El antecedente es la condicin quedeterminar en qu casos el consecuente es verdadero o falso. Esta estructurade clusula es de la forma:

conclusin si condicin

La resolucin de una de estas clusulas podra considerarse como la invocacina un procedimiento, que sera el encargado de comprobar qu valor de verdadposee la condicin (o condiciones), para luego asignar el resultado lgico de esaevaluacin al objeto que se halla a la izquierda de la implicacin si (elconsecuente o conclusin). Las reglas que gobiernan esta asignacin, en elcaso de existir ms de una condicin, son las que rigen la Lgica de PrimerOrden, con idnticos operadores y precedencias entre ellos.


7/64


Pag.7

Es posible que, para verificar una condicin, deban verificarse primeramente unao varias sub-condiciones. Esto equivaldra a la llamada de varios sub-procedimientos para completar la ejecucin de un procedimiento padre.

Las clusulas de Horn permiten crear un lenguaje de primer orden con unasintaxis rgida (se debe respetar siempre la estructura de antecedente -consecuente) pero con un gran poder de expresin, ya que nos deja representartodo el conocimiento necesario como cualquier otro LPO.

Estas clusulas pueden adoptar las siguientes formas:

conclusin B--- Afirmacin Hecho

conclusin se condicin B--- A1,A2,...An Implicacin Regla

si condicin --- A1,A2,...An Objetivo

Afirmacin: Cuando escribimos slo la conclusin, estamos afirmando algo queno necesita ser probado. Esto significa que estamos diciendo una verdad que nodebe ser comprobada, que no tiene condicin de valides. Por ejemplo :

mujer (ana)

con lo que decimos que ana posee la propiedad de ser mujer, sin que se debasatisfacer ninguna condicin.

Estos casos particulares de clusulas sin condicin son llamados hechos,porque son verdades por si mismas.

Implicacin: Afirmacin condicional, donde el predicado B es verdadero siA1,A2,...,An son verdaderos conjuntamente.

Cuando escribimos la clusula completa, estamos escribiendo un hechocondicional, llamado predicado con consecuente en la lgica de primer orden.Con este tipo de estructuras manifestamos que un objeto puede poseer ciertapropiedad o que puede existir cierta relacin entre objetos si se cumple lacondicin. Entonces, para expresar la idea de que Si pedro es hombre entonces

pedro es racional, deberamos escribir una clusula como la siguiente :racional (pedro) si hombre (pedro)

lo que indica que pedro es racional slo si es hombre.

NEGACION:A1,A2,...,An Clusula objetivo o goal. Cada uno de los predicadosA1,Aa2,...,An de la clusula son denominados subobjetivos. Esta es en realidadla clusula que queremos probar del conjunto de sentencias del programa.


8/64


Pag.8

Se deduce que en la prueba del objetivo se esta empleando el principio deresolucin de Robinson. Se niega la clusula que se desea probar y se la agregaa las clusulas del programa. Luego se aplican las reglas de resolucin y, al

derivarse una clusula nula, queda demostrado que la clusula original esverdadera.

4.1 RELACIONES

Resumiendo, el conjunto de reglas que define las relaciones y las propiedadesde los objetos es el programa en Prolog. Por ejemplo, segn vimos cuandodecimos "Juan es padre de Pablo" no estamos haciendo ms que afirmar queuna relacin (ser padre) liga dos objetos (designados por sus nombres: Juan yPablo), y esta relacin se puede escribir como:

es_padre_de (pablo, juan)

Igualmente, la respuesta a una pregunta del tipo "Quin es el padre de Pablo?"se reduce a comprobar si la relacin es_padre_de liga a Pablo con otro objeto,que ser la respuesta a la pregunta.

No debemos olvidar que cuando se define una relacin entre objetos, el ordenque se da a estos es relevante: es_padre_de (pablo, juan) puede significar que"Pablo es padre de Juan" o que "Juan es padre de Pablo", ya que la relacintiene un solo sentido. Es el programador el que ha de decidir cul de las dos esla interpretacin a usar. Ahora bien, una vez elegida la interpretacin, sta es

definitiva.En el ejemplo anterior se han utilizado identificadores para nombrar a los objetosy a la relacin que los liga. En Prolog, el nombre de la relacin (es_padre_de) sedenomina predicado, y los nombres que vincula (Juan y Pablo), argumentos.

4.2 RELACIONES EN PROLOG

Antes de estudiar la forma en que se construyen las clusulas en Prolog,veremos

cmo se escriben en este lenguaje los operadores lgicos para la conjuncin, ladisyuncin y la implicacin:

Operador Sintaxis en Prolog

AND (conjuncin y) , (coma)

OR (disyuncin o) ; (punto y coma)

IF (implicacin si) :- (dos puntos y guion)


9/64


Pag.9

Para conocer la forma de trabajar de Prolog, vamos a comenzar viendo un

primer

ejemplo que describe la carta de un restaurante. Los objetos que interesan aquson los platos que se pueden consumir y una primer serie de relaciones queclasifica estos platos en entradas, platos a base de carne o de pescado (platofuerte) y postres. Este men es un pequeo banco de datos que se expresa dela siguiente manera:

entrada(antipasto).

entrada(sopa).

entrada(quesos).

carne(milanesa).

carne(bife_de_chorizo).

carne(pollo_asado).

pescado(congrio).

pescado(pejerey).

postre(flan).

postre(helado).

postre(fruta).

Se podra decir que esto ya es un programa en Prolog, solo falta siertaestructuracin que ser vista mas adelante. Este programa esta compuesto porun conjunto de predicados que definen caractersticas de los objetos que poseeny los clasifican. Por ejemplo:

entrada(antipasto).

Indica que antipasto es una entrada y nada ms. En realidad este primer tipo de


10/64


Pag.10

regla se reduce a enunciar los hechos o declaraciones simples. Cuando setienen estas clusulas, se pueden hacer preguntas sobre ellas. Una preguntacomo: Es una entrada antipasto?. En prolog se hara de la siguiente manera:

:-entrada(antipiasto).

Ntese que, al contrario que las reglas, una pregunta comienza con :-, que es en

Prolog el smbolo de la implicacin. Esto se debe a que sta es una clusulaincompleta que posee slo el consecuente si antipasto es entrada, que es lo quese desea averiguar. A las clusulas de este tipo se las llama goals o clusulasobjetivo, ya que son el objetivo, el problema para el que fue escrito el programa.

Se busca entonces si esta afirmacin forma parte de las conocidas, la respuesta

es True (Verdadero), respuesta que indica que s es verdadera esa afirmacin.Sin embargo, :- entrada(ensalada). recibir una respuesta negativa (False oFalso), ya que esta entrada no se encuentra entre las declaraciones de la base.

Estas dos preguntas que realizamos tambin son llamadas consultas deexistencia, porque slo verifican la existencia de hechos y/o relaciones quesatisfagan la pregunta formulada.

Si ahora queremos saber cules son las entradas que se pueden consumir y nose desea preguntar por separado por las infinitas entradas posibles, esperandouna respuesta afirmativa (True) o negativa (False) en cada caso, entoncespodemos preguntar:

Cules son las entradas?

o lo que es mejor

Cules son los objetos X que son entradas?

sin conocer al efectuar la pregunta qu objetos representa la X. El smbolo X nodesigna un objeto en particular, sino todo objeto perteneciente al conjunto(posiblemente vaco) de los que poseen la propiedad de ser una entrada y quese pide sea definido por el programa. En este caso se dice que la X es una

variable. La pregunta del ejemplo se hara de la siguiente manera::- entrada(X).

Ante esta pregunta Prolog responder en la pantalla:

X=antipasto

X=sopa

X=quesos


11/64


Pag.11

que es el conjunto de objetos que designa la variable X para que la declaracin

pregunta se verifique.

Desde el punto de vista sintctico, una pregunta es una secuencia de uno o mstrminos (metas u objetivos) que representa una conjuncin de relaciones asatisfacer.

Las respuestas a esta pregunta son las restricciones sobre las variables queaparecen en la secuencia de metas y que satisfacen las relacionesconsideradas.

Se debe tener en cuenta que en Prolog la variables siempre comienzan con una

letra mayscula, mientras que los predicados y los literales deben comenzar conminsculas. Entonces, las variables son un conjunto de una o ms letras,nmeros y guiones bajos (_), que comienzan con una letra mayscula. Encambio, los predicados y cadenas de literales deben comenzar con una letraminscula, pudiendo contener, adems de letras, nmeros y guiones bajos (_).(En realidad los predicados, y no las constantes literales, tambin puedencomenzar con maysculas, pero en aqu los vamos a escribir siempre enminsculas.)

A partir de las relaciones que constituyen la base de datos inicial, se puedenconstruir relaciones ms complejas y generales. Por ejemplo, a partir de lasrelaciones carne y pescado, que indican que su argumento es un objeto que esun plato de carne o un plato de pescado, se puede definir la relacinplato_principal, que indicar que "un plato_principal es un plato de carne o unplato de pescado" y que se formula:

plato_principal(P) :- carne(P).

plato_principal(P) :- pescado(P).

Aqu aparecen por primera vez las clusulas de Horn completas, conantecedente y consecuente, que son llamadas reglas. Estas reglas seinterpretan as:

P es un plato_principal si P es un plato de carne.

P es un plato_principal si P es un plato de pescado.

lo que indica que un objeto es plato_principal, si es un plato de carne o si es unplato de pescado. Debido a esto, el par de reglas se podra escribir de lasiguiente manera

plato_principal(P) :- carne(P); pescado(P).


12/64


Pag.12

aunque continuaremos utilizando la definicin inicial en pos de una mayorsencillez.

En estas clusulas se utiliza la variable P para designar el conjunto de todos losplatos de carne, en la primera regla, y todos los platos de pescado, en lasegunda.

El mbito de una variable se limita a la regla en la que est definida, por lo quela variable P de la primera regla de la definicin de plato_principal no tiene nadaque ver con la variable P de la segunda. En este ejemplo, la pregunta " Culesson los platos principales?" formulada como:

:- plato_principal(P).

produce las respuestasP = milanesa

P = bife_de_chorizo

P = pollo_asado

P = congrio

P = pejerrey

Tratamos a continuacin la composicin de una comida completa. Como eshabitual,

una comida consta de una entrada, de un plato fuerte (carne o pescado) y de unpostre. Una comida es, por tanto, una terna: E,P,D, donde E es una entrada, Pun plato y D un postre. Esto se expresa de forma natural por la regla:

comida(E,P,D) :- entrada(E), plato_principal(P), postre(D).

que se interpreta as: E,P,D satisfacen la relacin comida si E satisface larelacin entrada, si P satisface la relacin plato_principal y D satisface larelacin postre.

Por tanto, se ha definido una nueva regla como la conjuncin de otras tres

A la pregunta "Qu comidas hay?", formulada como:

:- comida(E,P,D).

Prolog responde:

E=antipasto, P=milanesa, D=flan


13/64


Pag.13

E=antipasto, P=milanesa, D=helado

.....

E=sopa, P=milanesa, D=fruta

E=sopa, P=bife_de_chorizo, D=flan

.....

E=quesos, P=congrio, D=flan

E=quesos, P=congrio, D=helado

.....

E=quesos, P=pejerrey, D=fruta

que es la lista de las 54 combinaciones posibles.

Teniendo el mismo conjunto de relaciones definidas, se propone una preguntaun poco ms precisa: se desea conocer las comidas que contienen un plato depescado. Esta pregunta se formula as:

:- comida(E,P,D), pescado(P).que expresa la conjuncin de las dos condiciones que se quieren verificar.Prolog calcular los valores de las variables E,P,D para los que la primeracondicin comida(E,P,D) se verifica. Se observa que antes de la evaluacin dela relacin comida, las variables E,P,D no han recibido todava ningn valor, loque no ocurre despus de la evaluacin. En el momento en el que E,P,D hanrecibido ciertos valores, por ejemplo:

E = antipasto

P = milanesa

D = flan

se procede a evaluar la segunda parte de la pregunta,

pescado(P) con el valor asignado a la variable P, entonces, esta

seleccin se ha convertido en:

pescado(milanesa)


14/64


Pag.14

Al no contener la base ninguna declaracin como sta, el juego de valorespropuesto para E,P,D no satisface la pregunta: es un fallo y se intenta con lasolucin siguiente para comida.

Finalmente, el programa imprime las 18 soluciones posibles:

E=antipasto, P=congrio, D=flan

E=antipasto, P=congrio, D=helado

E=antipasto, P=congrio, D=fruta

E=antipasto, P=pejerrey, D=flan

.....

E=sopa, P=congrio, D=flan

E=sopa, P=congrio, D=helado

.....

E=quesos, P=pejerrey, D=fruta

Para tener en cuenta:

Para satisfacer una conjuncin de relaciones, se examinan de izquierda aderecha.

Durante la ejecucin, ciertas variables pueden recibir un valor. Si una variablerecibe un valor, todas sus apariciones (o ms precisamente sus ocurrencias)toman el mismo valor.

Las variables son locales a la regla en la que aparecen. Cada vez que se utilizauna regla, se tiene una nueva instancia de sus variables, exactamente igualcomo se hace para las variables locales en los lenguajes clsicos deprogramacin. En este caso, se dice que las variables de la regla han sidorenombradas.

En una relacin no hay distincin entre argumentos de entrada y argumentos desalida. Por tanto, una misma relacin puede tratarse de diversas formas: si todossus argumentos son conocidos slo hay que verificar si la relacin se satisface ono; si algunos de sus argumentos son desconocidos (representados porvariables), se calcula el conjunto de valores que se puede asignar a estosargumentos para satisfacer la relacin.

La ejecucin es no determinista: se calculan todos los juegos de valores deargumentos que satisfacen la relacin.


15/64


Pag.15

Este men podra completarse con la informacin calrica de cada racin decada plato, con un predicado que podra tener la siguiente forma:

calorias(, ).

que se interpreta como: "la racin de aporta caloras".As, deber escribirse un hecho para todos y cada uno de los distintos platosque posee el men (antipasto, sopa, milanesa, pejerrey, flan, etc.), indicandocuntas caloras contiene cada uno, lo que queda de ejercicio para el lector. Conesto se podr averiguar el valor calrico total de una comida completa. Para estoltimo se puede definir la relacin:

valor(E,P,D,V) :- calorias(E,X), calorias(P,Y), calorias(D,Z), V = X+Y+Z.

donde V es la suma de las caloras de los componentes de una comida. Paraconocer estos valores se pregunta:

:- comida(E,P,D), valor(E,P,D,V).

lo que buscara todas las combinaciones posibles de comidas y calculara suvalor calrico total.

Ahora sera natural definir el concepto de comida equilibrada, cuando el valor

calrico de una comida no excede las 800 caloras. La definicin de esta relacinqueda como ejercicio para el alumno.

5. BUSCANDO LAS SOLUCIONES

Hasta ahora hemos venido manejando slo objetos constantes, representadospor sus nombres (pejerrey, pollo_asado, etc.). Sin embargo, la estructura queProlog maneja ms naturalmente es el rbol. Las relaciones y sus argumentosse tratan como rboles, debido a que es una estructura suficientementepoderosa para representar informaciones complejas, organizadas

jerrquicamente, y de manejo sencillo, tanto desde un punto de vista algebraico

como desde un punto de vista informtico.

Si representamos en forma de rbol uno de nuestros primeros ejemplos,es_padre_de(pablo, juan) que indica que Pablo es padre de Juan, tendramosalgo como:

es_padre_de

juan pablo


16/64


Pag.16

Esta estructura, como veremos, es tambin utilizada a la hora de buscar lassoluciones a los goals de un programa.

5.1. EL CONTROL EN PROLOG

Por control se entiende la forma en que el lenguaje busca las respuestas a lasclusulas objetivos. En Prolog, el control respeta dos normas:

1. Orden de metas. Escoger la meta del extremo izquierdo.

2.Orden de reglas. Seleccionar la primera regla aplicable.

Qu significa esto? La primera de las normas nos indica que, cuando laclusula objetivo o goal posee ms de una regla unidas por conjunciones odisyunciones, estas se toman de izquierda a derecha para ser resueltas de auna, mediante la aplicacin de reglas.

Entonces, si volvemos al primer ejemplo del men de un restaurante, pararesponder a la pregunta

:- comida(E,P,D), pescado(P).

Prolog toma en primer lugar la meta del extremo izquierdo (que escomida(E,P,D)) y la resuelve, para tomar luego la segunda de izquierda a

derecha (que es pescado(P)) y resolverla, y as sucesivamente hasta terminarcon todas las submetas de la clusula objetivo.

La segunda de las normas enunciadas ms arriba quiere decir que, pararesolver cada una de las submetas, stas son reemplazadas por todas y cadauna de las reglas de la base de datos que las satisfagan, teniendo en cuenta elorden en que estn escritas. As, por ejemplo, la primera de las submetas queProlog toma (comida(E,P,D)), es reemplazada por el consecuente de la primerregla que la satisface, que es

comida(E,P,D) :- entrada(E), plato_principal(P), postre(D).

y sobre sta se vuelven a aplicar ambas normas, o sea que se toma entrada(E)y luego se la reemplaza por la primer regla que la satisfaga (si la hay), que eneste caso sera

entrada(antipasto).

con lo que E asume un primer valor tentativo (antipasto) que puede ser o novlido, dependiendo de todas las otras partes del goal. A la forma en que se vanrealizando los reemplazos la veremos con mayor detalle a continuacin, y es latcnica conocida como backtracking o 'vuelta atrs'.


17/64


Pag.17

Concluyendo, podemos decir que si se tienen en cuenta las dos normas con quese maneja Prolog para encontrar las soluciones, se advierte que la respuesta auna pregunta se ve afectada por el orden de las metas dentro de la consulta y

por el orden de las clusulas dentro de la base de datos de hechos y reglas. Esmuy importante tener esto en cuenta ya que, debido a un orden errneo en ladeclaracin de las reglas o a una pregunta mal formulada, se pueden producirciclos infinitos.

5.2. EL BACKTRACKING

Para obtener las soluciones a las clusulas objetivo solicitadas, Prolog utilizauna tcnica de borrado que consiste en reemplazar cada submeta por los

consecuentes de todas las reglas de la base que la satisfacen. Para poder haceresto utiliza el backtracking, que es el mecanismo para la bsqueda de datos deProlog, totalmente invisible para el usuario.

De esta forma se verifica si existe cierto hecho determinado o si se cumple algngoal. Este mecanismo consiste en recorrer reiteradamente las clusulas,tratando de establecer si el objetivo actual puede considerarse como verdaderoo falso.

Entonces, si poseemos tres reglas P, Q y R, que son de la siguiente manera:

P :- p1, p2,..., pm. (m>=0)P :- a1, a2,..., an. (n>=0)

Q :- q1, q2,..., qs. (s>=0)

R :- r1, r2,..., rt. (t>=0)

donde P est definida de dos formas (recordar la definicin de plato_principal), yrealizamos la pregunta

:- P, Q, R.

Prolog busca la solucin, aplicando el borrado de las submetas, respetando lasdos normas del control indicadas ms arriba. As, toma la primera submeta de laizquierda (P) y la borra, esto quiere decir que la reemplaza por la primera reglade la base que la satisfaga, con lo que nuestra pregunta original ser ahora:

:- p1, p2,..., pm, Q, R.

Con esto se borra P, y se contina realizando lo mismo con las submetas delnuevo objetivo, hasta que no quede nada para borrar o hasta que se llegue aalgo que no puede ser borrado. Esto ocurre cuando se llega a un hecho o


18/64


Pag.18

cuando se alcanza una contradiccin. De este modo, se borrara p1, luego p2, yas hasta terminar.

Sin embargo, todava quedan posibilidades abiertas que no fueron tenidas encuenta durante el proceso, como ser la segunda definicin de P. Entonces sevuelve atrs, se reconsidera la ltima eleccin y se intenta borrar el trmino encuestin de otra manera para tratar de obtener otra respuesta a la pregunta.Entonces, se toma la segunda definicin de la regla P de la base de reglas (P :-a1, a2,..., an.) obteniendo, en este caso,

:- a1, a2,..., an, Q, R.

para borrar luego nuevamente todas las submetas del nuevo objetivo,incluyendo Q y R. Se contina as hasta que no quede ningn punto de eleccin

sin tener en cuenta. Es importante observar que en el momento en que seefecta una nueva eleccin para intentar borrar una submeta, se deshacentodas las asignaciones y modificaciones realizadas a las dems submetas, entrela eleccin anterior y el momento actual. Esta vuelta atrs o retroceso es lo quese denomina backtracking.

Para comprender ms claramente este funcionamiento, veremos un ejemplo.

Retomaremos el caso del men del restaurante donde poseemos, entre otras,las siguientes reglas:

R1 carne(milanesa).

R2 carne(bife_de_chorizo).

R3 carne(pollo_asado).

R4 pescado(congrio).

R5 pescado(pejerrey).

R6 plato_principal(P) :- carne(P).

R7 plato_principal(P) :- pescado(P).

donde R1,..., R7 slo se agregan para numerar las reglas, y realizaremos lasiguiente pregunta (conjunto inicial de metas):

:- plato_principal(P), Pmilanesa.

que equivale a decir cules son los platos_principales que no son milanesa. Sedebe tener en cuenta que Prolog trata a todos los operadores (incluyendo a -


19/64


Pag.19

distinto a-) como reglas comunes, por lo que este goal posee dos reglas unidaspor una conjuncin (y).

El proceso de resolucin ser representado mediante un rbol, en el cual:

A cada nodo se le asocia el conjunto actual de las metas a borrar y el conjuntode restricciones actuales C;

A cada rama se le asocia la regla elegida para borrar la primer submeta del nodosuperior;

Los sucesores de un nodo son los nuevos conjuntos de objetivos generados porel borrado del primero de ellos de la lista asociada al nodo considerado.

Esta rama es la que queda formada apenas Prolog comienza el anlisis de lapregunta. Lo primero que se hace es, partiendo desde el nodo de ms arribahacia abajo, borrar plato_principal(P), reemplazndolo por el consecuente de laprimera regla que lo satisface, que es la regla R6. O sea que se permuta elantecedente plato_principal(P) por su definicin relacional:

carne(P)

Este borrado de la primer submeta cambia nuestra pregunta inicial, que es loque vemos en el segundo nodo, siendo ahora el objetivo:

:- carne(P), Pmilanesa.

Ahora debe borrarse nuevamente la primer submeta de este nuevo goal.Entonces se reemplaza carne(P) por la regla R1, que es la primera que lasatisface. Llegamos as altercer nodo donde se presenta una restriccin, ya quela clusula R1 asigna ala variable P el valor milanesa. En este nodo nos quedala nueva clusula objetivo

:- Pmilanesa.

En esta nueva meta vemos que ya no aparece nada de la primer submeta quehemos borrado, como sucedi al pasar del nodo inicial al segundo nodo por la

rama R6. Esto se debe a que llegamos a un hecho (R1) que se borra dejandonicamente la restriccin ya indicada. Entonces, respetando dicha restriccin, Ptoma el valor milanesa y obtenemos:

:- milanesamilanesa.

abreviado en el grfico como milmil, que al borrarse (solucionarse) produce unfallo.

Esto es lo que ocurre al realizarse los borrados de las submetas. Sin embargo,


20/64


Pag.20

todava no se consideraron otras reglas que podan reemplazar a las submetasborradas, ya que la base posee dos reglas que definen el plato principal y tresque definen el plato de carne. Aqu es donde aparece el backtracking retroceso).

Como la ltima regla que se borr, teniendo otras posibilidades, fue carne(P), serealiza el retroceso subiendo un nodo desde el tercero y se vuelve a borrar estasubmeta utilizando las otras opciones. En prime ra instancia se toma R2 que esla regla que sigue en la base, para luego repetir el proceso tomando R3. Estosborrados nos determinan el siguiente rbol:

R6

R1 R2 R3

Falk xito xito

P = bif P = pollEste segundo rbol es el que queda luego de hacer el backtracking para todaslas diferentes definiciones del predicado carne( ). Aqu observamos que sepresentaron dos xitos, dos valores de P que son vlidos. Estos valores sernlos que Prolog nos ir mostrando en la ventana de resultados, de la siguientemanera:

P = bife_de_chorizo

P = pollo_asado

Despus de este retroceso, Prolog intenta borrar de una manera diferente todaslas submetas borradas en pasos anteriores. En este ejemplo, se puede utilizar lasegunda definicin de plato_principal( )para realizar el backtracking. As seampla el rbol para llegar finalmente a :

plato principal (p), pmilanesaC = { }

carne (p), pmilanesaC =

mil milC = {p= mil}

bif milC = {p= bif

poll milC = {p= poll}


21/64


Pag.21

R6 R7

R1 R2 R3 R4 R5

Falk xito xito xito Exito

P = bif P = poll P = con P = pej

En esta nueva rama, se utiliza R7 para borrar la primer submeta de la clusulaobjetivo original, y se borra la nueva submeta de las dos maneras posibles (R4 yR5).

Hemos encontrado as, a travs de esta tcnica, las cuatro soluciones posiblesque se vern como

P = bife_de_chorizo

P = pollo_asado

P = congrio

P = pejerrey

Para finalizar, se debe decir que cada rama del rbol se sigue extendiendo haciaabajo hasta que ocurre alguna de las siguientes cosas:

La clusula objetivo del nodo actual est vaca. En este caso nos encontramosfrente a un xito y la respuesta es la restriccin actual C.

Se llega a alguna situacin donde una submeta no puede ser borrada(solucionada), por no existir una regla que lo permita. Esto es un fracaso.

Ante ninguna de estas situaciones se parara el proceso ya que ste se detienenicamente cuando se han revisado todas las opciones posibles de borrado. Lounico que provocan es el abandono de la rama donde se present dicha

plato principal (p), pmilanesaC = { }

carne (p), pmilanesaC = { }

pescado (p), pmilanesaC = { }

mil milC = = mil}

bif milC = = bif}

poll milC = = oll}

con milC = = con}

pej milC = = e }


22/64


Pag.22

circunstancia, con un xito o un fallo, y el intento de abrir otra rama mediante elbacktracking.

Un ejemplo del primero de estos casos es el nodo

donde, al borrar la meta bife_de_chorizomilanesa, nos queda el goal vaco,siendo esto un xito cuya solucin es la restriccin C.

Como ejemplo para el segundo caso podemos tomar el nodo

que tiene una meta que no se puede borrar, ya que el operador slo se borracuando sus argumentos son distintos. Entonces, como tenemos un objetivo queno podemos borrar, estamos frente a un fallo y se debe abandonar esta rama delrbol e intentar por otra utilizando el backtracking.

Otra explicacin, muy sencilla y con un ejemplo fcil de entender es la queencontramos en el sitio http://www.javiersuarezsanz.com/prolog/ y que citamos acontinuacin textualmente:

El mecanismo empleado por PROLOG para satisfacer las cuestiones que se le plantean, es el de razonamiento haciaatrs (backward) complementado con la bsqueda en profundidad (depth first) y la vuelta atrs reevaluacin(backtracking).Razonamiento hacia atrs: Partiendo de un objetivo a probar, busca las aserciones que pueden probar el objetivo. Si enun punto caben varios caminos, se recorren en el orden que aparecen en el programa, esto es, de arriba a abajo y deizquierda a derecha.Reevaluacin: Si en un momento dado una variable se instancia con determinado valor con el fin de alcanzar unasolucin, y se llega a un camino no satisfactorio, el mecanismo de control retrocede al punto en el cual se instanci lavariable, la des-instancia y si es posible, busca otra instanciacin que supondr un nuevo camino de bsqueda.Se puede ilustrar esta estrategia sobre el ejemplo anterior:Supongamos la pregunta:

?-puede_casarse_con(maria,X).PROLOG recorre la base de conocimiento en busca de un hecho que coincida con la cuestin planteada. Lo que halla esla regla

puede_casarse_con(X,Y) :- quiere_a(X,Y), varon(X), hembra(Y).producindose una coincidencia con la cabeza de la misma, y una instanciacin de la variable X de la regla con elobjeto 'maria'. Tendremos por lo tanto:

(1) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), varon(maria), hembra(Y).A continuacin, se busca una instanciacin de la variable Y que haga cierta la regla, es decir, que verifique los hechosdel cuerpo de la misma. La nueva meta ser:

(2) quiere_a(maria,Y).De nuevo PROLOG recorre la base de conocimiento. 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 doshechos una vez instanciada la variable Y:

varon(maria), hembra(enrique).Se recorre de nuevo la base de conocimiento, no hallando en este caso ninguna coincidencia con el hecho'varon(maria)'. Por lo tanto, PROLOG recurre a la vuelta atrs, desistanciando valor de la variable Y, y retrocediendocon el fin de encontrar una nueva instanciacin de la misma que verifique el hecho (2). Un nuevo recorrido de la basede hechos da como resultado la coincidencia con:

bif milC = = bif}

mil milC = = mil}


23/64


Pag.23

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:

varon(maria), hembra(susana).

De nuevo se produce un fallo que provoca la desinstanciacin de la variable Y, as como una vuelta atrs en busca denuevos hechos que coincidan con (2).Una nueva reevaluacin da como resultado la instanciacin de Y con el objeto 'ana' (la ltima posible), y un nuevo falloen el hecho 'varon(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 atrs y una nueva bsqueda en la base de conocimiento que tiene como resultado lacoincidencia 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 laregla. La primera coincidencia corresponde al hecho

quiere_a(maria,enrique).que provoca la instanciacin de la variable Y con el objeto 'enrique'. PROLOG tratar de probar ahora el resto delcuerpo de la regla con las instanciaciones actuales:

hembra(maria), varon(enrique).

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

X = enriqueMore (Y/N): y

De esta forma se generarn el resto de las soluciones, si las hubiera.[NOTA: Algunas implementaciones PROLOG incorporan los comandos 'trace' y 'notrace' que activan y desactivan lasalida por pantalla del proceso de bsqueda. No es el caso de PDPROLOG.]

Conclusin:PROLOG utiliza un mecanismo de bsqueda independiente de la base de datos. Aunque pueda parecer algo retorcido,

es una buena estrategia puesto que garantiza el proceso de todas las posibilidades. Es til para el programador conocerdicho mecanismo a la hora de depurar y optimizar los programas.

5.3. EL CORTE (!)

Hemos visto que el borrado de un trmino del goal se hace en forma nodeterminista. Esto significa que se tienen en reserva en todo momento losdiversos puntos de eleccin que se superaron para un posible retrocesoposterior. La introduccin del corte (representado en Turbo Prolog por un !) enuna regla permite suprimir algunos de estos puntos de eleccin, e incluso, hacer

un programa enteramente determinista.

Para comprender esto se deben tener en cuenta dos puntos

Cada vez que se borra una meta, sta se coloca en la secuencia de puntos deeleccin, para poder realizar los retrocesos.

El borrado de la meta del corte !' devuelve verdadero y suprime todos lospuntos de eleccin que estaban almacenados, impidiendo el retroceso de lassubmetas anteriores a su aparicin.


24/64


Pag.24

Por ejemplo, si encerramos entre corchetes los puntos de eleccin que vamossuperando y al lado de stos colocamos la lista de metas actual, al caso ya vistolo podemos modificar agregndole un corte como ltima meta

:- plato_principal(P), Pmilanesa, !.

cuya secuencia de elecciones y metas a borrar ser

[] plato_principal(P), Pmilanesa, !.

borrando la primer submeta por medio de R6 obtenemos un punto de eleccin yotra submeta

[plato_principal(P)] carne(P), Pmilanesa, !.

por medio de R1 borramos carne(P) y obtenemos

[plato_principal(P) carne(P)] milanesamilanesa, !.

lo que provoca un fallo y se retrocede al punto de eleccin precedente,quitndoselo de la lista

[plato_principal(P)] carne(P), Pmilanesa, !.

se vuelve a borrar carne(P), esta vez por medio de R2, obteniendo

[plato_principal(P) carne(P)] bife_de_chorizomilanesa, !.ahora se borra el operador sin introducir nuevas elecciones, quedando slo

[plato_principal(P), carne(P)] !.

El ! se borra suprimiendo todas las elecciones en espera, no queda nada paraborrar y, por haberse eliminado todos los puntos de eleccin que haba, no esposible realizar ningn retroceso. Por consiguiente, el rbol anterior se convierteen :

R6

R1 R2

plato principal (p), pmilanesa, !C =

carne (p), pmilanesa, !C =

mil mil, !C = {p= mil}

bif mil, !C = = bif

Aqu se eliminan todos los puntosde eleccin que se estabanalmacenando, por lo que no sepodr retroceder por encima deeste nodo.


25/64


Pag.25

Falk xito

P = bif

El borrado del ! tiene el efecto de suprimir todas las elecciones en espera, por loque no se produce ms de una respuesta a la pregunta, que es la primeraobtenida.

Si el corte en vez de ponerse al final se hubiera ubicado en otro lugar, porejemplo

:- plato_principal(P), !, Pmilanesa.

el rbol tendra la siguiente forma:

Falk

Cuando se llega al ! se eliminan todos los puntos de eleccin que se

almacenaban

para poder hacer los retrocesos, por lo que no se pueden buscar ms solucionesy no se encuentra ninguna respuesta que satisfaga la pregunta. El resultadodevuelto por esta consulta ser False (Falso).

!C = = bif

plato principal (p),!, pmilanesaC = }

carne (p),!, pmilanesaC =

!, mil milC = = mil

Aqu se eliminan todos los puntos de eleccinque se estaban almacenando, por lo que no sepodr retroceder por encima de este nodo.


26/64


Pag.26

5.4. LA NEGACIN COMO FRACASO

Para comprender cmo trabaja la negacin en Prolog, se debe tener en cuentaque las reglas y el borrado pueden ser vistos de la siguiente manera:

Las reglas de un programa son un conjunto de definiciones.

Un objetivo que se borra es una frmula verdadera en relacin con estasdefiniciones.

En efecto, borrar un objetivo equivale a demostrar que, para determinadosvalores de las variables, este objetivo se verifica. Por lo tanto, una consultacomo not(P), donde not() es el operador de negacin del Prolog de Edimburgo,se trata como verdadera si el sistema fracasa en borrar P, o sea que equivale a

decir 'Si no puedo probarlo debe ser falso'. Esto significa que no existe ladefinicin de P para el conjunto de valores que posee como argumentos y por lotanto no puede ser borrado.

Debe tenerse en cuenta que not() puede utilizarse nicamente para verificarvalores conocidos o que se conocan antes de aplicar el not().

5.5. REALIZANDO EL SEGUIMIENTO DE UN PROGRAMA

Turbo Prolog posee cuatro ventanas, una de las cuales est titulada comoTrace.

Esta ventana sirve para realizar el seguimiento de los pasos que realiza Prologdurante la resolucin de las clusulas objetivos planteadas.

Si deseamos seguir paso a paso o realizar la traza de un programa, agregamosla instruccin Trace como primer instruccin al comienzo del cdigo. De estaforma, el programa se parar despus de cada paso realizado y nos mostrar enesta ventana lo que se ha realizado, indicando las llamadas a las distintasreglas, los valores retornados y los puntos donde se realiza el retroceso. Paraprobar esto, realice el seguimiento de los ejemplos utilizados para explicar elbacktracking y el corte.

6. ESTRUCTURA DE UN PROGRAMA EN PROLOG

Un programa en turbo-Prolog consta de cuatro secciones: domains,predicates, goal y clauses. Cabe aclarar que todas estas son palabrasreservadas, y que toda otra palabra menos las variables deben escribirse enminsculas.


27/64


Pag.27

DOMAINS (dominio): Aqu se definen los objetos y los tipos de datos

correspondientes que usaremos en las definiciones posteriores:

domains

objeto = tipo de dato

Tipos de datos: Existen cinco tipos predefinidos :

symbol : Hay dos tipos de smbolos :

Una secuencia de letras, nmeros o caracteres de subrayado en la cual laprimera letra es minscula. Ej. : tiene_lindas_piernas.

Una secuencia de caracteres encerrados por comillas dobles () usada en elcaso que el smbolo contenga espacios o no comience con minsculas. Ej. :

Una persona es trabajadora.

char : Acepta cualquier carcter, se representa encerrado entre comillas simples() y consta de un solo carcter, por ejemplo A, 2, /.

integer : Acepta nmeros enteros en el rango de -32768 al 32767.

real : Acepta nmeros reales, pueden contener signo, punto decimal y variosdgitos decimales. Tambin pueden tener una parte exponencial, pudiendoabarcar nmeros desde +1e-307 a +1e+308, por ejemplo : 427054, -25000,86.25, - 8.525e-203 o - 8411.25658545.

string : Acepta una secuencia de caracteres encerrados entre comillas dobles (),por ejemplo : esto tambin es un string. La diferencia entre el tipo symbol en 2,y los strings es la forma de representacin interna de cada uno. Elalmacenamiento de los smbolos est implementado de tal manera que subsqueda en las tablas de memoria es ms rpida. Adems, los smbolos, tienenproblemas para hacer inserciones en tiempo de ejecucin. Su uso estar

determinado por el tipo de aplicacin que se realice.Por ejemplo:

domains

persona = symbol persona es un objeto de tipo symbol.

PREDICATES (predicados): En esta seccin se definen como sern lasrelaciones entre los objetos del dominio (domains) y el valor que se les asignaren las clusulas (clauses).


28/64


Pag.28

En una relacin no se puede poner nada que no sea del tipo definido para ella,pues el compilador Turbo Prolog dar error al comprobar tipos distintos. Porejemplo :

predicates

sabe (persona)

Aqu especificamos que el predicado sabe tiene un argumento: persona, quea su vez en el dominio est declarado como symbol.

intelijente(persona).

trabaja(persona).

En este ejemplo hemos definido un objeto como smbolo y luego lo relacionamoscon el predicado sabe. Tambin podemos definir un predicado solo conrelacionar tipos predefinidos, como por ejemplo :

factorial (integer, real)

Esto hace que la relacin factorial se establezca entre 2 objetos, uno de tipoentero y otro de tipo real.

GOAL (meta u objetivo a buscar): En esta seccin es donde se indicaexplcitamente cul es el objetivo o propsito del programa. Hay dos formas

bsicas de trabajar en Prolog :

Goal interno : Especificando en el programa en su seccin Goal un hecho averificar. En este caso el mecanismo de bsqueda se detiene al encontrar elprimer valor que lo cumpla, necesitando una indicacin explcita de impresin enpantalla para su representacin o visualizacin, si no est esa indicacin,responde slo con un mensaje de True o False, o no imprime mensajes.

Goal externo : Trabajando a travs de la ventana de dilogo sin la seccin Goalen el programa, verificando y consultando hechos en forma interactiva. En estecaso el mecanismo entrega todos los valores que lo verifiquen, y la bsqueda se

detendr slo al agotarse las clusulas pertinentes. No necesita de rdenesespeciales para vis ualizar los valores de variables hallados.

Trabajando de cualquiera de las dos formas los objetivos podrn ser tancomplicados como informacin se tenga en las clusulas.

Siguiendo con el ejemplo, en nuestro caso el objetivo ser encontrar unapersona que trabaja, da acuerdo al criterio de determinacin para ello que seestablecer en la seccin Clauses.


29/64


Pag.29

trabaja (X) and

write (La persona que trabaja es, X) and n1

Aqu vemos que hay algunos predicados que nosotros no definimos, como serwrite y n1. Ambos pertenecen a los llamados predicados predefinidos y sonpropios del lenguaje Prolog. write hace lo mismo que idntica instruccin enPascal o el print de BASIC : imprime un texto en la pantalla. n1 imprimesolamente una secuencia de fin de lnea.

El propsito de todo el conjunto es evaluar trabaja (X) e imprimir el resultadode ello con el mensaje entre comillas.

Las respuestas se darn a travs de la ventana de dilogos o se deber armar

una interfaz diferente.CLAUSES (Clusulas o definiciones de reglas y hechos): Aqu se definen lasreglas y hechos que evaluar Turbo Prolog para encontrar las soluciones que sepiden en Goal o por la ventana de Dilogos. Poniendo en castellano qu valoresasignamos a los predicados de nuestro ejemplo :

Jos sabe Ana sabe trabaja el que sabe

y en turbo prolog :

clauses

sabe (Jos)

sabe (Ana)

trabaja (X) if sabe (X)

trabaja (X) if sabe (X) se trata de una regla. Las reglas pueden tambin tenerms de una condicin para verific arse. Si por ejemplo nosotros ahoradecidiramos que una persona para trabajar debe ser inteligente adems desaber, reemplazaramos la anterior por la siguiente regla :

trabaja (X) if sabe (X) and inteligente (X)

Veamos el ejemplo completo, escribie ndo un programa en Prolog en el quedeterminaremos como tiene que ser una persona para trabajar en una oficina :

domainspersona = symbol

predicatessabe (persona).trabaja (persona).inteligente (persona).


30/64


Pag.30

tiene_lindas_piernas (persona).goal

trabaja (X) and

write ("La persona que trabaja es ",X).clausessabe(jose).sabe(ana).inteligente(ana).inteligente(carlos).inteligente(silvia).tiene_lindas_piernas(silvia).trabaja (X) if sabe (X).

Si cargamos en el editor el programa anterior y lo compilamos, veremos los

resultados como lo indica la figura siguiente.

Presionando la barra espaciadora volver al men principal.

Si en nuestro ejemplo no existiera la seccin Goals, tras compilar el programase activara la ventana de dilogos en que pondremos los hechos que queremoscomprobar o consultar. Nos aparecer en esa ventana lo siguiente :

Goal :_

Si nosotros ponemos este objetivo para nuestro ejemplo :


31/64


Pag.31

inteligente (Carlos)

y presionamos ENTER es como si hubiramos preguntado es Carlos

inteligente, o para ser mas exactos con la terminologa de la programacinlgica el objeto Carlos cumple la relacin inteligente. Como existe en la partede las clusulas un hecho idntico, inmediatamente veremos como respuesta lapalabra TRUE y volver a pedirnos otro Goal.

Si ponemos ahora : inteligente (Jos) la respuesta ser False pues buscar enlas clusulas esa relacin y no la encontrar.

Podemos poner adems por ejemplo preguntas como :

sabe (Ana)

tiene_lindas_piernas (Ana)

inteligente (Silvia)

Estas preguntas pueden efectuarse siempre y cuando exista esa relacindefinida en la seccin de predicados y tenga tambin al menos una clusula conese nombre y cantidad de argumentos. Todas las preguntas de este tipo sellaman objetivos simples de verificacin de hechos pues su respuesta es trueo false.

Recordando que en Prolog toda palabra que tiene la primera letra en mayscula

es una variable, veamos que ocurre si preguntamos lo siguiente :

trabaja (Quien)

La respuesta ser entonces :

Quien = Jos

Quien = Ana

2 solutions.

La diferencia en la respuesta se debe a la diferencia entre los objetivos internosy externos, como ya vimos: Si el objetivo est incluido en el programa (en laseccin Goal), el mecanismo de bsqueda se detiene al encontrar el primer valorque lo cumpla. Si el objetivo es exterior al programa (ingresando por ventanaDialogo), la bsqueda se detendr slo al agotarse las clusulas pertinentes.

En el caso del objetivo sabe (Quien) la mecnica es la siguiente : Prolog buscasi la relacin est declarada en los predicados, luego ve que tenga igualcantidad de argumentos y asume que Quien es un smbolo por definicin de larelacin ; va entonces a las clusulas buscando aquellas de mismo nombre derelacin. Entonces Prolog instancia Quien al valor de la clusula. En otras


32/64


Pag.32

palabras : la variable Quien asume por primera vez el valor del argumento de laclusula (llamado vinculacin de un valor a una variable o binding), e informa atravs de la ventana de dilogos que ha encontrado una instancia de la

pregunta, informa de ella y el valor temporal que ha asumido la variable ycontinua recorriendo las clusulas hasta el final. Prolog devolver as uno trasotro todos los casos que hagan verdad al objetivo, y su nmero. En el caso queninguna instancia cumpla con los hechos de las clusulas, Prolog devolverFalse.

Vemos as la importancia del orden en que se registran las clusulas en unprograma Prolog. Si hubiramos invertido el orden de los hechos en el programaoriginal, la respuesta hubiera sido :

La persona que trabaja es Ana

Hagamos ahora la siguiente pregunta :

inteligente (Ana) and sabe (Ana)

Aqu tenemos una pregunta de dos trminos, inteligente (Ana) y sabe (Ana),unidospor una operacin lgica de multiplicacin , and. La pregunta en lgicaes : cumple el objeto Ana las relaciones inteligente y sabe ?. Prolog primerove si se cumple la primera parte de la pregunta, si da verdadero (True), ve si secumple la segunda y devuelve el resultado de la multiplicacin lgica (and). Ennuestro caso, al cumplirse las dos da True. Si uno de los dos trminos da falsola respuesta es False

Otros operadores lgicos son el or que nos da la suma lgica, y el not,negacin lgica. Todas las preguntas de este tipo las llamaremos Objetivoscompuestos de verificacin de hechos.

Ejemplos de objetivos de verificacin compuestos que dan True para nuestrocaso en estudio son, entre otros :

inteligente (Carlos) and inteligente (Silvia)

trabaja (Jos) o trabaja (Carlos)

tiene_lindas_piernas (Silvia) and (not sabe (Silvia))

Formulemos a continuacin la siguiente pregunta :

inteligente (X) and not (sabe (X))

Prolog tomar el primer trmino y buscar el primer valor del primer objeto quecumpla esta condicin y lo reemplazar en el segundo trmino. Si compruebaque tambin se cumple devolver True.


33/64


Pag.33

En otras palabras : Prolog busca la primera clusula con nombre inteligente yreemplaza X con el valor del argumento de esta clusula, que en este caso esCarlos. Luego trata de comprobar la pregunta not (sabe (Carlos)) ;

comprueba sabe (Carlos) , que por no existir da False, y tras aplicar not larespuesta ser True. Este valor, junto con la respuesta del primer trmino queda True, verifica la regla y devuelve la instancia X con el valor asignadotemporalmente Carlos.

Vemos que la diferencia entre reglas y hechos es que mientras los hechosdescriben una situacin clara, que no necesita comprobarse, las reglas por logeneral son objetivos compuestos que deben verificarse. Por ejemplo lassiguientes reglas :

jefe (X) if inteligente (X) and not (trabaja (X))

jefe (X) if inteligente (X) and not (sabe (X))

Ambas describen la misma situacin : X es jefe si es inteligente y no trabaja ono sabe, ya que si no sabe no trabaja.

Tomemos un segundo ejemplo para otra serie de explicaciones.

domainsmarca, color = symbolmodelo = integer

precio, kilometraje = realpredicatesauto (marca, kilometraje, modelo, color, precio)

clausesauto (peugeot_404,90000,1980,azul,15000)auto (ford_taunus,13800,1986,rojo,30000)auto (renault_12,90000,1984,gris,25000)auto (dodge_1500,13000,1983,rojo,12000)auto (volkswagen,39000,1985,rojo,20000)

Podemos ver que hemos relacionado mas de un elemento en un predicado. Asun auto tiene marca, kilometraje, modelo, color y precio. Con este ejemploveremos mejor el tratamiento de variables y objetivos compuestos.

Carguemos en memoria y compilemos este programa, y luego formulemos la

siguiente pregunta :

Cuales son los datos de los autos cuyo precio es menor a 20000 ?

En Prolog puede escribirse as :

auto (Marca, Kilmetros, Modelos, Color, Precio) and Precio < 20000


34/64


Pag.34

Como se ve, Marca, Kilmetros, Modelo, Color y Precio son variables porcomenzar con maysculas. Cmo funciona Prolog aqu ?. Toma la primeraclusula del predicado auto e instancia cada una de las variables a su

correspondiente valor. De no ser compuesta la pregunta nos devolvera losvalores hallados, pero en este caso comprobar si el Precio en esta clusula esmenor a 20000. De cumplirse emitir la lista de datos, en caso contrario no ;pero de cualquier modo seguir con la clusula siguiente con la mismaoperacin hasta el fin de las clusulas.

La respuesta ser :

Marca = peugeot_404 Kilmetros = 90000 Modelo = 1980 Color = azul

Marca = dodge_1500 Kilmetros = 13000 Modelo = 1983 Color = rojo

Analicemos la forma en que expresamos el objetivo. Aqu utilizamos un objetivocompuesto que consta de dos condiciones : un predicado que debe verificarsecomprobando los hechos de la seccin clusulas, y una variable que estlimitada en los valores posibles que puede tomar. Esta es una de las formas mscomunes y tiles de utilizar las variables para especificar condicionesadicionales para un objetivo, sin apelar a otros predicados o a formular reglasinnecesariamente complejas.

Ahora bien, qu puedo hacer si lo nico que quiero saber es la Marca de losautos cuyo precio es mayor a 215000 ? Aqu aparecen las llamadas variablesannimas representadas con el signo de subrayado (_) y significa que elargumento con la variable annima no interesa y puede contener cualquier tipode dato. Entonces la pregunta ser la siguiente :

auto (Marca,_,_,_,Precio) and Precio > 21500

La respuesta de Prolog ser :

Marca = ford_taunus Precio = 30000

Marca = renault_12 Precio = 25000

Donde nos devuelve slo los valores que nos interesan, obviando los demsparmetros y sus valores.

Debemos aqu hacer una advertencia sobre el uso de las llamadas variablesnombradas. Estas variables son posicionales, es decir que su valor dependerdel lugar que ocupan entre los argumentos del predicado. Si pre guntsemos :

auto (Marca,Precio,_,_,_) and Precio > 21500

La respuesta que podra tomarse equivocadamente como correcta sera :


35/64


Pag.35

Marca = renault_12 Precio = 90000

Marca = ford_taunus Precio = 13800

Otro error frecuente en el uso de estas variables es el siguiente. Supongamosque deseamos exhibir juntos aquellos autos que tengan el mismo color.Supongamos tambin que debemos exhibirlos de a dos a los de color rojo.Escribimos el Goal que genere todos los pares posibles que cumplan con estacondicin :

auto (Marca_1,_,_,rojo,_) and auto (Marca_2,_,_,rojo)

La respuesta de Prolog ser :

Marca_1 = ford_taunus Marca_2 = ford_taunus

Marca_1 = ford_taunus Marca_2 = dodge_1500

Marca_1 = ford_taunus Marca_2 = volkswagen

Marca_1 = dodge_1500 Marca_2 = ford_taunus

Marca_1 = dodge_1500 Marca_1 = dodge_1500

Marca_1 = dodge_1500 Marca_2 = volkswagen

Marca_1 = volkswagen Marca_2 = ford_taunusMarca_1 = volkswagen Marca_2 = dodge_1500

Marca_1 = volkswagen Marca_2 = volkswagen

Sin dudas esta no es la solucin que estbamos buscando. En lugar de unanica Intentemos ahora colocar el siguiente objetivo externo :

auto (Marca_1,_,_,rojo,_) and auto (Marca_2,_,_,rojo,_)

and Marca_1 Marca_2

Obteniendo la respuesta :

Marca_1 = ford_taunus Marca_2 = dodge_1500

Marca_1 = ford_taunus Marca_2 = volkswagen

Marca_1 = dodge_1500 Marca_2 = ford_taunus

Marca_1 = dodge_1500 Marca_2 = volkswagen


36/64


Pag.36

Marca_1 = volkswagen Marca_2 = ford_taunus

Marca_1 = volkswagen Marca_2 = dodge_1500

7. OBJETOS COMPUESTOS

El Turbo Prolog, adems de trabajar con objetos simples, permite trabajar conargumentos ms complejos, como vimos e el ejemplo anterior. Larepresentacin del conocimiento se puede simplificar utilizando objetos mscomplejos. Un hecho simple es de la forma :

predicado (arg_1, arg_2, ..., arg_N)

Ejemplo.

Trabaja (juan, panadera)

Trabaja (luis, taller)

Hay veces que necesitamos poner ms detalles, por ejemplo, podramos ponerel nombre del lugar donde trabajan, el nmero y la categora, para esto esconveniente utilizar los objetos compuestos, el ejemplo quedara :

trabaja (juan, panadera (sucursal, 12))

trabaja (luis, taller (seccin, 97, c))

Si observamos detenidamente el ejemplo notaremos que hay argumentos,panadera y taller, que estn actuando como predicados. A estos losdenominamos functores y a sus argumentos componentes.

Los hechos con objetos compuestos son de la forma :

predicado (argumento, functor (componente, componente))

Declaraciones de predicados y dominios para objetos compuestos : Si se decideutilizar objetos compuestos, hay que poner especial atencin en la declaracinde predicados y dominios. Es necesario declarar cada functor y los dominios detodos sus componentes.

Programa ejemplo, con la declaracin apropiada para objetos compuestos.

domains

lugar = panadera (nombre_area, nmero)

taller (nombre_area, nmero, categora)

nombre, nombre_area, categora = symbol


37/64


Pag.37

nmero = integer

predicates

trabaja (nombre, lugar)

clauses

trabaja (juan, panadera (sucursal, 12))

trabaja (luis, taller (seccin, 97, c))

- Ahora veremos que obtenemos con algunos objetivos externos

GOAL : trabaja (Quien, Donde)

Quien = juan, Donde = panadera (sucursal, 12)

Quien = luis, Donde = taller (seccion, 97, c)

GOAL : trabaje (Quien, taller (En, Nro, Categora))

Quien = luis, En = seccin, Nro = 97, Categoria = c

En estos dos objetivos externos podemos visualizar cmo, utilizando variables,se puede profundizar en los distintos niveles de los functores.

8. RECURSIVIDAD

Si del lado derecho de una clusula aparece en algn punto el mismo predicadoque figura del lado izquierdo, se dice que la clusula tiene llamado recursivo, esdecir se llama a s misma para verificar que se cumple esa misma propiedadcomo parte de la condicin que define a la regla, y sobre algn posible valor desus variables.

El uso de recursividad es muy comn y suele ser imprescindible para de algunamanera simular esquemas de iteracin implcitos.

Por ejemplo, si tenemos :

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

progenitor(X,Y) :- madre(X,Y)

que expresa que tanto X es padre de Y como X es madre de Y son condicionessuficientes para afirmar que X es progenitor de Y. Podemos definir :


38/64


Pag.38

antepasado(X,Y) :- progenitor (X,Y)

antepasado(X,Y) :- progenitor (X,Z), antepasado (Z,Y)

que dice que X es antepasado de Y si es progenitor de Y, o bien, si es progenitorde algn otro antepasado de Y. La palabra antepasado figura de ambos lados deuna de las reglas.

Supongamos ahora que contamos con una base de datos (hechos) que sonciudades, y deseamos hacer una lista de todos los caminos existentes de unaciudad a otra. Contamos para eso con rutas simples entre pares de ciudades.Por ejemplo :

ruta (BsAs, LaPlata)

ruta (BsAs, Jujuy)

ruta (Miramar, BahaBlanca)

ruta (BsAs, MardelPlata)

ruta (BsAs, Miramar)

ruta (MardelPlata, Miramar)

ruta (LaPlata, Miramar)

Digamos ahora que toda ruta es reversible, es decir si puedo ir de C1 a C2 (de laciudad 1 a la 2), podremos volver por la misma ruta de C2 a C1. Eso se escribeas en Prolog :

ruta (C1, C2) :- ruta (C2, C1)

Por ltimo, para definir cundo un camino existe, podemos atravesar ciudadesintermedias. Escribimos entonces :

camino (C1, C2) :- ruta (C1, C2)

camino (C1, C2) :- ruta (C1, C3), camino (C3, C2)

que dice que existe un camino de la ciudad C1 a la ciudad C2 si hay una ruta(predefinida) entre ambas, o bien si hay una ruta desde la ciudad C1 hacia unaciudad C3, y desde sta hasta la ciudad C2. Vale decir, el llamado recursivosignifica resolver el problema original mediante dar un paso hacia una posicinauxiliar y resolver el mismo problema desde esa posicin (se supone que elproblema se simplifica). Con estas definiciones, la respuesta ser afirmativa siconsultamos :

? camino (BahaBlanca, Jujuy)


39/64


Pag.39

Otro ejemplo, definamos ahora que es un nmero par (positivo). Sabemos que el0 es par, y que los dems pares se obtienen simplemente al ir sumando 2 apartir de un par conocido. Bien, prolog cuenta con tipos numricos y operaciones

elementales predefinidas.

Por ello, esto se puede lograr simplemente con :

par (0)

par (N) :- par (M), N = M + 2

que afirma que el 0 es par, y que si tenemos que M es par, entonces definiendoN = M + 2 ser tambin un nmero par.

No siempre la recursividad es buena o garantiza xito en una bsqueda desolucin. Por ejemplo si ponemos:

lindo (X) :- lindo (X)

muchas versiones de prolog entraran en un ciclo infinito, ya que para buscaralgo que sea lindo, la solucin es buscar algo que sea lindo, es decir el mismoproblema sin cambio.

Los siguientes ejemplos estn tomados del apunte de Paradigmas deprogramacin de nuestra misma facultad pero de la regional Buenos Aires yestn citados textualmente.

Tengo habitaciones conectadas entre s porpuertas (como en el DOOM), y quiero llegar de una habitacin a otra, esdecir, hallar un paso entre las habitaciones.Veo entonces las relaciones:

puerta(Habitacion1, Habitacion2)paso(Habitacion1, HabitacionN).

Como se define el paso?El paso entre dos habitaciones A y B es que haya una puerta entre las habitaciones (este es el CORTE DE LARECURSIVIDAD), o bien que haya una puerta entre A y otra habitacin C y que desde esta haya paso a B.

Por ejemplo:

puerta(cuarto, pasillo).puerta(pasillo, banio).puerta(pasillo, cocina).puerta(cocina, living).paso(Habitacion1, Habitacion2):- puerta(Habitacion1, Habitacion2).paso(Habitacion1, Habitacion2):- puerta(Habitacion1, Habitacion3),paso(Habitacion3,Habitacion2).

Otros ejemplos de funciones recursivas:

Objetos que estn apoyados en objetos:


40/64


Pag.40

Un objeto se encuentra sobre otro objeto si:Est apoyado en ese objeto (corte recursivo).

Est apoyado en algn objeto que est sobre el otro objeto.predicatesapoyado(symbol, symbol).sobre(symbol, symbol).

clausessobre(UnObj, OtroObj):- apoyado(UnObj, OtroObj), !.sobre(UnObj, OtroObj):- apoyado(UnObj, ObjAuxiliar), sobre(ObjAuxiliar, OtroObj).

Cosas dentro de cosas (idem).Personas atrs unas de otras (idem):

Una persona est detras de otra siEsta "justo atras" de la otra.Est detras de una persona que est "justo atras" de la otra.

Yo tengo un amigo que... si los amigos de mis amigos son mis amigos entonces...

amigo(Yo, Otro):- MiAmigo(Yo, Otro),!.amigo(Yo, Otro):- MiAmigo(Yo, AlguienMas), amigo(AlguienMas, Otro).

9. LISTAS

Listas : es un conjunto de elementos encerrados entre corchetes y separadospor comas. Una lista de smbolos sera de la forma [elem_1, elem_2, ...,elem_N]. La lista vaca se representa con dos corchetes, [ ].

La manera ms sencilla de escribir listas es enumerar sus elementos. La listaque consta de tres tomos a, b y c puede escribirse como :

[ a, b, c ]

Tambin podemos especificar una secuencia inicial de elementos y una listarestante, separadas por |. La lista [a,b,c] tambin puede escribirse como :

[a, b, c | [ ] ]

[a, b | [c] ]

[a, | [b, c] ]

Un caso especial de esta notacin es una lista con cabeza H y cola T,representada como [H | T]. La cabeza puede usarse para extraer loscomponentes de una lista, de manera que no se requieren operadoresespecficos para extraer la cabeza y la cola. La solucin a la consulta :


41/64


Pag.41

? - [H | T] = [a, b, c]

T = [b, c]

H = a

asocia la variable H con la cabeza y la variable T con la cola de la lista [a,b,c]. Laconsulta :

? - [a | T] = [H, b, c]

T = [b, c]

H = a

ilustra la capacidad de Prolog para manejar trminos especificadosparcialmente. El trmino [a | T] es la especificacin parcial de una lista concabeza a y cola desconocida, denotada por la variable T. En forma similar, [H, b,c] es la especificacin parcial de una lista con cabeza H desconocida y cola [b,c]. Para unificar estas dos especificaciones, H debe denotar a a y T debedenotar a [b, c].

En Turbo Prolog es necesario declarar el dominio de toda lista que se maneje enun programa. No es complicado, solo se agrega un asterisco junto a la definicindel tipo de elementos de la lista. Quedara as :

domains

lista_enteros = integer *

El manejo de listas en Turbo Prolog es muy simple, teniendo en cuenta quedivide la lista en solo dos partes : cabeza y cola.

- Cabeza : es el primer elemento de la izquierda

- Cola : es el resto de la lista (es tambin una lista)

Las listas pueden pasarse como argumento, solo hay que encerrarlas entre

parntesis, o sea: predicado ([lista_1], [lista_2], ..., [lista_N])

Como vimos anteriormente, en Turbo Prolog se pueden hacer estructurascomplejas. Se pueden poner objetos compuestos dentro de objetos compuestos.De la misma manera se pueden poner listas dentro de listas, es decir que cadaelemento de la lista puede ser a su vez una lista.

Todo esto que aparenta ser un tanto complicado, es en realidad muy simple, dehecho, unas de las grandes ventajas que tiene las listas en prolog es su fasilmanejo. En trminos generales, la mecnica es:


42/64


Pag.42

Definir en los dominios (domains) la lista con su tipo de datos asociado.

Definir un predicado para recorrer la lista.

Definir al menos dos clusulas, una recursiva que indica como recorrer lalista pasa como argumentos cabeza y colo de la misma y eventualmentealgunas variables mas y...

Otra clusula que indica que hacer con una lista vaca.

Todo se ve mas claro cuando cundo vamos a los hechos... veamos un ejemplode un problema resuelto con listas y sin listas.

Supongamos tener una lista de materias del ciclo bsico y del ciclo superior.

Ciclo Bsico Ciclo Superior

geografa diseo

anatoma clculo

historia literatura

geometra taller

botnica tecnologa

Para ver si una materia pertenece a uno u otro ciclo superior, se podra hacer unlistado de hechos simples que los describan:

domainsmateria = symbol

predicatesciclo_basico (materia)ciclo_superior (materia)

clausesciclo_basico (geografa)ciclo_basico (anatoma)

ciclo_basico (historia)ciclo_basico (geometra)ciclo_basico (botnica)ciclo_superior (diseo)ciclo_superior (clculo)ciclo_superior (literatura)ciclo_superior (taller)ciclo_superior (tecnologa)

Ahora, si nosotros quisiramos agregar ms materias, tendramos que agregaruna clusula por cada materia que se agregue.


43/64


Pag.43

Trabajando con listas esto no es necesario, adems las definiciones recursivasde miembro hacen lo mismo y en menos espacio.

Ejemplo :domains

lista_materia = materia *materia = symbol

predicatesciclo_basico (materia).ciclo_superior (materia).miembro (materia, lista_materia).

clausesciclo_basico (X) :- miembro (X, [geografia, anatomia, historia, geometria, botanica]).ciclo_superior (X) :- miembro (X, [diseno, calculo, literatura, taller, tecnologia]).miembro (X, [A|B]) :- X = A or miembro (X,B).

La figura siguiente muestra el programa en jecucin.

En este ejemplo se ve claramente como las listas reemplazan a los predicados.

En las dos primeras clusulas se define una materia como perteneciente a unciclo, si Las otras dos clusulas son la definicin recursiva de miembropertenece a la respectiva lista.

Introduciendo el objetivo ciclo_superior(diseo) obtendremos como resultadoYES.


44/64


Pag.44

No ha sido necesario incluir una clusula que indique que hacer con la listavaca porque solo necesitamos que de cmo resultado No, pero en losejemplos resueltos de la parte prctica nmeros 12, 13, 14 y 15 encontrar este

tipo de clusulas.


45/64


46/64


Pag.46

barbara es amiga de juan.

barbara es amiga de mara.

susana es amiga de pedro.

Se debe escribir un programa que permita individualizar a los sospechosos del

asesinato de susana. Para ello considerar como sospechosos a :

a. Los hombres que tuvieron amistad con susana.

b. Las mujeres que tuvieron relacin con hombres que susana conoca.

c. Los amigos de mujeres que tuvieron relacin con hombres que susana

conoca.

3. Considerar los siguientes predicados

PERSONA (nombre, sexo, edad)

MAYOR_EDAD (nombre, nombre)

y sabiendo que :

pedro tiene 30 aos

ana tiene 10 aos

jorge tiene 60 aos

juan tiene 20 aos

luis tiene 28 aos

alejandra tiene 43 aosescribir un programa que permita identificar a las personas mayores de ciertaedad, identificndolas como hombres o mujeres.

4. En base a los siguientes predicados :

padres ()

masc (nombre)


47/64


Pag.47

fem (nombre)

y considerando el siguiente grfico de informacin se pide :

a. Que hijos tiene Alicia.

b. Que hermanos tiene Juan.

c. Que hermanas tiene Armando.

d. Quines son los antepasados de Monica.

e. Quienes son los parientes de Silvia.

f. Interpretar lazos como : tos, cuados, primos y matrimonios.

5. Desarrolle un programa que pueda decir quienes son los que llegan seguros asus casas despus de una fiesta y quienes no, en donde deber probar si puedehacerlo sin ayuda, o con ayuda, siendo este ltimo carcter probable a travs deque : Existe

unidad vi - paradigma logico

Documents