Sicstus Prolog .

1. Sicstus Prolog. Programación con Restricciones.

2. Introducción. • Sistema diseñado en Prolog por el Swedish Institute of Computer Science. • Proyecto llamado “Industrialization of SICStusProlog” en colaboración con Ericsson Telecom AB, NobeltechSystems AB, AB y InfologicsTeleverket y otras más, por ellas financiado (1988-1991). • El desarrollo de la versión 3 (1991-1995) fue financiado en parte por EllemtelUtvecklings AB.

3. Contenido del Sistema. • Una maquina abstracta de Warren (WAM), que es un emulador escrito en C y es el motor de Prolog (8 veces más rápido y menor consumo de memoria). • Una biblioteca. • Un sistema de ejecución escrito en C y Prolog. • Un interprete. • Y un compilador en Prolog.

4. Instalación en Windows. • Ir a la página de Sicstus http://sicstus.sics.se/. • Enlace DownloadforEvaluation. • Registrarse. • Mirar Mensaje. • DownloadSicstus. • Mirar requisitos de sistema. • Descargar Ejecutable apropiado. • Introducir datos recibidos en el mensaje.

5. Ejecutar instalador. • Seguir los pasos:

6. Ejecutar instalador. • Introducir clave del Mensaje.

7. Ejecutar instalador. • Introducir resto de datos del mensaje.

8. Ejecutar instalador.

9. Ejecutar instalador.

10. Ejecutar instalador.

11. Ejecutar instalador.

12. Ejecutar instalador.

13. Constraint Handling Rules-library(chr). • Se puede expresar restricciones tal como aparecen en una aplicación. • Combinar sistemas de restricciones. • Posibilidad de crear propios dominios. • Crear tu propio resolutor. • Simplificación (X> Y, Y> X <=> fallar). • Propagación (X> Y, Y> Z ==> X> Z).

14. Carga de la biblioteca • Desde consola: • | -? Use_module(library(chr)). • Cabecera Programa : • : - Use_module(library(chr)).

15. Sintaxis CHR. • Tiene una o mas heads (cabezas o reglas). • Guarda opcional. • Un body (cuerpo). • Un nombre opcional. • Tres tipos diferentes de CHR con semántica especifica. • Rule --> [Name @](Simplification | Propagation | Simpagation) [pragma Pragma].

16. Simplification. • Simplificación: La regla de simplificación elimina las restricciones en su cabeza y llama a su cuerpo. • Heads <=> [Guard '|'] Body • X> Y, Y> X <=> false.

17. Propagation • Propagación: La regla de propagación llama a su cuerpo exactamente una vez, por cada restricción en su cabeza. • Heads ==> [Guard '|'] Body • X> Y, Y> Z ==> X> Z

18. Simpagation • Simpagation :La regla simpagation elimina las restricciones en la cabeza después del “\” y luego llama a su cuerpo. • Heads1 \ Heads2 <=> [Guard '|'] Body • Heads1 , Heads2 <=> [Guard '|'] Heads1,Body

19. Declaración de Restricciones. • Debe declararse con chr_constrain y un especificador de restricción. • Un especificador de restricción es F/A donde F es el nombre y A la aridad (nº argumentos). • Se puede declarar múltiples restricciones. • :- chr_constraintfoo/1. • :- chr_constraint bar/2, baz/3.

