Algoritmos Evolutivos Sistemas de “Word Equations” - Aic.uniovi.es ...

UNIVERSIDAD DE OVIEDO
Facultad de Ciencias
Licenciatura en Matemáticas
Algoritmos Evolutivos
para la Resolución de
Sistemas de “Word Equations”
Fátima Drubi Vega
Trabajo Académico
Oviedo, julio de 2003

Índice general
1. Introducción 4
2. Los Algoritmos Genéticos 6
2.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2. Conceptos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3. Características de los Algoritmos Genéticos . . . . . . . . . . . . . . . . . . 9
2.4. El Algoritmo Genético Simple . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4.1. Codificación de los Individuos . . . . . . . . . . . . . . . . . . . . . . 11
2.4.2. Generación de la Población Inicial . . . . . . . . . . . . . . . . . . . 14
2.4.3. Evaluación de los Individuos . . . . . . . . . . . . . . . . . . . . . . 14
2.4.4. Selección . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.5. Cruce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.6. Mutación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5. Seudocódigo de un Algoritmo Genético Simple . . . . . . . . . . . . . . . . 22
2.6. El Teorema de los Esquemas . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.7. Otros Algoritmos Genéticos: los Algoritmos Evolutivos . . . . . . . . . . . . 34
3. El Problema de Satisfactibilidad 36
3.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2. Conceptos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3. Los Algoritmos Evolutivos para Resolver SAT . . . . . . . . . . . . . . . . . 39
4. Sistemas de “Word Equations”: el Algoritmo de Makanin 48
4.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.2. Conceptos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1

4.3. El Algoritmo de Makanin . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.3.1. Representación Gráfica . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.3.2. Las Ecuaciones Generalizadas . . . . . . . . . . . . . . . . . . . . . . 55
4.3.3. EL Algoritmo de Transformación . . . . . . . . . . . . . . . . . . . . 60
4.4. Casos Particulares de Sistemas de “Word Equations” . . . . . . . . . . . . . 66
5. Un Algoritmo Genético Simple para Resolver l SW ES 71
5.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.2. Codificación de los Individuos . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.3. Generación de la Población Inicial . . . . . . . . . . . . . . . . . . . . . . . 74
5.4. Evaluación de los Individuos . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.5. Los Operadores Genéticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6. El Algoritmo Genero Problema 88
7. Primeros Resultados Experimentales 91
7.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.2. Tamaño de Población . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
7.3. Probabilidad de mutación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
8. Algoritmos Evolutivos para Resolver l SW ES 107
8.1. A.E. Sólo Mutación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
8.2. A.E. Búsqueda Local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
8.3. Resultados experimentales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
9. Experimento final 125
A. El Algoritmo Genético Simple 128
B. El Algoritmo Genero Problema 145
C. Los problemas propuestos 157
C.1. El problema 10-15-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
C.2. El problema 10-15-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
C.3. El problema 10-3-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
C.4. El problema 10-5-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
2

C.5. El problema 10-5-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
C.6. El problema 10-8-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
C.7. El problema 10-8-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
C.8. El problema 12-6-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
C.9. El problema 15-12-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
C.10.El problema 15-25-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
C.11.El problema 15-7-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
C.12.El problema 25-23-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
C.13.El problema 25-8-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
C.14.El problema 25-8-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
C.15.El problema 5-15-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
C.16.El problema 5-3-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
D. A.E. Sólo Mutación 168
E. A.E. Búsqueda Local 179
Bibliografía 204
3

Capítulo 1
Introducción
En este trabajo hemos intentado reunir los resultados obtenidos a lo largo del curso
que comenzamos con el objetivo de diseñar un algoritmo que proporcione una solución a
un sistema de ecuaciones conocido como sistema de “word equations”.
El capítulo 2 lo dedicamos al estudio del tipo de algoritmos que pretendemos usar
para resolver estos sitemas, los llamados algoritmos evolutivos. Podríamos decir que en
este capítulo se encuentran las herramientas básicas necesarias para su diseño. Además,
como aplicación de los mismos a la resolución de diferentes problemas, estudiamos en el
capítulo 3 los llamados problemas SAT y explicamos el funcionamiento de los algoritmos
evolutivos más conocidos para su resolución. Algunos de estos algoritmos nos servirán de
referencia a la hora de diseñar el nuestro pues, como veremos, los problemas SAT se
reducen a sistemas de “word equations”.
En el capítulo 4 introducimos el problema que pretendemos resolver: los sistemas de
“word equations”, e intentamos resumir la teoría que ya ha sido desarrollada sobre estos
sistemas, destacando las dificultades que aparecen en su resolución, pues aunque existe
un algoritmo que los resuelve, el algoritmo de Makanin, éste no se puede usar en la
práctica por ser un algoritmo con una complejidad triplemente exponencial.
En los siguientes capítulos explicamos las distintas propuestas que emplearemos para
el diseño del algoritmo evolutivo.
Nuestro trabajo propiamente dicho comienza en el capítulo 5 diseñando un algoritmo
evolutivo denominado algoritmo genético simple, cuyos primeros resultados experi-
mentales aparecen en el capitulo 7. En el capítulo 6, hacemos un pequeño paréntesis
para diseñar un algoritmo que construya sistemas de “word equations”, pues no existen
4

documentos donde podamos encontrar estos problemas.
En el capítulo 8, obtenemos nuevos algoritmos evolutivos añadiendo algunas modifi-
caciones al algoritmo genético simple. Los resultados experimentales nos permitirán com-
probar las mejoras obtenidas al añadir búsqueda local al algoritmo genético simple.
Finalizamos exponiendo los resultados obtenidos del mejor de los algoritmos evolutivos
que hemos diseñado a lo largo de este curso.
Todos los algoritmos diseñados se encuentran en los distintos apéndices, escritos en el
lenguaje C++. También aparecen algunos de los sistemas de “word equations” que hemos
utlizado en los diferentes experimentos.
5

Capítulo 2
Los Algoritmos Genéticos
2.1. Introducción
Un algoritmo genético es un proceso de búsqueda basado en los mecanismos de la
evolución biológica: selección natural, reproducción y mutación.
Fueron desarollados por John Holland [12] , que desde pequeño se preguntaba cómo
la naturaleza logra crear seres cada vez más perfectos. Aunque esto no es totalmente
cierto, resulta curioso observar que todo tiene lugar mediante interacciones locales entre
individuos.
De la lectura del libro titulado “La teoría genética de la selección natural” aprendió que
la evolución era una forma de adaptación más potente que el simple aprendizaje.
Los objetivos de su búsqueda han sido dos:
Abstraer y explicar rigurosamente los procesos de adaptación de los sistemas natu-
rales.
Diseñar sistemas artificiales que conserven los mecanismos de los sistemas naturales.
Su primer monográfico sobre los algoritmos genéticos se publicó en 1975, “Adaptation in
Natural and Artificial Systems”. Algunos artículos y tesis posteriores establecen la validez
de la técnica en la optimización de funciones y aplicaciones de control.
Los algoritmos genéticos son computacionalmente simples, aunque potentes en su
búsqueda y mejora, y han sido aceptados como una aproximación válida a problemas
que requieren búsqueda eficiente y eficaz. Además, no están limitados por supuestas res-
tricciones sobre el espacio de búsqueda, como la continuidad o la existencia de derivadas.
6

2.2. Conceptos Básicos
Definición 1
Se llama alfabeto a un conjunto finito de símbolos dados.
Se denotará por A.
Ejemplo 1
Los siguientes conjuntos pueden ser alfabetos
1. { 1, 3, 5, 7, 9}
2. { a, b, c,. . . , x, y, z}
3. {α, β, γ}
4. {si, no, inicio, fin}
5. { 0, 1}
Definición 2
Una cadena o palabra es una sucesión ordenada y finita de símbolos de un alfabeto.
Se denotará por ω.
Definición 3
El número de símbolos que constituyen una cadena ω se llama longitud de ω.
Se denotará por |ω|.
Ejemplo 2
ω = 10011 es una cadena de longitud |ω| = 5 del alfabeto binario A = { 0, 1}.
Definición 4
Se dice cadena vacia a la cadena que no contiene símbolos y por lo tanto tiene longitud
cero.
Se denotará por Λ.
Definición 5
El exponente de periodicidad de una cadena ω es el máximo número p tal que
donde u, v y z son cadenas con v = Λ.
ω = uv p z
7

Definición 6
Dado un alfabeto A.
Se define el conjunto de todas las cadenas que se pueden formar con símbolos de A como
A ∗ = {Λ} ∪ A ∪ A 2 ∪ . . . ∪ A n ∪ . . . =
A k
siendo A k el conjunto de cadenas de longitud k.
Definición 7
Sea A un alfabeto.
Dadas dos cadenas ω1 y ω2 sobre A se define la concatenación de ω1 y ω2 como la cadena
que resulta de colocar primero ω1 y a continuación ω2.
Se denotará ω1ω2.
Propiedades de la concatenación:
Asociativa,
( ω1 ω2 ) ω3 = ω1 ( ω2 ω3 ) ∀ ω1, ω2, ω3 ∈ A.
Existencia de elemento neutro,
Λ ω = ω Λ ∀ ω ∈ A.
|ω1ω2| = |ω1| + |ω2|
En general, no es conmutativa.
Ejemplo 3
Si ω1 = ab y ω2 = b entonces
Nota 1
ω1ω2 = abb = bab = ω2ω1
El alfabeto A con la operación de concatenación tiene estructura de semigrupo con iden-
tidad.
Nota 2
Será frecuente usar el término “bit” para referirnos a los símbolos de un alfabeto, en
particular, cuando trabajemos con el alfabeto binario A = { 0, 1}.
8
k≥0

2.3. Características de los Algoritmos Genéticos
Algunas de las principales características de los algoritmos genéticos, que los diferencia
de otros procesos de optimización, son las siguientes:
Uso directo de un código.
Trabajan con una codificación del conjunto de variables del problema, no con las
propias variables.
En general, se codifican como cadenas de algún alfabeto.
Búsqueda de una población.
Buscan un conjunto de puntos, no un único punto.
Mientras que algunos métodos de optimización se mueven en el espacio de decisión
desde un único punto al siguiente usando reglas de transición, los algoritmos genéticos
trabajan simultaneamente con un conjunto de puntos, reduciéndose al máximo la
probabilidad de encontrar un falso óptimo.
Ceguedad sobre información auxiliar.
Usan la información de la función objetivo del problema de optimización, no sus
derivadas u otros conocimientos auxiliares.
Aleatoriedad controlada.
Utilizan reglas de transmisión probabilísticas, nunca reglas determinísticas.
Es importante no confundir los métodos de búsqueda estrictamente aleatorios con las
técnicas aleatorias. El algoritmo genético es un ejemplo de un proceso de búsqueda
que utiliza selección aleatoria como una herramienta para guiar una búsqueda muy
explosiva mediante una codificación sencilla de un espacio paramétrico. No estamos
hablando de un simple proceso aleatorio, es decir, no se trata de tomar una decisión a
cara o cruz, sino que definimos un método de búsqueda que aprovecha la información
histórica para especular sobre nuevos puntos.
Estas cuatro características contribuyen a dar fuerza a los algoritmos genéticos y re-
sultan de gran utilidad, por encima incluso de otras técnicas usadas con más frecuencia.
9

Además, la habilidad del algoritmo genético para explotar la información acumula-
da sobre un espacio de búsqueda permite su aplicación a espacios de búsqueda grandes,
complejos y poco entendidos.
Por lo tanto, los algoritmos genéticos tratan de alcanzar un equilibrio entre dos ob-
jetivos aparentemente en conflicto: explotar las buenas cualidades de las candidatas a
solución y explorar el espacio de búsqueda.
La simplicidad de las operaciones y la gran eficacia del proceso son dos de los principales
atractivos de los algoritmos genéticos. Veremos que la explicación de por qué este proceso
funciona es mucho más sutil.
2.4. El Algoritmo Genético Simple
Antes de examinar el funcionamiento interno de un algoritmo genético simple y estudiar
su potencia, tenemos que tener claros cuáles son nuestros objetivos cuando decimos que
queremos optimizar una función o un proceso. Es evidente que el objetivo más importante
de la optimización es la mejora.
Definición 8
Se llama individuo a cualquier cadena candidata a ser solución del problema que se pre-
tende resolver mediante un algoritmo genético.
Un conjunto finito de individuos se dice población.
Definición 9
Se llama función fitness, de calidad, o de aptitud... a aquella función que determina los
individuos mejor adaptados o, de alguna manera, más cercanos a la solución del problema.
Para seleccionar una función fitness adecuada hay que hacer un balance entre aquellas que
reflejen diferencias muy grandes (provocando una convergencia prematura de los indivi-
duos de la población hacia un óptimo local) y las que proporcionen diferencias pequeñas
(dando lugar a un estacionamiento).
En ocasiones se añade un factor de penalización para controlar los individuos que no
responden a las características de las soluciones del problema.
El algoritmo genético simple está constituido principalmente por tres etapas bien dife-
renciadas: selección, cruce y mutación. Sin embargo, en la práctica es necesario especificar
para su diseño los siguientes aspectos:
10

la codificación de las variables del problema que constituirán los individuos
el modo de generar la población inicial
la función fitness que evaluará la población
el criterio de selección
el tipo de cruce
y la forma en que se aplicará el proceso de mutación.
2.4.1. Codificación de los Individuos
Los operadores genéticos (selección, cruce y mutación) dependen del tipo de repre-
sentación utilizado. Originalmente, las soluciones se representaban por cadenas binarias,
es decir, listas de ceros y unos. Este tipo de representación permite definir fácilmente el
proceso de cruce. Sin embargo, en algunos problemas resulta poco natural y eficiente. Por
este motivo, es importante estudiar el problema que se pretende resolver para determinar
la representación más adecuada de los individuos y, en consecuencia, de la solución que se
busca.
Ejemplo 4
Consideramos el problema del viajante dado por 5 ciudades y 20 aristas.
Hay que calcular un camino cerrado que pase por todas las ciudades, sólo una vez por
cada ciudad, y tal que la distancia recorrida sea mínima.
Sean C1, C2, C3, C4 y C5 las ciudades que hay que recorrer.
Suponemos que el viajante parte siempre de la ciudad C1.
Tenemos que codificar cinco variables, una por cada una de las ciudades del problema.
Proponemos codificarlas como cadenas de longitud 4 del alfabeto A = { 0, 1} pues a cada
ciudad llegan y salen cuatro aristas. De esta forma, representamos para cada ciudad las
aristas que salen de esta y le asignamos el valor uno a aquella que forma parte del camino
elegido. Así, la cadena
0010 1000 0100 0010 1000
representa una candidata a solución sobre las aristas ordenadas.
C1
C2
C3
11
C4
C5

C1
0
0
C2
0 ✶
1
C5
C3
C4
C3
0
0
C4
1 ✶
0
C2
Sin embargo, no resulta una representación natural y, además, no todos los individuos que
tienen cinco unos representan una solución del problema.
La cadena
C5
C1
11101100000000000000
ni siquiera representa un camino en el grafo de bits correspondiente, pues cada subcadena
representando a una ciudad debe contener un uno y tres ceros. Así mismo, la cadena
01001000001000101000
aunque si representa un camino no permite recorrer todas las ciudades y no puede ser
aceptada como solución candidata del problema.
C1 ✮
❪
C2
▼
✇
✶ C3
C5
C4
Observamos que las posibles soluciones son de la forma
C1 ✐
C2
✼
✌
C5
✇
C3
C4
✕
✴
C1
C2
✌
C5
▼
✶
12
C5
1
0
0
0
. . .
Con esta representación de las
variables nos vemos obligados a
controlar las cadenas generadas
para garantizar que se visitan
todas las ciudades una sóla vez
cada una. Después, comprobamos
cuál es la que hace mínima la
distancia recorrida.
C3
C4
✕
C1
❪
C2
❦
❄
C5
C3
✻
C4

Por lo tanto, resulta más natural representar la ruta de las ciudades por una permutación,
digamos
(5, 4, 2, 3)
sobre el alfabeto A ′ = {2, 3, 4, 5} que permite definir diferentes poblaciones estables, es
decir, todos los individuos así generados representan posibles soluciones.
La permutación (5, 4, 2, 3) se interprata de la siguiente forma: partiendo de la ciudad C1
el viajante se desplaza hasta la ciudad C5, de ahí se mueve a C4, después sigue hacia C3
pasando primero por la ciudad C2 y finalmente vuelve a C1.
1
✾
2
❪
⑦
5
⑦
3
4
✸
Con esta representación sólo
tenemos que preocuparnos de
encontrar la permutación que
haga mínima la distancia necesaria
para recorrer todas las ciudades.
Además, el problema del viajante en su enunciado general no exige que el camino comience
en una ciudad concreta sino que se enuncia en los siguientes términos:
“Construir, si existe, un camino de coste mínimo que
pase por cada una de las cinco ciudades una sóla vez”
Con este enunciado y suponiendo, como hasta ahora, que todas las ciudades estan comu-
nicadas entre sí en ambos sentidos, la mejor representación de los individuos está formada
por permutaciones de cinco elementos, pues la representación binaria necesitaría además
indicar cuál es la ciudad inicial del camino para cada individuo.
Aunque existen múltiples tipos de representación, la mayoría de los resultados en la
teoría de los algoritmos genéticos, como el teorema de los esquemas que estudiaremos
posteriormente, han sido desarrollados sobre el alfabeto binario.
Nota 3
Una codificación correcta es una de las claves más importantes para tener exito en la
resolución de los problemas.
13

2.4.2. Generación de la Población Inicial
Una vez definida la codificación de los individuos, el primer paso en un algoritmo
genético es la creación de una población inicial de soluciones del problema, debidamente
codificada.
Normalmente, se fija el tamaño de la población y se generan de forma aleatoria los
individuos para conseguir una población inicial amplia y representativa del espacio de
búsqueda.
En los últimos tiempos, se han ido incorporando métodos heurísticos a este proceso con
el fin de generar individuos en la población inicial con un buen fitness. En este caso, hay
que garantizar la diversidad estructural de estos individuos para tener una representación
de la mayor parte de la población posible o, al menos, evitar la convergencia puntual.
También existen algoritmos donde el tamaño de la población es variable.
2.4.3. Evaluación de los Individuos
Cada vez que se genera una población de individuos es necesario evaluarlos para obtener
una medida de calidad, es decir, el fitness asociado a cada individuo. Este valor es utilizado
en el proceso de selección para la obtención de las sucesivas generaciones.
Como ya se mencionó, la elección del fitness que guiará el proceso de búsqueda será una
de las claves para garantizar el buen funcionamiento del algoritmo genético.
Ejemplo 5
En el problema del viajante anterior, en su versión general, generamos de forma aleatoria
una población de tamaño tp = 3.
Como se trata de un problema de minimización podemos tomar como función fitness f la
función que nos proporciona la distacia recorrida. De este modo, un individuo será mejor
que otro si la función fitness asociada tiene un valor más pequeño.
Definimos dij la distancia entre las ciudades Ci y Cj para i, j = 1, 2, 3, 4, 5 con i = j.
Suponemos que
d12 = 12 Km d13 = 40 Km d14 = 31 Km d15 = 65 Km d23 = 26 Km
d24 = 13 Km d25 = 78 Km d34 = 43 Km d35 = 37 Km d45 = 52 Km
Se tiene la siguiente tabla
14

Individuo fitness
I1 = (1, 4, 2, 3, 5) 172
I2 = (2, 3, 5, 4, 1) 158
I3 = (3, 1, 4, 2, 5) 199
Luego, la ruta que proporciona el individuo I2 es la mejor de las tres rutas de la población.
2.4.4. Selección
La selección es un operador genético mediante el cual cada individuo es copiado de
acuerdo a los valores que le asocia la función fitness. Se trata de una versión artificial de
la selección natural, donde el ser mejor adaptado tiene mayor probabilidad de sobrevivir.
Pensemos en la función fitness como una medida de ganancia, utilidad o bondad que
queremos maximizar. Los individuos que tienen asociado un valor más alto de la función
fitness tienen una mayor probabilidad de contribuir en uno o más descendientes en la
siguiente generación.
La implementación en forma algorítmica del proceso de selección se realiza mediante
una ruleta, donde a cada individuo de la población le corresponde una sección circular
directamente proporcional a la probabilidad que tiene de contribuir en la siguiente gene-
ración. De esta forma, cada vez que se tiene que seleccionar un individuo se realiza una
tirada de bola en la ruleta tomando aquel asociado a la sección circular donde cayó la
bola.
La probabilidad de contribuir en la siguiente generación viene dada por
para cada individuo i = 1, . . . , tp.
Ejemplo 6
P(i) = fitness(i)
tp
fitness(j)
j=1
Dada la función f : N −→ N
x −→ x 2
¿Cuál es el valor máximo que alcanza f en el intervalo entero [0, 31]?
Codificamos la única variable del problema, x, como una cadena de longitud 5 en el alfa-
beto A = { 0, 1}. De esta forma, podemos utilizar la numeración binaria para relacionar
el valor de x con su correspondiente codificación.
15

0 −→ 00000
4 −→ 00100
17 −→ 10001
31 −→ 11111
Como se trata de un problema de optimización (maximizar f) podemos tomar como
función fitness la propia función f.
Suponemos un tamaño de población tp = 4.
Consideramos la población inicial, generada de forma aleatoria,
I1 = 01010 I2 = 01001
I3 = 11100 I4 = 00010
Al evaluar estos indivios se tiene la siguiente tabla
Individuo Pob. Inicial Valor de x f(x) = x 2 P (i) = fi/ fj
I1 01010 10 100 0.19
I2 01001 18 324 0.6
I3 11100 7 49 0.09
I4 00010 8 64 0.12
Se deduce que el individuo I2 es el que más probabilidad tiene de contribuir en la gene-
ración siguiente, por eso, la sección circular que le corresponde en la ruleta es la más grande.
19 %
12 %
9 %
60 %
Nota:
La selección es con reemplazamiento,
es decir, un mismo individuo puede
ser copiado varias veces. Por lo tanto,
los individuos mejor adaptados tienen
mayor probabilidad de sobrevivir.
Existen otras técnicas para la selección de los individuos, como las denominadas:
Torneo: Se seleccionan dos individuos aleatoriamente y se elige el más apto con una
probabilidad p fijada. (el menos apto se elige con probabilidad (1 − p))
16

Ranqueo: Se ordena la población según el fitness de cada individuo y se le asigna la
probabilidad de selección de acuerdo a la posición que ocupa.
2.4.5. Cruce
Un sencillo proceso de cruce, denominado cruce en un punto, se realiza en dos etapas.
En la primera, los individuos de la población elegidos de acuerdo al criterio de selección
establecido son emparejados al azar.
Recuérdese que una pareja puede estar formada por el mismo individuo repetido.
En la segunda etapa, cada par de individuos experimenta un cruce como sigue:
1. Se selecciona al azar una posición entera entre uno y la longitud de la cadena, l,
menos uno.
Sea k ∈ {1, . . . , l − 1} la posición seleccionada al azar.
2. Se obtienen dos nuevas cadenas al intercambiar las subcadenas situadas entre las
posiciones k + 1 y l, ambas inclusive.
Ejemplo 7
Consideramos las cadenas w1 y w2 de la población inicial en el ejemplo anterior,
w1 = 01010
w2 = 01001
Como la longitud de estas cadenas es l = 5, tenemos que elegir la posición k como valor
entero entre 1 y 4.
Suponemos k = 4 (como indica el símbolo separador | )
w1 = 0101|0
w2 = 0100|1
El cruce resultante produce dos nuevas cadenas,
w ′ 1
w ′ 2
= 01011
= 01000
Así se genera una nueva población de individuos que hereda parte de la información de la
población anterior.
17

Nota 4
Se pueden seleccionar tantos individuos de la población actual como sean necesarios para
generar una nueva población que reemplace completamente a la actual.
Sin embargo, en muchas ocasiones se copian los N mejores individuos de la población actual
a la siguiente de modo que sólo se seleccionan los individuos necesarios para completar la
nueva población. Este tipo de selección se denomina elitista.
Normalmente, se suele copiar el mejor o los dos mejores individuos de cada población a la
siguiente. De esta forma se mantiene siempre en la población al mejor individuo alcanzado
hasta el momento.
Existen muchos otros procesos de cruce que se van adaptando a las necesidades con-
cretas de cada problema. A continuación definimos algunos de los más conocidos.
Definición 10 (Cruce en n puntos)
Se dice cruce en n puntos cuando dadas dos cadenas de longitud l se eligen n posiciones
enteras
{ki} i=1,...,n tal que ki ∈ {1, . . . , l − 1}
y se intercambian las subcadenas situadas entre estas posiciones.
Se trata de la generalización del cruce en un punto.
Ejemplo 8
Cosideramos dos individuos de longuitud l = 15 dados por
010101000001000
100100101011101
Vamos a aplicar un cruce de 4 puntos. Para ello seleccionamos al azar cuatro posiciones
enteras entre 1 y 14.
Supongamos que k1 = 3, k2 = 7, k3 = 9 y k4 = 13, entonces
010|1010|00|0010|00
100|1001|01|0111|01
Hemos obtenido dos nuevos individuos,
✿
③
100101001001001
010100100011100
18
100|1010|01|0010|01
010|1001|00|0111|00

Definición 11 (Cruce uniforme)
Se dice cruce uniforme cuando se cruzan dos cadenas dadas de longitud l mediante un
proceso que compara los símbolos que ocupan las mismas posiciones en ambas cadenas, es
decir, para cada posición i = 0, . . . , l se compara el símbolo que ocupa la i ésima posición
de la primera cadena con el que ocupa la i ésima posición de la segunda cadena.
El más utilizado cruce uniforme, genera una nueva cadena cruzando dos cadenas como
sigue:
para cada i = 0, . . . , l,
si los simbolos que ocupan la i ésima posición coinciden, entonces se copia dicho símbolo
a la posición i ésima de la nueva cadena, en otro caso, se elige uno de los dos símbolos
comparados (con probabilidad p se elige el de la primera cadena y con probabilidad (1-p)
el de la segunda) y se copia a la i ésima posición de la nueva cadena.
Ejemplo 9
Dadas dos cadenas sobre el alfabeto A = { 0, 1}
ω1 = 01010111
ω2 = 00101111
Obtenemos una nueva cadena aplicando un cruce uniforme que elige el símbolo de ω1
con probabilida 0,3 y el símbolo de ω2 con probabilidad 0,7 cuando los símbolos que se
comparan no coinciden.
Comparamos los símbolos que ocupan la primera posición, como coinciden se copia ese
símbolo a la nueva cadena.
ω1 = 01010111
ω2 = 00101111
✲ 0 · · ·
Al comparar los símbolos que ocupan la segunda posición, y teniendo en cuenta la proba-
bilidad de cruce, ha resultado que el símbolo de ω1 se copia a la nueva cadena.
ω1 = 01010111
ω2 = 00101111
✲ 0 1 · · ·
Repitiendo el proceso hasta la última posición de ambas cadenas podría obtenerse
ω1 = 01010111
ω2 = 00101111
19
✲ 0 1 1 0 1 1 1 1

Existen otros criterios para definir el operador de cruce uniforme, como por ejemplo:
Cuando dos símbolos no coincidan se intercambian entre sí con una determinada
probabilidad, dando lugar a dos nuevas cadenas.
Fijada una de las dos cadenas, se recorre símbolo a símbolo. Cada vez que se en-
cuentre un uno se compara con el símbolo que ocupa la misma posición en la otra
cadena. Si no coinciden, entonces se intercambian estos dos símbolos entre sí, dando
lugar a dos nuevas cadenas. Además, se puede imponer una probabilidad de cambio.
Ejemplo 10
Dadas dos cadenas sobre el alfabeto A = { 0, 1}
ω1 = 11001001
ω2 = 10011101
Para aplicar el cruce uniforme consideramos el criterio que intercambia dos símbolos dis-
tintos con probabilidad p = 0,5.
Empezamos a recorrer los símbolos de ambas cadenas y encontramos los dos primeros que
no coinciden
1 1 0 0 1 0 0 1
1 0 0 1 1 1 0 1
Al aplicar la probabilidad de intercambio resulta que no se cambian.
Seguimos recorriendo las dos cadenas. Llegamos al siguiente punto donde los símbolos de
ambas cadenas no coinciden
1 1 0 0 1 0 0 1
1 0 0 1 1 1 0 1
Ahora sí se intercambian. Se obtienen dos nuevas cadenas
1 1 0 0 1 0 0 1
1 0 0 1 1 1 0 1
✿
③
1 1 0 1 1 0 0 1
1 0 0 0 1 1 0 1
Este proceso se repite hasta que hayamos recorrido todos los símbolos.
Los nuevos individuos que resultan de aplicar el cruce uniforme vienen dados por
1 1 0 1 1 1 0 1
1 0 0 0 1 0 0 1
20

Los procesos de selección y cruce son sorprendentemente sencillos, involucrando gene-
ración aleatoria de números, copias de cadenas y algún intercambio parcial de cadenas.
No obstante, el énfasis combinado de selección, aleatoriedad controlada e intercambio
de información del cruce dan a los algoritmos genéticos gran parte de su potencia. Puede
parecer sorprendente que dos operaciones tan simples resulten útiles en algún caso. Incluso,
parece raro que el azar juege un papel tan fundamental en un proceso de búsqueda directo.
2.4.6. Mutación
El operador de mutación juega un papel secundario en el algoritmo genético simple.
Según algunos estudios, la frecuencia de mutación que permite obtener buenos resultados
en la mayor parte de los problemas es del orden de una mutación por mil bits. Se sabe
que en la naturaleza la probabilidad de mutación es aún más pequeña. Por eso podemos
concluir que la mutación es considerada, apropiadamente, un mecanismo secundario. Sin
embargo, este proceso nos permite dar un salto en otra dirección en el espacio de busqueda,
evitando la convergencia prematura a óptimos locales. Se trata de un mecanismo generador
de diversidad.
Uno de los procesos de mutación más sencillos y utilizados consiste en reemplazar el
valor de un bit de la población con cierta probabilidad. Otra forma de introducir nuevos
individuos en una población es la recombinación de éstos tomados al azar, sin tener en
cuenta el fitness.
21

2.5. Seudocódigo de un Algoritmo Genético Simple
Una vez estudiados los elementos necesarios para construir un algoritmo genético sim-
ple, vamos a describir el funcionamiento del mismo.
Fijados el tamaño de la población tp y la función fitness f que guiará el proceso, se
genera una población inicial P0 donde cada individuo se obtiene de forma aleatoria. En la
siguiente etapa, se evalúan los individuos de la población P0 para conocer el fitness asociado
a cada uno. Finalmente, se realiza un bucle de iteraciones que consiste en la generación de
nuevas poblaciones a partir de las anteriores mediante los operadores genéticos. De esta
forma, en la iteración k ésima se genera la población Pk a partir de los individuos de la
población Pk−1 usando selección, cruce y mutación.
Cuando finaliza la ejecución del algoritmo, se obtiene una población formada por
buenos individuos, siendo el mejor de ellos la solución que se propone.
Seudocódigo de un AGS
P0 ← generar población inicial
E0 ← evaluar (P0)
para k = 1 hasta NIter hacer
fin para
para j = 1 hasta tp hacer
fin para
Ij(1) ← seleccionar de Pk−1
Ij(2) ← seleccionar de Pk−1
Ij ← cruzar (Ij(1), Ij(2))
Ij ← mutar (Ij)
Ej ← evaluar (Ij)
Pk ← guardar (Ij)
Podíamos estar interesados en conservar los N mejores individuos de cada población
en la siguiente, es decir, aplicar una selección elitista.
En el siguiente seudocódigo, guardamos el mejor individuo generado hasta el momento
en la nueva población.
22

