1/16Algunos aspectos de la implementación de TOY
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
8. Trabajo futuro
2/16Algunos aspectos de la implementación de TOY
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
8. Trabajo futuro
3/161. Arquitectura
Toy
FD R
SICStus Prolog
H
store
FD R
store store
4/16Algunos aspectos de la implementación de TOY
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
8. Trabajo futuro
5/16
Programación lineal. Programación lineal entera mixta (MIP). Optimización. MIP en TOY.
2. Restricciones de reales
6/16
xc j
n
jj
1Minimizar (Maximizar)
bxa ij
n
jij
1
mi ,...,2,1
nj ,...,2,1,0x j
Sujeto a
21 23 xx
421 xx52 21 xx24 21 xx
0, 21 xx
Ejemplo
Maximizar
Sujeto a
x j
21, xx
Programación lineal
7/16
xc j
n
jj
1Minimizar (Maximizar)
bxa ij
n
jij
1
mi ,...,2,1
nj ,...,2,1,0x j
Sujeto a
Programación entera/mixta
21 23 xx
421 xx52 21 xx24 21 xx
0, 21 xx
Ejemplo
Maximizar
Sujeto a
x j
21, xx
8/16
X1
X2
A(0,4)
B(1,3)
C(2,1)
D(0,1/2)
Programación lineal
Algoritmo del Simplex (Dantzing 1947)
Algoritmo de barrera (punto interior Karmarkar 1984)
Programación entera/mixta
Algoritmo de ramificación y acotación(branch&bound, branch&cut, …)
xxMaximizar21 23
421 xx
52 21 xx
24 21 xx
X1 = 1,2X2 = 3
Relajación linealdel problema
Relajación linealdel problema + X1 <= 1
Relajación linealdel problema + X1 >= 2
B&B
9/16
MIP en Toy
minimize, maximize :: real -> real
Toy(R)> 2*X+Y <= 16, X+2*Y <= 11, X+3*Y <= 15, Z==30*X+50*Y, maximize Z == Z{ X -> 7.00000000000001, Y -> 1.9999999999999956, Z -> 310.00000000000006 }Elapsed time: 0 ms.sol.1, more solutions (y/n/d/a) [y]?noElapsed time: 0 ms.
10/16
MIP en Toy
bb_minimize, bb_maximize :: real -> [real ]-> real
Toy(R)> E==40*G+50*C,G+C<=50,3*G+4*C<=180, C<=40,C>=0,G>=0,bb_maximize E [C,G] == E { E -> 2300, G -> 20, C -> 30 } Elapsed time: 31 ms. sol.1, more solutions (y/n/d/a) [y]? no Elapsed time: 0 ms.
11/16
Resumen de funciones
minimize, maximizebb_minimize, bb_maximize
12/16
Implementación CFLP(R) Módulos
13/16
Implementación – Compilación de programas
Compilación
Declaraciones Toy (usuario y predefinidas)
Análisis léxico, sintáctico y (parte del) semántico
Traducción a primer orden
Unión de archivos
Outgenerated
Inferencia de tipos y última etapa de compilaciónplgenerated
Módulos
Archivos
14/16
Implementación – Carga de programas
Carga
• toycomm.plPredicados comunes (e.g., hnf)
• primFunct.plDeclaraciones de funciones predefinidas
• primitivCod.plImplementación de funciones predefinidas
:- consult(program)
plgenerated
15/16
Implementación – Carga de la biblioteca R
/cflpr
/nocflprArchivos Prolog
Módulos Sicstus
16/16
Implementación – Implementación de funciones
$<(X,Y,H,Cin,Cout):- hnf(X,HX,Cin,Cout1), hnf(Y,HY,Cout1,Cout2), (H=true,{HX<HY};H=false,{HX>=HY}), toSolver(HX,Cout2,Cout3), toSolver(HY,Cout3,Cout4), toSolver(H,Cout4,Cout).
$<(X,Y,H,Cin,Cout):- hnf(X,HX,Cin,Cout1), hnf(Y,HY,Cout1,Cout), (number(HX),number(HY) ->
(HX<HY,H=true;HX>=HY,H=false); errPrim).
primitivCod.pl
primitivCodClpr.pl
17/16Algunos aspectos de la implementación de TOY
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
8. Trabajo futuro
18/16
Abstracción operacional
e.g. x y + z (asignación) es x=y+z (relación),
Carácter multi-disciplinar Resolución de problemas de naturaleza diversa
(no-lineal, cooperativa, optimización, scheduling, timetabling, etc.)
Restricción = relación (ecuacional, simbólica, primitiva, etc.)
2. Restricciones de dominio finito
19/16Motivaciones
Marco natural: Declarative Programming DP = LP o FP
Problemas OR
Búsqueda +
Constraints
RelaciónObjetoObjeto
ObjetoConstraint
20/16
Estructura de un programa de restricciones (DF)
Declaración de las variables de decisión
Declaración de las restricciones
Especificación del proceso de búsqueda(Optimización)
Definición de los parámetros
Acotación de dominios (domain)
21/16Problema de satisfacción de restriccionesX = X1 , X2 , … , Xn
conjunto de variables que toma valores de los respectivos dominios finitos del conjunto
D = D( X1), D( X2) , … , D( Xn)
Una asignación a las variables X1 , X2, … , Xn es una n-tupla de valores
(d1, d2, … , dn) con di D(Xi) i = 1,...n.
Una restricción R(V) con V X, es un subconjunto del producto cartesiano de los dominios:
R( X1, X2, … , Xm) D( X1) x D( X2) x … x D( Xm).
Una asignación (d1, d2, … , dm) satisface la restricción R si:
R(d1 , d2, … , dm) R( X1 , X2, … , Xm)
Una restricción es satisfacible si existe al menos una asignación que la satisface
22/16
Ejemplo
Variables: X, Y, Z
Dominios: D(X) = 1, 2, 5, D(Y) = 1, 2, 3, 4, 5, D(Z) = 1, 2, 5, 7
Restricción: R(X, Y, Z) = X < Y Y< Z
Asignaciones: (1, 1, 1) insatisfacible
(1, 2, 5) satisfacible
Problema de satisfacción de restricciones (DOMINIOS FINITOS)
23/16
X > Y + Z + 6Y < T + Z
W Y X = W + TX < Z
D(X) = [1..9]D(Y) = [1..9]D(Z) = [1..9]D(T) = [1..9]D(W) = [1..9]
Solution [7]
X = 9Y = 1Z = 1T = 7W = 2
Solution [1]
X = 9Y = 1Z = 1T = 1W = 8
Solution [2]
X = 9Y = 1Z = 1T = 2W = 7
Solution [3]
X = 9Y = 1Z = 1T = 3W = 6
Solution [4]
X = 9Y = 1Z = 1T = 4W = 5
Solution [5]
X = 9Y = 1Z = 1T = 5W = 4
Solution [6]
X = 9Y = 1Z = 1T = 6W = 3
PSR Soluciones del PSR
Problema de satisfacción de restricciones (representación)
24/16
D(X) = [1..5]
D(Y) = [3..7]
D(T) = [1..5]
D(W) = [2..5]
D(Z) = [1..9]
Propagador de
X = W + T
Propagador de
X <> Z
Propagador de
Y < T + Z
Propagador de
X > Y + Z + 6
Propagador de
W <> Y
Arquitectura del resolutor de restricciones de dominios finitos
Dominios
25/16
Arco consistencia
Una restricción primitiva r es arco-consistente con dominio D si |vars(r)| 2 o vars(r) = {x,y} y para cada d in D(x) existe e en D(y) tal que: , y análogamente para y
Un PSR es arco consistente si todas sus restricciones
primitivas son arco_consitentes
reydx desolución una es },{
26/16
Una restricción primitiva r es límite_consistente con dominio D si para cada variable x en vars(r) existen números reales d1, ..., dk para el resto de variables x1, ..., xk tal que es una solución de r, y análogamente para
Un PSR aritmético es límite_consistente si lo son todas sus restricciones primitivas
{ min( , ), , }x D x x d xk dk 1 1
{ max( , )}x D x
Consistencia de límites
27/16
Ejemplos de consistencia de límites
No es límite-consistente, ya que para Z=2 (max(D(Z)) no existe solución de X-3Y=10 en D(X) y D(Y)
En cambio, sí es límite-consistente el siguiente dominio:
]2..1[)(],2..0[)(],7..2[)(
53
ZDYDXD
ZYX
]1..0[)(],2..0[)(],7..2[)( ZDYDXD
28/16Obtención de la consistencia de límites
Dado un dominio actual D se modifican los puntos extremos de las variables para que resulte límite_consistente
los propagadores o reglas de propagación se encargan de esta tarea
29/16
Consideremos la restricción primitiva X = Y + Z que es equivalente a las tres formas
Razonando sobre los valores mínimo y máximo obtenemos las siguientes reglas de propagación:
Reglas de propagación (propagadores)
X D Y D Z X D Y D Z
Y D X D Z Y D X D Z
Z D X D Y Z D X D Y
min( , ) min( , ) max( , ) max( , )
min( , ) max( , ) max( , ) min( , )
min( , ) max( , ) max( , ) min( , )
X Y Z Y X Z Z X Y
30/16
Las reglas de propagación determinan que:
Por lo que los dominios pueden reducirse a:
( ) ( )
( ) ( )
( ) ( )
0 2 2 5 3 2
4 2 2 6 8 2
4 3 1 8 8 0
X
Y
Z
D X D Y D Z( ) [ .. ], ( ) [ .. ], ( ) [ .. ] 4 5 2 3 2 2
Reglas de propagación (propagadores)
]2..2[)(],3..0[)(],8..4[)(
ZDYDXD
ZYX
31/16
Si el dominio inicial es:
Determinamos que
y el nuevo dominio será:
W P C 9
4
9
3
9
2, ,
4 3 2 9
9
4
3
4
2
49
3
4
3
2
39
2
4
2
3
2
W P C
W D P D C
P D W D C
C D W D P
min( , ) min( , )
min( , ) min( , )
min( , ) min( , )
Reglas de propagación (propagadores)
D W D P D C( ) [ .. ], ( ) [ .. ], ( ) [ .. ] 0 9 0 9 0 9
D W D P D C( ) [ .. ], ( ) [ .. ], ( ) [ .. ] 0 2 0 3 0 4
32/16Desigualdades
Las reglas de las desigualdades proporcionan una propagación débil. Sólo hay propagación cuando un miembro toma un valor fijo e igual al mínimo o máximo del otro miembro.
Y Z
]2..2[)(],4..3[)(n propagació]2..2[)(],4..2[)(
npropagaciósin ]3..3[)(],4..2[)(
npropagaciósin ]3..2[)(],4..2[)(
ZDYDZDYD
ZDYD
ZDYD
33/16
Multiplicación X Y Z
Si todas las variables son positivas, el propagador sería:
Ejemplo:
se convierte en:
X D Y D Z X D Y D Z
Y D X D Z Y D X D Z
Z D X D Y Z D X D Y
min( , ) min( , ) max( , ) max( , )
min( , ) / max( , ) max( , ) / min( , )
min( , ) / max( , ) max( , ) / min( , )
D X D Y D Z( ) [ .. ], ( ) [ .. ], ( ) [ .. ] 4 8 1 2 1 3
]3..2[)(],2..2[)(],6..4[)( ZDYDXD
34/16
Algoritmo general del resolutor
Fase de propagación de consistencia(ejecución de un propagador activo)
¿Inconsistencia?
Retroceso
Fase de búsqueda(imposición del valor de una variable a
uno de los elementos de su dominio actual)
¿Existendominios no
vacíos?
¿Son todos losdominiosunitarios?
FIN(con solución)
FIN(sin solución)
síno
nosí no sí
35/16
C(L)P ? (Jaffar y Lassez, 87)
CLP Expresividad LP + Eficiencia CP
Instancias según dominio de computación CLP(FD), CLP(Sets), CLP(), CLP(Bool),....
LP - Unificación
+ Resolución de restricciones
CLP
Motivaciones
36/16
Ningún intento convincente en FP, sí en en el contexto multiparadigma.
(Arenas et. al, 1996)l (López-Fraguas y Sánchez Hernández,1999) (Lux, 2001) (Smolka,1994) (Antoy y Hanus, 2000)
¿ Y DOMINIOS FINITOS (FD) ?
CFP ?
37/16
Antonio J. Fernández, Teresa Hortalá-González, Fernando Sáenz-Perez
PADL’2003, ES’2002
Nuestra propuesta
Antonio J. Fernández, Teresa Hortalá-González, Fernando Sáenz-Perez y Rafael del Vado Vírseda
TPLP’07
38/16El Modelo Opaco(Black box!) Ventajas: Eficiencia
Específico de la aplicación Semántica operacional oculta
Desventajas
Restricciones “hard wired” Carencia adaptabilidad
Constraint
Restricción Opaca
Entrada Salida
39/16
Variables
Lógicas
No
determinismo
FD
Propagación
restricciones
Labeling Funciones
HO PerezaComposición
restricciones
Patrones TiposAplicaciones
parciales
CFLP
sobre
FD
40/16TOY(FD)
Lenguaje fuente FLPTOY
Resolutor(SICStus)
Modelado problemaEvaluación perezosa
Almacén de restriccionesResolución restricciones
41/16TOY(FD): Restricciones FD = Funciones
42/16
Sintaxis ‘azucarada’ para los predicados
lógicos:
p t1...tn :- C1, ..., Ck
p t1...tn = true C1, ..., Ck noOverlaps :: task -> task -> bool noOverlaps T1 T2 :- precedes T1 T2 noOverlaps T1 T2 :- precedes T2 T1
TOY(FD)
43/16
Resolución CFLP(FD)
Resolución (tres fases)
+ narrowing (reducción de dominios)
+ propagación
+ técnicas de splitting (labeling)Repetitivas
Fases: (1) selección variable (2) selección valor
44/16CFLP(FD) vs. CLP(FD)
smm :: int int int int int int int int [labelType] boolsmm S E N D M O R Y Label :- domain [S,E,N,D,M,O,R,Y] 0 9, S #> 0, M #> 0, all_different [S,E,N,D,M,O,R,Y], add S E N D M O R Y, labeling Label [S,E,N,D,M,O,R,Y]
add :: int int int int int int int int booladd S E N D M O R Y :- 1000#*S #+ 100#*E #+ 10#*N #+ D #+ 1000#*M #+ 100#*O #+ 10#*R #+ E #= 10000#*M #+ 1000#*O #+ 100#*N #+ 10#*E #+ Y
CLP(FD) CFLP(FD)
45/16
CFLP(FD): Capacidades adicionales
• Tipos: ventajas ya conocidas• Notación funcional: domain [X] 1 (10-N)• Aplicaciones parciales, HO y polimorfismo
map (3#<) [X,Y] = [3#<X, 3#< Y] = [true,true]
map :: (A B) [A] [B]map F [ ] = [] map F [X|Xs]] = [(F X) | (map F Xs)]
X,Y [4,sup]
CFLP(FD) vs. CLP(FD)
46/16
Pereza:Abre nuevas posibilidades a la Resolución de restricciones
generateFD :: int -> [int]generateFD N = [X | generateFD N] <== domain [X] 0 (N-1)
lazymagic :: int -> [int]lazymagic N = L <== take N (generateFD N) == L, constrain L L 0 Cs, sum L (#=) N, scalar_product Cs L (#=) N, labeling [ff] L
Evaluación perezosa.Listas infinitas !!
CFLP(FD) vs. CLP(FD)CFLP(FD): Capacidades adicionales
47/16
CFLP(FD): Pereza
(.):: (B -> C) -> (A -> B) -> (A -> C)(F . G) X = F (G X)
from :: int [int]from N = [N|from (N+1)]
lazyseries :: int [[int]]lazyseries = map lazymagic.from
take 3 (lazyseries 7) [ [3,2,1,1,0,0,0], [4,2,1,0,1,0,0,0],
[5,2,1,0,0,1,0,0,0] ]
CFLP(FD) vs. CLP(FD)
48/16
Sumario
• CLP(FD) CFLP(FD)
• + notación funcional,• + tipos,• + HO, • + Parcialización,• + Evaluación perezosa,• + composición de funciones (restricciones)
• + ????
CFLP(FD) vs. CLP(FD)
49/16Aplicaciones
50/16
data taskName = t1 | t2 | t3 | t4 | t5 | t6data resourceName = m1 | m2type precedencesType = [taskName]type resourcesType = [resourceName]type task = (taskName, durationType, precedencesType, resourcesType, startType)
Tasks == [ (t1,3,[], [m1],S1), (t2,8,[], [m1],S2), (t3,8,[t4,t5],[m1],S3), (t4,6,[], [m2],S4), (t5,3,[t1], [m2],S5), (t6,4,[t1], [m2],S6)], schedule Tasks 1 20, labeling [] [S1,S2,S3,S4,S5,S6]
SOLVE!!
Planificación
51/16
scheduleTasks :: [task] -> [task] -> boolscheduleTasks [] TL = truescheduleTasks [(N, D, P, R, S)|Ts] TL :- precedeList (N, D, P, R, S) P TL, requireList (N, D, P, R, S) R TL, scheduleTasks Ts TL
precedeList :: task -> [taskName] -> [task] -> boolprecedeList T [] TL = trueprecedeList T1 [TN|TNs] TL :- belongs (TN, D, P, R, S) TL, precedes (TN, D, P, R, S) T1, precedeList T1 TNs TL
precedes :: task -> task -> boolprecedes T1 T2 = (start T1) #+ (duration T1) #<= (start T2)
Recursión
Restricciones FD
Planificación
52/16
NOT, AND, and OR gates Three-input, one-output circuits
A Hardware Design Problem
53/16
Circuitos Simples FLP (1)type behavior = bool -> bool -> bool -> bool
i0,i1,i2 :: behaviori0 I2 I1 I0 = I0 -- Input 0 Modulei1 I2 I1 I0 = I1 -- Input 1 Modulei2 I2 I1 I0 = I2 -- Input 2 Module
notGate :: behavior -> behavior notGate B I2 I1 I0 = not (B I2 I1 I0)
andGate,orGate :: behavior -> behavior -> behaviorandGate B1 B2 I2 I1 I0 = and (B1 I2 I1 I0) (B2 I2 I1 I0) orGate B1 B2 I2 I1 I0 = or (B1 I2 I1 I0) (B2 I2 I1 I0)
54/16
i0
i1
i2
Funciones de Orden Superior Patterns: Topologías Patterns aplicados a entradas: salidas orGate (andGate i0 (notGate i2)) (andGate i1 i2)
Circuitos Simples FLP
55/16
i0
i1
i2
P == orGate (andGate i0 (notGate i2)) (andGate i1 i2),O == P true false true
se evalua a verdadero y produce 0 == false
Pattern: ciudadano de primera Clase y HO
Circuitos Simples FLP
56/16Factores Físicos: Disipación de Potencia (1)
power :: behavior -> int
power i0 = 0
power i1 = 0
power i2 = 0
power (notGate C) = notGatePower + (power C)
power (andGate C1 C2) =
andGatePower + (power C1) + (power C2)
power (orGate C1 C2) =
orGatePower + (power C1) + (power C2)
Reglas para limitar la disipación de potencia
57/16
Construcción de circuitos con potencia limitada
power B == P, P < maxPower
power/1 usado como Generador de comportamiento
Factores Físicos: Disipación de Potencia (2)
58/16
Un enfoque restringido• Circuito caracterizadom por el estado:
•Idea: Empareja un estado a un circuito en construcción de manera que las variables de estado reflejen el estado actual del circuito durante su generación
• Estado representado por variables de dominio reducción de dominios por la limitación de factores durante la generación
< area, power, cost, delay >
No (Generate and Test) Test when Generating
59/16Ejemplo: el factor área type area, power, cost, delay = inttype state = (area, power, cost, delay)type circuit = (behavior, state)
genCir :: state -> circuitgenCir (A, P, C, D) = (i0, (A, P, C, D))genCir (A, P, C, D) = (i1, (A, P, C, D))genCir (A, P, C, D) = (i2, (A, P, C, D))genCir (A, P, C, D) = (notGate B, (A, P, C, D)) <== domain [A] ((fd_min A) + notGateArea) (fd_max A), genCir (A, P, C, D) == (B, (A, P, C, D))genCir (A, P, C, D) = (andGate B1 B2, (A, P, C, D))<== domain [A] ((fd_min A) + andGateArea) (fd_max A), genCir (A, P, C, D) == (B1, (A, P, C, D)), genCir (A, P, C, D) == (B2, (A, P, C, D))genCir (A, P, C, D) = (orGate B1 B2, (A, P, C, D)) <== domain [A] ((fd_min A) + orGateArea) (fd_max A), genCir (A, P, C, D) == (B1, (A, P, C, D)), genCir (A, P, C, D) == (B2, (A, P, C, D))
Funcion de reflexión
Constraint
60/16
Switching Function: Ejemplo
• Devuelve el resultado de un”comportamiento” B para todas sus combinaciones de entrada
data functionality = [bool]
switchF :: behavior -> functionality switchF Behavior = [Out1,Out2,Out3,Out4,Out5,Out6,Out7,Out8] <== (Behavior false false false) == Out1, (Behavior false false true) == Out2,
(Behavior false true false) == Out3, (Behavior false true true) == Out4,
(Behavior true false false) == Out5, (Behavior true false true) == Out6,
(Behavior true true false) == Out7, (Behavior true true true) == Out8
61/16Generando un Circuito NOR domain [A] 0 maxArea, domain [P] 0 maxPower, domain [C] 0 maxCost, domain [D] 0 maxDelay, genCir (A,P,C,D)==(B,S), switchF B ==[true,false,false,false,false,false,false,false]
Algunas respuestas calculadas (entre 24 posibles)para maxFactor = 6
B == (notGate (orGate i0 (orGate i1 i2))), B == (notGate (orGate (orGate i2 i1) i0))B == (andGate (notGate i0) (notGate (orGate i1 i2)))B == (andGate (notGate (orGate i2 i1)) (notGate i0))........................
Puerta Area Potencia Coste RetrasoNOT 1 1 1 1AND 2 2 1 1OR 2 2 2 2
62/16
Implementación – Carga de la biblioteca FD
/cflpfd
Nadacflpfd.toy
/nocflpfd
Compilación
63/16
Implementación – Biblioteca FD: compilación
Compile
64/16
• TOY(FD) se comporta como SICStus excepto en la resolución de ecuaciones lineales ;-(
• TOY(FD) es de 2 a 5 veces más rápido que PAKCs (La implementación de Curry, sin publicar )
Cfr. [TPLP’07]
Comparaciones
65/16Conclusiones
TOY+FD proporciona: declaratividad +• Resolución de restricciones FD• No-determinismo• Variables lógicas• Sintaxis relacional • Funciones• Orden superior• Aplicaciones parciales• Notación funcional• Tipos• Evaluación perezosa
66/16
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
8. Trabajo futuro
Algunos aspectos de la implementación de TOY
67/16
API para restricciones FD de Prolog
Compilation to
Prolog of Toy
Prolog FD Problem
Interface
Sicstus Prolog
Framework
Parameters FD Variables
Parameters
FD Variables
Constraints
FD Problem
68/16Ejemplos de uso
evalfd "queens" [4] == LL == [2,4,1,3] ;L == [3,1,4,2]
evalfd "queens" [1+3] == (append [2,4] [1,3])yes
evalfd "queens" [X] == [2,4,1,3],X == 4yes
evalfd "queens" [X] == [2,X|Y]X == 4, Y == [1,3] ;X == 5, Y == [3,1,4]
queens([N], L) :- length(L, N), domain(L, 1, N), constrain_all(L), labeling([], L).
constrain_all([]).constrain_all([X|Xs]) :- constrain_between(X, Xs, 1), constrain_all(Xs).
constrain_between(X,[],N).constrain_between(X,[Y|Ys],N) :- no_threat(X, Y, N), N1 is N+1, constrain_between(X,Ys,N1).
no_threat(X, Y, I) :- X #\= Y, X+I #\= Y, X-I #\= Y.
69/16
Implementación
evalfd(CL, PL, H, Cin, Cout):-
nf(CL, HCL, Cin, Cout1),
hnf(PL, HPL, Cout1, Cout),
toyListToIntPrologList(HPL, PrologList),
toyStringToProlog(HCL, PrologString),
name(Predicate, PrologString),
FDGoal =.. [Predicate, PrologList, Result],
call(FDGoal),
intPrologListToToyList(Result,H).
evalfd :: [char] -> [int] -> [int].
70/16
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
8. Trabajo futuro
Algunos aspectos de la implementación de TOY
71/16
ACIDE A Configurable Integrated Development
Environment. Multiplataforma. Configurable:
Coloreado léxico. Gramáticas para “parsing on-the-fly”. Barras de herramientas. Menús, …
72/16
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
73/16
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
8. Trabajo futuro
Algunos aspectos de la implementación de TOY
74/16
TOY
TOY + Resolutor de dominios finitos
TOY + Resolutor de reales
TOY + cooperación de los resolutores de reales y dominios finitos
vinculación y propagación
Cooperación en TOY
Puente
75/16
. . .
.
.
.
.
.
.
. . .
Ejemplo de cooperación (I)
D Primitive Functions AbbreviatesH seq :: A ! A ! bool e1 == e2 =def seq e1 e2 ! ! true e1
== e2 =def seq e1 e2 ! ! f alse
F D iseq :: int ! int ! bool e1 # = e2 =def i seq e1 e2 ! ! tr ue
e1 #n = e2 =def i seq e1 e2 ! ! f alse
i leq :: int ! int ! bool e1 # < e2 =def e2 i leq e1 ! ! f alse e1
# <= e2 =def e1 i leq e2 ! ! true e1
# > e2 =def e1 i leq e2 ! ! f alse e1
# >= e2 =def e2 i leq e1 ! ! tr ue
#+; #¡ ; #¤; #= :: int! int! int,
domain :: [int]! int! int! bool;
belongs :: int ! [int] ! bool,
labeling :: [labelT ype]! [int]! bool
R r leq :: r eal ! r eal ! bool e1 < e2 =def e2 r leq e1 ! ! f alse e1
<= e2 =def e1 r leq e2 ! ! tr ue e1
> e2 =def e1 r leq e2 ! ! f alse e1
>= e2 =def e2 r leq e1 ! ! true
+; ¡ ; ¤; =:: r eal ! r eal ! r eal
M equiv :: int ! real ! bool e1# == e2 =def equiv e1 e2 ! ! tr ue
Table 1: The Constraint Domains H, F D, R and M
(0,0)
(N,N)Calcular la intersección entre:
• Una cuadrícula discreta de puntos de dimensión N
domain [X, Y] 0 N
• Una región continua determinada por los semiplanos
RY>=RY0-H, RY-RX<=RY0-RX0, RY+RX<=RY0+RX0
(RX0,RY0)
H
H(RX0-H,RY0-H)
(RX0+H,RY0-H)
76/16
type dPoint = (int, int) type cPoint = (real, real)
type setOf A = (A → bool)
isIn :: (setOf A) → A → bool
isIn Set Element = Set Element
type grid = setOf dPoint
square:: int → gridsquare N (X, Y) :- domain [X, Y] 0 N
type region = setOf cPoint
triangle :: cPoint → real → regiontriangle (RX0, RY0) H (RX, RY) :- RY>=RY0-H, RY-RX<=RY0-RX0, RY+RX<=RY0+RX0
bothIn:: region → grid → dPoint → boolbothIn Region Grid (X, Y) :- X#==RX, Y#==RY, isIn Region (RX,RY), isIn Grid (X,Y), labeling [] [X,Y]
Ejemplo de cooperación (II): código en TOY
(RX0,RY0)
H
H(RX0-H,RY0-H)
(RX0+H,RY0-H)
. . .
.
.
.
.
.
.
. . .
D Primitive Functions AbbreviatesH seq :: A ! A ! bool e1 == e2 =def seq e1 e2 ! ! tr ue e1
== e2 =def seq e1 e2 ! ! f alse
F D iseq :: int ! int ! bool e1 # = e2 =def i seq e1 e2 ! ! tr ue
e1 #n = e2 =def i seq e1 e2 ! ! f alse
i leq :: int ! int ! bool e1 # < e2 =def e2 i leq e1 ! ! f alse e1
# <= e2 =def e1 i leq e2 ! ! tr ue e1
# > e2 =def e1 i leq e2 ! ! f alse e1
# >= e2 =def e2 i leq e1 ! ! tr ue
#+; #¡ ; #¤; #= :: int! int! int,
domain :: [int]! int! int! bool;
belongs :: int ! [int] ! bool,
labeling :: [labelT ype]! [int]! bool
R r leq :: r eal ! r eal ! bool e1 < e2 =def e2 r leq e1 ! ! f alse e1
<= e2 =def e1 r leq e2 ! ! tr ue e1
> e2 =def e1 r leq e2 ! ! f alse e1
>= e2 =def e2 r leq e1 ! ! tr ue
+; ¡ ; ¤; =:: r eal ! r eal ! r eal
M equiv :: int ! r eal ! bool e1# == e2 =def equiv e1 e2 ! ! tr ue
Table 1: The Constraint Domains H, F D, R and M
(0,0)
(N,N)
77/16Ejemplo de cooperación (III): posibles objetivos
Objetivos y respuestas que devuelve el sistema TOY:
1
0,5
78/16Ejemplo de cooperación (IV): posibles objetivos
2
79/16Ejemplo de cooperación (V)
PROBLEMA
¿Qué ocurre si la rejilla es muy muy muy grande ?
¡¡¡ Tarda demasiado !!!
MEJORA: Usar puentes para PROPAGAR
Reduce significativamente el espacio de búsqueda de FD
RY>=RY0-H
RY-RX<=RY0-RX0
RY+RX<=RY0+RX0 X#==RX
Y#==RY
domain [X, Y] 0 N
labeling [] [X,Y]
80/16
Ejemplo de cooperación (VI): Efecto de la propagación
Sin propagación
Con propagación
0<=RX , RX<=N
0<=RY, RY<=N
RY>=RY0-H
RY-RX<=RY0-RX0
RY+RX<=RY0+RX0
Y #>= RY0-H
Y #- X #<= RY0-RX0
Y #+ X #<= RY0+RX0 domain [X, Y] 0 N
labeling [] [X,Y]
RY>=RY0-H
RY-RX<=RY0-RX0
RY+RX<=RY0+RX0
domain [X, Y] 0 N
labeling [] [X,Y]
X#==RX
Y#==RY
X#==RX
Y#==RY
81/16Arquitectura
Toy
FD R
SICStus Prolog
H M
store store
FD R
store store
Toy
FD R
SICStus Prolog
H
store
FD R
store store
Sistema de partida (TOY 2.2) Sistema Cooperativo (TOY 2.3)
82/16Código prolog inicial del puente
$#==(L, R, true, Cin, Cout):-
hnf(L, HL, Cin, Cout1), hnf(R, HR, Cout1, Cout),
freeze(HL, HR is float(HL)), freeze(HR, HL is integer(HR)).
Imprecisión del resolutor de reales,
a veces HR tomo un valor aproximado a un entero
Solución: aplicar tolerancia a la var real en los puentes
Toy(R+FD)> X #== RX, X == 1, RX == 0.999999
no
Toy(R+FD)> /tolerance(0.000001)
Tolerance:1.0E-06
Toy(R+FD)> X #== RX, X == 1, RX == 0.999999
{ X -> 1, RX -> 0.999999 }
Elapsed time: 0 ms.
Problema:
83/16Más problemas
En ocasiones....
Necesitamos estar seguros que las variables toman un valor real y no entero
Apaño...
(number(HRaux) -> HR is HRaux*1.0; HR = HRaux)
84/16Código prolog actual del puente
$#==(L, R, Out, Cin, Cout):- hnf(L, HL, Cin, Cout1) hnf(R, HRaux, Cout1, Cout2) (number(HRaux) -> HR is HRaux*1.0; HR = HRaux) (tolerance_active(E) -> Epsilon is E ; Epsilon is 0.0) ((Out=true, Cout3 = ['#=='(HL,HR)|Cout2] freeze(HL, {HL - Epsilon =< HR, HR =< HL + Epsilon} ) freeze(HR, (HLaux is round(HR), HL is integer(HLaux)) ) ) (Out=false, Cout3 = ['#/=='(HL,HR)|Cout2] freeze(HL, (F is float(HL), {HR =\= F})) freeze(HR, (0.0 is float_fractional_part(HR) -> (I is integer(HR), HL #\= I) true)) ) ),cleanBridgeStore(Cout3,Cout)
La implementación de $#/== es semejante
85/16Código prolog de la propagación
$>(X,Y,H,Cin,Cout):-
hnf(X,HX,Cin,Cout1), hnf(Y,HY,Cout1,Cout2),
toSolver(HX,Cout2,Cout3), toSolver(HY,Cout3,Cout4), toSolver(H,Cout4,Cout),
(H=true,{HX>HY};H=false,{HX=<HY}),
(prop_active ->
( searchVarsFD(HX,Cout,Out1,HXFD),
searchVarsFD(HY,Cout,Out2,HYFD),
( (Out1 == true, Out2 == true, H == true,!, HXFD #> HYFD);
(Out1 == true, Out2 == true, H == false,!, HXFD #=< HYFD);
(Out1 == true, Out2 == false, H == true,!, HXFD #> HYFD);
(Out1 == true, Out2 == false, H == false,!, HXFD #=< HYFD);
(Out1 == false, Out2 == true, H == true,!, HXFD #>= HYFD);
(Out1 == false, Out2 == true, H == false,!, HXFD #< HYFD);!));true).
86/16Código prolog de la propagación
#>(L, R, Out, Cin, Cout):-
hnf(L, HL, Cin, Cout1), hnf(R, HR, Cout1, Cout2),
toSolverFD(HL,Cout2,Cout3), toSolverFD(HR,Cout3,Cout4),
((Out=true, HL #> HR); (Out=false, HL #=< HR)),
(prop_active -> (
searchVarsR(HL,Cout4,Cout5,HLR),
searchVarsR(HR,Cout5,Cout,HRR),
((Out == true, { HLR > HRR },!); (Out == false, { HLR =< HRR },!))
); Cout=Cout4
).
87/16
1. Arquitectura
2. Restricciones de reales
3. Restricciones de dominio finito
4. Carga de bibliotecas
5. API para restricciones Prolog
6. ACIDE
7. Cooperación de resolutores
8. Trabajo futuro
Algunos aspectos de la implementación de TOY
88/16
¡Más madera!
Bases de datos Lenguaje de especificación de estrategias de cooperación Resolutores de ILOG Front-end Web Mejorar ACIDE Publicación TOY 2.3.0 Lenguaje de especificación de restricciones Sobrecarga de funciones Nuevos tipos de datos:
Array Tipos enumerados con FD
Lenguaje algebraico para restricciones Integración con .NET, API C++, API Java Clases de tipos/Jerarquías