Tema 5: Problemas de Satisfacción de Restricciones

(1)

Introducci´on a la Inteligencia Artificial Curso 2002–2003

Tema 5: Problemas de

Satisfacci´ on de Restricciones

Jos´e A. Alonso Jim´enez Francisco J. Mart´ın Mateos

Jos´e L. Ruiz Reina

(2)

Problema de Satisfacci´ on de Restricciones

x

Elementos:

u Variables.

u Dominios.

u Restricciones.

x

Objetivo: Obtener una asignaci´ on de valores a las variables, dentro de sus dominios, que satisfaga u optimice las restricciones

x

Ejemplos:

u Problema de las N reinas.

u Problema criptoaritm´etico.

u Asignaci´on de tareas.

u Planificaci´on de corte.

IIA 2002–2003 CcIa Problemas de Satisfacci´on de Restricciones 5.2

(3)

Tipos de Problemas de Satisfacci´ on de Restricciones

x

Clasificaci´ on seg´ un el tipo de restricciones:

u Problemas de satisfactibilidad: Restricciones de obligaci´on (hard constraints).

u Problemas de optimizaci´on: Restricciones de preferencia (soft constraints).

x

Clasificaci´ on seg´ un los dominios:

u Dominios discretos.

u Dominios continuos.

x

Clasificaci´ on seg´ un el n´ umero de variables implicadas en las restric- ciones:

u Restricciones binarias.

u Restricciones m´ultiples.

(4)

Ejemplo detallado: N reinas

x

Situar N reinas en un tablero de ajedrez de tama˜ no NxN de forma que no se den jaque m´ utuamente.

x

Variables: V

₁

, . . . , V

_N

x

Dominios: D

_i

= {1, . . . , N}

x

Restricciones:

u Jaque horizontal: V_i 6= V_j

u Jaque diagonal: |V_i − V_j| 6= |i − j|

R

V

₁

= 1, V

₂

= 3

x

Problema de satisfactibilidad con dominios discretos y restricciones bi- narias.

(5)

Ejemplo detallado: Criptoaritm´ etica

x

Asignar valores distintos del 1 al 8 a cada letra para que la ecuaci´ on indicada sea cierta:

x

Variables: I, D, E, A, M, N, T, C

₁

, C

₂

, C

₃

x

Dominios: {1, . . . , 8} para I, D, E, A, M, N, T y {0, 1} para C

₁

, C

₂

, C

₃

x

Restricciones:

u Primera suma: 2 ∗ A = (10 ∗ C₃) + E

u Segunda suma: (2 ∗ E) + C₃ = (10 ∗ C₂) + T

u Tercera suma: (2 ∗ D) + C₂ = (10 ∗ C₁) + N

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

I D E A I D E A M E N T E

+

(C1 C2 C3)

(6)

Ejemplo detallado: Asignaci´ on de tareas

x

Asignar tareas a empleados de acuerdo con su capacidad para desarrol- larlas:

x

Variables: E

_i

x

Dominios: D

_i

= {T

₁

, . . . , T

_n

}

x

Restricciones:

u Obtener la mejor P_n

i=1C_i

x

Tabla de capacidades (C

_i

):

T₁ T₂ T₃ E₁ 1 3 2 E₂ 3 2 1 E₃ 2 3 1

x

Problema de optimizaci´ on con dominios discretos y restricciones bina- rias.

(7)

Ejemplo detallado: Planificaci´ on de corte

x

Encontrar la manera de situar patrones de corte en una pieza de cart´ on.

x

Variables: P

₁

, P

₂

, P

₃

, P

₄

x

Dominios: Coordenadas en el plano.

x

Restricciones:

u Las piezas no deben superponerse.

x

Problema de satisfactibilidad con dominios continuos y restricciones

binarias.

(8)

P.S.R.: Representaci´ on

x

Representaci´ on de las variables:

(defstruct (variable-psr (:constructor crea-variable) (:conc-name psr-var-))

nombre dominio)

x

Ejemplo: Variable V con dominio {1, 2, 3, 4, 5}:

