Departamento de Informática Universidad Técnica Federico Santa María 1 Lenguajes de Programación...

Lenguajes de ProgramaciónDepartamento de Informática

Universidad Técnica Federico Santa María

1

Capítulo V:Programación Lógica



2

5.1 Breve Introducción al Cálculo de Predicados



V-1-3

Definiciones Básicas

• 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.



V-1-4

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.



V-1-5

Proposiciones

• 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)



V-1-6

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.



V-1-7

Cláusulas de Horn

• Cláusulas de Horn 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.



V-1-8

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.



V-1-9

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.



10

5.2 Introducción a Prolog



V-1-11

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)



V-1-12

Hechos en Prolog: Ejemplo

padre(maria, pedro).padre(juan, pedro).padre(juan, carola).padre(pedro, ana).padre(pedro, paty).padre(paty, aldo).

anaana

mariamaria juanjuan

pedropedro carolacarola

patypaty

aldoaldo



V-1-13

Consultas en Prolog

?- padre(pedro, ana).=> yes

?- padre(ana, paty).=> no

?- padre(X, carola).=> X = juan

?- padre(pedro, X).=> X = ana ;=> X = paty ;=> no



V-1-14

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



V-1-15

Consulta: Ejemplo 2

Preguntar por los nietos de juan:

X, Y : (juan es padre de X) (X es padre de Y)


?- padre(juan, X), padre(X, Y).=> X = pedro

Y = ana ;

=> X = pedroY = paty



V-1-16

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)


?- padre(X, ana), padre(X, paty).=> X = pedro



V-1-17

Otros Hechos

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).



V-1-18

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!



V-1-19

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 :- )



V-1-20

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



V-1-21

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).



V-1-22

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) :- diferente(X, Y), padre(Z, X), padre(Z, Y), femenino(X).



V-1-23

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 ()



V-1-24

Reglas Recursivas

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 directoantepasado(X, Z) :- padre(X, Y), antepasado(Y, Z). % descendiente ind.



V-1-25

Ejemplo de Consulta

% Consultar por los descendientes de maria

?- antepasado (maria, X)=> X = pedro ;=> X = ana ;=> X = paty ;=> X = aldo



V-1-26

Resolución de Consulta

antepasado(juan, paty)antepasado(juan, paty)

NO

SI

padre(juan, paty)

Regla#1

padre(juan, X)antepasado(X, paty)

Regla#2

antepasado(pedro, paty)

Hecho:padre(juan, pedro)

X=pedro

padre(pedro, paty)

Regla#1

anaana

mariamaria juanjuan

pedropedro carolacarola

patypaty

aldoaldo



27

5.3 Tipos de Datos en Prolog



V-1-28

Objetos de Datos en Prolog

• Objetos de datos simples

• Objetos estructurados

• Calce de operaciones fundamentales sobre objetos



V-1-29

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)



V-1-30

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´



V-1-31

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 variabletiene_hijo(X) :- padre(X, _).

• Ámbito de variable es una cláusula



V-1-32

Ejemplo con Figuras Geométrica

2 4 6 8

2

4

6

P2 = (2,3)

P1 = (1,1)

(6,4)

(7,1)

(4,2) TS

P1 = punto(1, 1)P2 = punto(2,3)S = seg(P1, P2)T = triangulo (punto(4,2),

punto(6,4), punto(7,1))



33

5.4 Calce de Términos en Prolog



V-1-34

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.



V-1-35

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



V-1-36

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.



V-1-37

Ejemplo de Calce en Prolog

?- fecha(D, M, 2000) = fecha(D1, mayo, A1).D = H86M = mayoD1 = H86A1 = 2000

?- fecha(D, M, 2000) = fecha(D1, julio, 1956).no



V-1-38

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.



V-1-39

Grado de Ajuste del Calce

?- fecha(D, M, 2000) = fecha(D1, mayo, A1).

Podría haber sido calzado como:D = 1D1 = 1M = mayoA1 = 2000

Pero esta forma es más restrictiva (menos general) que la anterior.

¡Prolog calza el resultado a su forma más general!



V-1-40

Ejemplo de Calce de Estructuras

triangulo

punto puntoA

1 1 2 3

triangulo

punto puntoX

4 Y 2 Z

