Discreta2 Resumen General

Resumen de Discreta II Maximiliano Illbele 16 de agosto de 2012

Índice 1. Coloreo y repaso de grafos 1.0.1. BFS-DFS . . . . . . . . 1.1. Coloreo . . . . . . . . . . . . . 1.1.1. Número Cromático . . . 1.1.2. Algoritmo “Greedy” para 1.1.3. Propiedades de Greedy . 1.1.4. Heurísticas . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

4 . 5 . 6 . 6 . 7 . 8 . 10

2. Flujos en networks 2.1. Algoritmo de Greedy para hallar Flujo . . . 2.1.1. Ejemplos de Greedy . . . . . . . . . 2.1.2. Complejidad de Greedy . . . . . . . . 2.2. Algoritmo de Ford y Fulkerson . . . . . . . . 2.2.1. Lema del Camino Aumentante . . . . 2.3. Teorema: Max-Flow Min-Cut . . . . . . . . 2.3.1. Complejidad de Ford Fulkerson . . . 2.4. Algoritmo de Edmonds Karp . . . . . . . . . 2.4.1. Complejidad de Edmonds-Karp . . . 2.4.2. Ejemplo de Edmonds Karp . . . . . . 2.4.3. Pseudo-Código de Edmonds Karp . . 2.5. Algoritmos Tipo Dinic . . . . . . . . . . . . 2.5.1. Esquema general Tipo Dinic . . . . . 2.5.2. Ejemplo de Dinic . . . . . . . . . . . 2.5.3. Pseudo Código algoritmos Tipo Dinic 2.5.4. Complejidad de Dinic . . . . . . . . . 2.6. Algoritmo Wave de Tarjan . . . . . . . . . . 2.6.1. Pseudo Código de Wave . . . . . . . 2.6.2. Complejidad de Wave . . . . . . . . . 2.6.3. Ejemplos de Wave . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . coloreo . . . . . . . . . .

1

. . . . . .

12 14 14 15 15 16 20 21 23 24 27 28 29 30 32 33 35 36 36 38 39

3. MST 3.1. Kruskal . . . . . . . . . . . . . . . . . . . 3.1.1. Pseudo Código de Kruskal . . . . . 3.1.2. Teorema: Kruskal devuelve un MST 3.1.3. Complejidad de Kruskal . . . . . . 3.1.4. Kruskal Delete . . . . . . . . . . . 3.1.5. Complejidad Kruskal Delete . . . . 3.1.6. Ejemplo de Kruskal . . . . . . . . . 3.2. PRIM . . . . . . . . . . . . . . . . . . . . 3.2.1. Pseudo Código de Prim . . . . . . 3.2.2. Correctitud de Prim . . . . . . . . 3.2.3. Ejemplo de Prim . . . . . . . . . . 3.3. Implementaciones de Union Find . . . . . 3.3.1. Union Find con listas enlazadas . . 3.3.2. Union Find con Representantes . . 3.3.3. Union Find con ranking . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

41 42 43 43 44 44 44 45 46 46 46 47 48 48 48 49

4. Matchings 4.1. Transformación del problema de Matching a uno de flujo maximal 4.2. Teorema de Hall . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3. Complejidad del Algoritmo de Matching . . . . . . . . . . . . . . 4.4. Grafos con Peso . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4.1. Algoritmo de “Gross” . . . . . . . . . . . . . . . . . . . . . 4.4.2. Ejemplo del algoritmo de “Gross” . . . . . . . . . . . . . . 4.5. Prueba del teorema de HALL . . . . . . . . . . . . . . . . . . . . 4.6. Teorema del Matrimonio . . . . . . . . . . . . . . . . . . . . . . . 4.7. Minimizar la Suma . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7.1. Ejemplo de Matching que minimiza la Suma (A ojo) . . . 4.7.2. Algoritmo Húngaro . . . . . . . . . . . . . . . . . . . . . . 4.7.3. Ejemplo del algoritmo Húngaro . . . . . . . . . . . . . . . 4.7.4. Complejidad de algoritmo Hungaro . . . . . . . . . . . . . 4.7.5. EJEMPLO DEL MEJORADO (FALTA) . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

51 51 53 53 53 54 55 60 61 62 62 63 63 65 67

5. Códigos de correción de errores 5.1. Cota de Hamming . . . . . . . . . 5.2. Matriz generadora . . . . . . . . . 5.3. Matriz de chequeo . . . . . . . . . 5.4. Cota Singleton . . . . . . . . . . 5.5. Códigos Cíclicos . . . . . . . . . . 5.5.1. Correción de errores “Error

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

68 71 74 75 80 80 87

. . . .

90 90 90 91 91

6. P-NP 6.1. La clase P . 6.2. La Clase NP 6.3. Co-NP . . . 6.4. SAT . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Trapping”

. . . . 2

. . . .

. . . .

. . . .

. . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . . . . . . . . . . .

. . . . . .

. . . .

. . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

6.4.1. Reducción Polinomial . . . 6.4.2. k − color ≤P SAT . . . . 6.5. NP Completo . . . . . . . . . . . 6.5.1. 3-SAT es NP completo . . 6.5.2. 3-color es NP completo . . 6.5.3. Ejemplo 3-SAT ≤P 3-color 6.5.4. 2-SAT ∈ P . . . . . . . . . 6.5.5. HORN-SAT . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

92 92 94 94 96 97 100 101

7. Introducción a la Inteligencia Artificial 7.1. Hill Climbing . . . . . . . . . . . . . . . . . . . . 7.2. Simulated Annealing . . . . . . . . . . . . . . . . 7.3. Algoritmos Evolutivos . . . . . . . . . . . . . . . 7.4. Algoritmos Genéticos . . . . . . . . . . . . . . . . 7.4.1. Selección . . . . . . . . . . . . . . . . . . . 7.5. Ejemplo de un AG . . . . . . . . . . . . . . . . . 7.5.1. Codificación del ejemplo . . . . . . . . . . 7.5.2. Fitness del ejemplo . . . . . . . . . . . . . 7.5.3. Entrecruzamiento del ejemplo . . . . . . . 7.5.4. Mutación del ejemplo . . . . . . . . . . . . 7.5.5. Selección del ejemplo . . . . . . . . . . . . 7.5.6. Operadores de Selección . . . . . . . . . . 7.5.7. Remainde Methods (Métodos del “Resto”) 7.5.8. Otros métodos Fitness Proportional . . . . 7.5.9. Sigma Scaling . . . . . . . . . . . . . . . . 7.5.10. Crossover . . . . . . . . . . . . . . . . . . 7.5.11. Mutación . . . . . . . . . . . . . . . . . . 7.5.12. Mutaciones con Permutaciones . . . . . . . 7.6. No Free Lunch . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

102 102 102 102 102 103 103 104 104 104 104 105 105 107 107 108 109 110 110 111

3

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

1.

Coloreo y repaso de grafos

Recordemos que un grafo G es un par (V, E) donde E ⊆ {A ⊆ V : |A| = 2}. Donde V es el conjunto de vértices onodos y E es el conjuntode lados1 o aristas. Ejemplo: sea G = {1, 2, 3}, {1, 2}, {1, 3} Gráfico(G) :

2

1<

<< << << <

3

Notación usual {x, y} → xy “Vecinos” de un nodo x: Γ(x) = {y ∈ V : xy ∈ E} Grado2 o Valencia de un vértice: d(x) = Γ(x) Menor valencia de G: δ = m´ın{d(x) : x ∈ V } Mayor valencia de G: ∆ = máx{d(x) : x ∈ V } Definiciones Un grafo es regular si δ = ∆, a veces llamados “k-regular”. Un camino es una sucesión de vértices x1 , x2 , . . . , xt todos distintos tales que xi xi+1 ∈ E. Un grafo es conexo si ∀par de vértices ∃ un camino entre ellos. Conexo

2

1 ==

4 == == == _3

Disconexo _5

1 ==

== == == _3

4 ==

== == ==

2 En general definimos x ≈ y ⇔ ∃ camino entre x e y.

Ejercicio: demostrar que ≈ es una relación de equivalencia. 1. Reflexividad: x ≈ x 2. Simetría: x ≈ y ⇒ y ≈ x x≈y 3. Transitividad: ⇒x≈z y≈z 1 2

Edges. Degree.

4

5

Una componente conexa de G es una clase de equivalencia de la relación ≈. Notación La cantidad de vértices: n = |V |. La cantidad de lados: m = |E|. Observación n m≤ = 2

n∗(n−1) 2

Si G es conexo ⇒ n − 1 ≤ m 1.0.1.

BFS-DFS DFS(x)-Depth First Search3

Su funcionamiento consiste en ir expandiendo todos y cada uno de los nodos que va localizando, de forma recurrente, en un camino concreto. Cuando ya no quedan más nodos que visitar en dicho camino, sube en el árbol, de modo que repite el mismo proceso con cada uno de los hermanos del nodo ya procesado. Ejemplo DFS

G⇒

A z ??? zz ?? z ?? zz z ? zz _ _ D C B y @@ mmm yy mmmmm@@@ y y m @@ yyymymmmm @ m m E

DF S(A) ⇒

A

N ivel 0

B

N ivel 1

G

C

F

N ivel 2

D@

E

N ivel 3

@@ @@ @@ @

G

N ivel 4

F

3

DFS: Búsqueda en profundidad.

5

N ivel 5

BFS(x) - Breadth First Search4 Intuitivamente, se comienza en la raíz x y se exploran todos sus vecinos. A continuación para cada uno de los vecinos se exploran sus respectivos vecinos adyacentes, y así hasta que se recorra todo el Grafo. Ejemplo BFS BF S(A) ⇒

G⇒

A? ?? zz z ?? z z ?? zz ? z z _D _ B C y @@ mmm yy mmmmm@@@ y y m @@ yyymymmmm @ mm E

1.1.

B

G

A ss ??? s s ?? ss ?? sss s ? s ss C

E

G

F

F

D

N ivel 0 N ivel 1 N ivel 2 N ivel 3

Coloreo

Un coloreo (propio) de G = (V, E) con k colores es una función C : V → {1, 2, . . . , k} tal que si: xy ∈ E ⇒ C(x) 6= C(y) Ejemplo de coloreo A(1)

FF x FF xx FF x FF xx x F x x _ D(2) _ C(3) B(2) FF kkk x xx kkkkkFkFF x FF x kk FF xxxkxkkkkk k

E(1)

G(1)

F (2) 1.1.1.

Número Cromático

En general deseamos calcular el número cromático de G : χ(G). Donde χ(G) = m´ın{k : ∃ un coloreo propio de G con k colores }. Propiedad: 1 ≤ χ(G) ≤ n 4

BFS: búsqueda en anchura.

6

1.1.2.

Algoritmo “Greedy” para coloreo

Requiere un orden de los vértices: x1 , . . . , xn . Inicio: C(x1 ) = 1 Para j > 1 C(xj ) = El menor color que no crea conflicto con los vértices ya coloreados. n o C(xj ) = m´ın k : C(xi ) 6= k ∀i < j : xi ∈ Γ(xj ) Invariante: en todo momento el coloreo es propio, por lo tanto al terminar da un coloreo propio. Ejemplo: _D _ @@ ~B @@@ C ~ ~ @@ ~ ~ @ ~ ~ @@ @@ ~ ~ ~ ~ @@ @ ~ ~~ @@@~~~ @ E A@ ~~~ @@@ @@ ~~ @@ ~~~ @@ ~ @@ @@ ~~ ~~ @ ~~~ @ ~~ _

G

Orden alfabético Vértices A B C D E Color 1 2 1 2 1

F

F 3

G 4

Orden alternativo G C D F B A 1 2 3 2 1 2

E 1

Complejidad de coloreo con Greedy O d(x1 ) + d(x2 ) + . . . + d(xn ) = O(2m) = O(m) Teorema: sea G = C2r+1 ⇒ χ(G) = 3 Prueba: Supongamos que χ(G) = 2 Sea A el color del primer vértice. Sea B el color del segundo vértice. x1 x2 ∈ E ⇒ A 6= B Como estamos suponiendo χ(G) = 2 estos son los únicos colores que podemos usar. Como x2 x3 ∈ E ⇒ C(x3 ) 6= B ⇒ C(x3 ) = A Como5 x3 x4 ∈ E ⇒ C(x4 ) = B Por inducción: A cuando i es Impar C(xi ) = B cuando i es Par Pero entonces el lado x1 x2r+1 tiene los 2 vértices del mismo color Absurdo. |{z} | {z } A

A

5

Este paso es sólo ilustrativo no forma parte de una demostración formal ya que no sabemos si n > 3 ó n = 3.

7

∴ χ(G) ≥ 3 Y está claro que con 3 colores alcanza definimos:   A cuando i es Impar < 2r + 1 B cuando i es Par C(xi ) =  C cuando i = 2r + 1 Corolario: si C2r+1 ⊆ G ⇒ χ(G) ≥ 3 Definición: un grafo G es bipartito si: χ(G) = 2 Teorema: G es bipartito ⇔ @C2r+1 ⊆ G Más aún existe un algoritmo de complejidad polinomial para determinar si G es bipartito o no. Prueba: el algoritmo que daremos da un coloreo (propio) con dos colores, si χ(G) = 2, y si el algoritmo colorea con más de 2 colores entonces veremos que existe C2r+1 ⊆ G ∴ χ(G) ≥ 3 En realidad esto lo haremos para cada componente conexa de G. Vamos a suponer G conexo. Sea x ∈ V , y corramos BF S(x) y tomemos el siguiente coloreo que puede no ser propio:   0 Nivel BF S(x), z es Par C(z) =  1 Nivel BF S(x), z es Impar Si ese coloreo es propio ya está. Supongamos que no ⇒ ∃v, w : vw ∈ E : C(v) = C(w) Como vw ∈ E y estamos usando BFS, Si v fue puesto antes que w en el árbol entonces debe ser: nivel(w) = nivel(v + 1) ⇒ Absurdo pues nivel(v) ≡ nivel(w) (2) O bien nivel(v) = nivel(w) ∴ Hay un ciclo impar ⇒ χ(G) ≥ 3 1.1.3.

Propiedades de Greedy

Analizando a Greedy, podemos decir que en ciertos casos puede andar muy mal Ejemplo: i es Impar Sea G : V = {1, . . . , 2r} y con E = ij y j 6= i + 1 j es P ar Para simplificar veamos el grafo correspondiente a r = 4 x1 BUQQUUU x3 BQQ mmx5 B iiimimx7 BBQQ|QU|Q|UUUU BmBmQmQ|Q|Q|iiiiBimBmm||| B| QmQmmUUBiU|ii QmQmm B| |m|BmBmiBmBimiiQiQi|Q|iQm|QBmUBmBUmBUmUUQUQ|UQ|Q|QBBBB | | mii | m QQ | UUUQUQ x2 imi x4 m x6 x8 8

Luego Greedy corriendo en orden x1 , . . . , x2r = x8 va a necesitar r = 4 colores: Color Vértice Pero si definimos C(xi ) =

1 x1 x2

2 x3 x4

3 x5 x6

4 x7 x8

1 i es impar nos queda que χ(G) = 2 2 i es par

Conclusión: Greedy(G) devuelve un coloreo que usa r colores, pero vimos que χ(G) = 2. Sin embargo . . . Propiedad: ∀G ∃ un ordenamiento {x1 , . . . , xn } de los vértices de G en el cual Greedy() obtiene: χ(G) Prueba: sea t = χ(G)  Sean V1 los vértices de color 1   Sean V2 los vértices de color 2 en algún coloreo (propio) con t colores. ..  .   Sean V los vértices de color t  t

Inducción en t: Si t = 1 obvio. Supongamos que vale para t − 1 Orden de los vértices: Los de V1 < los de V2 < . . . < los de Vt , en Vi los ordeno como quiero. Por hipótesis inductiva hasta Vt−1 lo coloreamos con t − 1 colores. Los de Vt no están unidos entre si ⇒ Greedy en cada uno de sus vértices usará uno de los primeros t − 1 colores o el color t, nunca hay conflicto entre ellos que demande un color t + 1. Propiedad: χ(G) ≤ ∆ + 1 Prueba: usar Greedy en cualquier orden. Cuando vayamos a colorear xi lo peor que puede pasar es que todos los vecinos ya estén coloreados y con colores distintos, esto forzaría a Greedy() a usar un color distinto a esos d(xi ) de esos colores. Pero d(xi ) ≤ ∆ ∴ Greedy con ∆ + 1 colores se las arregla.

9

Más aún, si G es conexo o todas sus componentes conexas sean no regulares, tenemos que: δ 6= ∆ ⇒ χ(G) ≤ ∆ Prueba: sea x ∈ V : d(x) = δ Corramos BF S(x)6 y sea x1 , . . . , xn el orden inverso al de BFS(x) ∴ xn = x En BF S(x)7 todo vértice, salvo x es incorporado al árbol por medio de un vecino que ya está en el árbol. ∴ En el orden inverso todo vértice distinto de x tiene un vecino posterior en el orden (x1 , . . . , xn ). ∴ Cuando Greedy va a colorear xi : i < n, como xi tiene por lo menos un vecino posterior entonces xi tiene ≤ d(xi ) − 1 vecinos anteriores. ∴ Hay a lo sumo d(xi ) − 1 ≤ ∆ − 1 posibles “conflictos”. ∴ Greedy puede colorear con alguno de los ∆ colores. Ahora queda colorear xn = x Greedy necesita usar d(x) + 1 colores: d(x) = δ < ∆ ⇒ δ + 1 ≤ ∆ Ejemplos donde χ(G) = ∆ + 1 1. Los ciclos impares: χ(C2r+1 ) = 3 = 2 + 1 = ∆ + 1 2. Los grafos completos: χ(Kn ) = n = (n − 1) + 1 = ∆ + 1 El teorema de Brooks dice que si G es conexo esos son los únicos ejemplos. 1.1.4.

Heurísticas

1. Welsh-Powell Greedy en el orden: d(x1 ) ≥ d(x2 ) ≥ . . . ≥ d(xn ) 2. Matul-Marble-Isaacson xn : d(xn ) = δ Sea Gn−1 = Gn − xn Tomo xn−1 : δGn−1 (xn−1 ) = δ(Gn−1 ) y así seguimos . . . 1 >MMM 3 ; qqqqq5 >> MMM qqq;qq;qq;q >> qqMqqMqqM ; q>qq MM ; q qqqq >> MMM;M; qqqqq 2 4 6

2 6 7

3 qqq qqqqqqqqq q qqqqq qqqqqqqqq qqq

2

3 > qqq5 q>q>qq>qqqqq qqqq >>> qqqqqqqqq > qq qqqqq 4

5

6

pp5 ppppp p p p p ppppp ppppp p p p p pp ppppp

3

2

4

3 2

2

O lo mismo DF S(x). O DF S(x).

10

