estudio e implementación de algoritmos ac-6 y max-rpc

estudio e implementación de algoritmos ac-6 y max-rpc

PONTIFICIA UNIVERSIDAD CATÓLICA DE VALPARAÍSO
FACULTAD DE INGENIERÍA
ESCUELA DE INGENIERÍA INFORMÁTICA
ESTUDIO E IMPLEMENTACIÓN DE ALGORITMOS
AC-6 Y MAX-RPC
JAIME DAMIÁN ROMERO FERNÁNDEZ
HÉCTOR ANDRÉS ORTEGA MATURANA
INFORME FINAL DE PROYECTO II
PARA OPTAR AL TÍTULO DE
INGENIERO DE EJECUCIÓN EN INFORMÁTICA
JUNIO 2015
PONTIFICIA UNIVERSIDAD CATÓLICA DE VALPARAÍSO
FACULTAD DE INGENIERÍA
ESCUELA DE INGENIERÍA INFORMÁTICA
ESTUDIO E IMPLEMENTACIÓN DE ALGORITMOS
AC-6 Y MAX-RPC
JAIME DAMIÁN ROMERO FERNÁNDEZ
HÉCTOR ANDRÉS ORTEGA MATURANA
Profesor Guía: Ricardo Soto de Giorgis.
Profesor Co-referente: Ignacio Araya.
Carrera: Ingeniería de Ejecución en Informática.
JUNIO 2015
Agradezco
el
apoyo
incondicional brindado por mis
padres, Héctor y Luz, sin ellos nada
podría haber sido posible. . A mi
compañero y amigo, Jaime, por el
arduo trabajo en conjunto realizado.
Y finalmente Agradecer la guía de
los profesores y el conocimiento
entregado.
Agradezco
el
apoyo
incondicional a todas las personas
que creyeron en mi al momento de
entrar a la universidad, a mis
amigos, familiares, principalmente
mis padres, los profesores que
fueron
fundamentales
en
mi
desarrollo académico y en especial a
mi compañero y amigo Héctor por
ser una de las personas clave de este
proceso.
Índice
Resumen.........................................................................................................................iv
Abstract .......................................................................................................................... v
Lista de Figuras.............................................................................................................vi
Lista de Tablas .............................................................................................................vii
1.
Introducción ......................................................................................................... 1
2.
Definición de Objetivos ....................................................................................... 2
2.1
Objetivo General ................................................................................................ 2
2.2
Objetivos Específicos ........................................................................................ 2
3.
Bases de la Programación con Restricciones .................................................... 3
3.1
Problema de Satisfacción de Restricciones........................................................ 3
3.1.1. Definición de un Problema de Satisfacción de Restricciones ..................... 4
3.1.2. Modelado de un Problema de Satisfacción con Restricciones .................... 4
3.2
Algoritmos de Búsqueda .................................................................................... 6
3.2.1 Generate and Test (GT) ................................................................................... 6
3.2.2 Backtracking (BT) ........................................................................................ 7
3.3
Técnicas de Consistencia ................................................................................... 8
3.3.1. Consistencia de Nodo .................................................................................. 8
3.3.2. Consistencia de Arco ................................................................................... 9
3.3.3. Consistencia de camino ............................................................................... 9
4.
Algoritmo de Arco Consistencia....................................................................... 10
4.1
5.
Algoritmo AC-6 ............................................................................................... 10
Algoritmo de consistencia de camino. .............................................................. 12
5.1
6.
Algoritmo MAX-RPC...................................................................................... 12
Investigación ...................................................................................................... 16
6.1
Heurística Completa......................................................................................... 17
6.1
Heurística Optimista. ....................................................................................... 21
6.2
Heurística Pesimista. ........................................................................................ 23
7.
Generador de CSP ............................................................................................. 24
8.
Resultados .......................................................................................................... 26
i
8.1
Resultados Heurística Completa. ..................................................................... 26
8.2
Resultados Heurística Optimista. ..................................................................... 27
8.3
Resultados Heurística Pesimista. ..................................................................... 28
8.4
Análisis final de resultados. ............................................................................. 29
9.
Conclusiones ....................................................................................................... 30
10.
Referencias ......................................................................................................... 31
11.
Anexos ................................................................................................................. 32
11.1 Ejemplo AC-6 .................................................................................................. 32
11.2 Ejemplo MAX-RPC ......................................................................................... 36
11.3 Diagrama heurística optimista ......................................................................... 40
11.4 Diagrama heurística pesimista ......................................................................... 41
11.5 Problemas utilizados ........................................................................................ 42
11.5.1. P1 ............................................................................................................. 42
11.5.2. P2 ............................................................................................................. 42
11.5.3. P3 ............................................................................................................. 43
11.5.4. P4 ............................................................................................................. 43
11.5.5. P5 ............................................................................................................. 44
11.5.6. P6 ............................................................................................................. 45
11.5.7. P7 ............................................................................................................. 46
11.5.8. P8 ............................................................................................................. 47
11.5.9
P9 ............................................................................................................. 48
11.5.10. P10 ......................................................................................................... 49
11.5.11. P11 ......................................................................................................... 50
11.5.12. P12 ......................................................................................................... 51
11.5.13. P13 ......................................................................................................... 52
11.5.14. P14 ......................................................................................................... 53
11.5.15. P15 ......................................................................................................... 54
11.5.16. P16 ......................................................................................................... 55
11.5.17. P17 ......................................................................................................... 56
11.5.18. P18 ......................................................................................................... 57
11.5.19. P19 ......................................................................................................... 58
ii
11.5.20. P20 ......................................................................................................... 59
iii
Resumen
Los Problemas de Satisfacción de Restricciones conocidos como CSPs se definen
como problemas compuestos por variables asociadas a dominios y restricciones. La
programación con restricciones es el paradigma de programación utilizado para resolver
problemas relacionados con la optimización y la investigación operativa en general. Los CSPs,
generalmente, se resuelven utilizando un árbol de búsqueda en donde en cada uno de los
niveles se instancia una de las variables del problema. De esta manera, las soluciones, si
existen, se encontrarán en las hojas del árbol. Para evitar recorrer todo el árbol en el proceso
de búsqueda de una solución, existen técnicas para eliminar valores inconsistentes, es decir
valores de las variables con los que nunca se obtendrá una solución. Estas técnicas se
denominan Técnicas de Consistencia.
En este proyecto se implementan dos algoritmos de Técnicas de Consistencia llamados
AC6 y MAX-RPC. A partir de esto se busca demostrar la siguiente hipótesis: Dos o más
algoritmos en conjunto tienen mejor rendimiento que uno por sí solo. Para efectos de este
informe los algoritmos que se encargan de intercalar dos o más algoritmos de consistencia se
denominan adaptativos. Las experimentaciones se realizan usando un conjunto de 20
instancias de prueba, las cuales tienen diferentes estructuras, permitiendo así evaluar el
comportamiento de cada algoritmo adaptativo en diversos contextos de ejecución.
Palabras Claves: Problemas de Satisfacción, Técnicas de Consistencia, ArcoConsistencia, Consistencia Adaptativa, Camino-Consistencia.
iv
Abstract
The constraint satisfaction problems known as CSPs are defined as problems
composed of variables associated to domains and constraints. Constraint Programing is the
programming paradigm that uses CSPs to solve problems related to optimization and
operations research in general. CSPs are solved by using a search tree, where each level
corresponds to a variable of the CSP. To avoid instantiating all nodes of the search tree in the
search process, there exist techniques to delete inconsistent values, i.e., values for the variables
that do not lead to any solution. These techniques are called consistency techniques.
In this project we implement two consistency technique called AC6 and MAX-RPC.
From this start point we aim at demonstrating the following hypothesis: interleaving two or
more algorithms performs better that one by itself. In this report the algorithms that combine
two or more consistency techniques are called adaptive. To perform experiments, we have
used a set of 20 CSPs, which have different structures to evaluate the behavior of each
adaptive algorithm in different execution contexts.
v
Lista de Figuras
Figura 1 N- reinas. ........................................................................................................... 5
Figura 2 Soluciones N- reinas.......................................................................................... 5
Figura 3 Generate and Test en el problema de 4-reinas. ................................................. 7
Figura 4 Backtracking el problema de 4-reinas. .............................................................. 8
Figura 5 Ejemplo de consistencia de Arco. .................................................................... 9
Figura 6 Pseudocódigo AC-6......................................................................................... 11
Figura 7 Pseudocódigo MAX-RPC ............................................................................... 13
Figura 8 PropagDeletion ................................................................................................ 14
Figura 9 IsWithoutPCSupport ....................................................................................... 15
Figura 10 Costos de los filtros. ...................................................................................... 16
Figura 11 Restricciones asociadas a Filtros ................................................................... 17
Figura 12 Periodo de las restricciones ........................................................................... 18
Figura 13 Ejecución Heurística Completa .................................................................... 18
Figura 14 Pseudocódigo Heurística Completa .............................................................. 19
Figura 15 Pseudocódigo Heurística Optimista .............................................................. 22
Figura 16 Pseudocódigo Heurística Pesimista ............................................................... 23
Figura 17 Formato CSP ................................................................................................. 24
Figura 18 AC-6 X=1 ...................................................................................................... 33
Figura 19 AC-6 X=4 ...................................................................................................... 33
Figura 20 AC-6 Z=3 ..................................................................................................... 34
Figura 21 AC-6 Valores de Y ........................................................................................ 34
Figura 22 AC-6 X=3 ...................................................................................................... 35
Figura 23 MAX-RPC Y=2 Instanciación X .................................................................. 36
Figura 24 MAX-RPC Y=2 X=2 instanciación Z .......................................................... 37
Figura 25 MAX-RPC X=1 Instanciación Y .................................................................. 38
Figura 26 MAX-RPC X=1 Y=1 instanciación Z ......................................................... 39
Figura 27 Diagrama Heurística Optimista .................................................................... 40
Figura 28 Diagrama Heurística Pesimista ..................................................................... 41
Figura 29 Problema P1 .................................................................................................. 42
Figura 30 Problema P2 .................................................................................................. 42
Figura 31 Problema P3 .................................................................................................. 43
Figura 32 Problema P4 .................................................................................................. 43
Figura 33 Problema P5 .................................................................................................. 44
Figura 34 Problema P6 .................................................................................................. 45
Figura 35 Problema P7 .................................................................................................. 46
Figura 36 Problema P8 .................................................................................................. 47
Figura 37 Problema P9 .................................................................................................. 48
Figura 38 Problema P10 ................................................................................................ 49
vi
Figura 39 Problema P11 ................................................................................................ 50
Figura 40 Problema P12 ................................................................................................ 51
Figura 41 Problema P13 ................................................................................................ 52
Figura 42 Problema P14 ................................................................................................ 53
Figura 43 Problema P15 ................................................................................................ 54
Figura 44 Problema P16 ................................................................................................ 55
Figura 45 Problema P17 ................................................................................................ 56
Figura 46 Problema P18 ................................................................................................ 57
Figura 47 Problema P19 ................................................................................................ 58
Figura 48 Problema P20 ................................................................................................ 59
Lista de Tablas
Tabla 1 Resultados Heurística Completa ....................................................................... 26
Tabla 2 Resultados Heurística Optimista ...................................................................... 27
Tabla 3 Resultados Heurística Pesimista ....................................................................... 28
vii
1.
Introducción
La programación con restricciones (CP) es un paradigma de programación dedicado
principalmente a la resolución eficiente de problemas de satisfacción de restricciones
conocidos como CSP (Constraint Satisfacción Problem en inglés). Un CSP consta de un
conjunto de variables, dominios y restricciones, que respecta al modelamiento del problema.
Los CSPs se resuelven utilizando un árbol de búsqueda en donde cada uno de los niveles
corresponderá a una variable del CSP. En este proceso intervienen dos tipos de algoritmos:
algoritmos de búsqueda y algoritmos de técnicas de consistencia. Los algoritmos de búsqueda
se encargan de la exploración sistemática del espacio de soluciones hasta encontrar una
respuesta posible o comprobando que el problema no tiene resultado. Por otra parte las
técnicas de consistencia se enfocan en la eliminación de valores desde los dominios de las
variables que no conducen a ninguna solución factible, reduciendo el tamaño del árbol para
minimizar el tiempo de búsqueda.
Las técnicas estudiadas en este trabajo son la Arco-Consistencia y la CaminoConsistencia, ambas utilizan restricciones binarias y tienen como objetivo eliminar valores
inconsistentes de las variables involucradas en las restricciones del problema. La primera
técnica estudiada busca la consistencia local por cada par de variables participantes en una
restricción. Mientras que la Camino-Consistencia es una técnica de consistencia local de alto
nivel, que aplica la Arco-Consistencia en un par de restricciones. En esta investigación la
Arco-Consistencia se representa por el algoritmo AC-6, y la otra técnica es aplicada por el
algoritmo MAX-RPC. Para efectos de este informe los algoritmos que se encarguen de
intercalar dos o más algoritmos de consistencia se denominarán adaptativos. En esta
investigación se proponen 3 algoritmos de consistencia adaptativa: heurística completa,
heurística optimista y heurística pesimista.
1
2. Definición de Objetivos
2.1
x
Objetivo General
Comprender los conceptos básicos de la programación con restricciones para
implementar los algoritmos AC-6 y MAX-RPC.
2.2
Objetivos Específicos
x Comprender los conceptos básicos de la programación con restricciones.
x Implementar los algoritmos AC-6 y MAX-RPC.
x Implementar un sistema de consistencia adaptativa para CSPs.
x Realizar experimentos con la implementación desarrollada.
2
3. Bases de la Programación con Restricciones
La programación con restricciones es una tecnología que tiene sus orígenes en los años
sesenta y su principal objetivo es encontrar soluciones a problemas complejos mediante
restricciones, dichas soluciones deben respetar todas las restricciones declaradas.
En sus inicios CP era utilizada en el área de la inteligencia artificial, y desde allí siguió
desarrollándose durante veinte años, y es en los años ochenta cuando nace el primer lenguaje
de programación basado en restricciones, el que fue hecho en LISP.
¿Cómo se programa con restricciones? Hay tres palabras claves para aclarar esta
incógnita: Modelar y Resolución. Agruparemos las dos primeras, en una primera fase donde se
lleva a cabo el modelado del dominio ya sea con restricciones básicas o restricciones
establecidas por el usuario, imponiendo las reglas que acotarán los posibles valores de las
variables en un espacio definido. El tercer concepto, explorar, utiliza algoritmos que buscan
soluciones o asignaciones de valores a variables que sean factibles tomando siempre en
consideración cada una de las restricciones; A todos estos problemas que cumplan con lo
anterior y se resuelvan a través de CP.
3.1 Problema de Satisfacción de Restricciones
A todos los problemas modelados de tal forma que contengan variables que pueden
tomar valores de un dominio finito, se denominan Problemas de Satisfacción de restricciones
(CSP). Una infinidad de problemas pueden ser modelados de esta forma, en variados ámbitos
tanto en la investigación operativa como en la recuperación de información, o incluso en
problemas más cotidianos como planificar un viaje o preparar un plato de comida están sujetos
a restricciones por lo que se les podría modelar como CSP. Sin embargo, hay ciertas
soluciones que, aunque cumplan con el conjunto de restricciones, son más convenientes en
algunas ocasiones y no tan conveniente en otras, por lo que se hace necesario tener más de una
solución para lograr obtener una solución óptima.
La resolución de un CSP es un proceso divido en dos subprocesos fundamentales para
la obtención de una solución. Para describir la fase inicial se ocupa el término modelado. La
modelación es un paso importantísimo a la hora de realizar el proceso de resolución, ya que se
ordena el problema estructurándolo de tal manera que sea compatible en la sintaxis de CSP, en
otras palabras, expresa el problema como variables, dominio y restricciones.
Luego de terminada la etapa de modelado, se avanza a la fase de resolución, en donde
se toman variables, dominios y restricciones anteriormente definidas y se procesan utilizando
algoritmos de búsqueda o técnicas de consistencia para encontrar una o múltiples soluciones,
que respeten todas las restricciones, las que no necesariamente son óptimas. La acción en
conjunto de los algoritmos de búsqueda junto con las técnicas de consistencia permite reducir
el espacio de solución y explorar solo el espacio resultante, con el objetivo de obtener una
solución al problema de forma más rápida.
3
En cada una de las fases sobresalen términos que no se puede dejar de definir y serán
detallados a continuación:
Asignación: también llamada instanciación, son valores del dominio que se le conceden
a una variable, por ejemplo: (x,a) representa que el valor de x es asignado a la variable a, es
decir , la variable a es instanciada con el valor x.
Solución: concepto muy utilizado en la presente investigación. es una asignación de
valores a todas las variables de forma que satisfaga todas las restricciones.
3.1.1. Definición de un Problema de Satisfacción de Restricciones
En términos generales, un problema de satisfacción de restricciones se representa como
una terna (V, D, R) donde:
x V es un conjunto de variables ‫ݒ‬ଵ ǡ ‫ݒ‬ଶ ǡ ‫ݒ‬ଷ ǡ ǥ ǡ ‫ݒ‬௡ Ǥ
x D es un conjunto de dominios ݀ଵ ǡ ݀ଶ ǡ ǥǡ ݀௡ ǤDonde ݀௜ corresponde a los valores
posibles que puede tomar la variable ‫ݒ‬௜ , con ݅ ൌ ͳǡ ǥ ǡ ݊.
x C es el conjunto finito de restricciones ܿଵ ǡ ܿଶ ǡ ǥ ǡ ܿ௠ tal que ܿ௝ , donde ݆ ൌ ͳǡ ǥ ǡ ݉, es la
relación sobre el conjunto de variables ሼ‫ݔ‬ଵ ǡ ‫ݔ‬ଶ ǡ ǥ ǡ ‫ݔ‬௡ ሽ. Una restricción es binaria si se
relacionan únicamente dos variables como ‫ݔ‬௜ ‫ݔݕ‬௝ y se denotan como ܿ൫‫ݔ‬௜ ǡ ‫ݔ‬௝ ൯ǤC es la
encargada de restringir los valores que pueden tomar las variables V [5].
3.1.2. Modelado de un Problema de Satisfacción con Restricciones
Existen diferentes formas de representar un problema de satisfacción de restricciones,
incluso las restricciones pueden ser representadas ya sea como ecuaciones o como tuplas
válidas y no válidas para los problemas. En esta ocasión, se modela un ejemplo de CSP muy
conocido, llamado N-reinas para plasmar el modelado de CSP.
3.1.2.1.
N–reinas
La idea principal del problema de las N-reinas consiste en ubicar un tablero de ajedrez
de n unidades de largo y n unidades de ancho, y que a la vez posea igual número de reinas, en
este caso n. La problemática radica en que una reina no debe amenazar a las restantes reinas
dentro del tablero, en el juego de ajedrez la reina amenaza a todas las figuras que están en la
misma fila, columna o diagonal, por lo tanto dos o más reinas no pueden coincidir
horizontales, verticales, ni diagonalmente, tal como se muestra en la figura 1. En el presente
ejemplo se ocupará un tablero de 4x4, por lo tanto el número de reinas será 4.
4
Figura 1 N- reinas.
El modelo sería el siguiente, definiendo en primer lugar las variables correspondientes a
cada fila del tablero y el dominio del CSP, en este caso a las columnas del tablero.
ܴଵ ǡ ܴଶ ǡ ܴଷ ǡ ܴସ ߳ሾͳǡͶሿǤ
Cada ܴ௜ tiene asociado un valor j perteneciente al dominio, es decir, una reina R se
encuentra ubicada en la intersección de la fila i con la columna j.
Luego se definen las restricciones del CSP
ƒ Las reinas deben estar en distintas filas:
ܴ௜ ് ܴ௝ Ǥ
ƒ Las reinas no deben colocarse en diagonal:
ܴ௜ ൅ ݅ ് ܴ௝ ൅ ݆›ܴ௜ െ ݅ ് ܴ௝ െ ݆Ǥ
Ya definidas las variables, los dominios y las restricciones del problema, simplemente se
ordenan con la sintaxis adecuada y se procede a finalizar la etapa de modelado. El resultado de
esta fase es el siguiente:
Variables: R = {R1, R2, R3, R4}, una reina ubicada en cada fila.
Dominios: ୧ = {1, 2, 3, 4}, un valor por cada columna.
Restricciones: ܴ௜ ് ܴ௝ ǡܴ௜ ൅ ݅ ് ܴ௝ ൅ ݆›ܴ௜ െ ݅ ് ܴ௝ െ ݆Ǥ
Ya terminada la etapa da modelado se procede a resolver el problema. Al unir todos
los elementos anteriores se llega a posibles soluciones del CSP de N-reinas observables en la
siguiente ilustración, en ambas se respetan todas las restricciones ya que ninguna reina puede
amenazar a otra.
Figura 2 Soluciones N- reinas.
5
3.2
Algoritmos de Búsqueda
Hay algoritmos especializados para buscar soluciones en CSPs, los llamados
Algoritmos de Búsqueda recorren posibles soluciones en un conjunto de posibles instancias de
variables, sin embargo, ocupan distintas metodologías para lograr encontrar soluciones que no
infrinjan ninguna de las restricciones, esto se verá en detalle más adelante.
Existen dos grandes tipos de algoritmos para realizar búsquedas, estos son, los
completos e incompletos, y la principal diferencia entre ambos radica en el área de búsqueda
de soluciones. A los algoritmos incompletos también se les llama locales ya que realizan la
búsqueda solo en una sección del espacio de estados por lo que no garantiza una solución, y
mucho menos una solución óptima, no obstante, tienen la ventaja de reducir costos al recorrer
menos espacio que las búsquedas completas y al mismo tiempo son más veloces. Su
funcionamiento parte desde una solución inicial, la que itera varias veces dirigiéndose cada
vez a una solución distinta, tratando de mejorar el valor de la función objetivo.
El segundo grupo son los algoritmos completos, los cuales recorren la totalidad del
espacio buscando una solución, mediante la asignación de valores a las variables en un árbol
que representa cada una de las asignaciones realizables, el nodo raíz de dicho árbol representa
el problema sin variables asignadas. Con el objetivo de resolver CSP, se han desarrollado una
gran cantidad de algoritmos de búsqueda completa los que trabajan realizando búsquedas en la
totalidad del espacio de estados siendo algunos de ellos más eficientes que otros. Para
simplificar la explicación de los algoritmos de búsqueda, se utilizará el mismo ejemplo que
anteriormente se usó en CSP, de esta manera se hace más fácil comprender el funcionamiento
de los diferentes algoritmos que buscan las posibles soluciones.
3.2.1 Generate and Test (GT)
Es la técnica de búsqueda más simple, ya que instancia cada uno de los posibles
valores a las variables y recorren sistemáticamente todo el árbol de búsqueda, su nombre
deriva de las dos principales acciones que lleva acabo, Generar la instanciación de una
variable a la vez, hasta llegar al nodo hoja, luego procede a comprobar si estas cumplen con
las restricciones planteadas en el problema. Este método tiene la desventaja de ser muy
costoso y lento al momento de buscar una solución, ya que genera asignaciones que no
cumplen con las restricciones lo que se traduce en pérdida de tiempo y costo.
6
Figura 3 Generate and Test en el problema de 4-reinas.
Aplicando GT en el problema de las N-reinas, se concibe una gran cantidad de
instanciaciones innecesaria, ya que cuando se llega al término de una rama (nodo hoja), como
se muestra en la Figura 3, teniendo todas las variables instanciadas comprueba si se satisfacen
todas las restricciones, Demostrando la ineficiencia de este método.
3.2.2
Backtracking (BT)
Otro algoritmo de búsqueda de CSP es el conocido Bakctracking, su forma de trabajo
es similar a Generate and Test, pero con la gran diferencia que logra eliminar la ineficiencia de
GT. Cabe mencionar que el algoritmo de Backtracking asume dos cosas: por un lado, el CSP
es binario, y por otro lado asume que tanto las variables como sus dominios son estáticos. Este
algoritmo abarca dos procesos, el primero es hacia adelante en donde se selecciona la
siguiente variable y se instancia con el próximo valor, comprobando que no se entre en
conflicto con las restricciones del problema, en caso de que eso ocurra, se realiza el segundo
proceso (hacia atrás) donde el algoritmo deshace la asignación actual e intenta instanciar la
variable con otro valor, si no se encuentra un valor que satisfaga la inconsistencia, entonces
retrocede tomando en cuenta la variable anterior y evitando el recorrido innecesario de la rama
que cuelga de la última asignación. Los dos procesos se repiten hasta completar el recorrido
del árbol donde las variables toman valores consistentes con las restricciones planteadas.
7
Figura 4 Backtracking el problema de 4-reinas.
3.3
Técnicas de Consistencia
Los algoritmos de búsqueda por si solos son insuficientes para la resolución óptima de
un CSP, por lo que se hace necesaria la utilización de técnicas que permitan mejorar su
funcionamiento a la hora de resolver un problema. Estas técnicas se utilizan como etapas de
pre-proceso donde se detectan y se eliminan las inconsistencias locales, antes de empezar la
búsqueda o durante el proceso de búsqueda en sí, con el fin de reducir los nodos a instanciar
en el árbol de búsqueda [1].
Gracias a las técnicas de consistencia, se evita que busque una solución que no existe,
lo que permite ahorrar tiempo y que no se entorpezca el buen funcionamiento de los
algoritmos. La continua aparición de valores individuales o conjunto de ellos que no pueden
participar de ninguna solución, esto es lo que se conoce como inconsistencia local, es por esto
que estas técnicas son tan necesarias, ya que eliminan valores inconsistentes de los dominios
de las variables, con lo que se acota el universo de soluciones en un problema.
Si bien estas técnicas ayudan en demasía a la resolución de un problema, no quiere
decir que todo lo restante que queda en el árbol son soluciones, pero si se reduce la
complejidad del problema.
3.3.1. Consistencia de Nodo
La consistencia de nodo o también conocida nodo-consistencia corresponde al nivel
más básico de consistencia, donde se eliminan los valores inconsistentes con las restricciones
unarias donde participa la variable [1]. Una variable xi es nodo-consistente si y sólo si todos
los valores de su dominio Di son consistentes con las restricciones unarias sobre las variables.
Un CSP es nodo-consistente si y sólo si todas sus variables son nodo-consistentes: ‫ܺ׊‬௜ ‫א‬
ܺǡ ‫ܴ׊‬௜ ‫ ܴ א‬: ܺ௜ •ƒ–‹•ˆƒ…‡ܴ௜ . De lo contrario, si los valores contenidos en el dominio de la
variable x no pueden satisfacer las restricciones, se está frente a una inconsistencia,
8
pudiéndose eliminar los valores del dominio de la variable x, ya que no serían parte de
ninguna solución.
3.3.2. Consistencia de Arco
La consistencia de arco tiene como principal característica el hecho de que trabaja con
restricciones binarias en vez de unaria como lo hacía la nodo-consistencia [1]. Un CSP es
arco-consistente si para todo par de dominios ‫ܦ‬௜ ›‫ܦ‬௝ , ‫ݖ ് ݕ‬, y una restricción ܴ௡ se cumple
que:
‫ݔ׊‬௜ ‫ܦ א‬௬ ǡ ‫ݔ׌‬௝ ‫ܦ א‬௭ ൫‫ݔ‬௜ ǡ ‫ݔ‬௝ ൯ Cumple restricción
Si se cumple con lo antes mencionado, se podrá eliminar cualquier valor del dominio
‫ܦ‬௬ de la variable ‫ݔ‬௜ que no sea arco-consistente, esto porque no será parte de ninguna
solución.
Figura 5 Ejemplo de consistencia de Arco.
Como se muestra en la figura X, se tienen dos variables cada una con dominio propio;
La restricción indica que ܺ௜ ൏ ܺ௝ , en este caso, para cada variable ܽ existe un ܾ que cumple
con la restricción, por lo tanto es arco-consistente, sin embargo, si la restricción fuera ܺ௜ ൌ
ܺ௝ , el problema no sería arco consistente, ya que ningún n cumple con la restricción
planteada.
3.3.3. Consistencia de camino
La consistencia de camino es un nivel más alto de consistencia local comparada con la
consistencia de arco. Un CSP es camino-consistente si para cada par de valores a y b, para
dos variables Xi y Xj, de tal forma que a es una asignación para Xi y b, para Xj, y Cij
representa las restricciones entre Xi y Xj, existe un valor para cada variable que a lo largo de
cualquier camino entre Xi y Xj, todas las restricciones Cij son satisfechas.
9
4. Algoritmo de Arco Consistencia
Como ya se mencionó anteriormente, lo que se logra con las técnicas de arcoconsistencia es poder eliminar algunos valores que jamás formarán parte de una solución, es
decir, restringir los dominios de dos variables asociadas a una restricción, esto último es lo que
se conoce como restricciones binarias [1].
El proceso secuencial mediante el cual se realizan las técnicas de arco-consistencia, se
llama propagación. El algoritmo de arco-consistencia a utilizar en el presente estudio será
AC-6. A continuación se explica brevemente en los que consiste el algoritmo.
4.1 Algoritmo AC-6
AC-6, propuesto por Bessière y Cordier [1], es un algoritmo que requiere las siguientes
estructuras de datos:
x
x
x
Los dominios de las variables deben estar ordenados de forma ascendente.
Q es una lista de tuplas, formadas por la variable y su respectivo valor (Xi,Vi), y
contiene las tuplas que son eliminadas del dominio.
S es una matriz que almacena para cada una de sus casillas, el soporte más pequeño
encontrado.
El algoritmo AC-6 consta de un esquema de dos fases, impuestas por el algoritmo AC4. Las cuales son: inicialización y propagación. AC-6 busca un solo soporte b perteneciente a
Dj (el más pequeño) para cada valor de a perteneciente a Di, que cumpla con la restricción Rij.
Cada vez que el valor de un soporte b es encontrado, se almacena el valor de a junto con la
variable Xi en la lista S como uno de los valores con soporte en la variable Xj con el valor b.
En caso de que el valor de b sea eliminado del dominio de Xi, el algoritmo busca el siguiente
soporte para cada uno de los valores que fueron almacenados en la lista S para la variable Xj.
Cada vez que un soporte no cumple con la restricción, es almacenada la base evaluada (el
valor y la variable Xi) en la lista Q. Si se da el caso de que el dominio de Xi quede vacio, se
termina la fase de inicialización y se procede con la siguiente fase [3].
En la fase de propagación, una vez guardados todos los soportes en las listas S
y los valores erróneos en la lista Q. Se procede a extraer cada elemento de la lista Q, se busca
su correspondiente lista S. Por cada elemento de esta lista S, se busca un valor Vj’ que sea el
valor más pequeño, mayor que el valor Vj de la lista Q y que cumpla la restricción Rij. Si este
valor es encontrado, se agrega el valor de Xi y la variable a la lista S del par Xj, Vj’. Si no
existe tal Vj’, se elimina el valor Vi del dominio de Xi. Además, si el dominio de Xi queda
vacio, la fase de propagación se interrumpe y se termina el proceso.
10
AC-6() :boolean
inicio
/*Inicialización*/
Q ←ø;
S[xj
, vj ] = ø , ‫׊‬vj
‫ א‬D(xj ) , ‫ ׊‬xj
foreach xi ‫ א‬X, cij ‫ א‬C, vi ‫א‬
vj
‫א‬
X;
D( xi ) do
← valor más pequeño en D(xj) tal que (vi , vj) ‫ א‬cij ;
if ‫׌‬vj then agregar (xi,vi) a S[xj
, vj ] ;
else eliminar vi de D(xi) y agregar (xi , vi) a Q ;
if D(xi) = ø then return false ;
/* propagacion*/
while
Q ്ø do
pop(Q);
foreach (xi , vi) ‫ א‬S[xj
, vj ] do
if vi ‫ א‬D(xi) then
vj’
← valor más pequeño en D(xj) mayor que vj , tal
que (vi , vj) ‫ א‬cij ;
if ‫׌‬vj’ then agregar (xi,vi) a S[xj
, vj' ] ;
else eliminar vi de D(xi) y agregar (xi , vi) a Q ;
if D(xi) = ø then return false ;
return true ;
fin
Figura 6 Pseudocódigo AC-6
11
5. Algoritmo de consistencia de camino.
La camino consistencia requiere que para cada valor de a y b de dos variables Xi y Xj,
que satisfacen la restricción entre Xi e Xj, existan valores para ambas variables a lo largo del
camino entre Xi y Xj de forma que todas las restricciones a lo largo del camino se satisfagan.
Se define un par de variables Xi y Xj como Camino-Consistentes si y solo si
‫(׊‬a; b) ‫ א‬Rij ; ‫׊‬Xk ‫ א‬X; ‫ ׌‬c ‫ א‬Dk de tal forma que c esta soportado por a en Rik y c esta
soportado por b en Rjk[1].
Se define también un Problema de Satisfacción de Restricciones (CSP) binario es
Camino-Consistente si y solamente si ‫׊‬Xi;Xj ‫ א‬X; (Xi;Xj) es Camino consistente [1]
.
5.1
Algoritmo MAX-RPC.
La idea de MAX-RPC es usar AC-6 en dos oportunidades, la primera para demostrar
la camino consistencia de un valor (i, a), MAX-RPC busca en el dominio de cada variable
vinculada a i, para el soporte camino consistente más pequeño que este valor tenga. Para
determinar si un valor (j, b) es compatible con (i, a) siendo un suporte camino consistente,
MAX-RPC busca el soporte común más pequeño de (i, a) y (j, b) en el dominio de cada
variable k vinculada a i y j [3].
MAX-RPC necesita las siguientes estructuras de datos para su funcionamiento:
x
x
x
x
Los valores para los cuales (j, b) es el soporte camino consistente más pequeño que
está almacenado en la lista SAC[j,b].
Una Lista SPC[k,c],para almacenar el par de valores (i, a), (j, b) camino consistente,
tal que (k,c) es el soporte más pequeño en común entre (i ,a) y (j, b) en Dk.
una lista DeletionList, para los valores eliminados para los que la eliminación no ha
sido propagada aun.
Una lista InitList, para almacenar los arcos [(i, j), a], que se generan si el algoritmo no
ha verificado si (i, a) es un soporte camino consistente en Dj.
El algoritmo MAX-RPC comienza por inicializar las dos listas, DeletionList y InitList.
Luego para todas las tuplas (i, a) que pertenezcan a D se inicializan sus respectivas listas
SAC[i,a] y SPC[i,a] en cero. Una vez realizado este proceso de inicialización se procede a
realizar para cada una de las restricciones el llenado de la lista InitList, con tres parámetros, los
dos primeros representan las variables que son parte de la restricción (i,j) y el ultimo es el
valor de la variable el cual se está evaluando (a). Se repite esta acción hasta que se hayan
agregado a la InitList todos los valores de a que pertenezcan al dominio de i.
12
Max_RPC()
inicio
DeletionList ← ø;
InitList ← ø;
foreach (i , a) ‫ א‬D do
SPC[i
, a ] = ø;
SAC[i
, a ] = ø;
foreach
cij ‫ א‬C do
agregar [(i , j) , a]
while
a InitList;
InitList ്ø o DeletionList ്ø do
if DeletionList ്ø then
pop(DeletionList);
PropagDeletion(i , a , DeletionList);
else
pop(InitList);
if IsWithoutPCSupport(i , a , j , null) then
eliminar a de D(i) y agregar (i , a) a
DeletionList ;
fin
Figura 7 Pseudocódigo MAX-RPC
Se procede en el algoritmo desde la línea seis de la Figura 14, en la cual se realiza una
iteración mientras existan valores en la InitList o en la DeletionList.
Si existe un elemento en la DeletionList se extrae y se llama a la función
PropagDeletion (Figura 15). Si no es este el caso se realiza la misma acción pero con la
InitList y se llama a la función IsWithoutPCSupport (figura 16), si esta retorna true se procede
a remover del domino de i la variable a y se agrega esta tupla a la DeletionList.
13
PropagDeletion( j , b , DeletionList)
inicio
while SAC[j
, b ]
pop( SAC[j
്ø
do
, b ] );
if a ‫ א‬D(i) and
IsWithoutPCSupport(i , a , j , b) then
eliminar a de D(i) y agregar (i , a) a DeletionList ;
while SPC[j
, b ]
pop( SPC[j
്ø
do
, b ] );
if a ‫ א‬D(i)
and c ‫ א‬D(k) and (i , a) ‫א‬
SAC[k
, c ]
then
b’
←
b;
if IsPathConsitent(i , a , k , c , j , b’) then
agregar ( [i , a , k , c] ) a SPC[j
, b’ ];
else
eliminar (i , a) de SAC[k , c] ;
if
IsWithoutPCSupport(i , a , k , c) then
eliminar a de D(i) y agregar (i , a) a
DeletionList ;
fin
Figura 8 PropagDeletion
La función PropagDeletion (Figura 15) se encarga de agregar los elementos a eliminar
en la lista DeletionList. Para esto, primero recorre la lista SAC[j,b], en la cual por cada
elemento verifica si el valor a de la tupla (i,a) está en el dominio de la variable i y si esta tupla
no tiene un soporte camino consistente (línea 3), si es tal el caso, elimina el valor a del
dominio de i, y agrega la dupla en cuestión a la lista DeletionList. Luego, repite la misma
operación, pero sobre la lista SPC[j,b]. Si bien la lógica es la misma, cambia un poco la
operación por la naturaleza de la lista SPC[j,b]. en la línea 7, se verifica si los valores
pertenecen a los dominios correspondientes y si la base (i, a) pertenece a la lista SAC. De ser
cierto, se busca un valor b’ de tal manera que la 3-tupla (i, a),(k, c) y (j, b’) sea camino
consistente. En el caso verdadero, se agrega la tupla (i, a), (k, c) a la lista SPC[j,b’]. En caso
contrario, se verifica si la tupla (i, a), (k, c) no tiene soportes camino consistentes para agregar
el par (i, a) a la lista DeletionList y remover del dominio de i el valor a.
14
IsWithoutPCSupport( i , a , j , b ) :boolean
Inicio
Common
←
k ‫ א‬X , tal que cik ‫ א‬C y cjk ‫ א‬C ;
WithoutPCSupport ← true;
b’ ← b;
while
b’
്last( D(j) ) and WithoutPCSupport
do
b’ ← b’ + 1;
if cij( a , b’) then
PConsistent ← true;
for k ‫ א‬Common while PConsistent do
c ← null;
if IsPathConsitent(i , a
, j , b’, k , c) then
CS[k] ← c;
else
PConsistent ← false;
if
PConsistent then
for k ‫ א‬Common
do
agregar ( [i , a , j , b’] ) a SPC[ k
,
CS[k] ];
agregar ( [i , a] ) a SAC[j
, b’ ];
WithoutPCSupport ← false;
return
WithoutPCSupport;
fin
Figura 9 IsWithoutPCSupport
La función IsWithoutPCSupport se encarga de llenar las dos colas SPC y SAC, la
primera contiene dos tuplas las cuales la primera es la base recibida y la segunda es el soporte
más pequeño que cumpla con las restricciones y es guardada en su respectiva lista SPC de la
tupla que sea camino consistente de los valores que guarda. La segunda guarda la base en la
lista del soporte más pequeño que cumpla con la restricción.
Esta función retorna falso si existe al menos una variable que sea camino consistente
con las tuplas de entrada, en caso contrario retorna verdadero si no existen estos valores.
15
6. Investigación
Se entiende por adaptativos para efectos de este informe, a cualquier algoritmo que se
encargue de realizar la acción de poder alternar los algoritmos AC-6, Max-RPC y SAC-OPT
de manera tal, que al momento de recorrer el árbol de búsqueda estos se vallan intercalando y
se entenderá a su vez por heurística al método que tomara la decisión de en qué momento se
irán intercalado de los algoritmos.
Se pretende lograr mediante el adaptativos utilizar más de un algoritmo para la
resolución de CSPs, y verifica si esta alternancia afecta positivamente en el desempeño del
algoritmo. En la práctica se desea crear algoritmos que mejoren considerablemente el tiempo
para encontrar una o todas las soluciones. A priori se planea utilizar arco-consistencia y
camino-consistencia adaptativa junto al algoritmo de búsqueda Backtracking.
Para comprender los algoritmos adaptativos, primero se debe entender el costo que
conlleva utilizar cada una de las técnicas de consistencia, para este informe AC-6 Max-RPC y
SAC-OPT, los cuales para efectos del documento se denominan Filtros. Cada uno de estos
filtros conlleva el uso de complejas estructuras de datos diferentes, las cuales producen que
una estas sea más costosa en tiempo de ejecución con respecto a otra.
La relación que tiene un Filtro en su costo con respecto a la cantidad de poda debiese
ser directamente proporcional, es decir si un Filtro tiene un mayor costo esto significara que la
cantidad de poda debería será mayor y por lo tanto el tiempo de búsqueda de una solución se
verá reducida.
Basado en esta definición, se utilizaran los filtros dependiendo del costo que tenga cada
uno, es decir, si un Filtro tiene un costo mayor se pretenderá utilizarlo con menos frecuencia,
dependiendo del adaptativo, por otro que tenga menor costo. Para los Filtros utilizados en este
informe los costos asociados se muestran en la siguiente figura.
Figura 10 Costos de los filtros.
SAC = Singleton Arc Consistency.
MAX-RPC = Max Restricted Path Consistency.
PIC = Path Inverse Consistency.
RPC = Restricted Path Consistency.
16
AC = Arc Consistency.
En la figura 17 se muestra los costos de mayor a menor, de izquierda a derecha. Para
esta investigación se trabajara con SAC, MAX-RPC y AC.
Con esto presente, se toma en cuenta que cada uno de los filtros que serán aplicados al
árbol de búsqueda conllevan un costo asociado y dependiendo de tipo de filtro este costo
podría ser mayor o menor. Es por ello que se han formulado tres heurísticas las cuales tendrán
distintos tipos de decisiones, basándose en la cantidad de poda y decidirán cuál o cuáles serán
los próximos algoritmos que se ejecutarán.
6.1
Heurística Completa.
Esta heurística se caracteriza por la utilización de los tres Filtros en cada uno de los
nodos del árbol. En su ejecución, considera los resultados obtenidos al aplicar una restricción
en el filtro asociado, e ir aplicando con menor periodo aquellas que obtiene resultados
positivos en la poda de valores inconsistentes. Para esto, esta heurística recibe por parámetro
un valor L, el cual indica el máximo de veces con resultados negativos consecutivos por parte
de una restricción. Con esto, cuando una restricción alcanza este umbral, su periodo se
aumenta y disminuye la carga de ejecución del filtro asociado [2].
Para la ejecución primeramente se asocian todas las restricciones del CSPs a cada uno
de los filtros, de la siguiente manera:
Figura 11 Restricciones asociadas a Filtros
Como se busca aumentar la poda de valores incorrectos, si se percibe que una
restricción asociada a un filtro no produce alguna poda se aumentara su contador de fallos.
Dependiendo de la cantidad en la que esta situación ocurra, el periodo de esta restricción irá
aumentando.
Para comenzar, todos los filtros y sus restricciones comenzaran con periodo 1, lo cual
representara que el filtro ejecutara cada restricción en cada una de las instanciaciones del
árbol.
Durante la ejecución, si una restricción alcanza el máximo L, su periodo es duplicado.
En caso de que pode, el periodo de la restricción, sin importar su valor actual, volverá a ser
uno.
17
Figura 12 Periodo de las restricciones
Si se visualiza más detalladamente la ejecución de la heurística Completa se puede
apreciar que la ejecución de los filtros va variando por restricción, dependiendo de su
comportamiento. Esto producirá que los filtros sean ejecutados únicamente si las restricciones
asociadas a él estén logrando algún tipo de poda, de esta forma evitar la ejecución innecesaria
de filtros, que conlleva a aumentar el tiempo de ejecución. Esto se puede representar de la
siguiente manera:
Figura 13 Ejecución Heurística Completa
18
Cabe mencionar, que la iteración 0 corresponde al problema entero, donde los filtros
consideran los dominios completos de cada variable y se realiza antes de ejecutar el algoritmo
de búsqueda. Y desde la iteración 1 en adelante, es el recorrido del árbol, donde se instancia
un nodo del árbol especifico.
En la figura 20, se aprecia que C0 logra una poda en todas las instancias. Sin embargo,
C1 desde la iteración 2 a la 4 no obtiene resultados de poda, por lo cual se duplica su periodo,
volviéndose a aplicar en la iteración 6, sin resultados por lo que su periodo continúa en 2 y sus
fallos se incrementan. En la iteración 8 C1 es aplicada y produce una poda, por lo cual su
periodo es reiniciado a 1 y sus fallos, a 0.
A continuación se presenta el seudocódigo de esta heurística:
iteracion ← iteracion + 1;
foreach f
‫ א‬Filtros do
C ← ø;
foreach c
if
‫ א‬T do
iteracion % T[c] =0 then
agregar
c a C;
aplicar C en el filtro f;
guardar las restricciones con resultados en R[f];
foreach f ‫ א‬Filtros do
foreach c
if
‫ א‬T do
c ‫ ك‬R[f]
then
c->periodo = 1;
else
c->fallos +=1;
if c->fallos = L then
c->periodo *=2;
c->fallos = 0;
Figura 14 Pseudocódigo Heurística Completa
19
Para su funcionamiento el algoritmo adaptativo necesita las siguientes estructuras de
datos:
x
x
x
x
x
T: Es el conjunto de tuplas de la forma (restricción, periodo, fallos). Donde la
asociación con el filtro queda de la forma F[0] está asociado a las primeras N casillas
del vector T; el filtro F[1], a las siguientes N casillas, y así sucesivamente.
C: Esta lista contiene el conjunto de restricciones que ocupa el filtro en el nodo
instanciado.
R: es el conjunto de restricciones C que obtuvieron resultado en el respectivo filtro.
Filtros: Lista que contiene los algoritmos de consistencia a aplicar en la ejecución del
adaptativo.
L: máximo de fallos para cada restricción.
El algoritmo de la figura 20, es aplicado en cada nodo del árbol de búsqueda. Este
consiste, en llevar un contador de iteraciones iteración para poder aplicar las restricciones
según corresponda al periodo designado.
Lo primero que realiza el algoritmo adaptativo, es por cada nodo verificar a que
restricciones le corresponde según su periodo, para esto, verifica si al aplicar MOD al periodo
de cada restricción con respecto a la iteración actual es 0 (cero), de ser así, se agrega la
restricción en cuestión a la lista C. Luego de tener todas las restricciones respectivas para el
filtro f, se aplica la técnica solo a las restricciones de la lista C.
Este algoritmo, si al aplicar un filtro se obtiene una poda, almacena en la lista R las
restricciones con las cuales se obtuvieron dicha poda. Esto para dar una segunda oportunidad
a la restricción en la siguiente iteración.
En el último foreach, se procede a actualizar los fallos de cada restricción, y de ser
necesario su periodo. Para esto, se verifica si el elemento en la lista T está presente en la lista
R pertinente, de estarlo, su periodo es reiniciado a 1. En caso contrario, se procede a aumentar
sus fallos, si los fallos alcanzan el umbral L, el periodo de la restricción es duplicado y los
fallos son reiniciados.
Con la ayuda de este algoritmo lo que se busca es utilizar intercaladamente los
algoritmos AC-6, MAX-RPC y SAC-OPT de tal forma que consideramos el costo que
conlleva cada uno y el porcentaje de poda que produzca, para la toma de decisiones que
permita ir intercalando estos filtros, de esta forma maximizar la cantidad de poda del árbol de
búsqueda y disminuir el tiempo en la búsqueda de la solución del CSP.
Como hipótesis este algoritmo adaptativo producirá un tiempo inferior en cuanto a
tiempo de búsqueda de solución de un CSP, que si se utilizan los algoritmos de filtro por si
solo para cada instanciación de variables en el árbol de búsqueda de un CSP.
20
6.1
Heurística Optimista.
Ésta heurística es una variante de la heurística Completa. Lo que se busca en ésta es
tener en mayor consideración la poda asociada a cada filtro. Por esto, no aplica por defecto
todos los filtros, si no que evalúa los resultados obtenidos del filtro ejecutado. La premisa que
sigue esta heurística, es que si un filtro poda, el que sigue en la escala de costos debería podar
aún más, y así acotar más las búsquedas.
Utiliza las mismas estructuras de la heurística Completa. Agrega un índice i, el cual
indica el filtro y sus restricciones asociadas que deben ser aplicadas en la ejecución de cada
nodo. Si al aplicar un filtro este tiene resultados podando, se continúa con la ejecución del
siguiente filtro. En caso contrario, se prosigue con el siguiente nodo y se reinicia i, de tal
forma que señale la casilla del primer filtro del arreglo F.
Cabe mencionar, que el periodo de las restricciones que no podaron se modifica
cuando termina la ejecución de los filtros, al igual que en la heurística Completa.
21
En
términos
de
seudocódigo
la
heurística
es
la
siguiente.
iteracion ← iteracion + 1;
end=false;
while end != true
C ← ø;
foreach c
if
agregar
‫ א‬T[i] do
iteracion % T[c] =0 then
c a C;
aplicar C en el filtro Filtros[i];
guardar las restricciones con resultados en R[i];
if Filtro[i] tuvo resultados
i++;
if i> ultimo(Filtros);
i= ultimo(Filtros);
end=true;
else
end=true;
i=1;
foreach f ‫ א‬Filtros do
foreach c
if
‫ א‬T do
c ‫ ك‬R[f]
then
c->periodo = 1;
else
c->fallos +=1;
if c->fallos = L then
c->periodo *=2;
c->fallos = 0;
Figura 15 Pseudocódigo Heurística Optimista
22
6.2
Heurística Pesimista.
Este algoritmo se genera como contraparte de la heurística Optimista, en donde se tiene
en consideración el costo de los filtros.
En ésta la premisa es, si un Filtro logra resultados se continúa ejecutando este filtro en
las siguientes iteraciones, hasta que no logre podar. Esto ya que siempre se comienza con el
filtro de costo más bajo, por ende, los resultados finales en cuanto al tiempo deberían ser
menores.
Al igual que en la Optimista, maneja las mismas estructuras de la Heurística Original y
agrega un índice i para el manejo de los filtros a aplicar. Si al aplicar un filtro, este tiene
resultados podando, se continúa con la ejecución del siguiente filtro. En caso contrario, se
prosigue con el siguiente nodo y se reinicia i, de tal forma que señale la casilla del primer
filtro del arreglo F.
Cabe mencionar, que el periodo de las restricciones que no podaron se modifica
cuando termina la ejecución de los filtros, al igual que en la heurística Completa.
En términos de seudocódigo la heurística es la siguiente.
iteracion ← iteracion + 1;
end=falso;
while end != verdadero
C ← ø;
foreach c
if
‫ א‬T[i] do
iteracion % T[c] =0 then
agregar
c a C;
aplicar C en el filtro Filtro[i];
guardar las restricciones con resultados en R[i];
if Filtro[i] no tuvo resultados
i++;
if i > tamaño(Filtros)
i= primer(Filtros);
end=verdadero;
else
end = verdadero;
foreach f ‫ א‬Filtros do
foreach c
if
‫ א‬T do
c ‫ ك‬R[f]
then
c->periodo = 1;
else
Figura 16 Pseudocódigo Heurística Pesimista
23
7. Generador de CSP
Como lo que se busca es demostrar la hipótesis de que los adaptativo tiene mejor
funcionamiento que los filtros por sí mismo, se requieren CSPs que contengan una gran
cantidad de restricciones y a la vez una gran cantidad de variables debido a que si el tamaño
del CSP es muy pequeño el adaptativo no demostrara la eficiencia de su trabajo. De la misma
manera se necesitan tener CSPs en donde varíen la cantidad de variables y la cantidad de
restricciones para poder verificar en que situaciones el adaptativo se comporta de mejor o peor
manera. Así como también se podrá verificar distintos contextos donde quizás la cantidad de
restricciones sea muy alta y la cantidad de variables muy pequeñas, o posiblemente estando en
un contexto donde los dominios de las variables sean extremadamente grandes o tal vez con
dominios muy acotados.
Debido a esta problemática para la investigación fue necesario crear un generador de
CSP donde se pueda controlar la cantidad de variables y la cantidad de restricciones que este
contenga teniendo un tope máximo de 625* variables con dominios que van desde 1 hasta
2*109** y una cantidad ilimitada de restricciones, todos estos valores parametrizados para una
cómoda ejecución.
Los CSP que acepta el Solver del adaptativo tienen el siguiente formato:
variables:
gf in [1,100];
ir in [1,100];
constraints:
oy/jz>3;
jz/gf>=2;
gf/oy!=6;
Figura 17 Formato CSP
Para esto, el generador maneja una lista de identificadores que representa las variables,
llamado Variables. Para generar cada elemento de dicha lista, se concadenan dos letras al
azar del alfabeto. El alfabeto que utiliza el generador no contiene n ni ñ, ya que combinaciones
con estas letras son palabras reservadas del Solver.
Por lo tanto las combinaciones posibles van desde aa hasta zz (excluyendo las
combinaciones con n y ñ).
24
Luego, procede a generar las restricciones. Para esto, toman dos identificadores de la
lista Variables, que no sean iguales. Asigna un valor aleatorio a cada identificador, luego
selecciona un operador aritmético (opA) de la lista AristmeticOperator. Con esto evalúan los
valores aplicando el operador opA, y obtiene un Z. Entonces, selecciona un operador lógico
(opL) del vector LogicOperator, y la restricción queda de la forma:
<identificador1> opA <identificador2> opL Z, y es agregada a la lista Restricciones.
Finalmente, general el archivo que será leído por el Solver. Para esto, crea el archivo
con el nombre de archivo dado por parámetro. Y va escribiendo con el formato
correspondiente. Primero escribe la palabra reservada "variables:"; luego escribe las variables,
ordenadas alfabéticamente, con el formato <Variable[i]> "in" "[1, <dominio Ingresado>]".
Por último, escribe "constraints:" y a continuación, las restricciones de la lista
Restricciones.
* Se estima que los equipos de prueba no soportaran la ejecución de problemas de más
de 670 variables. Esto porque con la variación en el tiempo de ejecución de problemas de 50
variables a problemas de 100 variables, el tiempo varia casi en el doble por lo tanto la
ejecución de problemas con 600 variables sería un tiempo muy superior y sobre exigiendo los
equipos de prueba.
** Valor máximo de un int en Java.
25
8. Resultados
Una vez implementadas las distintas heurísticas se procedió a realizar pruebas, como lo
que se busca es lograr que los adaptativos consigan un tiempo inferior que los filtros por si
solos, se realizaron experimentos con siete variedades de adaptativos que son: por si solos
AC-6, MAX-RPC, SAC-OPT, AC-6 y MAX-RPC en conjunto, AC-6 y SAC-OPT, MAXRPC y SAC-OPT y los tres filtros juntos.
Cabe menciona, el filtro SAC-OPT fue desarrollado por el Proyectista Dynko
Hernández Rojas como su proyecto de título para optar al título de ingeniero de ejecución en
informática. Asimismo, las pruebas fueron realizadas en conjunto y los resultados son
compartidos por ambos proyectos de título.
8.1
Resultados Heurística Completa.
Con la heurística completa se obtuvieron los siguientes resultados del tiempo de
ejecución en milisegundos.
AC-6
CSP
MAXRPC
Tiempo Tiempo
SAC-OPT
AC-6
MAX-RPC
Tiempo
Tiempo
AC-6
SACOPT
Tiempo
MAXRPC
SAC-OPT
Tiempo
AC-6
MAX-RPC
SAC-OPT
Tiempo
P1
44
58
147
71
158
162
169
P2
147
81
139
105
121
183
131
P3
546
978
236
1662
212
225
248
P4
83
179
64
180
70
181
192
P5
253
1717
402
1549
303
1770
1556
P6
979
1314
1020
5009
1880
1474
4803
P7
782
1430
1095
2831
1191
1360
1470
P8
1235
4384
1018
4386
1126
1860
1877
P9
892
1470
893
9619
939
2602
9508
P10
1056
3375
972
1750
971
3694
1868
P11
978
1350
650
1315
840
1560
1512
P12
908
2251
939
15156
938
2406
3925
P13
783
6851
908
9195
954
7524
9503
P14
2658
16438
941
15415
970
15554
15600
P15
450
1861
403
1828
275
1833
825
P16
750
1344
1038
3680
1158
1563
1798
P17
970
1407
1066
1181
1024
1413
1395
P18
1245
4542
1343
3225
1185
1833
2556
P19
970
1658
938
6615
1032
2252
4488
P20
1315
3486
1001
1734
1019
3720
1906
TOTALES
852,2
2808,7
760,65
4325,3
818,3
Tabla 1 Resultados Heurística Completa
2658,45
3266,5
26
8.2
Resultados Heurística Optimista.
Tiempos en milisegundos de le Heurística Optimista.
AC-6
CSP
MAXRPC
Tiempo Tiempo
MAXRPC
AC-6
AC-6
SAC-OPT MAX-RPC SAC-OPT SAC-OPT
Tiempo
Tiempo
Tiempo
Tiempo
AC-6
MAX-RPC
SAC-OPT
Tiempo
P1
63
85
221
88
159
202
209
P2
72
92
114
136
183
126
138
P3
372
937
159
682
208
220
214
P4
83
177
62
180
66
183
179
P5
262
1861
403
1828
275
1833
825
P6
941
1344
1038
3680
1158
1563
1798
P7
801
1407
1066
1181
1024
1413
1395
P8
1173
4542
1343
3225
1185
1833
2556
P9
892
1658
938
6615
1032
2252
4488
P10
1095
3486
1001
1734
1019
3720
1906
P11
946
1980
920
2535
920
3335
1395
P12
923
2062
970
7987
921
2297
3133
P13
829
6977
923
4458
940
4958
4395
P14
3035
16765
1001
9055
1103
9153
6897
P15
1017
1548
946
1893
907
1783
2110
P16
1070
3532
985
1812
1017
3719
1875
P17
840
1560
940
1750
998
2345
1760
P18
938
2179
939
2354
937
2516
2861
P19
815
7967
955
4035
908
6944
4419
P20
3024
17266
1151
2236
978
16087
2501
959,55
3871,25
803,75
2873,2
796,9
3324,1
2252,7
TOTALES
Tabla 2 Resultados Heurística Optimista
27
8.3
Resultados Heurística Pesimista.
Tiempo en milisegundos de la Heurística Pesimista.
AC-6
CSP
MAXRPC
Tiempo Tiempo
SAC-OPT
Tiempo
AC-6
MAXRPC
Tiempo
MAXRPC
AC-6
SAC-OPT SAC-OPT
Tiempo
Tiempo
AC-6
MAX-RPC
SAC-OPT
Tiempo
P1
84
93
93
83
189
184
201
P2
88
89
107
92
132
135
152
P3
356
751
136
358
365
668
393
P4
91
223
68
114
81
191
114
P5
338
2093
468
870
325
2006
897
P6
970
1313
1036
1485
1111
1437
1701
P7
782
1360
1110
1173
1017
1579
1392
P8
1166
4379
1012
1704
1392
4195
1782
P9
1017
1548
946
1893
907
1783
2110
P10
1070
3532
985
1812
1017
3719
1875
P11
840
1560
940
1750
998
2345
1760
P12
938
2179
939
2354
937
2516
2861
P13
815
7967
955
4035
908
6944
4419
P14
3024
17266
1151
2236
978
16087
2501
P15
892
1658
938
6615
1032
2252
4488
P16
1095
3486
1001
1734
1019
3720
1906
P17
946
1980
920
2535
920
3335
1395
P18
923
2062
970
7987
921
2297
3133
P19
829
6977
923
4458
940
4958
4395
P20
3035
16765
1001
9055
1103
9153
6897
964,95
3864,05
784,95
2617,15
814,6
3475,2
2218,6
TOTALES
Tabla 3 Resultados Heurística Pesimista
28
8.4
Análisis final de resultados.
Al realizar un análisis de los experimentos se puede apreciar gráficamente que el filtro
SAC-OPT para todas las heurísticas tiene un promedio de tiempo menor los otros dos filtros
por sí solo, lo que es consistente con la investigación, debido a que anteriormente se mencionó
que SAC-OPT es el filtro con mayor costo en tiempo de ejecución pero el que debiese logra
mayor poda que los demás, por lo tanto produce una mayor reducción del árbol de búsqueda y
en consecuencia un menor tiempo.
Continuando la observación de los resultados, se aprecia que AC-6 es el segundo filtro
que por sí solo logra un menor tiempo. Esto no es consistente con la investigación debido a
que MAX-RPC se esperaba que lograra un tiempo menor. Esto se fundamenta en que los CSPs
son creados a partir del generador de CSPs, las selección de variables son aleatorios y MAXRPC para su funcionamiento utiliza la camino consistencia, es decir necesita un mino de tres
restricciones relacionadas entre sí, para efectos de implementación se adaptó el Filtro, para
que interpretara estos CSPs y pudiera ejecutar sin problemas. Esto produjo que el tiempo de
ejecución de todos los adaptativos que incluyeran MAX-RPC su tiempo se aumentara
considerablemente.
Finalmente la ejecución de todas las heurísticas arrojo como resultado que siempre los
menores tiempos estuvieran entre el filtro SAC-OPT y el adaptativo entre SAC-OPT y AC-6.
Como se aprecia en la Heurística Optimista el tiempo fue menor para el adaptativo
antes mencionado, lo que produce un logro en la investigación de este proyecto. Con un
tiempo de 796,9 milisegundos contra 803,75 se demostró que la utilización de dos o más
técnicas de consistencia puede afectar positivamente en la reducción del tiempo de solución de
distintos CSPs y tiene mejor rendimiento que utilizar una técnica por si sola.
29
9. Conclusiones
Con la realización de la presente investigación, se ha indagado de la forma más
completa posible los diferentes conceptos relacionados a los CSP con el fin de tener claro los
conocimientos básicos, que a su vez permitirán llevar a cabo la implementación de toda la
teoría descrita.
En primer lugar se comprendió la importancia de la programación con restricciones y
especialmente los CSP. Posterior a esto, a medida que se interiorizaba en el tema, se podía
identificar la importancia de cada componente que interactúa para la solución de problemas y
lo necesario que es el que dichos componentes actúen de forma complementaria. Por ejemplo,
un algoritmo de búsqueda no trabaja de la forma más óptima actuando por sí solo, pero sí se
potencia al actuar con alguna técnica de inferencia o consistencia, lo que tiene como resultado
el reducir los espacios de búsqueda y conseguir de manera más rápida la o las soluciones.
Cabe mencionar que, un fenómeno muy interesante en los algoritmos de arcoconsistencia, es que técnicas que se platearon hace más de treinta años son fundamentales para
las diversas investigaciones que se están dando hoy en día.
Debido a que la programación con restricciones es una tecnología un tanto
incomprendida y lo que se ha logrado en esta investigación es algo nuevo debido a que existen
pocos registros de trabajos similares, se concluyó que ha sido un avance importante para esta
tecnología.
Como se logró demostrar que la utilización de múltiples técnicas de consistencia puede
mejorar el tiempo de solución de un CSP con respecto a una técnica por si solas, propone una
apuesta personal para cada uno de los integrantes del grupo de trabajo, de continuar con
nuevas investigaciones que mejoren cada vez más el rendimiento y tiempo de respuesta
nuevos CSPs aún más complejos.
30
10. Referencias
[1] M. Arangús. Modelos y técnicas de consistencia en problemas de satisfacción de
restricciones. Tesis doctoral, Universidad politécnica de Valencia, Valencia, España, 2011.
[2] R. Soto, B. Crawford, and I. Araya. Adaptative Filtering for Numerical CSPs.
Investigación. Pontificia Universidad Católica de Valparaiso, Valparaiso, Chile. 2014.
[3] F. Rossi, P. van Beek and T. Walsh. Handbook of Constraint Programming, Elsevier B. V,
pages 29-77. ISSN 1574-6525. 2006.
[4] R.Soto, B. Crawford, E. Monfroy and V. Bustos. Using Autonomous Search for
Generating Good Enumeration Strategy Blends in Contraint Programming. In proceeding
of the 12th International Conference on Computational Science and Its Aplications
(ICCSA),
pages
607-617.
LNCS
7335,
Springer,
2012.
31
11. Anexos
11.1
Ejemplo AC-6
Se toma un típico problema de satisfacción de restricciones (CSP), al cual se aplicara
el algoritmo AC-6, para demostrar su funcionamiento y la poda que realiza en el árbol de
búsqueda.
Se define el CSP como:
Variables:
Dominios:
Restricciones:
x,y,z
D(x)={1,2,3,4}
x≤y
D(y)={1,2,3,4}
y != z
D(z)={3}
En la fase de inicialización se comprueba para cada valor de una variable, que
pertenezca a un domino, y que sea parte de una restricción.
Restricción X ≤ Y
X=1 Se busca en el domino de D(y)={1,2,3,4} que cumpla con la restricción, luego con
este valor se almacena en la lista del soporte el valor de la base.
32
Figura 18 AC-6 X=1
Figura 19 AC-6 X=4
Como se muestra en la figura 18 el valor X=1 cumple para todos el domino de la
variable Y, en la restricción x ≤ y, pero se debe buscar el primer valor más pequeño que
satisfaga esta restricción, en este caso Y=1. A diferencia de la figura 17 se muestra que solo
existe un valor que satisface la restricción, Y=4.
Cada vez que se produzca una nodo-consistencia el valor de la base es agregado a la
lista S del soporte, para el caso de la figura 9 el resultado de esta operación sería S[Y,1]=[X,1].
Como resultado de la evaluación de todos los valores de X e Y se obtiene como
resultado las siguientes listas S:
S[Y,1]={[X,1]}
S[X,1]={[Y,1] [Y,2] [Y,3] [Y,4}
S[Y,2]={[X,2]}
S[X,2]={}
S[Y,3]={[X,3]}
S[X,3]={}
S[Y,4]={[X,4]}
S[X,4]={}
Nótese que para la lista S[X,1] están todos los valores del dominio de Y, esto se
produce debido a que X=1 es el menor valor del dominio de X, y a la vez cumple con la
restricción para todos los valores de Y.
Restricción Y!=Z
33
Figura 20 AC-6 Z=3
Figura 21 AC-6 Valores de Y
Al igual que para la restricción anterior para los valores de Z al existir solamente uno,
Z=3 se agrega a la lista S el menor valor que cumpla con la restricción, en este caso quedaría
S[Y,1]={[Z,3]}.
En la figura 20 se muestra todos los valores de Y, para el caso en particular Y=3 no
existe ningún valor en el dominio de Z que cumpla con la restricción, cuando sucede esto se
procede a agregar Y=3 a la lista Q y es eliminado este valor de su dominio.
El resultado de estas operaciones arroja las siguientes listas:
S[Y,1]={[X,1] [Z,3]}
S[X,1]={[Y,1] [Y,2] [Y,3] [Y,4}
S[Y,2]={[X,2]}
S[X,2]={}
S[Y,3]={[X,3]}
S[X,3]={}
S[Y,4]={[X,4]}
S[X,4]={}
S[Z,3]={[Y,1] [Y,2] [Y,4]}
Q={[Y,3]}
En esta fase de inicialización, si llega a darse el caso en donde una variable no tenga
valores en su dominio, es decir, el dominio de la variable es igual a vacío y todos sus valores
hayan sido agregados a la lista Q, se procede a acabar con la búsqueda de esta variable y se
cambia por la otra.
34
En la fase de propagación se utiliza la lista Q, la cual contenía los valores que no eran
nodo-consistentes con ninguno de los valores de los soportes. Se van extrayendo de la lista Q
los valores y se buscan es su respectiva lista S.
En el ejemplo la lista Q contiene [Y, 3], al buscar su respectiva lista S, arroja que
contiene S [Y, 3]= [X, 3]. Luego con cada valor de la lista S encontrada se busca la respectiva
restricción a la cual pertenezca, en este caso sería la primera restricción X ≤ Y.
Figura 22 AC-6 X=3
Al igual que en la fase de propagación se evalúa el valor de X=3, pero en este caso se
utiliza el valor más pequeño que cumpla con la restricción, que a la vez sea más grande que el
soporte del cual fue seleccionado el valor que estamos comparando, en este caso el valor que
cumpla en Y, deberá ser mayor que Y=3.
Se encuentra que el valor Y=4 cumple con los requisitos y el valor de la base es
agregado a la lista del soporte lo que resultaría en S [Y, 4]= {[X, 4] [X, 3]}. Si se da el caso en
que no exista un valor que cumpla con estos requisitos el valor encontrado en este caso X=3 se
agrega a la lista Q.
Si se llega a dar el caso en que no se encuentre ningún valor más pequeño que sea más
grande que el soporte que cumpla con la restricción y a su vez el dominio de la variable la cual
representa la base es vacío, se procede a terminar de evaluar esta variable, tal como se muestra
en la línea 15 de la figura 8.
35
11.2
Ejemplo MAX-RPC
A partir de un CSP, se aplicara el algoritmo MAX-RPC, para ver su funcionamiento y
la cantidad de poda que puede realizar en un árbol de búsqueda.
Se definirá el siguiente CSP:
Variables:
Dominios:
Restricciones:
x,y,z
D(x)={1,2 }
y≤ x
D(y)={1,2 }
x + z >2
D(z)={1,2}
z ≤ y
La estructura denominada InitList Almacenara todos las instanciaciones de las
variables por cada una de las restricciones del CSP.
InitList = {([y,x],1), ([y,x],2), ([x,z],1), ([x,z],2), ([z,y],1), ([z,y],2),
([x,y],1), ([x,y],2), ([z,x],1), ([z,x],2), ([y,z],1), ([y,z],2) }
Se procede a recorrer esta lista y buscar los valores que hagan que los las variables con
y sus valores sean camino consistentes. Por ejemplo, con el elemento ([y,x],2), MAX-RPC
funcionara de la siguiente manera.
Figura 23 MAX-RPC Y=2 Instanciación X
36
Como el elemento seleccionado tiene asociado las variables X e Y, y la variable Y
instanciada con el valor 2, se evaluara todos los valores de X buscando el valor más pequeño
que haga que esto sea arco-consistente para este caso sería X = 2 e Y = 2.
Con los valores encontrados anteriormente, se busca, con los valores X=2 e Y = 2, un
valor para la variable que esté asociada con una restricción con X e Y para este CSP seria Z,
que al instanciarla haga que todo el camino que se produce entre estas restricciones, todas
estas se vean satisfechas.
Figura 24 MAX-RPC Y=2 X=2 instanciación Z
Al realizar un zoom a la Figura 23 se puede ver que la restricción x + z>2 y z ≤ y se
satisface con los valores Y=2, X=2 y Z=1, así como también para los valores Y=2, X=2 y Z=2,
por lo tanto para ambos conjunto de valores estas restricciones son camino consistentes. Como
MAX-RPC siempre escoge el valor más pequeño que haga que las restricciones sean camino
consistentes para este ejemplo toma los valores Y=2, X=2 y Z=1.
Por lo tanto con estos valores se crean las siguientes listas SAC[X,2]={(Y,2)} y
SPC[Z,1]={[(Y,2) (X,2)]} , que son los más pequeños que hacen que sea arco-consistente y
camino-consistente respectivamente.
37
Si llega a darse el caso en que un elemento de la InitList no sea camino consistente
para ninguno de sus valores instanciados de sus variables, tendrá el siguiente comportamiento.
Por ejemplo el elemento de la InitList ([x,y],1).
Figura 25 MAX-RPC X=1 Instanciación Y
Se puede apreciar que para los valores X=1 e Y=2 se cumple la arco-consistencia, se
procede a evaluar qué valor de Z hará que se cumpla con la camino-consistencia.
38
Figura 26 MAX-RPC X=1 Y=1 instanciación Z
Si se visualiza la restricción del CSP x + z>2 instanciada 1 + 1 > 2 no se ve satisfecha,
por lo tanto el valor de Z = 1 se descarta como posible valor para cumplir con la caminoconsistencia. Para el siguiente valor del domino de Z, en este caso Z = 2 al instanciar las
restricciones x + z > 2, que sería 1 + 2 > 2, la cual cumple, por lo tanto se ve la siguiente
restricción z ≤ y, que sería 2 ≤ 1, al no verse satisfecha se descarta el valor de Z = 1 como
camino-consistente.
En consecuencia se puede apreciar que no existe ningún valor en X que sea arcoconsistente y a su vez exista un valor en Z que utilice el valor anterior y haga que el camino de
las restricciones sea camino-consistente. Por lo tanto este es un valor inconsistente del
dominio de X, que ninguno de sus valores producirá que el CSP se vea satisfecho, MAX-RPC
procederá a eliminar el valor X=1 del dominio de X y agregar un nuevo elemento a la lista
DeletionList.
Para todos los elementos de la lista DeletionList, MAX-RPC procede a recorrerla y
buscar si existe una lista SPC o SAC, la cuales almacenan las posibles soluciones al CSP, y
procede a nuevamente buscar los valores más pequeños que hagan que las variables y sus
valores sean camino-consistentes.
39
11.3
Diagrama heurística optimista
En términos gráficos, el siguiente diagrama se muestra cómo funciona la heurística
Optimista.
Figura 27 Diagrama Heurística Optimista
40
11.4
Diagrama heurística pesimista
Esta heurística es similar a la Optimista, solo cambia el criterio de continuación del
filtro.
Mirada por medio de un diagrama, esta heurística seria de la siguiente forma:
Figura 28 Diagrama Heurística Pesimista
En la Figura 27, se aprecia la sutil pero efectiva diferencia entre las heurísticas
optimista y pesimista.
41
11.5
Problemas utilizados
11.5.1.
P1
variables:
be in [1,50];
bs in [1,50];
hs in [1,50];
tt in [1,50];
vq in [1,50];
constraints:
bs+hs<=52;
hs*be<476;
be+vq<=40;
vq+tt!=46;
tt*bs!=387;
Figura 29 Problema P1
11.5.2.
P2
variables:
ah in [1,50];
ct in [1,50];
mu in [1,50];
wh in [1,50];
wk in [1,50];
constraints:
mu*ct>=304;
ct*wk!=756;
wk+wh!=37;
wh+ah>40;
ah*mu>70;
Figura 30 Problema P2
42
11.5.3.
P3
variables:
ay in [1,50];
hu in [1,50];
ix in [1,50];
li in [1,50];
zs in [1,50];
constraints:
li*zs!=784;
zs*ix>497;
ix+ay!=44;
ay*hu>=750;
hu+li<83;
Figura 31 Problema P3
11.5.4.
P4
variables:
bp in [1,50];
hf in [1,50];
ir in [1,50];
wg in [1,50];
wl in [1,50];
constraints:
wg*bp!=220;
bp+ir>=76;
ir*wl>=32;
wl+hf!=74;
hf*wg!=540;
Figura 32 Problema P4
43
11.5.5.
P5
variables:
de in [1,50];
dq in [1,50];
kg in [1,50];
wc in [1,50];
zp in [1,50];
constraints:
wc/zp<1;
zp/de>2;
de-kg>=1;
kg*dq!=16;
dq+wc>=8;
Figura 33 Problema P5
44
11.5.6.
P6
variables:
bd in [1,50];
ct in [1,50];
dz in [1,50];
eb in [1,50];
lb in [1,50];
mq in [1,50];
of in [1,50];
qe in [1,50];
uz in [1,50];
zw in [1,50];
constraints:
ct*bd<=444;
bd*qe>600;
qe*ct>=1728;
qe*eb>60;
eb-dz<11;
dz*qe!=625;
of+zw<86;
zw*bd<=168;
bd*eb!=1776;
eb*of!=762;
Figura 34 Problema P6
45
11.5.7.
P7
variables:
fg in [1,50];
fs in [1,50];
gu in [1,50];
jm in [1,50];
le in [1,50];
mv in [1,50];
rd in [1,50];
vw in [1,50];
yb in [1,50];
zs in [1,50];
constraints:
jm*vw<=690;
vw+rd<=57;
rd*jm!=1800;
gu+jm>41;
jm*yb<16;
yb*gu<306;
mv*rd>=360;
rd*fs<=660;
fs*zs>=270;
zs*mv!=280;
Figura 35 Problema P7
46
11.5.8.
P8
variables:
gs in [1,50];
gt in [1,50];
if in [1,50];
it in [1,50];
jz in [1,50];
ld in [1,50];
tg in [1,50];
xa in [1,50];
xk in [1,50];
zq in [1,50];
constraints:
xa/gt<3;
gt*it!=520;
it-xa>1;
if-ld<10;
ld+xa>=21;
xa+if!=59;
xa/if>14;
if+tg>=47;
tg/gs!=3;
gs+xa<=50;
Figura 36 Problema P8
47
11.5.9.
P9
variables:
dc in [1,50];
dj in [1,50];
go in [1,50];
hh in [1,50];
iv in [1,50];
qc in [1,50];
qf in [1,50];
uc in [1,50];
yu in [1,50];
zs in [1,50];
constraints:
qc*iv<230;
iv+go<=76;
go*qc>=399;
dj*qc>720;
qc-zs<76;
zs+dj>1;
go+dj>=79;
dj*iv>22;
iv+dc>7;
dc*go<900;
Figura 37 Problema P9
48
11.5.10.
P10
variables:
bd in [1, 50];
gw in [1, 50];
jl in [1, 50];
la in [1, 50];
oe in [1, 50];
py in [1, 50];
rs in [1, 50];
tq in [1, 50];
ya in [1, 50];
zy in [1, 50];
constraints:
ya+bd>80;
bd+py!=2;
py+ya<=22;
bd+tq<17;
tq*rs>=93;
rs+bd>1;
oe*ya<=783;
ya*jl!=270;
jl+rs!=68;
rs-oe!=15;
Figura 38 Problema P10
49
11.5.11.
P11
variables:
ak in [1, 50];
bm in [1, 50];
co in [1, 50];
de in [1, 50];
dh in [1, 50];
fm in [1, 50];
gb in [1, 50];
la in [1, 50];
lb in [1, 50];
pe in [1, 50];
qw in [1, 50];
vf in [1, 50];
ws in [1, 50];
wv in [1, 50];
yv in [1, 50];
constraints:
co-la>9;
la+lb<53;
lb+co>45;
yv-ws>=23;
ws+wv<37;
wv+yv<60;
yv*ak>=819;
ak-de<34;
de-yv!=32;
qw*co<230;
co+dh>=53;
dh*qw!=585;
co+bm!=43;
bm+pe<=39;
pe+co>=74;
Figura 39 Problema P11
50
11.5.12.
P12
variables:
ai in [1,50];
bt in [1,50];
ev in [1,50];
gk in [1,50];
he in [1,50];
lp in [1,50];
mg in [1,50];
mh in [1,50];
mw in [1,50];
pc in [1,50];
pd in [1,50];
qj in [1,50];
sv in [1,50];
tv in [1,50];
yl in [1,50];
constraints:
ev+mg!=69;
mg*ai<=252;
ai*ev<=242;
yl-bt<=28;
bt-qj!=3;
qj+yl>78;
qj+he!=55;
he*mw<1128;
mw-qj>=15;
tv+ai>=70;
ai+qj>=54;
qj-tv<65;
lp+bt!=51;
bt+sv!=66;
sv*lp>=396;
Figura 40 Problema P12
51
11.5.13.
P13
variables:
df in [1,50];
fx in [1,50];
ga in [1,50];
gb in [1,50];
hf in [1,50];
ih in [1,50];
jr in [1,50];
le in [1,50];
ox in [1,50];
pj in [1,50];
rc in [1,50];
st in [1,50];
vh in [1,50];
vk in [1,50];
wo in [1,50];
constraints:
gb*st<35;
st*hf!=161;
hf+gb<57;
pj-vk<27;
vk+jr<69;
jr+pj<49;
st+ga!=3;
ga+gb>13;
gb+st>=64;
vk+ox!=43;
ox-wo!=14;
wo-vk>75;
st*jr!=144;
jr-ih<23;
ih+st<=59;
Figura 41 Problema P13
52
11.5.14.
P14
variables:
eg in [1,50];
gg in [1,50];
kp in [1,50];
ld in [1,50];
lk in [1,50];
ls in [1,50];
ox in [1,50];
sf in [1,50];
sq in [1,50];
uy in [1,50];
vm in [1,50];
wb in [1,50];
xo in [1,50];
zl in [1,50];
zs in [1,50];
constraints:
vm*zs<=646;
zs*ld>=345;
ld*vm!=30;
kp*uy<585;
uy*ox>=2200;
ox+kp>78;
ld+kp>65;
kp+ox!=54;
ox-ld>=6;
gg+eg>24;
eg+vm>24;
vm*gg>=2209;
sf*zs>=2070;
zs+ld<40;
ld+sf>76;
Figura 42 Problema P14
53
11.5.15.
P15
variables:
by in [1,50];
ch in [1,50];
cy in [1,50];
je in [1,50];
lj in [1,50];
mc in [1,50];
ms in [1,50];
qw in [1,50];
qy in [1,50];
sw in [1,50];
up in [1,50];
vl in [1,50];
wb in [1,50];
wz in [1,50];
ya in [1,50];
constraints:
mc*ch<1505;
ch-ms>24;
ms+mc>=35;
ya*wz>=58;
wz*ch<=1120;
ch*ya<24;
qw*wz!=423;
wz+mc>=23;
mc*qw>=1380;
sw+qy>=75;
qy*lj>1248;
lj*sw>=703;
wz-sw<=26;
sw*up!=875;
up+wz<83;
Figura 43 Problema P15
54
11.5.16.
P16
variables:
hr in [1,50];
lv in [1,50];
mh in [1,50];
qs in [1,50];
xt in [1,50];
constraints:
hr+qs>40;
qs+xt<88;
xt*hr>=120;
hr-mh!=14;
mh/lv<1;
lv-hr<=4;
lv*hr<=67;
hr*xt!=320;
xt*lv>655;
qs+xt<80;
xt*lv!=9;
lv*qs>=1232;
xt-lv<=54;
lv+qs>47;
qs*xt>=1896;
Figura 44 Problema P16
55
11.5.17.
P17
variables:
bt in [1,50];
ep in [1,50];
gk in [1,50];
iq in [1,50];
oo in [1,50];
constraints:
oo/iq!=7;
iq+bt!=34;
bt+oo>62;
bt-gk<23;
gk-iq<=26;
iq*bt>340;
iq*bt<266;
bt+gk>16;
gk-iq<37;
iq*oo>=50;
oo*gk>=1408;
gk+iq!=4;
iq-oo>16;
oo+bt>76;
bt+iq>=27;
Figura 45 Problema P17
56
11.5.18.
P18
variables:
ck in [1, 50];
il in [1, 50];
lg in [1, 50];
oh in [1, 50];
zz in [1, 50];
constraints:
il-ck>17;
ck*zz>=220;
zz-il!=28;
il*oh>=23;
oh+zz>=61;
zz-il>=18;
lg*oh>147;
oh*zz>18;
zz-lg>4;
ck-zz>=1;
zz+il>=31;
il*ck>117;
il+oh>=53;
oh*lg>729;
lg*il>=567;
Figura 46 Problema P18
57
11.5.19.
P19
variables:
cz in [1,50];
kj in [1,50];
pv in [1,50];
pw in [1,50];
sj in [1,50];
constraints:
sj*pw>=456;
pw*cz>273;
cz+sj<61;
cz+sj<37;
sj*pv>765;
pv+cz>=56;
kj-pv!=18;
pv-pw>24;
pw+kj>=39;
pw*pv<=351;
pv*kj!=660;
kj+pw>55;
pv*sj>116;
sj*kj>576;
kj*pv!=220;
Figura 47 Problema P19
58
11.5.20.
P20
variables:
ah in [1,50];
br in [1,50];
if in [1,50];
iy in [1,50];
mr in [1,50];
constraints:
iy*mr>=902;
mr*br<1330;
br-iy>=3;
iy-br>1;
br*mr!=1848;
mr*iy<1242;
ah-br>5;
br*if>369;
if*ah>1363;
mr*if>1564;
if*iy!=21;
iy+mr<30;
iy*ah>=135;
ah+mr>=38;
mr-iy<2;
Figura 48 Problema P20
59