Tema 7: Problemas de satisfacción de restricciones · x Problema con dominios finitos y restricciones binarias (de obligación). x Problema NP-completo u Por tanto, ... (igual

Inteligencia Artificial I Curso 2003–2004

Tema 7: Problemas desatisfaccion de restricciones

Jose A. Alonso Jimenez

Francisco J. Martın Mateos

Jose L. Ruiz Reina

Dpto. de Ciencias de la Computacion e Inteligencia Artificial

Universidad de Sevilla

IA-I 2003–2004 CcIa Problemas de satisfaccion de restricciones 7.1

Problema de Satisfaccion de Restricciones

x Un problema de satisfaccion de restricciones (PSR) viene definido porlos siguientes elementos:

u Un conjunto finito de variables X1, . . . , Xn

u Un conjunto finito de dominios Di asociados a cada variable Xi, especificando los

posibles valores que puede tomar

u Un conjunto finito de restricciones C1, . . . , Cm, que definen una serie de propiedades

que deben verificar los valores asignados a las variables

x Una solucion al problema es una asignacion de valores a las variables{X1 = v1, . . . , Xn = vn} tal que vi ∈ Di y se verifican las restricciones

x Esta formulacion permite una representacion simple del problema, y eluso de heurısticas de proposito general, independientes del problema


Tipos de Problemas de Satisfaccion de Restricciones

x Clasificacion segun el tipo de restricciones:

u Restricciones de obligacion (hard constraints).

u Restricciones de preferencia (soft constraints).

x Clasificacion segun los dominios:

u Dominios discretos (finitos o infinitos).

u Dominios continuos.

x Clasificacion segun el numero de variables implicadas en las restriccio-nes:

u Restricciones binarias.

u Restricciones multiples.


Ejemplo: N reinas

x Situar N reinas en un tablero de ajedrez de tamano N × N de formaque no se den jaque mutuamente.

x Variables: V1, . . . , VN

x Dominios: Di = {1, . . . , N}x Restricciones:

u Jaque horizontal: Vi 6= Vj

u Jaque diagonal: |Vi − Vj| 6= |i − j|

R

R

V1 = 1, V2 = 3

x Problema con dominios finitos y restricciones binarias (de obligacion).


Ejemplo: coloreado de mapas

x Usando tres colores (rojo,azul,verde) colorear el mapa de Andalucıa:

HU

SE

JACO

CA

GR

AL

MA

x Variables: Huelva, Cadiz, Sevilla, Cordoba, Malaga, Jaen,Granada, Almeria

x Dominios: {rojo, azul, verde}x Restricciones: P 6= Q, para cada par de provincias vecinas P y Q

x Problema con dominios finitos y restricciones binarias (de obligacion).


Ejemplo: satisfacibilidad proposicional

x Problema SAT (para clausulas):

u Dado un conjunto de variables proposicionales L = {p1, . . . , pn} y un conjunto de

clasusulas proposicionales {C1, . . . , Cm} formadas con los sımbolos de L, determinar

si existe una asignacion de valores de verdad a los simbolos de L de manera que se

satisfagan todan las clausulas

x Variables: {p1, . . . , pn}x Dominios: {T, F} (booleanos)

x Restricciones: {C1, . . . , Cm}x Problema con dominios finitos y restricciones binarias (de obligacion).

x Problema NP-completo

u Por tanto, en el peor caso, no es posible resolver PSRs con dominios finitos en

tiempo polinomial (si P 6= NP ).


Ejemplo: criptoaritmetica

x Asignar valores distintos del 1 al 8 a cada letra para que la ecuacionindicada sea cierta:

x Variables: I, D, E, A, M,N, T, C1, C2, C3

x Dominios: {1, . . . , 8} para I, D,E, A,M,N, T y {0, 1} para C1, C2, C3

x Restricciones:u Primera suma: 2 ∗ A = (10 ∗ C3) + E

u Segunda suma: (2 ∗ E) + C3 = (10 ∗ C2) + T

u Tercera suma: (2 ∗D) + C2 = (10 ∗ C1) + N

u Cuarta suma: (2 ∗ I) + C1 = (10 ∗M) + E

I D E AI D E A

M E N T E

+

(C1 C2 C3)

x Problema con dominios finitos y restricciones multiples (de obligacion).


Ejemplo: asignacion de tareas

x Asignar tareas a empleados de acuerdo con su capacidad para desarro-llarlas:

x Variables: Ei

x Dominios: Di = {T1, . . . , Tn}x Restricciones:

u Obtener la mejor∑n

i=1 Ci

x Tabla de capacidades (Ci):

T1 T2 T3

E1 1 3 2

E2 3 2 1

E3 2 3 1

x Problema con dominios finitos y restricciones multiples (de preferencia).


Ejemplo: planificacion de corte

x Encontrar la manera de situar patrones de corte en una pieza de carton.

x Variables: P1, P2, P3, P4

x Dominios: Coordenadas en el plano.

x Restricciones:u Las piezas no deben superponerse.

x Problema con dominios continuos y restricciones binarias (de obliga-cion).


Problemas de Satisfaccion de Restricciones

x En este tema, trataremos PSRs:

u Con dominios finitos

u Con restricciones binarias de obligacion

x Todo problema con restricciones multiples se puede reducir a uno equi-valente con restricciones binarias

x Representacion en forma de grafo de un PSR:

SE

CA

MA

CO JA

GR ALHU

HU=CA

HU=SE

CA=SE

CA=MA

SE=MA

SE=CO

CO=JA

CO=GR

MA=GR GR=AL

JA=GRCO=MA


Implementacion de la representacion de un PSR

x Variables: estructura con nombre + dominiou Funciones de acceso: psr-var-nombre y psr-var-dominio

x La variable global *variables* contiene a todas las variables del PSR

x Restricciones: estructura con los nombres de las variables involucradas+ funcion

u Funciones de acceso: psr-restr-variables y psr-restr-funcion

x La variable global *restricciones* contiene todas las restricciones delPSR


PSR como problema de espacio de estados

x Estados:u Asignaciones parciales (y consistentes con las restricciones) de valores a variables:

{Xi1 = vi1, . . . , Xik = vik}u Estado inicial: {}u Estados finales: asignaciones completas

x Operadores:

u Asignar un valor (de su dominio) a una variable no asignada en el estado

u Aplicabilidad: la asignacion resultante tiene que ser consistente

x Soluciones mediante busqueda en profundidad

u Puesto que las soluciones estan a una profundidad fija (igual al numero de variables),

profundidad es preferible a anchura


Simplificaciones en la busqueda

x El orden en el que se aplican los operadores es irrelevante para la solu-cion final (conmutatividad)

u Por tanto, los operadores puden reducirse a considerar las posibles asignaciones a

una unica variable no asignada

x El camino no es importante

u No necesitamos la estructura de nodo

u No necesitamos una representacion explıcita para los operadores

x No es posible repetir un estado durante la busqueda:

u No es necesario realizar comprobaciones para evitar repeticiones

u La lista de CERRADOS es superflua


Busqueda en profundidad para PSR: implementacion

x Estados: representados como listas de asociacion

x Funcion que elige la nueva variable a asignar (de entre las no asignadas):

u SELECCIONA-VARIABLE(ESTADO)

x Funcion que ordena los valores a asignar:

u ORDENA-VALORES(DOMINIO)

x Funcion que calcula los sucesores:

FUNCION PSR-SUCESORES(ESTADO)

1. Hacer VARIABLE igual a SELECCIONA-VARIABLE(ESTADO)

Hacer DOMINIO-ORD igual ORDENA-VALORES(PSR-VAR-DOMINIO(ESTADO))

Hacer SUCESORES igual a vacıo

2. Para cada VALOR en DOMINIO-ORD,

Hacer NUEVO-ESTADO igual a la asignacion obtenida ampliando

ESTADO con VARIABLE=VALOR

Si NUEVO-ESTADO es consistente con *RESTRICCIONES*,

a~nadir NUEVO-ESTADO a SUCESORES

3. Devolver SUCESORES


Busqueda en profundidad para PSR: implementacion

FUNCION PSR-BUSQUEDA-EN-PROFUNDIDAD()

1. Hacer ABIERTOS igual a la lista formada por la asignacion vacıa

2. Mientras que ABIERTOS no este vacıa,

2.1 Hacer ACTUAL el primer estado de ABIERTOS

2.2 Hacer ABIERTOS el resto de ABIERTOS

2.3 Si ACTUAL es una asignacion completa

2.4.1 devolver ACTUAL y terminar.

2.4.2 en caso contrario,

2.4.2.1 Hacer NUEVOS-SUCESORES igual a PSR-SUCESORES(ACTUAL)

2.4.2.2 Hacer ABIERTOS igual al resultado de incluir

NUEVOS-SUCESORES al principio de ABIERTOS

3. Devolver FALLO.


Busqueda en profundidad para PSR: ejemplos

x 8 reinas:

> (load "psr-alg-comun.lsp")

> (load "psr-busqueda-en-profundidad")

> (load "psr-n-reinas")

> (n-reinas 8)

> (psr-busqueda-en-profundidad)

((8 . 4) (7 . 2) (6 . 7) (5 . 3) (4 . 6) (3 . 8) (2 . 5) (1 . 1))

x Coloreado del mapa:

> (load "psr-mapa-andalucia")

> (psr-busqueda-en-profundidad)

((ALMERIA . AZUL) (GRANADA . ROJO) (JAEN . AZUL) (CORDOBA . VERDE)

(MALAGA . AZUL) (CADIZ . VERDE) (SEVILLA . ROJO) (HUELVA . AZUL))


Algoritmo de backtracking

x El algoritmo de busqueda en profundidad anterior se suele llamar algo-ritmo de backtracking

u Usualmente, se presenta de manera recursiva:

FUNCION PSR-BACKTRACKING()

Devolver PSR-BACKTRACKING-REC({})

FUNCION PSR-BACKTRACKING-REC(ESTADO)

1. Si ESTADO es una asignacion completa, devolver ESTADO y terminar

2. Hacer VARIABLE igual a SELECCIONA-VARIABLE(ESTADO)

Hacer DOMINIO-ORD igual ORDENA-VALORES(PSR-VAR-DOMINIO(ESTADO))

3. Para cada VALOR en DOMINIO-ORD,

3.1 Hacer NUEVO-ESTADO igual a la asignacion obtenida ampliando

ESTADO con VARIABLE=VALOR

3.2 Si NUEVO-ESTADO es consistente con *RESTRICCIONES*, hacer:

3.2.1 RESULTADO igual PSR-BACKTRCKING-REC(NUEVO-ESTADO)

3.2.2 Si RESULTADO no es FALLO, devolver RESULTADO y terminar

3. Devolver FALLO


Heurısticas en el algoritmo de backtracking

x En principio, el algoritmo de backtracking realiza una busqueda ciega

u Busqueda no informada, ineficiente en la practica

x Sin embargo, es posible dotar al algoritmo de cierta heurıstica que me-jora considerablemente su rendimiento

u Estas heurısticas son de proposito general

u Independientes del problema

u Sacan partido de la estructura especial de los PSR

x Posibles mejoras heurısticas

u Seleccion de nueva variable a asignar

u Orden de asignacion de valores a la variable elegida

u Propagacion de informacion a traves de las restricciones

u Vuelta atras “inteligente” en caso de fallo


Seleccion de variables y ordenacion de valores

x Definicion adecuada de la funcion SELECCIONA-VARIABLE(ESTADO)u Estrategia poco eficiente (no informada): tomar la primera variable no asignada

x Heurıstica MRV:u seleccionar la variable con el menor numero de valores en su dominio consistente

con la asignacion parcial actualu Ejemplo:

Con la asignacion (parcial) {Huelva=Rojo, Sevilla=Azul, Malaga=Rojo},

la siguiente variable a asignar serıa Cadiz o Cordoba (en ambos

casos solo hay un valor en sus dominios consistente con la asignacion)

x Otra heurıstica: mayor numero de restricciones para la variable (grado)u Usada para desempatar MRV

x Ordenacion de valores a asignar (funcion ORDENA-VALORES(DOMINIO))

u Considerar antes los que eliminen menos posibles valores de las variables por asignar


Comprobacion hacia adelante (forward checking)

x Para cada estado, mantener cierta informacion sobre los posibles valorespara las variables que quedan por asignar:

u Cada vez que se asigna un nuevo valor a una variable, quitar del dominio de las

variables por asignar, aquellos valores que no sean consistentes con el nuevo valor

asignado

x Ejemplo (seleccionando variables en orden alfabetico):

{AL=R} --> eliminar R del dominio de GR

{AL=R,CA=R} --> eliminar R de los dominios de HU, SE y MA

{AL=R,CA=R,CO=A} --> eliminar A de los dominios de MA, SE y JA

{AL=R,CA=R,CO=A,GR=V} --> eliminar V de los dominios de JA y MA

En este momento, MA no tiene ningun valor posible. Por tanto, no es

necesario seguir explorando en el arbol.

u Se ha detectado inconsistencia sin necesidad de asignar valores a Huelva y Jaen, y

para cualquier extension de la asignacion parcial construida hasta el momento


Eje

mplo

:N

-rein

as

xBacktr

ackin

g+

forw

ard

chec

kin

gen

4-r

ein

as

R

R

R

R

R

R

R

R

R

R

R

R

R

R

R

R

R

R

R

R

IA-I

2003

–200

4C

cI a

Pro

ble

mas

de

sati

sfac

cion

de

rest

ricc

iones

7.21

Propagacion de restricciones

x Cuestiones tecnicas sobre la comprobacion hacia adelante:

u Cada nodo del arbol debe contener el estado junto la lista de valores posibles en

las variables por asignar

u Muy facil de usar en conjuncion con la heurıstica MRV

x La comprobacion hacia adelante es un caso particular de propagacionde restricciones:

u Propagar las implicaciones de las restricciones sobre una variable sobre otras va-

riables

u existen tecnicas mas completas para propagar restricciones que la comprobacion

hacia adelante

u la propagacion debe ser rapida: completitud vs rapidez

x La consistencia de arcos proporciona un metodo con un buen compro-miso entre eficiencia y completitud


Consistencia de arcos

x En un PSR, por arco entendemos un arco dirigido en el grafo que lorepresenta

u Equivalentemente, un arco es una restriccion en la que hay una variable distinguida

u Notacion: B > E, CO 6= SE, |Vi − Vj| 6= |i− j|x Arco consistente respecto a un conjunto de dominios asociados a un

conjunto de variables:

u Para cualquier valor del dominio asociado a la variable distinguida del arco, existen

valores en los dominios de las restantes variables que satisfacen la restriccion del

arco

u Ejemplo: si SE y CO tienen ambas asignadas como dominio {rojo, verde}, el arco

CO 6= SE es consistente

u Ejemplo: si SE tiene como dominio {rojo} y CO tiene como dominio {rojo, verde},

el arco CO 6= SE no es consistente

u En este ultimo caso, el arco puede hacerse consistente eliminando rojo del dominio

de CO


Algoritmo de consistencia de arcos AC-3 (idea intuitiva)

x Objetivo:

u a partir de los dominios iniciales de las variables

u devolver un conjunto de dominios actualizado tal que todos los arcos del problema

sean consistentesx Actualizacion de dominios:

u Si un arco es inconsistente, podemos hacerlo consistente eliminando del dominio

de la variable distinguida aquellos valores para los que no existen valores en los

dominios de las restantes variables que satisfagan la restriccionx Revision de arcos:

u si el dominio de una variable se actualiza, es necesario revisar la consistencia de los

arcos en los que aparece la variable como variable no distinguidax Criterio de parada:

u Todos los arcos son consistentes respecto a los dominios de las variables

u O algun dominio queda vacıo (inconsistencia)


Consistencia de arcos (ejemplo)

x Planificacion de las acciones de un robot (Poole, pag. 149): Un robotnecesita planificar cinco actividades (A, B, C, D y E), donde cada acti-vidad ha de comenzar en un momento en el tiempo (1, 2, 3, o 4) y duraexactamente una unidad de tiempo. Restricciones:

u La actividad B no puede realizarse en el momento numero 3.

u La actividad C no puede realizarse en el momento numero 2.

u Las actividades A y B no pueden realizarse simultaneamente.

u Las actividades B y C no pueden realizarse simultaneamente.

u La actividad C ha de realizarse antes de la D.

u Las actividades B y D no pueden realizarse simultaneamente.

u Las actividades A y D han de realizarse simultaneamente.

u La actividad E ha de ser la ultima.



x Representacion como grafo:

1B

24

1 23 4

A

1C

431 23 4

D

1 23 4

E

A = B

B = D

E < D E < C

B = CA = D

E < BE < A

C < D



x Seguimiento del ejemplo:

Variables y dominios Arcos pendientes de revisar

(A 1 2 3 4) (B 1 2 4) (C 1 3 4) A 6= B, A 6= B, B 6= C, B 6= C, C < D, C < D, B 6= D, B 6= D,(D 1 2 3 4) (E 1 2 3 4) A = D, A = D, A > E, A > E, B > E, B > E, C > E, C > E,

D > E, D > E

(A 1 2 3 4) (B 1 2 4) (C 1 3) C < D, B 6= D, B 6= D, A = D, A = D, A > E, A > E, B > E,(D 1 2 3 4) (E 1 2 3 4) B > E, C > E, C > E, D > E, D > E, B 6= C

(A 1 2 3 4) (B 1 2 4) (C 1 3) B 6= D, B 6= D, A = D, A = D, A > E, A > E, B > E, B > E,(D 2 3 4) (E 1 2 3 4) C > E, C > E, D > E, D > E, B 6= C, C < D

(A 2 3 4) (B 1 2 4) (C 1 3) A = D, A > E, A > E, B > E, B > E, C > E, C > E, D > E,(D 2 3 4) (E 1 2 3 4) D > E, B 6= C, C < D, A 6= B

(A 2 3 4) (B 1 2 4) (C 1 3) B > E, B > E, C > E, C > E, D > E, D > E, B 6= C, C < D,(D 2 3 4) (E 1 2 3) A 6= B, A > E

(A 2 3 4) (B 2 4) (C 1 3) B > E, C > E, C > E, D > E, D > E, B 6= C, C < D, A 6= B,(D 2 3 4) (E 1 2 3) A > E, A 6= B, B 6= C, B 6= D

(A 2 3 4) (B 2 4) (C 3) C > E, D > E, D > E, B 6= C, C < D, A 6= B, A > E, A 6= B,(D 2 3 4) (E 1 2 3) B 6= C, B 6= D, C < D



x Seguimiento del ejemplo:

Variables y dominios Arcos pendientes de revisar

(A 2 3 4) (B 2 4) (C 3) D > E, D > E, B 6= C, C < D, A 6= B, A > E, A 6= B, B 6= C,(D 2 3 4) (E 1 2) B 6= D, C < D, B > E, C > E

(A 2 3 4) (B 2 4) (C 3) B > E, C > E, C < D, B 6= D, A = D, D > E(D 4) (E 1 2)

(A 2 3 4) (B 2) (C 3) A = D, D > E, A 6= B, B 6= C, B 6= D, B > E

(D 4) (E 1 2)

(A 4) (B 2) (C 3) D > E, A 6= B, B 6= C, B 6= D, B > E, A 6= B, A = D, A > E

(D 4) (E 1 2)

(A 4) (B 2) (C 3) (D 4) (E 1) A 6= B, A = D, A > E, A > E, B > E, C > E, D > E

(A 4) (B 2) (C 3) (D 4) (E 1)


Implementacion del algoritmo AC-3

x Arcos: estructura con los campos variable y restriccionu Funciones de acceso: arco-variable y arco-restriccion

x Generacion de todos los arcos de un PSR:FUNCION ARCOS()

1. Hacer ARC igual a vacıo

2. Para cada RESTRICCION es *RESTRICCIONES*

2.1 Para cada VARIABLE en PSR-RESTR-VARIABLES(RESTRICCION)

A~nadir a ARC el arco formado por VARIABLE+RESTRICCION

3. Devolver ARC

x Calculo de dominio actualizado:FUNCION ACTUALIZA-DOMINIO(VARIABLE,RESTRICCION,VARIABLES)

1. Hacer DOMINIO-ACTUAL igual al dominio de VARIABLE en VARIABLES

Hacer NUEVO-DOMINIO igual a vacıo

2. Para cada VALOR en DOMINIO-ACTUAL hacer

2.1 Si para ese VALOR de VARIABLE existe una asignacion a las

restantes variables de RESTRICCION que satisfaga RESTRICCION,

incluir VALOR en NUEVO-DOMINIO

3. Devolver NUEVO-DOMINIO


Implementacion del algoritmo AC-3

x Algoritmo AC-3u Entrada: una lista de variables+dominios

u Salida: la lista de entrada, con los dominios actualizados (destructivamente) de

manera que todos los arcos del PSR son consistentes

FUNCION AC-3(VARIABLES)

1. Hacer RED igual a ARCOS()

2. Mientras RED no sea vacıo

2.1 Hacer ACTUAL el primero de RED y RED el resto de RED

2.2 Hacer VARIABLE igual a ARCO-VARIABLE(ARCO) y

RESTRICCION igual ARCO-RESTRICCION(ARCO)

2.3 Hacer VIEJO-DOMINIO igual al dominio de VARIABLE en VARIABLES

2.4 Hacer NUEVO-DOMINIO igual a ACTUALIZA-DOMINIO(VARIABLE,RESTRICCION,VARIABLES)

2.5 Si NUEVO-DOMINIO y VIEJO-DOMINIO son distintos, entonces

2.5.1 Actualizar el dominio de VARIABLE en VARIABLES con NUEVO-DOMINIO

2.5.2 Incluir en RED todos los arcos de ARCOS() en los que aparezca

VARIABLE y esta NO sea la variable distinguida del arco

2.6 Devolver VARIABLES


Propiedades de AC-3

x Complejidad (en el caso de restricciones binarias)

u n: numero de variables

u d: maximo numero de valores de un dominio

u Complejidad en tiempo: O(n2d3) (polinomial)

x Por tanto, solo con AC-3 no es posible resolver un PSR

u Pero puede combinarse con algun tipo de busqueda

x Dos aproximaciones:

u Incorporar en el algoritmo de backtracking, como un paso de propagacion de res-

tricciones despues de cada asignacion

u Intercalar AC-3 con busqueda


Busqueda de soluciones mediante consistencia de arcos

x Resultado tras aplicar AC-3:

u Existe un dominio vacıo: no hay solucion.

u Todos los dominios son unitarios: hay una solucion.

u No hay dominios vacıos y al menos uno no es unitario: ¿soluciones?.

x Idea: romper un dominio no vacıo en subdominios y aplicar AC-3 a losestados resultantes

u Esto se puede hacer de manera sistematica (busqueda)

u Hasta que se detecta inconsistencia en todas las alternativas (no hay solucion)

u Hasta que se obtiene un estado con todos los dominios unitarios (solucion)


Busqueda de soluciones mediante consistencia de arcos

FUNCION BUSQUEDA-AC3()

1. Hacer ABIERTOS igual a una lista cuyo unico elemento es

una copia de *VARIABLES*

2. Mientras que ABIERTOS no este vacıa,

2.1 Hacer ACTUAL igual a AC3(PRIMERO(ABIERTOS))

2.2 Hacer ABIERTOS el resto de ABIERTOS

2.3 Si no existen dominios vacıos en ACTUAL,

2.3.1 Si ACTUAL tiene todos los dominios unitarios,

devolver ACTUAL y terminar

2.3.2 Si no, calcular los sucesores de ACTUAL y a~nadirlos

a la lista de ABIERTOS

3. Devolver FALLO.

x Detalles a concretar de la implementacion:

u Sucesores: escoger un dominio no unitario y dividirlo de alguna manera

u Gestion de la cola de abiertos: anchura o profundidad


Consi

stenci

ade

arc

os

xEje

mplo

de

uso

:N

-rein

as

>(load

"psr-alg-comun.lsp")

T >(load

"psr-n-reinas.lsp")

T >(load

"psr-alg-arcos.lsp")

T >(n-reinas

10)

*RESTRICCIONES*

>(time

(busqueda-ac3))

Real

time:

7.330538

sec.

Run

time:

7.06

sec.

Space:

5204128

Bytes

GC:

10,

GC

time:

0.17

sec.

(#S(VARIABLE-PSR

:NOMBRE

1:DOMINIO

(1))

#S(VARIABLE-PSR

:NOMBRE

2:DOMINIO

(3))