20. Declaración de Restricciones. • Un especificador de restricciones también se puede definir en su manera extensa, que es muy similar a una función con argumentos. • : - chr_constraint domain(?int, +list(int), alldifferent(?list(int)).

21. Tipos existentes. • int, float, number, natural y any. • Creados por el usuario: • :- chr_type type ---> body. • :- chr_type color ---> red ; blue ; yellow ; green. • :- chr_type tree ---> empty ; leaf(int) ; branch(tree, tree). • :- chr_type list(T) ---> [] ; [T | list(T)]. • :- chr_type pair(T1, T2) ---> (T1 - T2).

22. Restricción Programación Lógica sobre Dominios Finitos- library (clpfd) • Son restricciones en los que los posibles valores que pueden tomar las variables están restringidos a un conjunto finito. • Útil para optimización y verificación de problemas discretos como la planificación, programación, horarios, etc. • El corazón de este resolutor es un planificador de restricciones tanto indexadas como globales. • El resolutor mantiene dos colas de programación, dando prioridad a la cola de las indexadas

23. Carga de la biblioteca • Desde consola: • | -? Use_module (library(clpfd)). • Cabecera Programa : • : - Use_module (biblioteca (clpfd)).

24. Tipos de Restricciones: • Restricciones aritméticas. • Restricciones de membrecía. • Restricciones proposicionales. • Restricciones combinatorias.

25. Restricciones aritméticas • ?Expr  <RelOp>  ?Expr X --> variable {dominio de la variable}  N --> integer LinExpr --> N {expression lineal} | X | N * X | N * N | LinExpr + LinExpr | LinExpr - LinExpr

26. Restricciones aritméticas Expr --> LinExpr | Expr + Expr | Expr - Expr | Expr * Expr | Expr / Expr {división entera} | ExprmodExpr | min(Expr,Expr) | max(Expr,Expr) | abs(Expr)  RelOp --> #= | #\= | #< | #=< | #> | #>=

27. Restricciones aritméticas • sum (+Xs, +RelOp, ?Value): Xs : Lista de enteros o variables RelOp : Operador (#<, #> …) Value: Entero o variable Es verdadero si (suma de los elementos de Xs) RelOpValue

28. Restricciones aritméticas • scalar_product(+coeffs, +Xs ,+RelOp ,? Value) coeffs : Lista de enteros Xs : Lista de enteros o variables RelOp : Operador (#<, #> …) Value: Entero o variable Es verdadero si (suma de elems de Coeffs * Xs) RelOpValue

29. Restricciones de membrecía • domain(+Variables, +Min, +Max) Variables :lista de las variables de dominio o enteros Min : número entero o el número atómico “inf” Max : número entero o el número atómico “sup”  Es verdadero si todas las variables son elementos comprendidos en el rango de Min. .. Max.

30. Restricciones de membrecía • ?X in +Range X :numero entero o variable Range :  es un ConstantRange ConstantRange --> ConstantSet | Constant..Constant | ConstantRange/\ConstantRange | ConstantRange\/ConstantRange | \ConstantRange Es cierto si X es un elemento de Range

31. Restricciones Proposicionales Si se tiene que Q y P son restricciones primitivas • # \ : Q (negación) Verdadero si la restricción Q es falsa. • : P # / \ : Q (and) Verdadero si las restricciones P y Q son ambas verdaderas • : P # \ : Q (xor) Verdadero si exactamente una de las restricciones de P o Q es cierta. • : P # \ / : Q (or) True si al menos una de las restricciones de P o Q es cierto. • : P # => : Q: Q # <= : P • Verdadero si la restricción Q es verdadera o la restricción de P es falsa. • : P # <=> : Q • Verdadero si las restricciones de P y Q son ambas verdaderas o ambas falsas.

32. Restricciones Combinatorias • count (+Val, +List, +RelOp, ?Count) Val : es un entero List : es una lista de números enteros o variables de dominio Count : un entero o una variable de dominio RelOp : un símbolo relacional Cuenta el número de veces que aparece Val en List y lo compara con count

33. Restricciones Combinatorias • element(?N, +List, ?Y) N : Entero List : Lista de Enteros o variables de dominio Y : Entero o variable de dominio Es verdadero si el N-esimo elemento de List es igual a Y

34. Restricciones Combinatorias • all_different(+Variables) Variables: Lista de enteros o variables de dominio Devuelve verdadero si todos los elementos de Variables son distintos • Nota: all_distinct(+Variables) Lo mismo que all_different pero completa

35. Restricciones Combinatorias • cumulative(+Starts, +Durations, +Resources, ?Limit) Starts: Lista de inicio de procesos Durations: Lista de duracion Resources: Lista de recursos Limit: variable de dominio con límites finitos o un número entero

36. Restricción Programación Lógica sobre Racionales o Reales -library([clpq,clpr]) • Resuelve ecuaciones lineales sobre las variables racionales o reales • Cubre el tratamiento perezoso de ecuaciones no lineales(busca solucion mas simple) • Permite inecuaciones lineales

37. Carga de la biblioteca • Desde consola: • | -? Use_module (library(clpq)). • | -? Use_module (library(clpr)). • Cabecera Programa : • : - Use_module (library(clpq)). • : - Use_module (library(clpr)).

38. Interfaz del Resolutor • {+Restriccion} Las restricciones pueden tener la forma: Restriccion --> C | C , Cconjuncion   C --> Expr =:= Exprecuacion | Expr = Exprecuacion | Expr < Exprinecuacion | Expr > Exprinecuacion | Expr =< Exprinecuacion no estricta | Expr >= Exprecuacion no estricta | Expr =\= Expr desigualdad  

39. Interfaz del Resolutor • Expr --> variablevariableprolog | number punto flotante o entero | + Expr suma unaria | - Expr resta unaria | Expr + Expr suma | Expr - Expr resta | Expr * Exprmultiplicación | Expr / Exprdivisión | abs(Expr)absoluto valor | sin(Expr) seno | cos(Expr) coseno | tan(Expr) tangente | pow(Expr,Expr) | exp(Expr,Expr) | min(Expr,Expr)mínimo de 2 argumentos | max(Expr,Expr)máximo de 2 argumentos | #(Const) constantes numéricas

40. Interfaz del Resolutor - clpq • entailed(+Restriccion) Tiene éxito si y sólo si la restricción lineal implica la restricción actual. • inf(+Expr, -Inf) o inf(+Expr, -Inf, +Vector, -Vertex) Calcula el ínfimo de la expresión lineal Expr y unifica con Inf.

41. Interfaz del Resolutor - clpq • sup(+Expr, -Inf) o sup(+Expr, -Inf, +Vector, Vertex) Calcula el supremo de la expresión lineal Expr y unifica con Inf. • minimize(+Expr) Devuelve el minimo valor de la expresión Expr

42. Interfaz del Resolutor - clpq • maximize(+Expr) Devuelve el máximo valor de la expresión Expr • bb_inf(+Ints, +Expr, -Inf) Devuelve en Inf en valor ínfimo de Expr con la restricción adicional de que las variables de la lista Ints toman valores ínfimos.

43. Unificación entre clpr y clpq • clp(r) ?- {2*A+3*B=C/2}, C=10.0, A=B. •  A = 1.0, • B = 1.0, • C = 10.0   Esto es equivalente con errores a: • clp(r) ?- {2*A+3*B=C/2, C=10, A=B}.  • A = 1.0, • B = 0.9999999999999999, • C = 10.0

44. Unificación entre clpr y clpq • clp(q) ?- {2*A+3*B=C/2}, C=10.0, A=B. • {TYPE ERROR: _165=10.0 - arg 2: expected 'a rational number', found 10.0} Esto es porque 10.0 no es un racional. Para poder satisfacer esta operación en clp(Q) debemos hacer lo siguiente: • clp(q) ?- {2*A+3*B=C/2}, C=rat(10,1), A=B.  • A = 1,B = 1,C = 10

45. Resolutor de restricciones booleanas- library (ClpB) • Trabaja sobre el dominio booleano, es decir, los valores 0 y 1. • Es útil para el modelado, diseño, verificación y optimización de circuitos digitales. • Desde consola: • | -? Use_module (library(clpb)). • Cabecera Programa : • : - Use_module (library(clpb)).

46. Expresiones booleanas • P y Q expresiones booleanas, X variable lógica, ls lista de enteros o rangos de enteros, Es lista de expresiones booleanas. • ~ P Verdadero si P es falsa. • P * Q Verdadero si P y Q son ambas verdaderas. • P + Q  Verdadero si al menos uno de P o Q es cierto. • P # Q Verdadero si exactamente uno de P o Q es cierta. • X ^ P Verdadero si existe un X tal que P es cierto. Igual que P[X/0]+P[X/1].

47. Expresiones booleanas • P =: = Q Igual que ~ P # Q. • P = \ = Q Igual que P # Q. • P = < Q Igual que ~ P + Q. • P > = Q Igual que P + ~ Q. • P < Q Igual que ~ P * Q. • P > Q Igual que P * ~ Q. • card(Is, Es)  Verdadero si el número de expresiones verdaderas de Eses un miembro del conjunto denotado por Is.

48. Interfaz de resolutor-clpb • sat(+Expression) Comprueba si Expression es consistente con las restricciones y si lo es devuelve true. • taut(+Expression, ?Truth) Pregunta si Expression esta afectada por las restricciones con Truth=1 o si su negacion esta afectada por restricciones con Truth = 0.

49. Interfaz de resolutor-clpb • labeling(+Variables) Las variables se crean como instancias de una lista de 0s y 1s, para que satisfaga a todas las restricciones acumuladas. Enumera las restricciones por vuelta atrás.

50. Zinc Interface- library (zinc) • Proporciona un intérprete para programas FlatZinc, y a través de un traductor MiniZinc -to-FlatZinc, un intérprete también para programas MiniZinc. • Desde consola: • | -? Use_module (library(zinc)). • Cabecera Programa : • : - Use_module (library(zinc)).