Seudocódigo de un AGS elitista
P0 ← generar población inicial
E0 ← evaluar (P0)
para k = 1 hasta NIter hacer
fin para
I ← mejor individuo de Pk−1
Pk ← guardar (I)
para j = 1 hasta tp − 1 hacer
fin para
Ij(1) ← seleccionar de Pk−1
Ij(2) ← seleccionar de Pk−1
Ij ← cruzar (Ij(1), Ij(2))
Ij ← mutar (Ij)
Ej ← evaluar (Ij)
Pk ← guardar (Ij)
Para finalizar esta sección, estudiaremos el funcionamiento de un algoritmo genético
simple elitista aplicado a un problema concreto.
Ejemplo 11
Se pretende maximizar el valor de la función
Codificación de los individuos
f : [ −2, 2 ] −→ R
x −→
x
exp( ) cos(5x)
2
(x+3) 2
Tenemos que codificar una única variable x que toma valores reales entre −2 y 2.
Para poder codificarlo como cadena del alfabeto binario A = { 0, 1} definimos la
siguiente traslación:
˜f : [ 0, 4 ] −→ [ −2, 2 ] −→ R
˜x −→ ˜x − 2 −→
˜x−2
exp( ) cos(5(˜x−2))
2
((˜x−2)+3) 2
+ 1
+ 1 =
Suponemos que la solución viene dada con tres cifras decimales. Luego,
0, 000 ≤ ˜x ≤ 4, 000
23
˜x
exp( −1) cos(5˜x−10)
2
(˜x+1) 2 + 1

Sabemos que
2048 = 2 11 < 4000 < 2 12 = 4096
Por lo tanto, podemos codificar la variable ˜x como una cadena ω de longitud |ω| = 12
en el alfabeto A = { 0, 1}.
Nótese que
111111111111 = 4, 095 > 4, 000
Así que cuando generemos los individuos de la población tendremos que controlar
que el valor asociado a esa cadena es menor o igual que cuatro.
Población inicial
Fitness
Trabajaremos con poblaciones de tamaño tp = 4.
La población inicial será generada de forma totalmente aleatoria.
Como se trata de un problema de maximizar f podemos tomar como fitness la propia
función f.
Criterio de selección
Cruce
Mutación
Aplicamos en cada iteración selección elitista proporcional al fitness y que mantega
en la población a los dos mejores individuos alcanzados hasta ese momento.
Cada par de individuos seleccionados será cruzado en un punto.
Sólo el mejor individuo obtenido de los dos que resultan del proceso de cruce se
guardará en la nueva población .
La probabilidad de que un individuo sea mutado será de 0,7 y la probabilidad de
que un bit cambie su valor será de 1/12 = 0,083.
Empezamos a resolver el problema ejecutando el algoritmo genético simple así diseñado.
Obtenemos la pobalción inicial P0 dada por los individuos:
24

I1 = 011001010010
I2 = 110000100101
I3 = 101110100100
I4 = 010000100001
Se tiene la siguiente tabla asociada a la población inicial P0
Individuo P0 ˜x ˜ f(˜x) P (Ii) = ˜ fi/ ˜ fj
I 0 1 011001010010 1.190 0.914 0.23
I 0 2 110000100101 2.627 0.896 0.22
I 0 3 101110100100 0.605 1.149 0.28
I 0 4 010000100001 2.114 1.092 0.27
Los dos mejores individuos de P0, I0 3 y I0 4 , pasan directamente a la siguiente población,
P1.
Individuo P1 ˜x ˜ f(˜x)
I 1 1 101110100100 0.605 1.149
I 1 2 010000100001 2.114 1.092
· · · · · · · · · · · ·
Tenemos que generar otros dos individuos mediante los operadores genéticos para comple-
tar la población P1.
Generación de I 1 3 :
I 0 3
I 0 1
= 10|1110100100
= 01|1001010010
Luego, de los procesos de selección y cruce se tiene que I 1 3
✿
③
01|1110100100 con ˜ f(0,606) = 1,149
10|1001010010 con ˜ f(1,189) = 0,915
= 011110100100. Además, este
individuo es sometido al proceso de mutación. Sin embargo, ninguno de sus bits muta.
Generación de I 1 4 :
I 0 3
I 0 2
= 1011101|00100
= 1100001|00101
25
✿
③
1100001|00100 con ˜ f(0,579) = 1,134
1011101|00101 con ˜ f(2,653) = 0,897

Luego, de los procesos de selección y cruce se tiene que I1 4 = 110000100100. Este individuo
también es seleccionado para la mutación. En esta ocasión mutan los símbolos situados en
la sexta y duodécima posición. Se obtiene
La nueva población P1 queda como sigue
I 1 4 = 110001100101
Individuo P1 ˜x ˜ f(˜x) P (Ii) = ˜ fi/ ˜ fj
Ahora, generamos la población P2.
I 1 1 101110100100 0.605 1.149 0.27
I 1 2 010000100001 2.114 1.092 0.25
I 1 3 011110100100 0.606 1.149 0.27
I 1 4 110001100101 2.659 0.897 0.21
En primer lugar, copiamos los dos mejores individuos de P1, I 1 1 y I1 3 .
Después, para completar la población P2, generamos dos individuos aplicando los opera-
dores genéticos a P1.
I 1 3
I 1 2
I 1 1
I 1 1
= 0111|10100100
= 0100|00100001
= 10111010|0100
= 10111010|0100
De los procesos de selección y cruce se tiene que
I 2 3
I 2 4
✿
③
✿
③
= 010010100100
= 101110100100
Nótese que para obtener I 2 4 hemos cruzado el mismo individuo, I1 1 .
Además, al individuo I 2 3
0100|10100100 con ˜ f(0,594) = 1,143
0111|00100001 con ˜ f(0,126) = 1,088
101110100100 con ˜ f(0,605) = 1,149
101110100100 con ˜ f(0,605) = 1,149
se le aplica el operador de mutación. En este caso, los bits situados
en la quinta, sexta y última posición mutan. Se obtiene
Sin embargo, el individuo I 2 4
I 2 3 = 010001100101
no es sometido al proceso de mutación.
Por lo tanto, la nueva población P2 ya está completamente generada.
26

Individuo P2 ˜x ˜ f(˜x) P (Ii) = ˜ fi/ ˜ fj
I 2 1 101110100100 0.605 1.149 0.26
I 2 2 011110100100 0.606 1.149 0.26
I 2 3 010001100101 2.658 0.897 0.22
I 2 4 101110100100 0.605 1.149 0.26
Para generar la siguiente población, tenemos que elegir los dos mejores individuos de P2.
Como el mejor fitness se tiene para los individuos I2 1 , I2 2 y I2 4 , elegimos al azar dos. Estos
serán los que pasen directamente a la siguiente población, P3.
Para completar la población aplicamos los operadores genéticos a la población P2.
Se obtiene la siguiente tabla para la población P3.
Individuo P3 ˜x ˜ f(˜x) P (Ii) = ˜ fi/ ˜ fj
I 3 1 011110100100 0.606 1.149 0.25
I 3 2 101110100100 0.605 1.149 0.25
I 3 3 011110100100 0.606 1.149 0.25
I 3 4 010010100100 0.594 1.143 0.25
Repetimos los pasos para generar la población P4.
Individuo P4 ˜x ˜ f(˜x) P (Ii) = ˜ fi/ ˜ fj
I 4 1 101110100100 0.605 1.149 0.25
I 4 2 011110100100 0.606 1.149 0.25
I 4 3 111110100100 0.607 1.150 0.25
I 4 4 011111100100 0.638 1.163 0.25
Finalizamos este desarrollo generando la población P5.
Individuo P5 ˜x ˜ f(˜x) P (Ii) = ˜ fi/ ˜ fj
I 5 1 011111100100 0.638 1.163 0.25
I 5 2 111110100100 0.607 1.150 0.25
I 5 3 111110100100 0.607 1.150 0.25
I 5 4 011011100100 0.630 1.160 0.25
27

Tras estas generaciones, la solución que se propone es
ω = 011111100100 −→ ˜x = 0,638 ∈ [0, 4] −→ x = ˜x − 2 = −1,362 ∈ [−2, 2]
tal que f(x) = ˜ f(˜x) = 1,163 es el valor máximo alcanzado.
Con ayuda de MATLAB hemos representado la función f en el intervalo de definición
[−2, 2] y hemos calculado el valor máximo de f en dicho intervalo. De modo que se tiene
la siguiente gráfica
tal que
Figura 2.1:
max{f(x) : x ∈ [−2, 2 ]} = 1,177
Con este ejemplo hemos intentado terminar de comprender el funcionamiento del algo-
ritmo genético y al mismo tiempo ver el buen comportamiento del método. En este caso
particular, en pocas iteraciones nos hemos aproximado al óptimo de la función mediante
unas operaciones muy sencillas. Sin embargo, la convergencia al óptimo en este problema
se podría mejorar, pues hemos aplicado un proceso de selección elitista que mantenía los
dos mejores individuos encontrados hasta ese momento para una población de tamaño
tp = 4, resulta más interesante mantener en las nuevas poblaciones sólo al mejor individuo
encontrado hasta ese momento con el fin de aumentar la diversidad de las poblaciones
generadas.
Nota 5
En la práctica, el tamaño de población, el número de iteraciones, la probabilidad de mu-
tación... son determinados de forma experimental para cada problema concreto.
28

2.6. El Teorema de los Esquemas
Uno de los resultados más importantes de la teoría de los algoritmos genéticos es el
teorema de los esquemas. Este resultado justifica la convergencia del método usado por
los algoritmos genéticos sobre un alfabeto binario.
Antes de enunciar el teorema tenemos que introducir un nuevo concepto denominado
esquema.
Definición 12
Se llama esquema a una cadena que representa un conjunto de cadenas con similares ca-
racterísticas, es decir, cadenas que tienen los mismos símbolos en determinadas posiciones.
El símbolo ∗ se utiliza para indicar las posiciones donde no es obligada la coincidencia, es
decir, indica las posiciones donde puede ir cualquier elemento del alfabeto.
Ejemplo 12
Consideramos las cadenas
01001001
01000010
01101001
01100011
Es evidente que las posiciones 1, 2, 4 y 6 de todas estas cadenas coinciden. Por lo tanto,
la cadena
es el esquema que las representa.
Nota 6
01 ∗ 0 ∗ 0 ∗ ∗
Un mismo conjunto de cadenas puede pertenecer a distintos esquemas.
Definición 13
Sea H un esquema.
Se llama orden de H al número de símbolos en H que son distintos de *.
Se denotará por o(H).
Se llama longitud de H al número de símbolos del alfabeto { 0, 1, ∗ } más uno que hay
entre la primera y la última de las posiciones distintas de *.
Se denotará por δ(H).
29

Nota 7
Si el esquema H posee una única posición distinta de * entonces δ(H) = 0.
Ejemplo 13
Sea el alfabeto binario A = { 0, 1}.
Se tiene la siguiente tabla
Esquema Orden Longitud
H1 = 0 1 ∗ ∗ 1 ∗ 0 o(H1) = 4 δ(H1) = 6
H2 = ∗ 1 ∗ 1 ∗ 1∗ o(H2) = 3 δ(H2) = 4
H3 = 0 ∗ ∗ 0 1 0 1 o(H3) = 5 δ(H3) = 6
H4 = ∗ ∗ 0 ∗ 1 ∗ ∗ o(H4) = 2 δ(H4) = 2
Teorema 1 (Teorema de los Esquemas)
Sea H un esquema.
H5 = ∗0 ∗ ∗ ∗ ∗∗ o(H5) = 1 δ(H5) = 0
H6 = ∗ ∗ ∗11 ∗ ∗ o(H6) = 2 δ(H6) = 1
El número de individuos pertenecientes a H en la población k +1 que resulta de aplicar los
operadores genéticos (selección, cruce y mutación) sobre la población k puede aproximarse
por la desigualdad
m(H, k + 1) ≥ m(H, k) · f(H)
¯f
· [1 − pc · δ(H)
− o(H) · pm]
L − 1
donde f(H) es el fitness medio de los individuos de m(H, k),
¯f es el fitness medio de la población Pk,
pc es la probabilidad de cruce,
pm es la probabilidad de que un bit mute,
L es la longitud de los individuos y
m(H, k) es el número de individuos pertenecientes al esquema H contenidos en la
población k ésima.
Demostración 1
Para obtener esta estimación tenemos que estudiar el efecto individual y combinado de los
operadores genéticos sobre los esquemas contenidos en una población.
30

Sabemos que durante la selección la probabilidad de que un individuo Ii sea seleccionado
viene dada por la expresión P (Ii) = fi/Σfj. Luego, en n selecciones con reemplazamiento
en la población Pk se obtiene que el número de individuos del esquema H que han sido
escogidos en esas n selecciones viene dado por
m(H, k + 1) = m(H, k) · n · f(H)/Σfj
Pero, como ¯ f = fj/n denota el fitness medio de la población, podemos escribir la
estimación anterior como sigue
m(H, k + 1) = m(H, k) · f(H)/ ¯ f
Por la tanto, el número de individuos pertenecientes al esquema H en la siguiente ge-
neración es directamente proporcional al fitness medio del esquema H e inversamente
proporcional al fitness medio de la población. Esto quiere decir que los esquemas con fitness
medio mayor que el fitness medio de la población aumentarán su número de individuos
en la siguiente generación, y viceversa. De hecho, el crecimiento de los “buenos” esquemas
será exponencial, mientras que los esquemas “malos” tienden a desaparecer.
En particular, cuando el fitness medio de un determinado esquema H se mantiene por
encima del fitness medio de la población una cantidad c ¯ f, entonces se tiene
m(H, k + 1) = m(H, k) · ¯ f + c ¯ f
¯f
= (1 + c) · m(H, k)
Si suponemos un valor constante de c a lo largo de las distintas generaciones resulta que
m(H, k) = m(H, 0) · (1 + c) k
Por otro lado, resulta sencillo deducir que la probabilidad de supervivencia de un esquema
H tras el proceso de cruce viene dada por
ps = 1 − δ(H)
L − 1
Si se considera una probabilidad de cruce pc para cada par de individuos emparejados,
entonces la probabilidad de supervivencia de un esquema H se aproxima por
ps ≥ 1 − pc · δ(H)
L − 1
Ahora, combinando el efecto de la selección y del cruce sobre un esquema H, y teniendo
en cuenta que ambas operaciones son independientes, se obtiene
31
∀ k

m(H, k + 1) ≥ m(H, k) · f(H)
¯f
· 1 − pc · δ(H)
L − 1
Es decir, el esquema H crece o decrece según un factor multiplicativo que, por ahora,
depende de la calidad (su fitness medio) y de la longitud del esquema. Así, los esquemas
con fitness medio por encima del fitness medio de la población y de longitud pequeña
crecerán en la siguiente generación.
Finalmente, estudiamos el efecto de la mutación sobre un esquema H.
Es evidente que para que un esquema H sobreviva al proceso de mutación no deben cambiar
ninguno de los símbolos situados en las posiciones fijas, es decir, los símbolos distintos de
*. Por lo tanto, la probabilidad de que un esquema H sobreviva a una mutación viene dada
por
(1 − pm) o(H)
donde o(H) es el número de posiciones fijas de H y (1 − pm) es la probabilidad de que una
posición fija no mute.
En particular, para valores muy pequeños de pm la expresión anterior puede aproximarse
por (1 − o(H) · pm).
Para concluir la demostración, tenemos que tener encuenta el efecto conjunto de los
tres operadores genéticos sobre un esquema H, de modo que el número de individuos
pertenecientes a H en la siguiente generación puede aproximarse mediante la siguiente
desigualdad
m(H, k + 1) ≥ m(H, k) · f(H)
¯f
· 1 − pc · δ(H)
· (1 − o(H) · pm)
L − 1
Si despreciamos los términos pequeños, obtenemos la desigualdad buscada
m(H, k + 1) ≥ m(H, k) · f(H)
¯f
32
· 1 − pc · δ(H)
− o(H) · pm
L − 1

Ejemplo 14
Veamos con un sencillo ejemplo el efecto del cruce (en un punto) sobre los esquemas.
Consideramos una cadena de longitud 7,
Sean H1 y H2 dos esquemas de ω,
Suponemos que el punto de cruce es k = 3.
ω = 0111000
H1 = ∗ 1 ∗ ∗ ∗ ∗ 0
H2 = ∗ ∗ ∗ 1 0 ∗ ∗
H1 = ∗ 1 ∗ | ∗ ∗ ∗ 0
H2 = ∗ ∗ ∗ | 1 0 ∗ ∗
Observese que si el individuo que se cruza con ω no posee un 0 en la última posición o
un 1 en la segunda posición, entonces el esquema H1 se destruye al aplicar el operador de
cruce.
Sin embargo, el esquema H2 sobrevive al proceso de cruce pues al menos uno de sus hijos
pertenece a H2.
Si aplicamos el cruce en otros puntos, podemos concluir que el esquema H1 tiene mayor
probabilidad de desaparecer pues existen muchos puntos que rompen la estructura que
caracteriza dicho esquema. Es decir, existe una relación directa entre la desaparición de
un esquema y lo que hemos definido como su longitud.
En este caso concreto, se tiene que δ(H1) = 5 y δ(H2) = 1.
Como el punto de cruce se elige aleatoriamente, podemos decir que las probabilidades de
que dichos esquemas sean destruidos vienen dadas por
δ(H1)/(L − 1) = 5/6
δ(H2)/(L − 1) = 1/6
En general, la probabilidad de supervivencia de un esquema H tras aplicarle el operador
de cruce viene dada por
1 − δ(H)
L − 1
33

2.7. Otros Algoritmos Genéticos: los Algoritmos Evolutivos
Hasta ahora hemos estudiado el funcionamiento del algoritmo genético simple y hemos
descrito cada uno de los operadores necesarios para su diseño. Estos operadores pueden
redefinirse para adaptarlos a las necesidades concretas de cada problema, pero el algoritmo
genético simple deberá de conservar su estructura interna: generación de una población
inicial y generación de nuevas poblaciones mediante los operadores genéticos. Cualquier
modificación que afecte a la estructura del algoritmo genético daría lugar a un algoritmo
de búsqueda denominado algoritmo evolutivo.
En general, se llama algoritmo evolutivo a cualquier algoritmo probabilístico que par-
tiendo de una población inicial evoluciona, dando lugar a nuevas poblaciones, con la es-
peranza de que se hereden las buenas cualidades de las poblaciones anteriores. Por lo
tanto, el algoritmo genético simple es un caso particular de algoritmo evolutivo donde los
operadores de selección, cruce y mutación actúan sobre cada población para generar una
nueva.
Partiendo de un algoritmo genético simple vamos a definir algunas modificaciones que
dan lugar a diferentes algoritmos evolutivos.
Sólo mutación
Si consideramos poblaciones de tamaño tp = 1, no tiene sentido definir el operador de
cruce para generar nuevas poblaciones. En este caso, se tiene un algoritmo evolutivo
que en cada generación muta el único individuo de la población. El nuevo individuo
reemplazará al anterior si el fitness asociado es mejor.
Información heurística
En muchas poblaciones es posible conocer algunas de las características que deben
tener las candidatas a solución. Por ejemplo, en algunos problemas se puede saber a
priori que una cadena que sea solución del problema debe de empezar por uno. Esa
información puede ser usada en la generación de la población inicial e incluso en los
operadores genéticos.
Convergencia Prematura
Es posible evitar que una población converga a un valor que no nos permita mejorar
para alcanzar la solución. Para ello, una posibilidad es inyectar de forma artificial
34

diversidad mediante la generación aleatoria de nuevos individuos que reemplacen
parcial o totalmente la población actual.
Búsqueda local
En muchos algoritmos genéticos se introduce un nuevo operador que por si sólo cons-
tituye un algoritmo de búsqueda. Se trata de un proceso que busca puntos próximos
a uno dado con la esperanza de encontrar el óptimo o, por lo menos, mejorar la
solución. Existen muchas tecnicas para diseñar la búsqueda local, una de las más
extendidas consiste en la modificación de los valores de los símbolos que constituyen
un individuo. Cada vez que se cambia el valor de un símbolo se compara el nuevo
individuo con el anterior, tomando el mejor de los dos. Podríamos repetirlo para todos
los valores del individuo. Esta búsqueda local viene a ser un proceso de mutación
dirigido.
En general, la búsqueda local mejora considerablemente los algoritmos. Puede ser
utilizada para mejorar la población inicial de modo que el algoritmo arranca con una
población de óptimos locales. Incluso se puede aplicar a cada población generada.
Ejemplo 15 (Sólo Muatación)
Vamos a construir un algoritmo evolutivo para una población de tamaño tp = 1 que usa
búsqueda local.
Seudocódigo
I0 ← generar población inicial
I0 ← busqueda local (I0)
I0 ← evaluar (I0)
para k = 1 hasta NIter hacer
fin para
I1 ← copiar (I0)
I1 ← mutar (I1)
I1 ← busqueda local(I1)
E1 ← evaluar (I1)
I0 ← mejor individuo (I0 , I1)
35

Capítulo 3
El Problema de Satisfactibilidad
3.1. Introducción
Una de las muchas aplicaciones de los algoritmos estudiados en el capítulo anterior
es la resolución de los llamados problemas de satisfactibilidad o simplemente problemas
SAT.
A lo largo de este capítulo analizaremos algunos de los algoritmos evolutivos más impor-
tantes para la resolución de SAT. Empezamos introduciendo un poco de teoría relacionada
con este problema.
3.2. Conceptos Básicos
Definición 14 (Problema NP)
Se dice que un problema P es No Determinístico Polinomial si existe un algoritmo no
determinístico que lo resuelve en tiempo polinomial, es decir, dada una solución del pro-
blema P comprobar que efectivamente es solución lleva un tiempo polinomial.
Usaremos la notación NP para referirnos a un problema No Determinístico Polinomial.
Definición 15
Se dice que un problema P se reduce a otro problema Q si existe una función f computable
que transforma entradas de P en entradas de Q y tal que x es solución de P si y sólo sí f(x)
es solución de Q.
En este caso, un algoritmo para resolver Q proporciona otro algoritmo para resolver P.
Definición 16 (Problema NP duro)
Se dice que un problema P es NP duro cuando cualquier otro problema NP se reduce a él.
36

Definición 17 (Problema NP completo)
Se dice que un problema P es completo para NP o que es NP completo si es NP y, además,
cualquier otro problema NP se reduce a él.
Definición 18 (Variable booleana)
Se dice que una variable es booleana cuando sólo puede tomar los valores verdadero o
falso.
El conjunto booleano viene dado por
B = { falso, verdadero } = { 0, 1}
Por lo tanto, si x es una variable booleana entonces el valor de x está en B.
Definición 19
El problema de satisfactibilidad (SAT) consiste en encontrar un elemento
x = (x1, . . . , xn) ∈ B n tal que f(x) = 1
siendo f : B n −→ B una función booleana dada.
Si ∃ x ∈ B n tal que f(x) = 1 entonces el problema se dirá satisfactible. En otro caso, se
dirá insatisfactible.
Proposición 1 El problema SAT es NP completo.
Definición 20
Sea Ω un conjunto finito de variables, Ω = {x1, . . . , xn}.
Se dice literal sobre una variable xi a su afirmación o negación, denotándose respectiva-
mente por xi o ¯xi.
Se llama cláusula a cualquier conjunto finito de disyunciones de literales sobre variables.
Ejemplo 16
Dadas tres variables x1, x2 y x3, se pueden definir las siguientes cláusulas:
Definición 21
C1 = x1 ∨ x2 ∨ x3, formada por tres literales
C2 = x1 ∨ x1, formada por dos literales sobre la misma variable
Se dice que una función booleana f : B n −→ B está en forma normal si se expresa como
una conjunción de cláusulas, es decir, si
donde C1, . . . , Cm son m cláusulas.
f(x) = C1(x) ∧ C2(x) ∧ · · · ∧ Cm(x)
37

Ejemplo 17 (Un problema SAT)
Dada la función booleana en forma normal
f : B 4 −→ B
x −→ f(x) = C1(x)∧C2(x)
donde C1(x) = x1 ∨ x2 ∨ x3 y C2(x) = x2 ∨ x3 ∨ x4.
¿ ∃ x ∈ B 4 tal que f(x) = 1 ?
Si tomamos x = (0, 0, 1, 1) ∈ B 4 entonces
f(x) = C1(x) ∧ C2(x) = (0 ∨ 1 ∨ 0) ∧ (0 ∨ 1 ∨ 0) = 1 ∧ 1 = 1
Por lo tanto, este problema SAT es satisfactible.
Nota 8
Cualquier función de un problema SAT puede expresarse en forma normal sin que esto
suponga pérdida de generalidad. Por ello, toda función booleana asociada al problema
SAT que se considere a partir de ahora estará expresada en forma normal.
Definición 22
Un problema SAT se dice de clase k si todas las cláusulas contienen exactamente k literales
distintos.
Para simplificar la notación hablaremos del problema k SAT en lugar del problema SAT
de clase k.
Observaciones:
1. Mientras que los problemas 2 SAT son resolubles en tiempo polinomial, los problemas
k SAT son NP completos para k ≥ 3.
2. Los algoritmos exactos pueden dar una respuesta definitiva (ser satisfactible o in-
satisfactible) a algunos problemas concretos, pero tienen una complejidad de tipo
exponencial en el mejor de los casos.
3. Los algoritmos heurísticos, es decir, aquellos que aprovechan la información históri-
ca, pueden encontrar soluciones para los problemas SAT, pero no garantizan una
respuesta definitiva a todos los problemas, ya que no pueden determinar con seguri-
dad si el problema es o no satisfactible.
38

3.3. Los Algoritmos Evolutivos para Resolver SAT
Los algoritmos evolutivos son algoritmos heurísticos que han sido utilizados para re-
solver problemas SAT y otros muchos problemas NP completos.
Como hemos visto en el capítulo anterior, el primer paso será la codificación de las
variables del problema y la elección de la función fitness más adecuada para obtener una
solución.
A continuación describimos distintos métodos de codificación para el problema SAT.
Respresentación cadena de bits
El proceso inmediato y, hasta ahora, más seguro para representar una solución can-
didata de un problema SAT es una cadena de bits de longitud igual al número de
variables, de manera que a cada variable se le asocia un bit.
Para poder implementar el algoritmo genético tenemos que decidir cuál será nuestra
función fitness. La función booleana f del problema SAT puede ser usada como
función fitness pues las soluciones del problema SAT corresponden al óptimo global
de f. Sin embargo, esta aproximación falla porque el algoritmo genético degenera en
pura búsqueda aleatoria cuando todas las soluciones candidatas toman el valor cero
en la función objetivo, a menos que una solución sea encontrada.
Por este motivo se introduce la formulación MAXSAT, donde la función fitness re-
presenta el número de cláusulas que se verifican, es decir,
fMAXSAT (x) = C1(x) + · · · + Cm(x)
siendo Ci(x) el valor de verdad de la i ésima cláusula, para i = 1, . . . , m.
Ejemplo 18
Consideramos el problema SAT dado por la función
f : B 6 −→ B
x −→ f(x) = C1(x)∧C2(x)
donde C1(x) = {x1, x2, x1} y C2(x) = {x3, x4, x6}.
Observamos que la cláusula C1 se verifica siempre, pues aparece x1 y ¯x1.
Proponemos como solución el elemento
x = (x1, x2, x3, x4, x5, x6) = (1, 0, 0, 1, 1, 0) ∈ B 6
39

La codificación de esta solución como cadena de bits es 100110.
La función fitness que guiará el proceso de búsqueda se define como
fMAXSAT (x) = C1(x) + C2(x) = 1 + C2(x) ∀x
El elemento que se propone como solución es en realidad solución del problema pues
C2(101010) = 1. Por lo tanto,
fMAXSAT (101010) = 2
que es el valor máximo que puede tomar el fitness, es decir, se verifican todas las
cláusulas.
La función fMAXSAT es usada como función fitness en la mayoría de los algoritmos
evolutivos para SAT, sin embargo, las dificultades que han ido apareciendo, incluso
para resolver pequeños problemas SAT, han motivado la definición de nuevas fun-
ciones fitness que dependen de los mecanismos de adaptación utilizados, con el fin
de lograr una distinción entre las distintas soluciones candidatas.
Respresentación punto flotante
En 1998, Bäck [3] propone transformar los problemas SAT en problemas de opti-
mización continuos, de manera que la optimización numérica de estos problemas se
pueda abordar mediante técnicas clásicas.
Así, las soluciones candidatas son representadas por vectores continuos
y ∈ [−1, 1] n
y la función objetivo se define de modo que el óptimo global corresponde direc-
tamente a soluciones factibles para el problema SAT. Para ello, se reemplazan las
variables xj por (yj −1) 2 y xj por (yj +1) 2 para cada j = 1, . . . , n. Además, se define
la función fitness
g(x) =
⎛ ⎞
m n
⎝ hij(x) ⎠
siendo m el número de cláusulas y
⎧
(yj − 1)
⎪⎨
hij(x) =
2 si xj ∈ Ci(x) , ¯xj ∈ Ci(x)
(yj + 1) 2 si ¯xj ∈ Ci(x) , xj ∈ Ci(x)
⎪⎩
i=1
j=1
(yj − 1) 2 · (yj + 1) 2 si ¯xj , xj ∈ Ci(x)
1 en otro caso
40

Ahora el objetivo es minimizar la función g. De hecho, valores de g nulos se corres-
ponden con soluciones.
Ejemplo 19
Consideramos el problema 3 SAT dado por la fórmula booleana
f(x) = C1(x) ∧ C2(x) ∧ C3(x)
donde C1(x) = x1 ∨ x2 ∨ x4, C2(x) = x1 ∨ x3 ∨ x4, y C3(x) = x2 ∨ x3 ∨ x4.
La función f : B 4 −→ B se transforma en la función continua g : [−1, 1] 4 −→ R
definida por
g(y) = (y1−1) 2 (y2+1) 2 (y4−1) 2 +(y1+1) 2 (y3−1) 2 (y4+1) 2 +(y2+1) 2 (y3+1) 2 (y4−1) 2
y nuestro objetivo es minimizar el valor de g.
Ahora, los valores booleanos 0 y 1 son asociados a los valores -1 y 1.
En la implementación del algoritmo, para comprobar si una solución para el pro-
blema SAT es realmente representada, se convierten los vectores continuos a -1 y 1,
redondeando los valores negativos y positivos, respectivamente.
A pesar de lo prometedora y original que resulta esta representación, los resultados
obtenidos no mejoran los de la representación como cadena de bits.
Respresentación clausal
Propuesta por Hao [10] en 1995, esta representación resalta los efectos locales de las
variables en las cláusulas.
Para ello, se seleccionan asignaciones de valores localmente consistentes para las
distintas variables en cada cláusula con el fin de encontrar asignaciones globalmente
consistentes.
Ejemplo 20
Volviendo a la función boolena del ejemplo anterior
f(x) = C1(x) ∧ C2(x) ∧ C3(x)
donde C1(x) = x1 ∨ x2 ∨ x4, C2(x) = x1 ∨ x3 ∨ x4, y C3(x) = x2 ∨ x3 ∨ x4.
Existen 8 asignaciones posibles para las variables en la primera cláusula, pero sólo
una de ellas no es viable. En efecto,
sí (x1, x2, x4) = (0, 1, 0) entonces C1(x) = x1 ∨ x2 ∨ x4 = 0 ∨ 0 ∨ 0 = 0
41