#S(VARIABLE-PSR

:NOMBRE

3:DOMINIO

(6))

#S(VARIABLE-PSR

:NOMBRE

4:DOMINIO

(8))

#S(VARIABLE-PSR

:NOMBRE

5:DOMINIO

(10))

#S(VARIABLE-PSR

:NOMBRE

6:DOMINIO

(5))

#S(VARIABLE-PSR

:NOMBRE

7:DOMINIO

(9))

#S(VARIABLE-PSR

:NOMBRE

8:DOMINIO

(2))

#S(VARIABLE-PSR

:NOMBRE

9:DOMINIO

(4))

#S(VARIABLE-PSR

:NOMBRE

10

:DOMINIO

(7))

) IA-I

2003

–200

4C

cI a

Pro

ble

mas

de

sati

sfac

cion

de

rest

ricc

iones

7.34

Algoritmos de mejora iterativa para PSRs

x Planteamiento como un problema de busqueda local:

u Estados: asignaciones completas (consistentes o inconsistentes)

u Estado inicial escogido aleatoriamente

u Estados finales: soluciones al PSR

u Generacion de sucesor: elegir una variable y cambiar el valor que tiene asignado

(usando cierta heurıstica y aleatoriedad)

x Generacion de sucesor mediante la estrategia de mınimos conflictos

