Paradigma Lógico Francisco Bórquez Departamento de Informática Universidad Técnica Federico Santa María Marzo,2009

Definiciones Básicas - Predicado Proposición: sentencia lógica que puede ser verdadera o falsa. Se construye de objetos y relaciones. Lógica formal provee métodos para verificar su validez Lógica Simbólica: permite expresar proposiciones, relaciones entre proposiciones y  cómo inferir nuevas proposiciones que son verdaderas. Cálculo de Predicado: Forma particular de lógica simbólica usada en programación lógica.

Objetos y Términos Compuestos Objetos se representan como un único término, que puede ser: constante : representa un único objeto variable : puede representar diferentes objetos Término compuesto: consiste de functor y una lista de parámetros Un término con n parámetros se denomina n- tupla. El término padre(maria, jesús) es una 2-tupla.

Proposiciones pueden ser: Atómicas: corresponde a un único término compuesto Compuestas: dos o más proposiciones atómicas conectadas por operadores lógicos. Una proposiciones puede ser: Hecho: se define como una verdad (axioma) Consulta: la verdad debe ser probada (teorema)

Proceso de Resolución Presencia de variables requiere de un proceso de calce (matching) que al reemplazar sus valores produce una verdad (éxito). Este proceso se denomina unificación. Asignación temporal de valores a variables se denomina instanciación. Fallas (no éxito) en la instanciación requiere de backtracking.

Sólo permite dos tipos de formas: Cláusulas de Horn Cláusulas de Horn, son reglas de inferencia lógica, que simplifican el proceso de resolución, y permiten representar la mayoría de las proposiciones lógicas. Sólo permite dos tipos de formas: Existe sólo una proposición atómica en la izquierda de la cláusula (cláusula con cabeza) El lado izquierdo está vacío (cláusula sin cabeza) Cláusulas con cabeza se usan para definir reglas, en cambio cláusulas sin cabezas sólo establecen ciertos hechos.

Significado Declarativo versus Procedural La cláusula: P <= Q, R. Se interpreta declarativamente como: p es verdadero si Q y R lo son. De Q y R se deriva P. En cambio una interpretación procedural sería: Para resolver P, primero se debe resolver Q y luego R. Para satisfacer a P, primero se debe satisfacer Q y luego R.

Prolog está basado en el uso de cláusulas de Horn. Conclusiones Programación Lógica consiste básicamente en definir un conjunto de reglas y hechos (hipótesis). El sistema luego debe ser capaz de inferir si una determinada proposición (meta) es una verdad. Prolog está basado en el uso de cláusulas de Horn.

Características de Prolog Basado en Lógica y programación declarativa Produce estilo de programación orientado a metas No se especifica cómo debe hacerse, sino qué debe lograrse (alto nivel) El programador se concentra más en el conocimiento que en los algoritmos ¿Qué es conocido? (hechos y relaciones ) ¿Qué preguntar? (cómo resolverlo)

Hechos en Prolog: Ejemplo ana maria juan pedro carola paty aldo padre(maria, pedro). padre(juan, pedro). padre(juan, carola). padre(pedro, ana). padre(pedro, paty). padre(paty, aldo).

Consultas en Prolog ?- padre(pedro, ana). => yes ?- padre(ana, paty). => no ?- padre(X, carola). => X = juan ?- padre(pedro, X). => X = ana ; => X = paty ;

Consulta: Ejemplo 1 Preguntar por el abuelo de aldo: X, Y : (X es padre de Y)  (Y es padre de aldo) que se expresa en Prolog como: ?- padre(X, Y), padre(Y, aldo). => X = pedro Y = paty

Consulta: Ejemplo 2 Preguntar por los nietos de juan: X, Y : (juan es padre de X)  (X es padre de Y) que se expresa en Prolog como: ?- padre(juan, X), padre(X, Y). => X = pedro Y = ana ; Y = paty

Consulta: Ejemplo 3 Preguntar si ana y paty tienen un padre en común: X : (X es padre de ana)  (X es padre de patricio) que se expresa en Prolog como: ?- padre(X, ana), padre(X, paty). => X = pedro

