Complejidad del método simplex y métodos de puntos interiores

(1)

Complejidad Computacional del M´etodo Simplex

y M´etodos de Puntos Interiores

*

Omar Trejo - 119711

Octubre, 2013

1. Tiempo Exponencial

La idea general del método Simplex para resolver problemas de programa-ción lineal es recorrer las aristas, vértice por vértice, de un pol´ıtopo (región factible) revisando su optimalidad en cada paso. La cantidad máxima de v´ erti-ces dados por el sistema Ax ≤ b (que define el pol´ıtopo del problema), donde A ∈ Rmxn_{, es} n

m, aunque cotidianamente se prueba un número menor que éste. Sin embargo, el hecho de que la cantidad de pruebas necesarias esté relacionada a una expresión combinatoria indica un posible problema con la complejidad computacional del algoritmo.

1.1. Problema Klee-Minty

El ejemplo utilizado cotidianamente para demostrar la complejidad exponen-cial del método Simplex es el problema Klee-Minty. La idea básica es deformar un hipercubo de tal manera que el método deba recorrer todas las aristas antes de llegar al punto óptimo. Inicialmente fue propuesto en 1972 por Klee y Minty con la forma

maximizar

x yn

s.a. yj−1≤ yj ≤ 1 − yj−1, j = 2, . . . , n,

yj ≥ 0, j = 1, . . . , n.

Poco después Chvátal propuso[3] el cambio de variable x1 = y1, xj = (−1/)yj−1+ yj, lo que permite formular el problema como es más

popular-*_{Este documento no contiene un tratado riguroso de los m´}_{etodos. Se crea a manera de}

(2)

Figura 1: Politopos de Klee-Minty de dos y tres dimensiones[4]. mente conocido, maximizar x n X k=1 10n−kxk s.a. 2 j−1 X k=1 10j−kxk+ xj ≤ 100j−1, j = 1, . . . , n, xj≥ 0, j = 1, . . . , n.

Los resultados del problema Klee-Minty, utilizando el algoritmo programado y mostrado en la secci´on C´odigo, son

Dimensiones Iteraciones 3 50 5 47 6 31 8 35 10 45

Esto claramente muestra la complejidad exponencial del m´etodo. Por lo mis-mo, muchos de los esfuerzos comenzaron a enfocarse en m´etodos de puntos interiores, los cuales exhib´ıan caracter´ısticas deseables como complejidad poli-nomial.

2. M´

etodos de Puntos Interiores

Los métodos de puntos interiores han sido foco de atención desde que se mostró que existen problemas de complejidad exponencial para el método Sim-plex, y existe una variedad éstos.1 _{En esta secci´}_{on explicaremos brevemente el}

1_{Un contraste interesante es que el m´}_{etodo Simplex genera su complejidad del n´}_{umero de}

(3)

método elipsoidal y el método primal-dual infalible, y dejaremos de lado los demás por cuestiones de espacio. La tabla[4] presentada continuación resume la información.

A˜no M´etodo Autor Caracter´ıstica

1947 Simplex Dantzig Eficiente en la pr´actica

1979 Elipsoidal Khachiyan Ineficiente en la pr´actica

1990 Primal-Dual Kojima, Mizuno, Yoshise M´etodo Dominante Infactible

2.1. M´

etodo Elipsoidal de Khachiyan

2.1.1. ¿En qu´e consiste?

La idea básica del método elipsoidal se deriva de investigaciones previas, durante los años sesenta y setenta, dentro de lo que era la Unión Soviética. De manera burda, la idea es encerrar la región de interés en una sucesión de elipsoides que decrecen de tamaño cada vez más. La contribución de Khachiyan fue demostrar en sus dos publicaciones -publicadas en 1979 y 1980- que bajo ciertas condiciones el método tiene complejidad polinomial para problemas de programación lineal.

2.1.2. ¿C´omo se construye el punto inicial y la sucesi´on de elipsoi-des?

El método construye una elipsoide inicial que cubre P , el conjunto de fac-tibilidad, completamente. Se toma el centro de ese elipsoide y se identifica si se encuentra dentro de la región factible P . Si se encuentra dentro, el proble-ma es factible, si no se encuentra dentro se puede construir un elipsoide nuevo (en tiempo polinomial), tomando en cuenta la variable que corresponde a la restricción de AT_{x ≤ b que es violada, que cubra completamente la mitad del} elipsoide anterior del lado donde se encuentra P . Procedemos de esta manera hasta que se encuentra un centro dentro de la región factible, o se alcanza el número máximo de iteraciones disponibles (el resultado en este caso ser´ıa que el problema es no factible).