Luego corro Greedy con: x6 = 1 x5 = 6 x4 = 4 x3 = 5 x2 = 3 x1 = 2 Es decir en el orden: 2, 3, 5, 4, 6, 1 Y nos da χ(G) = 2 3. RLF: Recursive Largest First 1 RLF( ) 2 { 3 color = 1; 4 R = V; // Vértices no C o l o r e a d o s 5 while ( R 6= ∅ ) { 6 L = R; 7 while ( L 6= ∅ ) { 8 Tomar v de L : V t e n g a l a mayor c a n t i d a d de v e c i n o s en R 9 Color ( v ) = c o l o r ; 10 Remover ( v ) de R; 11 Remover ( v ) y Γ(v ) de L ; 12 } 13 C o l o r ++; 14 } 15 }

4. D-Satur d5 (x) = #de colores de los vecinos coloreados de x . Corre Greedy con un orden dinámico eligiendo como “próximo vértice” el que tenga d5 más grande.

11

2.

Flujos en networks

Un network (dirigido) es un grafo dirigido, es decir un par (V, E) : E ⊆ V ∗ V con pesos en los lados, es decir con una función C : E → R. En este contexto siempre pediremos C : E → R≥0 y los C(x, y) se llaman capacidades. Notación: → (x,y) → xy (si se sobreentiende por el contexto también xy). →

Γ+ (x) = {y ∈ V : xy ∈ E}. →

Γ− (x) = {y ∈ V : yx ∈ E}. Γ(x) = Γ+ (x) ∪ Γ− (x). Definición: dado un network N = (V, E, C) y vértices distinguidos s, t ∈ V , un flujo en N , de s a t es una función f : E → R tal que: →

→

→

1. Feasability8 : 0 ≤ f (xy) ≤ C(xy) ∀xy ∈ E P P → → 2. Conservación: f (xy) = f (yx) ∀x 6= s, t y∈Γ+ (x)

y∈Γ− (x)

3. s Productor: X

→

f (sy) ≥

X

→

f (ys)

y∈Γ− (s)

y∈Γ+ (s)

10 Como s produce se llama la fuente9 y t se llamará . P resumidero → En algunos textos se pide directamente que: f (ys) = 0 y∈Γ− (s) →

O más aún: C(ys) = 0 ∀y ∈ Γ− (s) Notación: P → f (xy) = Outf (x) y∈Γ+ (x)

P

→

f (yx) = Inf (x)

y∈Γ− (x)

Definición: el valor del flujo es V (f ) = Outf (s) − Inf (s)

8

Viabilidad. Source. 10 Sink. 9

12

Propiedad: V (f ) = Inf (t) − Outf (t) Prueba: Sea D = Inf (t) − Outf (t)  

0 x 6= s, t V (f ) x = s  −D x = t P ∴ Outf (x) − Inf (x) = V (f ) − D ? Outf (x) − Inf (x) =

x∈V →

P

Notación: Si A, B ⊆ V entonces f (A, B) =

f (xy)

x∈A y∈B → xy ∈ E X

Outf (x) =

X X

→

f (xy)

(1)

x∈V y∈Γ+ (x)

x∈V

X

=

→

f (xy)

x, y ∈ V → xy ∈ E = f (V, V )

(2)

( 1) Por definición de Outf (x). ( 2) Notación. Similarmente: X X X → Inf (x) = f (yx) x∈V y∈Γ− (x)

x∈V

=

X

→

f (yx)

x, y ∈ V → yx ∈ E = f (V, V ) ( 3) Por definición de Inf (x). ∴ ? Nos queda: f (V, V ) − f (V, V ) = V (f ) − D {z } | =0

∴ V (f ) = D

13

(3)

Problema a resolver: dado un network N hallar f que maximice V (f ). Esto se conoce como el problema del flujo maximal11 . Notación: −→ Sea s = x0 , x1 , . . . , xr = t : xi xi+1 ∈ E , la notación: s, x1 , . . . , xr−1 , t : Significa que se mandan unidades de flujo a través de ese camino, es decir, si G era un flujo existente definimos: ( −→ −→ −→ → G(xi xi+1 ) + Si xy = xi xi+1 f (xy) = −→ G( xy) Si no

2.1.

Algoritmo de Greedy para hallar Flujo

“Hasta que no se pueda más buscar caminos de s a t y mandar flujo por ellos.” 2.1.1.

Ejemplos de Greedy →

Todas las capacidades son 10, excepto C(EF ) = 15. /

?A

C@ @

@@ @@ @

s>

>> >> >> >

B

/

D

E ~> ~ ~ ~~ ~~

/

F

> G >> >> ~~ ~ >> ~ ~ >> ~~ ?t @@ @@ @@ @

H

Corremos Greedy en orden alfabético 1. Primer camino: s, A, C, E, F, G, t: 10 2. Segundo camino: s, B, D, E, F, H, t: 5 3. No hay más caminos posibles. Para este ejemplo podemos demostrar que no sólo es flujo sino también que es →

maximal, ya que, en pocas palabras C(EF ) = 15 y es un cuello de botella, y nos →

da: f (EF ) = 15 →

→

Ejemplo: todas las capacidades son 1000 excepto: C(CD) = 1 y C(CB) = 900 /B A G >> ? 00 >> 00 >> 0 >> 00 0 s? ?t ?? 000 ?? 00 ?? 0 ? / D C

Corremos Greedy con el orden alfabético 11

Por ahora no está claro que f exista.

14

1. Primer camino: s, A, B, t: 1000 2. Segundo camino: s, C, D, t: 1 3. Terminamos porque no hay más posibles caminos. En este caso el flujo obtenido (1001) no es maximal, el flujo maximal correspondiente es: (1901) Eligiendo caminos obtenemos el flujo maximal correspondiente :1901 1. Primer camino: s, A, D, t: 999 2. Segundo camino: s, A, B, t: 1 3. Tercer camino: s, C, B, t: 900 4. Cuarto camino: s, C, D, t: 1 2.1.2.

Complejidad de Greedy Greedy

Buscar camino dirigido: O(m) Aumentar en ese camino: O(n) Total por aumento: O(m) + O(n) = O(m) ¿Cuántos aumentos de flujo hay? →

→

En Greedy una vez que un lado se “satura”, es decir f (xy) = C(xy), no se vuelve a usar, ya que no se devuelve flujo. Además sabemos que por cada aumento se satura al menos un lado. ∴ Hay a lo sumo m aumentos. ∴ Complejidad(Greedy) = m ∗ O(m) = O(m2 )

2.2.

Algoritmo de Ford y Fulkerson

Definición: un camino aumentante12 de s a t es una sucesión de vértices: s = x0 , x1 , . . . , xr = t : ∀i ≤ r − 1 −→ −→ −→ O bien: xi xi+1 ∈ E : f (xi xi+1 ) < C xi xi+1 estos son los lados Forward. −→

−→

O bien: xi+1 xi ∈ E : f (xi+1 xi ) > 0 i.e. que haya mandado flujo, lados Backward. “Hasta que no se pueda más buscar caminos aumentantes y mandar flujo por ellos”. 12

Augmenting path.

15

2.2.1.

Lema del Camino Aumentante

Si f es un flujo y se aumenta a lo largo de un camino aumentante el resultado también es flujo. Más aún si se manda por el camino aumentante, el valor del nuevo flujo es V (f ) + . Prueba: Sea s = x0 , x1 , . . . , xr = t un camino aumentante. ( −→ −→ C(xi xi+1 ) − f (xi xi+1 ) para los lados forward Sea i = −→ f (xi+1 xi ) para los lados backward Elijo = m´ın{i } “Aumentar f ” es tomar  −→ → −→   f (xi xi+1 ) + Si xy = xi xi+1 forward → −→ → −→ f ∗ (xy) = f (xi+1 xi ) − Si xy = xi+1 xi backward  →  f (xy) en caso contrario Queremos ver que f ∗ es flujo y que V (f ∗ ) = V (f ) + Feasability: Obvio por definición de i , . Conservación: x 6= s, t ⇒ x = xi : 0 < i < r. Hay que analizar 4 casos: +

+

1. F-F: xi−1 −→ xi −→ xi+1 →

Outf ∗ (xi ) = Outf (xi ) + // xi xi+1 →

Inf ∗ (xi ) = Inf (xi ) + // xi−1 xi Outf ∗ (xi ) − Inf ∗ (xi ) = Outf (xi ) − Inf (xi ) + − = 0 porque f es flujo. +

−

2. F-B: xi−1 −→ xi ←− xi+1 Outf ∗ (xi ) = Outf (xi ) Inf ∗ (xi ) = Inf (xi ) + − Luego: Outf ∗ (xi ) − Inf ∗ (xi ) = 0 −

+

3. B-F: xi−1 ←− xi −→ xi+1 Inf ∗ (xi ) = Inf (xi ) Outf ∗ (xi ) = Outf (xi ) + − Luego: Outf ∗ (xi ) − Inf ∗ (xi ) = 0

16

−

−

4. B-B: xi−1 ←− xi ←− xi+1 Inf ∗ (xi ) = Inf (xi ) − Outf ∗ (xi ) = Outf (xi ) − Luego: Outf ∗ (xi ) − Inf ∗ (xi ) = 0 En el caso de s: +

1. s −→ x1 Outf ∗ (s) = Outf (s) + Inf ∗ (s) = Inf (s) ∴ V (f ∗ ) = V (f ) + −

2. s ←− x1 Outf ∗ (s) = Outf (s) Inf ∗ (s) = Inf (s) − ∴ V (f ∗ ) = V (f ) − (−) = V (f ) +

Definición: dado N = (V, E, C) con vértices s = fuente, t = resumidero. Un corte es un subconjunto S ⊆ V : s ∈ S, t 6∈ S Ejemplos de cortes: S = {s}. S = V − {t}. ¿Cuántos cortes hay? 2n−2 La capacidad de un corte S es: Cap(S) = C(S, S) : S = V − S X → = C(xy) x∈S y∈S → xy ∈ E

17

Lema: sea N network, f flujo y S corte entonces: 1. V (f ) = f (S, S) − f (S, S) 2. V (f ) ≤ Cap(S) 3. Si V (f ) = Cap(S) entonces f es Maximal, y S es Minimal i.e. el corte de menor capacidad. Prueba: 1. Observemos que: f (A ∪ B, C) = f (A, C) + f (B, C) : A, B disjuntos. f (A, B ∪ C) = f (A, B) + f (A, C) : B, C disjuntos. Además: Outf (x) = f {x}, V Inf (x) = f V, {x} Además si x ∈ S: Outf (x) − Inf (x) =

V (f ) Si x = s 0 Si x 6= s pues t 6∈ S

X Outf (x) − Inf (x) = 0 + . . . + 0 + V (f ) x∈S

= V (f ) X X ∴ V (f ) = Outf (x) − Inf (x) x∈S

x∈S

X X = f {x}, V − f V, {x} x∈S

(4)

x∈S

= f (S, V ) − f (V, S) = f (S, S ∪ S) − f (S ∪ S, S)

(5)

S) S) = f (S, + f (S, S) − f (S, S) − f (S,

(6)

= f (S, S) − f (S, S) ( 4) Por la observación. ( 5) V = S ∪ S. ( 6) Disjuntos.

18

1

2. V (f ) = f (S, S) − f (S, S) | {z } ≥0 | {z } <0

∴ V (f ) ≤ f (S, S) ≤ C(S, S) = Cap(S) 3. Sea g un flujo cualquiera: 2

Hip(3)

V (g) ≤ Cap(S) = V (f ) ⇒ f es maximal Similarmente, si T es corte tenemos que: 2

Cap(T ) ≥ V (g) ∀g En particular elijo como flujo a f y me queda: 2

Hip

Cap(T ) ≥ V (f ) = Cap(S) ∴ S es minimal

19

2.3.

Teorema: Max-Flow Min-Cut

En todo network el valor de todo flujo maximal es igual a la capacidad de todo corte minimal, es decir si f es maximal ⇒ ∃S corte : V (f ) = Cap(S). Demostración: dado f maximal13 construyamos S recursivamente así: s ∈ S por definición. →

→

? Si x ∈ S, y ∈ Γ+ (x) : f (xy) < C(xy) entonces agregamos “y” a S. →

† Si x ∈ S, y ∈ Γ− (x) : f (yx) > 0 entonces agregamos “y” a S. Es decir S es el conjunto de vértices que revisamos tratando de obtener un camino aumentante de s a t. Si t estuviera en S habría un camino aumentante de s a t. Por el lema del camino aumentante podríamos construir un flujo g tal que: V (g) = V (f ) + para algún > 0 ∴ V (g) > V (f ) Absurdo pues f es maximal. ∴ t 6∈ S i.e. S es corte. Sólo resta ver que: V (f ) = Cap(S) ∴ Por el lema anterior: V (f ) = f (S, S) − f (S, S)  ? → → x ∈ S  ⇒ f (xy) = C(xy) porque sino hubieramos agregado a “y” en algún momento. Si y 6∈ S →  Def xy ∈ E ⇒ f (S, S) = C(S, S) = Cap(S)  x∈S  → † ⇒ f (yx) = 0 ⇒ f S, S = 0 Si y 6∈ S →  yx ∈ E

∴ V (f ) = f (S, S) − f (S, S) = Cap(S) − 0 = Cap(S)

Corolario14 : Ford-Fulkerson es correcto i.e. si el output es un flujo f , entonces f es maximal. Prueba: el algoritmo aumenta a partir del flujo “0” usando caminos aumentantes hasta que no encuentra más caminos. Sea f el flujo obtenido allí. 13 14

Todavía no demostramos que exista. De la demostración.

20

Cuando < F − F >15 intentó aumentar f no pudo, entonces @ camino aumentante para f entre s y t. ∴ Los vértices que se buscaron formaron un corte S. Por la prueba del teorema16 , tenemos que V (f ) = Cap(S) entonces f es maximal por el lema previo al teorema. 2.3.1.

Complejidad de Ford Fulkerson

Los lados se pueden des-saturar por lo tanto el análisis de Greedy no vale. De todas maneras existen ejemplos en que < F − F > no termina, por lo que no podemos hablar de su complejidad. Ejemplo en que < F − F > no termina / y1 j ?? ?? ?? ?? / y2 /2 t ?

x1 ~? ~ ~~ ~~ ~ ~ / x2 s@ @@ @@ @@ @

/ y3

x3

−→

−→

−→

−→

Capacidades: todas 2 salvo: st : 1000 x1 y1 : 1 x2 y2 : r x3 y3 : r2 √ −1+ 5 Donde: r = 2 es raíz de: P (r) = r2 + r − 1 Observación: 1 − r = r2 r − r2 = r3 Satisface: 1 > r > r2 > . . . > rk > rk+1 Corramos < F − F > 1. s, x1 , y1 , t : 1 ←−

2. s, x3 , y3 , y1 , x1 , x2 , y2 , t : r2 ←−

3. s, x2 , y2 , y3 , x3 , x1 , y1 , t : r3 ←−

4. s, x1 , y1 , y2 , x2 , x3 , y3 , t : r4 Luego < F − F > repite (2) (3) (4) con r5 r6 r7 . . . 15 16

Denotaremos así al algoritmo de Ford-Fulkerson. Max Flow Min Cut.

21

∴< F − F > no termina, más aún si fi son los flujos intermedios: l´ım V (fi ) = 1 + r + r2 + r3 + . . .

i→∞

=

∞ X

ri − r

i=0

1 −r 1−r 1 − r(1 − r) = =2 1−r =

Pero el flujo maximal es: 1002, mandando st = 1000. Observación: si las capacidades son enteras entonces como el primer valor del flujo es 0 ∈ Z, y aumenta por: C −f = m´ın{i } : i = ∈Z f Entonces será un entero y los flujos intermedios también. ∴ Si les llamamos f1 , f2 , . . . ⇒ V (fi+1 ) ≥ V (fi ) + 1. Como hay cota superior, como por ejemplo: Cap({s}), en algún momento debemos parar. Es decir si las capacidades son enteras < F − F > siempre termina, inclusive cuando termina sabemos que el flujo que devuelve es entero, sumado al hecho de que < F − F > terminó, sabemos que ese flujo es maximal. Y llegamos a demostrar el Teorema de la integralidad: si las capacidades son enteras entonces existe un flujo maximal entero. Ejemplo ?A> s? ?? ?? ?? ?

>> >> >> > ?t

B

−→

Capacidades: AB : 1, las demás: 106 Corremos < F − F >: 1. s, A, B, t : 1 ←−

2. s, B, A, t : 1 Luego repetimos los pasos: (1 ↔ 2) 2 ∗ 106 veces, pero vamos a terminar en algún momento. Anexo: recordemos la notación δ(u, v) que referencia la longitud del menor camino entre u y v.

22

Lema: sea G un grafo conexo, dirigido o no, sea T = BF S(x) para algún x ∈ V , entonces: ∀z ∈ V δ(z, x) = N ivelT (z) Prueba: ?

Como T ⊆ G ⇒ δG (z, x) ≤ δT (z, x) = N ivelT (z) Para demostrar que vale el “=” lo vamos a hacer por inducción en δ(z, x). Caso base: δ(z, x) = 0 ⇒ z = x ⇒ N ivelT (z) = 0 = δ(z, x) Paso inductivo: Supongamos que vale para δ(z, x) = k y tomemos un z con δ(z, x) = k+1. Por lo que vimos al comienzo de la prueba: k + 1 = δG (z, x) ≤ N ivelT (z) Si es igual ya está. Entonces supongamos que N ivelT (z) = j > k + 1 Luego δ(z, x) = k + 1 ⇒ ∃ un camino de longitud mínima entre x y z de la forma: x = x0 , x1 , . . . , xk , xk+1 = z H.Ind

Entonces x = x0 , x1 , . . . , xk es de longitud mínima entre x y xk ⇒ δ(x, xk ) = k ⇒ N ivelT (xk ) = k  xk z ∈ E  T =BF S(x) N ivelT (z) = j ⇒ |j − k| ≤ 1  N ivelT (xk ) = k Ya que como son vecinos la diferencia de nivel es 0 ó 1. |j − k| ≤ 1 P ero ⇒ Absurdo. j >k+1

2.4.

Algoritmo de Edmonds Karp

En 1970 Edmonds y Karp dieron 2 “heurísticas”, que de ahora en adelante llamaremos < E − K >. Consiste en correr < F − F > usando caminos aumentantes de longitud mínima: < E − K > = < F − F > +BF S

23

2.4.1.

Complejidad de Edmonds-Karp

Teorema: la complejidad17 de < E − K > es O(nm2 ). Prueba: Supongamos que < E − K > crea flujos intermedios: O = f0 , f1 , . . . El paso k es el paso que “crea” fk Defino: dk (x) = “distancia” entre s y x en el paso k. bk (x) = “distancia” entre x y t en el paso k. “Distancia”: longitud del menor camino aumentante entre dos vértices. Lema interno dk (x) ≤ dk+1 (x) bk (x) ≤ bk+1 (x) Prueba: lo haremos para d ya que para b es similar. n o Sea A = z ∈ V : dk+1 (z) < dk (z) Queremos ver que A = ∅, supongamos que no y lleguemos a un absurdo. Si A 6= ∅ tomamos q ∈ A tal que dk+1 (q) ≤ dk+1 (z) ∀z ∈ A (1) Como q ∈ A ⇒ dk+1 (q) < dk (q) (2) Observación: q 6= s pues dk+1 (s) = dk (s) = 0 Sea s = x0 , x1 , . . . , xr−1 , xr = q Un camino aumentante de longitud mínima r = dk+1 (q) entre s y q. (El camino existe pues (2) ⇒ dk+1 (q) < ∞). Sea x = xr−1 Tenemos: dk+1 (x) = r − 1 = dk+1 (q) − 1 < dk+1 (q) ∴ dk+1 (x) < dk+1 (q) (3) dk+1 (x) < dk+1 (q) ⇒ x 6∈ A por (1) (En otras palabras, como x está antes que q, no puede estar en A) Luego como x 6∈ A ⇒ dk (x) ≤ dk+1 (x) (4)

17

Recordando que: n = |V | y m = |E|.

24

Diremos que un lado (u, v) está “disponible” en un paso j si: →

→

Es Forward con fj−1 (uv) < C(uv) → → Es Backward con fj−1 (vu) > 0 i.e. vu ∈ E ¿Está disponible (x, q) en el paso k? Supongamos que sí entonces: dk (q) ≤ dk (x) + 1 (4)

≤ dk+1 (x) + 1 (3)

= dk+1 (q) ⇒ Contradice (2) Absurdo!

Por lo tanto xq no está disponible en el paso k, pero sí lo está en el paso k + 1. Entonces lo usamos para el otro lado en el paso k, i.e. (q, x) se usó en el paso k. Como estamos usando < E − K > los caminos aumentantes son de longitud mínima. ∴ dk (x) = dk (q) + 1 (5) (3)

Entonces: dk+1 (q) = dk+1 (x) + 1 (4)

≥ dk (x) + 1 (5)

= dk (q) + 1 + 1 = dk (q) + 2 (2)

> dk+1 (q) + 2 ⇔ 0 > 2 Absurdo! Fin Lema Interno Continuando con el teorema, llamemos “crítico” a un lado disponible en un paso y no en el siguiente. Supongamos que xz se vuelve crítico en el paso k, antes de poder ser crítico otra vez debe ser usado en la otra dirección, sea L > k el paso donde se usa la próxima vez para el otro lado.    dk (z) = dk (x) + 1 ? Pues estoy en < E − K > entonces   d (x) = d (z) + 1 † L L dL (t) = dL (x) + bL (x) = dL (z) + 1 + bL (x) ≥ dk (z) + 1 + bk (x) = dk (x) + 1 + 1 + bk (x) = dk (t) + 2 25

(7) (8) (9)

∴ dL (t) ≥ dk (t) + 2 ( 7) Por † ( 8) Por el Lema Interno ( 9) Por ? Por lo tanto cuando un lado se vuelve crítico recién puede volver a usarse cuando la distancia a t haya aumentado en por lo menos 2. # Veces que un lado puede volverse crítico = O(n) Exactamente sería: n−1 2 Complejidad de cada búsqueda BF S + Aumento = O(m) + O(n) = O(m) En cada aumento al menos un lado se vuelve crítico. Hay m lados y cada uno se vuelve crítico ≤ O(n) veces. ∴ Complejidad(< E − K >) = O(m) ∗ O(m) ∗ O(n) = O(nm2 )

Corolario de la complejidad de < E − K > Siempre existe un flujo maximal.

26

2.4.2.

Ejemplo de Edmonds Karp

Capacidades sA:20

Caminos Primer Camino: s, A, B, t : 10 A C B E F I D K s s A A A A C C 20 20 20 3 10 3 10 10

s sC:20

AB:20 s

A s 10

s

A C s s 7 10

AE:3

C s 20

AF:10 AI:3

Bt:10 s BI:10 BJ:10 CD:10 s CK:10

Segundo B E A A 10 3

Camino: s, A, I, t : 3 F I D K J A A C C B 10 3 10 10 10

t B 10

G E 3

Tercer Camino: s, C, D, t : 10 B E F D K I J G A A A C C B B E 7 3 7 10 10 7 7 3

Cuarto A C B s s A 7 10 7

Camino: s, A, B, I, t : 7 E F K I J G A A C B B E 3 7 10 7 7 3

H E 3

t I 3

H t E D 3 10

H t E I 3 7

Quinto Camino: s, C, K, I, B, D, t : 2 C K I A B E F J G H t s C K I− I− A A B E E J 10 10 10 3 7 3 3 7 3 3 2

Dt:22 ←−

EG:10 s EH:10

Sexto C K s C 8 8

Camino: s, C, K, I, A, E, G, D, t : 3 I A B E F J G H D K I− I− A A B E E G 8 3 5 3 3 5 3 3 3

t D 3

FG:10 ←− ←−

GD:3 HD:10 It:10 Jt:2

s KI:10

←−

Séptimo Camino: s, C, K, I, B , A, F, G, E, H, D, t : 3 s C K I B J A F G E H D t s C K I − B B − A F G− E H D 5 5 5 5 5 5 5 5 3 3 3 3 Octavo C K s C 2 2

Camino?: No llega I B J A K I − B B− 2 2 2 2

27

at F G A F 2 2

Obtengo el Corte: S = {s,c,k,i,b,j,a,f,g} Capacidad del corte S Cap(S) =10 + 10 + 10 + 2 + 3 + 3 = 38 cd + it + bt + dt + ae + gd =0

z }| { ⇒ V (f ) = Outf (s) − Inf (s) −→

−→

= f ( sa) + f ( sc ) = 20 + 18 = 38 2.4.3. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

Pseudo-Código de Edmonds Karp

E−K( Network N) { F = 0 ; // F l u j o v = 0 ; // Valor d e l F l u j o S = V; // Corte while ( t ∈ S ) { // m i e n t r a s e l v e r t i c e t e s t e en e l c o r t e // b u s c a r camino y aumentar Q = new_queue ( S ) ; // Crear c o l a E [ x ] = ∞ ∀x ∈ V ; S = { s } ; // c o r t e while ( head ( q ) 6= t ) { x = head ( q ) ; Forward_search ( x ) ; Backward_search ( x ) ; dequeue ( q ) ; // s a c o x de l a c o l a } i f (t ∈ S ) { Aumentar_flujo ( ) ; } } return (F , v , S ) // f l u j o , v a l o r , c o r t e } Forward_search ( v e r t i c e x ) { f o r ( q ∈ Γ+ (x) && q 6∈ S ) { −→ −→ i f ( f ( xq ) < C( xq ) ) { enqueue (Q, q ) ; // Agregar q a Q S = S ∪ {q } ; A[ q ] = x ; // An c e s t r o −→ −→ E [ q ] = min{E( x ) ,C( xq ) − F( xq ) } ; b [ q ] = 1 ; // f o r w a r d } } }

28

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

Backward_search ( v e r t i c e x ) { f o r ( q ∈ Γ− (x) && ( q 6∈ S ) ) { −→ i f ( f ( qx ) >0) { enqueue (Q, q ) ; // Agregar q a Q S = S ∪ {q } ; A[ q ] = x ; // An c e s t r o b [ q ] = −1; // Backward −→ E [ q ] = min{E( x ) ,F( qx ) } ; } } } Aumentar_Flujo ( ) { p = t ; // p i v o t e = E( t ) ; v = v + ; while ( p 6= s ) { q = a[p]; i f ( b [ p ] == 1 ) { //FORWARD −→ −→ f ( qp ) = f ( qp ) + ; } else { −→ −→ f ( pq ) = f ( pq ) − ; } p = q; } }

2.5.

Algoritmos Tipo Dinic

Idea: usar un network auxiliar que se construye de la siguiente manera: corremos BFS de caminos aumentantes, como en < E − K >, agregando los vértices y lados correspondientes excepto que en < E − K > cuando p encuentra un q que ya está, no lo agrega, mientras que acá a veces sí, i.e. supongamos que estamos revisando p y hallamos → → → q ∈ Γ+ (p) con f (pq) < C(pq) ó q ∈ Γ− (p) : f (qp) > 0, pero que q ya está en el network auxiliar, entonces agregamos un lado pq al network auxiliar si el N ivel(q) = N ivel(p) + 1. Definición: un flujo G se dice bloqueante o saturante si para todo camino: −→

−→

−→

s = x0 , x1 , . . . , xr = t con (xi xi+1 ) ∈ E ∃i : G(xi xi+1 ) = C(xi xi+1 ) Dado f flujo en N y g flujo en un network auxiliar denotemos por: f (x, y) + g(x, y) Forward (f ⊕ g)(x, y) = f (x, y) − g(y, x) Backward

29

2.5.1.

Esquema general Tipo Dinic

1 Dinic () 2 { 3 f = 0; 4 Stop = NO; 5 while ( Stop == NO) { 6 NA = New_Na( f ) ; // c o n s t r u i r Network a u x i l i a r a p a r t i r de f 7 i f ( t ∈ NA) { 8 g = H a l l a r _ b l o q u e a n t e (NA) ; // b u s c o un f l u j o b l o q u e a n t e en NA 9 f = f ⊕ g; 10 } else { 11 Stop = Sí ; 12 } 13 } 14 return f ; 15 }

Teorema La distancia en NA18 sucesivos aumenta, por lo tanto hay a lo sumo n, NA’s. Demostración: Sea A un NA y A0 el siguiente NA, denotamos con δ la distancia en A y δ 0 la distancia en A0 . Como A y A0 se construyen con BFS ⇒ δ ≤ δ 0 Queremos ver que vale el “<”. Sea s = x0 , x1 , . . . , xr = t un camino en A0 . Caso 1: ∃i ∈ {1, . . . , r − 1} : xi 6∈ A ⇒ δ(t) ≤ δ(xi ) ≤ δ 0 (xi ) = i < r = δ 0 (t)

(10) (11)

( 10) Sino lo hubiera agregado. ( 11) Por < E − K > ∴ δ(t) < δ 0 (t) Caso 2: xi ∈ A ∀i Como antes de pasar a A0 debemos saturar todos los caminos de A, se sigue que ningún camino de A es un camino de A0 . →

Luego: s, x1 , . . . , xr−1 , t no es camino en A, como xi ∈ A ∀i ⇒ ∃i : xi xi+1 6∈ A Y tomemos el primer tal i. 18

NA: networks auxiliares.

30

• Caso 2-a: δ(xi+1 ) < i + 1 Como i + 1 = δ 0 (xi+1 ) ⇒ δ(xi+1 ) < δ 0 (xi+1 ) ? Luego: δ(t) = δ(xi+1 ) + b(xi+1 ) < δ 0 (xi+1 ) + b(xi+1 ) ≤ δ 0 (xi+1 ) + b0 (xi+1 ) = δ 0 (t)

(12) (13)

( 12) Por ? ( 13) Por < E − K > • Caso 2-b: δ(xi+1 ) = i + 1 Observación: es ≤ por < E − K > no hace falta ver “>”. −→ −→ Como i es el primero con xi xi+1 6∈ A ⇒ xj−1 xj ∈ A ∀j ≤ i ∴ s = x0 , x1 , . . . , xi ∈ A ∴ δ(xi ) = i ⇒ δ(xi+1 ) = i + 1 = δ(xi ) + 1 Como los niveles son los “correctos” la única razón por la cual xi xi+1 6∈ A es porque no está “disponible” en N , i.e. es Forward saturado o Backward vacío. −→

−→

Pero xi xi+1 ∈ A0 entonces se usó para el otro lado en A, es decir: xi+1 xi ∈ A Absurdo pues N ivel(xi+1 ) = i + 1, y N ivel(xi ) = i. Corolario: si un algoritmo tiene complejidad O(b) para hallar flujo bloqueante en el NA, entonces la complejidad del algoritmo completo es O(n ∗ b). Dinic = Algoritmo tipo Dinic + Greedy “DFS” para hallar flujo bloqueante. A simple vista sería: Complejidad(Dinic) = O(nm2 ) = Complejidad(< E − K >) Parecería que no ganamos nada. Pero veremos que en realidad Complejidad(Greedy en NA) = O(nm). ∴ Tendremos Complejidad(Dinic) = O(n2 m)

31

2.5.2.

Ejemplo de Dinic

Ejemplo: Aplicar Dinic al siguiente Network. Inicial

Primera Modificación

Segunda Modificación (final)

Caminos (6)

sA:8

sA:0

caminos (4) sAFt:4

sA:0

sD F AIt : 1

sC:7

sC:0

sAGt:3

sC:0

sD GAIt : 2

←− ←− ←−

sD:10

sD:7

sAIt:1

sD:4

sE F AIt : 3

sE:12 AF:4 AG:3

sE:11 AF:0 AG:0

sCGt:2 sCHt:3 sCJt:2

sE:1 AF:4 AG:3

sE GAIt : 1 sEGBIt : 1 SEGBJt : 2

AI:8

AI:7

sDFt:3

AI:0

SE GCJt : 1

←−

←− ←−

BI:2 BJ:2 CG:2 CH:3 CJ:5 DF:4 DG:2 EF:3 EG:5 EH:4 Ft:7 Gt:5 GB:4 Ht:4 It:9 Jt:15


sEHt:1

Primer Network Auxiliar I }> / }} /// } // }} }} // / GI >> /// ? A AA }> G >> / AA}} >> // }}AAA >>/ } } /t /C s/? F ? G 00AA }> G //?? 00AA}} // ??? }A // ?? } }00} AA 0 // 00 // D 00 > H // }}0}0 // }} 00 } } E


sE HCJt : 2

Segundo Network auxiliar /I / F (−) / A ? D AA ? G (−) ~~~> A AA ~ AA ~~ ~ ~ /B s? }> G AA ? ?? AA(−) ??? }} ?? A } ?? ?? AA ? } }} ? (−) /J / / C E H