(crea-variable :nombre ’V

:dominio ’(1 2 3 4 5))

x

Lista con todas las variables implicadas:

(defvar *variables*)

(9)

P.S.R.: Representaci´ on

x

Representaci´ on de las restricciones:

(defstruct (restriccion-psr (:constructor crea-restriccion) (:conc-name psr-restr-))

variables funcion)

x

Ejemplo: X < (Y + Z)

(crea-restriccion :variables ’(X Y Z)

:funcion (lambda (u v w) (< u (+ v w))))

x

Lista con todas las restricciones implicadas:

(defvar *restricciones*)

(10)

P.S.R.: Representaci´ on del problema de las N reinas

x

Dominios:

(defun crea-dominio (n)

(loop for i from 1 to n collect i))

x

Construcci´ on de las restricciones:

(defun restriccion-reinas (i j)

#’(lambda (x y)

(and (not (= x y))

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

(11)

P.S.R.: Representaci´ on del problema de las N reinas

x

Listas de variables y restricciones:

(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))))))

(12)

P.S.R. como problemas de b´ usqueda: N-reinas

x

Enunciado:

u Tenemos un tablero como los de ajedrez de N por N cuadr´ıculas y queremos colocar N reinas de forma que no se encuentren m´as de una en la misma l´ınea: horizontal, vertical o diagonal.

x

Representaci´ on de estados:

R

u Lista de pares: ((4 3) (3 1) (2 4) (1 2))

u Lista de posiciones: (3 1 4 2)

(13)

P.S.R. como problemas de b´ usqueda: N-reinas

x

Problema gen´ erico:

(defvar *numero-de-reinas*) (defvar *estado-inicial*) (defvar *operadores*)

(defun reinas (n)

(setf *numero-de-reinas* n) (crea-estado-inicial)

(crea-operadores) (list ’reinas n))

(14)

P.S.R. como problemas de b´ usqueda: N-reinas

x

Estado inicial:

(defun crea-estado-inicial () (setf *estado-inicial*

()))

x

Estado final:

(defun es-estado-final (estado)

(= (length estado) *numero-de-reinas*))

(15)

P.S.R. como problemas de b´ usqueda: N-reinas

x

Operadores:

(defun crea-operadores () (setf *operadores*

(loop for i from 1 to *numero-de-reinas*

collect (list ’colocar-en i)))) (defun colocar-en (y estado)

(when (no-ataca y estado) (cons y estado)))

(16)

P.S.R. como problemas de b´ usqueda: N-reinas

x

Operadores:

(defun no-ataca (y e &optional (distancia 1)) (if (null e)

t

(and (/= y (first e))

(/= (abs (- y (first e))) distancia)

(no-ataca y (rest e) (+ distancia 1))))) (defun aplica (operador estado)

(funcall (symbol-function (first operador)) (second operador)

estado))

(17)

P.S.R. como problemas de b´ usqueda

x

Estado: Lista de variables con dominios unitarios o vac´ıos.

x

Estado inicial: Copia de variables con dominios vac´ıos.

(defun copia-variables-psr-vacias (variables) ; -> "psr-alg-comun.lsp"

(mapcar (lambda (x)

(crea-variable :nombre psr-var-nombre x) :dominio nil))

variables))

(defparameter *estado-inicial*

(copia-variables-psr-vacias *variables*))

x

Operadores: Tomar una variable con dominio vac´ıo, asignarle un valor

cualquiera de su dominio y comprobar las restricciones.

(18)

P.S.R. como problemas de b´ usqueda

x

Estado final: Lista de variables con dominios unitarios. Los operadores aseguran la verificaci´ on de las restricciones.

(defun dominio-unitario (variable) ; -> "psr-alg-comun.lsp"

(= (length (psr-var-dominio variable)) 1))

(defun dominios-unitarios (variables) ; -> "psr-alg-comun.lsp"

(loop for var in variables

always (dominio-unitario var))) (defun es-estado-final (estado)

(dominios-unitarios estado))

(19)

P.S.R. como problemas de b´ usqueda

x

Simplificaciones:

u Fijar un orden en la asignaci´on de valores a las variables.