2.1.3. ¿Por qu´e es un m´etodo polinomial?

Bajo dos condiciones, que explicaremos a continuación, Bertismas y Tsitsiklis mostraron[5] que el método elipsoidal resuelve problemas de programación lineal en tiempo O(m4_{log(R/r)). Antes de definir las condiciones debemos definir el} conjunto poliédrico del problema (representación del problema de programación lineal de manera vectorial):

P = {x ∈ Rm: aT_jx ≤ cj, j = 1, . . . , n} su complejidad debido al n´umero de variables en el problema.

(4)

Figura 2: Elipsoides con y sin regi´on factible[8].

Si P 6= ∅ el problema tiene soluci´on. Las dos condiciones para que el algoritmo converja en tiempo polinomial son:

1. ∃ x0∈ Rm

, ∃ r ∈ R, r > 0, t.q. P ⊂ S(x0, R) = {x ∈ Rm: kx − x0k ≤ R}, 2. ∃ r ∈ R, r > 0 conocido t.q. si Y 6= ∅ =⇒ S(x∗, r) ⊂ Y,

donde S(y, r) es una bola con centro en y y radio r. La primer condición implica que P está acotado. La segunda condición implica que si P es no vac´ıo, entonces su interior tampoco es vac´ıo; i.e. existe un sentido de densidad.

Dado que tenemos un sentido de densidad, podemos construir cualquier elip-soide necesaria. La parte computacionalmente más compleja del método es preci-samente la construcción del elipsoide de volumen m´ınimo. Sin embargo, sabemos que este proceso es de complejidad polinomial, por lo que, de manera burda, podemos extender esto al hecho de que el método es de complejidad polinomial. En la teor´ıa se pueden construir (con aritmética exacta) sucesiones infinitas de elipsoides, pero en la práctica (aritmética de precisión finita) se establece una cota al número de iteraciones que si es superada el problema se considera que éste es infactible.

2.1.4. ¿Cuál es la relevancia teórica del método y por qué no es práctica su implementación para programación lineal?

La relevancia teórica del método reside en el hecho de que antes de la publi-cación del mismo no se hab´ıan logrado clasificar los problemas de programación lineal en alguno de los conjuntos de problemas P o N P, i.e. los que se pueden resolver en tiempo polinomial y los que no, respectivamente. Se cre´ıa que es-tos problemas no tienen una complejidad tal que deben ser clasificados en N P, pero nadie hab´ıa conseguido demostrar su pertenencia a P hasta que Kachiyan publicó su método elipsoidal. Además el método sirve para construir algorit-mos para problemas de optimización convexa, que son más generales que los de programación lineal.

(5)

La experiencia computacional muestra que las iteraciones necesarias para resolver problemas de programación lineal usando este método se encuentran muy cercanas al l´ımite teórico superior. Esto significa que prácticamente el al-goritmo no es muy bueno. El método Simplex, aunque tiene una complejidad exponencial, en la práctica la experiencia muestra que son necesarias muchas menos iteraciones que el l´ımite teórico máximo, haciéndolo un candidato para aplicaciones prácticas.

2.2. M´

etodo Primal-Dual Infactible de Kojima, Mizuno &

Yoshie

2.2.1. ¿En qu´e consiste?

El método consiste en tomar un punto nuevo en cada iteración a lo largo de la dirección de Newton, en la dirección de la trayectoria central, como lo hacen otros métodos de puntos interiores. La diferencia es que éste método no requiere que los puntos estén dentro de la región factible. Éste método aplica pasos largos y distintos entre el los problemas primal y dual, y se caracteriza por convergencia global en tiempo polinomial2

2.2.2. ¿Cómo se construye el punto inicial y la sucesión de puntos? Dado que es un método infactible, tenemos que no es necesario construir un punto inicial, i.e. cualquier punto (xi, yi, zi) en el espacio, con xi ≥ 0, zi ≥ 0, convergerá eventualmente a una solución. Es necesario notar que hay casos en programación no-lineal donde ésta solución puede ser no-óptima, pero en el caso de programación lineal, siempre convergerá a una solución óptima.

La sucesi´on de puntos se construye utilizando los problemas primal y dual P : minimizar x c T_x s.a. Ax = b, x ≥ 0 D : maximizar y,z b T_y s.a. ATy + z = c, z ≥ 0 En cada iteraci´on se resuelve el sistema

  A 0 0 0 AT _I Zk 0 Xk     ∆x ∆y ∆z  = −   Axk_{− b} ATyk+ zk− c XkZk− µe  