== == == == @ t

J

s?

Tercer Network auxiliar /

D ?? ?? ?? ? E

/

H

(−)

/

C

/

G

/

B

/

I

(−)

/

A

/

F

Obtengo el corte del conjunto de vértices del NA que no llega a t, el último. S = {s, d, e, h, c, g, b, i, a, f } Cap(S) =

4+ 5+ 5+ 2 + 9+ 7 = 32 ht+ cj+ gt+ bj + it+ f t 32

Se ve que Cap(S) = 32 = Outf (s) Entonces tengo una garantía de la resolución del ejercicio. Otra garantía es ver que los caminos obtenidos de un NA tengan el mismo tamaño y que a medida que voy construyendo otros NA’s sean más largos, en este caso los primeros tenían 4 de largo y los caminos del segundo network auxiliar tenian un largo de 6. 2.5.3. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

Pseudo Código algoritmos Tipo Dinic

D i n i c ( Network Na) { // Pa rte B l o q u e a n t e , Version con Goto g = 0; 2 p = s ; // l a b e l 2 , p i v o t e 1 i f ( p 6= t ) { // l a b e l 1 i f ( Γ+ (p) 6= ∅ ) { avanzar ( ) ; goto 1 ; } e l s e i f ( p 6= s ) { retroceder () ; goto 1 ; } e l s e return g ; } else { Incrementar_flujo () ; goto 2 ; } } D i n i c ( Network Na) { \\ Parte Bl o q ue a n te , V e r s i o n goto l e s s ; g = 0; E( s ) = ∞ ; continuar = 1; while ( c o n t i n u a r ) { p = s; while ( p 6= t && c o n t i n u a r ) { i f ( Γ+ (p) 6= ∅ ) { Avanzar ( ) ; } e l s e i f ( p 6= s ) { Retroceder () ; } else { continuar = 0; } } i f ( p == t ) { Incrementar_flujo () ; } } Return g }

33

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// Pre p t i e n e v e c i n o Avanzar ( p i v o t e p ) { Tomar q ∈ Γ+ (p) A( q ) = p ; // a n c e s t r o de q e s p −→ −→ E( q ) = min{E( p ) ,C( pq )−G( pq ) } ; p = q; } // Pre p t i e n e v e c i n o Retroceder ( pivote p) { B o r r a r p de Γ+ (A(p)) p = A( q ) ; } Incrementar_Flujo ( ) { = E( t ) ; q = t; while ( q 6= s ) { p = a(q) ; −→ −→ G( pq ) = G( pq ) + ; −→ −→ i f (G( pq ) == C ( pq ) ) { B o r r a r q de Γ+ (p) } } q = p; }

34

2.5.4.

Complejidad de Dinic

Teorema: la complejidad de Dinic es O(n2 m) Prueba: por el teorema general de los algoritmos “tipo Dinic” basta ver que la complejidad del paso bloqueante es O(n ∗ m). Sea: A = Avanzar() R = Retroceder() I = Incrementar_Flujo() + Inicialización (O(1)) Una corrida de Dinic luce como: A . . . AIA . . . ARAIA . . . ARAI . . . RRRRA . . . AI Sea X = I ó R. Tomemos una sucesión de palabras de la forma: A . . . AX 1. ¿Cuántas palabras hay? Si X = R: borramos un lado. Si X = I: borramos al menos un lado. ∴ Cada X borra al menos un lado ⇒ hay ≤ m palabras de la forma A . . . AX 2. ¿Cuál es la complejidad máxima de cada palabra? Complejidad de R = O(1) Complejidad de I = O(n); hay ≤ n vértices en el camino s, . . . , t. ∴ Complejidad(X) = O(n) Complejidad de A = O(1) ∴ Complejidad(A . . A} X) = O(r) + O(n) | .{z r

Como cada Avanzar() mueve el pivote un nivel más cerca de t entonces hay a lo sumo n Avanzar() antes de un R o un I ∴ r ≤ n. Complejidad(A . . . AX) = O(n) + O(n) = O(n) (1) + (2) ⇒ Complejidad(Paso Bloqueante de Dinic) = m ∗ O(n) = O(n ∗ m)

35

2.6.

Algoritmo Wave de Tarjan

Es un ejemplo de una clase de algoritmos en los cuales la invariante no es más “ser flujo”. Definición: un Preflujo es como un flujo sin la condición de balanceo. En el caso de Wave19 el desbalanceo sólo podrá ser por exceso de entrada, pero otros algoritmos permiten desbalanceo de los dos lados. Idea: una ola hacia adelante (“Forward”) que balancea si puede y marca (“bloquea”) si no. Una ola hacia atrás que balancea los bloqueados (“Backward”). 2.6.1. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

Pseudo Código de Wave

Wave ( ) { i n i c i a l i z a r () ; olaForward ( ) ; olaBackward ( ) ; while (N != 2 ) { olaForward ( ) ; olaBackward ( ) ; } return g ; } i n i c i a l i z a r () { g = 0; ∀(x 6= s){ B( x ) = 0 ; //No b l o q u e a d o D( x ) = 0 // D e s b a l a n c e o A( x ) = ∅ // s u b c o n j u n t o de a q u e l l o s que l e mandaron f l u j o a x } D( s ) = 0 ; N = 1 ; // #V e r t i c e s b a l a n c e a d o s ∀(x ∈ Γ+ (s)){ −→ −→ G( sx ) = C( sx ) ; −→ D( s ) = D( s ) − C( sx ) ; −→ D( x ) = C( sx ) ; N++; A( x ) = { s } ; } } olaForward ( ) { f o r ( x = s +1; To ; t −1){ // Orden BFS( ) i f (D( x ) >0) ForwardBalance ( x ) ; } } 19

Wave: inglés, ola.

36

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

olaBackward ( ) { f o r ( x = t − 1 DownTo s +1){ // Orden BFS( ) i f (D( x )>0 && B( x ) == 1 ) BackwardBalance ( x ) ; } } BackwardBalance ( v e r t i c e x ) { while (D( x ) >0){ Tomar y ∈ A( x ) ; −→ m = min{D( x ) ,G( yx ) } ; −→ −→ g ( yx )= g ( yx ) − m; D( x ) = D( x ) − m; i f (D( y ) == 0 ) { N++; } D( y ) = D( y ) + m; −→ i f (G( yx ) == 0 ) { A( x ) = A( x ) − {y } ; } } N−−; }

ForwardBalance ( v e r t i c e x ) { while (D( x )>0 && (Γ+ (x) 6= ∅) ) { Tomar y ∈ Γ+ (x) ; i f (B( y ) == 1 ) { Γ+ (x) = Γ+ (x) − {y} } else { −→ −→ m = min{D( x ) ,C( xy ) − G( xy ) } −→ −→ G( xy ) = G( xy ) + m ; D( x ) = D( x ) − m; i f (D( y ) == 0 ) { N++; } D( y ) = D( y ) + m; A( y ) = A( y ) ∪ {x } ; −→ −→ i f (G( xy ) == C( xy ) ) { Γ+ (x) = Γ+ (x) − {y} } } } i f (D( x ) >0) B( x ) = 1 ; // Bloqueamos x else N−−; }

37

2.6.2.

Complejidad de Wave

Teorema: la complejidad de Wave es O(n3 ) Prueba: como es “Tipo Dinic” sólo basta ver que la complejidad del paso bloqueante es O(n2 ). Sea ()t partes del algoritmo en donde se satura totalmente un lado o se vacía totalmente un lado. Y sea ()p donde se manda o devuelve parcialmente flujo. Compl(W ave_bloqueante) = Compl(W ave_bloqueante)t + Compl(W ave_bloqueante)p Analicemos primero la Compl(W ave_bloqueante)p . Cada ola Forward, salvo quizás la última bloquea al menos un vértice nuevo. ∴ Hay a lo sumo n ciclos: (ola forward,ola backward) ?? En cada ola forward hay n − 2, F orwardBalance(x) Entonces: Compl(olaF orward)p = n ∗ Compl(F orwardBalance(x))p = n ∗ Compl(F orwardBalance(x))p | {z }

(14)

O(1)

= O(n) ( 14) Pues en cada F B(x) a sólo un lado le mandamos flujo parcial. Compl(ola F orward)p = O(n) (2) Luego: (2) y ? ? ⇒ Compl(W ave_bloqueante)p = O(n2 ) Ahora analicemos Compl(W ave_bloqueante)t . Cada vez que un lado se satura completamente no puede volver a saturarse, pues si → el lado es xy lo quisiera volver a saturar debería primero hacer que “y” le devuelva el flujo a “x”. Pero esto sólo puede pasar si “y” está bloqueado y en ese caso “x” no le puede mandar más flujo, en particular no lo puede volver a saturar. →

Similarmente, un lado xy sólo se puede vaciar totalmente una vez porque sólo puede hacerlo si “y” está bloqueado. ∴ #Saturamientos + #V aciamientos ≤ 2m ∴ Compl(W ave_bloqueante)t = O(m) 38

Compl(W ave_bloqueante) = Compl(W ave_bloqueante)t + Compl(W ave_bloqueante)p = O(m) + O(n2 ) = O(n2 )

2.6.3.

Ejemplos de Wave Aplicar Wave al siguiente Network Auxiliar

sA:8 →0 sC:7 →0 sD:10 → 7 sE:7 →0 AF:4 →0 AG:3 → 0 AI:8 →7 CG:2 → 0 CH:3 → 0 CJ:5 →3 DF:4 →1 DG:2 → 2 EF:3 EG:5 EH:4 Ft:7 →3 Gt:5 →0 Ht:4 →0 It:9 →8 Jt:15 → 13

Nivel 0 s -32

→ -25

A 8 4 1 0

C 7 5 2 0

Nivel 1 D 10 6 4

6 7

E 7 4 60

4 7

Nivel 2 F G 4 3 8 5 11 7 11 4 6 1 2 0 0

I 1 0

H 3 60

0

→

3

-19

0

4 3 0

J 2 0

Nivel 3 t 7 12 13 16 18

← 19

←

39

Aplicar Wave Respetando el orden alfabético y observar que el flujo es distinto sA:8 sC:7 sD:10 sE:7 AF:4 AG:3 AI:8 CG:2 CH:3 CJ:5 DF:4 DG:2 EF:3 EG:5 EH:4 Ft:7 Gt:5 Ht:4 It:9 Jt:15

→ → → →

0 0 5 0

→0 → → → → → →

0 1 0 1 0 1

→ → → → →

0 0 0 1 11

Nivel 0 s -32

→ -27

Nivel 1 A C D 6 8 7 10 64 65 66 61 62 4 0 0 3 7 0

2 0

5

0

Nivel 2 E F G 67 64 63 6 4 8 5 0 11 7 11 4 6 0 3 1 0

I H J 61 63 62 0 0 0

7 0

Importante ver que termino porque Outf (s) = Inf (t)

40

2 0

Nivel 3 t 7 12 13 16 18 25 27 ←

3.

MST

MST: minimal spanning tree, árbol de expansión o generador minimal. Definición: sea G un grafo, un árbol generador de G es un subgrafo de G que es árbol y generador. Es decir T es árbol generador de G si: 1. T subgrafo de G. 2. T árbol ⇒ Conexo sin ciclos. 3. T generador ⇒ V (T ) = V (G). Obviamente si G tiene árbol generador debe ser G conexo si lo es DFS o BFS dan un árbol generador. Repaso de árboles Propiedad: T árbol ⇒ m = n − 1 Demostración: si T es árbol, entonces DF S(T ) = T . Si A(q) denota el antecesor de q en DFS, todos los lados de DFS son de la forma: A(q)q para algún q 6= raíz. ∴ Hay n − 1 lados. (uno por cada vértice 6= raíz)

Propiedad: (1) T árbol ⇔ T conexo y m = n − 1 ⇔ T no tiene ciclos y m = n − 1

(2) (3)

Prueba: (1) ⇒ (2) y (3) ya está. ?

(3) ⇒ (1) : T no tiene ciclos y m = n − 1 ⇒ T árbol Sólo tengo que ver que es conexo. Sean {x, y} ∈ T , supongamos que no hay un camino entre x e y. En particular xy 6∈ E(T ) Sea T 0 = T ∪ {xy} Como no hay caminos en T entre x e y en T 0 no hay ciclos. Si C fuese ciclo Como T es acíclico ⇒ xy ∈ T Entonces C − xy , es un camino en T entre x e y absurdo.

41

Conclusión: si x, y no tiene un camino entre ellos, T ∪ {x, y} sigue siendo acíclico. Continuando de esta forma terminamos con un Tb conexo y acíclico. Es decir árbol tal que T ∪ {xy} ⊆ Tb E Tb = V Tb − 1

(15)

= |V (T )| − 1 = |E(T )|

(16)

( 15) Tb es árbol ( 16) Por HIP.(3) Absurdo pues T ∪ {x, y} ⊆ Tb ⇒ E Tb ≥ |E(T )| + 1 ?

(2) ⇒ (1) : T conexo y m = n − 1 ⇒ T árbol Sólo tengo que ver que no contenga ciclos. Supongamos que T tenga un ciclo, borrando el lado del ciclo, el grafo resultante sigue siendo conexo. Por lo tanto puedo ir borrando un lado de cada ciclo manteniendo continuidad. Eventualmente llegamos a un grafo H sin ciclos que sigue siendo conexo. ∴ H es árbol. E(H) = V (H) − 1 = V (T ) − 1 = E(T ) Absurdo porque por lo menos quité un lado. Definición: dado un grafo G conexo con pesos en los lados, es decir W : E(G) → R≥0 . Un MST20 para G es un spanning tree T tal que: X X W (xy) ≤ W (xy) ∀spanning T ree T 0 xy∈E(T )

Notación P

xy∈E(T 0 )

W (xy) = W (T ).

xy∈E(T )

Problema: dado G conexo, hallar un MST para G.

3.1.

Kruskal

Repetir hasta tener n − 1 lados, agregar el lado de menor peso que no forme ciclo. Se necesita una estructura de datos de “conjuntos disjuntos”. 1. M akeset(x): construye un conjunto {x}. 2. F ind(x): devuelve el conjunto al cual pertenece x. 3. U nion(A, B): devuelve la unión de A y B. 20

Minimal Spanning Tree.

42

3.1.1. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

Pseudo Código de Kruskal

Kruskal ( ) { //α ∀(x ∈ V ){ Makeset ( x ) ; } //β Edges_Sort ( ) ; // Ordenar l o s l a d o s : W(E [ i ] ) ≤ W(E [ i +1]) m = 0 ; // c a n t i d a d de l a d o s i = 1 ; // i n d i c e // γ while (M < N−1){ A = find (x [ i ]) ; B = find (y [ i ]) ; i f (A 6= B) { t r e e . add ( e [ i ] ) ; // a g r e g a r a l a r b o l e [ i ] m++; Union (A, B) ; } i ++; }

}

3.1.2.

Teorema: Kruskal devuelve un MST

Demostración: el invariante es ser acíclico y termina con n − 1 lados, entonces tenemos garantizado que termina con un spanning tree. Veamos ahora que es minimal. Prueba por inducción: sea Kj el grafo en el paso j Si j = 0 queda demostrado porque los vértices desconectados siempre están. Hipótesis inductiva: ∀j ∃ un MST Tj : Kj ⊆ Tj Supongamos que Kj ⊆ Tj MST. Sea e : Kj+1 = Kj ∪ {e} • Si e ∈ Tj ya está pues Kj+1 ⊆ Tj • Por lo tanto supongamos: e 6∈ Tj En este caso, Tj ∪ {e} tiene: n − 1 + 1 = n lados ∴ no es árbol. Como Tj es conexo ⇒ Tj ∪ {e} es conexo. Como no es árbol ⇒ Tj ∪ {e} tiene un ciclo C. Pero Tj no tiene ciclos ⇒ e forma parte del ciclo C. 43

Sea f un lado de C que no esté en Kj+1 (∃f ⇐ Kj+1 es acíclico). Tj+1 = (Tj − f ) ∪ {e} = (Tj ∪ {e}) − f Como C es un ciclo: y f ∈ C ⇒ (Tj ∪ {e}) − f sigue siendo conexo. ∴ Tj+1 es conexo y tiene: n − 1 + 1 − 1 = n − 1 lados ⇒ Tj+1 es un árbol. Como Kj+1 ⊆ Tj+1 basta ver que Tj+1 es minimal. Pero W (Tj+1 ) = W (Tj ) − W (f ) + W (e) Pero f 6∈ Kj+1 Si W (f ) < W (e) ⇒ f se “analizó” antes de e. Como f 6∈ Kj+1 entonces se rechazó. Entonces Kj ∪ {f } tiene un ciclo absurdo pues Kj ∪ {f } ⊆ Tj |{z} árbol

Ya que Kj ⊆ Tj y f ∈ Tj

(estoy diciendo que un subconjunto de un árbol tiene un ciclo, absurdo). ∴ W (f ) ≥ W (e) W (Tj+1 ) ≤ W (Tj ) ⇒ Tj+1 también. Como Tj es MST 3.1.3.

Complejidad de Kruskal

Volviendo al pseudocódigo: α = O(n) β = O(m log(m)) = O(m log(n2 )) = O(2m log(n)) = O(m log(n)) γ = n ∗ (2 ∗ Compl(F ind) + Compl(U nion)) Como en general β > γ ∴ Compl(Kruskal) = O(m log(n)) 3.1.4.

Kruskal Delete

Repetir(?) hasta tener n − 1 lados. (?) Borrar el lado de mayor peso que no desconecte el grafo. 3.1.5.

Complejidad Kruskal Delete

No demostraremos el orden pero diremos que la complejidad es: O m log(n) (log (log(n)))3

44

3.1.6.

Ejemplo de Kruskal A B C D E F

(0)

A

C

A − 5 − 3 1 3

B 5 − 1 4 − −

C D E F − 3 1 3 1 4 − − − 7 − − 7 − 4 2 − 4 − 3 − 2 3 − (3)

E

A 1

(1)

B A E A

(4)

1

E

A 3

D B

F D

F (5)

1

C

E

F B

1

(2)

D C

B

A 3

F F ~ 00@@@ 00 @@3 002 @@ ~~ ~ 00 @ ~ 1 00 _ E A PPPP 00 PPP PPP 0 4 5 P PPP 00 3 P _D B@ 4 @@ ~ ~ @@ ~~ @ ~~ 7 1 @@ ~ ~ C

45

1

2

C

F

_E

B

2

_D

1

_E

1

C B ~~ ~ ~ 1 ~~ ~~ 4

F 3 ~~~

1

D

1

_D

C

3.2.

PRIM

Prim(x) = agregar el lado de menor peso que conecte x con otro vértice, creando una región R luego ir agregando el lado de menor peso que conecte R con V − R. Generalmente se implementa con un heap. 3.2.1.

Pseudo Código de Prim

1 Prim ( v e r t i c e x ) 2 { 3 ∀(p ∈ V ){ 4 Costo [ p ] = ∞ ; 5 Vecino [ p ] = NULL; 6 } 7 8 Costo ( x ) = 0 ; 9 M = 0; 10 Aux = V; 11 12 //FALTA CASO BASE 13 14 while (m < n−1){ 15 // p r e : c o s t o ( p )< c o s t o ( q ) 16 ∀(q ∈ Γ(p)){ 17 i f ( c o s t o ( q )> V( pq ) ) { 18 c o s t o ( q ) = W( pq ) ; 19 vecino (q) = p ; 20 } 21 } 22 Add( p , v e c i n o ( p ) ) ; 23 m++; 24 } 25 26 27 }

3.2.2.

∀q ∈ Aux

Correctitud de Prim

Como el invariante es ser árbol cuanto termina es efectivamente spanning tree. Sólo resta ver que es minimal y lo haremos por inducción. Si Pj es el árbol en el paso j, probaremos que ∃ M ST Tj : Pj ⊆ Tj j = 0: Trivial. Supongamos que vale para j Si Pj+1 ⊆ Tj ya está. De lo contrario existe e ∈ Pj+1 : e 6∈ Tj (y de hecho, será Pj+1 = Pj ∪ {e} ). e une Pj con V − Pj Como Tj es Spanning Tree ⇒ debe conectar Pj con V − Pj . 46

Sea f un lado en Tj que conecte estas dos regiones. Como e es el menor lado que conecta esas dos regiones tenemos que: W (e) ≤ W (f ) Entonces: W (Tj ∪ {e} − f ) ≤ W (Tj ) ∴ Tj ∪ {e} − f es un MST que contiene a Pj+1 .

3.2.3.

Ejemplo de Prim

A B C D E F

A − 5 − 3 1 3

B 5 − 1 4 − −

C D E F − 3 1 3 1 4 − − − 7 − − 7 − 4 2 − 4 − 3 − 2 3 −

P rim(A), Método Gráfico: 1

(1) A

_E

1

(2) A 3

_E

(3) A 3

D (4) A 3

1

_E

D

2

D

(5) A 3

_F

D

4

B

1

_E

2

_F

1

_C

1

_E

2

_F

4

B

Prim(A), Método Analítico;

1)

B (5, A)

C (∞, −)

D (3, A)

E (1,A)

F (3, A)

2)

(5, A)

(∞, −)

(3,A)

−

(3, A)

3) (4, D)

(7, D)

−

−

(2,D)

4)

(4,D)

(7, D)

−

−

−

5)

−

(1,B)

−

−

−

∴ Complejidad(P rim) = O(n2 ) 47

3.3.

Implementaciones de Union Find

1. Linked lists. (listas enlazadas) 2. Representantes. 3. Union Find By Rank. 3.3.1.

Union Find con listas enlazadas

Union es O(1) Find es O(n) Recordemos que Kruskal hace: 2m “Finds()” y n − 1 “Unions()”. ∴ O(mn) + O(n) = O(nm) Como mn >

3.3.2. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

m log(n) no sirve. | {z } Ordenar los lados

Union Find con Representantes

Makeset ( x ) { //O( 1 ) R( x ) = x ; } Find ( x ) { // O( 1 ) return R( x ) ; } Union ( R1 , R2 ) { // O( n ) ∀(x ∈ V ){ i f (R( x ) == R2 ) { R( x ) = R1 ; } } }

Compl(Kruskal) =

O(m log(n)) + O(m) + O(n2 ) | {z } | {z } | {z } Ordenar los lados m Finds n Unions

∴ Compl(Kruskal) = O(m log(n) + n2 ) bastante bien si: m ≈ n2 Es decir no funciona tan bien si es un grafo ralo, i.e. con pocos lados.

48

3.3.3. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

Union Find con ranking

Makeset ( v e r t i c e x ) { Π(x) = x ; Rk( x ) = 0 ; // Ranking } Find ( v e r t i c e x ) { // r e c u r s i v o a l a c o l a i f ( Π(x) == x ) return x ; e l s e return f i n d ( Π(x) ) } Find ( v e r t i c e x ) { // i t e r a t i v o y = x; while ( y 6= Π(y) ) y = Π(y) ; return y ; } /∗ Pre : F1 = Find ( x [ 1 ] ) ; F2 = Find ( x [ 2 ] ) ; F1 6= F2 ∗/ Union ( F1 , F2 ) { k1 = Rank ( F1 ) ; k2 = Rank ( F2 ) ; i f ( K1 > K2 ) { Π(F2 ) = F1 ; // c a b e z a d e l 2 do apunta a l primero } else { Π(F1 ) = F2 ; // c a b e z a d e l primero apunta a l segundo i f ( k1 == k2 ) { Rank ( F2 ) = k2 +1; } } }

Con esta implementación: makeset(x) = (1) U nion = O(1); F ind(x) = O(rank(representante(x)) ≤ O(log(n)) Teorema Find es O(log(n)) Corolario: Compl(Kruskal) = O(m log(n)) Demostración: Compl(Kruskal) =

O(m log(n)) + O(m) + O(n2 ) = O(m log(n)) | {z } | {z } | {z } Ordenar los lados m Finds n Unions

Demostración del Teorema Lema interno 1: (Rank(x) < Rank(Π(x)) : ∀x : x 6= Π(x)) Obvio pues Rank solo cambia con Union, y lo cambia sólo a F2 cuando Π(F1 ) == F2 En ese caso incrementa el rango de F2

49

Lema interno 2: Rank(x) = k ⇒ ∃ ≥ 2k elementos “por debajo” de x, contando a x. Prueba por inducción. • k = 0 obvio • Supongo que vale para k • Veamos para k + 1 Rank(x) = k + 1 ⇒ alguna vez fue k y union lo subió a k + 1 y esto sólo pasa si unimos 2 de rango k. Entonces la cantidad de elementos por debajo de x ≥ 2k + 2k = 2k+1 Lema interno 3: Hay ≤

n 2k

elementos de rango k, está demostrado en los lemas.

Finalmente Rango(x) ≤ log(n) ∀x Pues sea k el mayor rango ⇒ ∃ por lo menos un elemento de rango k. ⇒1≤

n 2k

⇒ 2k ≤ n ∴ k ≤ log2 (n).

¿Qué pasa si los lados vienen ordenados o se pueden ordenar21 en O(m)? Se puede usar “Path compresion” Solo cambia Find 1 Find ( x ) { 2 i f ( Π(x) 6= x ) { 3 Π(x) = Find ( Π(x) ) ; 4 } 5 return Π(x) ; 6 }

El análisis es más complicado, cada F ind() puede ser O(log(n)) Se puede ver: Teorema: la complejidad de m Finds + n Unions, está acotado por O m log∗ (n) Esencialmente: O(m) ∀n “razonable”. O log∗ (n) = # de veces que hay que aplicar log para llegar a algo ≤ 1 n log(n)

21

1 0

2 1

{3,4} 2

{5,. . . ,16} 3

Bucket sort.

50

{17,. . . ,216 } 4

{216 +1,. . . ,265536 } 5

4.

Matchings

Dado un grafo G, un matching en G es un subgrafo M tal que el grado en M de todos sus vértices es 1. Un matching es perfecto si “cubre” a G, es decir: V (M ) = V (G). De ahora en más supondremos que G es bipartito. Cuando escribamos G = (X ∪ Y, E) asumimos que X e Y son las partes. Es decir: pq ∈ E ⇒ p ∈ X, q ∈ Y Problema: hallar un matching perfecto en G, o en su defecto uno “maximal” (con la mayor cantidad de lados posibles).

4.1.

Transformación del problema de Matching a uno de flujo maximal

DadoG = (X ∪ Y, E) creamos el siguiente network. → N = X ∪ Y ∪ {s, t}, E, C   x ∈ X   S n−→o n−→o → S −→ E = sx xy : y ∈ Y yt   x∈X y∈Y xy ∈ E La capacidad de todos los lados es : 1. Ejemplo X

Y

B C ;; ;; ;; ; ;

s

A;

1

2

3

⇒

} AAA AA }} } AA }} A } } B A@ ~C @@ ~~ @@ ~ @@ ~~ @ ~~ 1 @@ 2 3 @@ ~~ @@ ~~ ~ @@ ~ @ ~~~

