estudio e implementaciÓn de algoritmos ac-6 y max...

PONTIFICIA UNIVERSIDAD CATÓLICA DE VALPARAÍSO FACULTAD DE INGENIERÍA

ESCUELA DE INGENIERÍA INFORMÁTICA

JUNIO 2015

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

PONTIFICIA UNIVERSIDAD CATÓLICA DE VALPARAÍSO FACULTAD DE INGENIERÍA

ESCUELA DE INGENIERÍA INFORMÁTICA

JUNIO 2015

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.

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.

i

Í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 Algoritmo AC-6 ............................................................................................... 10

5. Algoritmo de consistencia de camino. .............................................................. 12

5.1 Algoritmo MAX-RPC. ..................................................................................... 12

6. 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

ii

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

iii

11.5.20. P20 ......................................................................................................... 59

iv

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, Arco-Consistencia, Consistencia Adaptativa, Camino-Consistencia.

v

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.

vi

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

vii

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

1

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 Camino-Consistencia, 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.

2

2. Definición de Objetivos

2.1 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

Comprender los conceptos básicos de la programación con restricciones.

Implementar los algoritmos AC-6 y MAX-RPC.

Implementar un sistema de consistencia adaptativa para CSPs.

Realizar experimentos con la implementación desarrollada.

3

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.

4

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:

V es un conjunto de variables

D es un conjunto de dominios Donde corresponde a los valores posibles que puede tomar la variable , con .

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.

5

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.

6

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.

7

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.

8

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,

9

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.

10

4. Algoritmo de Arco Consistencia

Como ya se mencionó anteriormente, lo que se logra con las técnicas de arco-consistencia 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:

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 AC-4. 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.

11

AC-6() :boolean

inicio

/*Inicialización*/

Q ←ø; S[xj , vj ] = ø , vj D(xj ) , xj X;

foreach xi X, cij C, vi D( xi ) do

vj ← 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

12

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:

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.

13

Max_RPC()

inicio

DeletionList ← ø; InitList ← ø; foreach (i , a) D do

SPC[i , a ] = ø;

SAC[i , a ] = ø;

foreach cij C do

agregar [(i , j) , a] a InitList;

while 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.

14

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.

PropagDeletion( j , b , DeletionList)

inicio

while SAC[j , b ] ø do

pop( SAC[j , 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 ] ø do

pop( SPC[j , 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

15

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.

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

16

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.

17

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.

18

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

19

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 T do

if iteracion % T[c] =0 then

agregar c a C;

aplicar C en el filtro f;

guardar las restricciones con resultados en R[f];


foreach c T do

if 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

20

Para su funcionamiento el algoritmo adaptativo necesita las siguientes estructuras de datos:

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.

21

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.

22

En términos de seudocódigo la heurística es la siguiente.

iteracion ← iteracion + 1; end=false;

while end != true

C ← ø; foreach c T[i] do


agregar 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 c T do

if 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

23

Figura 16 Pseudocódigo Heurística Pesimista

iteracion ← iteracion + 1; end=falso;

while end != verdadero

C ← ø; foreach c T[i] do


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 c T do

if c R[f] then

c->periodo = 1;

else

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.

24

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:

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 ñ).

variables:

gf in [1,100];

ir in [1,100];

constraints:

oy/jz>3;

jz/gf>=2;

gf/oy!=6;

Figura 17 Formato CSP

25

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.

26

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, MAX-RPC 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 MAX-RPC SAC-OPT

AC-6 MAX-RPC

AC-6 SAC-OPT

MAX-RPC

SAC-OPT


CSP Tiempo Tiempo Tiempo Tiempo Tiempo Tiempo 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 2658,45 3266,5 Tabla 1 Resultados Heurística Completa

27

8.2 Resultados Heurística Optimista.

Tiempos en milisegundos de le Heurística Optimista.


AC-6 MAX-RPC

AC-6 SAC-OPT

MAX-RPC

SAC-OPT



TOTALES 959,55 3871,25 803,75 2873,2 796,9 3324,1 2252,7

Tabla 2 Resultados Heurística Optimista

28

8.3 Resultados Heurística Pesimista.

Tiempo en milisegundos de la Heurística Pesimista.


AC-6 MAX-RPC

AC-6 SAC-OPT

MAX-RPC

SAC-OPT



TOTALES 964,95 3864,05 784,95 2617,15 814,6 3475,2 2218,6

Tabla 3 Resultados Heurística Pesimista

29

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 MAX-RPC 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.

30

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 arco-consistencia, 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.

31

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.

32

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:

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.

Dominios:

D(x)={1,2,3,4}

D(y)={1,2,3,4}

D(z)={3}

Variables:

x , y , z

Restricciones:

x ≤ y

y != z

33

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

34

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.

35

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.

36

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:

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

Dominios:

D(x)={1,2 }

D(y)={1,2 }

D(z)={1,2}

Variables:

x , y , z

Restricciones:

y ≤ x

x + z >2

z ≤ y

37

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.

38

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.

39

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 camino-consistencia. 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 arco-consistente 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.

40

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

41

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.

42

Figura 29 Problema P1

11.5 Problemas utilizados

11.5.1. 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;

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;

43

11.5.3. 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;

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;


44

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;

45

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;


46

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;


47

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;


48

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;


49

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;


50

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;


51

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;


52

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;

53

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;

54

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;

55

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;


56

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;


57

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;


58

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;

59

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;


estudio e implementaciÓn de algoritmos ac-6 y max...

Documents