donde Zk _{y X}k _{son las matrices con la diagonal igual a z}k _{y x}k_, respecti-vamente. Cada una de las restricciones (ecuaciones del sistema lineal) vienen

2_{Para ser rigurosos deber´ıamos definir los conceptos direcci´}_{on de Newton, trayectoria}

cen-tral, pasos largos, problema primal y problema dual. Sin embargo, por cuestiones de espacio no profundizaremos en ellos.

(6)

de la búsqueda de cerar la brecha en la restricción de factibilidad de P , la res-tricción de factibilidad de D y la restricción de la brecha entre los problemas, XkZk= µe, respectivamente. Posteriormente se actualizan las variables

(xk+1, yk+1, zk+1) = (xk, yk, zk) + α(∆x, ∆y, ∆z)

Los detalles técnicos, por ejemplo como escoger α en cada iteración, la ob-tención de la factibilidad, la convergencia global o la identificación de la no-factibilidad, no serán explicados en este documento. Sin embargo, esto no sig-nifica que carezcan de gran importancia.

2.2.3. ¿Por qu´e es un m´etodo polinomial?

Aunque el cálculo de cada iteración es significativamente más alto que el método Simplex, cada iteración conlleva progreso mucho más significativo hacia el óptimo, suponiendo que existe. Además es un camino mucho más directo (si-gue el llamado central path). La complejidad del algoritmo radica en la solución de un sistema de ecuaciones lineales que, aunque puede ser complicado, sabe-mos que podesabe-mos hacer en tiempo polinomial, por lo que el algoritmo también muestra tiempo polinomial3_.

2.2.4. ¿Cuál es la relevancia del método y por qué es práctica su implementación para programación lineal?

El método se encuentra dentro de los más populares hoy en d´ıa y exhibe los mejores resultados prácticos. En promedio le toma entre 23 y 25 iteraciones resolver los problemas más complejos (con solución) que existen hoy en d´ıa en programación lineal. Además, teóricamente es importante el método porque no se restringe a comenzar con puntos dentro de la región factible, lo que puede presentar un problema en s´ı mismo.

3. C´

odigo - M´

etodo Simplex Revisado

El código aqu´ı presentado es una pequeña variación del método Simplex que utiliza un tableu más pequeño porque no guarda espacio para las columnas B de A = [N |B] que contienen la identidad en cada iteración. En realidad no es necesario almacenar ésta identidad. La utilización de este método es para mejorar el desempeño en el RAM de la computadora4_.

/*

* Programacion Lineal - Metodo Simplex Revisado * Omar Trejo Navarro

* 119711 *

3_{Claramente esta es una implicaci´}_{on burda y es necesario sustentarla de manera rigurosa,}

pero dicha prueba no ser´a presentada en este texto.

(7)

* r := y = maximizar, n = minimizar

* nv := numero de variables de funcion objetivo * nr := numero de restricciones

* t := tableu

* tipo := 1 = maximizar, -1 = minimizar * ai := auxiliar para inputs

* optimo := true = alcanzado, false = no alcanzado * xmax := maximo de coeficientes de funcion objetivo * bamin := mininmo de b_i/a_ij

* aux := variable auxiliar

* rp := indice del renglon pivote * cp := indice de la columna pivote * error := true = no acotado, false = acotado * CMAX := maxima cantidad de restricciones * VMAX := maxima cantidad de variables * */ #include <stdio.h> #include <math.h> #define CMAX 10 #define VMAX 10 int nr, nv, rp, cp;

bool optimo, error;

double t[CMAX][VMAX];

