-= INTRODUCCION AL PROLOG =- Javier Su rez Sanz, Abril 1.996 -=-=-=-=-=-=-=-= C O N T E N I D O =-=-=-=-=-=-=-=- 1. Introducci¢n. 1.1 La Quinta Generaci¢n. 1.2 Programaci¢n Logica. 2. El lenguaje de programaci¢n PROLOG. 2.1 Hechos. 2.2 Variables. 2.3 Reglas. 2.4 Operadores. 3. Programaci¢n b sica en PROLOG. 3.1 Un ejemplo sencillo. 3.2 Introduccion al PD-PROLOG. 3.3 La resoluci¢n de objetivos. 4. El mecanismo de control de PROLOG. 5. Programaci¢n avanzada. 5.1 Operadores especiales. 5.2 Estructuras de datos: las listas. 5.3 Recursividad. 5.4 Entrada/Salida. -=-=-=-=-=-=--=-=-=-=-=-=--=-=-=-=-=-=--=-=-=-=-=-=--=-=-=-=-=-=- -------------------- > 1. INTRODUCCION. < -------------------- 1.1. LA QUINTA GENERACION. -------------------------- En Octubre de 1981, el gobierno japon‚s y m s concretamente el Ministerio Japon‚s de Comercio Internacional e Industria (MITI), anuncia la puesta en marcha de un proyecto revolucionario equiparable a la carrera del espacio norteamericana. Est n dispuestos a ofrecer al mundo la siguiente generaci¢n, la Quinta Generaci¢n de Ordenadores. Unas m quinas de Inteligencia Artificial que pueden pensar, sacar conclusiones, emitir juicios e incluso comprender las palabras escritas y habladas. Con este fin se crea el ICOT (Institute for New Generation Computer Technology) constituido por cuarenta brillantes investigadores de las m s importantes empresas, y se les dota con todos los medios necesarios para construir la nueva clase de supercomputadoras. El papel del PROLOG. -------------------- La Quinta Generaci¢n prev‚ m quinas dise¤adas para el tratamiento l¢gico, de capacidades an logas a las capacidades de anteriores generaciones de ordenadores para tratar operaciones aritm‚ticas. Se trata de ordenadores que tienen el PROLOG como lenguaje nativo (lenguaje m quina), con capacidad para procesar millones de inferencias l¢gicas por segundo (LIPS). 1.2. PROGRAMACION LOGICA. ------------------------- La programaci¢n l¢gica es un paradigma de los lenguajes de programaci¢n en el cual los programas se consideran como una serie de aserciones l¢gicas. De esta forma, el conocimiento se representa mediante reglas, trat ndose de sistemas _declarativos_. Una representaci¢n declarativa es aqu‚lla en la que el conocimiento est  especificado, pero en la que la manera en que dicho conocimiento debe ser usado no viene dado. El m s popular de los sistemas de programaci¢n l¢gica es el PROLOG. La programaci¢n l¢gica en PROLOG. --------------------------------- Un programa escrito en PROLOG puro, es un conjunto de cla£sulas de Horn. Sin embargo, PROLOG, como lenguaje de programaci¢n moderno, incorpora m s cosas, como instrucciones de Entrada/Salida, etc. Una cla£sula de Horn puede ser ¢ bien una conjunci¢n de hechos positivos ¢ una implicaci¢n con un £nico consecuente (un £nico termino a la derecha). La negaci¢n no tiene representaci¢n en PROLOG, y se asocia con la falta de una afirmaci¢n (negaci¢n por fallo), seg£n el modelo de _suposici¢n de un mundo cerrado_ (CWA); solo es cierto lo que aparece en la base de conocimiento ¢ bien se deriva de esta. Las diferencias sint cticas entre las representaciones l¢gicas y las representaciones PROLOG son las siguientes: 1. En PROLOG todas las variables est n impl¡citamente cuantificadas universalmente. 2. En PROLOG existe un s¡mbolo explicito para la conjunci¢n "y" (,), pero no existe uno para la disyunci¢n "o", que se expresa como una lista de sentencias alternativas. 3. En PROLOG, las implicaciones p --> q se escriben alrev‚s q :- p, ya que el interprete siempre trabaja hacia atr s sobre un objetivo, como se vera m s adelante. ------------------------------------------ > 2. EL LENGUAJE DE PROGRAMACION PROLOG. < ------------------------------------------ PROLOG puede encontrarse en m£ltiples versiones diferentes. La m s popular es la definida por Clocksin y Mellish, y es la que se tratar  aqu¡. Afortunadamente, al ser tan sencilla la sintaxis del PROLOG, las variaciones entre distintas implementaciones son m¡nimas. Elementos de un programa PROLOG. -------------------------------- 2.1 HECHOS. ----------- Expresan relaciones entre objetos. Supongamos que queremos expresar el hecho de que "un coche tiene ruedas". Este hecho, consta de dos objetos, "coche" y "ruedas", y de una relaci¢n llamada "tiene". La forma de representarlo en PROLOG es: tiene(coche,ruedas). * Los nombres de objetos y relaciones deben comenzar con una letra min£scula. * Primero se escribe la relaci¢n, y luego los objetos separados por comas y encerrados entre par‚ntesis. * Al final de un hecho debe ir un punto (el car cter "."). El orden de los objetos dentro de la relaci¢n es arbitrario, pero debemos ser coherentes a lo largo de la base de hechos. 2.2. VARIABLES. --------------- Representan objetos que el mismo PROLOG determinar . Una variable puede estar _instanciada_ ¢ _no instanciada_. Estar  instanciada cuando existe un objeto determinado representado por la variable. De este modo, cuando preguntamos "¨ Un coche tiene X ?", PROLOG busca en los hechos cosas que tiene un coche y responder¡a: X = ruedas. instanciando la variable X con el objeto ruedas. * Los nombres de variables comienzan siempre por una letra may£scula. Un caso particular es la variable an¢nima, representada por el car cter subrayado ("_"). Es una especie de comod¡n que utilizaremos en aquellos lugares que deber¡a aparecer una variable, pero no nos interesa darle un nombre concreto ya que no vamos a utilizarla posteriormente. 2.3. REGLAS. ------------ Las reglas se utilizan en PROLOG para significar que un hecho depende de uno ¢ mas hechos. Son la representaci¢n de las implicaciones l¢gicas del tipo p ---> q (p implica q). * Una regla consiste en una cabeza y un cuerpo, unidos por el signo ":-". * La cabeza est  formada por un £nico hecho. * El cuerpo puede ser uno ¢ mas hechos (conjunci¢n de hechos), separados por una coma (","), que act£a como el "y" l¢gico. * Las reglas finalizan con un punto ("."). La cabeza en una regla PROLOG corresponde al consecuente de una implicaci¢n l¢gica, y el cuerpo al antecedente. Este hecho puede conducir a errores de representaci¢n. Supongamos el siguiente razonamiento l¢gico: tiempo(lluvioso) ----> suelo(mojado) suelo(mojado) Que el suelo est‚ mojado, es una condici¢n suficiente de que el tiempo sea lluvioso, pero no necesaria. Por lo tanto, a partir de ese hecho, no podemos deducir mediante la implicaci¢n, que est‚ lloviendo (pueden haber regado las calles). La representaci¢n *correcta* en PROLOG, ser¡a: suelo(mojado) :- tiempo(lluvioso). suelo(mojado). Advi‚rtase que la regla esta "al rev‚s". Esto es as¡ por el mecanismo de deducci¢n hacia atr s que emplea PROLOG. Si cometi‚ramos el *error* de representarla como: tiempo(lluvioso) :- suelo(mojado). suelo(mojado). PROLOG, partiendo del hecho de que el suelo est  mojado, deducir¡a incorrectamente que el tiempo es lluvioso. Para generalizar una relaci¢n entre objetos mediante una regla, utilizaremos variables. Por ejemplo: Representaci¢n l¢gica | Representaci¢n PROLOG ----------------------------------+------------------------------------ es_un_coche(X) ----> | tiene(X,ruedas) :- tiene(X,ruedas) | es_un_coche(X). Con esta regla generalizamos el hecho de que cualquier objeto que sea un coche, tendr  ruedas. Al igual que antes, el hecho de que un objeto tenga ruedas, no es una condici¢n suficiente de que sea un coche. Por lo tanto la representaci¢n inversa ser¡a incorrecta. El  mbito de las variables. --------------------------- Cuando en una regla aparece una variable, el _ mbito_ de esa variable es £nicamente esa regla. Supongamos las siguientes reglas: (1) hermana_de(X,Y) :- hembra(X), padres(X,M,P), padres(Y,M,P). (2) puede_robar(X,P) :- ladron(X), le_gusta_a(X,P), valioso(P). Aunque en ambas aparece la variable X (y la variable P), no tiene nada que ver la X de la regla (1) con la de la regla (2), y por lo tanto, la instanciaci¢n de la X en (1) no implica la instanciacion en (2). Sin embargo todas las X de *una misma regla* s¡ que se instanciar n con el mismo valor. 2.4. OPERADORES. ---------------- Son predicados predefinidos en PROLOG para las operaciones matem ticas b sicas. Su sintaxis depende de la posici¢n que ocupen, pudiendo ser infijos ¢ prefijos. Por ejemplo el operador suma ("+"), podemos encontrarlo en forma prefija '+(2,5)' ¢ bien infija, '2 + 5'. Tambi‚n disponemos de predicados de igualdad y desigualdad. X = Y igual X \= Y distinto X < Y menor X > Y mayor X =< Y menor ¢ igual X >= Y mayor ¢ igual Al igual que en otros lenguajes de programaci¢n es necesario tener en cuenta la _precedencia_ y la _asociatividad_ de los operadores antes de trabajar con ellos. En cuanto a precedencia, es la t¡pica. Por ejemplo, 3+2*6 se eval£a como 3+(2*6). En lo referente a la asociatividad, PROLOG es asociativo por la izquierda. As¡, 8/4/4 se interpreta como (8/4)/4. De igual forma, 5+8/2/2 significa 5+((8/2)/2). El operador 'is'. ----------------- Es un operador infijo, que en su parte derecha lleva un t‚rmino que se interpreta como una expresi¢n aritm‚tica, contrast ndose con el t‚rmino de su izquierda. Por ejemplo, la expresi¢n '6 is 4+3.' es falsa. Por otra parte, si la expresi¢n es 'X is 4+3.', el resultado ser  la instanciaci¢n de X: X = 7 Una regla PROLOG puede ser esta: densidad(X,Y) :- poblacion(X,P), area(X,A), Y is P/A. ------------------------------------- > 3. PROGRAMACION BASICA EN PROLOG. < ------------------------------------- 3.1 UN EJEMPLO SENCILLO. ------------------------ Con los datos que conocemos, ya podemos construir un programa en PROLOG. Necesitaremos un editor de textos para escribir los hechos y reglas que lo componen. Un ejemplo sencillo de programa PROLOG es el siguiente: >=================================================================== quiere_a(maria,enrique). quiere_a(juan,jorge). quiere_a(maria,susana). quiere_a(maria,ana). quiere_a(susana,pablo). quiere_a(ana,jorge). varon(juan). varon(pablo). varon(jorge). varon(enrique). hembra(maria). hembra(susana). hembra(ana). teme_a(susana,pablo). teme_a(jorge,enrique). teme_a(maria,pablo). /* Esta linea es un comentario */ quiere_pero_teme_a(X,Y) :- quiere_a(X,Y), teme_a(X,Y). querido_por(X,Y) :- quiere_a(Y,X). puede_casarse_con(X,Y) :- quiere_a(X,Y), varon(X), hembra(Y). puede_casarse_con(X,Y) :- quiere_a(X,Y), hembra(X), varon(Y). >=================================================================== Una vez creado, lo salvaremos para su posterior consulta desde el interprete PROLOG. Un programa PROLOG tiene como extensi¢n por defecto '.PRO'. Le daremos el nombre 'relacion.pro'. 3.2 INTRODUCCION AL PROLOG DE A.D.A. (AUTOMATA DESIGN ASSOCIATES). ------------------------------------------------------------------ Este curso se basa en el A.D.A. PROLOG y m s concretamente en su versi¢n de Dominio Publico PDPROLOG, disponible en ASTURIAS-BBS con el nombre PROLOG19.ARC. Una vez descomprimido, encontramos un archivo ejecutable con nombre PDPROLOG.EXE. Lo ejecutamos y nos aparecer  la informaci¢n referente al autor y versi¢n del programa (1.9). A continuaci¢n aparece el s¡mbolo ?- Se trata del prompt del PROLOG, que nos indica que est  dispuesto para recibir comandos. Un comando *siempre* debe finalizar con un punto ("."). [NOTA: En ning£n caso podremos introducir reglas ¢ hechos directamente en el prompt ?- puesto que PDPROLOG no dispone de un editor incorporado] ALGUNOS COMANDOS BASICOS: * consult. ---------- El predicado _consult_ est  pensado para leer y compilar un programa PROLOG ¢ bien para las situaciones en las que se precise a¤adir las cl usulas existentes en un determinado fichero a las que ya est n almacenadas y compiladas en la base de datos. Su sintaxis puede ser una de las siguientes: consult(fichero). consult('fichero.ext'). consult('c:\ia\prolog\fichero'). * recon. -------- El predicado _recon_ es muy parecido a _consult_, con la salvedad de que las cla£sulas existentes en el fichero consultado, reemplazan a las existentes en la base de hechos. Puede ser £til para sustituir una £nica cla£sula sin consultar todas las dem s, situando esa cla£sula en un fichero. Su sintaxis es la misma que la de _consult_. [NOTA: El predicado _recon_ puede encontrarse como _reconsult_ en otras implementaciones de PROLOG, tal como se indica en Clocksin & Mellish.] *forget. -------- Tiene como fin eliminar de la base de datos actual aquellos hechos consultados de un fichero determinado. Su sintaxis es: forget(fichero). * exitsys. ---------- Este predicado nos devuelve al sistema operativo. 3.2 LA RESOLUCION DE OBJETIVOS. ------------------------------- Ya hemos creado un programa PROLOG [relacion.pro] y lo hemos compilado en nuestro interprete PROLOG [consult(relacion)]. A partir de este momento podemos interrogar la base de datos, mediante consultas. Una consulta tiene la misma forma que un hecho. Consideremos la pregunta: ?-quiere_a(susana,pablo). PROLOG buscar  por toda la base de datos hechos que _coincidan_ con el anterior. Dos hechos coinciden si sus predicados son iguales, y cada uno de sus correspondientes argumentos lo son entre s¡. Si PROLOG encuentra un hecho que coincida con la pregunta, responder  yes. En caso contrario responder  no. Adem s, una pregunta puede contener variables. En este caso PROLOG buscara por toda la base de hechos aquellos objetos que pueden ser representado por la variable. Por ejemplo: ?-quiere_a(maria, Alguien). [NOTA: Alguien es un nombre perfectamente v lido de variable, puesto que empieza por una letra mayuscula.] El resultado de la consulta es: Alguien = enrique More (Y/N): El hecho 'quiere_a(maria,enrique).' coincide con la pregunta al instanciar la variable Alguien con el objeto 'enrique'. Por lo tanto es una respuesta valida, pero no la £nica. Por eso se nos pregunta si queremos obtener m s respuestas. En caso afirmativo, obtendr¡amos: Alguien = susana More (Y/N):y Alguien = ana More (Y/N):y No. ?- Las consultas a una base de datos se complican cuando estas est n compuestas por conjunciones ¢ bien intervienen reglas en su resoluci¢n. Conviene, por lo tanto, conocer cu l es el mecanismo de control del PROLOG, con el fin de comprender el porqu‚ de sus respuestas. ------------------------------------------ > 4. EL MECANISMO DE CONTROL DEL PROLOG. < ------------------------------------------ El mecanismo empleado por PROLOG para satisfacer las cuestiones que se le plantean, es el de _razonamiento hacia atr s_ (backward) complementado con la _b£squeda en profundidad_ (depth first) y la _vuelta atras_ ¢ _reevaluaci¢n_ (backtracking). Razonamiento hacia atr s: Partiendo de un objetivo a probar, busca las aserciones que pueden probar el objetivo. Si en un punto caben varios caminos, se recorren en el orden que aparecen en el programa, esto es, de arriba a abajo y de izquierda a derecha. Reevaluaci¢n: Si en un momento dado una variable se instancia con determinado valor con el fin de alcanzar una soluci¢n, y se llega a un camino no satisfactorio, el mecanismo de control retrocede al punto en el cual se instanci¢ la variable, la des-instancia y si es posible, busca otra instanciaci¢n que supondr  un nuevo camino de b£squeda. Se puede ilustrar esta estrategia sobre el ejemplo anterior: Supongamos la pregunta: ?-puede_casarse_con(maria,X). PROLOG recorre la base de datos en busca de un hecho que coincida con la cuesti¢n planteada. Lo que halla es la regla puede_casarse_con(X,Y) :- quiere_a(X,Y), varon(X), hembra(Y). produci‚ndose una coincidencia con la cabeza de la misma, y una instanciaci¢n de la variable X de la regla con el objeto 'maria'. Tendremos por lo tanto: (1) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), varon(maria), hembra(Y). A continuaci¢n, se busca una instanciaci¢n de la variable Y que haga cierta la regla, es decir, que verifique los hechos del cuerpo de la misma. La nueva meta ser : (2) quiere_a(maria,Y). De nuevo PROLOG recorre la base de datos. En este caso encuentra un hecho que coincide con el objetivo: quiere_a(maria,enrique). instanciando la variable Y con el objeto 'enrique'. Siguiendo el orden dado por la regla (1), quedan por probar dos hechos una vez instanciada la variable Y: varon(maria), hembra(enrique). Se recorre de nuevo la base de datos, no hallando en este caso ninguna coincidencia con el hecho 'varon(maria)'. Por lo tanto, PROLOG recurre a la vuelta atr s, desistanciando valor de la variable Y, y retrocediendo con el fin de encontrar una nueva instanciaci¢n de la misma que verifique el hecho (2). Un nuevo recorrido de la base de hechos da como resultado la coincidencia con: quiere_a(maria,susana). Se repite el proceso anterior. La variable Y se instancia con el objeto 'susana' y se intentan probar los hechos restantes: varon(maria), hembra(susana). De nuevo se produce un fallo que provoca la desinstanciaci¢n de la variable Y, as¡ como una vuelta atr s en busca de nuevos hechos que coincidan con (2). Una nueva reevaluaci¢n da como resultado la instanciaci¢n de Y con el objeto 'ana' (la £ltima posible), y un nuevo fallo en 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 atr s y una nueva b£squeda en la base de datos que tiene como resultado la coincidencia con la regla: (3) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), hembra(maria), varon(Y). Se repite todo el proceso anterior, buscando nuevas instanciaciones de la variable Y que verifiquen el cuerpo de la regla. La primera coincidencia corresponde al hecho quiere_a(maria,enrique). que provoca la instanciaci¢n de la variable Y con el objeto 'enrique'. PROLOG tratar  de probar ahora el resto del cuerpo de la regla con las instanciaciones actuales: hembra(maria), varon(enrique). Un recorrido de la base de datos, da un resultado positivo en ambos hechos, quedando probado en su totalidad el cuerpo de la regla (3) y por lo tanto su cabeza, que no es m s que una de las soluciones al objetivo inicial. X = enrique More (Y/N): y De esta forma se generar n el resto de las soluciones, si las hubiera. [NOTA: Algunas implementaciones PROLOG incorporan los comandos 'trace' y 'notrace' que activan y desactivan la salida por pantalla del proceso de b£squeda. No es el caso de PDPROLOG.] Conclusi¢n: ----------- PROLOG utiliza un mecanismo de b£squeda 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 conocer dicho mecanismo a la hora de depurar y optimizar los programas. ----------------------------- > 5. PROGRAMACION AVANZADA. < ----------------------------- Hasta ahora hemos visto los aspectos fundamentales de PROLOG necesarios para crear sencillos programas (¢ sistemas expertos). A continuaci¢n se comentan algunos mecanismos que nos permitir n crear programas mas avanzados. 5.1 OPERADORES ESPECIALES. -------------------------- El operador "corte". -------------------- El operador corte, representado por el s¡mbolo "!" nos da un cierto control sobre el mecanismo de deducci¢n del PROLOG. Su funci¢n es la de controlar el proceso de reevaluaci¢n, limit ndolo a los hechos que nos interesen. Supongamos la siguiente regla: regla :- hecho1, hecho2, !, hecho3, hecho4, hecho5. PROLOG efectuar  reevaluaciones entre los hechos 1, 2 sin ning£n problema, hasta que se satisface el hecho2. En ese momento se alcanza el hecho3, pudiendo haber a continuaci¢n reevaluaciones de los hechos 3, 4 y 5. Sin embargo, si el hecho3 fracasa, no se intentara de ninguna forma reevaluar el hecho2. Una interpretaci¢n pr ctica del significado del corte en una regla puede ser que "si has llegado hasta aqu¡ es que has encontrado la £nica soluci¢n a este problema y no hay raz¢n para seguir buscando alternativas". Aunque se suele emplear como una herramienta para la optimizaci¢n de programas, en muchos casos marca la diferencia entre un programa que funciona y otro que no lo hace. El operador "not". ------------------ Se define de tal forma que el objetivo not(X) se satisface solo si fracasa la evaluaci¢n de X. En muchos casos, puede sustituir al operador corte, facilitando la lectura de los programas. Por ejemplo: a :- b, c. a :- not(b), d. Equivale a: a :- b, !, c. a :- d. Sin embargo, en t‚rminos de coste, el operador corte es m s eficiente, ya que en el primer caso PROLOG intentar  satisfacer b dos veces, y en el segundo, solo una. 5.2 ESTRUCTURAS DE DATOS: LISTAS -------------------------------- La lista es una estructura de datos muy com£n en la programaci¢n no num‚rica. Es una secuencia ordenada de elementos que puede tener cualquier longitud. Ordenada significa que el orden de cada elemento es significativo. Un elemento puede ser cualquier t‚rmino e incluso otra lista. Se representa como una serie de elementos separados por comas y encerrados entre corchetes. Para procesar una lista, la dividimos en dos partes: la cabeza y la cola. Por ejemplo: Lista Cabeza Cola ----- ------ ---- [a,b,c,d] a [b,c,d] [a] a [] (lista vac¡a) [] no tiene no tiene [[a,b],c] [a,b] [c] [a,[b,c]] a [[b,c]] [a,b,[c,d]] a [b,[c,d]] Para dividir una lista, utilizamos el s¡mbolo "|". Una expresi¢n con la forma [X | Y] instanciar  X a la cabeza de una lista e Y a la cola. Por ejemplo: p([1,2,3]). p([el,gato,estaba,[en,la,alfombra]]). ?-p([X|Y]). X = 1, Y = [2,3] More (Y/N):y X = el, Y = [gato,estaba,[en,la,alfombra]] 5.3 LA RECURSIVIDAD. -------------------- La recursividad es un mecanismo que da bastante potencia a cualquier lenguaje de programaci¢n. Veamos un ejemplo de programaci¢n recursiva que nos permitir  determinar si un  tomo es miembro de una lista dada: (1) miembro(X,[X|_]). (2) miembro(X,[_|Y]) :- miembro(X,Y). La regla (1) es el caso base de la recursi¢n. Se evaluar  como cierta siempre que coincida la variable X con la cabeza de la lista que se pasa como argumento. En la regla (2) est  la definici¢n recursiva. X es miembro de una lista si lo es de la cola de esa lista (la cabeza se comprueba en la regla (1)). La regla (1) es una simplificaci¢n de la regla: miembro(X,[Y|_]) :- X = Y. La traza para el caso de 'miembro(b,[a,b,c]).' es la siguiente: (1) miembro(b,[a,b,c]) :- b = a. ---> no. (2) miembro(b,[a,b,c]) :- miembro(b,[b,c]). (1) miembro(b,[b,c]) :- b = b. ---> yes. Si necesitamos conocer la longitud de una lista, emplearemos una funci¢n recursiva como la siguiente: longitud([],0). longitud([_|Y],L1) :- longitud(Y,L2), L1 is L2 + 1. Otro ejemplo muy t¡pico de funci¢n recursiva es el del factorial de un n£mero: factorial(0,1) :- !. factorial(X,Y) :- X1 is X-1, factorial(X1,Y1), Y is X*Y1. 5.4 ENTRADA/SALIDA. ------------------- PROLOG, al igual que la mayor¡a de lenguajes de programaci¢n modernos incorpora predicados predefinidos para la entrada y salida de datos. Estos son tratados como reglas que siempre se satisfacen. * write. -------- Su sintaxis es: write('Hello world.'). Las comillas simples encierran constantes, mientras que todo lo que se encuentra entre comillas dobles es tratado como una lista. Tambi‚n podemos mostrar el valor de una variable, siempre que est‚ instanciada: write(X). * nl. ----- El predicado nl fuerza un retorno de carro en la salida. Por ejemplo: write('linea 1'), nl, write('linea 2'). tiene como resultado: linea 1 linea 2 * read. ------- Lee un valor del teclado. La lectura del comando read no finaliza hasta que se introduce un punto ".". Su sintaxis es: read(X). Instancia la variable X con el valor leido del teclado. read(ejemplo). Se eval£a como cierta siempre que lo tecleado coincida con la constante entre par‚ntesis (en este caso 'ejemplo'). -=-=-=-=-=-=--=-=-=-=-=-=--=-=-=-=-=-=--=-=-=-=-=-=--=-=-=-=-=-=- F I N