title: Algoritmo de pivote
text: # Algoritmo de pivote
  
  Los algoritmos de pivote (o algoritmos de cambio de base) son algoritmos de la optimización matemática, y en especial de la Programación Lineal. Dado un sistema de ecuaciones lineales cuyas variables deben adoptar valores no negativos (esencialmente lo mismo que un sistema de inecuaciones lineales), se busca la mejor de entre muchas soluciones alternativas, es decir, una solución óptima del sistema. En cada paso de tal búsqueda, el algoritmo transforma el sistema sin alterar su conjunto de soluciones. Algoritmos de pivote importantes son los diversos algoritmos simplex y los algoritmos criss-cross.
  Los algoritmos de pivote son de gran importancia para el tratamiento de inecuaciones lineales, donde juegan un papel análogo al de la eliminación de Gauss para ecuaciones lineales. Se encuentran numerosas aplicaciones de sistemas de inecuaciones en áreas tan diversas como la investigación de operaciones industriales, el transporte y distribución de bienes, en carteras de valores, la ingeniería estructural, la estadística, y la teoría de juegos. Frecuentemente se abordan sistemas con decenas de miles de variables.
  
  # Algoritmo de pivote
  ## Procedimiento general
  ### El problema normalizado
  
  Todo algoritmo de pivote parte de un sistema especialmente arreglado de ecuaciones lineales, cuyas variables todas, excepto tal vez una, deben tomar valores no negativos. De hecho, cualquier sistema de inecuaciones o ecuaciones lineales, así como todo problema de Programación Lineal, puede siempre reducirse a la siguiente forma diccionario:
      ${\begin{matrix}z&=&f&+&d_{1}\,x_{1}&+&\cdots &+&d_{n}\,x_{n}\\[3pt]x_{n+1}&=&b_{n+1}&+&G_{n+1,1}\,x_{1}&+&\cdots &+&G_{n+1,n}\,x_{n}\\\vdots &&\vdots &&\vdots &&&&\vdots \\x_{n+m}&=&b_{n+m}&+&G_{n+m,1}\,x_{1}&+&\cdots &+&G_{n+m,n}\,x_{n}\end{matrix}}$ ${\begin{matrix}\max ~z,\quad x_{1}\geq 0,\ \ldots \ x_{n+m}\geq 0,\end{matrix}}$
  donde los $f,\;d_{j},\;b_{i},\;G_{i,j}$ son números reales (en la práctica casi siempre números racionales). Este formato especifica que se busca valores para las incógnitas $\,x_{1},\ldots x_{n+m},\ z\,$, que satisfagan las ecuaciones e inecuaciones del sistema anterior de modo tal que la variable objetivo $\,z$ tome el mayor valor posible.
         ( Al convertir un problema a la forma anterior no disminuye el número de desigualdades; estas permanecen en su totalidad y sólo se convierten en condiciones de no-negatividad de algunas variables. De este modo, una inecuación como por ejemplo
            $3x_{1}~+~4x_{2}~-~x_{3}~\leq ~5x_{1}~+~8$
         es sustituida por
            $x_{4}~=~8~+~2x_{1}~-~4x_{2}~+~x_{3},\quad x_{4}\geq 0$ )
  Definiendo los conjuntos de índices
      $D=\{1,\ldots ,n\},\quad B=\{n+1,\ldots ,n+m\}$
  se escribirá esto en lo que sigue de la forma más compacta
      ${\begin{matrix}&&z&=&f&+&\sum _{j\in D}\,d_{j}\,x_{j}\\[6pt]\forall ~i\in B&&x_{i}&=&b_{i}&+&\sum _{j\in D}\,G_{i,j}\,x_{j}\end{matrix}}$ ${\begin{matrix}\max ~z\,,\quad \forall ~k\in D\cup B\quad x_{k}\geq 0\end{matrix}}$
  En cada iteración de un algoritmo de pivote se destaca un conjunto de variables independientes, mientras que las restantes son variables dependientes y se expresan como funciones lineales de las primeras. Al pasar de una iteración a la siguiente se intercambia una variable independiente por una dependiente; tales pares de variables se denominan pivotes.
  
  # Algoritmo de pivote
  ## Procedimiento general
  ### Condiciones de optimalidad
  
  En caso de que se cumplan las siguientes dos condiciones de optimalidad,
     * $b_{i}\geq 0$ para todo $i\in B$ (sistema factible) y
     * $d_{j}\leq 0$ para todo $j\in D$ (sistema acotado),
  podemos obtener una solución al problema anterior, asignando a las variables independientes del sistema los valores $\,x_{1}=0,\ldots ,x_{n}=0\,$. Por un lado, esto logra que las variables dependientes $\,x_{n+1}=b_{n+1},\ldots ,x_{n+m}=b_{n+m}\,$ adopten valores nonegativos, tal como se pedía. Por otro lado, toda solución alternativa al problema debe satisfacer la relación $\,z\leq f\,$, ya que en ella las variables independientes también deben tomar valores nonegativos.
         ( Por ejemplo, en el siguiente sistema,
            ${\begin{matrix}z&=&~~~0&-~3x_{1}&+~~\mathbf {x_{2}} \\[2pt]x_{3}&=&~~~3&-~~x_{1}&-~~x_{2}\\[2pt]x_{4}&=&~~~8&+~2x_{1}&-~4x_{2}\\[2pt]x_{5}&=&-~\mathbf {1} &+~3x_{1}&+~~x_{2}\end{matrix}}$
         las condiciones de optimalidad son violadas en dos lugares, ya que $b_{5}=-1<0$ y $d_{2}=+1>0$. Por un lado, los valores obtenidos al anular las variables independientes, $x_{1}=x_{2}=0$, no constituyen una solución admisible porque contienen un valor negativo, $x_{5}=-1$. Por otro lado, no podemos descartar la posibilidad de aumentar el valor que adopta la variable objetivo $\;z=-3x_{1}+x_{2}\;$ eligiendo conjuntos de variables independientes con $x_{2}>0$. )
  
  # Algoritmo de pivote
  ## Procedimiento general
  ### Transformación de las ecuaciones
  
  En el caso habitual de que las condiciones de optimalidad no se cumplan, puede reformularse el sistema de ecuaciones, eligiendo adecuadamente un nuevo subconjunto $\,B\,$ de entre las $\,n+m\,$ incógnitas, y expresando las incógnitas elegidas en función de las incógnitas restantes. Sea $\omega$ un reordenamiento de las variables, es decir una función de los índices que cumpla
      $\{x_{\omega (1)},\ldots x_{\omega (n+m)}\}=\{x_{1},\ldots x_{n+m}\}.$
  A partir de la partición $\pi ={\biglD(\pi ),~B(\pi ){\bigr )}$, con
      $D(\pi )=\{\omega (1),\ldots ,\omega (n)\},\quad B(\pi )=\{\omega (n+1),\ldots ,\omega (n+m)\},$
  que divide las variables del sistema en variables independientes $x_{j}$ con $j\in D(\pi )$ y las llamadas variables básicas $x_{i}$ con $i\in B(\pi )$, se construye entonces el sistema:
      ${\begin{matrix}&&z&=&f^{\pi }&+&\sum _{j\in D(\pi )}\,d_{j}^{\pi }\,x_{j}\\[6pt]\forall ~i\in B(\pi )&&x_{i}&=&b_{i}^{\pi }&+&\sum _{j\in D(\pi )}\,G_{i,j}^{\pi }\,x_{j}\end{matrix}}$ ${\begin{matrix}\max ~z\,,\quad \forall ~k\in D\cup B\quad x_{k}\geq 0\end{matrix}}$
  Nótese que los coeficientes $G_{i,j}^{\pi }$ existen solo para pares de subíndices con $i\in B(\pi )$ y con $j\in D(\pi )$. En cada iteración, los coeficientes del sistema así modificado vuelven a examinarse para ver si satisfacen las condiciones de optimalidad
     * $b_{i}^{\pi }\geq 0$ para todo $i\in B(\pi )$ (sistema factible) y
     * $d_{j}^{\pi }\leq 0$ para todo $j\in D(\pi )$ (sistema acotado),
  y de este modo generan una posible solución al problema. Un resultado estándar de la Programación Lineal establece que todo problema que tiene soluciones también posee un conjunto de variables básicas que conduce a una de ellas. Si los coeficientes del sistema satisfacen las condiciones de optimalidad, se dice que las variables básicas forman una base optimal del problema.
  
  # Algoritmo de pivote
  ## Procedimiento general
  ### Pivotes admisibles
  
  Un coeficiente no nulo $\,G_{k,l}^{\pi }\neq 0\,$ del sistema de ecuaciones se llama elemento pivote, porque permite despejar la variable independiente $\,x_{l}\,$ en lugar de la variable básica $\,x_{k}\,,$ para así seguir buscando una solución al problema. Sin embargo, los algoritmos de pivote no eligen un elemento pivote cualquiera, sino solamente los llamados pivotes admisibles $(x_{k},\,x_{l})$, que deben satisfacer:
     * O se cumple simultáneamente $\,b_{k}^{\pi }<0\,$ y $\,G_{k,l}^{\pi }>0\,$ (pivote de restricción),
     * o se cumple simultáneamente $\,d_{l}^{\pi }>0\,$ y $\,G_{k,l}^{\pi }<0\,$ (pivote de objetivo).
         ( En el ejemplo anterior,
            ${\begin{matrix}z&=&~~~0&-~3x_{1}&+~~~\mathbf {x_{2}} \\[2pt]x_{3}&=&~~~3&-~~x_{1}&-~~~{\underline {\mathbf {x_{2}} }}\\[2pt]x_{4}&=&~~~8&+~2x_{1}&-~{\underline {\mathbf {4x_{2}} }}\\[2pt]x_{5}&=&-~\mathbf {1} &+~{\underline {\mathbf {3x_{1}} }}&+~~~{\underline {\mathbf {x_{2}} }}\end{matrix}}$
         el coeficiente no optimal $b_{5}<0$ permite seleccionar el elemento pivote $G_{5,1}=+3>0,$ correspondiente a un pivote admisible con intercambio de $(x_{5},\,x_{1}),$ ó también el elemento pivote $G_{5,2}=+1>0$ correspondiente al pivote admisible $(x_{5},\,x_{2}).$ Alternativamente, el coeficiente no optimal $d_{2}>0$ permite también seleccionar el elemento pivote $G_{3,2}=-1<0$ correspondiente al pivote admisible $(x_{2},\,x_{3}),$ ó el elemento pivote $G_{4,2}=-4<0$ con el pivote admisible $(x_{2},\,x_{4})$. )
  La restricción a pivotes admisibles impide que en dos iteraciones sucesivas se elija el mismo pivote. Las reglas según las cuales el pivote es elegido dependen del algoritmo de pivote particular. No obstante, debe imponerse que el algoritmo termine en un número finito de pasos, lo que no sucede con una elección de pivotes inadecuada. Fukuda & Terlaky demostraron en 1999 que para todo problema con solución y para toda base inicial existe una secuencia de a lo más $\,n+m\,$ pivotes admisibles que conduce a una base optimal. Lamentablemente, esa demostración no es constructiva en el sentido de que indique cuál pivote deba elegirse en cada paso.
  Como se puede observar de las definiciones anteriores, una base optimal no tiene pivotes admisibles, por lo que el algoritmo no puede ser continuado a partir de una base optimal. Por otro lado, es fácil demostrar con argumentos similares a los expuestos que una base no optimal sin pivotes admisibles siempre pertenece a un problema sin solución; sea esto, porque el sistema de ecuaciones e inecuaciones no tiene solución alguna (problema infactible), o porque existen soluciones con un valor objetivo $z\,$ arbitrariamente grande (problema no acotado).
  
  # Algoritmo de pivote
  ## Procedimiento general
  ### Implementación sin errores de redondeo
  
  Para evitar errores de redondeo se trabaja en lo que sigue con números racionales, eligiendo un único denominador común para todo el sistema de ecuaciones. Para encontrar un denominador así en cada paso del algoritmo no hace falta analizar los coeficientes del sistema; en caso de un sistema inicial con coeficientes enteros, en cada iteración se cumplirá que
     * El numerador del elemento pivote es un denominador común para el sistema de ecuaciones siguiente.
  Al evaluar los coeficientes de un nuevo sistema el denominador común del sistema anterior quedará obsoleto, por lo que se procede a dividir los coeficientes del sistema nuevo por el denominador antiguo, con resultados que siempre serán enteros.
  Un arreglo matricial que contiene los coeficientes de un sistema de pivote suele llamarse tabla de pivoteo o cuadro de pivoteo. El siguiente esquema muestra cómo cambian los coeficientes del sistema de pivoteo al pasar de una iteración a la que sigue:
  | ${\begin{matrix}\delta \,x_{i}&\!=\!&(~~\alpha )&\!\!\!x_{j}&\!+\!&(~~\sigma )&\!\!\!x_{s}\\[6pt]\delta \,x_{r}&\!=\!&(~~\zeta )&\!\!\!x_{j}&\!+\!&(~~p)&\!\!\!x_{s}\end{matrix}}$ | ${x_{r}\leftrightarrow x_{s}}$ | ${\begin{matrix}p\,x_{i}&\!=\!&(\textstyle {\frac {\alpha p\,-\,\zeta \sigma }{\delta }})&\!\!\!x_{j}&\!+\!\!&(~\sigma )&\!\!\!x_{r}\\[6pt]p\,x_{s}&\!=\!&(~-\zeta ~)&\!\!\!x_{j}&\!+\!\!&(~\delta )&\!\!\!x_{r}\\\end{matrix}}$ |
  En ese esquema, el símbolo $\delta$ designa al denominador común del sistema de ecuaciones, el símbolo $p$ designa al numerador del elemento pivote, $\zeta$ designa cualquier coeficiente restante en la misma fila del elemento pivote, $\sigma$ designa cualquier coeficiente restante en la misma columna del elemento pivote, y $\alpha$ cualquier coeficiente ajeno a la fila y a la columna del pivote. Los coeficientes $d_{j}^{\pi }$ de la variable a maximizar ($x_{i}\!=\!z\,$) y los coeficientes $b_{i}^{\pi }$ de la columna de valores ($x_{j}\!=\!1\,$) se transforman de acuerdo a las mismas reglas.
  
  # Algoritmo de pivote
  ## Ejemplo ilustrado
  ### Representación gráfica
  
  Las ilustraciones en cada paso del ejemplo siguiente muestran todas el mismo sistema de ecuaciones graficado en distintos sistemas de coordenadas. En estos gráficos,
     * el área bordeada de verde es el conjunto de soluciones factibles, para el cual todas las variables toman valores no negativos,
     * los ejes de coordenadas corresponden a ecuaciones $x_{k}=0$ de variables independientes, las demás rectas a ecuaciones de variables básicas,
     * la recta en rojo recorre los puntos donde la variable objetivo adopta su valor máximo,
     * las intersecciones de rectas correspondientes a pivotes admisibles llevan puntos rojos, el pivote seleccionado va bordeado de negro, y
     * el área anaranjada corresponde al ortante no negativo de la iteración siguiente.
  
  # Algoritmo de pivote
  ## Ejemplo ilustrado
  ### Ejemplo de elección de pivotes
  
  La siguiente estrategia de elección de pivote corresponde al algoritmo criss-cross con pivoteo en los índices mínimos (minimal index criss-cross-algorithm). En cada paso, el pivote admisible se elegirá de acuerdo a la siguiente regla (el mínimo de un conjunto vacío se considera igual a infinito):
  * Determinar los índices $r=\min\{i\in B(\pi )~|~b_{i}^{\pi }<0\}$ y $s=\min\{j\in D(\pi )~|~d_{j}^{\pi }>0\}$.
  * Si se tiene $r<s\,$, elegir el pivote $(x_{r},\,x_{l})$ donde $l=\min\{j\in D(\pi )~|~G_{r,j}^{\pi }>0\}$.
  * Si se tiene $s<r\,$, elegir el pivote $(x_{k},\,x_{s})$ donde $k=\min\{i\in B(\pi )~|~G_{i,s}^{\pi }<0\}$.
  Se puede demostrar que este criterio simple (aunque no siempre eficiente) conduce siempre a una base optimal en un sistema que tenga solución.
  En el siguiente ejemplo se busca valores no negativos para las variables $\,x_{1}\geq 0,\ldots \ x_{5}\geq 0\,$ que maximicen la variable adicional $z\,$ satisfaciendo el siguiente conjunto de ecuaciones lineales:
      ${\begin{matrix}z&=&(&~~~~0&+~\mathbf {3x_{1}} &+~2x_{2}&)~/~1\\[2pt]x_{3}&=&(&~~~3&-~{\underline {\mathbf {2x_{1}} }}&-~~x_{2}&)~/~1\\[2pt]x_{4}&=&(&~~~7&-~2x_{1}&-~3x_{2}&)~/~1\\[2pt]x_{5}&=&(&~~~4&-~3x_{1}&-~~x_{2}&)~/~1\end{matrix}}$
  En el sistema inicial del ejemplo, los coeficientes no optimales son $\,d_{1}=3\,$, $\,d_{2}=2\,$, y todos los pivotes son admisibles. El criterio de selección, sin embargo, prescribe que despejemos $\,x_{1}\,$ en lugar de $\,x_{3}\;$:
  (para animar con Firefox, pulsar aquí y luego en la imagen, manteniendo presionado)
  Con ello obtenemos:
      ${\begin{matrix}z&=&(&~~~9&-~3x_{3}&+~~\mathbf {x_{2}} &)~/~2\\[2pt]x_{1}&=&(&~~~3&-~~x_{3}&-~~{\underline {\mathbf {x_{2}} }}&)~/~2\\[2pt]x_{4}&=&(&~~~8&+~2x_{3}&-~4x_{2}&)~/~2\\[2pt]x_{5}&=&(&-~1&+~3x_{3}&+~~x_{2}&)~/~2\end{matrix}}$
  Ahora los coeficientes no optimales son $\,d_{2}^{\pi }=1/2\,$ con los pivotes admisibles $(x_{2},\,x_{1})$, $(x_{2},\,x_{4})$, y el coeficiente $\,b_{5}^{\pi }=-1/2\,$ con los pivotes admisibles $(x_{5},\,x_{2})$, $(x_{5},\,x_{3})$. En consecuencia, despejamos $\,x_{2}\,$ en lugar de $\,x_{1}\;$:
  (animado)
  Se obtiene el sistema
      ${\begin{matrix}z&=&(&~~~6&-~2x_{3}&-~~x_{1}&)~/~1\\[2pt]x_{2}&=&(&~~~3&-~~x_{3}&-~2x_{1}&)~/~1\\[2pt]x_{4}&=&(&-~\mathbf {2} &+~3x_{3}&+~{\underline {\mathbf {4x_{1}} }}&)~/~1\\[2pt]x_{5}&=&(&~~~1&+~~x_{3}&-~~x_{1}&)~/~1\end{matrix}}$
  El único coeficiente no optimal en este sistema es $\,b_{4}^{\pi }=-2\,$ con los pivotes admisibles $(x_{4},\,x_{1})$, $(x_{4},\,x_{3})$; despejamos $\,x_{1}\,$ en lugar de $\,x_{4}\;$:
  (animado)
  El sistema final es
      ${\begin{matrix}z&=&(&~22&-~5x_{3}&-~~x_{4}&)~/~4\\[2pt]x_{2}&=&(&~~~8&+~2x_{3}&-~2x_{4}&)~/~4\\[2pt]x_{1}&=&(&~~~2&-~3x_{3}&+~~x_{4}&)~/~4\\[2pt]x_{5}&=&(&~~~2&+~7x_{3}&-~~x_{4}&)~/~4\end{matrix}}$
  Como este sistema satisface las condiciones de optimalidad, hemos obtenido la solución
      $z=22/4=5.5,$ $x_{1}=2/4=0.5,$ $x_{2}=8/4=2.0,$ $x_{3}=0,$ $x_{4}=0,$ $x_{5}=2/4=0.5$
  
  # Algoritmo de pivote
  ## Dualidad
  ### Problemas duales
  
  A todo problema de programación lineal llevado a la forma básica arriba descrita se le puede asociar un problema dual de programación lineal. Con respecto a esa forma básica, la matriz de coeficientes del problema dual es la matriz negativa traspuesta de la matriz de coeficientes del problema original, lo que muestra de paso que el dual del problema dual es el problema original, llamado problema primal en ese contexto.
      ${\begin{matrix}w&=&-f&-&b_{1}\,y_{n+1}&-&\cdots &-&b_{m}\,y_{n+m}\\[3pt]y_{1}&=&-d_{1}&-&G_{n+1,1}\,y_{n+1}&-&\cdots &-&G_{n+m,1}\,y_{n+m}\\\vdots &&\vdots &&\vdots &&&&\vdots \\y_{n}&=&-d_{n}&-&G_{n+1,n}\,y_{n+1}&-&\cdots &-&G_{n+m,n}\,y_{n+m}\end{matrix}}$ ${\begin{matrix}\max ~w,\quad y_{1}\geq 0,\ \ldots \ y_{m+n}\geq 0\end{matrix}}$
  ó, en notación compacta,
      ${\begin{matrix}&&w&=&(-f)&+&\sum _{i\in B}\,(-b_{i})\,y_{i}\\[6pt]\forall ~j\in D&&y_{j}&=&(-d_{j})&+&\sum _{i\in B}\,(-G_{i,j})\,y_{i}\end{matrix}}$ ${\begin{matrix}\max ~w\,,\quad \forall ~k\in D\cup B\quad y_{k}\geq 0\end{matrix}}$
  Como se muestra a continuación, el máximo obtenido en el problema dual (si es que existe) es igual al negativo del máximo obtenido en el problema primal.
         ( Precaución: Al usar la forma diccionario para escribir el problema dual, no es lícito sustituir $\max ~z,\,\max ~w$ por $\min ~z,\,\min ~w$. A menudo el problema dual se define con una función objetivo $\min \,(-w)$ en lugar de $\max \,w$, lo que es lícito pero un tanto engorroso. )
  
  # Algoritmo de pivote
  ## Dualidad
  ### Transformaciones sucesivas
  
  La relación anterior entre los coeficientes de un par de problemas duales no se cumple solamente para el sistema de partida, sino que persiste paso a paso a través de un algoritmo de pivotes, siempre y cuando el pivote elegido en cada iteración sea el mismo en ambos problemas:
      ${\begin{matrix}&&w&=&(-f^{\pi })&+&\sum _{i\in B(\pi )}\,(-b_{i}^{\pi })\,y_{i}\\[6pt]\forall ~j\in D(\pi )&&y_{j}&=&(-d_{j}^{\pi })&+&\sum _{i\in B(\pi )}\,(-G_{i,j}^{\pi })\,y_{i}\end{matrix}}$ ${\begin{matrix}\max ~w\,,\quad \forall ~k\in D\cup B\quad y_{k}\geq 0\end{matrix}}$
  La relación de dualidad es particularmente fácil de observar en un sistema de pivoteo que tiene solo dos variables independientes y dos variables despejadas. El sistema obtenido es el mismo si se intercambia el estado de dos de las variables y a continuación se construye el problema dual, o si se realiza estas operaciones en orden inverso:
  | ${\begin{matrix}\delta \,x_{i}&\!=\!&(~~\alpha )&\!\!\!x_{j}&\!+\!&(~~\sigma )&\!\!\!x_{s}\\[6pt]\delta \,x_{r}&\!=\!&(~~\zeta )&\!\!\!x_{j}&\!+\!&(~~p)&\!\!\!x_{s}\end{matrix}}$ | ${x_{r}\leftrightarrow x_{s}}$ | ${\begin{matrix}p\,x_{i}&\!=\!&({\frac {\alpha p\,-\,\zeta \sigma }{\delta }})&\!\!\!x_{j}&\!+\!\!&(~\sigma )&\!\!\!x_{r}\\[6pt]p\,x_{s}&\!=\!&(~-\zeta ~)&\!\!\!x_{j}&\!+\!\!&(~\delta )&\!\!\!x_{r}\\\end{matrix}}$ |
  | $-\,[\cdots ]^{\,T}$ | | $-\,[\cdots ]^{\,T}$ |
  | ${\begin{matrix}\delta \,y_{j}&\!=\!&(-\alpha )&\!\!\!y_{i}&\!+\!&(-\zeta )&\!\!\!y_{r}\\[6pt]\delta \,y_{s}&\!=\!&(-\sigma )&\!\!\!y_{i}&\!+\!&(-p)&\!\!\!y_{r}\\\end{matrix}}$ | ${y_{s}\leftrightarrow y_{r}}$ | ${\begin{matrix}p\,y_{j}&\!=\!&({\frac {\zeta \sigma \,-\,\alpha p}{\delta }})&\!\!\!y_{i}&\!+\!\!&(~~\zeta )&\!\!\!y_{s}\\[6pt]p\,y_{r}&\!=\!&(~-\sigma ~)&\!\!\!y_{i}&\!+\!\!&(-\delta )&\!\!\!y_{s}\\\end{matrix}}$ |
  De esta relación de dualidad se concluye que toda base optimal para el problema primal provee también una base optimal para el problema dual. Al ejemplo anteriormente desarrollado le corresponde el problema dual
      ${\begin{matrix}~w~&=&(&~~0&-~~3y_{3}&-~~7y_{4}&-~~4y_{5}&)~/~1\\[2pt]y_{1}&=&(&-3&+~~2y_{3}&+~~2y_{4}&+~~3y_{5}&)~/~1\\[2pt]y_{2}&=&(&-2&+~~~y_{3}&+~~3y_{4}&+~~~y_{5}&)~/~1\end{matrix}}$ ${\begin{matrix}\max ~w,\quad y_{1}\geq 0,\ y_{2}\geq 0,\ y_{3}\geq 0,\ y_{4}\geq 0,\ y_{5}\geq 0\end{matrix}}$
  El sistema optimal de este problema es entonces
      ${\begin{matrix}~w~&=&(&-22&-~~8y_{2}&-~~2y_{1}&-~~2y_{5}&)~/~4\\[2pt]y_{3}&=&(&~~~5&-~~2y_{2}&+~~3y_{1}&-~~7y_{5}&)~/~4\\[2pt]y_{4}&=&(&~~~1&+~~2y_{2}&-~~~y_{1}&+~~~y_{5}&)~/~4\end{matrix}}$
  En el problema original, la variable a maximizarse toma el valor óptimo $z=22/4$; el valor óptimo del problema dual es el negativo de este valor: el mayor valor posible que su variable objetivo puede adoptar es $w=-z=-22/4=-5.5$. Una posible solución óptima para el problema dual es
      $y_{1}=0,$ $y_{2}=0,$ $y_{3}=5/4=1.25,$ $y_{4}=1/4=0.25,$ $y_{5}=0$.
  
  # Algoritmo de pivote
  ## Dualidad
  ### Tratamiento conjunto
  
  Una importante consecuencia teórica de la dualidad es la siguiente: para resolver problemas de optimización lineal no se requiere un algoritmo que maximice (o minimice) una de las variables, basta para ello cualquier algoritmo capaz de resolver sistemas de desigualdades lineales. Esto es así porque las relaciones de dualidad implican que toda base optimal para el problema primal también provee una base optimal para el problema dual, donde el valor óptimo de la variable $w\,$ del problema dual es el negativo del valor óptimo de la variable $z\,$ del problema original. Por tanto, para pares de soluciones óptimas se tiene
      $z+w~=~(\max z)\!+\!(\max w)$ $~=~(\max z)\!+\!(-\max z)~=~0$
  Por otro lado, para pares de soluciones factibles de las cuales al menos una no es óptima se cumple
      $z+w~<~(\max z)\!+\!(\max w)~=~0$
  De ahí podemos concluir que las soluciones óptimas para un par de problemas duales son exactamente las soluciones de los sistemas de igualdades escritos arriba más las siguientes desigualdades,
      $z\,+\,w\,\geq \,0,\qquad \forall ~k\in D\cup B\qquad x_{k}\geq 0,\quad y_{k}\geq 0,$
  lo que se reduce a
      ${\begin{matrix}\forall ~i\in B\quad x_{i}~=~b_{i}~+~\sum _{j\in D}\,G_{i,j}\,x_{j}\\[6pt]\forall ~j\in D\quad y_{j}~=~(-d_{j})~+~\sum _{i\in B}\,(-G_{i,j})\,y_{i}\\[6pt]\sum _{j\in D}\,d_{j}\,x_{j}~~+~~\sum _{i\in B}\,(-b_{i})\,y_{i}~~\geq ~~0\\[6pt]\forall ~k\in D\cup B\qquad x_{k}\geq 0,\quad y_{k}\geq 0\end{matrix}}$
  En el caso de aplicaciones prácticas, sin embargo, esta forma de proceder solo es competitiva si se logra aprovechar adecuadamente la estructura de datos común a los sistemas primal y dual.
  
  # Algoritmo de pivote
  ## Problemas con muchas variables
  
  La implementación computacional de problemas prácticos a menudo dista mucho de ser trivial. Los coeficientes de sistemas con decenas de miles de variables siempre presentan una u otra estructura, la cual debe ser aprovechada para determinar los sistemas de iteraciones subsecuentes de manera relativamente rápida y numéricamente estable (sin mayores errores de redondeo):
  * Los sistemas iniciales de problemas grandes (no los sistemas transformados) contienen una inmensa mayoría de coeficientes iguales a cero (el sistema es disperso), lo que permite ahorrar muchas operaciones aritméticas si se recurre al sistema de partida.
  * Muchos procedimientos se basan en una evaluación retardada, donde se calcula solo aquellos coeficientes de un sistema que sean necesarios para determinar un pivote, y esto solamente en el instante en que se ocupan. Para evitar la evaluación de coeficientes superfluos tales procedimientos emplean permutaciones de las variables en el sistema de partida, factorizaciones de las inversas de matrices básicas, una factorización de la matriz de coeficientes, y otras técnicas más. En todos estos casos suele ser necesario referirse a sistemas de iteraciones previas a la última, por lo que las transformaciones adoptan formas bastante más complejas que la directa.
  * A menudo se encuentran insertas en la estructura del sistema diversas estructuras especiales, por ejemplo de flujos en redes, y para tales estructuras especiales se ha desarrollado implementaciones particularmente eficientes.
  No obstante lo anterior, hay también muchas aplicaciones que dan origen a problemas de tamaño moderado, para los cuales basta una implementación simple como la presentada.
  
  # Algoritmo de pivote
  ## Herramienta interactiva
  
  El applet de pivoteo interactivo de Robert Vanderbei, programado en 1997, permite definir un sistema de ecuaciones lineales de tamaño reducido y realizar en ese sistema pivoteos sobre pares arbitrarios de variables. La herramienta (en inglés) se autodenomina «Simplex Pivot Tool», pero está orientada a algoritmos de pivote totalmente arbitrarios. Para evitar redondeo, los coeficientes del sistema pueden también verse en forma de fracciones, aunque éstas no adoptan un denominador común.
  
  # Algoritmo de pivote
  ## Literatura complementaria
  
  * George Dantzig (1963): Linear Programming and Extensions, Princeton University Press, archivo pdf
  * Vašek Chvátal (1983): Linear Programming, Freeman and Company, New York NY, ISBN 0-7167-1587-2
  * Robert Vanderbei (2007): Linear Programming. Foundations and Extensions, 3a ed., Springer, ISBN 978-0-387-74387-5, archivo pdf