En el resto de los casos, es fácil comprobar que C1(x) = 1.
Razonando de la misma forma, obtenemos las asignaciones posibles para las otras
cláusulas.
Una combinación de asignaciones posibles para las distintas cláusulas viene dada por
{(x1, x2, x4) = (1, 0, 0); (x1, x3, x4) = (1, 1, 0); (x2, x3, x4) = (0, 1, 1)}
Esta sería una candidata a solución, sin embargo, contiene asignaciones inconsis-
tentes para la variable x4, pues por un lado se tiene que x4 = 0 en la cláusula C1 y,
por otro lado, x4 = 1 para la cláusula C3. Por lo tanto, esta candidata a solución no
es globalmente consistente.
Siguiendo con este razonamiento, se llega a la candidata a solución
{(x1, x2, x4) = (1, 0, 0); (x1, x3, x4) = (1, 1, 0); (x2, x3, x4) = (0, 1, 0)}
que es globalmente consistente y, por lo tanto, x = (1, 0, 1, 0) es solución del proble-
ma.
En este caso, el algoritmo genético tiene que ser guiado por una función objetivo
que refleje la cantidad de inconsistencias entre las distintas asignaciones de variables
para las cláusulas. Esto implica un proceso de búsqueda centrado en las relaciones
entre las variables que, al mismo tiempo, están relacionadas entre sí por las distintas
cláusulas.
Aunque Hao argumentó que la eliminación de las asignaciones inviables reduce el
espacio de búsqueda, la representación clausal induce un espacio de búsqueda mu-
cho más grande incluso que el obtenido en la representación cadena de bits para
problemas con muchas cláusulas.
Respresentación “path”
Sugerida por Gottlieb y Voss [6] en 1998, se basa en el hecho de que una solución
viable debe satisfacer al menos una variable en cada cláusula.
La idea consiste en ir seleccionando una variable en cada cláusula mediante un
proceso que recorre todas las cláusulas exactamente una vez cada una. Si no hay
inconsistencia en este proceso, podemos construir un vector de asignaciones.
42

Una función fitness razonable para este tipo de representación debe medir el número
de inconsistencias.
Ejemplo 21
Dado el problema SAT, encontrar x = (x1, x2, x3, x4) ∈ B 4 tal que
siendo
f(x) = 1
f(x) = (x1 ∨ x2 ∨ x4) ∧ (x1 ∨ x3 ∨ x4) ∧ (x2 ∨ x3 ∨ x4)
El camino (x1, x4, x3) es factible y nos permite construir los vectores de asignación
x = (1, 0, 0, 0) y x ′ = (1, 1, 0, 0), mientras que el camino (x1, x4, x4) contiene una
inconsistencia.
Una característica de este proceso, que lo distingue de la representación clausal,
es que permite representar una familia de soluciones factibles en lugar de intentar
determinar exactamente una.
Aunque esta representación parece la más idónea, los resultados obtenidos no han
mejorado los de la representación cadena de bits.
Después de esta breve descripción podemos concluir que la mayoría de los algoritmos
evolutivos para resolver problemas SAT utilizan como representación la cadena de bits.
La diferencia se encuentra en el tipo de función fitness utilizada. Además, algunos algo-
ritmos evolutivos incorporan otras características, no genéticas, como la búsqueda local y
la adaptación.
SAT.
A continuación describimos algunos de los algoritmos evolutivos más conocidos para
SAWEA ( stepwise adaptation of weights )
En 1997, Eiben y van der Hauw [4] proponen una función fitness para resolver
los problemas SAT, principalmente 3 SAT . El algoritmo evolutivo que la utiliza
se denominó SAW y la función fitness se definió como
fSAW (x) = ω1 · C1(x) + · · · + ωm · Cm(x)
donde los pesos ωi ∈ N, para i = 1, . . . , m, son adaptados para identificar las cláusu-
las difíciles de satisfacer en la actual fase de búsqueda.
43

En la primera fase todos los pesos son inicializados a uno, ωi = 1 para i = 1, . . . , m,
con lo que se utiliza fMAXSAT .
En las siguientes fases, cada 250 evaluaciones de la función fitness, los pesos son
ajustados de acuerdo a la siguiente expresión
ωi ← ωi + 1 − Ci(x ∗ )
donde x ∗ es el actual individuo mejor adaptado. De esta forma, se incrementan sólo
los pesos que corresponden a cláusulas que no se verifican con x ∗ , es decir, los pesos
reflejan la “dureza” de las cláusulas asociadas obligando a enfocar hacia ellas la
búsqueda evolutiva.
En 1998, Bäck identifico las mejores características de este algoritmo evolutivo y que
se conoce por SAWEA. Estas características son: tamaño de población tp = 1, un o-
perador de mutación que mute exactamente un bit y un esquema de reemplazamiento
en el cual de cada individuo se generan λ hijos mediante mutaciones, sustituyendo
el mejor de todos ellos a su padre, este tipo de reemplazamiento se denota como
(1, λ ∗ ).
Más tarde, Jong y Kosters sugieren aplicar un operador adicional a los individuos
obtenidos de la mutación. Este operador selecciona aleatoriamente algunas cláusulas
y, en aquellas que todavía no se verifiquen, muta una variable elgida aleatoriamente.
Esta mejora se conoce por LSAWEA.
RFEA ( refining functions )
En 1998, Gottlieb y Voss [7] introducen una nueva función fitness con el fin de
distinguir las distintas cadenas binarias que tienen asociado un mismo valor fitness
fMAXSAT .
Para ello, definen una función
r : B n −→ [0, 1)
que guarda el conocimiento heurístico adicional y utilizan la función fitness redefinida
para guiar el proceso de búsqueda.
fREF (x) = C1(x) + · · · + Cm(x) + α · r(x)
44

En la función fREF la constante α > 0 controla la influencia de r. De esta forma, si
usamos un nivel de influencia α ∈ [0, 1), podemos distinguir cadenas que satisfacen
el mismo número de cláusulas.
Una versión mejorada de este algoritmo evolutivo, denominada RFEA, usa una
población de tamaño tp = 4, selección por torneo, y un esquema de reemplaza-
miento basado en la eliminación del peor individuo. Además, un nuevo individuo es
rechazado si ya está en la población. El operador de mutación consiste en seleccionar
una cláusula de entre las que no se verifican y cambiar el valor de una de las variables
de la cláusula, elegida aleatoriamente.
El principal componente del algoritmo evolutivo, junto con el operador de mutación,
es la función de referencia
r(x) = 1
⎛
n
⎞
⎜ K(xj)vj ⎟
⎜
⎟
⎜ j =1 ⎟
⎜1
+
2 ⎜
n
⎟
⎝ 1 + |vj| ⎠
j =1
donde vj ∈ R es el peso asociado a la variable xj y K : B −→ {−1, 1} viene definida
por K(0) = −1 y K(1) = 1.
La adaptación de vj tiene como objeto escapar del óptimo local y se define como
sigue
vj ← vj − K(x ∗ j) · |Uj(x ∗ )|
donde x ∗ es el actual individuo mejor adaptado y |Uj(x ∗ )| denota el cardinal del
conjunto de cláusulas que no se satisfacen y que contienen la correspondiente variable
x ∗ j .
Existen otras formas de aproximar los pesos pero que no vamos a mencionarlas pues
no serán de utilidad en nuestro trabajo.
FlipGA ( Flip Heuristic )
Se trata de un algoritmo evolutivo con búsqueda local, desarrollado por Marchiori y
Rossi [17] en 1999, que genera nuevos individuos mediante los operadores genéticos
usuales y luego los mejora aplicando un proceso de búsqueda local.
45

Este algoritmo utiliza un tamaño de población tp = 10, proceso de selección propor-
cional al fitness, y un esquema de reemplazamiento generacional elitista, copiando
los dos mejores individuos de la población actual en la población siguiente. Siempre
se aplica cruce uniforme y un proceso de mutación con probabilidad 0,9, de modo
que, cada bit del individuo que muta cambia de valor con probabilidad 0,5.
La clave de este algoritmo es la aplicación de un proceso de búsqueda local a cada
individuo después de realizar el cruce y la mutación. Este proceso consiste en reco-
rrer de izquierda a derecha los bits de un individuo y cambiar el valor de cada bit
seleccionado si el número de cláusulas que se satisfacen después del cambio menos el
número de cláusulas que se satisfacen antes de cambiar el valor de dicho bit es mayor
o igual que cero. Cuando se han considerado todos los bits del individuo, se mira si
el fitness asociado a ese individuo ha mejorado, en ese caso, se repite el proceso.
La idea de este algoritmo es conseguir explotación y exploración mediante dos módu-
los bien diferenciados: búsqueda local y operadores genéticos. De esta forma, se puede
controlar mejor el efecto de los distintos módulos y modificarlos facilmente para la
investigación experimental.
ASAP ( Flip Heuristic and Adaptation )
Es una versión de FlipGA, introducida por Rossi [22] en 2000, denominada como
algoritmo evolutivo adaptado para el problema de satisfactibilidad. Se obtiene de
FlipGA al considerar un único individuo, esto es, tamaño de población tp = 1, un
esquema de reemplazamiento, denotado por (1 + 1), en el cual de cada individuo se
genera un hijo mediante mutación que sustituye al padre si es mejor y un mecanismo
adaptado para controlar la diversificación en el proceso de búsqueda.
ASAP actua sobre el individuo como sigue: primero, se aplica siempre el proceso
de mutación y se cambia, para cada j ∈ {1 . . . n}, el valor del j ésimo bit con pro-
babilidad µj ∈ [0, 0,5], donde µj es adaptado durante la ejecución. Luego, el nuevo
individuo es mejorado mediante búsqueda local como en FlipGA. Además, un meca-
nismo de adaptación basado en la búsqueda tabu es usado para prohibir que cambie
el valor de algunas variables y para controlar la probabilidad de mutación µj.
En la siguiente tabla aparecen las principales características de los algoritmos evolu-
tivos, más conocidos, para resolver SAT.
46

Características SAWEA RFEA FlipGA ASAP
Reemplazamiento (1, λ ∗ ) elimina el peor generacional (1 + 1)
Selección — torneo proporcional al fitnes —
fitness fSAW fREF fMAXSAT fMAXSAT
Inicialización aleatorio aleatorio aleatorio aleatorio
Cruce — — uniforme —
Mutación muta uno muta uno aleatorio aleatorio adaptado
Búsqueda local — — heurístico heurístico
Nota 9
Adaptación fitness fitness — lista tabu
Todos los algoritmos propuestos utilizan poblaciones iniciales puramente aleatorias.
Por último, hablaremos de la búsqueda local para los problemas SAT. Con este proceso
se pretende explorar el espacio de búsqueda de las asignaciones de valores para encontrar
una solución que maximice el número de cláusulas que se verifican. Se empieza con una
asignación generada de forma aleatoria y se van generando nuevas asignaciones al cambiar
el valor de verdad de una variable simple. La fase crucial de este proceso es la selección de
la variable que cambia. Existen muchas teorías y todas incluyen aleatoriedad y memoria.
Uno de los más populares métodos de búsqueda local para SAT es WSAT. Fue desa-
rrollado por Selman [23] en 1994 y McAllester [18] en 1997. En este caso, la selección de
una variable para ser cambiada se realiza en dos etapas. Primero, una cláusula de entre las
que no se verifican es elegida aleatoriamente. Luego, una de las variables de esta clausula
se selecciona para cambiar su valor (pasa de cero a uno o de uno a cero) obteniendose una
nueva asignación de valores.
Para finalizar, observese que WSAT y FlipGA, y en consecuencia ASAP, adoptan
diferentes estrategias de búsqueda. Mientras que una iteración de WSAT actua localmente
sobre una cláusula que no se verifica, modificandola sin afectar al resto de cláusulas que
si se verifican, en FlipGA, cada iteración actua globalmente sobre el problema con el fin
de reducir el número total de cláusulas que no se verifican.
47

Capítulo 4
Sistemas de “Word Equations”: el
Algoritmo de Makanin
4.1. Introducción
A lo largo de este capítulo estudiaremos el tipo de problemas que pretendemos resolver
con ayuda de la teoría desarrollada sobre los algoritmos genéticos.
Introduciremos el concepto de sistema de “word equations” y algunos de los resultados
conocidos hasta la fecha para su resolución. (ver [9, 21])
Pensemos en un sencillo problema que consiste en determinar si dos cadenas dadas
sobre un alfabeto coinciden. No resulta difícil diseñar métodos capaces de resolver este
problema.
Ejemplo 22
Sea A = { a, b} un alfabeto.
Consideramos las cadenas
Es evidente que ω1 = ω2.
ω1 = abbabbab
ω2 = abbabab
Una idea tan sencilla como la de recorrer ambas cadenas símbolo a símbolo (de forma
simultánea) y comparar ambos símbolos, nos permite diseñar un método que determina si
ω1 coincide con ω2.
48

ω1
ω2
✲
✲
a b b a b b a · · ·
a b b a b b b · · ·
✻
⇒ ω1 = ω2
Un problema más difícil surge cuando se pretenden encontrar patrones en cadenas
dadas. Pensemos en ecuaciones formadas por cadenas que contienen los símbolos de un
alfabeto dado, y las variables que representan los patrones a determinar. El caso más
sencillo se dá cuando en un lado de la ecuación sólo hay símbolos del alfabeto y las
variables aparecen en el otro lado.
Ejemplo 23
Tenemos que encontrar dos cadenas ω1 y ω2 sobre el alfabeto A = { a, b} tal que al
reemplazar x por ω1 e y por ω2 en la ecuación
ambos lados de la igualdad sean idénticos.
xabbxy = aabbaabaaa
De nuevo, existen muchas formas de calcular ω1 y ω2. En este caso, es evidente que ω1 = a
y ω2 = abaaa son solución de la ecuación. Pero, no tiene por que ser la única posibilidad.
Nota 10
La búsqueda de patrones en ecuaciones donde uno de los lados es constante (formado
por la cadena texto) y en el otro aparecen los patrones a encontrar (representados por
variables) ha sido muy estudiado y existen algoritmos bastante eficientes que lo resuelven.
En general, podemos plantear el problema de encontrar la solución de una ecuación
formada por cadenas de un alfabeto y tal que en ambos lados aparecen variables a deter-
minar. Como veremos, la resolución de estos problemas no es tan sencilla.
Ejemplo 24
Determinar la solución de la ecuación
no resulta una tarea fácil.
xaxbya = bybyax
Soluciones parciales de este problema se conocen desde hace tiempo. En 1972, Lentin [15],
Plotkin [20] y Siekmann [25] diseñaron procedimientos de semi decisión, es decir, algorit-
mos que encuentran una solución si existe alguna pero que podrían no terminar si no existe
49

solución. En 1971 Hmelevski [11] resuelve el problema para ecuaciones con tres variables.
Finalmente, en 1977 Makanin [16] resuelve el problema mediante el primer algoritmo (y
único conocido hasta la fecha) que encuentra solución si existe alguna y además es capaz
de determinar la no existencia de solución.
Los documentos originales de Makanin estaban enfocados a determinar si la existencia
de solución de este tipo de ecuaciones, denominadas “word equation”, es un problema
decidible. No estaba interesado en la complejidad o en la implementación del algoritmo.
Aunque posteriormente se han realizado mejoras (Pécuchet [19], Abdulrab [1], Jaf-
far [13], Schuld [24], Koscielski, Pachóski [14], entre otros, consiguieron simplificar algunos
de los detalles técnicos de la demostración, empezaron a aproximar el problema desde un
punto de vista computacional y realizaron un estudio sistemático de su complejidad) el
algoritmo de Makanin sigue siendo inviable en la práctica.
El desarrollo teórico del algoritmo de Makanin que aparece en este documento nos
permitirá comprender su funcionamiento y nos dará una idea de su complejidad computa-
cional.
4.2. Conceptos Básicos
Sean A = { a1, . . . , ar} un alfabeto y V = { v1, v2, . . .} un conjunto infinito de varia-
bles tal que A ∩ V = ∅.
Definición 23
Se llama “word equation” al par
(L, R) ∈ (A ∪ Ω) ∗ × (A ∪ Ω) ∗
donde Ω ⊆ V es un conjunto finito (de variables).
Se denotará por L = R.
Definición 24
Se llama longitud de la ecuación E ≡ (L, R) al número dado por |E| = |L| + |R|.
Nota 11
Aunque V es un conjunto infinito de variables, en una ecuación E aparecen sólo un número
finito de variables que, en genral, denotaremos por Ω = {x1, . . . , xn} ⊆ V.
50

Definición 25
Se llama sistema de “word equations” a cualquier conjunto de ecuaciones
{ L1 = R1, . . . , Lk = Rk}
donde (Li, Ri) ∈ (A ∪ Ω) ∗ × (A ∪ Ω) ∗ para cada i = 1, . . . , k.
Definición 26
Un homomorfismo
σ : (A ∪ Ω) ∗ −→ A ∗
se dice solución de un sistema de “word equations” cuando deja invariantes los elementos
del alfabeto A y además
para todo i = 1, . . . , k.
Definición 27
σ(Li) = σ(Ri)
Una solución σ de un sistema se dice mínimal si la suma
|σ(x)| es mínima en el
conjunto de longitudes de las soluciones.
Definición 28
Dado un sistema de “word equations” sobre un alfabeto A, de conjunto de variables
Ω = {x1, . . . , xn}, se llama exponente de periodicidad de una solución σ al máximo
x∈ Ω
exponente de periodicidad de las cadenas σ(xi) para i = 1, . . . , n.
4.3. El Algoritmo de Makanin
4.3.1. Representación Gráfica
Será muy importante comprender la siguiente representación de las “word equations”
para justificar los conceptos utilizados en el algoritmo de Makanin, así como para entender
su desarrollo. Esta representación es el punto de arranque de dicho algoritmo.
Consideramos la ecuación
xaby = ybax
sobre el alfabeto A = {a, b} y donde x e y representan las variables. Gráficamente, la
cadena xaby será representada por
51

x b
a y
siendo la longitud de las lineas horizontales desconocida en cada caso, excepto, las co-
rrespondientes a las constantes que son siempre de longitud uno. Las lineas verticales se
llamaran fronteras.
La ecuación posee solución si existe una forma consistente de superponer ambos lados
de la igualdad de manera que los trozos (representados mediante segmentos horizontales)
entre las fronteras coincidan.
dada
En general, existen muchas posibilidades para hacer las superposiciones. Para la ecuación
xaby = ybax
se tienen por ejemplo estas dos posibilidades, entre muchas otras,
Nota 12
x b
a y
y a
b x
x b
y a
a y
b x
Dibujamos los símbolos en distintos niveles para destacar las fronteras de cada uno.
En la siguiente etapa, se eliminan los símbolos que coinciden desde la izquierda hasta
la derecha. Por ejemplo, en la representación
x b
a y
y a
b x
52

podemos reemplazar y = xa en el otro suceso de y, para obtener
b a
x
a
b x
=⇒
b a
x
a
b x
=⇒ xa = ax
La idea básica del funcionamiento del algoritmo de Makanin es como sigue:
1. Suponer un orden de fronteras, es decir, cuál viene primero, cuál es la segunda, . . .
para todas las fronteras iniciales de ambos lados de la ecuación.
2. Proceder de izquierda a derecha reemplazando igualdades por igualdades.
Sin embargo, este ingenioso método tiene algunos inconvenientes:
El número de veces que aparece una variable puede aumentar después del reemplaza-
miento.
No siempre son evidentes los reemplazamientos. En el siguiente ejemplo,
x b
y a
no existe un reemplazamiento evidente.
a y
b x
Este proceso puede entrar en un bucle infinito. En uno de los ejemplos anteriores, se
llega a ax = xa.
53

Por estos motivos es necesario un estudio más elaborado de la representación.
Empezamos construyendo, para cada “word equation”, una representación como la
anterior. Es conveniente, para evitar que el número de ocurrencias de una variable aumente
con los reemplazamientos, trabajar con un sistema equivalente de ecuaciones en el cual
cada variable aparece no más de dos veces en cada ecuación.
Nota 13
Siempre es posible pasar de un sistema de “word equations” dado a otro equivalente donde
todas las variables ocurren a lo sumo dos veces.
Ejemplo 25
Sea la ecuación bxyx = yaxz.
Las variables de esta ecuación son
Construimos el sistema equivalente
x que ocurre tres veces
y que ocurre dos veces
z que ocurre una vez
bx1yx1 = yax2z
x1 = x2
para evitar que la variable x aparezca tres veces. Ahora, todas las variables suceden no
más de dos veces en cada ecuación. Una posible representación de este sistema equivalente,
con fronteras ordenadas, vendría dada como sigue:
bx1yx1 = yax2z =⇒
b y
x1
y x2
x1
a z
x1 = x2 =⇒
Notar que ambas ecuaciones pueden ser representada en la misma gráfica de la siguiente
forma:
54
x1
x2

y
x1
y x2
x2
x1
a z
1 2 3 4 5 6 7
Además, resulta conveniente tener exactamente dos copias de cada variable en la repre-
sentación. En este caso, tenemos que añadir una copia de la variable z. Así, la repre-
sentación final del sistema viene dada por
b y
x1
y x2
x2
x1
z
a z
1 2 3 4 5 6 7
Esta representación es el punto de arranque del algoritmo de Makanin.
4.3.2. Las Ecuaciones Generalizadas
Introducimos los conceptos utilizados por Makanin [16, 13, 24] para poder comprender
dicho algoritmo.
Definición 29
Sea (BD, ≤) un conjunto finito de números naturales que denominaremos conjunto de
fronteras.
Se llama base a una tupla
bs = (t, (e1, . . . , en))
donde n ≥ 2, t ∈ A ∪ Ω y Ebs = (e1, . . . , en) es una secuencia de fronteras ordenados por
≤.
BS denotará un conjunto finito de bases.
55

Definición 30
Una base bs = (t, Ebs) ∈ BS se dice constante si t ∈ A. En otro caso, es decir, si t ∈ Ω se
dirá base variable.
Definición 31
Sea bs ∈ BS, cualquiera.
Se llama frontera izquierda de la base bs al primer elemento en Ebs.
Se denotará Izq(bs).
Se llama frontera derecha de la base bs al último elemento en Ebs.
Se denotará Der(bs).
Nota 14
Las letras i, j,. . . se usarán para denotar las fronteras.
Ejemplo 26
Sea BD = {1, 2, 3, 4, 5, 6}, A = {a, b} y Ω = {x, y, z}.
Consideramos las bases
bs1 = (a, (1, 3, 5, 7))
bs2 = (y, (1, 2, 4, 6))
Resulta que bs1 es una base constante con Izq(bs1) = 1 y Der(bs1) = 7, mientras que bs2
es una base variable con Izq(bs2) = 1 y Der(bs2) = 6.
Definición 32
Se llama ecuación generalizada (EG) a la tupla (A, Ω, BD, BS) tal que
1. Para cada x ∈ Ω hay exactamente dos bases, llamadas duales y denotadas por x y
¯x, respectivamente.
Además, las secuencias de fronteras asociadas, Ex y E¯x, deben tener la misma lon-
gitud.
2. La secuencia de fronteras de cada base constante tiene exactamente dos elementos
que son consecutivos en el orden ≤.
Ejemplo 27
Sea A = {a, b} y Ω = {x, y}.
Se tiene la siguiente ecuación generalizada:
56

x y
b a
a b
y x
1 2 3 4 5 6 7
siendo el conjunto de fronteras BD = {1, 2, 3, 4, 5, 6, 7} y el conjunto de bases
BS = {(x, (1, 3)), (x, (5, 7)), (y, (4, 6)), (y, (2, 4)), (a, (3, 4)), (a, (4, 5)), (b, (6, 7)), (b, (1, 2))}.
Definición 33
Se llama columna de una EG a un par (i, j) de fronteras tal que i ≤ j.
Para todo i, la columna (i, i) se dice vacía y la columna (i, i+1) se dice indescomponible.
Dada una base bs, cualquiera. Se define
col(bs) = (Izq(bs), Der(bs))
Por lo tanto, una base es vacía si su columna es vacía.
Definición 34
Una EG se dice que está resuelta si todas sus bases variables son vacías.
Definición 35
Se llama unificador de una EG a una función σ que asigna a cada columna indescomponible
de la EG una cadena ω ∈ A ∪ Ω (extendida por concatenación a todas las columnas no
vacías de la EG) verificando las siguientes propiedades:
1. Para cada base constante bs = (a, Ebs),
σ(col(bs)) = a
2. Para todo par de variables duales, x y ¯x, y para todo elemento ej ∈ Ex,
Nota 15
En particular, σ(col(x)) = σ(col(¯x)).
Si ej ∈ Ex entonces ēj ∈ E¯x.
σ(e1, ej) = σ(ē1, ēj)
57

Veamos algunas de las propiedades que verifica el unificador σ de una EG.
Si σ(i, i + 1) es no vacío para todo i ∈ BD entonces σ se dirá unificador estricto.
|σ(b1, bm)|, donde b1 y bm denotan el primer y último elemento de BD, respectiva-
mente, es el índice del unificador σ.
El exponente de periocidad σ es el máximo exponente de periocidad de las cadenas
σ(col(x)), donde x es una variable base.
Para comprender la complejidad de resolver las ecuaciones generalizadas, veremos
que el problema de resolución de sistemas de ecuaciones lineales diofánticas, que es NP-
completo, se reduce a resolver una EG. Por lo tanto, encontrar solución de una EG es un
problema NP duro.
Definición 36
Dada una EG.
Para cada constante a ∈ A se define el sistema asociado de ecuaciones lineales diofánticas,
L(GE, a), dado de la siguiente forma:
1. para cada columna indescomponible (i, i+1) de la EG introducimos una variable zi.
2. para cada par de bases de variables duales
construimos (n-1) ecuaciones dadas por
ej≤i

Definición 37
Una EG se dice que es admisible si su sistema asociado L(EG, a) es resoluble para cada
a ∈ A.
Para finalizar esta sección veremos que cualquier “word equation” se puede escribir
como un conjunto finito de ecuaciones generalizadas.
Lema 2
Dada E una “word equation”, existe un algoritmo GEN que proporciona un conjunto finito
de ecuaciones generalizadas GEN(E) verificando las siguientes propiedades:
1. E tiene un unificador con exponente de periocidad p sí y sólo si alguna EG ∈ GEN(E)
posee un unificador estricto con exponente de periocidad p.
2. Para cada EG ∈ GEN(E), toda frontera es la frontera derecha o izquierda de una
base.
Además, toda secuencia de fronteras contiene exactamente a estas dos fronteras.
3. Para cada EG ∈ GEN(E) el número de bases de la EG no supera 2|E|.
4. Toda EG ∈ GEN(E) es admisible.
Ejemplo 28
Sean A = {a, b} y Ω = {x, y, z}.
La “word equation” E ≡ (bxyx, yaxz) tiene asociado el conjunto finito de ecuaciones
generalizadas GEN(E).
Antes de determinar este conjunto GEN(E) notar que es conveniente trabajar con un
sistema equivalente de ecuaciones en el que cada variable ocurre no más de dos veces en
cada ecuación. Esto siempre es posible, basta con redefinir las variables.
En este caso, la ecuación E es equivalente al sistema
bx1yx1 = yax2z
x1 = x2
donde cada variable ocurre a lo sumo dos veces.
Por lo tanto, una EG viene dada por
A = {a, b}
˜Ω = {x1, x2, y, z}
59

BD = {1, . . . , 7}
Gráficamente se representa como sigue:
BS = {(b, (1, 2)), (a, (3, 4)), (x1, (2, 3)), (x1, (5, 7)), (y, (3, 5)),
(y, (1, 3)), (x2, (4, 6)), (x2(5, 7)), (z, (6, 7)), (z, (6, 7))}
b y
x1
y x2
x2
x1
z
a z
1 2 3 4 5 6 7
4.3.3. EL Algoritmo de Transformación
Como toda “word equation” E posee un conjunto de ecuaciones generalizadas GEN(E)
equivalente, podemos reducir nuestro problema al estudio de la resolución de ecuaciones
generalizadas.
Dada una EG la idea del algoritmo de transformación es ir reemplazando sucesiva-
mente, de izquierda a derecha, las variables iguales. Se empieza con la variable situada
más a la izquierda y más grande, que se denomina portadora, y se transporta toda su
columna a la posición de su dual. Sin embargo, no siempre es posible mover todas las
columnas sin perder parte de la información esencial.
Ejemplo 29
Consideramos la representación de la ecuación xaby = ybax dada por
x b
y a
a y
b x
1 2 3 4 5 6 7 8
60

El conjunto de bases viene dado por
BS = {(x, (1, 5)), (x, (4, 8)), (y, (7, 8)), (y, (1, 2)), (a, (5, 6)), (a, (3, 4)), (b, (2, 3)), (b, (6, 7))}
Las variables situadas más a la izquierda son x e y, pero la más grande es x. Así que,
tomamos x como variable portadora y al intentar trasladar toda su columna, (1, 5), a
la posición de su dual nos encontramos con dificultades en cuanto a la identificación de
nuevas fronteras. Dichas dificultades motivan las siguientes definiciones:
Definición 38
Se llama portadora de la EG a la base de variable no vacía con frontera izquierda más
pequeña.
Si hay más de una, se toma la que tiene mayor frontera derecha.
Si todavía hay más de una candidata, se elige una al azar entre estas.
Se denotará por xc la portadora de la EG. Sus fronteras serán lc = Izq(xc) y rc = Der(xc).
Se define la frontera crítica de la EG como sigue
⎧
⎨ min{Izq(y) : rc ∈ col(y)} si {Izq(y) : rc ∈ col(y)} = ∅
cr =
⎩
si {Izq(y) : rc ∈ col(y)} = ∅
Definición 39
rc
Dada bs una base cualquiera de EG tal que bs no es portadora.
Se dice que bs es superfluo si col(bs) = (i, i) < lc.
Se dice que bs es transporte si lc ≤ Izq(bs) < cr o bien col(bs) = (cr, cr).
En otro caso, la base bs se dice fija.
Nota 16
Todas las bases variables con Izq(x) < lc son vacias como consecuencia de la definición
de base portadora. Además, cada base, excepto la portadora, es exactamente superflua,
transporte o fija, dependiendo de la región que ocupe por debajo de su frontera derecha
en el diagrama.
b1 lc cr rc bm
superfluo transporte
(col(b1) < lc) (lc ≤ Izq(bs) < cr) fijo fijo
61

Ejemplo 30
1. En este diagrama
la variable portadora es y.
x b
a y
y a
b x
1 2 3 4 5 6
Para esta variable, lc = 1 y rc = 3. Por lo tanto,
{Izq(y) : rc ∈ col(y)} = {Izq(y) : 3 ∈ col(y)} = ∅ ⇒ cr = rc = 3,
es decir, la frontera crítica de esta EG es cr = 3.
2. En el siguiente diagrama
la variable portadora es x.
x b
y a
a y
b x
1 2 3 4 5 6 7 8
Para esta variable, lc = 1 y rc = 5. Por lo tanto,
{Izq(y) : rc ∈ col(y)} = {Izq(y) : 5 ∈ col(y)} = {Izq(x) : 5 ∈ col(x) = (4, 8)} = 4
es decir, la frontera crítica de esta EG es cr = 4.
Hemos obtenido un método para determinar las bases que deberíamos mover, las bases
transporte. Ahora, vamos a estudiar hacía donde se deben trasladar estas bases.
Definición 40
Se llama impresión de una EG a una ordenación lineal ≤ en el conjunto
BD ∪ {i tr : i ∈ [lc, rc]}
62