t

Teorema Flujos maximales en N corresponden con matchings maximales en G y V (fmax ) = #lados. Dicho de otra manera: existe una correspondencia entre matchings maximales en G (bipartito) y flujos maximales enteros en N. Prueba: dado un flujo entero f construimos un matching Mf y dado un Matching M construimos un flujo entero fM . S Vf = {x, y} xy∈Ef Dado f sea Mf = (Vf , Ef ) : −→ Ef = {xy ∈ E : f ( xy) = 1} Hay que ver que Mf es matching.

51

Observemos que por definición de Vf tenemos que δMf (z) ≥ 1 ∀z ∈ Vf Si Mf no es matching ⇒ ∃z : δMf (z) ≥ 2 Caso 1: z ∈ X como δMf (z) ≥ 2 entonces ∃y1 , y2 : −→

y1 6= y2 zy1 , zy2 ∈ Ef

−→

Entonces f (zy1 ) = f (zy2 ) = 1 ∴ Outf (z) ≥ 2 ⇒ Absurdo. −→ Pero Inf (z) = f ( sz ) ≤ 1 Caso 2: z ∈ Y ⇒ ∃x1 , x2 : −→

x1 6= x2 x1 z, x2 z ∈ Ef

−→

Entonces f (x1 z) = f (x2 z) = 1 ∴ Inf (z) ≥ 2

−→

Pero Outf (z) = f ( zt ) ≤ 1

⇒ Absurdo

Concluimos que Mf es matching. Dado ahora un Matching M sea fM definido así: −→

fM ( xy) =

1 Si xy ∈ E(M ) 0 Si no

−→

1 Si x ∈ V (M ) ∩ X 0 Si no

−→

1 Si y ∈ V (M ) ∩ Y 0 Si no

fM ( sx) =

fM ( yt ) = Como M es matching, está claro que:

Mf (z) = Outf (z) =

1 Si z ∈ V (M ) 0 Si z 6∈ V (M )

Además está claro que: MfM = M y que: fMf = f

52

Veamos ahora que: V (f ) = |EMf | =0