Otros Hechos femenino(maria). masculino(juan). masculino(pedro). Agregar cláusulas sobre el sexo de las personas (relaciones unarias): femenino(maria). masculino(juan). masculino(pedro). femenino(carola). femenino(ana). femenino(paty). masculino(aldo).

Alternativa de definición de hechos Podría haberse definido también con una relación binaria: sexo(maria, femenino). sexo(juan, masculino). sexo(pedro, masculino). sexo(carola, femenino). sexo(ana, femenino). sexo(paty, femenino). sexo(aldo, masculino). ¡A continuación usaremos la forma unaria!

se expresa en Prolog como: Reglas en Prolog La relación: a  b se expresa en Prolog como: a :- b. Una cláusula de este tipo se denomina regla, que tiene la siguiente estructura: la cabeza (parte izquierda de :- ) es la conclusión la proposición definida en el cuerpo (parte derecha de :- )

La relación hijo de corresponde a: que se expresa en Prolog como: Resolución Simple La relación hijo de corresponde a: X, Y : (Y es hijo de X)  (X es padre de Y) que se expresa en Prolog como: hijo(X, Y) :- padre(Y, X). Ejemplo: la meta siguiente es evaluada como: La meta: hijo(paty, pedro) se convierte en submeta padre(pedro, paty) Se busca este hecho: yes

Ejemplo de Reglas Se puede definir ahora varias nuevas reglas como: papa(X, Y) :- padre(X, Y), masculino(X). mama(X, Y) :- padre(X, Y), femenino(X). abuelo(X, Y) :- padre(X, Z), padre(Z, Y). hermana(X, Y) :- padre(Z, X), padre(Z, Y), femenino(X).

Ejemplo de Consulta ?- hermana(ana, paty). => yes ?- hermana(X, paty). => X = ana ; => X = paty oops ... paty es hermana de ella misma ¡Falta excluir este caso: hermana(X, Y) :- padre(Z, X), padre(Z, Y), femenino(X), X\=Y.

Resumiendo... Programas Prolog se extienden simplemente agregando más cláusulas Cláusulas son de tres tipos: hechos, reglas y consultas Reglas declaran cosas que cuya verdad depende de otras condiciones Por medio de consultas el usuario puede solicitar al programas que establezca qué cosas son verdad Una cláusula tiene una cabeza y un cuerpo. El cuerpo son metas separadas por comas (conjunción) Hechos son cláusulas que no tienen cuerpo Preguntas sólo tienen cuerpo Reglas tienen cabeza y cuerpo Una evaluación puede sustituir una variable X por otro objeto (se dice que X se instancia) Variables se cuantifican universalmente ()

Reglas Recursivas {X es padre de Z }  La relación antepasado se define sobre la base de una regla de descendencia directa y otra regla de descendencia indirecta: X, Z : (X es un antepasado de Z), si {X es padre de Z }  { Y: (X es padre de Y)  (Y es antepasado de Z) } Lo que en Prolog se expresa como : antepasado(X, Z) :- padre(X, Z). % descendiente directo antepasado(X, Z) :- padre(X, Y), antepasado(Y, Z). % descendiente ind.

Ejemplo de Consulta ?- antepasado (maria, X) % Consultar por los descendientes de maria ?- antepasado (maria, X) => X = pedro ; => X = ana ; => X = paty ; => X = aldo

Resolución de Consulta antepasado(juan, paty) padre(juan, paty) Regla#1 padre(juan, X) antepasado(X, paty) Regla#2 ana maria juan pedro carola paty aldo antepasado(pedro, paty) Hecho: padre(juan, pedro) X=pedro NO padre(pedro, paty) Regla#1 SI

Objetos de datos simples Objetos estructurados Objetos en Prolog Objetos de datos simples Objetos estructurados Calce de operaciones fundamentales sobre objetos

Reconocimiento de Tipos Se reconoce el tipo de un dato por su forma sintáctica; no se requiere de declaración de tipos Ejemplo: Variables se definen comienzan con primera en mayúsculas (e.g. X) Atomos comienzan con una letra en minúscula (e.g. pedro)

