Upload
others
View
13
Download
0
Embed Size (px)
Citation preview
Aritmética
y
operadores
(2011/2012)
Luis Valencia Cabrera (coordinador)
(http://www.cs.us.es/~lvalencia)
Manuel García-Quismondo
(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.