u Variable elegida: aquella (distinta de la ultima modificada) que participa en mas

restricciones NO satisfechas en el estado (los empates se deshacen aleatoriamente)

u Valor elegido: aquel valor (distinto del que tenıa) que produce el menor numero de

restricciones incumplidas (los empates se deshacen aleatoriamente)


Algoritmo de reparacion heurıstica (mınimos conflictos)

x Estructura nodo-minc: asignacion + ultima variable modificada

x Pseudocodigo:

FUNCION MIN-CONFLICTOS(MAX-ITERACIONES)

1. Hacer ACTUAL igual a un nodo con una asignacion generada aleatoriamente.

2. Para I desde 1 hasta MAX-ITERACIONES hacer

2.1 Si la asignacion de ACTUAL es una solucion, devolverla y terminar.

2.2 Hacer VARIABLE igual a una variable (distinta de la ultima

modificada) escogida aleatoriamente de entre aquellas que

participan en el mayor numero de restricciones incumplidas.

2.3 Hacer SUCESORES igual a la lista de nodos obtenidos cambiando

en la asignacion de ACTUAL el valor de VARIABLE por cada uno de

los posibles valores del dominio de VARIABLE en *VARIABLES*

(excepto el correspondiente al valor que tenıa en ACTUAL)

2.4 Hacer ACTUAL el nodo de SUCESORES escogido aleatoriamente de

