Aritmética

y

operadores

(2011/2012)

Luis Valencia Cabrera (coordinador)

lvalencia@us.es

(http://www.cs.us.es/~lvalencia)

Manuel García-Quismondo

mgarciaquismondo@us.es

(http://www.cs.us.es/~mgarcia)

Ciencias de la Computacion e IA

(http://www.cs.us.es/)

Universidad de Sevilla

Aritmética en Prolog

Operadores predefinidos

Unificación y Evaluación

Predicados aritméticos

Ejemplos de uso de operadores predefinidos

Operadores definidos por el usuario

Ejemplos de definición de operadores por el usuario

Índice

Aritmética en Prolog.

Operadores prefijos e infijos

Operadores prefijos e infijos:

(a + b) * (5 / c)

?- display((a + b) * (5 / c)).

*(+(a, b), /(5, c))

Yes

a + b * 5 / c

?- display(a + b * 5 / c).

+(a, /(*(b, 5), c))

Yes

Aritmética en Prolog.

Precedencia y asociatividad Precedencia y tipo de operadores predefinidos:

Menor precedencia implica aplicar antes (como si llevara paréntesis). Mayor precedencia, más arriba en árbol (see next).

fx, fy: Prefijo

xfx: Infijo no asociativo yfx: Infijo asocia por la izquierda xfy: Infijo asocia por la derecha xf, yf: Postfijo

Precedencia Tipo Operadores

500 yfx +, -

500 fx -

400 yfx *, /

200 xfy ^

Aritmética en Prolog.

Precedencia de operadores(I) Precedencia entre

argumentos La precedencia de un término

simple es cero

La precedencia de un término compuesto es la del símbolo de función principal y cero si no está predefinido

x e y x representa un argumento

cuya precedencia es estrictamente menor que la del operador

y representa un argumento cuya precedencia es menor o igual que la del operador

Aritmética en Prolog.

Precedencia de operadores (II) Análisis de expresiones con operadores ?- display(2+3+4).

+(+(2, 3), 4) Yes

?- display(2+3*4). +(2, *(3, 4))

Yes

?- display((2+3)*4). *(+(2, 3), 4) Yes

?- display(2^3^4). ^(2, ^(3, 4)) Yes

Operadores definidos ¿Se puede saber si un operador está definido y

cómo?

current_op(?Precedencia, ?Tipo, ?Nombre) Es verdadero si el operador Nombre está definido

como operador de tipo Tipo con precedencia Precedencia

Ejemplo: ?- current_op(Precedencia, Tipo, \+).

Precedencia = 900 Tipo = fy True

Ver todos los operadores definidos: ?- current_op(Precedencia, Tipo, Operador).

Aritmética y Unificación ?- X=1+2.

X = 1+2.

?- 1+2. Warning: toplevel: Undefined procedure: (+)/2 (DWIM could not correct

goal) false.

?- 1 + 2 = 2 + 1. false.

?- X + 1 = 1 + 2. false.

?- X + 1 =:= 1 + 2. ERROR: =:=/2: Arguments are not sufficiently instantiated 12 ?- X + 1 is 1 + 2.

false.

?- 1 + A = B + 2. A = 2, B = 1.

Evaluación aritmética Evaluador: is

Ejemplos:

?- X is 2+3^3. X = 29 Yes

?- 29 is X+3^3. [WARNING: Arguments are not sufficiently instantiated]

?- X = 1 + 2, display(X), Y is X. +(1, 2) % Functor: +. Argumentos: 1, 2. Visualización (display) X = 1+2 % Término: 1+2. Unificación (=) Y = 3 % Evaluación (is)

Yes

(Unificación, visualización y evaluación)

Predicados aritméticos

?- X = 2+3^3. X = 2+3^3

?- 2+3^Y = 2+3^3. Y = 3

?- 3 =< 5. Yes

?- 3 > X. [WARNING: Arguments

are not sufficiently instantiated]

?- 2+5 = 10-3. No

?- 2+5 =:= 10-3. Yes

?- 2+5 =\= 10-3. No

?- 2+5 =\= 10^3. Yes

Precedencia Tipo Operadores

700 xfx <, =<, >, >=, =:=, =\=

Ejemplos. Máximo Máximo de dos números:

maximo(X,Y,Z) se verifica si Z es el máximo de los números X e Y.

Ejemplo: maximo(3,5,Z) => Z=5

Programa: maximo.pl maximo(X,Y,X) :- X >= Y.

maximo(X,Y,Y) :- X < Y.

Sesión ?- maximo(2,3,X).

X = 3 ; No

?- maximo(3,2,X). X = 3 ; No

Ejemplos. Factorial Factorial de un número:

factorial(X,Y) se verifica si Y es el factorial de X

Programa: factorial.pl factorial(1,1). factorial(X,Y) :-

X > 1,

X1 is X - 1,

factorial(X1,Y1),

Y is X * Y1.

Sesión ?- factorial(4,Y).

Y = 24

Yes

Cálculo de factorial(4,Y) X = 4

X1 is X-1 => X1 = 3

factorial(X1,Y1) => Y1 = 6

Y is X*Y1 => Y = 24

Ejemplos. Fibonacci La sucesión de Fibonacci es: 0, 1, 1, 2, 3, 5, 8, ... y está definida por

f(0) = 0 f(1) = 1 f(n) = f(n-1)+f(n-2), si n >1

fibonacci(N,X) se verifica si X es el N–ésimo término de la sucesión de Fibonacci.

Programa: fibonacci.pl fibonacci(0,0). fibonacci(1,1). fibonacci(N,X) :-

N > 1,

N1 is N-1,

fibonacci(N1,X1),

N2 is N-2,

fibonacci(N2,X2),

X is X1+X2.

Sesión ?- fibonacci(6,X).

X = 8

Ejemplos. Longitud de lista Longitud de una lista

longitud(L,N) se verifica si N es la longitud de la lista L

Ejemplos longitud([],N) => N = 0 longitud([a,b,c],N) => N = 3 longitud([a,[b,c]],N) => N = 2

Programa: longitud.pl longitud([],0). longitud([_X|L],N) :-

longitud(L,M),

N is M + 1.

Sesión ?- longitud([a,b,c],N).

N = 3

Yes

Predicado predefinido: length(L,N)

Ejemplos. Máximo de lista Máximo de una lista

max_list(L,N) se verifica si N es el máximo de los elementos de la lista de números L

Sesión ?- max_list([1,3,9,5],X).

X = 9 Yes

Programa: max list.pl max_list([X],X).

max_list([X,Y|L],Z) :- max_list([Y|L],U), maximo(X,U,Z).

maximo(X,Y,X) :- X >= Y.

maximo(X,Y,Y) :- X < Y.

Ejemplos. Número entero en

un intervalo entre otros dos Intervalo entero

entre(N1,N2,X) que se verifica si X es mayor o igual que N1 y menor o igual que N2.

Sesión ?- entre(2,5,X).

X = 2 ;

X = 3 ;

X = 4 ;

X = 5 ;

No

?- entre(2,1,X). No

Programa: entre.pl

entre(N1,N2,N1) :- N1 =< N2.

entre(N1,N2,X) :- N1 < N2, N3 is N1 + 1, entre(N3,N2,X).

Predicado predefinido: between(N1,N2,X)

Operadores definidos

por el usuario (I) Operadores definidos por el usuario

pedro come pan ==>come(pedro,pan) juan tiene discos ==>tiene(juan,discos)

Definición de operadores (directiva op) :- op(600,xfx,come).

Precedencia: Entre 1 y 1200

Estructura de arbol Juan y Pedro comen pan

Operadores definidos

por el usuario (II) Sin operadores:

comen(y(juan,pedro),pan).

Con operadores: :-op(800,xfx,comen).

:-op(400,xfx,y).

juan y pedro comen pan.

?- display(juan y pedro comen pan). comen(y(juan, pedro), pan)

Yes

?- Quienes comen pan. Quienes = juan y pedro ;

No

?- Alguien y pedro comen pan. Alguien = juan ;

No

?- juan y pedro comen Algo. Algo = pan ;

No

Ejemplos de definición de

operadores. Libro de ciencias Ejemplo:

El libro de ciencias de Juan es rojo

Programa :-op(800,xfx,es).

:-op(400,yfx,de).

el_libro de ciencias de juan es rojo.

Ejemplos de definición de

operadores. Libro de ciencias ?- display(el_libro de ciencias de juan es rojo).

es(de(de(el_libro, ciencias), juan), rojo)

?- display(X es rojo). es(_G177, rojo)

X = _G177

?- X es rojo. X = el_libro de ciencias de juan

?- display(X de Y es rojo). es(de(X, Y), rojo)

?- X de Y es rojo. X = el_libro de ciencias

Y = juan

?- display(el_libro de X es rojo). es(de(el_libro, X), rojo)

?- el_libro de X es rojo. No

Ejemplos de representación y

operadores. Fuga de agua Descripción:

Si la cocina está seca y el recibidor mojado entonces la fuga de agua está en el baño.

Si el recibidor está mojado y el baño está seco entonces el problema está en la cocina.

Si la ventana está cerrada o no llueve entonces no entra agua del exterior.

Si el problema está en la cocina y no entra agua del exterior, la fuga de agua está en la cocina.

Evidencias: El recibidor está mojado.

El baño está seco.

La ventana está cerrada.

Ejemplos de representación y

operadores. Fuga de agua Representación directa en Prolog:

Reglas:

fuga_en_bagno :- recibidor_mojado, cocina_seca.

problema_en_cocina :- recibidor_mojado, bagno_seco.

no_agua_exterior :- ventana_cerrada; no_llueve.

fuga_en_cocina :- problema_en_cocina, no_agua_exterior.

Hechos:

recibidor_mojado.

bagno_seco.

ventana_cerrada.

Pregunta en Prolog:

?- fuga_en_cocina. true

Ejemplos de representación y

operadores. Fuga de agua

Debilidades (desde el pto de vista del usuario): El usuario puede no estar familiarizado con la

sintaxis de Prolog

La base de conocimiento debe de distinguirse del programa Prolog que implemente el SBC

Vamos a dar una alternativa para separar la sintaxis de Prolog pura de la base de conocimiento.

Lo haremos a través de operadores.

Representación de

Reglas y hechos % La representacion interna de una

regla debe ser la que aparece a la derecha.

% Cond puede ser una combinacion, usando ’o’ o ’y’, % de afirmaciones (la disyuncion con prioridad mayor).

% Los hechos se deben representar internamente como:

f

Representación. Operadores

Para poder escribir los hechos y reglas con

esta sintaxis definimos una serie de

operadores:

:- op(875, xfx, hecho).

:- op(875, xfx, #).

:- op(825, fx, si).

:- op(850, xfx, entonces).

:- op(800, xfy, o). % Asociatividad a la derecha

:- op(775, xfy, y). % Asociatividad a la derecha

Ejemplo fuga de agua.

Base de conocimiento r1 # si cocina_seca y recibidor_mojado

entonces fuga_en_bagno. r2 # si recibidor_mojado y bagno_seco entonces problema_en_cocina. r3 # si ventana_cerrada o no_llueve

entonces no_agua_exterior. r4 # si problema_en_cocina y no_agua_exterior entonces fuga_en_cocina. f1 hecho recibidor_mojado.

f2 hecho bagno_seco. f3 hecho ventana_cerrada.

Conclusión sobre esta

representación

Las reglas y hechos de la base de

conocimiento continúan siendo hechos

Prolog.

Los Operadores Prolog consiguen

acercar la expresión de las reglas al

lenguaje natural.

Esto facilita la legibilidad para el usuario

no familiarizado con Prolog.