2) Strings de caracteres especiales 3) Strings con citación simple Atomos 1) Strings de letras, dígitos y underscore (_), comenzando con minúscula pedro nil x_25 algo_especial 2) Strings de caracteres especiales <----> ===> ... 3) Strings con citación simple ´Juan´ ´San Francisco´

Ámbito de variable es una cláusula Variables Strings de letras, dígitos y underscore, comenzando con mayúscula o underscore. X Resultado _X1 _12 Si una variable aparece una solo vez en una cláusula, se puede usar variables anónima _ ?- padre(juan, _). yes % no se imprime variable tiene_hijo(X) :- padre(X, _). Ámbito de variable es una cláusula

Ejemplo con Figuras Geométrica 2 4 6 8 P2 = (2,3) P1 = (1,1) (6,4) (7,1) (4,2) T S P1 = punto(1, 1) P2 = punto(2,3) S = seg(P1, P2) T = triangulo (punto(4,2), punto(6,4), punto(7,1))

Dos términos calzan si: Concepto de Calce La operación más importante sobre términos es el calce, que corresponde a la unificación en el cálculo de predicados. Dos términos calzan si: Son idénticos Las variables en ambos términos pueden ser instanciados, sustituyendo variables, tal que los términos se hacen idénticos.

Calzar: fecha(D, M, 2000) y fecha(D1, mayo, A1) , entonces: Ejemplo de Calce Calzar: fecha(D, M, 2000) y fecha(D1, mayo, A1) , entonces: D se instancia a D1 M se instancia a mayo A1 se instancia a 2000 Que como salida de Prolog se escribe: D = D1 M= mayo A1 = 2000

Ejemplo de Calce Calzar: fecha(D, M, 2000) y fecha(D1, julio, 1956) , entonces: No es posible encontrar un calce (se dice que el proceso de calce ha fracasado). En caso contrario, se dice que el proceso ha sido exitoso.

Ejemplo de Calce en Prolog ?- fecha(D, M, 2000) = fecha(D1, mayo, A1). D = H86 M = mayo D1 = H86 A1 = 2000 ?- fecha(D, M, 2000) = fecha(D1, julio, 1956). no

Reglas de Calce Dos términos S y T calzan, si: Si S y T son constantes, entonces S y T calzan si ambos son el mismo objeto. Si S es una variable y T cualquier cosa, entonces calzan y S se instancia como T. Viceversa, si T es variable, entonces T se instancia como S. Si S y T son estructuras, entonces calzan sólo si:  S y T tienen el mismo functor, y  Todas sus correspondientes componentes calzan. Instanciaciones resultantes es determinado por proceso de calce de componentes.

Grado de Ajuste del Calce ?- fecha(D, M, 2000) = fecha(D1, mayo, A1). Podría haber sido calzado como: D = 1 D1 = 1 M = mayo A1 = 2000 Pero esta forma es más restrictiva (menos general) que la anterior. ¡Prolog calza el resultado a su forma más general!

Ejemplo de Calce de Estructuras ?- triangulo(punto(1, 1), A, punto(2, 3)) = triangulo(X, punto(4, Y), punto(2, Z)). A = punto(4,H193) X = punto(1,1) Y = H193 Z = 3 triangulo punto X 4 Y 2 Z triangulo punto A 1 2 3

Ejemplo de Calce con Estructuras Hechos: vertical( seg( punto(X,_), punto(X, _) ) ). horizontal( seg( punto(_,Y), punto(_,Y) ) ). ?- vertical(seg(punto(1,1), punto(1,2))). yes ?- vertical(seg(punto(1,1), punto(2,Y))). no ?- horizontal(seg(punto(1,1), punto(2,Y))). Y = 1 ?- vertical(seg(punto(2,3), Y)). Y = punto(2,H561) ?- vertical(S), horizontal(S). S = seg(punto(H576,H577),punto(H576,H577))