?- 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 = H193Z = 3



V-1-41

Ejemplo de Calce con Estructuras

?- 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))



V-1-42

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.



43

5.5 Listas y Operadores



V-1-44

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)



V-1-45

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]



V-1-46

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 L3conc(L1, L2, L3)

• Agregar un elemento X en una lista Ladd(X, L, L1)

• Borrar un elemento X en una lista Ldel(X, L, L1)



V-1-47

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 listaconc([], L, L).

% caso de que primera lista no esté vacíaconc([X | L1], L2, [X | L3]) :- conc(L1, L2, L3).



V-1-48

Ejemplos de Operadores con Listas

?- member(X, [a, b]).X = a ;X = b ;no

?- conc([a], [b], L).L = [a,b] ;no

?- add(a, X, Y).X = H918Y = [a | H918] ;no

?- del(b, [a, b, c, b, d], L).L = [a,c,b,d] ;L = [a,b,c,d] ;no



V-1-49

Sublistas

• Una sublista es una parte de una lista

• El operador puede ser definido con la siguiente regla:

• Ejemplo:

?- sublist([b, X], [a, b, c, d]).X = c

sublist(S, L) :- conc(L1, L2, L), conc(S, L3, L2).



50

5.6 Operadores y Aritmética



V-1-51

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++



V-1-52

Ejemplo de Operadores

La expresión:

+(*(2, a), *(b, c))

podría escribirse como:

2*a + b*c

¡¡Que resulta más legible!!

Ejemplo en Prolog:

?- X = +(*(2, 3), *(4, 5)).X = 2 * 3 + 4 * 5

?- X is +(*(2, 3), *(4, 5)).X = 26 .

?- X is 2*3 + 4*5.X = 26

Se ha supuesto que + tiene mayor precedencia que *



V-1-53

Ejemplo: Máximo Común Divisor

mcd(X, X, X).

mcd(X, Y, D) :-X<Y,Y1 is Y-X,mcd(X, Y1, D).

mcd(X, Y, D) :-Y<X,mcd(Y, X, D).



V-1-54

Ejemplo: Máximo Común Divisor

?- mcd(100, 10, X).

X = 10

?- mcd(27, 36, X).

X = 9



55

5.7 Ejemplos de Programas con Estructuras



56

Ejemplo de Programa

Problema de las Ocho Reinas



V-1-57

Problema de las Ocho Reinas

1

2

3

4

5

6

7

8

1 2 3 4 5 6 7 8



V-1-58

Solución #1 en Prologsolucion1([]).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 filasY1 - Y =\= X1 - X, % diferentes diagonalesY1 - Y =\= X - X1,noataque(X/Y, Otras). % Primera reina no ataca a otras

plantilla([1/Y1, 2/Y2, 3/Y3, 4/Y4, 5/Y5, 6/Y6, 7/Y7, 8/Y8]).

solucion(S) :- plantilla(S), solucion1(S).



V-1-59

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]



60

5.8 Control de Backtracking



V-1-61

¿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.



V-1-62

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 (6X), entonces Y =4

3 6

2

4



V-1-63

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



V-1-64

Evaluación de la Meta

f(1, Y)2<Y

f(1, Y)2<Y

1<32<0

1<32<0

2<02<0

¡NO!

Regla#1Y=0

311<6

2 < 2

311<6

2 < 2

Regla#2Y=2

¡NO!

Regla#3Y=4

¡NO!

612<4

612<4

CUT



V-1-65

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



V-1-66

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



V-1-67

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).



V-1-68

Ejemplos de NegaciónLa verificación si dos expresiones difieren:

diferente(X, Y) :- X = Y, !, fail;true.

El procedimiento interno not de Prolog se comportacomo:

not(P) :- P, !, fail; true.



V-1-69

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).



V-1-70

Problema de las 8 Reinas Expresada con Negación

solucion1([]).

solucion1([X/Y | Otras]) :- % primera reina en X/Ysolucion1(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 diagonalesY1 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).



V-1-71

Uso de Cut y Negación

• Ventajas– 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

Departamento de Informática Universidad Técnica Federico Santa María 1 Lenguajes de Programación...

Documents

Transcript of Departamento de Informática Universidad Técnica Federico Santa María 1 Lenguajes de Programación...