entre aquellos cuya asignacion incumple el menor numero de restricciones

3. Devolver FALLO


Repara

cion

heurı

stic

a:eje

mplo

s

xEje

mplo

de

uso

:N

-rein

as

>(load

"psr-alg-comun.lsp")

T >(load

"psr-n-reinas.lsp")

T >(load

"psr-alg-minc.lsp")

T >(n-reinas

10)

*RESTRICCIONES*

>(time

(reparacion-heuristica-minc

:iteraciones

20))

Real

time:

2.155908

sec.

Run

time:

2.15

sec.

Space:

2758404

Bytes

GC:

6,

GC

time:

0.07

sec.

(12 (#S(VARIABLE-PSR

:NOMBRE

1:DOMINIO

(6))

#S(VARIABLE-PSR

:NOMBRE

2:DOMINIO

(8))

#S(VARIABLE-PSR

:NOMBRE

3:DOMINIO

(1))

#S(VARIABLE-PSR

:NOMBRE

4:DOMINIO

(4))

#S(VARIABLE-PSR

:NOMBRE

5:DOMINIO

(7))

#S(VARIABLE-PSR

:NOMBRE

6:DOMINIO

(10))

#S(VARIABLE-PSR

:NOMBRE

7:DOMINIO

(2))

#S(VARIABLE-PSR