u Los estados nunca se repiten.

u La lista de cerrados no es ´util.

u El camino que lleva a la soluci´on no interesa.

u La funci´on es-estado-final se puede substituir por dominios-unitarios.

x

Simplificaciones para b´ usqueda ciega:

u El nodo queda reducido al estado del problema.

u La funci´on sucesores se puede especializar.

u Prescindir de *estado-inicial* al asignar el valor a abiertos.

(20)

P.S.R. como problemas de b´ usqueda

x

Forma simplificada de los algoritmos de b´ usqueda ciega:

; (defun busqueda-en-... ()

; (let ((abiertos (list (copia-variables-psr-vacias *variables*)))

; (actual nil)

; (nuevos-sucesores nil))

; (loop until (null abiertos) do

; (setf actual (first abiertos))

; (setf abiertos (rest abiertos))

; (cond ((dominios-unitarios actual)

; (return actual))

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

; (setf abiertos .... ))))))

(21)

P.S.R. como problemas de b´ usqueda

x

Algoritmo de b´ usqueda en profundidad para P.S.R.:

(defun busqueda-en-profundidad-con-restricciones ()

(let ((abiertos (list (copia-variables-psr-vacias *variables*))) (actual nil)

(nuevos-sucesores nil)) (loop until (null abiertos) do

(setf actual (first abiertos)) (setf abiertos (rest abiertos)) (cond ((dominios-unitarios actual)

(return actual))

(t (setf nuevos-sucesores ( actual))

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

(22)

P.S.R. como problemas de b´ usqueda

x

Generaci´ on de sucesores: Asignar una nueva variable y eliminar suce- sores inconsistentes:

(defun bpr-sucesores (actual) ( ( actual)))

x

Selecci´ on de variables: La primera con dominio vac´ıo.

(V

₁

. . . V

_i

. . . V

_n

) =⇒ ((V

₁

. . . V

_i−1

) V

_i

(V

_i+1

. . . V

_n

))

(defun selecciona-variable (variables)

(let ((indice (position-if #’dominio-vacio variables))) (list (subseq variables 0 indice)

(nth indice variables)

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

(defun dominio-vacio (variable) ; -> "psr-alg-comun.lsp"

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

(23)

P.S.R. como problemas de b´ usqueda

x

Asignaci´ on de valores a la variable seleccionada:

(defun asigna-nueva-variable (estado) (let* ((seleccion ( estado))

(inicio (first seleccion))

(nombre (psr-var-nombre (second seleccion))) (final (third seleccion))

(dominio (dominio-nombre nombre *variables*))) (loop for val in dominio collect

(append (copia-lista-variables-psr inicio) (list (crea-variable :nombre nombre

:dominio (list val))) (copia-lista-variables-psr final)))))

x

Copiar una lista de variables:

(24)

P.S.R. como problemas de b´ usqueda

x

Dominio de una variable:

(defun variable-nombre (nombre variables) ; -> "psr-alg-comun.lsp"

(find-if (lambda (x) (equal nombre (psr-var-nombre x))) variables))

(defun dominio-nombre (nombre variables) ; -> "psr-alg-comun.lsp"

(psr-var-dominio (variable-nombre nombre variables)))

x

Eliminaci´ on de inconsistencias:

(defun elimina-inconsistentes (estados) (loop for estado in estados

when ( estado) collect estado))

(25)

P.S.R. como problemas de b´ usqueda

x

Verificaci´ on de restricciones (binarias):

(defun verifica-restricciones-posibles (estado) (loop for restriccion in *restricciones* always

(let* ((variables (psr-restr-variables restriccion)) (dom1 (dominio-nombre (first variables) estado)) (dom2 (dominio-nombre (second variables) estado))) (or (null dom1)

(null dom2)

(funcall (psr-restr-funcion restriccion) (first dom1)

(first dom2))))))

(26)

P .S.R. como problemas de b ´usqueda

x

Ejemplo de uso: N-reinas

>(load"psr-alg-comun.lsp") T >(load"psr-n-reinas.lsp") T >(load"psr-alg-busqueda.lsp") T >(n-reinas10) *RESTRICCIONES* >(time(busqueda-en-profundidad-con-restricciones)) Realtime:6.775447sec. Runtime:6.65sec. Space:10535724Bytes GC:20,GCtime:0.24sec. (#S(VARIABLE-PSR:NOMBRE1:DOMINIO(1)) #S(VARIABLE-PSR:NOMBRE2:DOMINIO(3)) #S(VARIABLE-PSR:NOMBRE3:DOMINIO(6)) #S(VARIABLE-PSR:NOMBRE4:DOMINIO(8)) #S(VARIABLE-PSR:NOMBRE5:DOMINIO(10)) #S(VARIABLE-PSR:NOMBRE6:DOMINIO(5)) #S(VARIABLE-PSR:NOMBRE7:DOMINIO(9)) #S(VARIABLE-PSR:NOMBRE8:DOMINIO(2)) #S(VARIABLE-PSR:NOMBRE9:DOMINIO(4)) #S(VARIABLE-PSR:NOMBRE10:DOMINIO(7)) ) IIA2002–2003CcI a

ProblemasdeSatisfacci´ondeRestricciones5.26

(27)

como problemas de b ´usqueda de uso: N-reinas

R R R R R R R

R

R R R R

R R R

R R CcI a

(28)

P.S.R. como problemas de b´ usqueda

x

Seguimiento de un ejemplo: N-reinas

Actual Sucesores Abiertos

((V1) (V2) (V3) (V4)) ((V1) (V2) (V3) (V4)) ((V1 1) (V2) (V3) (V4))

((V1 2) (V2) (V3) (V4)) ((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4))

((V1 1) (V2) (V3) (V4)) ((V1 1) (V2 3) (V3) (V4)) ((V1 2) (V2) (V3) (V4)) ((V1 1) (V2 4) (V3) (V4)) ((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4))

((V1 1) (V2 3) (V3) (V4)) ((V1 1) (V2 4) (V3) (V4))

((V1 2) (V2) (V3) (V4)) ((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4)) ((V1 1) (V2 4) (V3) (V4)) ((V1 1) (V2 4) (V3 2) (V4)) ((V1 2) (V2) (V3) (V4)) ((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4))

(29)

P.S.R. como problemas de b´ usqueda

x

Seguimiento de un ejemplo: N-reinas

Actual Sucesores Abiertos

((V1 1) (V2 4) (V3 2) (V4)) ((V1 2) (V2) (V3) (V4))

((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4)) ((V1 2) (V2) (V3) (V4)) ((V1 2) (V2 4) (V3) (V4)) ((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4)) ((V1 2) (V2 4) (V3) (V4)) ((V1 2) (V2 4) (V3 1) (V4)) ((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4)) ((V1 2) (V2 4) (V3 1) (V4)) ((V1 2) (V2 4) (V3 1) (V4 3)) ((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4)) ((V1 2) (V2 4) (V3 1) (V4 3)) SOLUCION ((V1 3) (V2) (V3) (V4)) ((V1 4) (V2) (V3) (V4))

(30)

Consistencia de arcos

x

Arco = Restricci´ on + 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))))

(31)

Consistencia de arcos

x

Planificaci´ on de las acciones de un robot (Poole, pag. 149): Un robot necesita planificar cinco actividades (A, B, C, D y E), donde cada ac- tividad ha de comenzar en un momento en el tiempo (1, 2, 3, o 4) y dura exactamente una ´ unidad de tiempo. Restricciones:

u La actividad B no puede realizarse en el momento n´umero 3.

u La actividad C no puede realizarse en el momento n´umero 2.

u Las actividades A y B no pueden realizarse simult´aneamente.

u Las actividades B y C no pueden realizarse simult´aneamente.

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

u Las actividades B y D no pueden realizarse simult´aneamente.

Las actividades A y D han de realizarse simult´aneamente.

(32)

Consistencia de arcos

x

Desarrollo gr´ afico de AC-3:

B 1 4 2 1 2

3 4 A

C 1 3 4 1 2

3 4 D

1 2 3 4 E

A = B

B = D

E < D E < C

B = C A = D

E < B E < A

C < D

(33)

Consistencia de arcos

x

Seguimiento del ejemplo:

Variables Arcos

(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

(34)

Consistencia de arcos

x

Seguimiento del ejemplo:

Variables Arcos

(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)

(35)

Algoritmo de consistencia de arcos AC-3

x

Descripci´ on del algoritmo:

0 El algoritmo recibe como entrada una lista de VARIABLES (nombres + dominios) 1 Crear las siguientes variables locales

1.1 RED (para almacenar el conjunto de arcos cuya consistencia no ha sido comprobada) cuyo valor inicial es la lista formada por todos los arcos (se obtiene con la funci´on ARCOS).

1.2 ACTUAL (para almacenar el arco cuya consistencia se esta comprobando) cuyo valor inicial es nil.

2 Mientras RED no sea la lista vac´ıa (por tanto quedan arcos cuya consistencia queda por comprobar),

2.1 Hacer ACTUAL el primer arco de RED 2.2 Hacer RED el resto de RED

(36)

Algoritmo de consistencia de arcos AC-3

x

Descripci´ on del algoritmo (cont.):

2.3 Crear las siguientes variables

2.3.1 VARIABLE-MOD cuyo valor es el de la variable asociada al arco ACTUAL, dentro de la lista de VARIABLES

2.3.2 VIEJO-DOMINIO cuyo valor es el dominio en el conjunto de VARIABLES de la VARIABLE-MOD

2.3.3 NUEVO-DOMINIO cuyo valor es el dominio modificado de la VARIABLE-MOD, que hace dicho arco consistente

2.4 Cuando VIEJO-DOMINIO y NUEVO-DOMINIO no sean iguales,

2.4.1 Se modifica el dominio de la VARIABLE-MOD y se hace igual a NUEVO-DOMINIO

2.4.2 Se a~naden a la RED todos los nuevos arcos asociados a restricciones en las que intervenga la VARIABLE-MOD y ´esta no sea la variable

asociada.

3 Devolver la lista de VARIABLES con respecto a la cual todos los arcos son consistentes.

(37)

Algoritmo de consistencia de arcos AC-3

x

Algoritmo AC-3:

(defun ac3 (variables) ; 0

(let ((red (arcos)) ; 1.1

(actual nil)) ; 1.2

(loop until (null red) do ; 2

(setf actual (first red)) ; 2.1

(setf red (rest red)) ; 2.2

(let* ((variable-mod

(variable-nombre (arco-variable actual) variables)) ; 2.3.1 (restriccion (arco-restriccion actual))

(viejo-dominio (psr-var-dominio variable-mod)) ; 2.3.2 (nuevo-dominio

( variable-mod variables restriccion))) ; 2.3.3

(when (not (equal nuevo-dominio viejo-dominio)) ; 2.4 (setf (psr-var-dominio variable-mod) nuevo-dominio) ; 2.4.1

(38)

Algoritmo de consistencia de arcos AC-3

x

Obtenci´ on 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)))

(39)

Algoritmo de consistencia de arcos AC-3

x

Actualizaci´ on 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 ( val1

(variable-nombre nombre2 variables) funcion)

collect val1))

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

(variable-nombre nombre1 variables) funcion)

(40)

Algoritmo de consistencia de arcos AC-3

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

(41)

B´ usqueda de soluciones mediante consistencia de arcos

x

Resultado tras aplicar AC-3:

u Existe un dominio vac´ıo: No hay soluci´on.

u Todos los dominios son unitarios: Hay una soluci´on.

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

x

Romper un dominio no vac´ıo en subdominios y aplicar AC-3 a los esta-

dos resultantes.

(42)

B´ usqueda de soluciones mediante consistencia de arcos

x

Descripci´ on del algoritmo:

1 Crear las siguientes variables locales

1.1 ABIERTOS (para almacenar los estados cuya consistencia no ha sido

establecida), cuyo valor inicial es una copia del par´ametro *variables*;

1.2 ACTUAL (para almacenar el estado que se est´a analizando), cuyo valor inicial es vac´ıo.

2 Mientras que ABIERTOS no est´e vac´ıa,

2.1 Hacer ACTUAL el resultado de establecer la consistencia de arcos del primer elemento de ABIERTOS,

2.2 Hacer ABIERTOS el resto de ABIERTOS.

2.3 Si en el estado ACTUAL hay alg´un dominio vac´ıo 2.3.1 devolver NIL, no hay soluci´on.

2.4 Si en el estado ACTUAL todos los dominios son unitarios 2.4.1 devolver ACTUAL, es una soluci´on.

2.5 En otro casocalcular los sucesores del estado ACTUAL y a~nadirlos a la lista de ABIERTOS.

(43)

B´ usqueda de soluciones mediante consistencia de arcos

x

B´ usqueda por consistencia de arcos:

(defun consistencia-de-arcos ()

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

(actual nil)) ; 1.2

(loop until (null abiertos) do ; 2

(setf actual ( (first abiertos))) ; 2.1

(setf abiertos (rest abiertos)) ; 2.2

(cond ((hay-dominio-vacio actual) ; 2.3

nil) ; 2.3.1

((dominios-unitarios actual) ; 2.4

(return actual)) ; 2.4.1

(t (setf abiertos

(append ( actual) abiertos))))))) ; 2.5

(44)

B´ usqueda de soluciones mediante consistencia de arcos

x

Comprobaci´ on de dominios vac´ıos:

(defun hay-dominio-vacio (variables) ; -> "psr-alg-comun.lsp"

(loop for var in variables

thereis (dominio-vacio var)))

x

Generaci´ on de sucesores:

(defun cda-sucesores (estado) (let* ((seleccion ( estado))

(inicio (first seleccion)) (variable (second seleccion)) (final (third seleccion))

(nuevos-dominios ( variable))) (loop for var in nuevos-dominios

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

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

(45)

B´ usqueda de soluciones mediante consistencia de arcos

x

Seleccionar una variable con dominio no unitario:

(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:

(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)))))

(46)

Consistencia de arcos

x

Ejemplo de uso: N-reinas

>(load"psr-alg-comun.lsp") T >(load"psr-n-reinas.lsp") T >(load"psr-alg-arcos.lsp") T >(n-reinas10) *RESTRICCIONES* >(time(consistencia-de-arcos)) Realtime:7.330538sec. Runtime:7.06sec. Space:5204128Bytes GC:10,GCtime:0.17sec. (#S(VARIABLE-PSR:NOMBRE1:DOMINIO(1)) #S(VARIABLE-PSR:NOMBRE2:DOMINIO(3)) #S(VARIABLE-PSR:NOMBRE3:DOMINIO(6)) #S(VARIABLE-PSR:NOMBRE4:DOMINIO(8)) #S(VARIABLE-PSR:NOMBRE5:DOMINIO(10)) #S(VARIABLE-PSR:NOMBRE6:DOMINIO(5)) #S(VARIABLE-PSR:NOMBRE7:DOMINIO(9)) #S(VARIABLE-PSR:NOMBRE8:DOMINIO(2)) #S(VARIABLE-PSR:NOMBRE9:DOMINIO(4)) #S(VARIABLE-PSR:NOMBRE10:DOMINIO(7)) ) IIA2002–2003CcI a

(47)

de reparaci´ on heur ´ıstica Lista de v ariables con dominios unitar- Se escoge un v alor cualquiera v ariable. T omar un v ariable del estado y un n uev o v alor den tro de su dominio. Estado que v erifica to das las re- T oma los v alores m ´ınimos en los es- v erifican to das las restricciones.

dem´ınimosconflictos:N´umeroderestric- NOverificaelestado.

ximaciones:

enescalada. tosimulado. desatisfacci´onGSAT. gen´eticos. CcI a

(48)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Operadores: Seleccionar la variable que m´ as restricciones incumple, dis- tinta de la ´ ultima modificada, y asignarle un nuevo valor dentro de su dominio.

x

Para evitar bucles infinitos, se predetermina el n´ umero de iteraciones posibles.

x

Nodo gsat:

(defstruct (nodo-gsat (:constructor crea-nodo-gsat) (:conc-name gsat-))

estado

ultima-modificada)

(49)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Descripci´ on del algoritmo:

0 El algoritmo recibe un parámetro clave que indica el número máximo de ITERACIONES que se pueden realizar.

1 Crear la siguiente variable local

1.1 ACTUAL (para almacenar el nodo-gsat que se esta considerando), cuyo valor inicial viene dado por la funci´on CREA-NODO-INICIAL.

2 Para todos los valores de I desde 0 hasta ITERACIONES hacer 2.1 si el numero de conflictos del nodo ACTUAL es 0,

2.1.1 devolver el estado del nodo ACTUAL y el n´umero de pasos dado (I).

2.1.2 en otro caso seleccionar un nodo de los sucesores de NODO-GSAT con menor n´umero de conflictos y ponerlo como ACTUAL.

(50)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Funci´ on principal GSAT:

(defun reparacion-heuristica-gsat (&key (iteraciones 100)) ; 0

(let ((actual ())) ; 1.1

(loop for i from 1 to iteraciones do ; 2

(if (= ( (gsat-estado actual)) 0) ; 2.1

(return (list i (gsat-estado actual))) ; 2.1.1

(setf actual

( ( actual))))))) ; 2.1.2

x

Construcci´ on del nodo inicial:

(defun crea-nodo-inicial () (

:estado (loop for var in *variables* collect

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

:dominio (list (first (psr-var-dominio var))))) :ultima-modificada nil))

(51)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

N´ umero de conflictos de un estado:

(defun numero-conflictos (estado)

(loop for restriccion in *restricciones*

count (not ( restriccion estado))))

x

Comprobaci´ on de restricciones (binarias):

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

(val1 (first (dominio-nombre (first nombres) variables))) (var2 (first (dominio-nombre (second nombres) variables)))) (funcall (psr-restr-funcion restriccion) val1 val2)))

(52)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Generaci´ on de sucesores de un nodo gsat:

(defun rhc-sucesores (nodo-gsat) (let* ((seleccion ( nodo-gsat))

(inicio (first seleccion)) (variable (second seleccion)) (final (third seleccion))

(nombre (psr-var-nombre variable))

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

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

(loop for n-val in dominio when (not (equal n-val valor)) collect (

:estado (append (copia-lista-variables-psr inicio) (list (crea-variable :nombre nombre

:dominio (list n-val))) (copia-lista-variables-psr final))

:ultima-modificada nombre))))

(53)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Selecci´ on aleatoria de una variable conflictiva:

(defun selecciona-conflictiva (nodo-gsat) (let* ((variables (gsat-estado nodo-gsat))

(ultima-mod (gsat-ultima-modificada nodo-gsat)) (indice ( variables ultima-mod)))

(list (subseq variables 0 indice) (nth indice variables)

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

(54)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Selecci´ on aleatoria de una variable conflictiva:

0 Entrada: Una lista de VARIABLES y la ULTIMA variable modificada.

1 Crear las siguientes variables locales:

1.1 LISTA-MAXIMOS (lista con los ´ındices de los mejores nodos encontrados hasta el momento), inicialmente es la lista vac´ıa.

1.2 MAXIMO, el n´umero de conflictos del estado cuyo ´ındice est´a en la LISTA-MINIMOS, inicialmente es 0.

2 Para todo ´ındice I desde 0 hasta la longitud de VARIABLES menos 1,

2.1 cuando el elemento I-´esimo de VARIABLES no es la variable cuyo nombre se indica en ULTIMA-MOD

2.2 Calcular el n´umero de conflictos de la variable correspondiente con

respecto a la lista de VARIABLES y almacenarlo localmente en NUEVO-VALOR 2.3 Si el NUEVO-VALOR es mayor que el MAXIMO hacer

2.3.1 MAXIMO el NUEVO-VALOR

2.3.2 LISTA-MAXIMOS la lista formada por el ´ındice I 2.4 Si el NUEVO-VALOR es igual que el MAXIMO

2.4.1 incluir el ´ındice I en la LISTA-MAXIMOS

3 Seleccionar aleatoriamente un ´ındice de LISTA-MAXIMOS y devolverlo.

(55)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Selecci´ on aleatoria de una variable conflictiva:

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

(let ((maximo 0) ; 1.1

(lista-maximos nil)) ; 1.2

(loop for i from 0 to (- (length variables) 1) when ; 2 (not (equal (psr-var-nombre (nth i variables)) ultima)) ; 2.1 do (let ((nuevo-valor

( variables

(nth i variables)))) ; 2.2

(cond ((> nuevo-valor maximo) ; 2.3

(setf maximo nuevo-valor ; 2.3.1

lista-maximos (list i))) ; 2.3.2

((= nuevo-valor maximo) ; 2.4

(push i lista-maximos))))) ; 2.4.1

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

(56)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

N´ umero de restricciones incumplidas por una variable:

(defun numero-conflictos-variable (variables var) (loop for restriccion in *restricciones*

when (member (psr-var-nombre var)

(psr-restr-variables restriccion) :test #’equal)

count (not ( restriccion variables))))

(57)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Selecci´ on del nodo menos conflictivo:

0 El algoritmo recibe como entrada una LISTA-NODOS-GSAT 1 Crear las siguientes variables locales:

1.1 NODO-MINIMO (el mejor nodo encontrada hasta el momento), su valor inicial es el primer elemento de la LISTA-NODOS-GSAT;

1.2 RESTO (la lista de nodos gsat que queda por analizar), su valor inicial es el resto de la LISTA-NODOS-GSAT;

1.3 VAL-MINIMO, el n´umero de conflictos del estado del NODO-MINIMO.

2 Para todo elemento NODO la lista RESTO hacer

2.1 Calcular el n´umero de conflictos del estado del NODO y almacenarlo localmente en NUEVO-VAL,

2.2 Si el NUEVO-VAL es menor que el VAL-MINIMO hacer 2.2.1 NUEVO-VAL el VAL-MINIMO

2.2.2 NODO-MINIMO el NODO 3 Devolver el NODO-MINIMO

(58)

Algoritmos de reparaci´ on heur´ıstica: GSAT

x

Selecci´ on del nodo menos conflictivo:

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

(let* ((nodo-minimo (first lista-nodos-gsat)) ; 1.1

(resto (rest lista-nodos-gsat)) ; 1.2

(val-minimo ( (gsat-estado nodo-minimo)))) ; 1.3

(loop for nodo in resto do ; 2

(let ((nuevo-val ( (gsat-estado nodo)))) ; 2.1

(when (< nuevo-val val-minimo) ; 2.2

(setf val-minimo nuevo-val) ; 2.2.1

(setf nodo-minimo nodo)))) ; 2.2.2

nodo-minimo)) ; 3

(59)

on heur ´ıstica: GSA T de uso: N-reinas

10) :iteraciones20)) 2.155908sec. 2.15sec. Bytes time:0.07sec. :NOMBRE1:DOMINIO(6)) :NOMBRE2:DOMINIO(8)) :NOMBRE3:DOMINIO(1)) :NOMBRE4:DOMINIO(4)) :NOMBRE5:DOMINIO(7)) :NOMBRE6:DOMINIO(10)) :NOMBRE7:DOMINIO(2)) :NOMBRE8:DOMINIO(9)) :NOMBRE9:DOMINIO(5)) :NOMBRE10:DOMINIO(3)) CcI a

(60)

Reparaci´ on heur´ıstica: GSAT

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

(61)

Comparaci´ on de los tres algoritmos:

x

Ejemplo: N-reinas

b´usqueda arcos gsat (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

(62)

Bibliograf´ıa

x

Poole, D.; Mackworth, A. y Goebel, R. Computational Intelligence (A Logical 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, 1995).

u Cap. 3.7: “Constraint Satisfaction Search”.

x

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

Hill, 2000)

u Cap. 11 “M´etodos alternativos de b´usqueda y otras aplicaciones”.