void datos() {

/*

* Obtener los datos del problema */

char r;

int i, j;

double tipo, ai;

printf("\n Programacion Lineal - Metodo Simplex Revisado\n");

do { printf("\n Maximizar [s/n] ? "); scanf(" %c", &r); if (r == 'S' || r == 's') tipo = 1; else if (r == 'N' || r == 'n') tipo = -1; else

printf("\n [!] Error. Debe indicar si (s) o no (n).\n\n" )←-;

} while (r != 'S' && r != 's' && r != 'N' && r != 'n'); printf(" Cantidad de variables ? "); scanf(" %d", &nv); printf(" Cantidad de restricciones ? "); scanf(" %d", &nr);

// Funcion objetivo

printf("\n Funcion objetivo:\n");

for (j = 1; j <= nv; j++) {

printf(" Coeficiente de la variable %d ? ", j); scanf(" %lf", &ai);

t[1][j + 1] = ai * tipo; }

(8)

scanf(" %lf", &ai); t[1][1] = ai * tipo;

// Restricciones

for (i = 1; i <= nr; i++) {

printf("\n Restriccion %d:\n", i);

for (j = 1; j <= nv; j++) {

printf(" Coeficiente de la variable %d ? ", j); scanf(" %lf", &ai);

t[i + 1][j + 1] = -ai; }

printf(" Constante de restriccion ? "); scanf(" %lf", &t[i + 1][1]);

}

// Indices de las variables

for (j = 1; j <= nv; j++) t[0][j + 1] = j; for (i = nv + 1; i <= nv + nr; i++) t[i - nv + 1][0] = i; } void pivotear() { /*

* Hacer el cambio de pivotear */

double bamin, aux, xmax;

int i, j; xmax = 0;

// maximo {costos reducidos}

for (j = 2; j <= nv + 1; j++) { if (t[1][j] > 0 && t[1][j] > xmax) { xmax = t[1][j]; cp = j; } } bamin = 1000000; // minimo {b_i/a_ij} for (i = 2; i <= nr + 1; i++) { if (t[i][cp] < 0) {

aux = fabs(t[i][1] / t[i][cp]);

if (aux < bamin) { bamin = aux; rp = i; } } } // Cambio de indices aux = t[0][cp]; t[0][cp] = t[rp][0]; t[rp][0] = aux; } void actualizar() { /* * Actualizar el tableu */ int i, j; for (i = 1; i <= nr + 1; i++)

(9)

if (i != rp) for (j = 1; j <= nv + 1; j++) if (j != cp) t[i][j] -= t[rp][j] * t[i][cp] / t[rp][cp]; t[rp][cp] = 1.0 / t[rp][cp]; for (j = 1; j <= nv + 1; j++) if (j != cp) t[rp][j] *= fabs(t[rp][cp]); for (i = 1; i <= nr + 1; i++) if (i != rp) t[i][cp] *= t[rp][cp]; } void revisar() { /*

* Revisar optimalidad del tableu */ int i, j; optimo = true; error = false; // Revisar si es no-acotado for (i = 2; i <= nr + 1; i++) if (t[i][1] < 0)

// TODO: Avisar que es no acotado

error = true;

// Revisar si es optimo

if (error == false)

for (j = 2; j <= nv + 1; j++)

// TODO: Revisar si hay solucion multiple

if (t[1][j] > 0) optimo = false; }

void simplex() {

/*

* Metodo Simplex Revisado */

while (optimo == false) { pivotear(); actualizar(); revisar(); } } void resultados() { /*

* Presentar los resultados */ int i, j; printf("\n Resultados:\n"); if (error == false) { for (i = 1; i <= nv; i++) for (j = 2; j <= nr + 1; j++) if (t[j][0] == 1 * i) printf(" Variable %d: %f\n", i, t[j][1]); printf(" Funcion objetivo: %f\n\n", t[1][1]);

(10)

printf(" No hay solucion.\n\n"); } int main() { datos(); simplex(); resultados(); }

Referencias

[1] Stephen J. Wright, Primal-Dual Interior Point Methods, Argonne National Laboratory, SIAM, 1997.

[2] Mokhtar S. Bazaraa, John J. Jarvis, Hanif D. Sherali, Linear Programming and Network Flows, Wiley, 2010.

[3] Steven R. Dunbar, Worst Case and Average Case Behavior of the Simplex Algorithm, University of Nebraska-Lincoln, Department of Mathematics. [4] A. Deza, E. Nematollahi & T. Terlaky, How good are interior point methods?,

McMaster University, Advanced Optimization Laboratory, 2005.

[5] Yinyu Ye, The Ellipsoid (Kachiyan) Method, Department of Management Science and Engineering, Stanford University.

[6] Robert G. Bland, Donald Goldfarb & Michael J. Todd The Ellipsoid Method: A Survey, Cornell University, Ithaca, New York, 1981.

[7] Masakazu Kojima, Nimrod Megiddo & Shinji Mizuno A primal-dual infeasi-ble interior point algorithm for linear programming, Mathematical Program-ming, North-Holland, 1992.

[8] Steffen Rebennack Ellipsoid Method, Encyclopedia of Optimization, Sprin-ger, 2008.