verificando las siguientes propiedades:
1. ≤ extiende el orden de BD y además j tr < k tr para lc ≤ j < k ≤ rc.
2. tr(Ec) = Ēc, es decir, la estructura de la portadora superpone a su dual.
3. Si x es transporte y ¯x es fijo, entonces se cumple
e tr
i = ēi para algún ei ∈ Ex ⇒ tr(Ex) = Ēx
Es decir, el orden ≤ es consistente con la información de secuencias de fronteras.
4. Si (c, (i, j)) es una base constante, entonces i, j son consecutivos en el orden ≤.
Nota 17
Además, i tr y j tr tambien son consecutivos cuando i, j ∈ [lc, rc].
Es decir, las constantes se conservan.
Para cada frontera i ∈ [lc, rc] denotamos por i tr al nuevo lugar que ocupa la frontera i tras
el transporte. En general,
tr(Ex) = tr(e1, · · · , en) = (e tr
1 , · · · , e tr
n )
Una vez realizada la clasificación de las bases y una impresión de la EG, es decir, una
guía de a donde vá cada frontera transportada, se dejan las bases fijas (intactas) y se
mueven todas las bases transporte. De esta forma estamos reemplazando igualdades por
igualdades de izquierda a derecha.
Por lo tanto, el algoritmo de Makanin se guía mediante la variable portadora y su dual.
Ejemplo 31
Consideramos la siguiente EG:
u
xc
¯y
y
¯xc
1 2 3 4 5 6 7 8
donde BS = {(u, (1, 3)), (ū, (6, 8)), (xc, (1, 5)), (¯xc, (5, 8)), (y, (3, 5, 7)), (¯y, (2, 4, 5))}
63
ū

xc es la variable portadora tal que lc = 1 y rc = 5.
Calculamos la frontera crítica,
Por lo tanto,
u
cr = min{Izq(y) : rc ∈ col(y)} = 3
lc cr rc
xc
¯y
y
¯xc
1 2 3 4 5 6 7 8
Veamos como se transportan las variables transporte (ver [9]):
Como cr < rc, entonces xc y ¯xc se reducen de la siguiente forma,
ū
Ec = Ec ∩ {i ∈ BD : cr = 3 ≤ i} = {3, 4, 5}
Ēc = Ēc ∩ {i ∈ BD : c tr
r = 7 ≤ i} = {7, 8}
Hemos obtenido las nuevas bases de la variable portadora y de su dual.
lc cr rc
u
¯y
xc
y
ū
¯xc
1 2 3 4 5 6 7 8
Recordar que si cr = rc entonces Ec = tr(Ec), es decir, en este caso xc es transportada
completamente.
Estudiamos el comportamiento de las bases transporte bs,
Ec = Ec ∪ {i : i ∈ Ebs y cr = 3 < i} = {3, 4, 5} ∪ {4} = {3, 4, 5}
Ēc = Ēc ∪ {i tr : i ∈ Ebs y cr < i} = {7, 8} ∪ {4 tr } = {7, 4 tr , 8}
Hemos introducido una nueva frontera, 4 tr .
Notar que 1 tr = 5 y 5 tr = 8.
64

lc cr rc
u
¯y
xc
y
ū
¯xc
1 2 3 4 5 6 7 4 tr 8
Ya sólo queda por transportar u y ¯y. Como las variable y y su dual tienen un segmento
en común, se pierde parte de la información al transportar ¯y. Teniendo en cuenta que
obtenemos la gráfica
lc cr rc
xc
y
1 tr = 5, 2 tr = 6, 3 tr = 7
u
ū
¯y
¯xc
1 2 3 4 5 6 7 4 tr 8
Ahora, podemos eliminar las fronteras inferiores a la frontera crítica.
Definición 41 (El Árbol de Makanin)
Dada E una “word equation”, se define recursivamente el árbol de Makanin T (E) asociado
a E como sigue:
1. La raiz de T (E) es E.
2. Los hijos de E son GEN(E).
3. Para cada nodo EG (distinto de la raiz), el conjunto de sus hijos es un número finito
de ecuaciones generalizadas, T RANS(EG).
65

Teorema 2
Sea E una “word equation”.
E tiene un unificador si y sólo si T (E) tiene un nodo etiquetado con una ecuación gener-
alizada resoluble.
Este teorema proporciona el siguiente procedimiento de semi decisión:
Nota 18
Examinar todos los nodos del árbol T (E) para averiguar si E tiene solución.
En general, el árbol de Makanin asociado a una “word equation” puede ser infinito. Sin
embargo está demostrado que existe un número finito kE que acota el número de nodos
que hay que visitar. Si no se encuentra solución tras la visita de dichos kE nodos, se puede
concluir que no existe solución. kE es de carácter doblemente exponencial en la longitud
de la ecuación E.
4.4. Casos Particulares de Sistemas de “Word Equations”
Para finalizar este capítulo vamos a exponer algunos resultados conocidos para casos
particular de sistemas de “word equations”.
Definición 42
Un sistema de “word equations” se dice cuadrático si cada variable aparece a lo sumo dos
veces en el sistema.
Hablaremos de sistemas cuadráticos para referirnos a los sistemas de “word equations” de
tipo cuadrático.
El algoritmo más sencillo que los resuelve usa un espacio lineal no determinístico. En la
primera etapa se comprueba qué variables pueden ser reemplazadas por la palabra vacía,
de modo que podemos suponer que las ecuaciones son de la forma
donde y es una variable tal que x = y.
x . . . = y . . .
Además, si asumimos que x es un prefijo de y podemos reemplazar y (al menos dos ve-
ces) por xy, y cancelar x en la parte izquierda de la primera ecuación. Ahora, comprobamos
si y puede ser sustituido por la palabra vacia, Λ.
66

Repetimos el proceso sucesivamente.
Aunque el tamaño del sistema cuadrático nunca decrece, la longitud de una solución
mínima decrece en cada etapa. Por lo tanto, el algoritmo no determinístico encontrará una
solución, si la hay.
Teorema 3
Sea |A| ≥ 2.
El problema de decidir la existencia de solución de una “word equation” cuadrática es
NP duro.
Demostración 2
Consideramos un problema 3 SAT dado por la función
donde cada cláusula tiene la forma
para la familia { ˜ Xj : j = 0, . . . , 3m − 1}.
F = C0 ∧ · · · ∧ Cm−1
Ci = ( ˜ X3i ∨ ˜ X3i+1 ∨ ˜ X3i+2)
Sea V el conjunto de variables del problema.
Podemos reescribir este problema como un sistema de “word equations” introduciendo
nuevas variables
ci, di
xj
yv, zv
para i = 0, . . . , m − 1
para j = 0, . . . , 3m − 1
para cada variable v ∈ V
Tomamos las constantes a y b del alfabeto A tal que a = b.
Para cada cláusula Ci definimos dos ecuaciones:
cix3ix3i+1x3i+2 = a 3m
cidi = a 3m−1
Para cada v ∈ V consideramos el conjunto de posiciones {i1, . . . , ik} tal que
v = ˜ Xi1 = · · · = ˜ Xik
67

y el conjunto de posiciones {j1, . . . , jn} talque
˜v = ˜ Xj1 = · · · = ˜ Xjn
Suponemos que k ≤ n; el caso n ≤ k es simétrico.
Para cada v definimos dos nuevas ecuaciones:
yvzv = b
xi1 · · · xik yva n bxj1 · · · xjnzv = a n ba n b
Por lo tanto, la fórmula F es satisfactible si y sólo si el sistema cuadrático
tiene solución.
cix3ix3i+1x3i+2 = a 3m
cidi = a 3m−1
yvzv = b
xi1 · · · xik yva n bxj1 · · · xjnzv = a n ba n b
Pero, cualquier sistema de k “word equations”, con k ≥ 1
L1 = R1, . . . , Lk = Rk
donde R1, . . . , Rk ∈ {a, b} ∗ , es equivalente a una ecuación de la forma
siendo c una constante.
L1c · · · Lk−1cLk = R1c · · · Rk−1cRk
Luego, podemos reescribir el sistema cuadrático como una “word equation” sin más que
aumentar el tamaño del alfabeto en una constante. Incluso, podemos eliminar esta nueva
constante c, sin incrementar el número de veces que aparece cada variable del sistema,
codificando las tres letras como aba, abba y abbba y reemplazando cada variable xi del
problema por axia.
Por lo tanto, hemos reducido un problema 3 SAT , cualquiera, a una “word equation”
cuadrática y sabemos que 3 SAT es NP completo, es decir, hemos probado que el problema
de existencia de solución de una “word equation” cuadrática sobre un alfabeto binario es
NP duro.
68

Destacar que es posible reducir un problema de tipo 3 SAT a un sistema de “word
equations”, de forma análoga al esquema utilizado en la anterior demostración.
Proposición 2 Todo problema 3 SAT se reduce a un sistema de “word equations” sobre
el alfabeto unario A = {1}.
Demostración 3
Consideramos un problema 3 SAT dado por la función
donde cada cláusula tiene la forma
F = C0 ∧ · · · ∧ Cm−1
Ci = ˜ X3i ∨ ˜ X3i+1 ∨ ˜ X3i+2
para la familia de literales { ˜ Xj : j = 0, . . . , 3m − 1}.
Sea V el conjunto de variables del problema.
Podemos reescribir este problema como un sistema de “word equations” sobre el alfabeto
unario A = {1} introduciendo nuevas variables:
ci, di
yv, zv
Para cada v ∈ V definimos la ecuación:
para i = 0, . . . , m − 1
para cada variable v ∈ V
yvzv = 1
Para cada cláusula Ci = ˜ X3i ∨ ˜ X3i+1 ∨ ˜ X3i+2 definimos dos ecuaciones:
donde
civ3iv3i+1v3i+2 = 111
cidi = 11
⎧
⎨ yv si
vj =
⎩
˜ Xj = v
zv si ˜ Xj = ˜v
En estas condiciones se puede ver que la fórmula F es satisfactible si y sólo si el sistema
formado por las ecuaciones
civ3iv3i+1v3i+2 = 111
69

cidi = 11
yvzv = 1
para i = 0, . . . , m − 1 y v ∈ V tiene solución.
Por último, consideramos un problema particular de sistema de “word equations” que
se obtiene al imponer restricciones en la longitud de las soluciones.
Definición 43
Dado un sistema S de n “word equations” sobre un alfabeto A y con variables en el
conjunto Ω = {x1, . . . , xm}.
Se llama l sistema de “word equations” al problema de determinar si existe una solución
de S
tal que |σ(xi)| ≤ l, para cada i = 1, . . . , m.
Esta problema se denotará por l SW ES.
σ : (A ∪ Ω) ∗ −→ A ∗
Proposición 3 El problema l SW ES es NP completo para l ≥ 2.
Demostración 4
Es fácil ver que l SW ES está en NP.
Tomando como cota l = 2, se obtiene el resultado de forma análoga a como se probó la
proposición 2, pero en este caso se pueden suprimir del sistema equivalente a F las ecua-
ciones de la forma cidi = 11 para cada i = 0, . . . , m − 1.
En consecuencia 3 SAT se reduce ha 2 SW ES.
Nota 19
Nuestro trabajo se centrará en la búsqueda de solución de los problemas l SW ES sobre
el alfabeto binario A = {0, 1}.
70

Capítulo 5
Un Algoritmo Genético Simple
para Resolver l SW ES
5.1. Introducción
Una vez estudiado el problema de encontrar solución de un sistema de “word equations”
y tras observar la enorme complejidad (triplemente exponencial) del algoritmo de Makanin,
intentaremos construir un algoritmo genético que proporcione una solución si existe.
La motivación de este trabajo son los buenos resultados que se han obtenido en la
resolución de los problemas SAT mediante el uso de los algoritmos evolutivos y el hecho
de que los problemas SAT se reducen a sistemas de “word equations”, como hemos visto.
Empezamos nuestro trabajo diseñando un algoritmo genético simple con la esperanza
de obtener resultados más o menos satisfactorios.
5.2. Codificación de los Individuos
Sea A = {0, 1} el alfabeto binario y Ω = {x1, . . . , xm} el conjunto de variables del
problema l SW ES formado por n “word equations”
S = { L1 = R1, . . . , Ln = Rn}
siendo l una cota para la longitud de las variables.
Recordar que un homomorfismo σ es una solución candidata de S si |σ(xi)| ≤ l para
cada i = 1, . . . , m. Por lo tanto, tenemos que codificar m variables como cadenas de
71

longuitud menor o igual que l sobre el alfabeto A.
Definimos un nuevo símbolo B, que llamaremos símbolo blanco, de modo que, todas las
variables del problema l SW ES se pueden codificar como cadenas de longitud exactamente
igual a l sobre el nuevo alfabeto B = {0, 1, B} de la siguiente forma:
para cada i = 1, . . . , m, sea αi la codificación de la variable xi sobre B, esta codificación
es una cadena formada por símbolos de B que se lee de izquierda a derecha y cada vez que
se encuentra el símbolo blanco B se pasa al siguiente símbolo sin hacer nada.
Ejemplo 32
Las cadenas sobre B = {0, 1, B} dadas por
se leen como
α1 = 01BB0B011BBB
α2 = BB01BB0BB0BB
α3 = 111B11BB0
β1 = 010011
β2 = 0100
β3 = 111110
Además, cadenas distintas sobre el alfabeto B pueden representar la misma cadena
sobre el alfabeto A.
Ejemplo 33
Las siguientes cadenas sobre B
α1 = 01B011BBB
α2 = B01BB0B1BB1
α3 = 0101B1BB
representan la misma cadena sobre A dada por
α4 = BB0B1B0B1B1B
01011
Por lo tanto, una misma variable candidata a formar parte de la solución del problema
puede tener distintas codificaciones. Así que, con el fin de unificar la codificación de las
variables y para poder simplificar los procesos de cruce y mutación que estudiaremos más
72

tarde, reordenaremos de la siguiente forma las codificaciones:
recorriendo de izquierda a derecha la codificación desplazamos los símbolos B al final de
la cadena.
Con esta reordenación conseguimos construir un representante de todas las posibles
codificaciones de una misma variable.
Ejemplo 34
Sea la codificación dada por
tras la reordenación obtenemos la cadena
0B10B00B1BB1B001
0100011001BBBBBB
que representa todas las posibles codificaciones de la variable 0100011001.
Nota 20
La cadena formada sólo por símbolos blancos representa la cadena vacia, Λ.
Una vez codificadas las variables del problema, definimos un individuo como la con-
catenación de las cadenas αi para i = 1, . . . , m que se obtienen al codificar las m variables
x1, . . . , xm.
Ejemplo 35
Supongamos que tenemos que codificar 4 variables de longitud menor o igual a 6 sobre el
alfabeto binario A. Sean
α1 = B01B10
α2 = BB1BB0
α3 = 11BB1B
Lo primero que tenemos que hacer es reordenar los símbolos, obteniendo
α1 = 0110BB
α2 = 10BBBB
α3 = 111BBB
Un individuo o solución candidata del problema viene dada por la cadena
I = α1α2α3 = 0110BB 10BBBB 111BBB
α1 α2 α3
73

Nota 21
No tiene sentido reordenar las cadenas que representan individuos de la población, pues
perderíamos la información de las variables que componen esas posibles soluciones del
problema.
Para finalizar esta sección, queremos destacar que con esta codificación de los indivi-
duos conseguimos que todos tengan la misma longitud, m · l. Además, todas las variables
son codificadas como cadenas de longitud igual a l, aunque la longitud real de la variable
que se representa es menor o igual que l, pues el símbolo B no aporta nada al valor de las
variables. Por lo tanto, buscamos soluciones en un espacio de búsqueda de tamaño
l
2 i
m
= (2 l+1 − 1) m
5.3. Generación de la Población Inicial
i=0
Trabajaremos con poblaciones de tamaño fijo, tp. Aunque el algoritmo que diseñaremos
permitirá al usuario elegir el tamaño de la población con el que quiere resolver el problema,
uno de nuestro primeros objetivos será determinar el tamaño de la población más adecuado
para la resolución de los problemas l SW ES.
Una vez fijado el tamaño tp, la población inicial será generada de forma aleatoria.
Para la implementación de este proceso proponemos dos métodos.
Método 1.
Cada individuo de la población inicial se genera como sigue:
para cada i = 1, . . . , m eligimos de forma aleatoria un número entre 0 y l, que deno-
taremos por lr(i). Después, construimos aleatoriamente una cadena βi de longitud
lr(i) sobre el alfabeto A y una cadena ¯ βi formada por el símbolo B de longitud igual
a l − lr(i). La cadena αi se obtiene como la concatenación de βi y ¯ βi.
Finalmente, definimos el individuo
Ejemplo 36
αi = βi ¯ βi
I = α1 · · · αm
Generamos una población de tamaño tp = 3 para resolver un problema 4 SW ES
con dos variables. (l = 4)
74

Empezamos definiendo el primer individuo de la población inicial, I1.
Para i = 1 elegimos al azar la longitud de la subcadena β1, sea lr(1) = 2 ∈ {0, 1, . . . , 4}.
Construimos aleatorimente β1 = 01. Definimos ¯ β1 = BB.
Se obtiene la cadena α1 = β1 ¯ β1 = 01BB.
Para i = 2 elegimos al azar la longitud de la subcadena β2, sea lr(2) = 4 ∈ {0, 1, . . . , 4}.
Construimos aleatoriamente β2 = 0110. Definimos ¯ β2 = Λ.
Se obtiene la cadena α2 = β2 ¯ β2 = 0110Λ = 0110.
Por lo tanto, se tiene que
I1 = α1α2 = 01BB0110
Definimos ahora el segundo individuo de la población inicial, I2.
Para i = 1 elegimos al azar la longitud de la subcadena β1, sea lr(1) = 1 ∈ {0, 1, . . . , 4}.
Construimos aleatoriamente β1 = 1. Definimos ¯ β1 = BBB.
Se obtiene la cadena α1 = β1 ¯ β1 = 1BBB.
Para i = 2 elegimos al azar la longitud de la subcadena β2, sea lr(2) = 0 ∈ {0, 1, . . . , 4}.
Construimos aleatoriamente β2 = Λ. Definimos ¯ β2 = BBBB.
Se obtiene la cadena α2 = β2 ¯ β2 = ΛBBBB = BBBB.
Por lo tanto, se tiene que
I2 = α1α2 = 1BBBBBBB
Finalmente, generamos el último individuo, I3.
Para i = 1 elegimos al azar la longitud de la subcadena β1, sea lr(1) = 3 ∈ {0, 1, . . . , 4}.
Construimos aleatoriamente β1 = 101. Definimos ¯ β1 = B.
Se obtiene la cadena α1 = β1 ¯ β1 = 101B.
Para i = 2 elegimos al azar la longitud de la subcadena β2, sea lr(2) = 3 ∈ {0, 1, . . . , 4}.
Construimos aleatoriamente β2 = 111. Definimos ¯ β2 = B.
Se obtiene la cadena α2 = β2 ¯ β2 = 111B.
Por lo tanto, se tiene que
I3 = α1α2 = 101B111B
De esta forma, hemos generado al azar una población inicial de tamaño tp = 3.
Método 2.
Cada individuo de la población inicial se genera como sigue:
para cada i = 1, . . . , m construimos al azar una cadena αi de longitud l sobre el
75

alfabeto B y luego reordenamos dicha cadena para que todos los símbolos blancos
estén situados al final de la misma. Finalmente, definimos el individuo
Ejemplo 37
I = α1 · · · αm
Generamos una población de tamaño tp = 3 para resolver un problema 4 SW ES
con dos variables. (l = 4)
Empezamos definiendo el primer individuo de la población inicial, I1.
Para i = 1 construimos aleatorimente la cadena α1 = B1B0, después de la reorde-
nación se tiene que α1 = 10BB.
Para i = 2 construimos aleatoriamente la cadena α2 = BB1B, después de la reorde-
nación se tiene que α2 = 1BBB.
Por lo tanto,
I1 = α1α2 = 10BB1BBB
Definimos ahora el segundo individuo de la población inicial, I2.
Para i = 1 construimos aleatorimente la cadena α1 = 1BB1, después de la reorde-
nación se tiene que α1 = 11BB.
Para i = 2 construimos aleatoriamente la cadena α2 = 0B01, después de la reorde-
nación se tiene que α2 = 001B.
Por lo tanto,
I1 = α1α2 = 11BB001B
Finalmente, generamos el último individuo, I3.
Para i = 1 construimos aleatorimente la cadena α1 = 0000, después de la reorde-
nación se tiene que α1 = 0000.
Para i = 2 construimos aleatoriamente la cadena α2 = BBBB, después de la reor-
denación se tiene que α2 = BBBB.
Por lo tanto,
I1 = α1α2 = 0000BBBB
De esta forma, hemos generado al azar una población inicial de tamaño tp = 3.
76

5.4. Evaluación de los Individuos
Este es un paso muy importante en el diseño del algoritmo genético, pues tenemos
que encontrar una función fitness sencilla, es decir, con poco coste a la hora de evaluar
los individuos, y que al mismo tiempo nos permita guiar el proceso de búsqueda de las
soluciones de la forma más eficiente posible.
Un individuo I = α1 · · · αm es solución del problema l SW ES si al sustituir las sub-
cadenas αi por las variables xi, para i = 1, . . . , m, en el sistema de “word equations” se
obtienen identidades.
Ejemplo 38
Consideramos el problema 3 SW ES dado por el sistema
01x11 = x21x1
x101x2 = 10x21
Generamos una población de tamaño tp = 2 dada por
I1 = 11B01B
I2 = 1BB01B
Veamos si alguno de los individuos de esta población es solución del problema. Empezamos
sustituyendo el individuo I1.
Como,
resulta que
Es decir, I1 no es solución.
I1 = 11B01B ✲
Ahora, comprobamos si I2 es solución.
Como,
α1 = 11B ✲ x1 = 11
α2 = 01B ✲ x2 = 01
01x11 = x21x1 ✲ 01111 = 01111
x101x2 = 10x21 ✲ 110101 = 10011
I2 = 1BB01B ✲
α1 = 1BB ✲ x1 = 1
α2 = 01B ✲ x2 = 01
77

esulta que
I2 tampoco es solución.
01x11 = x21x1 ✲ 0111 = 0111
x101x2 = 10x21 ✲ 10101 = 10011
Observamos que aunque ninguno de los dos individuos de la población son solución, ambos
hacen que se verifique la primera de las ecuaciones del sistema. Sin embargo, parece estar
más proximo a la solución el individuo I2 pues sólo dos símbolos de la segunda ecuación
del sistema no coinciden.
Este ejemplo, nos sugiere definir el fitness asociado a un individuo como el número
de símbolos que no coinciden al sustituir dicho individuo en el sistema. De esta forma,
nuestro objetivo será minimizar el valor de la función fitness, es decir, conseguir que nigún
símbolo sea distinto del correspondiente situado en el otro lado de la ecuación.
Definición 44
Sea S = {L1 = R1, . . . , Ln = Rn} un l SW ES.
Se define el fitness asociado a un individuo I como el valor dado por
n
f(I) = (max{lk, rk} − ck)
k=1
siendo lk = |Lk(I)|, rk = |Rk(I)| y ck el número de símbolos que coinciden al sustituir el
individuo I en la k ecuación del sistema, para cada k = 1, . . . , n.
Nota 22
Al sustituir en cada ecuación Lk = Rk el individuo I, obtenemos dos cadenas Lk(I) y
Rk(I) sobre el alfabeto A cuyas longitudes hemos denotado por lk y rk, respectivamente.
El individuo I será solución del sistema si Lk(I) = Rk(I) para cada k = 1, . . . , n.
Ejemplo 39
Volviendo al sistema del anterior ejemplo
Teníamos una población dada por
01x11 = x21x1
x101x2 = 10x21
I1 = 11B01B
I2 = 1BB01B
78

Veamos quien es el fitness asociado a cada uno de estos individuos:
Al sustituir I1 en el sistema se obtiene
L1(I1) = 01111 con l1 = 5
R1(I1) = 01111 con r1 = 5
L2(I1) = 110101 con l2 = 6
R2(I1) = 10011 con r2 = 5
Como L1(I1) = R1(I1), todos los símbolos del lado izquierdo de la ecuación coinciden con
los del lado derecho, por lo tanto, c1 = 5. Luego, f1(I1) = max{l1, r1} − c1 = 5 − 5 = 0.
En la segunda ecuación resulta que L2(I1) = R2(I1). Contamos los símbolos que ocupando
la misma posición en ambas cadenas coinciden.
L2(I1) = 1 1 01 01
R2(I1) = 1 0 01 1
Se obtiene que c2 = 3. Luego, f2(I1) = max{l2, r2} − c2 = max{6, 5} − 3 = 6 − 3 = 3.
Por lo tanto,
f(I1) =
2
fk(I1) =
k=1
Al sustituir I2 en el sistema se obtiene
2
(max{lk, rk} − ck) = 0 + 3 = 3
k=1
L1(I2) = 0111 con l1 = 4
R1(I2) = 0111 con r1 = 4
L2(I2) = 10101 con l2 = 5
R2(I2) = 10011 con r2 = 5
Como L1(I2) = R1(I2) todos los símbolos del lado izquierdo de la ecuación coinciden con
los del lado derecho, por lo tanto, c1 = 4. Luego, f1(I2) = max{l1, r1} − c4 = 4 − 4 = 0.
En la segunda ecuación resulta que L2(I2) = R2(I1). Contamos los símbolos que ocupando
la misma posición en ambas cadenas coinciden.
L2(I2) = 10 10 1
R2(I2) = 10 01 1
79

Se obtiene que c2 = 3. Luego, f2(I2) = max{l2, r2} − c2 = max{5, 5} − 3 = 5 − 3 = 2.
Por lo tanto,
f(I2) =
2
fk(I2) =
k=1
2
(max{lk, rk} − ck) = 0 + 2 = 2
k=1
Como el fitness asociado a I2 es menor que el asociado a I1 podemos concluir que es mejor
candidata a solución la cadena I2.
Nota 23
Cuando sustituimos un individuo en una ecuación obtenemos dos cadenas sobre el alfabeto
A, las correspondientes al lado derecho e izquierdo de la ecuación, que no tienen por que
tener la misma longitud. Una condición necesaria para que ambas cadenas coincidan es
que tengan la misma longitud, por eso a la hora de calcular el fitness no sólo contamos
los símbolos que ocupando las mismas posiciones en ambas cadenas no coinciden sino que
también contamos los símbolos que hacen que una cadena tenga mayor longitud, es decir,
los símbolos situados entre la posición min{lk, rk} + 1 y max{lk, rk}.
5.5. Los Operadores Genéticos
Selección
Usaremos un criterio de selección elitista que mantiene en la población al mejor
individuo alcanzado hasta ese momento. Además, la selección de los individuos que
darán lugar a una nueva población se hará de acuerdo al fitness asociado mediante
el método de la ruleta. En este caso, pretendemos minizar la función fitness, por lo
que los individuos con un fitness más pequeño son los que mayor probabilidad tiene
de contribuir en la siguinte población.
La probabilidad de contribuir en la siguiente población viene dada por
P(i) =
para cada individuo i = 1, . . . , tp.
Ejemplo 40
tp
j=1
tp
tp
l=1
(
j=1
f(j) − f(i)
f(j) − f(l))
Supongamos que tenemos una población de tamaño tp = 4 y hemos evaluado los
individuos obteniendo la siguiente tabla
80

Cruce
Individuo fitness
I1
I2
I3
I4
Es evidente que el individuo con mayor probabilidad de contribuir en la siguiente
generación es I1. Luego, la probabilidad de contribuir en la siguiente población es
inversamente proporcional al fitness.
Construimos una ruleta de la siguiente forma:
sea sum la suma de los fitness de la población,
sum =
2
12
5
7
4
f(Ii)
i=1
definimos para cada individuo un nuevo fitness dado por
f(Ii) = sum − f(Ii)
Ahora, la probabilidad de que un individuo contribuya en la siguiente población es
directamente proporcional al nuevo fitness. En este ejemplo,
Para cada par de individuos
sum = 2 + 12 + 5 + 7 = 26
Individuo fitness
fitness f(Ii)/ 4
j=1 f(Ij)
I1 2 24 24/78 = 0,31
I2 12 14 14/78 = 0,18
I3 5 21 21/78 = 0,27
I4 7 19 19/78 = 0,24
I1 = α 1 1 · · · α1 m
I2 = α 2 1 · · · α2 m
se define el operador de cruce como un proceso que cruza cada subcadena α 1 i = β1 i ¯ β 1 i
con la subcadena α2 i = β2 i ¯ β2 i , para i = 1, . . . , m, en dos etapas, obteniendose un
81

nuevo individuo.
Recordar que cada subcadena αi sobre el alfabeto B = {0, 1, B} está formada por
dos subcadenas βi y ¯ βi siendo βi una cadena de longitud menor o igual que l sobre
el alfabeto A = {0, 1} y ¯ βi una cadena de símbolos blancos.
En la primera etapa, se aplica un cruce uniforme como sigue:
1. Se calcula la posición k = min{|β 1 i |, |β2 i |}
2. Para cada j = 1, . . . , k elijo con probabilidad p el símbolo que ocupa la posición
j ésima de α1 i y con probabilidad 1 − p tomamos el de la subcadena α2 i , este
símbolo pasa a ocupar la posición j ésima de la subcadena αi en el nuevo
individuo, es decir, estamos aplicando un cruce uniforme a las cadenas α1 i (1, k)
y α2 i (1, k).
En nuestro algoritmo tomaremos p = 0,5.
Ejemplo 41
Vamos a aplicar la primera etapa del cruce a las subcadenas
Calculamos la posición
α 1 i
α 2 i
= 011101 BB
β 1 i
¯β 1 i
= 1101 BBBB
β 2 i
¯β 2 i
k = min{|β 1 i |, |β 2 i |} = min{6, 4} = 4
Por lo tanto, aplicamos un cruce uniforme a las cadena
Obteniendo, por ejemplo, la cadena
α1 i (1, 4) = 0111
α2 i (1, 4) = 1101
αi(1, 4) = 0101
En la segunda etapa, aplicamos un cruce en un punto como sigue:
1. Elegimos una posición q ∈ {k, . . . , l}, siendo l la longitud de las cadenas α 1 i y
α2 i , para i = 1, . . . , m.
82