Disjunción en Cláusulas La cláusula: P :- Q; R. Se puede interpretar como: P :- Q. P :- R. La cláusula: P :- Q, R; S, T, U. Se puede interpretar como: P :- Q, R. P :- S, T, U.

Una lista en Prolog se puede escribir como: Listas en Prolog Una lista en Prolog se puede escribir como: [perro, gato, ratón, loro] Sin embargo esto es sólo un sabor sintáctico, pues Prolog lo traduce una forma de estructura. Si existe la estructura .(Cabeza, Cola), entonces: .(perro, .(gato, .(ratón, .(loro, [])))) equivale a la lista anterior (que es más legible)

Representación de Listas Una lista define un árbol binario, similar a las listas propias de Scheme. Prolog permite una notación similar a los pares: L = [a | Cola] , donde a es la cabeza (cualquier tipo) y Cola es el resto de la lista (debe ser una lista) . La lista vacía se expresa como []. Ejemplo: ?- L2 = [ a | [b | []]]. L2 = [a,b]

Algunos Posibles Operadores sobre Listas Membresía del objeto X en la lista L: member(X, L) Concatenación de listas L1 y L2 en L3 conc(L1, L2, L3) Agregar un elemento X en una lista L add(X, L, L1) Borrar un elemento X en una lista L del(X, L, L1)

Definición de Operadores (1/2) %definicion de membresia de X en una lista L: member(X, L). % ============================================ member(X, [X | Cola]). member(X, [Cabeza | Cola]) :- member(X, Cola). % concatenacion de listas L1 y L2 en lista L3: conc(L1, L2, L3). % ============================================== % concat. con lista vacia es la misma lista conc([], L, L). % caso de que primera lista no esté vacía conc([X | L1], L2, [X | L3]) :- conc(L1, L2, L3).

Ejemplos de Operadores con Listas ?- member(X, [a, b]). X = a ; X = b ; no ?- conc([a], [b], L). L = [a,b] ; ?- add(a, X, Y). X = H918 Y = [a | H918] ; no ?- del(b, [a, b, c, b, d], L). L = [a,c,b,d] ; L = [a,b,c,d] ;

sublist(S, L) :- conc(L1, L2, L), conc(S, L3, L2). Sublistas Una sublista es una parte de una lista El operador puede ser definido con la siguiente regla: Ejemplo: sublist(S, L) :- conc(L1, L2, L), conc(S, L3, L2). ?- sublist([b, X], [a, b, c, d]). X = c

Notación de Operadores Las operaciones en Prolog se expresan normalmente como functores. Se permite también especificar operadores especiales con su relación de precedencia mediante directivas al traductor Prolog. Este mecanismo permite mejorar la lectura de programas (sabor sintáctico), similar a la sobrecarga de operadores en C++

Ejemplo de Operadores Ejemplo en Prolog: La expresión: ?- X is +(*(2, 3), *(4, 5)). X = 26 . ?- X is 2*3 + 4*5. X = 26 La expresión: +(*(2, a), *(b, c)) podría escribirse como: 2*a + b*c ¡¡Que resulta más legible!! Se ha supuesto que + tiene mayor precedencia que *

Ejemplo: Máximo Común Divisor mcd(X, X, X). mcd(X, Y, D) :- X<Y, Y1 is Y-X, mcd(X, Y1, D). Y<X, mcd(Y, X, D).

Ejemplo: Máximo Común Divisor ?- mcd(100, 10, X). X = 10 ?- mcd(27, 36, X). X = 9

Problema de las Ocho Reinas Ejemplo de Programa Problema de las Ocho Reinas

Problema de las Ocho Reinas 1 2 3 4 5 6 7 8 

Solución #1 en Prolog solucion1([]). solucion1([X/Y | Otras]) :- % primera reina en X/Y solucion1(Otras), member(Y, [1,2,3,4,5,6,7,8]), noataque(X/Y, Otras). % Primera reina no ataca a otras noataque(_, []). noataque(X/Y, [X1/Y1 | Otras]) :- Y =\= Y1, % diferentes filas Y1 - Y =\= X1 - X, % diferentes diagonales Y1 - Y =\= X - X1, plantilla([1/Y1, 2/Y2, 3/Y3, 4/Y4, 5/Y5, 6/Y6, 7/Y7, 8/Y8]). solucion(S) :- plantilla(S), solucion1(S).