z }| { V (f ) = Outf (s) − Inf (s) X −→ = f ( sx) x∈X −→

= #{x : f ( sx) = 1} = #{x : Inf (x) = 1} = #{x : Outf (x) = 1} por ser f un flujo = |Vf ∩ X| = |EMf | Por lo tanto flujos maximales enteros corresponden a matchings maximales.

Definición: Sea S ⊆ V ⇒ Γ(S) =

S

Γ(z) = {w ∈ V : ∃z ∈ S : wz ∈ E}

z∈S

Definición: Si G = (X ∪ Y, E) es bipartito, un matching se dice completo de X a Y si cubre a X, i.e. X ⊆ V (M ).

4.2.

Teorema de Hall

Sea G = (X ∪ Y, E) bipartito entonces: ∃ un matching completo de X a Y ⇔ : Γ(S) ≥ S ∀S ⊆ X

4.3.

Complejidad del Algoritmo de Matching

Asumiendo |X| = |Y | = n Matching inical: O(n2 ). Extender el matching en un lado: O(n2 ). Extenderlo O(n) veces. ∴ Nos queda: O(n3 )

4.4.

Grafos con Peso

Sea G = (X ∪ Y, E) grafo bipartito, con |X| = |Y | = n y sea C una matriz de costos n∗n Cx,y = Costo de asignar el trabajo X al trabajador Y.22 Hay 2 (al menos) formas de minimizar: 1. Minimizar el máximo. 22

A veces pueden ser “Ganancias”.

53

2. Mimizar la suma. El problema 1 a veces es llamado el: bottleneck problem23 , se resuelve con el algoritmo de “Gross” y es bastante simple. 4.4.1.

Algoritmo de “Gross”

Dado C: 1. Ordenar los Ci,j como : b1 < b2 < . . . < bk (k ≤ n2 ) 2. Tomar, para r= 1, . . . , k: (Ar )i,j =

1 Si Ci,j ≤ br 0 Si no

(r es el “umbral”)

3. Hallar r: Ar tenga Matching perfecto y Ar−1 no, eso da un matching M tal que: f)} ∀M f máx{Ci,j : {i, j} ∈ E(M )} ≤ máx{Ci,j : {i, j} ∈ E(M

23

Problema de cuello de botella.

54

4.4.2.

Ejemplo del algoritmo de “Gross” Hallar un Matching I II III A 1 2 15 B π e e2 C 9 2 1 D e2 1 2 E 10 9 7 F 1 2 3 G 8 2 9

que minimice el Máximo IV V VI VII 2 7 5 4 5 8 2 1 10 8 100 9 10 4 10 10 8 1 9 10 4 5 6 7 10 5 10 10

Ordeno los Ci,j : 1, 2, e, 3, π, 4, 5, 6, 7, e2 , 8, 9, 10, 15, 1000 máx{m´ın(f ilas); m´ın(columnas)} = máx{1, 1, 1, 1, 1, 1, 2; 1, 1, 1, 2, 1, 2, 1} = 2 Umbral 7 Busco Matching A B C D E F G A B C D E F G

I 1 1 0 0 0 1 0 I 1 1 0 0 0 1 0

II 1 1 1 1 0 1 1 II 1 1 1 1 0 1 1 G

III 0 0 1 1 1 1 0 III 0 0 1 1 1 1 0 E

IV 1 1 0 0 0 1 0 IV 1 1 0 0 0 1 0

A B C D E F G

V 1 0 0 1 1 1 1 V 1 0 0 1 1 1 1 E

I 1 1 0 0 0 1 0 B

VI 1 1 0 0 0 1 0 VI 1 1 0 0 0 1 0

VII 1 1 0 0 0 1 0 VII 1 1 0 0 0 1 0

? ?

II III V ? ?

Extiendo el II III IV 1 0 1 0 1 1 1 1 0 1 1 0 0 1 0 1 1 1 1 0 0 G E B 55

A B C D E F G

A B C D E F G

Matching V VI 1 1 0 1 0 0 1 0 1 0 1 1 1 0 E B

I 1 1 0 0 0 1 0 I 1 1 0 0 0 1 0 B

Intento extenderlo II III IV V VI 1 0 1 1 1 1 0 1 0 1 1 1 0 0 0 1 1 0 1 0 0 1 0 1 0 1 1 1 1 1 1 0 0 1 0 G E E II III IV V VI 1 0 1 1 1 1 0 1 0 1 1 1 0 0 0 1 1 0 1 0 0 1 0 1 0 1 1 1 1 1 1 0 0 1 0 G E B E B

VII 1 I 1 II 0 III 0 V 0 ? 1 IV 0 ? B

VII 1 1 0 0 0 1 0

? ?

VII 1 1 II 0 III 0 V 0 ? 1 0 ? B

A B C D E F G

A B C D E F G

I 1 1 0 0 0 1 0 B I 1 1 0 0 0 1 0 B

II 1 1 1 1 0 1 1 G II 1 1 1 1 0 1 1 G

III 0 0 1 1 1 1 0 E III 0 0 1 1 1 1 0 E E

IV 1 1 0 0 0 1 0 B IV 1 1 0 0 0 1 0 B

A B C D E F G

V 1 0 0 1 1 1 1 E

VI 1 1 0 0 0 1 0 B

VII 1 1 0 0 0 1 0 B

V 1 0 0 1 1 1 1 E E

VI 1 1 0 0 0 1 0 B

VII 1 1 0 0 0 1 0 B

I 1 1 0 0 0 1 0 B

II 1 1 1 1 0 1 1 G C

III 0 0 1 1 1 1 0 E E

I II III V ? IV ?

I II III V ? IV ?

IV 1 1 0 0 0 1 0 B

A B C D E F G

?

A B C D E F G

III V ?

V 1 0 0 1 1 1 1 E E

VI 1 1 0 0 0 1 0 B

I 1 1 0 0 0 1 0 B I 1 1 0 0 0 1 0 B

II 1 1 1 1 0 1 1 G II 1 1 1 1 0 1 1 G C

VII 1 I 1 II 0 III III 0 V V 0 ? ? 1 IV 0 ? II B

Obtengo: • S = {C, D, E, G} = Filas etiqueteadas. • Γ(S) = {II, III, V } = Columnas etiqueteadas. • Luego |Γ(S)| = 3 < 4 = |S| ∴ @ Matching Perfecto. Entonces tengo que subir el umbral.

56

III IV V VI VII I 0 1 1 1 1 II 0 1 0 1 1 1 0 0 0 0 III 1 0 1 0 0 V 1 0 1 0 0 ? ? 1 1 1 1 1 IV 0 0 1 0 0 ? E B E B B E E III IV V VI VII 0 1 1 1 1 I II 0 1 0 1 1 1 0 0 0 0 III III 1 0 1 0 0 V V 1 0 1 0 0 ? ? IV 1 1 1 1 1 ? 0 0 1 0 0 E B E B B E E

Umbral 9 I II 1 1 1 1 1 1 1 1 0 1 1 1 1 1

A B C D E F G

III 0 1 1 1 1 1 1

IV 1 1 0 0 1 1 0

V 1 1 1 1 1 1 1

VI 1 1 0 0 1 1 0

VII 1 1 1 0 0 1 0

Busco Matching A B C D E F G A B C D E F G

I 1 1 1 1 0 1 1 I 1 1 1 1 0 1 1 G

II 1 1 1 1 1 1 1 II 1 1 1 1 1 1 1 G

III 0 1 1 1 1 1 1 III 0 1 1 1 1 1 1 G

IV 1 1 0 0 1 1 0 IV 1 1 0 0 1 1 0

V 1 1 1 1 1 1 1 V 1 1 1 1 1 1 1 G

VI 1 1 0 0 1 1 0 VI 1 1 0 0 1 1 0

VII 1 1 1 0 0 1 0 VII 1 1 1 0 0 1 0

A B C D E F G

? I II III V

A B C D E F G

?

I 1 1 1 1 0 1 1 G I 1 1 1 1 0 1 1 G

II III IV V VI VII 1 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1 1 0 1 0 0 1 1 1 1 1 0 1 1 1 1 1 1 1 1 0 1 0 0 ? G G G II III IV V VI VII 1 0 1 1 1 1 I 1 1 1 1 1 1 II 1 1 0 1 0 1 III V 1 1 0 1 0 0 1 1 1 1 1 0 1 1 1 1 1 1 1 1 0 1 0 0 ? G G A G A A

Extiendo el Matching A B C D E F G

I 1 1 1 1 0 1 1 G

II 1 1 1 1 1 1 1 G

III 0 1 1 1 1 1 1 G

IV 1 1 0 0 1 1 0 A

V 1 1 1 1 1 1 1 G

VI 1 1 0 0 1 1 0 A

VII 1 I 1 II 1 III 0 V 0 1 0 ? A

Existe Matching ∴ hay que bajar el umbral: M = { A-VII:4 ; B-II:e ; C-III:1 ; D-V:4 ; E-IV:8 ; F-VI:6 ; G-I:8 } ∴ Tengo un Matching de 8, entonces no hago el umbral de 8, sólo basta ver si hay Matching de 10 s con umbral e2 . 57

Umbral de e2 I II 1 1 1 1 0 1 1 1 0 0 1 1 0 1

A B C D E F G

III IV 0 1 1 1 1 0 1 0 1 0 1 1 0 0

V 1 0 0 1 1 1 1

VI VII 1 1 1 1 0 0 0 0 0 0 1 1 0 0

Busco Matching A B C D E F G A B C D E F G

I 1 1 0 1 0 1 0 I 1 1 0 1 0 1 0

II 1 1 1 1 0 1 1 II 1 1 1 1 0 1 1 G

III 0 1 1 1 1 1 0 III 0 1 1 1 1 1 0 E

IV 1 1 0 0 0 1 0 IV 1 1 0 0 0 1 0

A B C D E F G

V 1 0 0 1 1 1 1 V 1 0 0 1 1 1 1 E

I 1 1 0 1 0 1 0 B

VI 1 1 0 0 0 1 0 VI 1 1 0 0 0 1 0

VII 1 1 0 0 0 1 0 VII 1 1 0 0 0 1 0

? ?

II III V ? ?

Extiendo el II III IV 1 0 1 1 1 1 1 1 0 1 1 0 0 1 0 1 1 1 1 0 0 G E B

58

I 1 1 0 1 0 1 0

A B C D E F G

A B C D E F G

I 1 1 0 1 0 1 0 B

Matching V VI 1 1 0 1 0 0 1 0 1 0 1 1 1 0 E B

II III IV V VI VII 1 0 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 0 1 1 0 1 0 0 0 1 0 1 0 0 ? 1 1 1 1 1 1 1 0 0 1 0 0 ? G E E II III IV V VI VII 1 0 1 1 1 1 1 1 1 0 1 1 II 1 1 0 0 0 0 III 1 1 0 1 0 0 V ? 0 1 0 1 0 0 1 1 1 1 1 1 1 0 0 1 0 0 ? G E B E B B

VII 1 I 1 II 0 III V 0 0 ? 1 0 ? B

A B C D E F G

A B C D E F G

I 1

II 1

III 0

IV 1

V 1

VI 1

VII 1

1 0 1 0 1 0 B

1

1 0 0 0 1 0 B

1 0 0 0 1 0 B

II 1

0 0 1 1 1 1 E E V 1

1 0 0 0 1 0 B

I 1

1 1 1 1 1 0 E E III 0

VI 1

VII 1

1 0 1 0 1 0 B D

1

1 0 0 0 1 0 B

1 0 0 0 1 0 B

1 1 0 1 1 G

1 1 0 1 1 G C

1 1 1 1 1 0 E E

A B C D E F G

IV 1 1 0 0 0 1 0 B

I 1 1 0 1 0 1 0 B D

0 0 1 1 1 1 E E

II 1 1 1 1 0 1 1 G C

I II III V ?

A III V ?

?

I

B C D E F G

I

A

II III III V V ? ?

B C D E F G

Extiendo III IV 0 1 1 1 1 0 1 0 1 0 1 1 0 0 E B E A

?

II

I 1

II 1

III 0

IV 1

V 1

VI 1

VII 1

1 0 1 0 1 0 B D I 1

1

1 1 1 1 1 0 E E III 0

1 0 0 0 1 0 B

1 0 0 0 1 0 B

1 0 0 0 1 0 B

IV 1

0 0 1 1 1 1 E E V 1

VI 1

VII 1

1 0 1 0 1 0 B D

1

1 1 1 1 1 0 E E

1 0 0 0 1 0 B A

0 0 1 1 1 1 E E

1 0 0 0 1 0 B A

1 0 0 0 1 0 B A

1 1 0 1 1 G C II 1 1 1 0 1 1 G C

el Matching V VI VII I 1 1 1 I II 0 1 1 III 0 0 0 III V V 0 0 1 1 0 0 ? ? 1 1 1 1 0 0 ? II E B B E A A

Hallé un Matching que minimiza el máximo: (e2 ) n o M = A − V II : 4; B − V I : 2; C − III : 1; D − I : e2 ; E − V : 1; F − IV : 4; G − II : 2

59

I II III III V V ? ?

?

I I II III III V V ? ?

?

II

4.5.

Prueba del teorema de HALL Sea G = (X ∪ Y, E) grafo bipartito entonces: existe matching completo de X a Y ⇔ |S| ≤ |Γ(S)| ∀S ≤ X

Prueba: ⇒ Obvio pues el matching induce una funcion ψ : 1 − 1 de X en Y y la imagen de S por esa función está incluida en Γ(S) ψ1−1

∴ |S| = |ψ(S)| ≤ |Γ(S)| ⇐ Es equivalente a ver que: Si @ un matching completo ⇒ ∃S ⊆ X : |S| > |Γ(S)| Corramos el algoritmo de hallar matching (Filas X, Columnas Y ) Cuando termine habrá filas sin Matchear24 . Sea S0 = Filas sin Matchear. Sea T1 = Γ(S0 ) son las columnas etiqueteadas por las filas de S0 S1 = Filas etiqueteadas por las columas de T1 T2 = columnas etiqueteadas por las filas de S1 . No necesariamente T2 6= Γ(S1 ). Pero si tenemos que T1 ∪ T2 = Γ(S0 ∪ S1 ) Y así seguimos: Nos queda definido: Sj = Filas etiqueteadas por las columnas de Tj Tj+1 = las columnas etiqueteadas por las filas de Sj Sj = filas Matcheadas con Tj . ∴ Si Tj 6= ∅ ⇒ Sj también. El algoritmo se detiene sin extender el matching (por hipótesis). Por lo tanto se detiene en un k con Tk+1 = ∅ Observación: 1. |Sj | = |Tj | ∀j Pues Sj son las filas Matcheadas con Tj 2. Γ(S0 ∪ . . . ∪ Sj ) = T1 ∪ T2 ∪ . . . ∪ Tj+1 Sea S = S0 ∪ S1 ∪ . . . ∪ Sk |Γ(S)| = |Γ(S0 ∪ . . . ∪ Sk )| = |T1 ∪ . . . ∪ Tk ∪ Tk+1 | = |T1 ∪ . . . ∪ Tk | = |T1 | + . . . + |Tk | = |S1 | + . . . + |Sk | = |S| − |S0 | < |S| 24

Las marcadas con ?.

60

(17) (18) (19) (20)

( ( ( (

4.6.

17) 18) 19) 20)

Por las observación 2. Tk+1 = ∅ Unión Disjunta. Por las observación 1.

Teorema del Matrimonio Todo grafo bipartito regular (con lados) tiene un matching perfecto.

Prueba: sea G = (X ∪ Y, E) : E 6= ∅, regular. Dado W ⊆ V con W ⊆ X ó W ⊆ Y Definimos: Ew = Lados con un extremo en w = {xy ∈ E : x ∈ W ó y ∈ W } Supongamos W ⊆ X |Ew | = {xy ∈ E : x ∈ w} X = {y : xy ∈ E} x∈w

=

X x∈w

d(x) |{z}

(21)

∆

= ∆ ∗ |w| ( 21) Por ser G regular. Similar prueba si: W ⊆ Y Observemos que por ser G bipartito: Ex = E = Ey ∴ |Ex | = |Ey | ⇒ ∆ ∗ |X| = ∆ ∗ |Y | Como ∆ 6= 0 ⇒ |X| = |Y | Por lo tanto para ver si existe un matching perfecto en G, basta ver que existe un matching completo de X a Y . Por el teorema de Hall basta entonces con ver: |S| ≤ |Γ(S)| ∀S ⊆ X Sea entonces S ⊆ X Sea e ∈ Es ⇒ ∃

x∈S : e = xy y∈Y

⇒ y ∈ Γ(x) ⊆ Γ(S) ⇒ e = x y ∈ EΓ(s) ∴ Hemos probado que: Es ⊆ EΓ(S) ⇒ |Es | ≤ |EΓ(S) | ∆|S| ≤ ∆|Γ(S)| ∴ |S| ≤ |Γ(S)|

61

4.7.

Minimizar la Suma

Problema: dada una matriz de costos C, hallar el menor M, Matching. n P Simbólicamente buscamos M: M = m´ın Ci,j i=1 j : ij ∈ M e una matriz de costos que se La solución a este problema usa una idea sencilla: sea C obtiene de C restándole o sumándole una constante a una fila o columna. Entonces sea Mm´ın (C) un Matching que minimiza la suma. Ci,j Si i 6= î ei,j Si a la fila î le resto una constante k, i.e. C Ci,j − k Si i = î n n P P ei,j = Está claro que: C Ci,j − k , similar para las columnas. i=1 i=1 j : ij ∈ M j : ij ∈ M e ∴ Mm´ın (C) también minimiza C Segunda Observación: si Ci,j ≥ 0. Entonces si M es un matching de 00 s es decir Ci,j = 0 ∀i, j ∈ M ⇒ M minimiza la suma. Idea básica: restar o sumar fila “inteligentemente” hasta hallar un matching de ceros. Ese matching automáticamente minimiza la matriz original. 4.7.1.

Ejemplo de Matching que minimiza la Suma (A ojo) A B C D

Restamos a I A 0 B 4 C 0 D 9

cada fila II III 3 5 5 0 5 6 0 3

su mínimo IV 5 6 9 3

I 2 9 1 10

II III 5 7 10 5 6 7 1 4

IV 7 11 10 4

Restamos a cada columna su mínimo I II III IV A 0 3 5 2 @ Matching de 00 s. B 4 5 0 3 C 0 5 6 6 D 9 0 3 0

Restamos 5 a la tercer fila. A B C D

I II 0 3 4 5 -5 0 9 0

III 5 0 1 3

IV 2 3 1 0

Existe Matching Pero tengo un número Negativo.

62

Sumamos I A 5 B 9 C 0 D 14

5a II 3 5 0 0

la columna I III IV 5 2 0 3 1 1 3 0

Restamos el I A 3 B 9 C 0 D 14

mínimo a cada fila. II III IV 1 3 0 5 0 3 0 1 1 0 3 0

Hallé un I A 3 B 9 C 0 D 14

Matching II III 1 3 5 0 0 1 0 3

de 00 s. IV 0 3 1 0

n o M = AIV : 7; BIII : 5; CI : 1; DII : 1 ∴ Hallé un matching que minimiza la suma(14). 4.7.2.

Algoritmo Húngaro

Algoritmo de Khun-Munkres, conocido como algoritmo húngaro. 1. Restar el mínimo de cada fila a cada fila. 2. Restar el mínimo de cada columna a cada columna. 3. Buscar Matchings de 00 s Si existe hallé un matching que minimiza la suma. Sino tomar S: |S| > |Γ(S)|, y restarle un cierto m a las filas de S y sumarle m a las columnas de Γ(S) • ¿Cuál m? • m = m´ın S ∩ Γ(S) Equivalentemente: restar m a S ∩ Γ(S) y sumar m a S ∩ Γ(S) 4.7.3.

Ejemplo del algoritmo Húngaro I II III A 2 5 7 B 9 10 5  C 1 6 7 D 10 1 4 

IV 7 11 10 4

   

1. Restamos a cada fila su mínino: I II A 0 3 B 4 5 C0 5 D 9 0 

63

III 5 0 6 3

IV 5 6 9 3

   

2. Restamos a cada columna su mínimo: I II A 0 3 B 4 5 C0 5 D 9 0

III 5 0 6 3



IV 2 3 6 0

   

3. Buscamos Matching de 00 s A B C D

I 0 4 0 9

II 3 5 5 0

III 5 0 6 3

IV 2 3 6 0

A B C D

*

I 0 4 0 9 C

II 3 5 5 0

III 5 0 6 3

IV 2 3 6 0

6∗

A B C D

I 0 4 0 9 6C

III 3 0 4 3

IV 0 3 4 0

II 3 5 5 0

4. No hay matching perfecto A B C D

I 0 4 0 9 6C

II 3 5 5 0

III 5 0 6 3

IV 2 3 6 0

6I 6∗

Tengo S = {A, C} , las filas etiqueteadas. Γ(S) = I , las columas etiqueteadas. Con |S| > |Γ(S)| 5. Calculo: m = m´ın S ∗ Γ(S)

A B C D

I 0 4 0 9 6C

II 3 5 5 0

III 5 0 6 3

IV 2 3 6 0

I II 6I A 0 1 m=2 B   6 5 −→ C 0 3 6∗ D 11 0 

Referencias: S ∩ Γ(s) S ∩ Γ(s) S ∩ Γ(S) S ∩ Γ(S)

No lo modifico Sumo m No lo modifico Resto m

64

   

III 5 0 6 3

IV 2 3 6 0

I 6∗

6. Busco Matching de 00 S I A 0 B  6 a) No encuentro: C 0 D 11 

II 1 5 3 0

III 3 0 4 3

IV 0 3 4 0

   

b) Intento extenderlo: A B C D

I 0 6 0 11 C

II 1 5 3 0

III 3 0 4 3

IV 0 3 4 0

A B C D

I 0 6 0 11 C

II 1 5 3 0

III 3 0 4 3

IV 0 3 4 0 A

⇒

*

I

*

Extiendo el matching

I A 0 B  6 7. Llegué al Matching de 00 s: C 0 D 11 

II 1 5 3 0

III 3 0 4 3

IV 0 3 4 0

A B C D

I 0 6 0 11 C

II 1 5 3 0

III 3 0 4 3

IV 0 3 4 0

A B C D

I 0 6 0 11 C

II 1 5 3 0

III 3 0 4 3

IV 0 3 4 0 A

   

“A mano” 1. Tachar filas de S, y las columnas de Γ(S). 2. De lo no tachado, calcular el mínimo m. 3. Restar de lo no tachado m. 4. Sumar, a lo tachado dos veces, m. 4.7.4.

Complejidad de algoritmo Hungaro

Restar el mínimo en cada fila: O(n2 ). Restar el mínimo en cada columna: O(n2 ). Buscar Matching inicial: O(n2 ) Extender matching en un lado: “Paso” ∴ hay O(n) pasos.

65

I *

I

*

Complejidad de cada Paso Buscar m, restarlo y sumarlo: O(n2 ). Buscar Matching en la nueva matriz O(n3 ). ¿Cuántas veces buscamos m en un paso? No sabemos ∴ Compl(Hungaro) = O(n) ∗ O(n3 ) ∗ (No sabemos) Llamémosle “cambio de matriz” a buscar el m, restarlo y sumarlo. Lema: luego de un cambio de matriz el matching parcial que se tenía no se pierde. Prueba: la idea está en fijarse dónde está el matching.     S S

A A B C

Γ(S) Γ(S) Referencias A: puede haber ceros. B: No hay ceros, no hay matching. C: Ceros del Matching. S ∩ Γ(S) y S ∩ Γ(S) no cambian. Por lo tanto cualquier 0 de matching ahí permanece. En S ∩ Γ(S) no hay ceros, por lo tanto no hay matching. Sólo queda por ver: S ∩ Γ(S), donde puede haber ceros, pero ninguno del matching, pues supongamos que hubiera uno en la columna j, fila i. i 6∈ S, j ∈ Γ(s). Cuando revisamos la columna j buscamos el elemento del matching, ∴ hubieramos agregado la fila i a S, absurdo. Corolario: luego de un cambio de matriz, aumenta el matching, (i.e. se termina el paso) o bien aumenta S. Prueba: En S ∩ Γ(S) habrá un nuevo cero, digamos en la columna j, al revisar la j si está libre extendemos el matching. Sino hay una fila i con {i, j} ∈ M :matching, por lo tanto agregamos la fila i a S. Entonces S crece. Observación: i no formaba parte de S, pues por el lema anterior i debe estar en S. Corolario: hay a lo sumo n cambios de matriz en cada paso, pues S sólo puede crecer n veces. 66

Por lo tanto: Compl(Hungaro) = n ∗ Compl(paso) Compl(paso) =

n ∗Compl(cambiar la matriz) + O(n2 ) |{z} cambio de matriz Compl(cambiar la matriz) = O(n2 ) Compl(paso) = O(n3 ) Compl(Hungaro) = O(n4 )

Sin embargo, siendo “truquero” se puede reducir la complejidad a O(n3 ). ∴ Compl(Hungaro) = O(n3 ) 1. ¿Cómo restar m de S y sumar m a Γ(S) en tiempo O(n)? Agregamos etiquetas: cada fila y cada columna tiene una etiqueta que indica cuánto se le suma o resta. Cambiar las etiquetas es: O(n). Costo: en vez de chequear if(Ci,j == 0) hay que revisar: (Ci,j − ETi + ETj == 0) Acá suponemos que el costo de sumar y restar es O(1). 2. ¿Cómo calcular m´ın{S ∩ Γ(S)} en tiempo O(n)? Tendremos una etiqueta ψ que por cada columna guardará el mínimo, de la intersección de esa columna con S. ∴ Verificar el mínimo de {S ∩ Γ(S)} es simplemente calcular: m´ın{ψ(y) : ψ(y) 6= 0} = O(n) ya que ψ(y) == 0 ⇔ y ∈ Γ(S) Y los ψ(y) los vamos actualizando a medida que examinamos las filas de S. 4.7.5.

EJEMPLO DEL MEJORADO (FALTA)

67

5.

Códigos de correción de errores

En general un código, sobre un alfabeto A, de longitud n es un subconjunto de An . En general usaremos: A = {0, 1}. Llamaremos “Código”, a un código binario de bloque25 . Definición: dados x, y ∈ {0, 1}n la distancia de Hamming entre x e y es: dH (x, y) = d(x, y) = #{i : xi 6= yi } El peso de Hamming de x ∈ {0, 1}n es: W (x) = |x| = #{i : xi 6= 0} = d(x, 0n ) Claramente: d(x, y) = d(x ⊕ y, 0) = |x ⊕ y| ⇒ (x ⊕ y)i = xi ⊕ yi i.e. ⊕ = suma en Zn2 Con ⊕ xor definido de la siguiente manera: 0⊕0=0 0⊕1=1 1⊕0=1 1⊕1=0 es decir la suma módulo 2. Propiedad d es una distancia. Prueba: 1. d(x, x) = 0 2. d(x, y) = 0 ⇒ x = y 3. d(x, y) = d(y, x) 4. Desigualdad triangular: d(x, y) ≤ d(x, z) + d(z, y) ∀z Sean: A = {i : xi = yi }, B = {i : xi = zi }, C = {i : yi = zi }. xi = zi Si ⇒ xi = y i yi = zi ∴ i ∈ B ∩ C ⇒ i ∈ A, es decir (B ∩ C) ⊆ A Aplico De morgan: (B ∩ C) ⊆ A y obtengo: A⊆B∪C |A| ≤ |B ∪ C| ≤ |B| + |C| ∴ d(x, y) ≤ d(x, z) + d(z, y)

25

“Block code”: código de bloque.

68

Definiciones Br (x) = {y ∈ Zn2 : d(x, y) ≤ r} Un código C detecta r errores si: C ∩ Br (x) = {x} ∀x ∈ C Un código C corrige t errores si: Bt (x) ∩ Bt (y) = ∅ ∀x, y ∈ C : x 6= y Notación: δ = m´ın{d(x, y) : x 6= y : x, y ∈ C} Ejemplos: 1. C1 = {00, 01, 10, 11} ⇒ δ(C1 ) = 1 2. C2 = {000, 011, 110, 101} HHC2 C2 HH

HH

000

011

110

101

2

2 2

2 2 2

000 011 110 101

⇒ δ(C2 ) = 2

3. C3 = {000000, 010101, 101010, 111111} HH C3 C3 HHH

H

000000 010101 101010 111111

000000

010101

101010

111111

3

3 6

6 3 3

69

⇒ δ(C3 ) = 3

Teorema: sea C código binario y d = δ(C) entonces: 1. C detecta d − 1 errores y no detecta d errores. 2. C corrige b d−1 c errores y no corrige b d−1 c + 1 errores. 2 2 Prueba: 1. Detecta d − 1: Recordemos que δ es la “menor distancia entre palabras del código ” ?

Sea x ∈ C, y ∈ Bd−1 (x) ∩ C ⇒ x = y d(x, y) ≤ δ − 1 < δ ⇒x=y Pero x, y ∈ C No detecta d: x, y ∈ C : x 6= y Sean d(x, y) = δ

y ∈ Bd (x) ∩ C ⇒ Como y 6= x

⇒no detecta d errores.

c errores: 2. Corrige b d−1 2 Sea t = b d−1 c. 2 Sean x, y ∈ C, x 6= y. Supongamos Bt (x) ∩ Bt (y) 6= ∅ ⇒ ∃z ∈ Bt (x) ∩ Bt (y)

δ ≤ d(x, y) ≤ d(x, z) + d(z, y) ≤ 2t ≤δ−1 ∴ 0 ≤ −1 absurdo

(22) (23)

( 22) Ya que x 6= y y las dos están en C. ( 23) Ya que z está en las dos Bolas. c + 1 errores: No corrige b d−1 2 Sean x, y ∈ C : d(x, y) = d, sea e = x ⊕ y Entonces e tiene d unos. Sea e0 con b d−1 c + 1 unos de estos. 2 Sea z = x ⊕ e0 Quiero ver que z ∈ Bb d−1 c+1 (x) ∩ Bb d−1 c+1 (y) y ya está porque justamente la inte2 2 sección es no vacía. Luego d(x, z) = |x ⊕ z| = |x ⊕ x ⊕ e0 | = |e0 | = b d−1 c+1 2 70

d−1 d(y, z) = |y ⊕ z| = |y ⊕ x ⊕ e | = |e ⊕ e | = d − 1 + b c 2 0

0

?

≤b

d−1 c+1 2

Demostración de ? Si d = 2k + 1 (Impar) d − 1 + b d−1 c = 2k + 1 − 1 − k = k = b d−1 c < b d−1 c+1 2 2 2 Si d = 2k (Par) c = 2k − 1 − (k − 1) = 2k − 1 − k + 1 = k = k − 1 + 1 = b d−1 c+1 d − 1 + b d−1 2 2

Suposiciones acerca del medio de transmisión 1. No se pierden ni agregan bits.26 2. Sean: Ei+ el evento “Bit i cambia de 0 → 1”. Ei− el evento “Bit i cambia de 1 → 0”. Entonces: P Ei+ = P Ei− . Denotamos Ei al evento: cambia el Bit i. 3. Ei es independiente de Ej ∀i 6= j 4. 0 < P (Ei ) = P (Ej ) <

5.1.

1 2

Cota de Hamming

Teorema: sea C código de longitud n que corrija t errores entonces: |C| ≤ Prueba: sea A =

S

2n 1 + n + ... +

n t

Bt (x)

x∈C

Como C corrije t errores, esa unión es disjunta. X ∴ |A| = |Bt (x)| x∈C

Calculemos |Bt (x)|: Para ello definamos: Sr (x) = {y ∈ Zn2 : d(x, y) = r} 26

Sólo hay flips de bits.

71

∴ Bt (x) =

t S

Sr (x) unión disjunta.

r=0

|Bt (x)| =

t X

|Sr (x)|

r=0

y ∈ Sr (x) ⇔ d(x, y) = r ⇔ (x ⊕ y) = r donde defino (x ⊕ y) = e ⇔ ∃ e : |e| = r : y = e ⊕ x | {z } ∈Sr (0)

∴ Sr (x) = x ⊕ Sr (0) ⇒ |Sr (x)| = |Sr (0)| Luego e ∈ Sr (0) ⇔ tiene r 10 s y n − r 00 s De las n ubicaciones hay que elegir las r donde irán los 10 s. n ∴ |Sr (0)| = r ∴ |A| =

X

|Bt (x)|

x∈C

! t X X n = r r=0 x∈C t X n = ∗ C r r=0

Como A ⊆ Zn2 ⇒ |A| ≤ 2n t X n ⇒ ∗ C ≤ 2n r r=0 2n ⇒ C ≤ 1 + n + . . . + nt

Definición: un código se dice perfecto si C es un subespacio vectorial de Zn2 Recordemos que un subespacio vectorial27 se da si: 1. C 6= ∅ 2. Si x, y ∈ C ⇒ x ⊕ y ∈ C 3. x ∈ C, k ∈ Z2 ⇒ k ∗ x ∈ C 27

SEV.

72