2. Si una de las dos cadenas α1 i (k + 1, l) ó α2 i (k + 1, l) contiene algun símbolo
Nota 24
Mutación
distinto de B, definimos αi(k + 1, q) con las q − k primeras posiciones de esa
cadena y completamos la subcadena αi con l − q símbolos blancos, es decir,
αi(q + 1, l) = B l−q .
En otro caso, se define αi(k + 1, l) = B l−k
Si q = k entonces αi = (k + 1, l) = B l−k
Ejemplo 42
En el ejemplo anterior aplicamos la primera etapa del cruce a las subcadenas
α 1 i
α 2 i
= 011101BB
= 1101BBBB
Obtuvimos αi(1, 4) = 0101. Ahora aplicamos la segunda etapa del cruce para definir
αi(5, 8). Para ello, tenemos que eligir una posición entre 4 y 8, sea q = 7.
Como α 1 i (5, 8) = 01BB tiene símbolos distintos del blanco, definimos αi(k+1, q) = αi(5, 7)
con los q − k = 3 primeros símbolos de α 1 i (5, 8) = 01BB, es decir, αi(5, 7) = 01B.
Finalmente, completamos la cadena αi con l − q = 1 símbolos blancos.
Hemos construido la subcadena
αi = 010101BB
Repitiendo este proceso para cada par de subcadenas α 1 i y α2 i
un nuevo individuo a partir de los individuos I1 e I2.
conseguimos definir
Cada individuo de la población será mutado con probabilidad p, fijada. La prob-
abilidad de mutación será otro de los datos que el usuario fija para resolver los
problemas. En nuestro caso, buscaremos la probabilidad de mutación más adecuada
para resolver los problemas l SW ES.
Si un individuo I = α1 · · · αm es seleccionado para la mutación, entonces se aplica un
proceso de mutación a cada subcadena αi = βi ¯ βi de la siguiente forma: cada símbolo
de la subcadena αi cambia con probabilidad 1
l , siendo l la longitud de la subcadena
αi.
83

Recordar que la subcadena αi toma valores en el alfabeto B. Así pues, tras el proceso
de mutación es necesario reordenar de nuevo para situar los símbolos blancos al final.
Hemos definido todas los elementos necesarios para el diseño del algoritmo genético
simple. En el apendice A se encuentra el código de este algoritmo escrito en el lenguaje
C++.
Veamos con un sencillo ejemplo su funcionamiento.
Ejemplo 43
Consideramos el problema 3 SW ES dado por las ecuaciones
Codificación de los individuos
x2x1 = 10x2
x210x1 = 1x10x1
Cada individuo se obtiene como la concatenación de dos cadenas de longitud l = 3
sobre el alfabeto B.
Población inicial
Trabajaremos con poblaciones de tamaño tp = 4.
La población inicial será generada usando el método 2.
Usaremos el fitness y los operadores genéticos que acabamos de definir.
Empezamos a resolver el problema ejecutando el algoritmo genético simple así diseñado.
Generamos la población inicial:
α1 1 = 0B1 ✲ α1 1 = 01B
α1 2 = B11 ✲ α1 2 = 11B
α2 1 = 011 ✲ α2 1 = 011
α2 2 = B1B ✲ α2 2 = 1BB
α3 1 = 101 ✲ α3 1 = 101
α3 2 = BB0 ✲ α3 2 = 0BB
84
✲
✲
✲
I 0 1
I 0 2
I 0 3
= 01B11B
= 0111BB
= 1010BB

α4 1 = BB1 ✲ α4 1 = 1BB
α4 2 = 1B0 ✲ α4 2 = 10B
Obtenemos la pobalción inicial P0 dada por los individuos:
Evaluamos la población inicial:
x210x1 = 1x10x1
x2x1 = 10x2
x210x1 = 1x10x1
x2x1 = 10x2
x210x1 = 1x10x1
x2x1 = 10x2
x210x1 = 1x10x1
x2x1 = 10x2
I 0 1
I 0 2
I 0 3
I 0 4
= 01B11B
= 0111BB
= 1010BB
= 1BB10B
✲
I0 1 1101 = 1011
✲
✲
I0 1 111001 = 101001
✲
I0 2 110011 = 10110011
✲
I0 2 1011 = 101
✲
I0 3 010101 = 11010101
✲
I0 3 0101 = 100
✲
I0 4 10101 = 1101
✲
I0 4 101 = 1010
Se tiene la siguiente tabla asociada a la población inicial P0
I 0 4
= 1BB10B
Individuo P0 fitness
fitness P (Ii)
I 0 1 01B11B 3 20 0.29
I 0 2 0111BB 8 15 0.22
I 0 3 1010BB 7 16 0.23
I 0 4 1BB10B 5 18 0.26
✲
✲
✲
✲
f1 = 3
f2 = 8
f3 = 7
f4 = 5
El mejor individuo de P0, I0 1 , pasa directamente a la siguiente población, P1.
Individuo P1 fitness
I 1 1 01B11B 3
· · · · · · · · ·
85

Tenemos que generar otros tres individuos mediante los operadores genéticos para com-
pletar la población P1.
Generación de I 1 2 :
Selección
Cruce
I 0 1 = 01B11B −→ α1 1 = 01B α1 2
I 0 3 = 1010BB −→ α3 1 = 101 α3 2
Empezamos aplicando el cruce a las cadenas α 1 1 = 01B y α3 1
= 11B
= 0BB
= 101.
De aplicar el cruce uniforme a las subcadenas 01 y 10 resulta la subcadena 00.
De aplicar el cruce en un punto a las subcadenas B y 1 resulta la subcadena B.
Por lo tanto, hemos obtenido
α 3 1
α 1 1
= 101
= 01B
Repetimos el proceso para las cadenas α 1 2 = 11B y α3 2
✲
α1 = 00B
= 0BB.
De aplicar el cruce uniforme a las subcadenas 1 y 0 resulta la subcadena 0.
De aplicar el cruce en un punto a las subcadenas 1B y BB resulta la subcadena 1B.
Por lo tanto, hemos obtenido
Luego, I 1 2
Mutación
= 00B01B.
α 3 2
α 1 2
= 0BB
= 11B
✲
α2 = 01B
Este individuo es sometido al proceso de mutación, resultando
Generación de I 1 3 :
Selección
00B −→ B0B −→ 0BB
01B −→ 01B −→ 01B
✲
I 0 2 = 0111BB −→ α2 1 = 011 α2 2
I 0 1 = 10B11B −→ α1 1 = 01B α1 2
86
I 1 2
= 0BB01B
= 1BB
= 11B

Cruce
Empezamos aplicando el cruce a las cadenas α 2 1 = 011 y α1 1
= 01B.
De aplicar el cruce uniforme a las subcadenas 01 y 01 resulta la subcadena 01.
De aplicar el cruce en un punto a las subcadenas 1 y B resulta la subcadena 1.
Por lo tanto, hemos obtenido
α 1 1
α 2 1
= 01B
= 011
Repetimos el proceso para las cadenas α 2 2 = 1BB y α1 2
✲
α1 = 011
= 11B.
De aplicar el cruce uniforme a las subcadenas 1 y 1 resulta la subcadena 1.
De aplicar el cruce en un punto a las subcadenas BB y 1B resulta la subcadena BB.
Por lo tanto, hemos obtenido
Luego, I 1 2
Mutación
= 0111BB.
α 1 2
α 2 2
= 11B
= 1BB
✲
α2 = 1BB
Este individuo es sometido al proceso de mutación, resultando
011 −→ B01 −→ 01B
0BB −→ 0B1 −→ 01B
✲
I 1 2
= 01B01B
Repitiendo este proceso generamos los otros individuos de la población. Tras la evaluación
de los nuevos individuos se obtine la siguiente tabla para la población P1,
Individuo P0 fitness
I 1 1 01B11B 3
I 1 2 01B01B 4
I 1 3 1BB11B 5
I 1 4 01B10B 0
Como uno de los individuos de la nueva población tiene fitness 0, el algoritmo ha finalizado.
La solución propuesta es
x1 = 01
x2 = 10
87

Capítulo 6
El Algoritmo Genero Problema
Estamos en condiciones de empezar a experimentar con el algoritmo genético simple,
pero nos encontramos con un inconveniente: no existen documentos donde aparezcan pro-
blemas del tipo de los que pretendemos resolver, así que nos vemos obligados a construir
los problemas l SW ES.
Para facilitar este trabajo hemos decidido diseñar un algoritmo que construye un sis-
tema de “word equations” sobre el alfabeto A = {0, 1} con un número de ecuaciones y de
variables fijado. Este algoritmo también proporcionará una solución del problema, pero
no tiene por que ser la única.
pasos:
La primera idea para el diseño de este algoritmo consistía en realizar los siguientes
1. Generar un sistema de identidades sobre el alfabeto A.
2. Generar las variables como cadenas de longitud menor o igual que lmax sobre el
alfabeto A.
3. Para cada variable generada, recorrer el sistema buscando una subcadena que coinci-
da con la variable. Si la encuentro, sustituyo con probabilidad p la subcadena por la
letra que representa a la variable y lo sigo recorriendo en busca de otra coincidencia.
Sin embargo, esta idea tan sencilla no nos garantiza que, al final, el sistema generado
contenga todas las variables pues, por ejemplo, una variable puede ser generada como una
cadena sobre A que no es subcadena en ninguna de las ecuaciones del sistema.
Logicamente, fijado un número de ecuaciones, n, y un número de variables, m, nuestro
interés es construir un sistema de n “word equations” sobre el alfabeto A que contenga
88

exactamente m variables, x1, . . . , xm. Por lo tanto, nos vemos obligados a modificar esta
primera idea y construimos un algoritmo con los siguientes pasos:
1. Generar un sistema de identidades sobre el alfabeto A = {0, 1}.
2. Para cada variable xi,
a) elegimos una ecuación del sistema,
b) elegimos el lado derecho o izquierdo de la ecuación,
c) definimos la variable xi como una subcadena de la parte elegida (derecha o
izquierda) de la ecuación, esta subcadena será de longitud menor o igual que
lmax sobre A,
d) sustituimos la subcadena de la ecuación por la letra que representa a la variable
generada. De esta forma se consigue que cada variable generada aparezca al
menos una vez en el sistema.
3. Una vez que se han generado todas las variables, recorremos el sistema en busca de
Nota 25
coincidencias para cada variable xi, i = 1, . . . , m. Si se encuentra una subcadena en el
sistema que coincida con la variable xi, se cambia con probabilidad p la subcadena
por la letra que representa a la variable. Con este paso pretendemos aumentar el
número de veces que aparece una variable en el sistema.
A medida que se van generando las variables, el sistema de identidades sobre el alfabeto
A se convierte en un sistema de ecuaciones sobre el conjunto A ∪ {x1, . . . , xm}.
El paso crítico de este algoritmo se encuentra al definir las variables del sistema. In-
tentaremos explicar un poco más este paso. El algoritmo que diseñamos necesita, además
del número de ecuaciones y el número de variables, dos cotas le y lmax. La primera de ellas,
le, indica la longitud máxima de las cadenas que generamos sobre A para construir las
identidades (paso 1). La segunda cota, indica la longitud máxima de las variables. Por lo
tanto, una vez que se ha elegido el lado de la ecuación donde se vá a definir la variable xi,
se selecciona al azar una posición q de la misma y se cuentan los símbolos (consecutivos)
del alfabeto A que hay a la derecha de q. Si denotamos por lq al número de símbolos del
alfabeto A que hay a la derecha de q, entonces la variable xi se define como un subcadena
89

de longitud lr ∈ {0, min{lmax, lq}} que coincide con el trozo de subcadena de la ecuación
que vá de q a q + lr.
Notar que si lr = 0, entonces la variable xi es la palabra vacía.
Nota 26
En general, el problema(n m lmax) denotará un sistema de n “word equations” con m
variables, de modo que cada variable (al menos en una solución del sistema) tiene longitud
menor o igual que lmax.
En la última versión de este algoritmo, hemos añadido un proceso para controlar
el tipo de ecuaciones que constituyen el sistema. Con este proceso se pretenden evitar
las ecuaciones donde el lado derecho coincide con el izquierdo. Por ejemplo, la ecuación
0x110 = 0x110 puede ser eliminada del sistema por tratarse de una igualdad. De modo
que una vez generado el sistema lo sometemos a los siguientes pasos:
1. Recorremos el sistema en busca de ecuaciones con la misma cadena en ambos lados.
2. Para ecuación de este tipo,
a) Recorremos la ecuación para cada variable xi buscando una coincidencia. Si
hay coincidencia, se sustituye con probabilidad p la subcadena de la ecuación
por la letra que representa dicha variable.
b) Si depués de recorrer la ecuación para cada variable ambos lados siguen siendo
iguales, sustituimos dicha ecuación por una nueva identidad sobre el alfabeto
A y volvemos al paso a).
De esta forma conseguimos que el sistema contenga exactamente n ecuaciones (con
ambos lados distintos).
En el apéndice C se encuentran algunos de los problemas que hemos generado con este
algoritmo. Además, en el apéndice B se encuentra el código del algoritmo Genero Problema
escrito en el lenguaje C++.
90

Capítulo 7
Primeros Resultados
Experimentales
7.1. Introducción
Cada experimento consistirá en la resolución, cincuenta veces, de un problema dado y
con unos parámetros fijos. Estos parámetros serán:
1. El tamaño de la población. (tp)
2. La longitud máxima de las variables (l). Así, cada individuo estará constituido por
subcadenas de longitud l sobre el alfabeto B.
3. El número máximo de evaluaciones a realizar en una ejecución. (NMax. Eval.)
4. La probabilidad de mutación. (Mutación)
5. La selección del método para la generación de la población inicial. (Método)
Nota 27
Con el fin de comparar los resultados obtenidos hemos acotado el número de evaluaciones
que puede realizar el algoritmo para resolver cada problema.
Llamaremos Media Eval. al número medio de evaluaciones que fueron necesarias para
encontrar solución en las pruebas exitosas de las cincuenta realizadas.
Llamaremos Éxito al número de veces que se encuentra solución para un problema. Se
expresará en tanto por cien.
91

7.2. Tamaño de Población
Nuestro primer objetivo es determinar el tamaño de población más adecuado para la
resolución de los diferentes problemas.
No sabemos nada acerca de cuál es la mejor probabilidad de mutación, así que hemos
decidido tomar 0,6. Acotamos el proceso con 150000 evaluaciones y tomamos l = 5.
Aprovecharemos también este experimento para establecer, si es posible, una diferencia
entre el método 1 y el método 2 usados para generar la población inicial.
Resolvemos el Problema15-12-4
Tamaño del espacio de búsqueda: aprox. 2 60
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 60 % 150000 22 % 106887
2 2 5 60 % 150000 34 % 107556
3 1 5 60 % 150000 12 % 108542
3 2 5 60 % 150000 6 % 109582
4 1 5 60 % 150000 2 % 88213
4 2 5 60 % 150000 0 % 0
6 1 5 60 % 150000 0 % 0
6 2 5 60 % 150000 0 % 0
8 1 5 60 % 150000 0 % 0
8 2 5 60 % 150000 0 % 0
10 1 5 60 % 150000 0 % 0
10 2 5 60 % 150000 0 % 0
Los mejores resultados obtenidos corresponden a tamaño de población igual a dos.
Además, no se observa una diferencia entre el método 1 y el método 2 que nos permita
decir que uno es mejor que el otro, al menos en este problema concreto.
Nota 28
Siempre encuentra la misma solución y la mayoría de las variables que la forman son la
cadena vacía, Λ.
92

Resolvemos el Problema25-8-5
Tamaño del espacio de búsqueda: aprox. 2 48
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 60 % 150000 88 % 27667.5
2 2 5 60 % 150000 94 % 22222.3
3 1 5 60 % 150000 86 % 23132.5
3 2 5 60 % 150000 74 % 29488.7
4 1 5 60 % 150000 70 % 26295.2
4 2 5 60 % 150000 70 % 23354.7
6 1 5 60 % 150000 62 % 48727
6 2 5 60 % 150000 64 % 48273.5
8 1 5 60 % 150000 62 % 65029.6
8 2 5 60 % 150000 56 % 75479.5
10 1 5 60 % 150000 40 % 87881.9
10 2 5 60 % 150000 32 % 95393.1
Otra vez los mejores resultados se obtienen para tamaño de población igual a dos.
Tampoco parece que sea determinante la elección del método que genera la población
inicial.
Los mejores resultados corresponden a
Nota 29
Usando el método 1
tp Exito Media Eval.
2 88 % 27667.5
3 86 % 23132.5
4 70 % 26295.2
Usando el método 2
tp Exito Media Eval.
2 94 % 22222.3
3 74 % 29488.7
4 70 % 23354.7
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
93

Resolvemos el Problema10-3-3
Tamaño del espacio de búsqueda: aprox. 2 12
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 60 % 150000 100 % 278.08
2 2 5 60 % 150000 100 % 223.78
3 1 5 60 % 150000 100 % 345.96
3 2 5 60 % 150000 100 % 282.84
4 1 5 60 % 150000 100 % 332.08
4 2 5 60 % 150000 100 % 407.8
6 1 5 60 % 150000 100 % 649.7
6 2 5 60 % 150000 100 % 615.6
8 1 5 60 % 150000 100 % 845.9
8 2 5 60 % 150000 100 % 757.98
10 1 5 60 % 150000 100 % 1033.48
10 2 5 60 % 150000 100 % 1261.54
Problema aparentemente sencillo que nos permite comprobar que mayor tamaño de
población no mejora los resultados pero sí produce un aumento en el número de evalua-
ciones, por ejemplo, pasamos de 1261 evaluaciones para una población tp = 10 a tan sólo
223 evaluaciones para una población tp = 2.
Parece que el método 2 reduce el número de evaluaciones pero no es una diferencia lo
suficientemente grande como para decantarnos por este método en lugar del método 1.
Los mejores resultados corresponden a
Nota 30
Usando el método 1
tp Exito Media Eval.
2 100 % 278.08
4 100 % 332.08
3 100 % 345.96
Usando el método 2
tp Exito Media Eval.
2 100 % 223.78
3 100 % 282.84
4 100 % 407.8
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
94

Resolvemos el Problema10-5-2
Tamaño del espacio de búsqueda: aprox. 2 15
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 60 % 150000 100 % 1118.56
2 2 5 60 % 150000 100 % 1323.76
3 1 5 60 % 150000 100 % 2261.4
3 2 5 60 % 150000 100 % 2412.48
4 1 5 60 % 150000 100 % 4590.82
4 2 5 60 % 150000 100 % 4229.5
6 1 5 60 % 150000 100 % 13627.5
6 2 5 60 % 150000 100 % 16416.7
8 1 5 60 % 150000 100 % 27001.4
8 2 5 60 % 150000 100 % 31674.5
10 1 5 60 % 150000 100 % 36888.2
10 2 5 60 % 150000 100 % 47870.9
Como en el problema anterior, el algoritmo ha encontrado solución en todas las oca-
siones pero el número de evaluaciones ha ido creciendo a medida que hemos aumentado
el tamaño de la población. Y este aumento es considerable, pues hemos pasado de 2261.4
evaluaciones con una población tp = 3 a 36888.2 evaluaciones con una población tp = 10.
Respecto a la elección del método para la generación de la población inicial nos encon-
tramos en la misma situación del problema10-3-3.
Los mejores resultados corresponden a
Nota 31
Usando el método 1
tp Exito Media Eval.
2 100 % 1118.56
3 100 % 2261.4
4 100 % 4590.82
Usando el método 2
tp Exito Media Eval.
2 100 % 1323.76
3 100 % 2412.48
4 100 % 4229.5
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
95

Resolvemos el Problema12-6-4
Tamaño del espacio de búsqueda: aprox. 2 30
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 60 % 150000 100 % 706.18
2 2 5 60 % 150000 100 % 702.72
3 1 5 60 % 150000 100 % 1089.4
3 2 5 60 % 150000 100 % 1080.08
4 1 5 60 % 150000 100 % 2279.8
4 2 5 60 % 150000 100 % 2313.4
6 1 5 60 % 150000 100 % 5529.3
6 2 5 60 % 150000 100 % 6020.5
8 1 5 60 % 150000 100 % 9966.48
8 2 5 60 % 150000 100 % 10437
10 1 5 60 % 150000 100 % 15989.1
10 2 5 60 % 150000 100 % 17786.8
Como en los dos casos anteriores el problema12-6-4 ha resultado ser sencillo y el número
de evaluaciones aumenta a medida que crece el tamaño de la población.
Los mejores resultados corresponden a
Nota 32
Usando el método 1
tp Exito Media Eval.
2 100 % 706.18
3 100 % 1089.4
4 100 % 2279.8
Encuentra distintas soluciones.
96
Usando el método 2
tp Exito Media Eval.
2 100 % 702.72
3 100 % 1080.08
4 100 % 2313.4

Resolvemos el Problema5-3-2
Tamaño del espacio de búsqueda: aprox. 2 9
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 60 % 150000 100 % 338.6
2 2 5 60 % 150000 100 % 611.4
3 1 5 60 % 150000 100 % 622.68
3 2 5 60 % 150000 100 % 890.12
4 1 5 60 % 150000 100 % 858.7
4 2 5 60 % 150000 100 % 1664.44
6 1 5 60 % 150000 100 % 1487
6 2 5 60 % 150000 100 % 2822.7
8 1 5 60 % 150000 100 % 3280.5
8 2 5 60 % 150000 100 % 5467.16
10 1 5 60 % 150000 100 % 4207.6
10 2 5 60 % 150000 100 % 6347.44
Otra vez el número de evaluaciones aumenta a medida que crece el tamaño de la
población.
En esta ocasión si existe una diferencia clara entre los dos métodos propuestos para
generar la población inicial, llegando a ser de casi la mitad de evaluaciones con el método
1.
Los mejores resultados corresponden a
Nota 33
Usando el método 1
tp Exito Media Eval.
2 100 % 338.6
3 100 % 622.68
4 100 % 858.7
Usando el método 2
tp Exito Media Eval.
2 100 % 611.4
3 100 % 890.12
4 100 % 1664.44
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
97

Conclusión 1
Después de este primer contacto con el algoritmo genético resulta evidente que el tamaño
de población más adecuado es tp = 2 pues a medida que crece el número de individuos de
la población disminuye la probabilidad de éxito y aumenta el número de evaluaciones.
Sin embargo, no estamos en condiciones de afirmar que uno de los dos métodos propues-
tos para la generación de la población inicial sea mejor que el otro. Por eso, seguiremos
realizando los experimentos con los dos métodos.
Resumen de los mejores resultados obtenidos:
Nota 34
Problema Esp. Búsq. tp Exito Media Eval. Método
15-12-4 2 60 2 34 % 107556 2
25-8-5 2 48 2 94 % 22222.3 2
10-3-3 2 12 2 100 % 223.78 2
10-5-2 2 15 2 100 % 1118.56 1
12-6-4 2 30 2 100 % 702.72 2
5-3-2 2 9 2 100 % 338.6 1
En los sucesivos experimentos tomaremos siempre tamaño de población tp = 2 y acotare-
mos los procesos por 1.5 millones de evaluaciones.
98

7.3. Probabilidad de mutación
Nuestro segundo objetivo es determinar los valores de la probabilidad de mutación
más adecuados para la resolución de los problemas l SW ES. Para ello, fijamos todos los
parámetros excepto la mutación que irá variando desde el 20 % al 100 %.
Resolvemos el Problema10-15-5
Tamaño del espacio de búsqueda: aprox. 2 90
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 20 % 1.5e+06 0 % 0
2 2 5 20 % 1.5e+06 0 % 0
2 1 5 40 % 1.5e+06 2 % 1.06558e+06
2 2 5 40 % 1.5e+06 0 % 0
2 1 5 70 % 1.5e+06 0 % 0
2 2 5 70 % 1.5e+06 2 % 1.12725e+06
2 1 5 80 % 1.5e+06 2 % 1.37572e+06
2 2 5 80 % 1.5e+06 0 % 0
2 1 5 90 % 1.5e+06 2 % 801145
2 2 5 90 % 1.5e+06 2 % 1.0302e+06
2 1 5 100 % 1.5e+06 4 % 1.04644e+06
2 2 5 100 % 1.5e+06 2 % 253817
Los mejores resultados se obtienen para
Nota 35
Usando el método 1
Mutación Exito Media Eval.
100 % 4 % 1.04644e+06
90 % 2 % 801145
Usando el método 2
Mutación Exito Media Eval.
100 % 2 % 253817
90 % 2 % 1.0302e+06
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
99

Resolvemos el Problema10-5-1
Tamaño del espacio de búsqueda: aprox. 2 10
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 20 % 1.5e+06 100 % 22751.7
2 2 5 20 % 1.5e+06 100 % 41875.7
2 1 5 40 % 1.5e+06 100 % 11364.6
2 2 5 40 % 1.5e+06 100 % 17492.3
2 1 5 70 % 1.5e+06 100 % 7952.02
2 2 5 70 % 1.5e+06 100 % 7800.06
2 1 5 80 % 1.5e+06 100 % 7923.1
2 2 5 80 % 1.5e+06 100 % 8119.02
2 1 5 90 % 1.5e+06 100 % 8101.9
2 2 5 90 % 1.5e+06 100 % 6422.6
2 1 5 100 % 1.5e+06 100 % 5594.96
2 2 5 100 % 1.5e+06 100 % 5600.88
Los mejores resultados se obtienen para
Usando el método 1
Mutación Exito Media Eval.
100 % 100 % 5594.96
80 % 100 % 7923.1
Usando el método 2
Mutación Exito Media Eval.
100 % 100 % 5600
90 % 100 % 6422.6
Aunque el algoritmo siempre encuentra solución, el número de evaluaciones disminuye
considerablemente para valores de la probabilidad de mutación altos.
Nota 36
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
100

Resolvemos el Problema10-8-5
Tamaño del espacio de búsqueda: aprox. 2 48
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 20 % 1.5e+06 98 % 381874
2 2 5 20 % 1.5e+06 94 % 304587
2 1 5 40 % 1.5e+06 98 % 203427
2 2 5 40 % 1.5e+06 100 % 180120
2 1 5 70 % 1.5e+06 100 % 129486
2 2 5 70 % 1.5e+06 100 % 179024
2 1 5 80 % 1.5e+06 100 % 134950
2 2 5 80 % 1.5e+06 100 % 114512
2 1 5 90 % 1.5e+06 98 % 90263.3
2 2 5 90 % 1.5e+06 100 % 93544.5
2 1 5 100 % 1.5e+06 100 % 86991.9
2 2 5 100 % 1.5e+06 100 % 73362.4
Los mejores resultados se obtienen para
Usando el método 1
Mutación Exito Media Eval.
100 % 100 % 86991.9
70 % 100 % 129486
Usando el método 2
Mutación Exito Media Eval.
100 % 100 % 73362.4
90 % 100 % 93544.5
En esta ocasión, los valores de la probabilidad de mutación hacen que el algoritmo no
siempre encuentre solución y además aumentan el número de evaluaciones.
Nota 37
Encuentra distintas soluciones.
Una de las variables del problema puede tomar distintos valores, el resto de las variables
siempre toman el mismo valor.
101

Resolvemos el Problema25-8-3
Tamaño del espacio de búsqueda: aprox. 2 32
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 20 % 1.5e+06 100 % 117905
2 2 5 20 % 1.5e+06 100 % 121339
2 1 5 40 % 1.5e+06 100 % 47327.7
2 2 5 40 % 1.5e+06 100 % 60389.5
2 1 5 70 % 1.5e+06 100 % 41581.5
2 2 5 70 % 1.5e+06 100 % 32645.8
2 1 5 80 % 1.5e+06 100 % 31538.3
2 2 5 80 % 1.5e+06 100 % 44212.9
2 1 5 90 % 1.5e+06 100 % 31687.5
2 2 5 90 % 1.5e+06 100 % 28286.8
2 1 5 100 % 1.5e+06 100 % 26726.1
2 2 5 100 % 1.5e+06 100 % 32858.1
Los mejores resultados se obtienen para
Usando el método 1
Mutación Exito Media Eval.
100 % 100 % 26726.1
80 % 100 % 31538.3
Usando el método 2
Mutación Exito Media Eval.
90 % 100 % 28286.8
70 % 100 % 32645.8
Aunque siempre encuentra solución, el número de evaluaciones que fueron necesarias
para encontrar solución disminuye para valores de la probabilidad de mutación entre el
70 % y el 100 %.
Nota 38
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
102

Resolvemos el Problema25-8-5
Tamaño del espacio de búsqueda: aprox. 2 48
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 20 % 1.5e+06 100 % 140364
2 2 5 20 % 1.5e+06 100 % 98455.6
2 1 5 40 % 1.5e+06 100 % 57316.9
2 2 5 40 % 1.5e+06 100 % 79764.9
2 1 5 70 % 1.5e+06 100 % 26307.5
2 2 5 70 % 1.5e+06 100 % 36819.7
2 1 5 80 % 1.5e+06 100 % 32292.8
2 2 5 80 % 1.5e+06 100 % 30747.8
2 1 5 90 % 1.5e+06 100 % 20602.3
2 2 5 90 % 1.5e+06 100 % 34846.2
2 1 5 100 % 1.5e+06 100 % 35748.3
2 2 5 100 % 1.5e+06 100 % 29859.6
Los mejores resultados se obtienen para
Usando el método 1
Mutación Exito Media Eval.
90 % 100 % 20602.3
70 % 100 % 26307.5
Usando el método 2
Mutación Exito Media Eval.
100 % 100 % 29859.6
80 % 100 % 30747.8
De nuevo, el éxito es del 100 % para todos los experimentos realizados con este prob-
lema, pero el número de evaluaciones mejora para valores de la probabilidad de mutación
entre el 70 % y el 100 %.
Nota 39
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
103

Resolvemos el Problema5-15-3
Tamaño del espacio de búsqueda: aprox. 2 60
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 20 % 1.5e+06 4 % 881354
2 2 5 20 % 1.5e+06 0 % 0
2 1 5 40 % 1.5e+06 4 % 750816
2 2 5 40 % 1.5e+06 0 % 0
2 1 5 70 % 1.5e+06 2 % 91868
2 2 5 70 % 1.5e+06 10 % 273665
2 1 5 80 % 1.5e+06 8 % 681722
2 2 5 80 % 1.5e+06 0 % 0
2 1 5 90 % 1.5e+06 2 % 374402
2 2 5 90 % 1.5e+06 10 % 511213
2 1 5 100 % 1.5e+06 10 % 743411
2 2 5 100 % 1.5e+06 4 % 1.00708e+06
Los mejores resultados se obtienen para
Usando el método 1
Mutación Exito Media Eval.
100 % 10 % 743411
80 % 8 % 681722
Usando el método 2
Mutación Exito Media Eval.
70 % 10 % 273665
90 % 10 % 511213
El algoritmo genético simple no siempre encuentra solución. Notar que el tamaño del
espacio de búsqueda es de aprox. 2 60 . A pesar de ello, los valores de probabilidad de
mutación entre el 70 % y el 100 % proporcionan los mejores resultados.
Nota 40
Encuentra distintas soluciones.
La gran mayoría de las variables, aproximádamente 10 de las 15, pueden tomar distintos
valores.
104

Resolvemos el Problema15-12-4
Tamaño del espacio de búsqueda: aprox. 2 60
tp Método l Mutación NMax Eval. Exito Media Eval.
2 1 5 20 % 1.5e+06 76 % 638268
2 2 5 20 % 1.5e+06 80 % 658522
2 1 5 40 % 1.5e+06 84 % 386301
2 2 5 40 % 1.5e+06 86 % 496717
2 1 5 70 % 1.5e+06 96 % 324814
2 2 5 70 % 1.5e+06 98 % 313743
2 1 5 80 % 1.5e+06 92 % 277741
2 2 5 80 % 1.5e+06 98 % 288551
2 1 5 90 % 1.5e+06 100 % 263719
2 2 5 90 % 1.5e+06 100 % 204263
2 1 5 100 % 1.5e+06 98 % 295557
2 2 5 100 % 1.5e+06 96 % 255491
Los mejores resultados se obtienen para
Usando el método 1
Mutación Exito Media Eval.
90 % 100 % 263719
100 % 98 % 295557
Usando el método 2
Mutación Exito Media Eval.
90 % 100 % 204263
80 % 98 % 288551
Podemos observar que los valores de probabilidad de mutación entre el 80 % y el 100 %
no sólo mejoran el éxito sino que también reducen el número de evaluaciones necesarias
para encontrar solución.
Nota 41
Siempre encuentra la misma solución y coincide con la propuesta por Genero Problema.
La mayoría de las variables son la cadena vacia, Λ.
105