Consulta a la Solución #1 ?- solucion(S). S = [1 / 4,2 / 2,3 / 7,4 / 3,5 / 6,6 / 8,7 / 5,8 / 1] ; S = [1 / 5,2 / 2,3 / 4,4 / 7,5 / 3,6 / 8,7 / 6,8 / 1] ; S = [1 / 3,2 / 5,3 / 2,4 / 8,5 / 6,6 / 4,7 / 7,8 / 1]

¿Porqué controlar Backtracking? Prolog realiza backtracking automático si falla la satisfacción de una cláusula Sin embargo, en algunos casos el backtracking automático es ineficiente El programador puede controlar o prevenir el backtracking usando cut.

Suponga las siguientes tres reglas para una función de doble escalón: Ejemplo de una Función Suponga las siguientes tres reglas para una función de doble escalón: Regla#1: Si (X<3) entonces Y=0 Regla#2: Si (3 X) y (X<6), entonces Y=2 Regla#3: Si (6X), entonces Y =4 3 6 2 4

Función Expresada en Prolog f(X, 0) :- X<3. % regla #1 f(X, 2) :- 3 =< X, X < 6. % regla #2 f(X, 4) :- 6 =< X. % regla #3 % La consulta siguiente -? f(1, Y), 2<Y. no

Evaluación de la Meta f(1, Y) 2<Y 1<3 2<0 Regla#1 Y=0 31 ¡NO! Regla#1 Y=0 31 1<6 2 < 2 Regla#2 Y=2 Regla#3 Y=4 61 2<4 CUT

Función Expresada en Prolog usando CUT f(X, 0) :- X<3, !. % regla #1 f(X, 2) :- 3 =< X, X < 6, !. % regla #2 f(X, 4) :- 6 =< X. % regla #3 -? f(1, Y), 2<Y. no

Optimizando Evaluación de Función usando CUT f(X, 0) :- X<3, !. % regla #1 f(X, 2) :- X < 6, !. % regla #2 f(X, 4) . % regla #3 -? f(7, Y). Y=4

A María le gustan los animales: ¡¡Pero no le gustan las serpientes!! Negación como Falla A María le gustan los animales: gusta(maria, X) :- animal(X). ¡¡Pero no le gustan las serpientes!! Expresado en Prolog: gusta(maria, X) :- serpiente(X), !, fail ; animal(X).

Ejemplos de Negación La verificación si dos expresiones difieren: diferente(X, Y) :- X = Y, !, fail ; true. El procedimiento interno not de Prolog se comporta como: not(P) :- P, !, fail

Aplicación de la Negación La función diferente ahora se puede escribir como: diferente(X, Y) :- not(X =Y). Y la regla de Maria: gusta(maria, X) :- not(X = serpiente), animal(X).

Problema de las 8 Reinas Expresada con Negación solucion1([]). solucion1([X/Y | Otras]) :- % primera reina en X/Y solucion1(Otras), member(Y, [1,2,3,4,5,6,7,8]), not ataque(X/Y, Otras). % Primera reina no ataca a otras ataque(X/Y, Otras) :- member(X1/Y1, Otras), (Y = Y1; % en la misma filas, ó Y1 is Y + X1 - X; % en la mismas diagonales Y1 is Y + X - X1). plantilla([1/Y1, 2/Y2, 3/Y3, 4/Y4, 5/Y5, 6/Y6, 7/Y7, 8/Y8]). solucion(S) :- plantilla(S), solucion1(S).

Ventajas Desventajas Uso de Cut y Negación Se puede aumentar la eficiencia Se pueden expresar reglas que son mutuamente exluyentes Desventajas Se pierde correspondencia entre significado declarativo y procedural Cambio del orden de las cláusulas puede afectar significado declarativo

Fin