:NOMBRE

8:DOMINIO

(9))

#S(VARIABLE-PSR

:NOMBRE

9:DOMINIO

(5))

#S(VARIABLE-PSR

:NOMBRE

10

:DOMINIO

(3))

))

IA-I

2003

–200

4C

cI a

Pro

ble

mas

de

sati

sfac

cion

de

rest

ricc

iones

7.37

Reparacion heurıstica: ejemplos

x Seguimiento de un ejemplo: N-reinas

V1 V2 V3 V4

valor conflictos valor conflictos valor conflictos valor conflictos

1 3 1 3 1 3 1 3

1 2 1 2 4 0 1 2

1 2 2 1 4 0 1 1

3 1 2 1 4 0 1 0

3 0 1 1 4 0 1 1

3 0 1 0 4 0 2 0


Comparacion de los tres algoritmos:

x Ejemplo: N-reinas

backtracking arcos min-conflictos (media sobre 10 pruebas)

N tiempo espacio tiempo espacio tiempo espacio

4 0.04 84064 0.06 73968 0.08 97019

8 6.18 9967912 3.17 2792464 2.27 2953025

12 51.16 75282044 22.71 16295860 16.96 20217256

x Reparacion heurıstica tiene muy buenos resultados en algunos tipos dePSRs:

