A Simple Rule to find a Basic Feasible Solution

TL;DR

This paper introduces a straightforward algorithm, similar to Bland's rule, for efficiently finding a basic feasible solution in the initial phase of the Simplex Algorithm.

Contribution

It presents a simple, proven rule to identify a basic feasible solution, enhancing the initial step of the Simplex Method.

Findings

The algorithm reliably finds basic feasible solutions.

It simplifies the initial phase of the Simplex Algorithm.

The method is easy to implement and understand.

Abstract

This short note provides and proves an easy algorithm to find a basic feasible solution for the Simplex Algorithm. The method uses a rule similar to Bland's rule for the initial phase of the algorithm.

Equations

$$c^{T}x$$

$$1\le j_1<\dots <j_m\le n$$

$$x_J=(A_J{)}^{-1}b,\text{xj=0 for j∈/J}.$$

$$\sum _{i=1}^m{t}_i$$

$$\tilde{A}=A_J^{-1}A,\tilde{b}=A_J^{-1}b.$$

$$Ax=b⟺\tilde{A}x=A_J^{-1}Ax=A_J^{-1}b=\tilde{b}.$$

$$J_1\to J_2\to \dots \to J_k\to J_1.$$

$$j_{u+1}<\dots <j_m$$

$${\tilde{a}}_{i,1},\dots ,{\tilde{a}}_{i,j_u-1}\ge 0,{\tilde{a}}_{i,j_u}<0,{\tilde{b}}_i<0$$

$${\tilde{a}}_{i,j_u+1}=\dots ={\tilde{a}}_{i,j_m}=0.$$

$$x_j=0\text{for j=J and j>ju}$$

$$x_{j_1},\dots ,x_{j_u-1}\ge 0,x_{j_u}<0$$

$${\tilde{b}}_1,\dots ,{\tilde{b}}_{u-1}\ge 0,{\tilde{b}}_u<0.$$

$$x_j=0\text{for j=J}$$

$$x_{j_1}={\tilde{b}}_1,\dots ,x_{j_u-1}={\tilde{b}}_{u-1}\ge 0,x_{j_u}={\tilde{b}}_u<0.$$

$${\tilde{a}}_{i,j}<0,{\tilde{b}}_i<0$$

Full text

Keywords: Simplex Algorithm, Linear Programming

1 Introduction

We want to solve a linear optimization problem in the so-called standard form.

[TABLE]

Here, $A$ is a $m\times n$ real matrix, $b\in\mathbb{R}^{m}$, $c\in\mathbb{R}^{n}$, $x\in\mathbb{R}^{n}$. We may assume $\text{rank }(A)=m$. A basic solution of the system is an $x\in\mathbb{R}^{n}$ connected to a tupel $J$ of column indices

[TABLE]

such that the matrix $A_{J}$ consisting of the columns in $J$ of $A$ is regular (called a column base), and

[TABLE]

Then clearly $Ax=b$.

Such a basic solution $x$ can be determined easily with the Gauß-algorithm. If the corresponding solution satisfies $x\geq 0$ then $x$ is feasible and the Simplex algorithm can be started to find an optimal feasible solution, or to find that the problem is unbounded.

If $x$ is not feasible the standard method of finding a basic feasible solution is to extend the problem (P) to

[TABLE]

Since equalities can be multiplied by $-1$ we can assume $b\geq 0$ in (P). So (PE) has the basic feasible solution $x=0$ and $t=b$, and the corresponding column base $J$ contains the columns of the $t_{i}$.

Moreover, (P) has a feasible point if and only if (PE) has the minimal value [math]. The columns $J$ of the optimal basic solution of (PE) can be easily used to find a basic feasible solution (P).

This extension is proposed in many books. Examples are the introductions by Dantzig and Tapa [2], Alevras and Padberg [1], Kosmol [3], and of course the Wikipedia articles about the Simplex algorithm.

However, this extension is not at all necessary, and there is a much easier way to find a basic feasible solution using a rule similar to Bland’s rule (see [2]). The purpose of this paper is to propose such a rule for the initial phase, and to prove that the algorithm succeeds after a finite number of steps.

2 The Algorithm

Starting with a basic solution $x$ as above, let us assume that $x\geq 0$ does not hold.

Let us denote the scheme after the Gauß-Algorithm as

[TABLE]

Note $x_{J}=\tilde{b}$. Note that we still assume that $J$ is sorted, so that the unit vectors in $I_{m}$ appear in $\tilde{A}$ in the correct order. By the way, the target function does not matter for the initial phase.

We then proceed as follows.

We determine the minimal $i$, such that $x_{j_{i}}=\tilde{b}_{i}<0$. 2. 2.

In the $i$-th row of $\tilde{A}$ we determine a minimal $j$ such that $\tilde{a}_{i,j}<0$. 3. 3.

We then exchange the column $j_{i}\in J$ for $j$.

Note that the problem cannot have a feasible point if the second step fails since

[TABLE]

In other words, the Gauß-algorithm transforms the system $Ax=b$ to the equivalent system $\tilde{A}x=\tilde{b}$. But $\tilde{A}x=\tilde{b}$ is not possible if the $i$-th row of $\tilde{A}$ is non-negative and $b_{i}<0$, due to the restriction $x\geq 0$.

We continue the three steps until either $x\geq 0$, or we see that there is no feasible solution.

Theorem 1

The Algorithm as described above ends after a finite number of steps, with either a feasible basic solution, or a failure of the second step showing that there is no feasible solution.

Proof:

If the algorithm does not terminate we get a cyclic repetition of column bases

[TABLE]

In these tupels there is a maximal column index $j_{u}$ that is at one point inserted and at another point removed in the cycle. There may be larger columns

[TABLE]

which are in all column bases of the cycle.

Now there is one of the column bases $J_{a}$ in the cycle where the $j_{u}$ is going to be inserted in the next step. This can only happen if

[TABLE]

in some row $i$ for the scheme $\tilde{A}x=\tilde{b}$ corresponding to $J_{a}$. The columns $j_{u+1},\ldots,j_{m}$ of each scheme $\tilde{A}$ in the cycle contain the unit vectors $e_{u+1},\ldots,e_{m}$, and thus

[TABLE]

We deduce that there is no $x\in\mathbb{R}^{n}$ such that

[TABLE]

and

[TABLE]

which solves our system of equations, no matter what values we assign to the variables $x_{j_{u+1}},\ldots,x_{j_{m}}$.

Then there is another basis $J_{b}$ in the cycle where the column $j_{u}$ is going to be removed in the next step. By our rule in step 1, this can only happen if

[TABLE]

where $\tilde{b}$ is the right hand side in our scheme corresponding to $J_{b}$. The corresponding basic solution $x$ now satisfies

[TABLE]

and

[TABLE]

Since the schemes are equivalent this is a contradiction. We conclude that a cycle cannot happen, and thus the algorithm must end.

q.e.d.

It can be shown that we can remove all columns and rows that are never used for a Pivot element $\tilde{a}_{i,j}$ during the scheme, so effectively $j_{u}=m$. However, this additional step requires some additional arguments, and we found the proof above easier to understand.

If the algorithm is computed with the Gauß-Algorithmus without sorting the base columns, we have to follow the following rule: Search for a Pivot $(i,j)$ such that

[TABLE]

in the scheme, and such that it removes a column with minimal column from the base, and adds a column with minimal index. Since the selection of $i$ determines the column that will be removed this must be done first. Then $j$ can simply be chosen as the minimal index that satisfies $a_{i,j}<0$.