Pero Z2 = {0, 1} • 1*X = X • 0*X = 0 ∴ Trivialmente está en C, bastaría ver que 0 ∈ C. C 6= ∅ ⇒ ∃x ∈ C ⇒ x ⊕ x} ∈ C | {z =0

∴ C es lineal si y sólo si (⇔) C 6= ∅ x, y ∈ C ⇔ x ⊕ y ∈ C n o Teorema: C lineal ⇒ δ = m´ın |x| : x ∈ C, x 6= 0 Prueba: Sea w = m´ın{|x| : x ∈ C, x 6= 0} Sean x, y ∈ C : x 6= y con d(x, y) = δ δ = |x ⊕ y| Como C es lineal x ⊕ y ∈ C y x ⊕ y 6= 0, pues x 6= y ⇒ δ ≥ w Sea ahora x ∈ C, x 6= 0 con |x| = w Entonces w = d(x, 0) , 0 ∈ C pues C es lineal. Como δ es la menor distancia tenemos que δ ≤ w ∴δ=w Ejemplos: C1 , C2 , C3 son obviamente lineales C1 = {11, 00, 01, 10} = Z22 ⇒ w = δ = 1 C2 = {000, 110, 101, 011} ⇒ w = δ = 2 C3 = {000000, 111111, 101010, 010101} ⇒ w = δ = 3 Notación: si C es lineal k denotará la dimensión de C. Corolario: si C es lineal de dimensión k ⇒ |C| = 2k Prueba: obvio pues k = Dim(C) ⇒ C ' Zk2 ⇒ |C| = 2k

73

5.2.

Matriz generadora

Definición: una matriz generadora G para C es una matriz cuyas filas forman una base de C. Por lo tanto si C es de dimesión k y longitud n y G es generadora de C entonces G es Kx N . G generadora ⇔ G es Kx N, con k = Dim(x) y C = EF (G) Recordemos que: EF (G) = {x ∈ Zn2 : ∃U ∈ Zk2 : x = U ∗ G}   1 0 0 1 1 1 Sea G = 0 1 0 1 0 1 0 0 1 1 0 0 C = {x1 x2 x3 x4 x5 x6 : ∃u1 , u2 , u3 : x = U ∗ G} u1 u2 u3 ∗ G = u1 u2 u3 (u1 ⊕ u2 ⊕ u3 )u1 (u1 ⊕ u2 )  0     0     0    0 C= 1     1     1    1

0 0 1 1 0 0 1 1

0 1 0 1 0 1 0 1

0 1 1 0 1 0 0 1

0 0 0 0 1 1 1 1

 0   0    1    1 ⇒δ=2 1   1    0    0

En particular:  n−1  z}|{   G=  

I

 1   ..  .   1

Da el código: C = {x1 . . . xn : xn = x1 ⊕ . . . ⊕ xn−1 } = {x1 . . . xn : x1 ⊕ . . . ⊕ xn−1 ⊕ xn = 0} “Bit parity Code” tiene δ = 2 Otro ejemplo de código lineal: códigos de repetición z }| { z }| { z }| { C = {x1 . . . xk x1 . . . xk . . . x1 . . . xk } | {z } r veces

n=r∗k Una matriz generadora G = I I I I I | {z r I0s

74

I ⇒ δ = peso mínimo no nulo = r }

5.3.

Matriz de chequeo

Una matriz H se dice matriz de chequeo si C = N u(H) = {x ∈ Zn2 : Hxt = 0} Propiedad  N  z }|  { t  I A A I |{z} |{z} k es generadora de C ⇔ n − k |{z} |{z} es de chequeo.  kx k n−k k n−k   Todo código tiene una matriz de chequeo. Prueba: Hay que ver que EF [I A] = N u [At I] ⊆ Sea x ∈ EF [I|A] ⇒ ∃U : x = U [I|A] = U (U.A)

Ut [A |I]x = [A |I] (U.A)t t

t

t

= At U t ⊕ (U A)t = At U t ⊕ At U t =0 Entonces x ∈ N u([At I]) ⊇ EF [I|A] ⊆ N u([At |I])  Pero Dim(EF ([I|A])) = k    Dim(N u([|{z} At | |{z} I ])) = k  k n−k dep. indeptes

∴ son iguales

   

Ejemplo:     1 0 0 1 1 1 1 1 1 1 0 0 G = 0 1 0 1 0 1 ⇒ H = 1 0 0 0 1 0 1 1 0 0 0 1 0 0 1 1 0 0        

   x1       x2      1 1 1 1 0 0    x 3     Entonces N u(H) = x1 . . . x6 : 1 0 0 0 1 0   = 0 x4      1 1 0 0 0 1        x   5     x6   x1 ⊕ x2 ⊕ x3 ⊕ x4 = 0   = x1 . . . x6 : x1 ⊕ x5 = 0   x1 ⊕ x2 ⊕ x6 = 0   x4 = x1 ⊕ x2 ⊕ x3   = x1 . . . x6 : x5 = x1 que es lo que tenía antes.   x6 = x1 ⊕ x2 75

Ejercicio: calcular las palabras del código que genera la siguiente matriz G.  1    1 1 0 1 1 1 0 0 0   0 1 1 0 0 0 1 0 Si G = ⇒H= 0 0 1 0 1 1 0 0 0 1 0

0 1 0 0 0

0 0 1 0 0

0 0 0 1 0

0 0 0 0 1

1 1 0 1 1

0 1 1 0 0

 1 0  1  en este caso δ = 3 1 0

Teorema: sea H la matriz de chequeo de C, si H no tiene la columna 0 ni columnas repetidas entonces δ ≥ 3. Y por lo tanto corrige al menos un error. Prueba: supongamos que no (δ < 3) ⇒ δ = 1 ó δ = 2 Supongamos δ = 1. Como C es lineal ⇒ ∃x ∈ C : |x| = 1 ⇒ ∃i : x = ei 28 Como x ∈ C ⇒ Hxt = 0 ∴ 0 = Hxt = Heti = H (i) Columna i de H. ⇒ H (i) = 0 absurdo. Supongamos δ = 2. Entonces ∃x ∈ C : |x| = 2 Entoces ∃i,j : i 6= j : x = ei ⊕ ej 0 = Hxt = Heti ⊕ Hetj = H (i) ⊕ H (j) ∴ H (i) = H (j) absurdo.

Ejemplo  1 0 Sea H =  0 0

0 1 0 0

0 0 1 0

0 0 0 1

1 0 1 1

1 1 0 1

1 1 1 0

 1 1  H es 4x 9 1 1

C = N u(H) ? |C| = 2k = 25 = 32 ∗ k =9−4=5 9 variables - 4 independientes ∗ = #Columnas − Rango es n porque tengo la identidad. ?

δ(C) = Como H no tiene la columna 0 ni columnas repetidas ⇒ δ(C) ≥ 3 Como H (1) + H (5) = H (9) 28

Recordemos ei = 0 . . . 0 |{z} 1 0 . . . 0. i

76

Entonces x = 010001001 ∈ C ⇒ δ(C) ≤ 3 ∴ δ(C) = 3 Una matriz que cumple esa condición es una matriz r ∗ (2r − 1) Con todas las columnas posibles no nulas de altura r. Entonces C = código de Hamming 1 0 1 orden posible. 2 = H = 0 1 1

H

H

2

x⊕z =0 = xyz : y⊕z =0 = {xyz : z = x = y} = código de repetición

H

3

H

4

 1 0 0 = H = 0 1 0 0 0 1  1010101 0110011 =H= 0001111 0000000

 1 0 1 1 1 1 0 1 K = 4 0 1 1 1  0110101 0010011  K = 11 0001111 1111111

Propiedad: los Hamming son perfectos.

H

2n Prueba: Hay que ver r = 1+n Donde n = 2r − 1 ⇒ 1 + n = 2r ∴

2n 2n r = r = 2n−r = 22 −1−r = 2k = 1+n 2

H

r

Algoritmo para corregir 1 error Cuando H (i) 6= 0, H (j) Supongamos que el emisor manda x ∈ C y el receptor recibe y = x ⊕ e con |e| ≤ 1. Si e = 0 Hy y = Hxt = 0 ∴ y ∈ C Si e = e ⇒ Hy t = Hxt ⊕ Heti = 0 ⊕ H (i) = H (i)

77

∴ El algoritmo es: 1. Calcular Hy t . 2. Si Hy t = 0 Aceptar y. 3. Si Hy t = H (i) Aceptar y ⊕ ei . 4. Si Hy t 6= 0, H (i) ∀i ⇒ hubo ≥ 2 errores, pedir retrasmisión. Ejemplo:  1 0 H= 0 0

0 1 0 0

0 0 1 0

0 0 0 1

0 1 1 1

1 0 1 1

1 1 0 1

1 1 1 0

 1 1  1 1

Se recibe: y = 01000100 Hy t = H (2) ⊕ H (3) ⊕ H (7)         0 0 1 1 1 0 1 0 (6)        = 0 ⊕ 1 ⊕ 0 = 1 = H 0 0 1 1 ∴ La palabra enviada fue x = y ⊕ e6 = 011001100 Pero si recibo z = 000011000 Hz t = H (5) ⊕ H (6)       0 1 1 1 0 1 (i)      = 1 ⊕ 1 = 0 6= 0, H ∀i ∴ Hubo ≥ 2 errores 1 1 0 Por ejemplo me pueden haber mandado: 000000000 ó 110011000 (i) En el caso del Hamming Hy t siempre va a ser 0 ó algún H (i) El algoritmo si se usa la matriz con H (i) = Binario Es más fácil: 1. Calcular Hy t 2. Si Hy t = 0 aceptar y 3. Sino tomar i: (representación binaria i)= Hy t y acepto y ⊕ ei

78

H

Ejemplo 5 5 tiene n =262 − 1 = 31 ⇒ k = 31 − 5 = 26 ∴ 5 =2 Supongamos que llega y = e1 ⊕ e2 ⊕ e11 ⊕ e27 ⊕ e31 Entonces:

H

Hy t = H (1) ⊕ H (2) ⊕ H (11) ⊕ H (27) ⊕ H (31)             1 0 1 0 1 1 0 1 1 1 1 0             (1)            = 0 ⊕ 0 ⊕ 0 ⊕ 1 ⊕ 1 = 0 = H 0 0 1 0 1 0 0 0 0 1 1 0 ∴ Mandaron x = y ⊕ e1 Si hubiese sido y = e2 ⊕ e7 ⊕ e17         0 1 1 0 1 1 0 0         (20)        Hy t =  0 ⊕ 1 ⊕ 0 = 1 = H 0 0 0 0 0 0 1 1 ∴ Mandaron x = y ⊕ e20 Observación: Hamming más un bit de paridad avisa si hay 2 errores. Teorema: sea C = N u(H) ⇒ δ(C) = m´ın{j : ∃j columnas L.D. de H}29 Prueba: ≥ : Sea x : |x| = δ(C) = d Entonces ∃i1 , i2 , . . . , id : x = ei1 ⊕ . . . ⊕ eid 0 = Hxt = Heti1 ⊕ . . . ⊕ Hetid = H (i1 ) ⊕ . . . ⊕ H (id ) Entonces {H (i1 ) , . . . , H (id ) } es L.D. ∴ δ ≥ m´ın{j : ∃j columnas dependientes de H} = j ∗ ≤ ∃i1 , . . . , ij ∗ : {H i1 , . . . , H ij∗ } es L.D. Entonces ∃c1 , . . . , cj ∗ no todos nulos tal que: c1 Hi1 , . . . , cj ∗ Hij∗ = 0 Como j ∗ es el mínimo ⇒ c1 , . . . , cj ∗ 6= 0 todos no nulos. Como Ci ∈ Z2 ⇒ ci = 1 ∀i ∴ H (i1 ) ⊕ . . . ⊕ H (ij∗ ) = 0 Entonces x ∈ C donde x = ei1 ⊕ . . . ⊕ eij∗ ∴ δ ≤ j∗ 29

LD: Linealmente dependientes.

79

5.4.

Cota Singleton

Corolario: si C es un código lineal de longitud n y dimensión k entonces δ(C) ≤ n−k+1 Prueba: Sean d = δ(C), H : C = N u(H) d = m´ın{j : ∃j columnas L.D. de H} = 1 + máx{j : Todo conjunto de j columnas es L.I.} ≤ 1 + máx{j : Existe un conjunto de j columnas L.I.} ≤ 1 + Rango(H) =1+n−k

Definición: un Código con δ = n − k + 1 se llama un código MDS30 .

5.5.

Códigos Cíclicos

Definición: sea W = w0 w1 . . . wn−1 definimos Rot(W ) = wn−1 w0 w1 . . . wn−2 Definición: un código C es cíclico si: 1. Es lineal. 2. Invariante por rotaciones: i.e. W ∈ C ⇒ Rot(W ) ∈ C Ejemplos Z2 + Bit de paridad es cíclico C = {000, 110, 101, 011} C = {000, 100, 010, 001} es invariante por rotación pero no cíclico ya que no es lineal: C[1] + C[2] 6∈ C C = {000, 100, 011, 111} es lineal pero no es cíclico. Identificación: w0 w1 . . . wn−1 ↔ w0 + w1 x + . . . + wn−1 xn−1 Definición: si P (x), H(x) son polinomios. P (x) mód H(x) es el resto de dividir P (x) por H(x). Teorema: si W tiene longitud n entonces: Rot(W ) = xW (x)

mód (1 + xn )

Prueba: xW (x) = x w0 + w1 x + . . . wn−1 xn−1 = w0 x + w1 x2 + . . . + wn−2 xn−1 + wn−1 xn 30

MDS: maximun distances separable.

80

Aplico módulo 1 + xn xW (x)

mód (1 + xn ) = w0 x + w1 x2 + . . . + wn−2 xn−1 + wn−1 = wn−1 + w0 x + w1 x2 + . . . + wn−2 xn−1 ↔ wn−1 w0 . . . wn−2 = Rot(W )

(24) (25)

( 24) wn−1 xn = wn−1 (xn + 1) + wn−1 | {z } | {z } Resto

Cociente

( 25) Conmuto. Ejemplo C = {0000, 1010, 0101, 1111} C ↔ {0, 1 + x2 , x + x3 , 1 + x + x2 + x3 } • Tomo w = 1010 ⇒ Rot(w) = 0101 1 + x2 ⇒ x(1 + x2 ) = x + x3 mód (1 + x4 ) = x + x3 ↔ 0101 • Tomo w = 0101 ⇒ Rot(w) = 1010 x + x3 ⇒ x(x + x3 ) = x2 + x4 x2 + x4 mód (1 + x4 ) = x2 + 1 = 1 + x2 ↔ 1010 Corolario: Sea C cíclico de longitud n,

W (x) ∈ C Q(x) ∈ Z2 (x)

⇒ W (x)Q(x) mód (1 + xn ) ∈ C

Propiedad: sea C lineal entonces ∃! polinomio no nulo de grado mínimo. Definición: si C es cíclico, el único polinomio no nulo de grado mínimo se llama el polinomio Generador de C, y usualemente se lo denomina G(x). Prueba: Sean g1 , g2 dos de ellos : Gr(g1 ) = Gr(g2 ) = t g1 + g2 ∈ C pues C es lineal. ? Entonces: Gr(g1 + g2 ) = Gr(g1 − g2 ) < t que era el menor grado. ∴ g1 + g2 = 0 ⇒ g1 = g2 ? : g1 (x) = a0 + a1 x + . . . + at−1 xt−1 + 1.xt : g2 (x) = b0 + b1 x + . . . + bt−1 xt−1 + 1.xt Entonces: g1 + g2 = (a0 + b0 ) + (a1 + b1 )x + . . . + (at−1 + bt−1 )xt−1 + 0

81

Propiedad: sea G(x) Generador : G(x) 6= 0 ⇒ Gr(G(x)) ≤ Gr(p(x)) ∀p(x) ∈ C Teorema: sea C un código cíclico de longitud n, G(x) su polinomio generador entonces: n o C = P (x) ∈ Z2 (x) : Gr(P (x)) ≤ n − 1 y G(x)|P (x) Prueba: ⊇ Si G(x) dividide a P(x): G(x)|P (x)

⇒

∃q(x) : P (x) = q(x) ∗ G(x) ⇒ P (x)

clase pasada

Como Gr(P (x)) ≤ n − 1 ⇒ P (x)

mód (1 + xn ) ∈ C

mód (1 + xn ) = P (x) ⇒ P (x) ∈ C

⊆ La parte importante Sea P (x) ∈ C ⇒ Gr(P (x)) ≤ n − 1 Para la segunda condición: Sean Q(x), R(x) ∈ Z2 (x) : P (x) = Q(x)G(x) + R(x): con Gr(R(x)) < Gr(G(x)) Gr(R(x)) < n − 1 Como Gr(R(x)) < Gr(G(x)) ⇒ ⇒ Gr(Q(x)G(x)) ≤ n − 1 Gr(P (x)) ≤ n − 1 Entonces por ⊇ Q(x)G(x) ∈ C ∴ R(x) = P (x) + Q(x)G(x) ∈ C por ser lineal. | {z } | {z } ∈C

∈C

Gr(R(x)) < Gr(G(x)) ≤ n − 1 ⇒ R(x) = 0 R(x) ∈ C ∴ P (x) = Q(x)G(x) ⇒ G(x)|P (x)

82

Teorema Sea C cíclico de longitud n, y G(x) el polinomio generador de C, con k = Dim(C) Entonces: 1. Gr(G(x)) = n − k 2. G(x)|1 + xn 3. G(x) = 1 +g1 (x) + . . . i.e. g0 = 1 Prueba 1. Sea P (x) : Gr(P (x)) ≤ n − 1 Por el teorema anterior P (x) ∈ C ⇔ ∃Q(x) : P (x) = Q(x)G(x) Si t = Gr(G(x)) ⇒ n − 1 ≥ Gr(P (x)) = Gr(Q(x)) + Gr(G(x)) | {z } =t

∴ Gr(Q(x)) ≤ n − t − 1 Viceversa si P (x) = Q(x)G(x) con Gr(Q(x)) ≤ n − t − 1 Entonces: Gr(P (x)) ≤ n − t − 1 + t = n − 1 ∴ P (x) ∈ C

Gr(Q(x)) ≤ n − t − 1 C = P (x) : ∃Q(x) : P (x) = Q(x)G(x) n o Esto da una biyección entre C y Q(x) : Gr(Q(x)) ≤ n − t − 1 = ?

∴ |C| = | ? | = |{Q(x) = q0 + q1 x + . . . + qn−t−1 xn−t−1 }| = 2n−t Como k = Dim(C) ⇒ |C| = 2k ⇒ 2k = 2n−t ⇔ k = n − t ⇔ t = n − k 2. Supongamos G(x) = g0 + g1 x + . . . + gn−k−1 xn−k−1 + xn−k Por lo demostrado en 1. sabemos que es de esa manera. Multiplico por xk :

xk G(x) = g0 xk + g1 xk+1 + . . . + gn−k−1 xn−1 + xn = (1 + g0 xk + . . . + gn−k−1 xn−1 ) +(1 + xn ) | {z } Rotk (G)

83

(26)

( 26) Sumo dos veces 1 en Z2 , que es lo mismo que sumar 0. Como C es cíclico y G(x) ∈ C ⇒ Rotk (G(x)) ∈ C Como G(x) es generador ∃Q(x) : Rotk (G) = Q(x)G(x)

∴ xk G(x) = Rotk (G(x)) + (1 + xn ) = Q(x)G(x) + (1 + xn ) ∴ 1 + xn = xk G(x) + Q(x)G(x) k = x + Q(x) G(x) Entonces G(x)|1 + xn 3. 1 + xn = V (x)G(x) ⇒ 1 = v0 g0 ⇔ g0 = 1

Esto da origen a un método para codificar: Primer método: Simplemente dada m(x) de grado ≤ k − 1. Tomo V (x) = m(x)G(x) Ejemplo: G(x) = 1 + x2 + x3 : n = 7 ¿Cuánto vale k = Dim(C) ? n − k = Gr(G(x)) ∴ 7 − k = 3 ⇒ k = 4 Por lo tanto el código tiene 24 = 16 palabras. Supongamos que queremos codificar: • m = 1011 ↔ m(x) = 1 + x2 + x3

V (x) = m(x)G(x) = (1 + x2 + x3 )2 = 1 + x4 + x6 ↔ 1000101 ∴ Mando 1000101

84

• Otra: m = 0110 ↔ x + x2

V (x) = (x + x2 )(1 + x2 + x3 ) = x + x 3 + x4 + x2 + x4 + x5 = x + x 2 + x3 + x5 ↔ 0111010 Esto corresponde a la siguiente matriz generadora: 

1 g1 g2 . . . gn−k−1 0 1 g1 g2 ...  0 0 1 g1 g2   .. .. .. . . . .. . . . . 0 0 0 0 1  1 0 G= 0 0

1

0 1

0 0 1 .. .

... ... ... .. .

gn−k−1 ... gn−k−1 .. .. . . g1 g2 . . . gn−k−1  0 1 1 0 0 0 1 0 1 1 0 0  0 1 0 1 1 0 0 0 1 0 1 1

Segundo Método Idea: sea P (x) + P (x) mód G(x) = 0 mód (G(x)) G(x)|[P (x) + (P (x) mód G(x))] ∴ Si el Gr(P (x)) ≤ n − 1 ya está: P (x) + (P (x) mód G(x)) ∈ C Truco Dado m(x) con Gr(m(x)) ≤ k − 1 ⇒ Gr(xn−k m(x)) ≤ n − 1 En definitiva m(x) → V (x) = xn−k m(x) mód G(x) + xn−k m(x) Ejemplos: • m(x) = 1011 ↔ 1 + x2 + x3 : n = 7 ⇒ k = 4 x3 m(x) mód G(x) = 0 ∴ V (x) = 0 + x3 m(x) = x3 + x5 + x6 ↔ 0001011 • m(x) = 0110 ↔ x + x2 x3 m(x) = x4 + x5 ?

x3 m(x) mód G(x) = Truco: G(x) = 1 + x2 + x3 ⇒ 1 + x2 + x3 ≡ 0(G(x)) x3 ≡ 1 + x2 (G(x))

85

 0 0  0  ..  . 1

x4 ≡ x + x3 (G(x)) ≡ x + 1 + x2 (G(x)) ≡ 1 + x + x2 (G(x))

x5 ≡ x + x2 + x3 (G(x)) ≡ x + x2 + 1 + x2 (G(x)) ≡ 1 + x (G(x)) ∴ x4 + x5 mód G(x) ≡ 1 + x + x2 + 1 + x ≡ x2 ∴ V (x) = (x4 + x5 ) mód G(x) + x4 + x5 = x2 + x4 + x5 ↔ 001 0110 | {z } m(x)

Esto corresponde a la matriz generadora:   xn−k mód G(x) + xn−k xn−k−1 mód G(x) + xn−k−1    G =  .. .. .. ..   . . .  . n−1 n−1 x mód G(x) + x Teníamos: x3 x4 x5 x6

mód mód mód mód

 G(x) ≡ 1 + x2 1 1 G(x) ≡ 1 + x + x2 ⇒G= 1 G(x) ≡ 1 + x 2 G(x) ≡ 1 + x 0

Es decir obtenemos la matriz G con identidad a Una matriz de chequeo H es:  1 0 0 1 H = 0 1 0 0 0 0 1 1

0 1 1 1

1 1 0 1

1 0 0 0

0 1 0 0

0 0 1 0

 0 0  0 1

derecha.  1 1 0 1 1 1 1 0 1

En general esto vale claramente: es decir, H (i) = xi mód G(x) : 0 ≤ i ≤ n − 1

86

Ejemplo: sea G(x) = 1 + x2 + x3 + x4 : n = 7 Hallar una matriz de chequeo con la identidad a izquierda. x4

mód G(x) ≡ 1 + x2 + x3

x5

mód G(x) ≡ x + x3 + x4

x6

≡ x + x3 + 1 + x2 + x3 ≡ 1 + x + x2 mód G(x) ≡ x + x2 + x3  1 0 H= 0 0

5.5.1.

0 1 0 0

0 0 1 0

0 0 0 1

1 0 1 1

1 1 1 0

 0 1  1 1

Correción de errores “Error Trapping”

Teorema: sea C cíclico de longitud n que corrige t errores, con G(x) = generador. Asuma que se manda V (x) y llega W (x) : E(x) = V (x) ⊕ W (x) Con |E| ≤ t, “error corregible”. Sean Si los “síndromes”: Si (x) = xi W (x) mód (G(x)) : 0 ≤ i ≤ n − 1 Si ∃i : |Si | ≤ t ⇒ E(x) = Rotn−i (Si ) = xn−i Si

mód (1 + xn )

Prueba de “Error Trapping”: Observación: Rot(U ) mód G(x) = xU (x) mód G(x) Pues Rot(U ) = xU (x) mód (1 + xn ) ∴ ∃Q(x) : xU (x) = Q(x)(1 + xn ) + Rot(U ) xU (x)

mód G(x) = Q(x)(1 + xn mód G(x)) + Rot(U ) | {z }

mód (G(x))

0 pues G(x)|1+xn

∴ Rot U (x) mód G(x) = xU (x) mód G(x) ∴ Roti U (x) mód G(x) = xi U (x) mód G(x) Sea i : |Si | ≤ t ? Si (x) = xi U (x) mód G(x) ⇒ absurdo. Si (x) = Roti (W (x)) mód G(x) ⇒ ∃P (x): Roti (W (x)) = P (x)G(x) + Si (x) ? y ⇒ Roti (W (x)) ∈ Bt (P (x)G(x)) ♦ Pero P (x)G(x) ∈ C 87

Pero W (x) = V (x) + E(x) Roti (W (x)) = Roti (V (x)) + Roti (E(x)) † Y |Roti (E(x)| = |E(x)| ≤ t ∴ Roti (W (x)) ∈ Bt (Roti (V (x)) ♣ | {z } ∈C

♦ y ♣ ⇒ Bt (P (x)G(x)) ∩ Bt (Roti (V (x))) 6= ∅ | {z } | {z } ∈C

∈C

i

⇒ P (x)G(x) = Rot (V (x)) ♠ Entonces por ♠ y y † ⇒ Si (x) = Roti (E(x)) ∴ E(x) = Rotn−i Si Ejemplo G(x) = 1 + x4 + x6 + x7 + x8 : n = 15 con t = 2 Llega W (x) = 1100 1110 1100 010 W (x) = 1 + x + x4 + x5 + x6 + x8 + x9 + x13 Al aplicar mód G(x) solo tengo que resolver los xi : i > k = 7 (los encuadrados). x8

mód G(x) ≡ 1 + x4 + x6 + x7

x9

mód G(x) ≡ x + x5 + x7 + x8

x10

≡ x + x5 + x7 + 1 + x4 + x 6 + x7 ≡ 1 + x + x4 + x5 + x6 mód G(x) ≡ x + x2 + x5 + x6 + x7

x11

mód G(x) ≡ x2 + x3 + x6 + x7 + x8

x12 x13

≡ x2 + x3 + x6 + x 7 + 1 + x4 + x6 + x7 ≡ 1 + x2 + x3 + x4 mód G(x) ≡ x + x3 + x4 + x5 mód G(x) ≡ x2 + x4 + x5 + x6

S0 = W (x) mód G(x) 6 7 4 5 6 2 4 = 1 + x + x4 + x5 + x6 + 1| + x4 + + x5 + x}6 {zx + x} + |1 + x + x{z+ x + x} + x | + x {z x8

2

5

=1+x +x +x ∴ |S0 | = 4 > 2

m´ od G(x)

7

88

x9

m´ od G(x)

x13

m´ od G(x)

Continúo calculando |S1 |, hasta encontrar uno tal que |Si | ≤ 2 S1 = x(W (x) mód G(x)) = x 1 + x 2 + x5 + x7 = x + x3 + x6 + x8 = x + x3 + x6 + 1 + x4 + x6 + x7 = 1 + x + x 3 + x4 + x7

S2 = 1 + x + x2 + x3 + x5 + x6 + x7 S3 = 1 + x + x2 + x3 + x4 .. . S6 = x3 + x4 + x5 + x6 + x7 S 7 = x4 + x5 + x6 + x 7 + x8 = x4 + x5 + x6 + x7 + 1 + x4 + x6 + x7 = 1 + x5 ∴ |S7 | = 2 ≤ 2 = 7 Entonces: E(x) = xn−i Si mód (1 + xn ) = x15−7 S7 mód (1 + x15 ) = x8 (1 + x5 ) mód (1 + x15 ) = x8 + x13 ∴ V (x) = W (x) + E(x) = 1 + x + x4 + x5 + x6 + x9 Ejercicio: sea G(x) = 1 + x2 + x4 + x5 + x6 + x10 + x11 : n = 23 con t = 3 W (x) = 1 + x7 + x8 + x9 + x12 + x13 Respuesta: V (x) = 1 + x8 + x9 + x12 + x13 + x14 + x15 + x16 Con S16 = 1 + x8 + x9 Definición: Polinomio Chequeador H(x) =

1 + xn G(x)

Propiedad (ejercicio) W (x) ∈ C ⇔ H(x)W (x)

mód (1 + xn ) = 0 : Gr(W (x)) ≤ n − 1 89

6.

P-NP

Definición: un “problema” de decisión es un problema cuyas únicas respuestas posibles son Sí o No (alternativamente 1 ó 0). Ejemplos Matching: dado un grafo G ¿tiene G un matching perfecto? Primo: dado un n ∈ N ¿es n primo? K-color: dado un grafo G ¿es χ(G) ≤ k? Semiformalización de “problema de decisión”. Un conjunto I (conjunto de instancias del problema y una función Π : I → {Sí,No} Alternativamente, tomando el conjunto de instancias positivas. S = {x ∈ I : Π(x) = Sí} Se puede pensar que un problema es un par (I,S) con S ⊆ I. En general, dado x ∈ I tenemos una “medida” del “tamaño” de x. En general, # de bits necesarios para representar a x, o algo ligado a eso. Lo denotaremos |x|. Por ejemplo si I = {G : G es un grafo finito}, podemos tomar |G| = #de vértices. Si I = N ⇒ |n| = dlog(n)e = #bits de n

6.1.

La clase P

P = clase de problemas de decisión tal que existe un polinomio P (x), y un algoritmo A tal que A resuelve el problema para x ∈ I en tiempo O(P (x)) Sí Si Π(x) = Sí Resolver es que: A(x) = N o Si Π(x) = No O bien en la forma “{I,S}” A(x) = Sí ⇔ x ∈ S Ejemplos: 2 − color ∈ P Matching bipartito: como Matching con instancia reducida a grafos bipartitos. Vimos que Matching bipartito31 ∈ P

6.2.

La Clase NP

NP no significa “No Polinomial”. (de hecho P ⊆ N P ). NP significa: “Non deterministic Polynomial”. Otra forma de definir esta clase que es la clase de problemas de decisión para los cuales existen “certificados” que verifican la respuesta “Sí” en tiempo polinomial. 31

Edmonds probó que Matching ∈ P .

90

Formalmente (I, S) ∈ N P ⇔ ∃j, ∃t ⊆ Ix J y ∃P (x) tales que: 1. (Ix J, T ) ∈ P 2. Dado x ∈ I vale x ∈ S ⇔ ∃y ∈ J :

6.3.

(x, y) ∈ T |y| ≤ P (|x|)

Co-NP

Definición: Co-NP = problema de decisión tal que el “complemento” está en P. Ejemplo: Primo ∈ Co-NP Certificado para “NO” una factorización. (En 1976 se probó que Primo ∈ NP) y en 2002 se probó que PRIMO ∈ P .

b Es Π(x) =

“Complemento de Π” N o Si Π(x) = Sí ó (I, S) → (I, I − S) Sí Si Π(x) = N o k-color ∈ NP ∀k

Certificado: dado un coloreo con k colores ver que es propio es: O(m) = O(n2 ) Observación: Claramente P ⊆ N P . “El” problema del millón es ¿P=NP?

6.4.

SAT

Un problema importate: SAT Una variable booleana x es una variable que sólo puede tomar dos valores 0 ó 1. Dado un conjunto de variables Booleanas: x1 , . . . , xn . Un literal: es una de esas variables o la negación de ellas. (x = 1 ⊕ x). Una claúsula: (“Clause”) es un “∨” de literales (“Disjunción”). Ejemplo: x1 ∨ x2 . . . Una expresión Booleana en forma Conjuntiva Normal32 , es una conjunción (“∧”) de claúsulas. Ejemplo: (x1 ∨ x2 ) ∧ (x1 ∨ x3 ∨ x7 ) ∧ (x2 ∨ x3 ∨ x4 ) SAT es:33 dada B en CNF: ¿∃ un asignamiento de valores a las variables que la vuelva verdadera? 32 33

CNF: Conjuctive Normal Form. Nota: “SAT”, sería sin pedir CNF, esto sería “CNF-SAT, pero todo el mudo lo llama SAT”.

91

SAT ∈ N P : Certificación una valuación. Otras formas de SAT están en P. DN F − SAT ∈ P : ∨0 s de ∧0 s Xor − SAT ∈ P : ∧0 s de ⊕0 s (Xors) Pero SAT no se sabe, de hecho Cook probó que SAT ∈ P ⇒ P = N P No probaremos este teorema pero daremos una “olfateada” al mismo. La clave está en lo que Cook llamó: “Reducción Polinomial”. Que ahora también se conoce como “Reducción de Cook”. 6.4.1.

Reducción Polinomial

Definición: dados dos problemas de decisión π = (I, S) , τ (J, T ) Diremos que π se reduce a τ (π ≤P τ ) si: ∃ Polinomio P (x) y una función ψ : I → J : 1. Calcular ψ(x) es O(P (x)) y ψ(x) es polinomial en x. 2. x ∈ S ⇔ ψ(x) ∈ τ i.e. π(x) = “Sí” ⇔ τ (ψ(x)) =“Sí”. Ejemplos sencillos: Tonto y no del todo correcto: • π : Dada ax2 + bx + c = 0 ¿tiene solución ∈ R? • τ : Dado t ∈ R ¿es t ≥ 0? Entonces: π ≤P τ tomando t = b2 − 4 ∗ a ∗ c Otro ejemplo • π : Dada A ∈ Qn∗n ¿A es invertible? • Dado t ∈ Q ¿es t 6= 0? π ≤P τ tomando Det(A) = t. 6.4.2.

k − color ≤P SAT

Teorema: k − color ≤P SAT Prueba: Dado un grafo G debemos construir polinomialmente una B ∈ CN F tal que: χ(G) ≤ k ⇔ B es satisfactible i.e. ∃ un asignamiento que la vuelve verdadera. Sea n = # vértices de G. Tomemos variables xi,j : 1 ≤ i ≤ n, 1 ≤ j ≤ k Para i = 1, . . . , n defino Ci = xi,1 ∨ xi,2 ∨ . . . ∨ xi,k C = C1 ∧ C2 ∧ . . . ∧ Cn

92

Di =

V

xi,j ∨ xi,r

j, r j
b=C b1 ∧ . . . ∧ C bn = 1 ∴C Todo vértice tiene un sólo color ∀i ∃! j ≤ k : C(i) = j ∴ ∀i @j 6= r : C(i) = j, C(i) = r ∀i, ∀j < r : C(i) 6= j ∨ C(i) 6= r x bi,j = 0 ∨ x bi,r = 0 o lo mismo: x bi,j = 1 ó x bi,r = 1 b =1 x bi,j ∨ x bi,r = 1 ∀i, ∀j < r ⇒ D Finalmente como el coloreo es propio ∀il ∈ E Tenemos C(i) 6= C(l) i.e. ∀il ∈ E, @j : C(i) = C(l) = j ⇒ ∀il ∈ E, ∀j : (C(i) 6= j ó C(l) 6= (j) | {z } x bi,j =1 ó x bi,r =1 93

∴ ∀il ∈ E, ∀j : x bi,j ∨ x bi,r = 1 ⇒ Fb = 1 b=C b∧D b ∧ Fb = 1 B Fin (⇒) b = 1 y queremos ver que: χ(G) ≤ k bi,j con B ⇐ Ahora sabemos que existe x C bi,j = 1 (?) b = 1 ⇒ ∀i, ∃j : x b b B = 1 ⇒ D = 1 ⇒ ∀i, ∃!j : x bi,j = 1 definimos C(i) = el único j con x bi,j = 1 b F = 1 ⇒ ∀ij ∈ E, C(i) 6= C(l) ∴ C es propio ? Cuento con la demostración de la ida. Observación: Cook probó π ∈ N P ⇒ π ≤P SAT Corolario: SAT ∈ P ⇒ P = N P

6.5.

NP Completo

Definición: un problema τ es NP completo si: 1. τ ∈ N P 2. π ∈ N P ⇒ π ≤P τ Un año después de Cook, Karp dió otros 23 problemas NP completos, en la actualidad hay más de 2000. La clave es lo siguiente: Si τ ∈ N P Completo y τ ≤P τ ∗ : τ ∗ ∈ N P Entonces τ ∗ es NP Completo. La demostración sale del hecho que ≤P , es transitiva, ya que es una composición de polinomios. A continuación daremos algunos ejemplos NP completos. 6.5.1.

3-SAT es NP completo

3-SAT es como SAT pero en cada claúsula debe haber exactamente 3 literales distintos. 3-SAT es NP completo Prueba: probaremos que SAT ≤P 3-SAT (por Cook). b en CNF pero que Es decir dada B en CNF debemos construir polinomialmente una B tenga exactamente 3 literales por claúsula y tal que B sea satisfactible ⇔ B 0 lo es. Supongamos que B = D1 ∧ . . . ∧ Dm : Di claúsulas. Variables de B = x1 , . . . , xn Dada una claúsula D arbitraria, definiremos una conjunción de claúsulas E (con más variables), y luego tomaremos: B 0 = E1 ∧ E2 ∧ . . . ∧ Em donde Ei corresponde a Di . 94

Cada Ei crea sus propias variables extras. Construcción: Si D tiene 3 literales: E =D Si D tiene 2 literales : D = L1 ∨ L2 Tomamos una variable extra y 6∈ {x1 , . . . , xn }. Tomamos E = (L1 ∨ L2 ∨ y) ∧ (L1 ∨ L2 ∨ y) c1 ∨ L c2 = 1 ⇒ (L c1 ∨ L c2 ∨ yb) ∧ (L c1 ∨ L c2 ∨ yb) = 1 Claramente si L Viceversa: Si ∃{xb1 , . . . , x cn , yb} c1 ∨ L c2 ∨ yb) ∧ (L c1 ∨ L c2 ∨ yb) = 1 Tal que (L Entonces si: c1 ∨ L c2 = 1 • yb = 0 ⇒ L c1 ∨ L c2 = 1 • yb = 1 ⇒ L Observación: probamos un poco más de lo que dijimos ~ ~ ~ ~ ~ ∃x b:D x b = 1 ⇔ ∃yb : E x b, yb = 1 Esto valdrá en todos los casos. D tiene un literal: i.e. D = L Tomamos: E = (L ∨ y1 ∨ y2 ) ∧ (L ∨ y1 ∨ y2 ) ∧ (L ∨ y1 ∨ y2 ) ∧ (L ∨ y1 ∨ y2 ) Y es casi obvio que: b=1⇔E b = 1 i.e. cualquier yb1 , yb2 L D tiene ≥ 4 literales. D = L1 ∨ L2 ∨ . . . ∨ Lk Entonces tomamos k − 3 variables nuevas: y1 , y2 , . . . , yk−3 polinomial en k K >> 4: E = (L1 ∨L2 ∨y1 )∧(y1 ∨y2 ∨L3 )∧(y2 ∨y3 ∨L4 )∧. . .∧(y k−4 ∨yk−3 ∨Lk−2 )∧(y k−3 ∨Lk−1 ∨Lk )

95

#claúsulas = k − 2 ∴ lineal en k. b = 1 ⇒ ∃j : L bj = 1 Supongamos ahora D Definamos: yb1 = yb2 = . . . = ybj−2 = 1 ybj−1 = ybj = . . . = ybk−3 = 0

b =(L b1 ∨ L b2 ∨ yb1 ) ∧ (b b ) ∧ . . . ∧ (b bj ) ∧ (b bj+1 ) E y 1 ∨ yb2 ∨L y j−2 ∨ ybj−1 ∨ L y j−1 ∨b yj ∨ L |{z} |{z} 3 |{z} |{z} =1

=1

HIP =1

=1

bk−1 ∨ L bk ) ∧ . . . ∧ (b y k−3 ∨L |{z} =1

b=1 ∴E b=1 Veamos la vuelta: supongamos que E b = 1. Supongamos que no. Queremos ver que D b c ck = 0 ⇒ L b D = 0 ⇒ L1 ∨ . . . ∨ L r = 0 ∀r b = yb1 ∧ yb1 ∨ yb2 ∧ yb2 ∨ yb3 ∧ . . . ∧ ybk−4 ∨ ybk−3 ∧ ybk−3 Nos queda: E b=1 Como E Tenemos:      yb1 = 1        ⇒ yb2 = 1      yb1 ∨ yb2 = 1 ⇒ yb3 = 1    . . . ⇒ ybk−4 = 1   yb2 ∨ yb3 = 1 ⇒ y b = 1  k−3   Absurdo    yb3 ∨ yb4 = 1        . . . ybk−4 ∨ ybk−3 = 1   b y k−3 = 1 

6.5.2.

3-color es NP completo

Teorema: 3-color es NP completo Prueba: veremos que 3-SAT ≤P 3-color. Es decir necesitamos : B(3-CN F ) → G Sea B = D1 ∧ . . . ∧ Dm con variables {x1 , . . . , xn }. Dj = L1,j ∨ L2,j ∨ L3,j Vamos a construir G = (V, E) con |V |, |E| polinomiales en n, m Ya damos la construcción en general, primero un ejemplo.

96

6.5.3.

Ejemplo 3-SAT ≤P 3-color B = (x1 ∨ x2 ∨ x3 ) ∧ (x2 ∨ x3 ∨ x4 )

efefefnt YXP?PXYXYXYY efefefefefnefnefnnn ??PPPXPXYPXYXYXYXYXYXYXYYYYY e e e f e e f e ?? PP XX YY e ff nnn eefefefefefeffff ?? PPPP XXXXXYXYXYXYXYXYYYYYYY e n e e n e e e f n e XXXXX YYYYYYY f e f P n e ? f e e P f n P XXXX YYYYY fff eeeee nn _ _ x4 _ x3 x 4 x3 x1, eee _ x1 fff x2 x2 A 3 u ,, A 3 u A u 33 AA ,, uu 33 AA uu u ,, ' AA 33 uu u ,, A 33 bb efhmbefhm s AA uuu bb e bb f e bb e f h bb e f bb e h bb f e ,, 33 bbbbbbbbbbbb eeeeefefefhfhfhhhmmm || uAu A ,, uu Abb bbbbbbbbbbbb33 eeeeeefefefefefefhfhfhfhfhhhmmmmm ||| bb A u bb bb u A bb ff hh mm u bb bbbb ,, eeee3 AA || eeeefefeffffffffhhhhhh mmmmm bbbbbbbbbbbbuuu e bb e A bb || e bb e ,, bb e e A u | e1,2 e f e m e f 2,2 e m f u e AAfffff || ,, eeeeee uu mmm || ueueeeeeee ffffffffffAAA mmm e | m e u ,, e m e e | AA ff ee u | mmm , eeeeee uuuu fffffffff A || mmm eeeeee f m e | f e f e m e f e f e e2,1 e1,1 e2,3 e1,3

i1,1

{{ {{ { { {{

i1,2

CC CC CC CC _ i1,3

{{ {{ { { {{ i2,1 _

i2,2

CC CC CC CC

i2,3

En general: V = {s, t} ∪ {x1 , . . . , xn , x1 , . . . , xn } ∪ {W1 , . . . , Wm } Con Wj = {ej,1 , ej,2 , ej,3 , ij,1 , ij,2 , ij,3 } E = {st}∪{txk , txk , xk xk }nk=1 ∪T1 ∪. . .∪Tm ∪E1 ∪. . .∪Em ∪F1 ∪. . .∪Fm ∪{sej,k }

Donde: Tj = {ij,1 ij,2 ; ij,2 ij,3 ; ij,3 ij,1 } Ej = {ej,1 ij,1 ; ej,2 ij,2 ; ej,3 ij,3 } Fj = {ej,1 L1,j ; ej,2 L2,j ; ej,3 L3,j } G tiene: 2 + 2n + 6m vértices, polinomial. G tiene: 1 + 3n + 3m + 9m = 1 + 3n + 12m lados, polinomial. Hay que ver B satisfactible ⇔ χ(G) ≤ 3 (Como G tiene triángulos χ(G) ≤ 3 ⇔ χ(G) = 3)

97

1≤j≤m k = 1, 2, 3

Veamos ⇐ primero: Sea C un coloreo de G de 3 colores queremos dar un asignamiento de valores a las b) = 1 variables tal que: B(~x Definamos: 1 Si C(xk ) = C(s) xbk = 0 Sino b) = 1 Queremos ver que B(~x b) = 1 ∴ ∀j basta ver: Dj (~x b1,j ∨ L b2,j ∨ L b3,j = 1 ∴ Hay que probar ∀j L Veamos como Tj es un triángulo entonces los 3 colores están representados. Entonces: ∃k : C(ij,k ) = C(t) ij,k ej,k ∈ E ⇒ C(ej,k ) 6= C(ij,k ) = C(t) sej,k ∈ E ⇒ C(ej,k ) 6= C(s) st ∈ E ⇒ C(s) 6= C(t) C(ej,k ) = “tercer color” Como ej,k Lj,k ∈ E ⇒ C(Lk,j ) 6= “tercer color” tLk,j ∈ E ⇒ C(Lk,j ) 6= C(t)

⇒ C(Lk,j ) = C(s)

bk,j = 1 Fin ⇐ Por definición L b : B(~x b) = 1 debemos construir un coloreo propio ⇒ Dado un asignamiento de valores ~x con 3 colores. Definimos: C(s) = 1 , C(t) = 2 ⇒ st No Crea Problemas (NCP). Coloreamos: C(xi ) = xbi ⇒ xi xi (N CP ) C(xi ) = 1 ⊕ xbi Además: C(xi ), C(xi ) ∈ {0, 1} C(t) = 2

⇒ txi , txi

b) = 1 Como B(~x b) = 1 ∀j = 1, . . . , m ⇒ Dj (~x d d d i.e. L 1,j ∨ L2,j ∨ L3,j = 1 d ⇒ ∀j, ∃k : L k,j = 1 (si hay más de uno elijo alguno) Coloreamos: C(ej,k ) = 0 bk,j = 1 ⇒ C(Lk,j ) = 1 ⇒ Lk,j ej,k Como L Y coloreo:

C(ej,r ) = 2 : r 6= k C(Lr,j ) ∈ {0, 1}

(N CP )

(N CP )

⇒ ej,r Lr,j 98

(N CP )

Como:

 C(ej,k ) = 0 C(ej,r ) = 2 ⇒ sej,k y los sej,r  C(s) = 1

(N CP )

Finalmente coloreamos: C(ij,k ) = 2 C(ej,k ) = 0

⇒ ej,k ij,k

(N CP )

Y coloreamos: C(ij,r ) = 0 ó 1 : r 6= k ∴ ij,r ej,r |{z} |{z} 0 ó 1 =2

(N CP )

Finalmente el triángulo:

ij,1

}} }} } } }}

ij,2

AA AA AA AA _ ij,3

Tiene un vértice de color 2 el (j, k) uno de color 0 y otro de color 1

99

(N CP )

6.5.4.

2-SAT ∈ P

D[j] = Claúsula j-ésima, un par de números (L, R). Registros x[0] , . . . , x[n-1] ; x[n] , . . . , x[2n-1] b1 , . . . , bn Representan x b1 , . . . ,x bn ;x x 2-SAT 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

V ariables : x0 , . . . , xn−1 SET EAR(v) : //M ACRO X[v] = 1; X[2n − 1 − v] = 0; Q = Q ∪ P [v] ∪ P [2n − 1 − v] N = { 0 , . . . , n−1} ; // V a r i a b l e s no s e t e a d a s M = { 0 , . . . , m−1} ; // D i s j u n c i o n e s no s a t i s f e c h a s Q = ∅; f o r ( i = 0 , i < 2n , i ++){ x [ i ] = −1 ; P [ i ] = { j ∈ M : i a p a r e c e en D[ j ] } ; } f o r ( j = 0 , j < m, j ++){ Sat [ j ] = 0 ; } while ( N 6= ∅ ) Tomar i ∈ N, SETEAR( i ) ; while (Q 6= ∅ ) { E l e j i r j ∈ Q; L ,R: D( j ) = {L ,R} ; i f ( ( x [ L ] == 1 ) | | ( x [R] == 1 ) ) { Sat [ j ] = 1 ; Remover j de Q; // Pero no de M } e l s e i f ( x [R] <0) { SETEAR(R) ; /∗ S i X[R] < 0 , d e b e s e r x [ i ] = 0 e n t o n c e s debo a s i g n a r x [R] = 1 ∗/ } e l s e i f ( x [ i ] <0) { SETEAR(L) /∗ E s t e e s t a d o e s cuando queda e l c a s o 00 , por l o t a n t o nos equivocamos coon e l s e t e o de x [ i ]= 1 , por l o t a n t o hay que cambiar ∗/ } e l s e i f ( x [ i ] == 1 ) { // Anular t o d o s ∀t ∈ N, ∀s ∈ M { SAT( s ) = 0 ; x [ t ] = x [ 2 n−1−t ] = −1; } Q = ∅; SETEAR[ 2 n−1− i ] } else return "NO SAT" } ∀i ∈ N, ∀j : SAT [j] = 1{ B o r r a r j de P [ i ] y P [ 2 n−1− i ] } } Return "SAT"

100

6.5.5.

HORN-SAT

HORN-SAT es como CNF-SAT pero donde cada claúsula tiene a lo sumo un literal “positivo” : xi → “positivo” y xi → “negativo” Teorema: HORN -SAT ∈ P Prueba: x1 ∨ x2 ∨ . . . ∨ xk ∨ xk+1 ≡ x1 ∧ x2 ∧ . . . ∧ xk ∨ xk+1 ≡ x1 ∧ x2 ∧ . . . ∧ xk ⇒ xk+1 El algoritmo empieza seteando todas las variables a f alse. Recordamos: true ⇒ true ≡ true F alse ⇒ ? ≡ true true ⇒ f alse ≡ f alse Entonces todas las disjunciones de la forma: x ∧ x2 ∧ . . . ∧ xk ⇒ xk+1 van a ser true {z } |1 |{z} f alse

f alse

Las de la forma: x1 ∨ x2 ∨ . . . ∨ xk ≡ x1 ∨ x2 ∨ . . . ∨ xk ∨ f alse ≡ x1 ∧ x2 ∧ . . . ∧ xk ⇒ f alse | {z } f alse

≡ true El único problema son las disjunciones de la forma: x ≡ true ⇒ |{z} x f alse

≡ f alse Si hay una de esas, listo. Si hay, seteamos estas variables a true (permanentemente). Luego de eso se hacen true todas las variables xk+1 que estén en una disjunción de la forma: x1 ∧ . . . ∧ xk ⇒ xk+1 En donde x1 , . . . , xk sean true. Si en algún momento se llega a una contradicción, no se puede satisfacer. La contradicción vendría de alguna de la forma: x1 ∨ x2 ∨ . . . ∨ xk con todas las xi true

Ejemplo: (x ∨ y ∨ z ∨ w) ∧ (x ∨ y) ∧ (z ∨ w ∨ x) ∧ (x ∨ z) ∧ (y ∨ z) ∧ y yb = 1 ⇒ zb = 1 ⇒ x b = 0, zb = 0 Pero supongamos que siguiera con . . . ∧ (y ∨ z ∨ U ) ∧ (u ∨ x) b=1⇒x yb = 1 ⇒ zb = 1 ⇒ U b=0 ∴ No se puede resolver x ∨ y 101

7.

Introducción a la Inteligencia Artificial

7.1.

Hill Climbing

7.2.

Simulated Annealing

7.3.

Algoritmos Evolutivos

Tomar una población de posibles soluciones (por ejemplo una cadena de bits). 1. Elegir un miembro de la población. 2. Cambiar cada bit de ese miembro y evaluar si el cambio mejora la solución. Nos quedamos con el mejor: Si hay uno repetir 2. Sino, guardar el individuo en un conjunto B, y repetir 1. 3. Finalmente elegir el mejor de B. Este algoritmo es evolutivo pero no genético

7.4.

Algoritmos Genéticos Genético ⇒ Interacción entre individuos.

Los algoritmos genéticos34 , se basan más o menos en la evolución biológica. Cada individuo, tiene cromosomas, que forman cadenas de ADN, se dividen en “Genes” que codifican un aspecto del individo, por ejemplo el color de los ojos. El conjunto de cromosomas se llama “genotipo” y las características inducidas en el individuo por la acción del genotipo y el medio ambiente es el “fenotipo”. También podemos distinguir entre especies haploides y diploides, (humanos). Los cromosomas vienen en pares con genes dominantes y recesivos. Haploide: los cromosomas no están emparejados. En la mayoría de los algoritmos genéticos los individuos son haploides y con un solo cromosoma. A veces a los individuos se les llama “cromosomas”. Pero a veces el individuo tiene algo más que cromosomas. Una parte importante de un AG es codificar el problema con cromosomas. Un cromosoma será una cadena de símbolos, usualmente bits o un vector de números. Ejemplos: 1. Maximizar una función en R3 la codificación puede ser una cadena de 3 números. 2. Hallar un recorrido de n ciudades que no repita ninguna y minimice la distancia (TSP)35 . Codifica una cadena con el nombre de cada ciudad (sin repetir). 34 35

AG. Travel Salesman Problem.

102

En todo AG necesitamos una función a maximizar, llamada función de “Fitness36 ”. En los ejemplos anteriores: 1. f es la función. 2. Sería la f del costo del camino. A veces como en TSP no toda cadena representa una solución, por ejemplo puede ser que no haya camino entre las dos ciudades. Generalmente se soluciona “creativamente”, por ejemplo en TSP, podemos suponer que hay ruta entre 2 ciudades cualesquiera, asignándole, un peso muy grande si no existe en la realidad. Pero en otros problemas esto es más delicado. ∴ Es la primera característica de un AG. 1) Una población de individuos con cromosomas y una función de fitness adecuada. Otra característica es: 2) Selección de individuos a reproducirse mediante la fitness. Un AG tendrá lo que se llaman “Generaciones”. Población Inicial (generación 0) ⇓ Algo ⇓ Población nueva (generación 1) ⇓ Algo ⇓ Población nueva (generación 2) 7.4.1.

Selección

Los individuos a reproducirse se seleccionan de a pares y luego viene lo esencial: 3) Los progenitores producen nuevos individuos (“offspring”) por medio del cruzamiento (“crossover”) de genes. 4) Los “offspring” son sometidos a mutaciones al azar. Operador mutación. Esto depende de una tasa de mutación, generalmente baja ≈ 0, 001 5) Debe haber un operador de Selección entre Progenitor 1, Progenitor 2, offspring 1 y offspring 2. (es decir tengo que matar a 2). 6) Debe haber una condición de terminación. Por ejemplo, un número máximo de generaciones.

7.5.

Ejemplo de un AG

Problema: dado un número natural escribirlo como suma, resta, producto y división de los dígitos: 0, 1, . . . , 9 quizás repetidos (asociando a izquierda). 36

Adaptabilidad.

103

7.5.1.

Codificación del ejemplo

n o Una posibilidad sería una cadena de símbolos del alfabeto A = 0, . . . , 9, +, ∗, / pero que debe tener: N ◦ Símbolo N ◦ . Problema: crossover y mutaciones se pueden complicar. Una posibilidad es hacer cadenas de pares (N ◦ ,operador) u (operador, N ◦ ) y suponer que empezamos con 0. Otra posibilidad: simplemente usar cadenas de bits, entonces un gen serán 4bits. 0000 → 0 0001 → 1 .. . 1001 → 9 1010 → +

1011 → − 1100 → ∗ 1101 → / 1110 → N ada 1111 → N ada

El cromosoma será el genotipo, el fenotipo en cambio tiene que ser una cadena: 0 Símbolo N ◦ Símbolo . . . que además no tenga “/0”. Genotipo → F enotipo Si es 14 ó 15 lo descartamos. Si es N ◦ y se requiere un Símbolo lo descartamos. Si es un Símbolo y se requiere un N ◦ lo descartamos. Sino se usa. Si tenemos un “/0” cambiar 0 por 1. 7.5.2.

Fitness del ejemplo Fitness será algo como : =

7.5.3.

P

1 F enotipo−31

“∞”

P si F enotipo 6= 31 P si F enotipo = 31

Entrecruzamiento del ejemplo

Crossover: Singled Point Crossover Progenitor 1: b1 b2 b3 . . . b400 Progenitor 2: bb1 bb2 bb3 . . . bb400 Elijo al azar un número x : 0 < x < 400 y obtengo: Por ejemplo x = 127 Offspring 1: b1 b2 b3 . . . b127bb128 . . . . . . bb400 Offspring 2: bb1bb2bb3 . . . bb127 b128 . . . . . . b400 7.5.4.

Mutación del ejemplo

Para cada bit lo cambio con probabilidad p. 104

7.5.5.

Selección del ejemplo

Mato a los padres, me quedo con los offsprings. 7.5.6.

Operadores de Selección

Asumimos que cada individuo tiene una fitness Fi calculada. Queremos seleccionar de los n individuos, quiénes se van a reproducir, tomando, en cuenta las Fi . Hay varios métodos, los más usados caen en un categoría llamada: “Fitness Proportional Selection” n P

Sea F =

Fi

i=1

n

la fitness promedio.

Sea Ei = FFi = # esperado de veces que el individuo i, debería ser seleccionado de acuerdo a su fitness. Fi Ei = n ∗ P n Fj j=1

Queremos seleccionar i con un método que lo elija cerca de Ei veces. El primer método propuesto por Holland, hace esto lo más cercano posible se llama “Stochastic Sampling With Replaciment” (SSWR), o Ruleta. Elijo un número al azar y elijo ese número. Calculando las Ei0 s se toma un número al azar A entre 0 y n y se toma el primer i P i: Ej > A j=1

Ejemplo: 6 individuos. “Fitnesses” F1 F2 F3 F4 F5 F6

= = = = = =

17,118 9,51 36,138 22,824 91,296 13,314

∴

6 P

Fj = 190, 200

j=1

Lo más simple es tomar un número al azar entre 0 y 1 que por ejemplo tomando r ∈ (0, 1) y calculo r ∗ 190, 2. Para entender mejor otros conceptos, haremos el cálculo sin embargo con los Ei0 s  E1 = 0, 54     E2 = 0, 30    Fi E3 = 1, 14 ∗6⇒ Ei = E4 = 0, 72  190, 2    E = 2, 88    5 E6 = 0, 42 105

Ruleta: # al azar: entre 0 y 1: 0, 15 0, 7 0, 22 0, 91 0, 46 0, 63 Multiplico por n = 6 0, 90 4, 2 1, 32 5, 46 2, 76 3, 78 1 → 0, 54     2 → 0, 84    i P 3 → 1, 98 1• 3• Ahora calculo: Ej ⇒  4 → 2, 70 j=1    5 → 5, 58 2• , 4• , 5• , 6•    6→6 Este método puede producir lo que se llama “Crowding” de la población por un individuo o grupo de individuos y “convergencia temprana” a un máximo local, además tiene otro problema. Hay 3 medidas de un operador de selección: Bias. Spread. Eficiencia computacional. Bias: es la diferencia entre FFi y el valor esperado de veces que el individuo será seleci cionado con el método propuesto. Bias(Ruleta) = 0. Spread: rango de offspring que un individuo puede tener: Ruleta(Spread(i)) = [0, n]. Conclusión: ruleta tiene Bias = 0 y Spread Máximo (malo). Eficiencia: buena, pero se necesitan n randoms. Alternativa a Ruleta: “Stochastic Universal Sampling” (SUS), usa un sólo número al azar, digamos r y toma los puntos: r, r + 1, r + 2, . . . , r + (n − 1). 0,15 ↓ I1

En nuestro caso: r = 0, 15 1,15 2,15 3,15 4,15 5,15 ↓ ↓ ↓ ↓ ↓ I3 I4 I5 I5 I5

Entonces nos queda: 1→1 2→0 3→1 4→1 5→3 6→0

(0, 54) (0, 34) (1, 14) (0, 72) (2, 88) (0, 42)

Bias = 0. Pero Spread(i) = {bEi c, dEi e}. Y un factor extra que tengo que elegir a quién reproduzco con quién. 106

7.5.7.

Remainde Methods (Métodos del “Resto”)

El individuo, se selecciona determinísticamente. Se toma bEi c veces. n P Los n − bEi c posibles se llenan con algún otro método. i=1

Por ejemplo se usan los restos: Ri = Ei − bEi c y se distribuyan usando Ruleta o SUS. Ejemplo: bE1 c = b0, 54c = 0 bE2 c = b0, 30c = 0 bE3 c = b1, 14c = 1 bE4 c = b0, 72c = 0 bE5 c = b2, 88c = 2 bE6 c = b0, 42c = 0

→ R1 → R2 → R3 → R4 → R5 → R6

= 0, 54 = 0, 30 = 0, 14 = 0, 72 = 0, 88 = 0, 42

Entonces me quedan 3 slots, por ejemplo uso ruleta para asignarlos. Elijo 3 números al azar: r = 0, 15|0, 7|0, 22. Multiplico por n = 3 0, 45 2, 1 0, 6 ↓ ↓ ↓ I1 I5 I2 Orden 0,54 0,54 0,30 0,84 0,14 0,98 0,72 1,7 0,88 2,58 3 0,42  1→1     2→1    3→1 El asignamiento final nos queda: y luego apareo al azar. 4→0     5→3    6→0 7.5.8.

Otros métodos Fitness Proportional

Los métodos que hemos visto con BIAS = 0 o casi pueden producir que al principio cuando hay gran disparidad de Fitness, un grupo de individuos con alta fitness relativa, cope la población. Impidiendo una búsqueda exhaustiva, de todo el espacio de búsqueda, por otro lado, luego de que se estabilice la población es difícil para un individuo con mayor Fitness influenciar la búsqueda produciendo un estancamiento. Por esto se han propuesto alternativas. 107

7.5.9.

Sigma Scaling

ci En este método se calculan las Ei en forma distinta E −F σ= 6 0 1 + Fi2σ c Se define Ei = : σ = desvío estándar de los Fi . 1 σ=0 Ventaja: al principio, σ suele se grande, entonces se evita “Crownding”, al final σ ≈ 0. Entonces el mejor individuo se va a reproducir mucho más. Ejemplo: con las Fitness de antes obtengo σ = 30, 627 ci Y voy calculando los E c1 = 1 + 17, 118 − 31, 7 = 0, 762 Primero: E 2σ i P

ci E

Ej

j=1

c1 E c2 E c3 E c4 E c5 E c6 E

= 0, 762 = 0, 638 = 1, 072 = 0, 855 = 1, 973 = 0, 700

0, 762 1, 400 2, 472 3, 327 5, 3 6

Aplico Ruleta Elijo n = 6, números al azar 0, 15 0, 7 0, 22 0, 91 0, 46 0, 63 Multiplico por n = 6 0, 90 4, 2 1, 32 5, 46 2, 76 3, 78 I2 I5 I2 I6 I4 I5 Obtengo algo más balanceado. Si hubiera aplicado SUS: con r = 0, 15 0, 15 1, 15 2, 15 3, 15 4, 15 5, 15 I1 I2 I3 I4 I5 I5 Roletamiento Fi

bi = E

eT P rj eT

: T temperatura, inicialmente alta y luego se enfría

Otros métodos no usan Fitness Proporcion Por ejemplo: métodos de Rango, se usan las Fi para ordenar los individuos y luego se elije por algún método. Basándonos sólo en la posición en ese ordenamiento. Otras Selecciones: no tan basadas en Fitness. 108

Métodos de rango: se usa la Fitness para ordenar la población y luego se usa una medida que dependa sólo de la posición en esa población. Lineal Ranking: LR(pos) = (2 − SP ) + 2(SP − 1) pos−1 n−1 SP parámetro en [1, 2] SP es por “Selective Pressure” Estas tomarían el lugar de los Ei i.e. sería: Ei = LR(P os(i)) Por ejemplo SP = 1 ⇒ LR(pos) = 1∀pos, no hay presión. SP = 2 ⇒ LR(pos) = 2 pos−1 n−1 SP ∈ (1; 2), por ejemplo SP = 1, 2 pos − 1 LR(pos) = 0, 8 + 0, 4 n−1 SP no tiene que ser fijo, podría ir aumentando para aumentar la presión. Ejemplo: con las Fitness del ejemplo anterior F2 ↓ 1

< F6 ↓ 2

< F1 ↓ 3

< F4 ↓ 4

< F3 ↓ 5

< F5 ↓ 6

Tomando SP = 1, 2: E1 E2 E3 E4 E5 E6

= LR(3) = 0, 96 : 3 es la posición = LR(1) = 0, 8 = LR(5) = 1, 12 = LR(4) = 1, 04 = LR(6) = 1, 2 = LR(2) = 0, 8 + 0,4 = 0, 88 5

Selección “Torneo” Seleccionar k (usualmente 2) individuos y quedarse con el “mejor”, en un torneo determinísticamente o probabilísticamente. 7.5.10.

Crossover

SinglePoint TwoPointCroospoint Máscara Binaria Supongo que tengo esta máscara, generada al azar: 1,0,0,1,1,0,1,0,1,1. P1 = 2 P2 = 4

9 2

7 3

2 6

5 6 109

3 3

1 9

6 8

5 0

8 9

Obtengo: O1 = 2, 2, 3, 2, 5, 3, 1, 8, 5, 8 O2 = 4, 9, 7, 6, 6, 3, 9, 6, 0, 9 Partial Map Crossover ¿Qué pasa con codificación del problema que depende de la posición? P1 = BIGAECJF DH P2 = DJBF ECIGAH Corta en dos lugares: O1 = BIG|JECA|F DH O2 = DJB|F IEC|GAH También se puede hacer con máscaras. “Order Based” Cyclic Crossover VERRRRRRRRRRRRRRRR 7.5.11.

Mutación

Strings de bits: cambiar cada bit con probabilidad p ≈ 0. Strings de enteros o reales: también se puede hacer algo así, pero en el caso en que haya “fronteras” se hace otra cosa. Por ejemplo supongamos que la frontera es: |Ii | ≤ 10 es ∀i I = 0, 5|7, 8|5 Ie = 0, 5|10|5 5 O bien: Ie = 0, 5 10+7,8 2 7.5.12.

Mutaciones con Permutaciones

Mutación para codificaciones basadas en posiciones TSP. Permutar dos elementos al azar. Elegir uno al azar y cambiarlo con un vecino “Inversion Mutation”, elijo dos puntos al azar y cambio todos los lugares entre si: GRAFICO Algunas otras arquitecturas 1. Elitismo (los mejores miembros permanecen). Graf 2. A veces la mutación no se aplica solo a los offsprings. 110

3. Steady State 4. Migraciones Inundación: mato a los peores cada tanto, se usa mucho con restricciones muy cortas, cada tanto tengo una subpoblación no válida pero la penalizo, pero es muy buena, luego la mato.

7.6.

No Free Lunch

Todos los algoritmos que optimizan37 en funciones se comportan, promediando sobre todos las funciones posibles, igual.

Referencias [1] Biggs: “Matematica Discreta” [2] Roberts, “Applied Combinatorics” [3] Tarjan: “Data Structures and Network Flows” [4] BFS: http://en.wikipedia.org/wiki/Breadth-first_search [5] DFS: http://en.wikipedia.org/wiki/Depth-first_search [6] Árboles en Latex: http://www.essex.ac.uk/linguistics/external/clmt/latex4ling/trees/ pstrees/ [7] Código C en latex: http://stackoverflow.com/questions/586572/make-code-in-latex-look-nice

37

Por ejemplo calcular máximo

111

Discreta2 Resumen General

Recommend Documents