u PSRs cuyas soluciones estan distribuidas uniformemente a lo largo del espacio de

estados

u PSRs en los que las restricciones pueden cambiar dinamicamente


Bibliografıa

x Nilsson, N.J. Inteligencia artificial (Una nueva sıntesis) (McGraw–Hill, 2000)

u Cap. 11 “Metodos alternativos de busqueda y otras aplicaciones”.

x Poole, D.; Mackworth, A. y Goebel, R. Computational Intelligence (ALogical Approach) (Oxford University Press, 1998)

u Cap. 4.7: “Constraint Satisfaction Problems”.

x Russell, S. y Norvig, P. Artificial Intelligence (A Modern Approach)(Prentice–Hall, 2000). Second Edition

u Cap. 5: “Constraint Satisfaction Search”.


Inteligencia Artificial I Curso 2003–2004

Tema 7 (anexo):Implementaciones en Lisp

Dpto. de Ciencias de la Computacion e Inteligencia Artificial

Universidad de Sevilla


Representacion de PSRs

x Representacion de las variables:

(defstruct (variable-psr (:constructor crea-variable)

(:conc-name psr-var-))

nombre

dominio)

x Representacion de las restricciones:

(defstruct (restriccion-psr (:constructor crea-restriccion)

(:conc-name psr-restr-))

variables

funcion)


Problema de las N reinas

(defun crea-dominio (n) (loop for i from 1 to n collect i))

(defun n-reinas (n)

(defparameter *variables*

(loop for i from 1 to n collect

(crea-variable :nombre i :dominio (crea-dominio n))))

(defparameter *restricciones*

(loop for i from 1 to n append

(loop for j from 1 to n

when (> j i)

collect (crea-restriccion

:variables (list i j)

:funcion (restriccion-reinas i j))))))

(defun restriccion-reinas (i j)

#’(lambda (x y)

(and (not (= x y))

(not (= (abs (- x y)) (abs (- i j)))))))


Problema de colorear el mapa de Andalucıa (I)

(defparameter *colores* ’(azul rojo verde))

(defparameter *variables*

(list (crea-variable :nombre ’Huelva :dominio *colores*)

(crea-variable :nombre ’Sevilla :dominio *colores*)

(crea-variable :nombre ’Cadiz :dominio *colores*)

(crea-variable :nombre ’Malaga :dominio *colores*)

(crea-variable :nombre ’Cordoba :dominio *colores*)

(crea-variable :nombre ’Jaen :dominio *colores*)

(crea-variable :nombre ’Granada :dominio *colores*)

(crea-variable :nombre ’Almeria :dominio *colores*)))


Problema de colorear el mapa de Andalucıa (II)