Conclusión 2
Resumen de los mejores resultados obtenidos:
Usando el método 1
Problema Esp. Búsq. Mutación Exito Media Eval.
10-15-5 2 90 100 % 4 % 1.04644e+06
10-5-1 2 10 100 % 100 % 5594.96
10-8-5 2 48 100 % 100 % 86991.9
25-8-3 2 32 100 % 100 % 26726.1
25-8-5 2 48 90 % 100 % 20602.3
5-15-3 2 60 100 % 10 % 743411
15-12-4 2 60 90 % 100 % 263719
Usando el método 2
Problema Esp. Búsq. Mutación Exito Media Eval.
10-15-5 2 90 100 % 2 % 253817
10-5-1 2 10 100 % 100 % 5600
10-8-5 2 48 100 % 100 % 73362.4
25-8-3 2 32 90 % 100 % 28286.8
25-8-5 2 48 100 % 100 % 29859.6
5-15-3 2 60 70 % 10 % 273665
15-12-4 2 60 90 % 100 % 204263
Se de duce que los mejores resultados se obtienen con una probabilidad de mutación
comprendida entre el 70 % y el 100 %.
Aunque puede parecer que la probabilidad de mutación es muy alta, hemos obtenido
valores similares a los propuestos en la resolución de los problemas SAT , que en definitiva
es nuestra única referencia.
106

Capítulo 8
Algoritmos Evolutivos para
Resolver l SW ES
A partir del algoritmo genético simple, definido en el capítulo 5, vamos a construir dos
algoritmos evolutivos.
La codificación de los individuos, la generación de la población inicial, el fitness y
los operadores genéticos se definen de la misma forma. Además, seguiremos acotando la
resolución de los problemas por 1,5 millones de evaluaciones y buscaremos soluciones cuyas
variables sean de longitud menor o igual que cinco.
8.1. A.E. Sólo Mutación
Como consecuencia de los primeros resultados experimentales, el alto valor que toma
la probabilidad de mutación y teniendo en cuenta los algoritmos evolutivos que fueron
propuestos para resolver SAT (ver capítulo 2), resulta interesante modificar nuestro al-
goritmo genético para obtener un algoritmo evolutivo que trabaje con una población de
tamaño tp = 1.
Este algoritmo evolutivo usará sólo el operador genético de mutación.
Si los resultados que proporcionan este algoritmo mejoran los del algoritmo genético
simple, seguiremos nuestro estudio con este nuevo algoritmo o bien intentaremos modificar
el operador de cruce para mejorar el algoritmo genético simple.
El esquema de funcionamiento de este algoritmo es el siguiente
107

Seudocódigo
I0 ← generar población inicial
I0 ← evaluar (I0)
para k = 1 hasta NIter hacer
fin para
I1 ← copiar (I0)
I1 ← mutar (I1)
E1 ← evaluar (I1)
I0 ← mejor individuo (I0 , I1)
En el apéndice D se encuentra este algoritmo escrito en C++.
En las siguientes tablas comparamos los resultados obtenidos al resolver un mismo
problema l SW ES con el algoritmo genético simple (AGS) y con este nuevo algoritmo
evolutivo (AE).
Usando el método 1 para generar la población inicial se obtuvo
Problema Esp. Búsq. Exito(AGS) Exito(AE) Eval.(AGS) Eval.(AE)
10-5-1 2 10 100 % 100 % 5594.96 5599.28
10-8-5 2 48 100 % 78 % 86991.9 366416
25-8-3 2 32 100 % 88 % 26726.1 293262
25-8-5 2 48 100 % 66 % 35748.3 39866
5-15-3 2 60 10 % 6 % 743411 461058
15-12-4 2 60 98 % 100 % 263719 203817
Usando el método 2 para generar la población inicial se obtuvo
Problema Esp. Búsq. Exito(AGS) Exito(AE) Eval.(AGS) Eval.(AE)
10-5-1 2 10 100 % 100 % 5600 5155.18
10-8-5 2 48 100 % 66 % 73362.4 405752
25-8-3 2 32 100 % 88 % 32858.1 385027
25-8-5 2 48 100 % 60 % 29859.6 14243.1
5-15-3 2 60 4 % 0 % 1.00708e+06 0
15-12-4 2 60 96 % 100 % 255491 250908
108

Resulta evidente que el AE no mejora los resultados obtenidos con el AGS. Por lo
tanto, el operador de cruce que hemos definido tiene influencia en la resolución de los
sistemas.
8.2. A.E. Búsqueda Local
Añadimos al algoritmo genético simple un proceso de búsqueda local que se aplicará a
cada individuo de las sucesivas poblaciones generadas, con el fin de mejorar (localmente)
el fitness de dichos individuos.
Para la implementación de este proceso definimos dos métodos:
Búsqueda Local 1
Dado un individuo I = α1 · · · αm, cualquiera. Se realizan dos etapas:
1. Cada subcadena αi, para i = 1, . . . , m, se somete a un proceso de busqueda local
clásico que afecta unicamente a las cadena βi, para i = 1, . . . , m. (Recordar que
αi = βi ¯ βi siendo βi ∈ A ∗ y ¯ βi ∈ {B} ∗ )
Este proceso consiste en recorrer de izquierda a derecha los símbolos de las
cadenas βi, para i = 1, . . . , m, cambiando cada símbolo, es decir, se pasa de
cero a uno o viceversa. Cada vez que se cambia un símbolo se evalua el nuevo
individuo y nos quedamos con el mejor, es decir, si al cambiar un símbolo de una
de las cadenas βi el fitness del nuevo individuo mejora o iguala al del individuo
anterior, entonces nos quedamos con el nuevo y pasamos a cambiar el siguiente
símbolo situado más a la derecha (que pertenezca a una cadena βi). Pero si
el fitness del individuo no mejora al cambiar un símbolo, entonces se recupera
el símbolo original y se pasa al siguiente. De esta forma, se recorren todos los
símbolos de βi, para i = 1, . . . , m y se cambiando aquellos símbolos que mejoren
el fitness del individuo.
Si al final de este proceso el fitness del individuo ha mejorado, entonces volvemos
a aplicar la búsqueda local clásica a las nuevas cadenas βi.
2. Cuando la búsqueda local clásica no permite mejorar el fitness del individuo
I = α1 · · · , αm, se aplica una búsqueda local que permite modificar en una
unidad la longitud de las cadenas βi, para i = 1, . . . , m.
109

Notar que hasta ahora lo único que hacíamos era cambiar los símbolos, pasando
de cero a uno o viceversa, pero la longitud de las cadenas βi, para i = 1, . . . , m
no cambiaba.
Para modificar la longitud de la cadena βi, para i = 1, . . . , m en una unidad,
procedemos como sigue:
a) Disminuimos en una unidad la longitud de βi convirtiendo el último símbolo
de esta cadena en un símbolo blanco, de modo que la longitud de la cadena
¯βi aumenta una unidad.
Ejemplo 44
Sea βi ¯ βi = 0010BBB con |βi| = 4 y | ¯ βi| = 3.
Al disminuir la longitud de βi en una unidad se obtiene
siendo ahora |βi| = 3 y | ¯ βi| = 4.
βi ¯ βi = 001BBBB
b) Aumentamos en una unidad la longitud de la cadena βi convirtiendo el
primer símbolo blanco de la cadena ¯ βi en un símbolo del alfabeto A, de
modo que la longitud de ¯ βi disminuye en una unidad.
Como A = {0, 1}, tenemos dos posibilidades para aumentar la longitud de
βi:
1) convertir en un cero el primer símbolo blanco de ¯ βi,
2) convertir en uno el primer símbolo blanco de ¯ βi.
Ejemplo 45
Sea βi ¯ βi = 0010BBB con |βi| = 4 y | ¯ βi| = 3.
Al aumentar la longitud de βi en una unidad se obtiene dos cadenas
siendo ahora |βi| = 5 y | ¯ βi| = 2.
00100BB
00101BB
Luego, para cadena αi obtenemos tres posibilidades al modificar en una unidad
la longitud de βi, si alguna de estas nuevas cadenas mejora el fitness del indi-
viduo, entonces αi es sustituida por la nueva cadena.
110

Búsqueda Local 2
Nota 42
Cuando terminamos de modificar las longitudes de todas las cadenas βi en bus-
ca de un individuo mejor, comprobamos si el fitness ha mejorado, en ese caso
se vuelve a el paso 1. Si no hay mejora, se termina el proceso de búsqueda local
1 aplicado al individuo I.
Dado un individuo I = α1 · · · αm, cualquiera.
A cada subcadena αi, se le aplica el proceso de búsqueda local clásica (que afecta
unicamente a la cadena βi) y después se le aplica el proceso de búsqueda local que
permite modificar en una unidad la longitud de βi, tomando aquella que mejore el
fitness del individuo.
Una vez que hemos aplicado estos dos procesos a todas las subcadenas αi del indi-
viduo I, si el fitness del individuo ha mejorado volvemos a repetir el proceso. En
otro caso, la búsqueda local 2 aplicada al individuo I finaliza.
Observese que aunque ambos procedimientos de búsqueda local puedan parecer iguales,
hay una importante diferencia:
mientras que en el proceso de búsqueda local 1 realizamos sucesivas veces (hasta que no
se produzca mejora) lo que hemos denominado búsqueda local clásica antes de tratar de
modificar las longitudes, en el proceso de búsqueda local 2 realizamos en cada iteración
una vez la búsqueda local clásica seguida de una posible modificación en una unidad de
las longitudes.
8.3. Resultados experimentales
Hasta ahora hemos resuelto los problemas con ayuda de un algoritmo genético simple.
En esta sección vamos a estudiar los resultados obtenidos al añadir búsqueda local.
Se intentará establecer, si fuese posible, cuál de los dos métodos implementados para
el proceso de búsqueda local es mejor.
También resultará interesante determinar si la mutación sigue siendo importante cuan-
do se usa búsqueda local. Para ello iremos tomando distintos valores de probabilidad de
mutación.
111

Finalmente, compararemos los resultados obtenidos al aplicar un algoritmo genético
simple para resolver los problemas l SW ES y los resultados obtenidos al utilizar un A.E.
con búsqueda local.
Para poder comparar los resultados seguimos manteniendo tamaño de pobalción tp = 2,
longitud máxima de las variables que forman los individuos igual a 5 y acotamos la ejecu-
ción del algoritmo por 1.5 millones de evaluaciones.
Resolvemos el Problema10-3-3
Tamaño del espacio de búsqueda: aprox. 2 18
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 85.34 100 % 50.9
2 5 70 % 100 % 79.94 100 % 50.26
2 5 90 % 100 % 77.1 100 % 50.26
2 5 100 % 100 % 77.1 100 % 50.26
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 90.06 100 % 44.06
2 5 70 % 100 % 73.72 100 % 46.9
2 5 90 % 100 % 75.96 100 % 50.32
2 5 100 % 100 % 75.96 100 % 50.32
Parece que la probabilidad de mutación no influye sobre los resultados. Sin embargo,
si queda reflejado la superioridad de la búsqueda local 2 frente a la 1.
Nota 43
Siempre encuentra la misma solución.
112

Resolvemos el Problema10-8-5
Tamaño del espacio de búsqueda: aprox. 2 48
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 26705.3 100 % 19301.1
2 5 70 % 100 % 15371.6 100 % 10368.7
2 5 90 % 100 % 15947.3 100 % 10164.8
2 5 100 % 100 % 16017.8 100 % 8220.76
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 27036.5 100 % 21981.9
2 5 70 % 100 % 16879.7 100 % 12433.7
2 5 90 % 100 % 15947.3 100 % 9702.92
2 5 100 % 100 % 15585 100 % 9629.52
Se observa que la búsqueda local 2 reduce el número de evaluaciones. Además, a medida
que aumenta la probabilidad de mutación disminuye el número de evaluaciones.
Los mejores resultados se obtienen para
Usando el método 1
Búsq. L. Mut. Exito Media Eval.
Nota 44
2 100 % 100 % 8220.76
2 90 % 100 % 10164.8
Admite distintas soluciones.
Usando el método 2
Búsq. L. Mut. Exito Media Eval.
2 100 % 100 % 9629.52
2 90 % 100 % 9702.92
Una de las variables del problema puede tomar distintos valores, el resto de las variables
siempre toman el mismo valor.
113

Resolvemos el Problema10-8-3
Tamaño del espacio de búsqueda: aprox. 2 48
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 35040.2 100 % 22728.9
2 5 70 % 100 % 19519.9 100 % 16844.7
2 5 90 % 100 % 23727.3 100 % 20473.6
2 5 100 % 100 % 22740 100 % 16484.9
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 49985.8 100 % 28200.4
2 5 70 % 100 % 24295.2 100 % 22562
2 5 90 % 100 % 27747.4 100 % 18935.5
2 5 100 % 100 % 31129.4 100 % 16596.1
De nuevo hay que destacar la diferencia que existe entre los métodos de búsqueda local
implementados.
Los mejores resultados se obtienen para
Usando el método 1
Búsq. L. Mut. Exito Media Eval.
Nota 45
2 100 % 100 % 16484.9
2 70 % 100 % 16844.7
Siempre encuentra la misma solución.
Usando el método 2
Búsq. L. Mutación Exito Media Eval.
114
2 100 % 100 % 16596.1
2 90 % 100 % 18935.5

Resolvemos el Problema10-15-5
Tamaño del espacio de búsqueda: aprox. 2 90
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 484850 100 % 593998
2 5 70 % 100 % 474252 100 % 288598
2 5 90 % 100 % 182997 100 % 104509
2 5 100 % 100 % 457354 100 % 340361
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 831604 100 % 646195
2 5 70 % 100 % 589418 100 % 338841
2 5 90 % 100 % 472892 100 % 362079
2 5 100 % 100 % 499089 100 % 340070
En este caso podemos observar que no siempre la mejor probabilidad de mutación es
el 100 %, pues aunque siempre se encuentra solución el número de evaluaciones necesarias
varía.
Los mejores resultados se obtienen para
Usando el método 1
Búsq. L. Mut. Exito Media Eval.
Nota 46
2 90 % 100 % 104509
1 90 % 100 % 182997
Siempre encuentra la misma solución.
115
Usando el método 2
Búsq. L. Mut. Exito Media Eval.
2 70 % 100 % 338841
2 100 % 100 % 340070

Resolvemos el Problema10-15-3
Tamaño del espacio de búsqueda: aprox. 2 90
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 44 % 611542 76 % 338663
2 5 70 % 50 % 652274 94 % 327947
2 5 90 % 68 % 642407 98 % 362663
2 5 100 % 56 % 583024 92 % 264417
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 38 % 646377 72 % 614781
2 5 70 % 48 % 616960 94 % 424924
2 5 90 % 34 % 643584 86 % 401649
2 5 100 % 64 % 573071 92 % 413873
Como en todos los problemas anteriores la búsqueda local 2 es más efectiva.
Los mejores resultados se obtienen para
Usando el método 1
Búsq. L. Mut. Exito Media Eval.
Nota 47
2 90 % 98 % 362663
2 70 % 94 % 327947
Admite distintas soluciones.
Usando el método 2
Búsq. L. Mut. Exito Media Eval.
2 70 % 94 % 424924
2 100 % 92 % 413873
Existen dos variables del problema que puede tomar distintos valores, el resto de las
variables siempre toman el mismo valor.
116

Resolvemos el Problema15-12-4
Tamaño del espacio de búsqueda: aprox. 2 72
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 1676.5 100 % 1187.36
2 5 70 % 100 % 1377.96 100 % 1154.76
2 5 90 % 100 % 1484.46 100 % 860.82
2 5 100 % 100 % 1254.8 100 % 1058.64
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 2289.98 100 % 1729.18
2 5 70 % 100 % 1988.92 100 % 1456.82
2 5 90 % 100 % 2110.4 100 % 1395.68
2 5 100 % 100 % 2032.8 100 % 1431.26
La búsqueda local resulta ser un proceso tan potente que permite en muchas ocasiones
encontrar solución aplicandolo unicamente a la población inicial, es decir, no se llega a
usar el algoritmo genético simple.
Los mejores resultados se obtienen para
Usando el método 1
Búsq. L. Mut. Exito Media Eval.
Nota 48
2 90 % 100 % 860.82
2 100 % 100 % 1058.64
Siempre encuentra la misma solución.
La mayoría de las variables son la cadena vacia, Λ.
117
Usando el método 2
Búsq. L. Mut. Exito Media Eval.
2 90 % 100 % 1395.68
2 100 % 100 % 1431.26

Resolvemos el Problema15-7-5
Tamaño del espacio de búsqueda: aprox. 2 42
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 225.48 100 % 226.56
2 5 70 % 100 % 225.48 100 % 225.26
2 5 90 % 100 % 290.3 100 % 216.64
2 5 100 % 100 % 290.3 100 % 225.64
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 354.9 100 % 374.8
2 5 70 % 100 % 402.16 100 % 268.84
2 5 90 % 100 % 347.18 100 % 322.48
2 5 100 % 100 % 341.42 100 % 255.94
En la mayoría de los casos la búsqueda local aplicada a la población inicial es sufi-
ciente para encontrar la solución del problema, sólo en algunos casos necesita unas pocas
iteraciones del algoritmo genético para encontrarla. Por eso no existe diferencia entre los
resultados obtenidos para las distintas probabilidades de mutación.
Nota 49
Admite distintas soluciones.
Existen dos variables del problema que puede tomar distintos valores, el resto de las
variables siempre toman el mismo valor.
118

Resolvemos el Problema25-8-3
Tamaño del espacio de búsqueda: aprox. 2 48
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 2938.72 100 % 2336.18
2 5 70 % 100 % 1748.66 100 % 1525.2
2 5 90 % 100 % 1280.28 100 % 1405.06
2 5 100 % 100 % 1839.48 100 % 1054.16
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 3599.8 100 % 3011.56
2 5 70 % 100 % 2282.54 100 % 1665.56
2 5 90 % 100 % 2487.56 100 % 1630.5
2 5 100 % 100 % 2375.56 100 % 2222.46
Los mejores resultados se obtienen para
Usando el método 1
Búsq. L. Mut. Exito Media Eval.
Nota 50
2 100 % 100 % 1054.16
1 90 % 100 % 1280.28
Siempre encuentra la misma solución.
119
Usando el método 2
Búsq. L. Mut. Exito Media Eval.
2 90 % 100 % 1630.5
2 70 % 100 % 1665.56

Resolvemos el Problema25-8-5
Tamaño del espacio de búsqueda: aprox. 2 48
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 4674.82 100 % 2522.74
2 5 70 % 100 % 2782.76 100 % 1517.26
2 5 90 % 100 % 3174.1 100 % 1407.38
2 5 100 % 100 % 2613.64 100 % 1189.84
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 100 % 3502.56 100 % 1710.58
2 5 70 % 100 % 2591.5 100 % 1244
2 5 90 % 100 % 2788.2 100 % 1145.1
2 5 100 % 100 % 2468.54 100 % 1165.28
Destacar de nuevo la diferencia entre el número de evaluaciones necesarias para encon-
trar solución usando los distintos métodos de búsqueda local.
Los mejores resultados se obtienen para
Usando el método 1
Búsq. L. Mut. Exito Media Eval.
Nota 51
2 100 % 100 % 1189.84
2 90 % 90 % 1407.38
Siempre encuentra la misma solución.
120
Usando el método 2
Búsq. L. Mut. Exito Media Eval.
2 90 % 100 % 1145.1
2 100 % 100 % 1165.28

Resolvemos el Problema5-15-3
Tamaño del espacio de búsqueda: aprox. 2 90
Usando el método 1 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 94 % 535684 88 % 311136
2 5 70 % 96 % 299938 96 % 171128
2 5 90 % 94 % 246925 100 % 192842
2 5 100 % 94 % 317776 98 % 246269
Usando el método 2 para generar la población inicial se obtuvo
Búsq. Local 1 Búsq. Local 2
tp l Mutación Exito Media Eval. Exito Media Eval.
2 5 20 % 62 % 541543 96 % 391371
2 5 70 % 94 % 415857 94 % 284990
2 5 90 % 88 % 341641 94 % 222077
2 5 100 % 92 % 316503 96 % 218227
En este problema, la búsqueda local 2 no sólo mejora el número de evaluaciones sino
que aumenta la probabilidad de éxito, es decir, de encontrar solución.
Los mejores resultados se obtienen para
Usando el método 1
Búsq. L. Mut. Exito Media Eval.
Nota 52
2 90 % 100 % 192842
2 100 % 98 % 246269
Admite distintas soluciones.
121
Usando el método 2
Búsq. L. Mut. Exito Media Eval.
2 100 % 96 % 218227
2 20 % 96 % 391371

Conclusión 3
Resumen de los mejores resultados obtenidos:
Usando el método 1
Problema Búsq. L. Mutación Exito Media Eval.
10-8-5 2 100 % 100 % 8220.76
10-8-3 2 100 % 100 % 16484.9
10-3-3 2 — 100 % 50.26
10-15-5 2 90 % 100 % 104509
10-15-3 2 90 % 98 % 362663
15-12-4 2 90 % 100 % 860.82
15-7-5 2 — 100 % 216.64
25-8-3 2 100 % 100 % 1054.16
25-8-5 2 100 % 100 % 1189.84
5-15-3 2 90 % 100 % 192842
Usando el método 2
Problema Búsq. L. Mutación Exito Media Eval.
10-8-5 2 100 % 100 % 9629.52
10-8-3 2 100 % 100 % 16596.1
10-3-3 2 — 100 % 44.06
10-15-5 2 70 % 100 % 338841
10-15-3 2 70 % 94 % 424924
15-12-4 2 90 % 100 % 1395.68
15-7-5 2 — 100 % 255.94
25-8-3 2 90 % 100 % 1630.5
25-8-5 2 90 % 100 % 1145.1
5-15-3 2 100 % 96 % 218227
Estamos en condiciones de afirmar que la búsqueda local 2 es más efectiva que la 1
y que la probabilidad de mutación sigue siendo una etapa del proceso importante en la
resolución de los problemas.
122

Hemos podido obsevar que la búsqueda local resulta decisiva en la primera etapa, cuan-
do se genera la población inicial. Antes de empezar a trabajar con el algoritmo genético,
la población inicial es sometida a un proceso de búsqueda local y, como consecuencia,
esta población experimenta una mejora considerable. Pero, una vez iniciado el algoritmo
genético, el efecto que tiene la búsqueda local sobre las nuevas poblaciones generadas no es
significativo. Por ese motivo, creemos que es importante mantener valores de probabilidad
de mutación entre 70 % y el 100 %.
Para concluir esta sección comparamos algunos de los resultados obtenidos al aplicar
el algoritmo genético simple (AGS) y el algoritmo genético con búsqueda local (AE).
Como ya sabemos que la búsqueda local 2 es mejor que la 1, tomamos como refe-
rencia los resultados obtenidos con busqueda local 2 para compararlos con los resultados
obtenidos sin búsqueda local.
Se tienen las siguientes tablas
Usando el método 1
Problema Mutación Éxito(AGS) Éxito(AE) Media Eval.(AGS) Media Eval.(AE)
10-15-5 70 % 0 % 100 % 0 288598
(2 90 ) 90 % 2 % 100 % 801145 104509
100 % 4 % 100 % 1.04644e+06 340361
10-8-5 70 % 100 % 100 % 129486 10368.7
(2 48 ) 90 % 98 % 100 % 90263.3 10164.8
100 % 100 % 100 % 86991.9 8220.76
15-12-4 70 % 96 % 100 % 324814 1154.76
(2 72 ) 90 % 100 % 100 % 263719 860.82
100 % 98 % 100 % 295557 1058.64
25-8-5 70 % 100 % 100 % 26307.5 1517.26
(2 48 ) 90 % 100 % 100 % 20602.3 1407.38
100 % 98 % 100 % 35748.3 1189.84
5-15-3 70 % 2 % 96 % 91868 171128
(2 90 ) 90 % 2 % 100 % 374402 192842
100 % 10 % 98 % 743411 246269
123

Usando el método 2
Problema Mutación Éxito(AGS) Éxito(AE) Media Eval.(AGS) Media Eval.(AE)
10-15-5 70 % 2 % 100 % 1.12728e+06 338841
(2 90 ) 90 % 2 % 100 % 1.0302e+06 362079
100 % 2 % 100 % 253817 340070
10-8-5 70 % 100 % 100 % 179024 12433.7
(2 48 ) 90 % 100 % 100 % 93544.5 9702.92
100 % 100 % 100 % 73362.4 9629.52
15-12-4 70 % 98 % 100 % 313743 1456.82
(2 72 ) 90 % 100 % 100 % 204263 1395.68
100 % 96 % 100 % 255491 1431.26
25-8-5 70 % 100 % 100 % 36819.7 1244
(2 48 ) 90 % 100 % 100 % 34846.2 1145.1
100 % 100 % 100 % 29859.6 1165.28
5-15-3 70 % 10 % 94 % 273665 284990
(2 90 ) 90 % 10 % 94 % 511213 222077
Conclusión 4
100 % 4 % 96 % 1.00708e+06 218227
La búsqueda local mejora la probabilidad de exito y reduce considerablemente el número
de evaluaciones necesarias para encontrar una solución del problema.
124

Capítulo 9
Experimento final
En esta sección vamos a presentar los resultados obtenidos en la resolución de un
grupo de problemas clasificados como de gran dificultad por tener un espacio de búsqueda
grande.
Como ya hemos comprobado el mejor funcionamiento de la búsqueda local 2, en toda
esta sección usaremos esta búsqueda con tamaño de población dos.
Resolvemos el Problema15-25-5
Tamaño del espacio de búsqueda: aprox. 2 150
Usando el método 1 para generar la población inicial se obtuvo
Búsq. L. tp l Mutación Exito Media Eval.
2 2 5 70 % 92 % 414500
2 2 5 80 % 98 % 384799
2 2 5 90 % 96 % 359897
2 2 5 100 % 86 % 417172
Usando el método 2 para generar la población inicial se obtuvo
Búsq. L. tp l Mutación Exito Media Eval.
2 2 5 70 % 98 % 475580
2 2 5 80 % 96 % 424660
2 2 5 90 % 90 % 409549
2 2 5 100 % 90 % 421117
125

Mientras que con el método 1 los mejores resultados se obtienes con probabilidad
de mutación 80 % y 90 %, con el método 2 a medida que disminuye la probabilidad de
mutación mejoran los resultados, esto nos lleva a pensar en intentar resolver el problema
con menor probabilidad de mutación. Aunque según la experiencia no esperamos que haya
mejora, pues hemos establecido la probabilidad de mutación más adecuada entre el 70 %
y el 100 %.
Nota 53
Admite distintas soluciones.
Existen dos variables del problema que puede tomar distintos valores, el resto de las
variables siempre toman el mismo valor.
Resolvemos el Problema25-23-4
Tamaño del espacio de búsqueda: aprox. 2 138
Usando el método 1 para generar la población inicial se obtuvo
Búsq. L. tp l Mutación Exito Media Eval.
2 2 5 70 % 68 % 375905
2 2 5 80 % 78 % 549016
2 2 5 90 % 78 % 593530
2 2 5 100 % 76 % 601812
Usando el método 2 para generar la población inicial se obtuvo
Búsq. L. tp l Mutación Exito Media Eval.
2 2 5 70 % 74 % 530816
2 2 5 80 % 72 % 690505
2 2 5 90 % 70 % 663918
2 2 5 100 % 70 % 519235
Se repite el comportamiento observado en el problema anterior, con el método 1 el
mejor éxito se tiene con probabilidad de mutación igual a 80 %, seguido del 90 %, mientras
que con el método 2 va mejorando el resultado a medida que disminuye la probabilidad
de mutación.
Nota 54
Siempre encuentra la misma solución.
126

Para finalizar, en la siguiente tabla se comparan los resultados obtenidos al resolver
algunos problemas en distintos espacios de búsqueda con el algoritmo genético simple
(AGS) y con el A.E. Búsqueda Local (AE).
Usamos el método 1 para generar la población inicial y mutación del 90 %
Problema l Esp. Búsq. Éxito(AE) Éxito(AGS) Eval.(AE) Eval.(AGS)
p10-8-3 3 2 32 100 % 98 % 3593.14 243568
p25-8-3 3 2 32 100 % 100 % 771.66 86942
p10-8-3 4 2 40 100 % 72 % 7094 464914
p25-8-3 5 2 48 100 % 74 % 1405.06 393360
p25-8-3 6 2 56 100 % 42 % 2502.06 644780
p5-15-3 3 2 60 100 % 50 % 19332.8 290949
p10-15-3 3 2 60 100 % 62 % 9788.18 458878
p15-12-4 4 2 60 100 % 100 % 644.94 193523
p10-8-3 7 2 64 100 % 4 % 221302 60725
p25-8-3 8 2 72 100 % 16 % 4946.56 389959
p10-8-3 10 2 88 76 % 0 % 577926 –
p5-15-3 5 2 90 100 % 6 % 192842 366681
p10-15-3 5 2 90 98 % 10 % 362663 712000
p10-15-5 5 2 90 100 % 2 % 104509 801145
p25-23-4 4 2 115 96 % 0 % 493575 –
p25-23-4 5 2 138 78 % 0 % 593530 –
p15-25-5 5 2 150 96 % 0 % 359897 –
p5-15-3 10 2 165 4 % 0 % 464710 –
p25-8-3 20 2 168 100 % 0 % 31189.3 –
Conclusión 5
El algoritmo evolutivo que proponemos para resolver los problemas l SW ES usa los o-
peradores genéticos definidos en el capítulo 5 y aplica búqueda local 2 a cada una de las
poblaciones generadas.
127

Apéndice A
El Algoritmo Genético Simple
// //////////////////////////////////////////////////////////// //
// / / //
// / Un Algoritmo Genético para Resolver el problema l_SWES / //
// / / //
// //////////////////////////////////////////////////////////// //
#include #include #include
#include #include #include
using namespace std;
fstream fsol("solucion.dat",ios::out);
void Pedir_Datos(string &problema, int &TamPob, int &lMaxVsol,
int &NMaxIter, int &ProMut, int &Metodo);
void Lee_Prob(const string &problema, int &n_ec, int &m_var,
void Simplifica(const int &n_ec, vector &l_ec,
vector &l_ec, vector &Sist);
vector &Sist);
128