(defparameter *restricciones*

(list (crea-restriccion :variables ’(Huelva Sevilla)

:funcion #’(lambda (x y) (not (eq x y))))

(crea-restriccion :variables ’(Huelva Cadiz)


(crea-restriccion :variables ’(Cadiz Malaga)


(crea-restriccion :variables ’(Cadiz Sevilla)


(crea-restriccion :variables ’(Sevilla Cordoba)


(crea-restriccion :variables ’(Sevilla Malaga)


(crea-restriccion :variables ’(Cordoba Jaen)


(crea-restriccion :variables ’(Cordoba Malaga)


(crea-restriccion :variables ’(Malaga Granada)


(crea-restriccion :variables ’(Granada Jaen)


(crea-restriccion :variables ’(Granada Almeria)

:funcion #’(lambda (x y) (not (eq x y))))))


Solucion a PSRs mediante busqueda en profundidad (I)

x Estados finales:

(defun es-asignacion-completa (estado)

(= (length estado) (length *variables*)))

x Sucesores:

(defun bpr-sucesores (actual)

(elimina-inconsistentes-nueva-asignacion

(asigna-nueva-variable actual)))


Solucion a PSRs mediante busqueda en profundidad (II)

x Asignacion de nuevas variables:

(defun asignada (variable estado)

(assoc variable estado))

(defun primera-variable-no-asignada (estado)

(find-if-not

#’(lambda (x) (asignada (psr-var-nombre x) estado))

*variables*))

(defun asigna-nueva-variable (estado)

(let* ((variable (primera-variable-no-asignada estado))

(nombre (psr-var-nombre variable))

(dominio (psr-var-dominio variable)))

(loop for val in dominio collect (acons nombre val estado))))


Solucion a PSRs mediante busqueda en profundidad (III)

x Eliminacion de asignaciones inconsistentes:

(defun elimina-inconsistentes-nueva-asignacion (estados)

(loop for estado in estados

when (verifica-restricciones-posibles estado)

collect estado))

(defun verifica-restricciones-posibles (estado)

(loop for restriccion in *restricciones*

always

(let* ((variables (psr-restr-variables restriccion))

(a1 (assoc (first variables) estado))

(a2 (assoc (second variables) estado)))

(or (not (member (caar estado) variables))

(not a1) (not a2)

(funcall (psr-restr-funcion restriccion) (cdr a1) (cdr a2))))))


Solucion a PSRs mediante busqueda en profundidad (y IV)

x Busqueda en profundidad:

(defun psr-busqueda-en-profundidad ()

(let ((abiertos (list nil)))

(loop until (null abiertos) do

(setf actual (first abiertos))

(setf abiertos (rest abiertos))

(cond ((es-asignacion-completa actual)

(return actual))

(t (setf nuevos-sucesores (bpr-sucesores actual))

(setf abiertos (append nuevos-sucesores abiertos)))))))


Algoritmo de backtracking (version recursiva)

x Seleccion de variables y ordenacion de valores:

(defun selecciona-variable (estado) (primera-variable-no-asignada estado))

(defun ordena-valores-del-dominio (x) x)

x Backtracking recursivo:

(defun psr-backtracking () (psr-backtracking-rec ’()))

(defun psr-backtracking-rec (estado)

(if (es-asignacion-completa estado)

estado

(let* ((variable (selecciona-variable estado))


(dominio (ordena-valores-del-dominio (psr-var-dominio variable))))

(loop for val in dominio do

(let ((nuevo-estado (acons nombre val estado)))

(when (verifica-restricciones-posibles nuevo-estado)

(let ((resultado (psr-backtracking-rec nuevo-estado)))

(when resultado (return resultado)))))))))


Consistencia de arcos

x Arco = Restriccion + Variable

(defstruct (arco (:constructor crea-arco)

(:conc-name arco-))

variable

restriccion)

x Lista de arcos de un P.S.R.:

(defun arcos ()

(loop for restriccion in *restricciones* append

(loop for var in (psr-restr-variables restriccion) collect

(crea-arco :variable var :restriccion restriccion))))


Algoritmo de consistencia de arcos AC-3

(defun ac3 (variables)

(let ((red (arcos))

(actual nil))

(loop until (null red) do

(setf actual (first red))

(setf red (rest red))

(let* ((variable-mod

(variable-nombre (arco-variable actual) variables))

(restriccion (arco-restriccion actual))

(viejo-dominio (psr-var-dominio variable-mod))

(nuevo-dominio

(actualiza-dominio variable-mod variables restriccion)))

(when (not (equal nuevo-dominio viejo-dominio))

(setf (psr-var-dominio variable-mod) nuevo-dominio)

(when (null nuevo-dominio) (return))

(setf red (append red (nuevos-arcos variable-mod red)))))))

variables)



x Obtencion de arcos cuya consistencia es discutible:

(defun nuevos-arcos (variable-mod red)

(let ((var-mod (psr-var-nombre variable-mod))

(arcos (arcos)))

(loop for arco in arcos

when (and (not (equal var-mod (arco-variable arco)))

(not (member arco red :test #’equalp))

(member var-mod (psr-restr-variables

(arco-restriccion arco))))

collect arco)))



x Actualizacion de dominios (restricciones binarias):

(defun actualiza-dominio (variable-mod variables restriccion)

(let ((nombre1 (first (psr-restr-variables restriccion)))

(nombre2 (second (psr-restr-variables restriccion)))

(funcion (psr-restr-funcion restriccion)))

(cond ((equal (psr-var-nombre variable-mod) nombre1)

(loop for val1 in (psr-var-dominio variable-mod) when

(test-de-existencia-1 val1

(variable-nombre nombre2 variables)

funcion)

collect val1))

(t (loop for val2 in (psr-var-dominio variable-mod) when

(test-de-existencia-2 val2

(variable-nombre nombre1 variables)

funcion)

collect val2)))))



x Tests de existencia:

(defun test-de-existencia-1 (val1 var2 funcion)

(loop for val2 in (psr-var-dominio var2)

thereis (funcall funcion val1 val2)))

(defun test-de-existencia-2 (val2 var1 funcion)

(loop for val1 in (psr-var-dominio var1)

thereis (funcall funcion val1 val2)))


Busqueda de soluciones mediante consistencia de arcos (I)

x Busqueda por consistencia de arcos:

(defun busqueda-ac3 ()

(let ((abiertos (list (copia-lista-variables-psr *variables*)))

(actual nil))

(loop until (null abiertos) do

(setf actual (ac3 (first abiertos)))

(setf abiertos (rest abiertos))

(cond ((hay-dominio-vacio actual)

nil)

((dominios-unitarios actual)

(return actual))

(t (setf abiertos

(append (cda-sucesores actual) abiertos)))))))


Busqueda de soluciones mediante consistencia de arcos (II)

x Comprobacion de dominios vacıos:

(defun hay-dominio-vacio (variables)

(loop for var in variables thereis (dominio-vacio var)))

x Generacion de sucesores:

(defun cda-sucesores (estado)

(let* ((seleccion (selecciona-dominio estado))

(inicio (first seleccion))

(variable (second seleccion))

(final (third seleccion))

(nuevos-dominios (rompe-dominio variable)))

(loop for var in nuevos-dominios

collect (append (copia-lista-variables-psr inicio)

(list var)

(copia-lista-variables-psr final)))))


Busqueda de soluciones mediante consistencia arcos (y III)

x Seleccionar una variable con dominio no unitario:

(V1 . . . Vi . . . Vn) =⇒ ((V1 . . . Vi−1) Vi (Vi+1 . . . Vn))

(defun selecciona-dominio (variables)

(let ((indice (position-if-not #’dominio-unitario variables)))

(list (subseq variables 0 indice)

(nth indice variables)

(subseq variables (+ indice 1)))))

x Romper un dominio en subdominios (unitario mas el resto):

(defun rompe-dominio (variable)

(list (crea-variable :nombre (psr-var-nombre variable)

:dominio (list (first (psr-var-dominio variable))))

(crea-variable :nombre (psr-var-nombre variable)

:dominio (rest (psr-var-dominio variable)))))


Reparacion heurıstica (mınimos conflictos) (I)

x Nodo:

(defstruct (nodo-minc (:constructor crea-nodo-minc)

(:conc-name minc-))

estado

ultima-modificada)

x Funcion principal:

(defun reparacion-heuristica-minc (&key (iteraciones 100))

(let ((actual (crea-nodo-inicial)))

(loop for i from 1 to iteraciones do

(if (= (numero-conflictos (minc-estado actual)) 0)

(return (list i (minc-estado actual)))

(setf actual

(nodo-menos-conflictivo (rhc-sucesores actual)))))))


Reparacion heurıstica (mınimos conflictos) (II)

x Construccion del nodo inicial:

(defun crea-nodo-inicial ()

(crea-nodo-minc

:estado

(loop for var in *variables* collect

(crea-variable :nombre (psr-var-nombre var)

:dominio (list (first (psr-var-dominio var)))))

:ultima-modificada nil))


Reparacion heurıstica (mınimos conflictos) (III)

x Numero de conflictos de un estado:

(defun numero-conflictos (estado)


count (not (comprueba-restriccion restriccion estado))))

x Comprobacion de restricciones (binarias):

(defun comprueba-restriccion (restriccion variables)

(let* ((nombres (psr-restr-variables restriccion))

(val1 (first (dominio-nombre (first nombres) variables)))

(val2 (first (dominio-nombre (second nombres) variables))))

(funcall (psr-restr-funcion restriccion) val1 val2)))


Reparacion heurıstica (mınimos conflictos) (IV)

x Generacion de sucesores de un nodo gsat:

(defun rhc-sucesores (nodo-minc)

(let* ((seleccion (selecciona-conflictiva nodo-minc))

(inicio (first seleccion))

(variable (second seleccion))

(final (third seleccion))


(valor (first (psr-var-dominio variable)))

(dominio (dominio-nombre nombre *variables*)))

(loop for n-val in dominio

when (not (equal n-val valor))

collect (crea-nodo-minc

:estado

(append (copia-lista-variables-psr inicio)

(list (crea-variable :nombre nombre

:dominio (list n-val)))

(copia-lista-variables-psr final))

:ultima-modificada nombre))))


Reparacion heurıstica (mınimos conflictos) (V)

x Seleccion aleatoria de una variable conflictiva:

(V1 . . . Vi . . . Vn) =⇒ ((V1 . . . Vi−1) Vi (Vi+1 . . . Vn))

(defun selecciona-conflictiva (nodo-minc)

(let* ((variables (minc-estado nodo-minc))

(ultima-mod (minc-ultima-modificada nodo-minc))

(indice (indice-con-maximos-conflictos variables ultima-mod)))

(list (subseq variables 0 indice)

(nth indice variables)

(subseq variables (+ indice 1)))))


Reparacion heurıstica (mınimos conflictos) (VI)

x Seleccion aleatoria de una variable conflictiva:

(defun indice-con-maximos-conflictos (variables ultima)

(let ((maximo 0)

(lista-maximos nil))

(loop for i from 0 to (- (length variables) 1) when

(not (equal (psr-var-nombre (nth i variables)) ultima))

do (let ((nuevo-valor

(numero-conflictos-variable variables

(nth i variables))))

(cond ((> nuevo-valor maximo)

(setf maximo nuevo-valor

lista-maximos (list i)))

((= nuevo-valor maximo)

(push i lista-maximos)))))

(nth (random (length lista-maximos)) lista-maximos)))


Reparacion heurıstica (mınimos conflictos) (VII)

x Numero de restricciones incumplidas por una variable:

(defun numero-conflictos-variable (variables var)


when (member (psr-var-nombre var)

(psr-restr-variables restriccion)

:test #’equal)

count (not (comprueba-restriccion restriccion variables))))


Reparacion heurıstica (mınimos conflictos) (y VIII)

x Seleccion del nodo menos conflictivo:

(defun nodo-menos-conflictivo (lista-nodos-minc)

(let* ((nodo-minimo (first lista-nodos-minc))

(resto (rest lista-nodos-minc))

(val-minimo (numero-conflictos (minc-estado nodo-minimo))))

(loop for nodo in resto do

(let ((nuevo-val (numero-conflictos (minc-estado nodo))))

(when (< nuevo-val val-minimo)

(setf val-minimo nuevo-val)

(setf nodo-minimo nodo))))

nodo-minimo))


Documents

Tema 7: Problemas de satisfacción de restricciones · x Problema con dominios finitos y restricciones binarias (de obligación). x Problema NP-completo u Por tanto, ... (igual