void Genera_PobIni(vector &PobIni,
vector &lReVsol,
vector &AuxPob,
vector &AuxlRsol,
const int &TamPob, const int &m_var,
const int &lMaxVsol, const int &Metodo);
void reordeno(const int &l, vector &v, int &lReVsol);
void Evalua(const int &n_ec, const vector &l_ec,
const vector &Sist,
const vector &lReVsol,
const vector &PobIni,
vector &AuxIzq, vector &AuxDer,
int &fitness, int &haysol);
void sustituyo( const vector &Sist, int &lAux,
vector &Aux, const vector &lVsol,
const vector &PobIni);
void Mejor_Sol(int &MejorFit, vector &fitness,
const int &TamPob, const int &m_var,
vector &AuxPob, const int &lMaxVsol,
vector &PobIni,
vector &AuxlRsol, vector &lReVsol);
void Ruleta(int &Sumfit, const int &TamPob, vector &fitness);
void eligo_padre(int &TamPob, int &Padre, vector &fitness);
void Cruce(const int &m_var, const int &lMaxVsol,
129

vector &AuxPob,
vector &lReVsolIzq, vector &lReVsolDer,
vector &AuxlRsol, vector &PobIniIzq,
vector &PobIniDer);
void Mutacion(const int &m_var, const int &lMaxVsol, int &muto,
int main(void)
{
string problema;
vector &AuxPob, vector &AuxlRsol);
int TamPob, lMaxVsol, NMaxIter, ProMut, Metodo;
int n_ec, m_var;
int haysol, muto;
int MejorFit, Sumfit, PadreIzq, PadreDer;
int i, j, k, iter;
vector l_ec;
vector Sist;
vector PobIni;
vector lReVsol;
vector AuxPob; //vector auxiliar
vector AuxlRsol; //vector auxiliar
vector fitness;
vector AuxIzq; //Sólo se utiliza en la función evalua
vector AuxDer; //Sólo se utiliaza en la función evalua
randomize();
Pedir_Datos(problema, TamPob, lMaxVsol, NMaxIter, ProMut, Metodo);
Lee_Prob(problema, n_ec, m_var, l_ec, Sist);
130

Simplifica(n_ec, l_ec, Sist);
Genera_PobIni(PobIni, lReVsol, AuxPob,
fitness.resize(TamPob);
haysol= 0;
for(k= 0; k

* Cruce *
Cruce(m_var, lMaxVsol, AuxPob[k], lReVsol[PadreIzq], lReVsol[PadreDer],
// * Mutación *
if(ProMut!=0)
{
muto = rand() %100;
AuxlRsol[k], PobIni[PadreIzq], PobIni[PadreDer]);
if(muto< ProMut) // * Muto la solusión k_esima *
Mutacion(m_var, lMaxVsol, muto, AuxPob[k], AuxlRsol[k]);
}//fin if(ProMut!=0)
}//fin for(k)
for(k= 0; k< TamPob; k++)
for(i= 0; i< m_var; i++)
{
lReVsol[k][i]= AuxlRsol[k][i];
for(j= 0;j< lMaxVsol; j++) PobIni[k][i][j]= AuxPob[k][i][j];
}//fin for(i)
fitness[0]= MejorFit;
for(k= 1; k

for(k= 0; k< TamPob; k++) { for(i= 0; i< m_var; i++) {
for(j= 0;j< lMaxVsol; j++) fsol

fsol

do{
do{
cout

cout

}//fin while
if(coincidencia!=0)
{
l_ec[i]= l_ec[i]-coincidencia;
for(int j= 0; j< l_ec[i]; j++)
Sist[i][j]= Sist[i][j+coincidencia];
Sist[i].resize(l_ec[i]);
l_ec[i+1]= l_ec[i+1]-coincidencia;
for(int j= 0; j< l_ec[i+1]; j++)
Sist[i+1][j]= Sist[i+1][j+coincidencia];
Sist[i+1].resize(l_ec[i+1]);
}//fin if
coincidencia= 0; columnas= 1; minimo= min (l_ec[i],l_ec[i+1]);
while(columnas

{
int longitud;
PobIni.resize(TamPob);
lReVsol.resize(TamPob);
AuxPob.resize(TamPob); //vector auxiliar
AuxlRsol.resize(TamPob); //vector auxiliar
for(int k= 0; k< TamPob; k++)
{
PobIni[k].resize(m_var);
lReVsol[k].resize(m_var);
AuxPob[k].resize(m_var); //vector auxiliar
AuxlRsol[k].resize(m_var); //vector auxiliar
for(int i= 0; i< m_var; i++)
{
PobIni[k][i].resize(lMaxVsol);
if(Metodo == 1)
{
longitud= lMaxVsol +1;
lReVsol[k][i]= rand() % longitud;
for(int j= 0; j< lReVsol[k][i]; j++) PobIni[k][i][j]= rand() % 2;
for(int j= lReVsol[k][i]; j< lMaxVsol; j++) PobIni[k][i][j]= 2;
}//fin if(Metodo==1)
if(Metodo == 2)
{
lReVsol[k][i]= lMaxVsol;
for(int j= 0; j< lMaxVsol; j++) PobIni[k][i][j] = rand() % 3;
reordeno(lMaxVsol, PobIni[k][i],lReVsol[k][i]);
}//fin if(Metodo==2)
}//fin for(i)
}//fin for(k)
}//fin Genera_PobIni
138

void reordeno(const int &l, vector &v,int &lReVsol)
{
// Reordeno la variable y calculo la longitud real de la misma
int columna;
for(int j= 0; j< l-1; j++)
if(v[j] == 2)
{
columna= j+1;
while(v[columna] == 2 && columna< l-1) columna = columna +1;
if(v[columna]!= 2)
{
v[j]= v[columna];
v[columna]= 2;
}//fin if
}//if(v[j] == 2)
for(int j= 0; j< l; j++)
if(v[j] == 2) lReVsol= lReVsol -1;
}//fin reordeno
void Evalua(const int &n_ec, const vector &l_ec,
{
const vector &Sist, const vector &lReVsol,
const vector &PobIni, vector &AuxIzq,
vector &AuxDer, int &fitness, int &haysol)
int lAuxIzq, lAuxDer;
int coincidencia, minimo;
coincidencia = 0;
for(int i= 0; i

AuxDer.resize(lAuxDer);
sustituyo(Sist[2*i], lAuxIzq, AuxIzq, lReVsol, PobIni);
sustituyo(Sist[2*i+1], lAuxDer, AuxDer, lReVsol, PobIni);
minimo = min(lAuxIzq,lAuxDer);
for(int j= 0;j< minimo; j++)
if(AuxIzq[j] != AuxDer[j]) coincidencia= coincidencia+1;
coincidencia= coincidencia + abs(lAuxIzq-lAuxDer);
}//fin for(i)
fitness= coincidencia;
if(fitness == 0) haysol= 1;
}//fin Evaluacion
void sustituyo(const vector &Sist, int &lAux,
{
int auxiliar, variable;
int j, l;
auxiliar = 0;
for(j= 0;j< lAux; j++)
vector &Aux, const vector &lVsol,
const vector &PobIni)
if(Sist[j+auxiliar]==0 || Sist[j+auxiliar]==1) Aux[j] = Sist[j+auxiliar];
else
{
variable = Sist[j+auxiliar] - 3;
if(lVsol[variable]==0)
{
}
else
lAux=lAux-1;
Aux.resize(lAux);
auxiliar=auxiliar+1;
j=j-1;
140

{
}
lAux=lAux+lVsol[variable]-1;
Aux.resize(lAux);
for(l= 0; l< lVsol[variable]; l++) Aux[j+l] = PobIni[variable][l];
auxiliar = auxiliar - lVsol[variable] + 1;
j=j+lVsol[variable]-1;
}//fin else
}//fin sustituyo
void Mejor_Sol(int &MejorFit, vector &fitness,
{
int minimo, variable;
variable = 0;
MejorFit = fitness[0];
const int &TamPob, const int &m_var, vector &AuxPob,
const int &lMaxVsol, vector &PobIni,
vector &AuxlRsol, vector &lReVsol)
for(int k= 1; k< TamPob; k++)
{
if(fitness[k]< MejorFit)
{
MejorFit= fitness[k];
variable= k;
}//fin if(fitness[k]< MejorFit)
if(MejorFit == fitness[k])
{
minimo= rand() % 2;
if(minimo == 0)
{
MejorFit= fitness[k];
variable= k;
141

}//fin if(minimo == 0)
}//fin if(MejorFit == fitness[k])
}//fin for(k)
for(int i= 0; i< m_var; i++)
{
AuxPob[i].resize(lMaxVsol);
AuxlRsol[i]= lReVsol[variable][i];
for(int j= 0; j< lMaxVsol; j++) AuxPob[i][j]= PobIni[variable][i][j];
}//fin for(i)
}//fin Mejor_Sol
void Ruleta(int &Sumfit, const int &TamPob, vector &fitness)
{
Sumfit = 0;
for(int k= 0; k< TamPob; k++) Sumfit= Sumfit + fitness[k];
for(int k= 0; k< TamPob; k++) fitness[k]= Sumfit - fitness[k];
Sumfit = 0;
for(int k= 0; k< TamPob; k++) Sumfit= Sumfit + fitness[k];
}//fin Ruleta
void eligo_padre(int &TamPob, int &Padre, vector &fitness)
{
int limInf, limSup, coinciden;
coinciden= 0;
limInf = 0;
limSup = fitness[0];
for(int i= 0; i

}
else
}
{
limInf = limInf + fitness[i];
limSup = limSup + fitness[i+1];
}
}//fin eligo_padre
void Cruce(const int &m_var, const int &lMaxVsol,
{
vector &AuxPob,
vector &lReVsolIzq, vector &lReVsolDer,
vector &AuxlRsol, vector &PobIniIzq,
vector &PobIniDer)
int minimo, columna, longitud;
for(int i= 0; i< m_var; i++)
{
AuxPob[i].resize(lMaxVsol);
minimo= min(lReVsolIzq[i],lReVsolDer[i]);
AuxlRsol[i]= minimo;
for(int j= 0; j< minimo; j++)
{
columna= rand() % 2;
if(columna == 0) AuxPob[i][j]= PobIniIzq[i][j];
else AuxPob[i][j]= PobIniDer[i][j];
}//fin for(j)
longitud= lMaxVsol - minimo;
columna= longitud +1;
columna= rand() % columna;
if(lReVsolIzq[i]< lReVsolDer[i])
{
143

for(int j= 0; j< columna; j++)
{
AuxPob[i][minimo+j]= PobIniDer[i][minimo+j];
if(AuxPob[i][minimo+j]!= 2) AuxlRsol[i]= AuxlRsol[i] +1;
}//fin for(j)
for(int j= columna; j< longitud; j++) AuxPob[i][minimo+j]= 2;
}//fin if
else
{
for(int j= 0; j< columna; j++)
{
AuxPob[i][minimo+j]= PobIniIzq[i][minimo+j];
if(AuxPob[i][minimo+j]!= 2) AuxlRsol[i] = AuxlRsol[i] +1;
}//fin for(j)
for(int j= columna; j< longitud; j++) AuxPob[i][minimo+j] = 2;
}//fin else
}//fin for(i)
}//fin cruce
void Mutacion(const int &m_var, const int &lMaxVsol, int &muto,
{
vector &AuxPob, vector &AuxlRsol)
for(int i= 0; i< m_var; i++){
for(int j= 0; j< lMaxVsol; j++)
{
muto= rand() % lMaxVsol;
if(muto == 0) AuxPob[i][j]= rand() % 3;
}//fin for (j)
AuxlRsol[i]= lMaxVsol;
reordeno(lMaxVsol, AuxPob[i],AuxlRsol[i]);
}//fin for(i)
}//fin Mutacion
144

Apéndice B
El Algoritmo Genero Problema
// //////////////////////////////////////////////////////////// //
// / / //
// / Un Algoritmo que Genera Sistemas de ‘‘Word Ecuations’’ / //
// / / //
// //////////////////////////////////////////////////////////// //
#include #include #include
#include #include #include
using namespace std;
void Pedir_Datos(string &sistema, string &soluciones,
int &n_ec, int &lmax_ec,
int &m_var, int &lmax_var);
void Genero_Cadenas(const int &SumaLong, const int &lmax_ec,
vector &Ecizq, vector &Ecder,
int &l_ecizq, int &l_ecder);
void ruleta(const int &SumaLong, const int &lmax_ec, int &l_ec);
145

void Def_variable(const int &n_ec, const int &m_var,
const int &lmax_var, vector &l_ec,
vector &Ec, vector &l_var,
vector &Var, int &contador);
void insertar(const int &k,int &posicion, int &a, vector &v);
void sustituir(const int &k, int &posicion, int &a,
const int &b,vector &v);
void recorro_ec(int &contador, const int &k, int &l_ec,
const int &lmax_var, const int &l_var,
const vector &Var, vector &Ec);
void mejora(int &l_ecizq, vector &Ecizq,
const int &SumaLong, int &l_ecder, vector &Ecder,
const int &lmax_var, const vector &l_var,
const vector Var,
const int &lmax_ec, const int &m_var);
void Simplifica(const int &n_ec, vector &l_ec,
int main(void)
{
string sistema;
string soluciones;
int i, j, k, l, m;
int probabilidad;
vector &Ec);
int n_ec, lmax_ec, m_var, lmax_var;
int indice, posicion, auxiliar, contador, coincidencia, coinciden;
146

int SumaLong;
vector Ec;
vector Var;
vector l_ec;
vector l_var;
randomize();
Pedir_Datos(sistema, soluciones, n_ec, lmax_ec, m_var, lmax_var);
fstream fprob(sistema.c_str(),ios::out);
fstream fsol(soluciones.c_str(),ios::out);
fsol

ecorro_ec(contador, k, l_ec[i], lmax_var, l_var[k],
if(contador

for(i= 0; i< m_var; i++)
{
if(l_var[i] == 0) fsol

do{
cout

limSup = sum;
l_ec = 0;
for(int j= 0; j< lmax_ec && l_ec == 0; j++)
if(limInf0; k++)
{
do{
indice = 2 * n_ec;
indice = rand() % indice;
posicion = rand() % l_ec[indice];
}while(Ec[indice][posicion]!=0 && Ec[indice][posicion]!=1);
auxiliar = 0;
for(int j= posicion; j< l_ec[indice] &&
(Ec[indice][j]==0 || Ec[indice][j]==1); j++)
auxiliar = auxiliar + 1;
auxiliar = min(lmax_var,auxiliar) +1;
151

l_var[k] = rand() % auxiliar;
Var[k].resize(l_var[k]);
if(l_var[k]==0) insertar( k, posicion, l_ec[indice], Ec[indice]);
else
{
auxiliar = 0;
for(int j= posicion; j< posicion +l_var[k]; j++)
{
Var[k][auxiliar]= Ec[indice][j];
auxiliar= auxiliar +1;
}//fin for(j)
sustituir(k, posicion, l_ec[indice], l_var[k], Ec[indice]);
}//else
contador = contador -l_var[k];
}//fin for(k)
}//fin void Def_variable
void insertar(const int &k,int &posicion, int &a, vector &v)
{
a = a+1;
v.resize(a);
for(int l = a-1; l> posicion; l--) v[l] = v[l-1];
v[posicion] = k+3;
}//fin insertar
void sustituir(const int &k,int &posicion,int &a,const int &b,
{
v[posicion]= k+3;
a = a -b +1;
vector &v)
for(int l= posicion; l< a-1; l++) v[l+1]=v[l+b];
v.resize(a);
152

}// fin sustituir
void recorro_ec(int &contador, const int &k, int &l_ec,
{
const int &lmax_var, const int &l_var,
const vector &Var, vector &Ec)
int coincidencia, probabilidad, auxiliar, posicion;
coincidencia = 1;
for(int j= 0; j< l_ec && coincidencia == 1; j++)
if(l_var==0)
{
}
else
{
if((Ec[j] == 0 || Ec[j] == 1) && (Ec[j-1] != k+3))
{
probabilidad = 4*lmax_var;
probabilidad = rand() % probabilidad;
if(probabilidad == 0)
{
insertar( k, j, l_ec, Ec);
j=j+1;
}//fin if
}//fin if
auxiliar=l_ec-j;
if(l_var > auxiliar) coincidencia = 0;
else
{
auxiliar = 0;
coincidencia = 1;
posicion = j;
for(int l= posicion;l< posicion +l_var && coincidencia == 1; l++)
153

if(Ec[l] != Var[auxiliar]) coincidencia = 0;
else auxiliar = auxiliar + 1;
}//fin else
if(coincidencia == 1)
{
// * Cambio con probabilidad l_var[k]/lmax_var *
probabilidad = rand() % lmax_var;
probabilidad = probabilidad + 1;
if(probabilidad

cont_der = 0;
for(int j= 0; j< l_ecder; j++)
if(Ecder[j]!=0 && Ecder[j]!=1) cont_der = cont_der +1;
if(cont_der == 0)
for(int k= 0; k< m_var && contador> 0; k++)
recorro_ec(cont_der, k, l_ecder, lmax_var, l_var[k],Var[k], Ecder);
if(l_ecizq == l_ecder)
{
coinciden= 1;
for(int j= 0; j< l_ecizq && coinciden == 1; j++)
if(Ecizq[j]!=Ecder[j]) coinciden=0;
if(coinciden == 1) // * defino una nueva ecuacion *
{
Genero_Cadenas(SumaLong,lmax_ec,Ecizq,Ecder,l_ecizq,l_ecder);
contador= 2*l_ecizq;
for(int k= 0; k< m_var && contador> 0; k++)
{
recorro_ec(contador, k, l_ecizq, lmax_var, l_var[k],
recorro_ec(contador, k, l_ecder, lmax_var, l_var[k],
}//fin for(k)
}//fin if(coinciden == 1)
}//fin if(l_ecizq == l_ecder)
}while(coinciden == 1 || cont_izq == 0 || cont_der == 0);
}//fin mejora
void Simplifica(const int &n_ec, vector &l_ec,
{
int coincidencia, columnas, minimo;
vector &Ec)
155
Var[k], Ecizq);
Var[k], Ecder);

for(int i= 0; i< 2*n_ec - 1; i+= 2)
{
coincidencia= 0; columnas= 0; minimo= min (l_ec[i],l_ec[i+1]);
while(Ec[i][columnas]== Ec[i+1][columnas] && columnas< minimo)
{
coincidencia= coincidencia +1; columnas= columnas +1;
}//fin while
if(coincidencia!=0)
{
l_ec[i]= l_ec[i]-coincidencia;
for(int j= 0; j< l_ec[i]; j++)
Ec[i][j]= Ec[i][j+coincidencia];
Ec[i].resize(l_ec[i]);
l_ec[i+1]= l_ec[i+1]-coincidencia;
for(int j= 0; j< l_ec[i+1]; j++)
Ec[i+1][j]= Ec[i+1][j+coincidencia];
Ec[i+1].resize(l_ec[i+1]);
}//fin if
coincidencia= 0; columnas= 1; minimo= min (l_ec[i],l_ec[i+1]);
while(columnas

Apéndice C
Los problemas propuestos
En el capítulo de experimentos hacemos referencia a una cadena de problemas que
hemos seleccionado para estudiar el comportamiento del algoritmo genético diseñado.
Estos son algunos de los problemas propuestos:
C.1. El problema 10-15-3
Sistema de 10 “word equations” con 15 variables de longitudes comprendidas entre 0
y 3, siendo al menos una de ellas una cadena de longitud 3.
x1x13x4x7 = x1x2x11x6
x13x4x4x1x1x1x11 = x1x41x6x1x13x4
x1x6x5x1 = 0x1x1x10
x11 = x11
x11x810x6x9x12x13 = 0x21x4x10x1x15x13
x1x4x10x50x2x1x6 = x11x61x4x6x1x12x13
1x1x4x11x40 = x2x81x1x3x4x120
1x2x13x6x110 = x40x1x80x20x4x13
0x4x310x2x6 = x8x11x8x31x1x120x1
x5x6x1x1x13 = x2x5x14x70
157

C.2. El problema 10-15-5
Sistema de 10 “word equations” con 15 variables de longitudes comprendidas entre 0
y 5, siendo al menos una de ellas una cadena de longitud 5.
x3x6x5x1701 = x121x15x161x1200x111x9x14x1
x10x50x90 = x10x5x9x170x12
1x12x3x4x8x90 = x171x120x15x5x160x41x9x170
x9x111 = x91
0 = x160
x6x3x12x10x10 = 1x1610x9x15x3
x5x1101x50x70 = x8x5x3x11x170
1x90x90x9x4x13 = x10x900x11x120x1400
x12 = x4x9
10x131x30x10x70 = 1x9x8101x6
C.3. El problema 10-3-3
Sistema de 10 “word equations” con 3 variables de longitudes comprendidas entre 0 y
3, siendo al menos una de ellas una cadena de longitud 3.
x400100x301x3 = 1000100x301x3
x4x40101x4x50 = x410010x31010
00x3 = 00110
0x5x401x40x30 = 0x4x30x30x30
11x300x4 = 11x30010
1001 = x401
10001x3x41x30 = x4001x3x5x30
x4x401000010 = x4x4010000x4
010x4000000 = 0x410000000
1100010x4x41 = 11000x50x5
La solución propuesta es: x3 = 110 x4 = 10 x5 = 101
158

C.4. El problema 10-5-1
Sistema de 10 “word equations” con 5 variables de longitudes comprendidas entre 0 y
1, siendo al menos una de ellas una cadena de longitud 1.
x3x61x3x61x31 = x4x61x61x5
x31x61x40x40 = x31x61x60x30
x311x4x61x301 = 5x5x31x3x60x31
x4x60x410x300 = x7x61x600x60
x3101x60 = x5x40x10
x30x611x70 = x3x60x31100
x40x30x60 = x7x3x40x30
x4x6100x31 = x5x300x41
x7x60x4x60x30 = x3x4000x30
x7x31x3x610x30 = x7x3x61x3x4x610x30
La solución propuesta es:
C.5. El problema 10-5-2
x3 = Λ x4 = Λ
x5 = 1 x6 = Λ x7 = 0
Sistema de 10 “word equations” con 5 variables de longitudes comprendidas entre 0 y
2, siendo al menos una de ellas una cadena de longitud 2.
x41x4 = x61
x40x4010x41x41x4 = x5x40x41011
0x50 = x50x40x6
1x6 = x41
x4x6111 = 111x4
x71x4 = x51
x611x5 = 110
x4 = Λ
x60x5x50x4x600 = 0x7x7x7x5x5
x3x7 = x6100
159

La solución propuesta es: x3 = 10 x4 = Λ
C.6. El problema 10-8-3
x5 = 0 x6 = Λ x7 = 0
Sistema de 10 “word equations” con 8 variables de longitudes comprendidas entre 0 y
3, siendo al menos una de ellas una cadena de longitud 3.
1x80x7 = 1x901
0x3 = 0x4x81
x5011 = x50x7x5x7
x90x3000 = 0x3000
0x40x40x90x50 = x90x5x10x8x1000
00100x90 = 00x1000
x60 = x4x30
x4x10000 = x3000x50
x10x80x900x50 = x400x90x900
0x3x50x51 = 0x8x7x401
C.7. El problema 10-8-5
Sistema de 10 “word equations” con 8 variables de longitudes comprendidas entre 0 y
5, siendo al menos una de ellas una cadena de longitud 5.
0011x3111 = 0x30x8x81
x4x9x31 = x40x411
01x7x50111 = x5x3x10x300011x3x1
0x91x5001 = x300x8x3x4000x41
x81x51x611 = x81x301x6x8
0x51x5x5x5 = x501x500
000x9x30 = x50x50x410
0x3x4x10x5 = x3x9x5x5010
1x91x710 = 101x10x90
x51x50 = 0x310x5
160

C.8. El problema 12-6-4
Sistema de 12 “word equations” con 6 variables de longitudes comprendidas entre 0 y
4, siendo al menos una de ellas una cadena de longitud 4.
x501x8 = x50x710
111 = 1x711
x41x8101x81x8 = 1010x4x710x41x8
x711x500 = 11x500
x811x310 = 0x411x3x410
101x80110x411 = 1010011011
x80x41 = 0x81
1x6x701x4100 = 1x6x4x70x6
x7x811x70x31 = 0110x31
x4x61 = x61
0x4x710x4x71001 = 01x401001
000x3 = 0x80x3
C.9. El problema 15-12-4
Sistema de 15 “word equations” con 12 variables de longitudes comprendidas entre 0
y 4, siendo al menos una de ellas una cadena de longitud 4.
11x5x13x3x9x12x3x10x13 = 1x611x50x9x121x90
0x70000 = 00x3x9000
1x130x3x120x12x13x511 = x101x5x6x12x8011x90x12x3x5x12
x4x40 = x50x6100x5100
x611x411x3x4x300x12 = x61x9x12x41x120x120x5x7x8
x6x101x130x4x70x8 = x6x10x12x3x10x1410x3x140x4x50x90x30x5x71
x910x12x5x13x4 = x7x131x120x4
x6x50x4x140x3x12 = x3x8001
0x4x71x91x60x50 = x1400x610x31x141x900
x50x301x30 = 0x3x4
x41x61x3x1401x6x71x10x12 = x41x71x140x12x121
161

x50x1100 = 011x7x141x60x500
x10011 = 0x12x51
1x91x130x1411 = 1x10x141x3x13x30x141x91
x12x12x4x50x3x141x7x12x4 = x1210x1200x91x31x4
C.10. El problema 15-25-5
Sistema de 15 “word equations” con 25 variables de longitudes comprendidas entre 0
y 5, siendo al menos una de ellas una cadena de longitud 5.
x1701000100x241x18 = x3x2011x160x201x300x200100111
x810x2601x20000x10 = x3x1001x1801x12x19001x2010x230
1x4x41x251x14 = x11x311x181x191x12111x100x19
x8x121x10 = 0x201
x14x160x2511x19011x3 = x19x201x30x10011011
x1111x10x191x100x15x5 = x4x400x12x16x2001x201x25110
x51x201 = x251x4011x12x25x10
x8x9 = x2501x18x250x181
x1500001x180x1000x3x1211x21 = 0x120x101000x190x181x1311x12x201x161
x11x11x161x1610 = 1x22
x121x16x190x2001x100x201x18101x121x200x191x3 = x14010x25110110x161
010x1800x191x160x11x6 = x3x200x16x201x270x121x1001x18010x10x121
1x3x191010011x12x250x16100x10 = x4x3x120x3x1010x180x16x201101x1900x25
x2001x7x121 = x61x17
x1910x25010x2510x8 = 100x2010100
162

C.11. El problema 15-7-5
Sistema de 15 “word equations” con 7 variables de longitudes comprendidas entre 0 y
5, siendo al menos una de ellas una cadena de longitud 5.
10x900x40000 = 10x7x4000000
x8x31 = 10x3x9
x40x7 = 001
x7x50000x4x9 = x7x5000001
00010 = 000x9x4
11x60x4x40 = x91x60x40x4
x810x80x5 = 1010x700x5
x9 = 1
x400x8x411 = 0001x6
0x7x41x4 = 0x90x70
0x711x4x7 = 01x9101
x70x4x90x80 = x900x701x40
x5x80001 = x5100001
x60 = 001x7x4
0x5x51 = 0x5x5x7
163

C.12. El problema 25-23-4
Sistema de 25 “word equations” con 23 variables de longitudes comprendidas entre 0
y 4, siendo al menos una de ellas una cadena de longitud 4.
x9x13x7x14x9x30x7x5x13x19x25 = x9x7x6x230x9x5x25x5x9x41x9
x22x7x7x3x13x3x9x6x9x13x4x22 = x22x4x4x16x21x3x9x13x4x18x60
0x70x140x21x40 = x24010x15x10x25x7x13x5x22
x5x1010x4x7x22x12x3 = x1301x4x20x22x9
x221x24x25x3x16x3x9 = x9x140x3x25x3x3
1x4x3 = x4x4x3
x21x9x4x14x3x7x4x3x4x7x9 = x10x231x18x12x3x4x191x3x6x22
x60x9 = 1x15x22x9
x18x22x18x13 = x16x10x251
1x10x18x30x6x240x10x19x21x3 = x51x3x3x4x4x9x13x220
1x91 = x231x17
x71x22x14x251x16x15x3x15 = x8x7x18x10x15x3x40x9x4
x7x2400x5x4x22x6x9x8x14x16 = x7x100x22x130x8x7x4x100x5x13x90
x3x3x6x40x14x5x15 = x3x11x40x6
x6x7x4 = x4x4x4x21
x6x9x9x18x4x7x6x41x4x5x14x4x25 = x14x4x30x51x5x7x4x5x7x5x21x13x4x4x210
x15x4x4 = x5x10x14x5x7x13
x51x5x9x21 = x15x25x7
x21 = x15
x21x3x6x25x7 = x7x18x9x13x10x7x17
x7x4x9x410x19x15x16x15x4x18 = x13x40x4x130x400x7x5x130
x7x50x14x4x6 = x24x5x241x22x6x13x4
0x7x9x7x18x40x6x5x7x5x7x5x7x6 = 0x7x9x21x251x18x15x5x6x12x4x14
x4x3x5x13x10x12x12x3x30x7 = x7x9x100x7x4x4x6x16x25x9x22x14
x21x22x15 = x4x9x13
164

C.13. El problema 25-8-3
Sistema de 25 “word equations” con 8 variables de longitudes comprendidas entre 0 y
3, siendo al menos una de ellas una cadena de longitud 3.
x70 = x6x8x500
1x3x3x10x7x4x3x9x9 = 1x8x31x3x3x40x3x3
x9 = 0
11x4x8x3x61x8x50 = x6x10x10x3x10x10x3x3x100x60
x3x5x91x3x30 = x3x81x7x8
x101x10x3x10x10x3x7x5x8x3x10x8 = x1011x4x90x3x3x81x3
1x401x8x9x3x3 = 1x401x3x8x3x9
1x61x3x3x10x8 = 1x10x71x3
x51x8 = x61x3
x6x8x60x4x4x10x10x41 = 0x3x31x61x4x101x5x4x10
x7x610x51x31x6x8x30x3x91x9 = x9x9x10x9101x3x3x5x70x10x9
x9x10x9x31x8 = x31x3x81x3
11x40x7x30x100 = x101x40x30x7x10x3
11x3x8x10 = 11x8x31
1x301x3 = x10x8x3x10x50
0x80x10x4x10x7x10x91 = 0x9x31x4x10x71x31
x8x311x311x10x10 = x8x3x10x5x10x41x5x61
x10x8x7 = x10x3x7
x10x10x90x3 = 1x5x6x100x7
x9 = 0
x41x71 = x3x1011x71
x10x8x3x50x8x3x3x4 = x10x70x3x9x9x3x10x10
x71x41 = x3x31x4x10
x8x70x50 = 0x5x6x9x3x6x7
101x5x710x9x3 = 1x31x71x50x50x8
165

C.14. El problema 25-8-5
Sistema de 25 “word equations” con 8 variables de longitudes comprendidas entre 0 y
5, siendo al menos una de ellas una cadena de longitud 5.
1x3x50 = x6x90x10
x401000x4000x401110 = 0x1000x911x40
1x8 = x60
11x81x30 = 1x601x30
1x90x4100 = 1000x41x40x10
x8110x311 = x8x4110x311
x7111x6 = x71111x4110
00x10x4001 = 00100001
0101x4x601x41x41 = 0101x60111
x1000 = 10000
001x40 = 0010
0x60x61000 = 0x601x700
1x410x10x10111 = x7x40x10111
x41 = 1
x9000 = 000x41x4000
1011110x51 = 101x6x51
110x4101001 = x71001
11011111x6 = 110x411111111x40
x41x700000 = x610x400000
111111x410 = 1111x6
x10x4001x3011 = x410x4x9x3011
00001x31x411 = 00001x3111
x4000 = 000
x40x1000x9x9 = 0x10000x4001x9
0001x400 = 000x10
166

C.15. El problema 5-15-3
Sistema de 5 “word equations” con 15 variables de longitudes comprendidas entre 0 y
3, siendo al menos una de ellas una cadena de longitud 3.
x1210110x150x160 = 001011001x8
x61110x91000100 = x51x31x51x1100x90100x11
x4x40x91x13 = x9x141x901x7
x301001000x111001x6 = x401x90010001x110010
x10x10x110x90100 = x4x17x10001x1100x9
C.16. El problema 5-3-2
Sistema de 5 “word equations” con 3 variables de longitudes comprendidas entre 0 y
2, siendo al menos una de ellas una cadena de longitud 2.
10 = x3x4
x51 = 0x31x3
x3011001 = 011001x3
x30 = x5
x5 = x30
La solución propuesta es:
x3 = Λ
x4 = 10
x5 = 0
167

Apéndice D
A.E. Sólo Mutación
// //////////////////////////////////////////////////////////// //
// / / //
// / Un Algoritmo Evolutivo para Resolver el problema l_SWES / //
// / / //
// / (SÓLO MUTACIÓN) / //
// / / //
// //////////////////////////////////////////////////////////// //
#include #include #include
#include #include #include
using namespace std;
fstream fsol;
void Pedir_Datos(string &problema, int &lMaxVsol,
int &NMaxIter, int &Metodo);
void Lee_Prob(const string &problema, int &n_ec, int &m_var,
vector &l_ec, vector &Sist);
168

void Simplifica(const int &n_ec, vector &l_ec,
vector &Sist);
void Genera_PobIni(vector &PobIni,
vector &lReVsol,
vector &AuxPob, const int &m_var,
const int &lMaxVsol, const int &Metodo);
void reordeno(const int &l, vector &v, int &lReVsol);
void Evalua(const int &n_ec, const vector &l_ec,
const vector &Sist, const vector &lReVsol,
const vector &PobIni, vector &AuxIzq,
void sustituyo(const vector &Sist, int &lAux,
vector &AuxDer, int &fitness, int &haysol);
vector &Aux, const vector &lVsol,
const vector &PobIni);
void Mutacion(const int &m_var, const int &lMaxVsol,
int main()
{
string problema;
int lMaxVsol, NMaxIter, Metodo, Npruebas;
int n_ec, m_var;
int fitness, AuxFit, haysol;
int i, j, k, iter, npru;
vector l_ec;
vector &AuxPob, vector &AuxlRsol);
169

vector Sist;
vector PobIni;
vector lReVsol;
vector AuxPob; //vector auxiliar
vector AuxlRsol; //vector auxiliar
vector AuxIzq; //Sólo se utiliza en la función evalua
vector AuxDer; //Sólo se utiliaza en la función evalua
randomize();
Pedir_Datos(problema, lMaxVsol, NMaxIter, Metodo);
Lee_Prob(problema, n_ec, m_var, l_ec, Sist);
PobIni.resize(m_var);
lReVsol.resize(m_var);
AuxPob.resize(m_var); //vector auxiliar
AuxlRsol.resize(m_var); //vector auxiliar
Simplifica(n_ec, l_ec, Sist);
Genera_PobIni(PobIni, lReVsol, AuxPob, m_var, lMaxVsol, Metodo);
haysol= 0;
Evalua(n_ec, l_ec, Sist, lReVsol, PobIni, AuxIzq, AuxDer, fitness, haysol);
fsol

for(i= 0; i< m_var; i++)
{AuxlRsol[i]= lReVsol[i];
for(j= 0;j< lMaxVsol; j++) AuxPob[i][j]= PobIni[i][j];
}//fin for(i)
for(iter= 0; iter< NMaxIter && haysol == 0; iter++)
{
Mutacion(m_var, lMaxVsol, AuxPob, AuxlRsol);
Evalua(n_ec, l_ec, Sist, AuxlRsol, AuxPob, AuxIzq, AuxDer, AuxFit,haysol);
if(AuxFit < fitness)
{
}
else
{
}
for(i= 0; i< m_var; i++)
{lReVsol[i] = AuxlRsol[i];
for(j= 0;j< lMaxVsol; j++) PobIni[i][j] = AuxPob[i][j];
}//fin for(i)
fitness = AuxFit;
for(i= 0; i< m_var; i++)
{AuxlRsol[i] = lReVsol[i];
for(j= 0;j< lMaxVsol; j++) AuxPob[i][j] = PobIni[i][j];
}//fin for(i)
AuxFit = fitness;
}//fin for(iter)
if(haysol == 1)
{
fsol

fsol

do{
do{
cout

coutn_ec; fprob>>m_var;
l_ec.resize(2*n_ec);
Sist.resize(2*n_ec);
for(int i= 0; i< 2*n_ec; i++){
fprob>>l_ec[i]; Sist[i].resize(l_ec[i]);
vector &l_ec, vector &Sist)
for(int j= 0; j< l_ec[i]; j++) fprob>>Sist[i][j];
}//fin for(i)
}//fin Lee_Prob
void Simplifica(const int &n_ec, vector &l_ec,
{
int coincidencia, columnas, minimo;
for(int i= 0; i< 2*n_ec - 1; i+= 2)
{
vector &Sist)
coincidencia= 0; columnas= 0; minimo= min (l_ec[i],l_ec[i+1]);
while(Sist[i][columnas]== Sist[i+1][columnas] && columnas< minimo)
{coincidencia= coincidencia +1; columnas= columnas +1; }//fin while
if(coincidencia!=0)
{
l_ec[i]= l_ec[i]-coincidencia;
for(int j= 0; j< l_ec[i]; j++)
174

Sist[i][j]= Sist[i][j+coincidencia];
Sist[i].resize(l_ec[i]);
l_ec[i+1]= l_ec[i+1]-coincidencia;
for(int j= 0; j< l_ec[i+1]; j++)
Sist[i+1][j]= Sist[i+1][j+coincidencia];
Sist[i+1].resize(l_ec[i+1]);
}//fin if
coincidencia= 0; columnas= 1; minimo= min (l_ec[i],l_ec[i+1]);
while(columnas

for(int j= 0; j< lReVsol[i]; j++) PobIni[i][j]= rand() % 2;
for(int j= lReVsol[i]; j< lMaxVsol; j++) PobIni[i][j]= 2;
}//fin if(Metodo==1)
if(Metodo == 2)
{lReVsol[i]= lMaxVsol;
for(int j= 0; j< lMaxVsol; j++) PobIni[i][j] = rand() % 3;
reordeno(lMaxVsol, PobIni[i], lReVsol[i]);
}//fin if(Metodo==2)
}//fin for(i)
}//fin Genera_PobIni
void Evalua(const int &n_ec, const vector &l_ec,
{
const vector &Sist, const vector &lReVsol,
const vector &PobIni, vector &AuxIzq,
vector &AuxDer, int &fitness, int &haysol)
int lAuxIzq, lAuxDer;
int coincidencia, minimo;
coincidencia = 0;
for(int i= 0; i< n_ec; i++)
{lAuxIzq= l_ec[2*i];
lAuxDer= l_ec[2*i+1];
AuxIzq.resize(lAuxIzq);
AuxDer.resize(lAuxDer);
sustituyo(Sist[2*i], lAuxIzq, AuxIzq, lReVsol, PobIni);
sustituyo(Sist[2*i+1], lAuxDer, AuxDer, lReVsol, PobIni);
minimo = min(lAuxIzq,lAuxDer);
for(int j= 0;j< minimo; j++)
if(AuxIzq[j] != AuxDer[j]) coincidencia= coincidencia+1;
coincidencia= coincidencia + abs(lAuxIzq-lAuxDer);
}//fin for(i)
fitness= coincidencia;
176

if(fitness == 0) haysol= 1;
}//fin Evaluacion
void sustituyo(const vector &Sist, int &lAux,
{
int auxiliar, variable;
int j, l;
auxiliar = 0;
for(j= 0;j< lAux; j++)
vector &Aux, const vector &lVsol,
const vector &PobIni)
if(Sist[j+auxiliar]==0 || Sist[j+auxiliar]==1) Aux[j] = Sist[j+auxiliar];
else
{
variable = Sist[j+auxiliar] - 3;
if(lVsol[variable]==0)
else
{lAux=lAux-1;
Aux.resize(lAux);
auxiliar=auxiliar+1;
j=j-1;}
{lAux=lAux+lVsol[variable]-1;
Aux.resize(lAux);
for(l= 0; l< lVsol[variable]; l++) Aux[j+l] = PobIni[variable][l];
auxiliar = auxiliar - lVsol[variable] + 1;
j=j+lVsol[variable]-1;}
}//fin else
}//fin sustituyo
void Mutacion(const int &m_var, const int &lMaxVsol,
{
vector &AuxPob, vector &AuxlRsol)
177

int muto;
for(int i= 0; i< m_var; i++)
{
for(int j= 0; j< lMaxVsol; j++)
{muto= rand() % lMaxVsol;
if(muto == 0) AuxPob[i][j]= rand() % 3;}//fin for (j)
AuxlRsol[i]= lMaxVsol;
reordeno(lMaxVsol, AuxPob[i],AuxlRsol[i]);
}//fin for(i)
}//fin Mutación
void reordeno(const int &l, vector &v,int &lReVsol)
{
// Reordeno la variable y calculo la longitud real de la misma
int columna;
for(int j= 0; j< l-1; j++)
if(v[j] == 2)
{
columna= j+1;
while(v[columna] == 2 && columna< l-1) columna = columna +1;
if(v[columna]!= 2)
{v[j]= v[columna];
v[columna]= 2; }//fin if
}//if(v[j] == 2)
for(int j= 0; j< l; j++)
if(v[j] == 2) lReVsol= lReVsol -1;
}//fin reordeno
178

Apéndice E
A.E. Búsqueda Local
// //////////////////////////////////////////////////////////// //
// / / //
// / Un Algoritmo Evolutivo para Resolver el problema l_SWES / //
// / / //
// / (BÚSQUEDA LOCAL) / //
// / / //
// //////////////////////////////////////////////////////////// //
#include #include #include
#include #include #include
using namespace std;
fstream fsol("solucion.dat",ios::out);
void Pedir_Datos(string &problema, int &TamPob, int &lMaxVsol,
int &NMaxIter, int &ProMut, int &Metodo, int &Busqueda);
void Lee_Prob(const string &problema, int &n_ec, int &m_var,
vector &l_ec, vector &Sist);
179

void Simplifica(const int &n_ec, vector &l_ec,
vector &Sist);
void Genera_PobIni(vector &PobIni,
vector &lReVsol,
vector &AuxPob,
vector &AuxlRsol,
const int &TamPob, const int &m_var,
const int &lMaxVsol, const int &Metodo);
void reordeno(const int &l, vector &v, int &lReVsol);
void Evalua(const int &n_ec, const vector &l_ec,
const vector &Sist, const vector &lReVsol,
const vector &PobIni, vector &AuxIzq,
vector &AuxDer, int &fitness, int &haysol, int &prueba);
void sustituyo( const vector &Sist, int &lAux,
vector &Aux, const vector &lVsol,
const vector &PobIni);
void Mejor_Sol(int &MejorFit, vector &fitness,
const int &TamPob, const int &m_var,
vector &AuxPob, const int &lMaxVsol,
vector &PobIni,
vector &AuxlRsol, vector &lReVsol);
void Ruleta(int &Sumfit, const int &TamPob, vector &fitness);
void eligo_padre(int &TamPob, int &Padre, vector &fitness);
void Cruce(const int &m_var, const int &lMaxVsol,
180

vector &AuxPob,
vector &lReVsolIzq, vector &lReVsolDer,
vector &AuxlRsol, vector &PobIniIzq,
vector &PobIniDer);
void Mutacion(const int &m_var, const int &lMaxVsol, int &muto,
vector &AuxPob, vector &AuxlRsol);
void Busqueda_loc_A(const int &m_var, vector &lReVsol,
const int &lMaxVsol, const int &n_ec,
const vector &l_ec,
const vector &Sist, vector &AuxIzq,
vector &AuxDer, vector &PobIni,
int &fitness, int &haysol, int &cont_uno, int &cont_dos,
int &prueba);
void Busqueda_loc_B(const int &m_var, vector &lReVsol,
int main(void)
{
string problema;
const int &lMaxVsol, const int &n_ec,
const vector &l_ec,
const vector &Sist, vector &AuxIzq,
vector &AuxDer, vector &PobIni,
int &fitness, int &haysol, int &cont_uno,int &prueba);
int TamPob, lMaxVsol, NMaxIter, ProMut, Metodo, Busqueda;
int n_ec, m_var;
int haysol, muto;
int MejorFit, Sumfit, PadreIzq, PadreDer;
int i, j, k, iter;
int cont_uno, cont_dos;
181

int prueba; prueba=0;
vector l_ec;
vector Sist;
vector PobIni;
vector lReVsol;
vector AuxPob; //vector auxiliar
vector AuxlRsol; //vector auxiliar
vector fitness;
vector AuxIzq; //Sólo se utiliza en la función evalua
vector AuxDer; //Sólo se utiliaza en la función evalua
cont_uno = 0; cont_dos = 0;
randomize();
Pedir_Datos(problema, TamPob, lMaxVsol, NMaxIter, ProMut, Metodo, Busqueda);
fsol

fsol

PadreIzq = rand() % Sumfit;
eligo_padre(TamPob, PadreIzq, fitness);
PadreDer = rand() % Sumfit;
eligo_padre(TamPob, PadreDer, fitness);
// * Cruce *
Cruce(m_var, lMaxVsol, AuxPob[k], lReVsol[PadreIzq], lReVsol[PadreDer],
// * Mutación *
if(ProMut!=0)
{
muto = rand() %100;
AuxlRsol[k], PobIni[PadreIzq], PobIni[PadreDer]);
if(muto< ProMut) // * Muto la solusión k_esima *
Mutacion(m_var, lMaxVsol, muto, AuxPob[k], AuxlRsol[k]);
}//fin if(ProMut!=0)
}//fin for(k)
for(k= 0; k< TamPob; k++)
for(i= 0; i< m_var; i++)
{
lReVsol[k][i]= AuxlRsol[k][i];
for(j= 0;j< lMaxVsol; j++) PobIni[k][i][j]= AuxPob[k][i][j];
}//fin for(i)
fitness[0]= MejorFit;
for(k= 1; k

else
Busqueda_loc_A(m_var, lReVsol[k], lMaxVsol, n_ec, l_ec, Sist,
AuxIzq, AuxDer, PobIni[k], fitness[k],
haysol, cont_uno, cont_dos, prueba);
Busqueda_loc_B(m_var, lReVsol[k], lMaxVsol, n_ec, l_ec, Sist,
}//fin for(iter)
if(haysol == 1)
{
AuxIzq, AuxDer, PobIni[k], fitness[k],
haysol, cont_uno,prueba);
fsol

{
fsol

fsol

do{
cout

if(Busqueda == 3)
{
cout

for(int i= 0; i< 2*n_ec - 1; i+= 2)
{
coincidencia= 0; columnas= 0; minimo= min (l_ec[i],l_ec[i+1]);
while(Sist[i][columnas]== Sist[i+1][columnas] && columnas< minimo)
{
coincidencia= coincidencia +1; columnas= columnas +1;
}//fin while
if(coincidencia!=0)
{
l_ec[i]= l_ec[i]-coincidencia;
for(int j= 0; j< l_ec[i]; j++)
Sist[i][j]= Sist[i][j+coincidencia];
Sist[i].resize(l_ec[i]);
l_ec[i+1]= l_ec[i+1]-coincidencia;
for(int j= 0; j< l_ec[i+1]; j++)
Sist[i+1][j]= Sist[i+1][j+coincidencia];
Sist[i+1].resize(l_ec[i+1]);
}//fin if
coincidencia= 0; columnas= 1; minimo= min (l_ec[i],l_ec[i+1]);
while(columnas

void Genera_PobIni(vector &PobIni,
{
int longitud;
PobIni.resize(TamPob);
lReVsol.resize(TamPob);
vector &lReVsol,
vector &AuxPob,
vector &AuxlRsol, const int &TamPob,
const int &m_var, const int &lMaxVsol, const int &Metodo)
AuxPob.resize(TamPob); //vector auxiliar
AuxlRsol.resize(TamPob); //vector auxiliar
for(int k= 0; k< TamPob; k++)
{
PobIni[k].resize(m_var);
lReVsol[k].resize(m_var);
AuxPob[k].resize(m_var); //vector auxiliar
AuxlRsol[k].resize(m_var); //vector auxiliar
for(int i= 0; i< m_var; i++)
{
PobIni[k][i].resize(lMaxVsol);
if(Metodo == 1)
{
longitud= lMaxVsol +1;
lReVsol[k][i]= rand() % longitud;
for(int j= 0; j< lReVsol[k][i]; j++) PobIni[k][i][j]= rand() % 2;
for(int j= lReVsol[k][i]; j< lMaxVsol; j++) PobIni[k][i][j]= 2;
}//fin if(Metodo==1)
if(Metodo == 2)
{
lReVsol[k][i]= lMaxVsol;
for(int j= 0; j< lMaxVsol; j++) PobIni[k][i][j] = rand() % 3;
191

eordeno(lMaxVsol, PobIni[k][i],lReVsol[k][i]);
}//fin if(Metodo==2)
}//fin for(i)
}//fin for(k)
}//fin Genera_PobIni
void reordeno(const int &l, vector &v,int &lReVsol)
{
// Reordeno la variable y calculo la longitud real de la misma
int columna;
for(int j= 0; j< l-1; j++)
if(v[j] == 2)
{
columna= j+1;
while(v[columna] == 2 && columna< l-1) columna = columna +1;
if(v[columna]!= 2)
{
v[j]= v[columna];
v[columna]= 2;
}//fin if
}//if(v[j] == 2)
for(int j= 0; j< l; j++)
if(v[j] == 2) lReVsol= lReVsol -1;
}//fin reordeno
void Evalua(const int &n_ec, const vector &l_ec,
{
const vector &Sist, const vector &lReVsol,
const vector &PobIni, vector &AuxIzq,
vector &AuxDer, int &fitness, int &haysol,int &prueba)
int lAuxIzq, lAuxDer;
int coincidencia, minimo;
192

prueba=prueba+1;
coincidencia = 0;
for(int i= 0; i

{
}
else
{
}
lAux=lAux-1;
Aux.resize(lAux);
auxiliar=auxiliar+1;
j=j-1;
lAux=lAux+lVsol[variable]-1;
Aux.resize(lAux);
for(l= 0; l< lVsol[variable]; l++) Aux[j+l] = PobIni[variable][l];
auxiliar = auxiliar - lVsol[variable] + 1;
j=j+lVsol[variable]-1;
}//fin else
}//fin sustituyo
void Mejor_Sol(int &MejorFit, vector &fitness,
{
int minimo, variable;
variable = 0;
MejorFit = fitness[0];
const int &TamPob, const int &m_var,
vector &AuxPob, const int &lMaxVsol,
vector &PobIni,
vector &AuxlRsol, vector &lReVsol)
for(int k= 1; k< TamPob; k++)
{
if(fitness[k]< MejorFit)
{
MejorFit= fitness[k];
variable= k;
194

}//fin if(fitness[k]< MejorFit)
if(MejorFit == fitness[k])
{
minimo= rand() % 2;
if(minimo == 0)
{
MejorFit= fitness[k];
variable= k;
}//fin if(minimo == 0)
}//fin if(MejorFit == fitness[k])
}//fin for(k)
for(int i= 0; i< m_var; i++)
{
AuxPob[i].resize(lMaxVsol);
AuxlRsol[i]= lReVsol[variable][i];
for(int j= 0; j< lMaxVsol; j++) AuxPob[i][j]= PobIni[variable][i][j];
}//fin for(i)
}//fin Mejor_Sol
void Ruleta(int &Sumfit, const int &TamPob, vector &fitness)
{
Sumfit = 0;
for(int k= 0; k< TamPob; k++) Sumfit= Sumfit + fitness[k];
for(int k= 0; k< TamPob; k++) fitness[k]= Sumfit - fitness[k];
Sumfit = 0;
for(int k= 0; k< TamPob; k++) Sumfit= Sumfit + fitness[k];
}//fin Ruleta
void eligo_padre(int &TamPob, int &Padre, vector &fitness)
{
int limInf, limSup, coinciden;
coinciden= 0;
195

limInf = 0;
limSup = fitness[0];
for(int i= 0; i

if(columna == 0) AuxPob[i][j]= PobIniIzq[i][j];
else AuxPob[i][j]= PobIniDer[i][j];
}//fin for(j)
longitud= lMaxVsol - minimo;
columna= longitud +1;
columna= rand() % columna;
if(lReVsolIzq[i]< lReVsolDer[i])
{
for(int j= 0; j< columna; j++)
{
AuxPob[i][minimo+j]= PobIniDer[i][minimo+j];
if(AuxPob[i][minimo+j]!= 2) AuxlRsol[i]= AuxlRsol[i] +1;
}//fin for(j)
for(int j= columna; j< longitud; j++) AuxPob[i][minimo+j]= 2;
}//fin if
else
{
for(int j= 0; j< columna; j++)
{
AuxPob[i][minimo+j]= PobIniIzq[i][minimo+j];
if(AuxPob[i][minimo+j]!= 2) AuxlRsol[i] = AuxlRsol[i] +1;
}//fin for(j)
for(int j= columna; j< longitud; j++) AuxPob[i][minimo+j] = 2;
}//fin else
}//fin for(i)
}//fin cruce
void Mutacion(const int &m_var, const int &lMaxVsol, int &muto,
{
vector &AuxPob, vector &AuxlRsol)
for(int i= 0; i< m_var; i++){
for(int j= 0; j< lMaxVsol; j++)
197

{
muto= rand() % lMaxVsol;
if(muto == 0) AuxPob[i][j]= rand() % 3;
}//fin for (j)
AuxlRsol[i]= lMaxVsol;
reordeno(lMaxVsol, AuxPob[i],AuxlRsol[i]);
}//fin for(i)
}//fin Mutacion
void Busqueda_loc_A(const int &m_var, vector &lReVsol,
{
const int &lMaxVsol, const int &n_ec,
const vector &l_ec, const vector &Sist,
vector &AuxIzq, vector &AuxDer,
vector &PobIni, int &fitness, int &haysol,
int &cont_uno, int &cont_dos, int &prueba)
int mejoro, repito, MejorFit, columna, valor, vizq, vder;
do{
cont_uno = cont_uno +1;
repito = 0;
do{
cont_dos = cont_dos +1;
mejoro = 0;
for(int i= 0; i< m_var && fitness != 0; i++)
{
for(int j= 0; j< lReVsol[i]; j++)
{
if(PobIni[i][j] == 1) PobIni[i][j] = 0;
else PobIni[i][j] = 1;
MejorFit = fitness;
Evalua(n_ec, l_ec, Sist, lReVsol, PobIni, AuxIzq, AuxDer,
198
fitness, haysol, prueba);

if(fitness >= MejorFit)
{
}
fitness = MejorFit;
if(PobIni[i][j] == 1) PobIni[i][j] = 0;
else PobIni[i][j] = 1;
else mejoro = 1;
}//fin for(j)
}//fin for(i)
}while(mejoro == 1 && fitness != 0);
for(int i= 0; i< m_var && fitness != 0; i++)
{
//Incremento la variable i_ésima
columna = lReVsol[i];
if(columna < lMaxVsol)
{
MejorFit = fitness;
PobIni[i][columna]= 0;
lReVsol[i] = columna +1;
Evalua(n_ec,l_ec,Sist,lReVsol,PobIni,AuxIzq,AuxDer,fitness,haysol,
if(MejorFit

lReVsol[i] = columna +1;
Evalua(n_ec,l_ec,Sist,lReVsol,PobIni,AuxIzq,AuxDer,fitness,
haysol,prueba);
if(MejorFit 0 && fitness != 0)
{
valor = PobIni[i][columna -1];
if(columna < lMaxVsol) vder = PobIni[i][columna];
PobIni[i][columna -1]= 2;
if(columna < lMaxVsol) PobIni[i][columna]= 2;
MejorFit = fitness;
lReVsol[i] = columna -1;
Evalua(n_ec,l_ec,Sist,lReVsol,PobIni,AuxIzq,AuxDer,fitness,haysol,
prueba);
if(MejorFit

}
else lReVsol[i] = columna;
}//fin if
else repito = 1;
}//fin if if(lReVsol[i] > 0 && columna > 1)
}//fin for(i)
}while(repito == 1 && fitness != 0);
}//fin Busqueda_loc_A
void Busqueda_loc_B(const int &m_var, vector &lReVsol,
{
const int &lMaxVsol, const int &n_ec,
const vector &l_ec, const vector &Sist,
vector &AuxIzq, vector &AuxDer,
vector &PobIni, int &fitness, int &haysol,
int &cont_uno, int &prueba)
int repito, MejorFit, columna, valor, vizq, vder;
do{
repito = 0;
cont_uno = cont_uno +1;
for(int i= 0; i< m_var && fitness != 0; i++)
{
for(int j= 0; j< lReVsol[i]; j++)
{
if(PobIni[i][j] == 1) PobIni[i][j] = 0;
else PobIni[i][j] = 1;
MejorFit = fitness;
Evalua(n_ec, l_ec, Sist, lReVsol, PobIni, AuxIzq, AuxDer,
if(fitness >= MejorFit)
{
fitness = MejorFit;
201
fitness, haysol,prueba);

}
if(PobIni[i][j] == 1) PobIni[i][j] = 0;
else PobIni[i][j] = 1;
else repito = 1;
}//fin for(j)
//Incremento la variable i_ésima
columna = lReVsol[i];
if(columna < lMaxVsol)
{
MejorFit = fitness;
PobIni[i][columna]= 0;
lReVsol[i] = columna +1;
Evalua(n_ec, l_ec, Sist, lReVsol, PobIni, AuxIzq, AuxDer,
if(MejorFit

else repito = 1;
}//fin if(columna < lMaxVsol)
//decremento la variable i_ésima
if(columna > 0 && fitness != 0)
{
valor = PobIni[i][columna -1];
if(columna < lMaxVsol) vder = PobIni[i][columna];
PobIni[i][columna -1]= 2;
if(columna < lMaxVsol) PobIni[i][columna]= 2;
MejorFit = fitness;
lReVsol[i] = columna -1;
Evalua(n_ec, l_ec, Sist, lReVsol, PobIni, AuxIzq, AuxDer,
if(MejorFit 0 && columna > 1)
}//fin for(i)
}while(repito == 1 && fitness != 0);
}//fin Busqueda_loc_B
203
fitness, haysol,prueba);

Bibliografía
[1] Abdulrab, H.: Résolution d’equations sur les mots: étude et implementation LIPs
de l’algoritme de Makanin.
Ph. D. dissertation, Univ. Rouen, Rouen. 1987
[2] Alonso, C.L., Drubi, F., and Montaña, J.L.: An Evolutionary Algorithm for Sol-
ving Word Equation Systems.
[3] Bäck, T., Eiben, A., and Vink, M.: A superior evolutionary algorithm for 3-SAT.
In Saravanan, N., Waagen, D., and Eiben, A., editors,
Proceedings of the Seventh Annual Conference on Evolutionary Programming. Lecture Notes
in Computer Science, Volumen 1477, pages 125 − 136, Springer, Berlin, Germany. 1998
[4] Eiben, A., and van der Hauw, J.: Solving 3-SAT with adaptative genetic algo-
rithms.
In Proceedings of the Fourfth IEEE Conference on Evolutionary Computation, pages 81 − 86,
IEEE Press, Piscataway, New Jersey. 1997
[5] Goldberg, D. E.: Genetic Algorithms in Search, Optimization & Machine Lear-
ning.
Addison-Wesley Publishing Company, Inc. 1989
[6] Gottlieb, J., and Voss, N.: Improving the performance of evolutionary algorithms
for the satisfiability problem by refening functions.
In Eiben, A. et al., editors,
Proceedings of the Fifth International Conference on Parallel Problem Solving from Nature.
Lecture Notes in Computer Science, Volumen 1498, pages 755 − 764, Springer, Berlin, Ger-
many. 1998
204

[7] Gottlieb, J., and Voss, N.: Representations, fitness functions and genetic oper-
ators for the satisfiability problem.
In Hao, J.-K. et al., editors,
Proceedings of Artificial Evolution. Lecture Notes in Computer Science, Volumen 1363, pages
55 − 68, Springer, Berlin, Germany. 1998
[8] Gottlieb, J., Marchiori, E., and Rossi, C.: Evolutionary Algorithms for the Sa-
tisfiability Problem.
Massachusetts Institute of Technology. 2002
[9] Gutiérrez, C.: Solving Equations in Strings: On Makanin’s Algorithm.
Wesleyan University, Middletown, CT 06459, U.S.A.
[10] Hao, J.-K.: A clausal genetic representation and its evolutionary procedures for
satisfiatibility problems.
In Pearson, D., Steele, N., and Albrecht, R., editors,
Proceedings of the International Conference on Artificial Neural Nets and Genetic Algorithms,
pages 289 − 292, Springer, Vienna, Austria. 1995
[11] Hmelevski, J. I.: Equations in free semigroups.
Trudy Mat. Inst. Steklov. 107, 1971
[12] Holland, J. H.: Adaptation in natural and artificial systems.
Ann Arbor: The University of Michigan Press. 1975
[13] Jaffar, J.: Minimal and Complete Word Unification.
Journal ACM, Vol. 37, N o 1, January 1990, pages47 − 85
[14] Koscielski, A., and Pacholski, L.: Complexity of Makanin’s Algorithm.
Journal of the ACM, Vol. 43, July 1996, pages670 − 684
[15] Lentin, J.: Equations in free monoids, in automata languages and programming.
In Nivat, M., editors,
North Holland, pages67 − 85. 1972
[16] Makanin, G.S.: The problem of solvability of equations in a free semigroup, Math.
USSR Sbornik 32(1997) (2), 129 − 198
205

[17] Marchiori, E. and Rossi, C.: A flipping genetic algorithm for hard 3-SAT pro-
blems.
In Banzhaf, W. et al., editors,
Proceedings of Genetic and Evolutionary Computation Conference, pages 393 − 400, Morgan
Kaufmann, San Francisco, California. 1999
[18] McAllester, D., selman, B., and Kautz, H.: Evidence for invariants in local
search.
In Proceedings of the National Conference on Artificial Intelligent, pages 321 − 326, AAAI
Press, Menlo Park, California. 1997
[19] Pécuchet, J. P.: Equations avec constantes et algoritme de Makanin. These de
doctorat, Laboratoire dínformatique, Rouen, 1981
[20] Plotkin, G. D.: Building in equational theories, Mach. pages 73 − 90, 1972
[21] Robson, J. M., and Diekert, V.: On quadratic word equations.
[22] Rossi, C., Marchiori, E., and Kok, J.: An adaptive evolutionary algorithm for the
satisfiability problem.
In Carroll, J. et al., editors,
Proceedings of ACM Symposium on Applied Computing, pages 463 − 469, ACM, New York.
2000
[23] Selman, B., Kautz, H., and Cohen, B.: Noise strategies for improving local search.
In Proceedings of the Twelfth National Conference on Artificial Intelligent, pages 337 − 343,
AAAI Press, Menlo Park, California. 1994
[24] Schulz, K. U.: Word Unification and Transformation of Generalized Equatons.
Journal of Automated Reasoning 11, pages 149 − 184, 1993
[25] Siekmann, J.: A modification of Robinson’s unification procedure, M.Sc. Thesis.
1972
206