# Interactive Simplex Method¶

The purpose of this module is to support learning and exploring of the simplex method. While it does allow solving Linear Programming Problems (LPPs) in a number of ways, it may require explicit (and correct!) description of steps and is likely to be much slower than “regular” LP solvers. Therefore, do not use this module if all you want is the result. If, however, you want to learn how the simplex method works and see what happens in different situations using different strategies, but don’t want to deal with tedious arithmetic, this module is for you!

Historically it was created to complement the Math 373 course on Mathematical Programming and Optimization at the University of Alberta, Edmonton, Canada.

AUTHORS:

• Andrey Novoseltsev (2013-03-16): initial version.

EXAMPLES:

Most of the module functionality is demonstrated on the following problem.

Corn & Barley

A farmer has 1000 acres available to grow corn and barley. Corn has a net profit of 10 dollars per acre while barley has a net profit of 5 dollars per acre. The farmer has 1500 kg of fertilizer available with 3 kg per acre needed for corn and 1 kg per acre needed for barley. The farmer wants to maximize profit. (Sometimes we also add one more constraint to make the initial dictionary infeasible: the farmer has to use at least 40% of the available land.)

Using variables $$C$$ and $$B$$ for land used to grow corn and barley respectively, in acres, we can construct the following LP problem:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P
LP problem (use typeset mode to see details)


It is recommended to copy-paste such examples into your own worksheet, so that you can run these commands with typeset mode on and get

$\begin{split}\begin{array}{l} \begin{array}{lcrcrcl} \max \!\!\!&\!\!\! \!\!\!&\!\!\! 10 C \!\!\!&\!\!\! + \!\!\!&\!\!\! 5 B \!\!\! \\ \!\!\!&\!\!\! \!\!\!&\!\!\! C \!\!\!&\!\!\! + \!\!\!&\!\!\! B \!\!\!&\!\!\! \leq \!\!\!&\!\!\! 1000 \\ \!\!\!&\!\!\! \!\!\!&\!\!\! 3 C \!\!\!&\!\!\! + \!\!\!&\!\!\! B \!\!\!&\!\!\! \leq \!\!\!&\!\!\! 1500 \\ \end{array} \\ C, B \geq 0 \end{array}\end{split}$

Since it has only two variables, we can solve it graphically:

sage: P.plot()
Graphics object consisting of 19 graphics primitives


The simplex method can be applied only to problems in standard form, which can be created either directly

sage: LPProblemStandardForm(A, b, c, ["C", "B"])
LP problem (use typeset mode to see details)


or from an already constructed problem of “general type”:

sage: P = P.standard_form()


In this case the problem does not require any modifications to be written in standard form, but this step is still necessary to enable methods related to the simplex method.

The simplest way to use the simplex method is:

sage: P.run_simplex_method()
'...'


(This method produces quite long formulas which have been omitted here.) But, of course, it is much more fun to do most of the steps by hand. Let’s start by creating the initial dictionary:

sage: D = P.initial_dictionary()
sage: D
LP problem dictionary (use typeset mode to see details)


Using typeset mode as recommended, you’ll see

$\begin{split}\renewcommand{\arraystretch}{1.5} \begin{array}{|rcrcrcr|} \hline x_{3} \!\!\!&\!\!\! = \!\!\!&\!\!\! 1000 \!\!\!&\!\!\! - \!\!\!&\!\!\! C \!\!\!&\!\!\! - \!\!\!&\!\!\! B\\ x_{4} \!\!\!&\!\!\! = \!\!\!&\!\!\! 1500 \!\!\!&\!\!\! - \!\!\!&\!\!\! 3 C \!\!\!&\!\!\! - \!\!\!&\!\!\! B\\ \hline z \!\!\!&\!\!\! = \!\!\!&\!\!\! 0 \!\!\!&\!\!\! + \!\!\!&\!\!\! 10 C \!\!\!&\!\!\! + \!\!\!&\!\!\! 5 B\\ \hline \end{array}\end{split}$

With the initial or any other dictionary you can perform a number of checks:

sage: D.is_feasible()
True
sage: D.is_optimal()
False


You can look at many of its pieces and associated data:

sage: D.basic_variables()
(x3, x4)
sage: D.basic_solution()
(0, 0)
sage: D.objective_value()
0


Most importantly, you can perform steps of the simplex method by picking an entering variable, a leaving variable, and updating the dictionary:

sage: D.enter("C")
sage: D.leave(4)
sage: D.update()


If everything was done correctly, the new dictionary is still feasible and the objective value did not decrease:

sage: D.is_feasible()
True
sage: D.objective_value()
5000


If you are unsure about picking entering and leaving variables, you can use helper methods that will try their best to tell you what are your next options:

sage: D.possible_entering()
[B]
sage: D.possible_leaving()
Traceback (most recent call last):
...
ValueError: leaving variables can be determined
for feasible dictionaries with a set entering variable
or for dual feasible dictionaries


It is also possible to obtain feasible sets and final dictionaries of problems, work with revised dictionaries, and use the dual simplex method!

Note

Currently this does not have a display format for the terminal.

class sage.numerical.interactive_simplex_method.LPAbstractDictionary

Abstract base class for dictionaries for LP problems.

Instantiating this class directly is meaningless, see LPDictionary and LPRevisedDictionary for useful extensions.

base_ring()

Return the base ring of self, i.e. the ring of coefficients.

OUTPUT:

• a ring

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.base_ring()
Rational Field
sage: D = P.revised_dictionary()
sage: D.base_ring()
Rational Field

basic_solution(include_slack_variables=False)

Return the basic solution of self.

The basic solution associated to a dictionary is obtained by setting to zero all nonbasic_variables(), in which case basic_variables() have to be equal to constant_terms() in equations. It may refer to values of decision_variables() only or include slack_variables() as well.

INPUT:

• include_slack_variables – (default: False) if True, values of slack variables will be appended at the end

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.basic_solution()
(0, 0)
sage: D.basic_solution(True)
(0, 0, 1000, 1500)
sage: D = P.revised_dictionary()
sage: D.basic_solution()
(0, 0)
sage: D.basic_solution(True)
(0, 0, 1000, 1500)

coordinate_ring()

Return the coordinate ring of self.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.coordinate_ring()
Multivariate Polynomial Ring in x0, x1, x2, x3, x4
over Rational Field
sage: D = P.revised_dictionary()
sage: D.coordinate_ring()
Multivariate Polynomial Ring in x0, x1, x2, x3, x4
over Rational Field

dual_ratios()

Return ratios used to determine the entering variable based on leaving.

OUTPUT:

• A list of pairs $$(r_j, x_j)$$ where $$x_j$$ is a non-basic variable and $$r_j = c_j / a_{ij}$$ is the ratio of the objective coefficient $$c_j$$ to the coefficient $$a_{ij}$$ of $$x_j$$ in the relation for the leaving variable $$x_i$$:

$x_i = b_i - \cdots - a_{ij} x_j - \cdots.$

The order of pairs matches the order of nonbasic_variables(), but only $$x_j$$ with negative $$a_{ij}$$ are considered.

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.dictionary(2, 3, 5)
sage: D.leave(3)
sage: D.dual_ratios()
[(5/2, x1), (5, x4)]
sage: D = P.revised_dictionary(2, 3, 5)
sage: D.leave(3)
sage: D.dual_ratios()
[(5/2, x1), (5, x4)]

enter(v)

Set v as the entering variable of self.

INPUT:

• v – a non-basic variable of self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable

OUTPUT:

• none, but the selected variable will be used as entering by methods that require an entering variable and the corresponding column will be typeset in green

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.enter("x1")


We can also use indices of variables:

sage: D.enter(1)


Or variable names without quotes after injecting them:

sage: P.inject_variables()
Defining x0, x1, x2, x3, x4
sage: D.enter(x1)


The same works for revised dictionaries as well:

sage: D = P.revised_dictionary()
sage: D.enter(x1)

is_dual_feasible()

Check if self is dual feasible.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.is_dual_feasible()
False
sage: D = P.revised_dictionary()
sage: D.is_dual_feasible()
False

is_feasible()

Check if self is feasible.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.is_feasible()
True
sage: D = P.revised_dictionary()
sage: D.is_feasible()
True

is_optimal()

Check if self is optimal.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.is_optimal()
False
sage: D = P.revised_dictionary()
sage: D.is_optimal()
False
sage: D = P.revised_dictionary(1, 2)
sage: D.is_optimal()
True

leave(v)

Set v as the leaving variable of self.

INPUT:

• v – a basic variable of self, can be given as a string, an actual variable, or an integer interpreted as the index of a variable

OUTPUT:

• none, but the selected variable will be used as leaving by methods that require a leaving variable and the corresponding row will be typeset in red

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.leave("x4")


We can also use indices of variables:

sage: D.leave(4)


Or variable names without quotes after injecting them:

sage: P.inject_variables()
Defining x0, x1, x2, x3, x4
sage: D.leave(x4)


The same works for revised dictionaries as well:

sage: D = P.revised_dictionary()
sage: D.leave(x4)

possible_dual_simplex_method_steps()

Return possible dual simplex method steps for self.

OUTPUT:

• A list of pairs (leaving, entering), where leaving is a basic variable that may leave() and entering is a list of non-basic variables that may enter() when leaving leaves. Note that entering may be empty, indicating that the problem is infeasible (since the dual one is unbounded).

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.dictionary(2, 3)
sage: D.possible_dual_simplex_method_steps()
[(x3, [x1])]
sage: D = P.revised_dictionary(2, 3)
sage: D.possible_dual_simplex_method_steps()
[(x3, [x1])]

possible_entering()

Return possible entering variables for self.

OUTPUT:

• a list of non-basic variables of self that can enter() on the next step of the (dual) simplex method

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.possible_entering()
[x1, x2]
sage: D = P.revised_dictionary()
sage: D.possible_entering()
[x1, x2]

possible_leaving()

Return possible leaving variables for self.

OUTPUT:

• a list of basic variables of self that can leave() on the next step of the (dual) simplex method

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.enter(1)
sage: D.possible_leaving()
[x4]
sage: D = P.revised_dictionary()
sage: D.enter(1)
sage: D.possible_leaving()
[x4]

possible_simplex_method_steps()

Return possible simplex method steps for self.

OUTPUT:

• A list of pairs (entering, leaving), where entering is a non-basic variable that may enter() and leaving is a list of basic variables that may leave() when entering enters. Note that leaving may be empty, indicating that the problem is unbounded.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.possible_simplex_method_steps()
[(x1, [x4]), (x2, [x3])]
sage: D = P.revised_dictionary()
sage: D.possible_simplex_method_steps()
[(x1, [x4]), (x2, [x3])]

ratios()

Return ratios used to determine the leaving variable based on entering.

OUTPUT:

• A list of pairs $$(r_i, x_i)$$ where $$x_i$$ is a basic variable and $$r_i = b_i / a_{ik}$$ is the ratio of the constant term $$b_i$$ to the coefficient $$a_{ik}$$ of the entering variable $$x_k$$ in the relation for $$x_i$$:

$x_i = b_i - \cdots - a_{ik} x_k - \cdots.$

The order of pairs matches the order of basic_variables(), but only $$x_i$$ with positive $$a_{ik}$$ are considered.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.enter(1)
sage: D.ratios()
[(1000, x3), (500, x4)]
sage: D = P.revised_dictionary()
sage: D.enter(1)
sage: D.ratios()
[(1000, x3), (500, x4)]

class sage.numerical.interactive_simplex_method.LPDictionary(A, b, c, objective_value, basic_variables, nonbasic_variables, objective_variable)

Construct a dictionary for an LP problem.

A dictionary consists of the following data:

$\begin{split}\begin{array}{|l|} \hline x_B = b - A x_N\\ \hline z = z^* + c x_N\\ \hline \end{array}\end{split}$

INPUT:

• A – a matrix of relation coefficients
• b – a vector of relation constant terms
• c – a vector of objective coefficients
• objective_value – current value of the objective $$z^*$$
• basic_variables – a list of basic variables $$x_B$$
• nonbasic_variables – a list of non-basic variables $$x_N$$
• objective_variable – an objective variable $$z$$

OUTPUT:

Note

This constructor does not check correctness of input, as it is intended to be used internally by LPProblemStandardForm.

EXAMPLES:

The intended way to use this class is indirect:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D
LP problem dictionary (use typeset mode to see details)


But if you want you can create a dictionary without starting with an LP problem, here is construction of the same dictionary as above:

sage: A = matrix(QQ, ([1, 1], [3, 1]))
sage: b = vector(QQ, (1000, 1500))
sage: c = vector(QQ, (10, 5))
sage: R = PolynomialRing(QQ, "x1, x2, x3, x4", order="neglex")
sage: from sage.numerical.interactive_simplex_method \
....:     import LPDictionary
sage: D2 = LPDictionary(A, b, c, 0, R.gens()[2:], R.gens()[:2], "z")
sage: D2 == D
True

ELLUL(entering, leaving)

Perform the Enter-Leave-LaTeX-Update-LaTeX step sequence on self.

INPUT:

• entering – the entering variable
• leaving – the leaving variable

OUTPUT:

• a string with LaTeX code for self before and after update

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.ELLUL("x1", "x4")
\renewcommand{\arraystretch}{1.5} \setlength{\arraycolsep}{0.125em}
\begin{array}{|rcrcrcr|}
\hline
x_{3} & = & 1000 & - &\color{green}  x_{1} & - &  x_{2}\\
\color{red}x_{4} &\color{red} = &\color{red} 1500 &\color{red} - &\color{blue} 3 x_{1} &\color{red} - &\color{red}  x_{2}\\
\hline
z & = & 0 & + &\color{green} 10 x_{1} & + & 5 x_{2}\\
\hline
\multicolumn{2}{c}{}\$-3ex] \hline x_{3} & = & 500 & + & \frac{1}{3} x_{4} & - & \frac{2}{3} x_{2}\\ x_{1} & = & 500 & - & \frac{1}{3} x_{4} & - & \frac{1}{3} x_{2}\\ \hline z & = & 5000 & - & \frac{10}{3} x_{4} & + & \frac{5}{3} x_{2}\\ \hline \end{array}  This is how the above output looks when rendered: \[\begin{split}\renewcommand{\arraystretch}{1.5} \begin{array}{|rcrcrcr|} \hline x_{3} \!\!\!&\!\!\! = \!\!\!&\!\!\! 1000 \!\!\!&\!\!\! - \!\!\!&\color{green}{\!\!\! x_{1} \!\!\!}&\!\!\! - \!\!\!&\!\!\! x_{2}\\ \color{red}{x_{4} \!\!\!}&\color{red}{\!\!\! = \!\!\!}&\color{red}{\!\!\! 1500 \!\!\!}&\color{red}{\!\!\! - \!\!\!}&\color{blue}{{\!\!\! 3 x_{1} \!\!\!}}&\color{red}{\!\!\! - \!\!\!}&\color{red}{\!\!\! x_{2}}\\ \hline z \!\!\!&\!\!\! = \!\!\!&\!\!\! 0 \!\!\!&\!\!\! + \!\!\!&\color{green}{\!\!\! 10 x_{1} \!\!\!}&\!\!\! + \!\!\!&\!\!\! 5 x_{2}\\ \hline \\ \hline x_{3} \!\!\!&\!\!\! = \!\!\!&\!\!\! 500 \!\!\!&\!\!\! + \!\!\!&\!\!\! \frac{1}{3} x_{4} \!\!\!&\!\!\! - \!\!\!&\!\!\! \frac{2}{3} x_{2}\\ x_{1} \!\!\!&\!\!\! = \!\!\!&\!\!\! 500 \!\!\!&\!\!\! - \!\!\!&\!\!\! \frac{1}{3} x_{4} \!\!\!&\!\!\! - \!\!\!&\!\!\! \frac{1}{3} x_{2}\\ \hline z \!\!\!&\!\!\! = \!\!\!&\!\!\! 5000 \!\!\!&\!\!\! - \!\!\!&\!\!\! \frac{10}{3} x_{4} \!\!\!&\!\!\! + \!\!\!&\!\!\! \frac{5}{3} x_{2}\\ \hline \end{array}\end{split}$

The column of the entering variable is green, while the row of the leaving variable is red in the original dictionary state on the top. The new state after the update step is shown on the bottom.

basic_variables()

Return the basic variables of self.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.basic_variables()
(x3, x4)

constant_terms()

Return the constant terms of relations of self.

OUTPUT:

• a vector.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.constant_terms()
(1000, 1500)

entering_coefficients()

Return coefficients of the entering variable.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.enter(1)
sage: D.entering_coefficients()
(1, 3)

leaving_coefficients()

Return coefficients of the leaving variable.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.dictionary(2, 3)
sage: D.leave(3)
sage: D.leaving_coefficients()
(-2, -1)

nonbasic_variables()

Return non-basic variables of self.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.nonbasic_variables()
(x1, x2)

objective_coefficients()

Return coefficients of the objective of self.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.objective_coefficients()
(10, 5)

objective_value()

Return the value of the objective at the basic_solution() of self.

OUTPUT:

• a number

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.objective_value()
0

update()

Update self using previously set entering and leaving variables.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.objective_value()
0
sage: D.enter("x1")
sage: D.leave("x4")
sage: D.update()
sage: D.objective_value()
5000

class sage.numerical.interactive_simplex_method.LPProblem(A, b, c, x='x', constraint_type='<=', variable_type='', problem_type='max', prefix='x', base_ring=None)

Construct an LP (Linear Programming) problem.

This class supports LP problems with “variables on the left” constraints.

INPUT:

• A – a matrix of constraint coefficients
• b – a vector of constraint constant terms
• c – a vector of objective coefficients
• x – (default: "x") a vector of decision variables or a string giving the base name
• constraint_type – (default: "<=") a string specifying constraint type(s): either "<=", ">=", "==", or a list of them
• variable_type – (default: "") a string specifying variable type(s): either ">=", "<=", "" (the empty string), or a list of them, corresponding, respectively, to non-negative, non-positive, and free variables
• problem_type – (default: "max") a string specifying the problem type: "max", "min", "-max", or "-min"
• prefix – (default: parameter x if it was given as a string, string "x" otherwise) a string giving the base name of automatically created variables in standard_form()
• base_ring – (default: the fraction field of a common ring for all input coefficients) a field to which all input coefficients will be converted

EXAMPLES:

We will construct the following problem:

$\begin{split}\begin{array}{l} \begin{array}{lcrcrcl} \max \!\!\!&\!\!\! \!\!\!&\!\!\! 10 C \!\!\!&\!\!\! + \!\!\!&\!\!\! 5 B \!\!\! \\ \!\!\!&\!\!\! \!\!\!&\!\!\! C \!\!\!&\!\!\! + \!\!\!&\!\!\! B \!\!\!&\!\!\! \leq \!\!\!&\!\!\! 1000 \\ \!\!\!&\!\!\! \!\!\!&\!\!\! 3 C \!\!\!&\!\!\! + \!\!\!&\!\!\! B \!\!\!&\!\!\! \leq \!\!\!&\!\!\! 1500 \\ \end{array} \\ C, B \geq 0 \end{array}\end{split}$
sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")


Same problem, but more explicitly:

sage: P = LPProblem(A, b, c, ["C", "B"],
....:     constraint_type="<=", variable_type=">=")


Even more explicitly:

sage: P = LPProblem(A, b, c, ["C", "B"], problem_type="max",
....:     constraint_type=["<=", "<="], variable_type=[">=", ">="])


Using the last form you should be able to represent any LP problem, as long as all like terms are collected and in constraints variables and constants are on different sides.

A()

Return coefficients of constraints of self, i.e. $$A$$.

OUTPUT:

• a matrix

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.constraint_coefficients()
[1 1]
[3 1]
sage: P.A()
[1 1]
[3 1]

Abcx()

Return $$A$$, $$b$$, $$c$$, and $$x$$ of self as a tuple.

OUTPUT:

• a tuple

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.Abcx()
(
[1 1]
[3 1], (1000, 1500), (10, 5), (C, B)
)

b()

Return constant terms of constraints of self, i.e. $$b$$.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.constant_terms()
(1000, 1500)
sage: P.b()
(1000, 1500)

base_ring()

Return the base ring of self.

Note

The base ring of LP problems is always a field.

OUTPUT:

• a ring

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.base_ring()
Rational Field

sage: c = (10, 5.)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.base_ring()
Real Field with 53 bits of precision

c()

Return coefficients of the objective of self, i.e. $$c$$.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.objective_coefficients()
(10, 5)
sage: P.c()
(10, 5)

constant_terms()

Return constant terms of constraints of self, i.e. $$b$$.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.constant_terms()
(1000, 1500)
sage: P.b()
(1000, 1500)

constraint_coefficients()

Return coefficients of constraints of self, i.e. $$A$$.

OUTPUT:

• a matrix

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.constraint_coefficients()
[1 1]
[3 1]
sage: P.A()
[1 1]
[3 1]

decision_variables()

Return decision variables of self, i.e. $$x$$.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.decision_variables()
(C, B)
sage: P.x()
(C, B)

dual(y=None)

Construct the dual LP problem for self.

INPUT:

• y – (default: "x" if the prefix of self is "y", "y" otherwise) a vector of dual decision variables or a string giving the base name

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: DP = P.dual()
sage: DP.b() == P.c()
True
sage: DP.dual(["C", "B"]) == P
True

feasible_set()

Return the feasible set of self.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.feasible_set()
A 2-dimensional polyhedron in QQ^2
defined as the convex hull of 4 vertices

is_bounded()

Check if self is bounded.

OUTPUT:

• True is self is bounded, False otherwise

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.is_bounded()
True

is_feasible()

Check if self is feasible.

OUTPUT:

• True is self is feasible, False otherwise

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.is_feasible()
True

m()

Return the number of constraints of self, i.e. $$m$$.

OUTPUT:

• an integer

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.n_constraints()
2
sage: P.m()
2

n()

Return the number of decision variables of self, i.e. $$n$$.

OUTPUT:

• an integer

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.n_variables()
2
sage: P.n()
2

n_constraints()

Return the number of constraints of self, i.e. $$m$$.

OUTPUT:

• an integer

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.n_constraints()
2
sage: P.m()
2

n_variables()

Return the number of decision variables of self, i.e. $$n$$.

OUTPUT:

• an integer

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.n_variables()
2
sage: P.n()
2

objective_coefficients()

Return coefficients of the objective of self, i.e. $$c$$.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.objective_coefficients()
(10, 5)
sage: P.c()
(10, 5)

optimal_solution()

Return an optimal solution of self.

OUTPUT:

• a vector or None if there are no optimal solutions

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.optimal_solution()
(250, 750)

optimal_value()

Return the optimal value for self.

OUTPUT:

• a number if the problem is bounded, $$\pm \infty$$ if it is unbounded, or None if it is infeasible

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.optimal_value()
6250

plot(*args, **kwds)

Return a plot for solving self graphically.

INPUT:

• xmin, xmax, ymin, ymax – bounds for the axes, if not given, an attempt will be made to pick reasonable values
• alpha – (default: 0.2) determines how opaque are shadows

OUTPUT:

• a plot

This only works for problems with two decision variables. On the plot the black arrow indicates the direction of growth of the objective. The lines perpendicular to it are level curves of the objective. If there are optimal solutions, the arrow originates in one of them and the corresponding level curve is solid: all points of the feasible set on it are optimal solutions. Otherwise the arrow is placed in the center. If the problem is infeasible or the objective is zero, a plot of the feasible set only is returned.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: p = P.plot()
sage: p.show()


In this case the plot works better with the following axes ranges:

sage: p = P.plot(0, 1000, 0, 1500)
sage: p.show()


TESTS:

We check that zero objective can be dealt with:

sage: LPProblem(A, b, (0, 0), ["C", "B"], variable_type=">=").plot()
Graphics object consisting of 8 graphics primitives

plot_feasible_set(xmin=None, xmax=None, ymin=None, ymax=None, alpha=0.2)

Return a plot of the feasible set of self.

INPUT:

• xmin, xmax, ymin, ymax – bounds for the axes, if not given, an attempt will be made to pick reasonable values
• alpha – (default: 0.2) determines how opaque are shadows

OUTPUT:

• a plot

This only works for a problem with two decision variables. The plot shows boundaries of constraints with a shadow on one side for inequalities. If the feasible_set() is not empty and at least part of it is in the given boundaries, it will be shaded gray and $$F$$ will be placed in its middle.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: p = P.plot_feasible_set()
sage: p.show()


In this case the plot works better with the following axes ranges:

sage: p = P.plot_feasible_set(0, 1000, 0, 1500)
sage: p.show()

standard_form()

Construct the LP problem in standard form equivalent to self.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: DP = P.dual()
sage: DPSF = DP.standard_form()
sage: DPSF.b()
(-10, -5)

x()

Return decision variables of self, i.e. $$x$$.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblem(A, b, c, ["C", "B"], variable_type=">=")
sage: P.decision_variables()
(C, B)
sage: P.x()
(C, B)

class sage.numerical.interactive_simplex_method.LPProblemStandardForm(A, b, c, x='x', problem_type='max', slack_variables=None, auxiliary_variable=None, objective='z', base_ring=None)

Construct an LP (Linear Programming) problem in standard form.

The used standard form is:

$\begin{split}\begin{array}{l} \pm \max cx \\ Ax \leq b \\ x \geq 0 \end{array}\end{split}$

INPUT:

• A – a matrix of constraint coefficients
• b – a vector of constraint constant terms
• c – a vector of objective coefficients
• x – (default: "x") a vector of decision variables or a string the base name giving
• problem_type – (default: "max") a string specifying the problem type: either "max" or "-max"
• slack_variables – (default: same as x parameter, if it was given as a string, otherwise string "x") a vector of slack variables or a sting giving the base name
• auxiliary_variable – (default: same as x parameter with adjoined "0" if it was given as a string, otherwise "x0") the auxiliary name, expected to be the same as the first decision variable for auxiliary problems
• objective – (default: "z") the objective variable (used for the initial dictionary)
• base_ring – (default: the fraction field of a common ring for all input coefficients) a field to which all input coefficients will be converted

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)


Unlike LPProblem, this class does not allow you to adjust types of constraints (they are always "<=") and variables (they are always ">="), and the problem type may only be "max" or "-max". You may give custom names to slack and auxiliary variables, but in most cases defaults should work:

sage: P.decision_variables()
(x1, x2)
sage: P.slack_variables()
(x3, x4)

auxiliary_problem()

Construct the auxiliary problem for self.

OUTPUT:

The auxiliary problem with the auxiliary variable $$x_0$$ is

$\begin{split}\begin{array}{l} \max - x_0 \\ - x_0 + A_i x \leq b_i \text{ for all } i \\ x \geq 0 \end{array}\ .\end{split}$

Such problems are used when the initial_dictionary() is infeasible.

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: AP = P.auxiliary_problem()

auxiliary_variable()

Return the auxiliary variable of self.

Note that the auxiliary variable may or may not be among decision_variables().

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: P.auxiliary_variable()
x0
sage: P.decision_variables()
(x1, x2)
sage: AP = P.auxiliary_problem()
sage: AP.auxiliary_variable()
x0
sage: AP.decision_variables()
(x0, x1, x2)

coordinate_ring()

Return the coordinate ring of self.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: P.coordinate_ring()
Multivariate Polynomial Ring in x0, x1, x2, x3, x4, x5
over Rational Field
sage: P.base_ring()
Rational Field
sage: P.auxiliary_variable()
x0
sage: P.decision_variables()
(x1, x2)
sage: P.slack_variables()
(x3, x4, x5)

dictionary(*x_B)

Construct a dictionary for self with given basic variables.

INPUT:

• basic variables for the dictionary to be constructed

OUTPUT:

Note

This is a synonym for self.revised_dictionary(x_B).dictionary(), but basic variables are mandatory.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.dictionary("x1", "x2")
sage: D.basic_variables()
(x1, x2)

feasible_dictionary(auxiliary_dictionary)

Construct a feasible dictionary for self.

INPUT:

• auxiliary_dictionary – an optimal dictionary for the auxiliary_problem() of self with the optimal value $$0$$ and a non-basic auxiliary variable

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: AP = P.auxiliary_problem()
sage: D = AP.initial_dictionary()
sage: D.enter(0)
sage: D.leave(5)
sage: D.update()
sage: D.enter(1)
sage: D.leave(0)
sage: D.update()
sage: D.is_optimal()
True
sage: D.objective_value()
0
sage: D.basic_solution()
(0, 400, 0)
sage: D = P.feasible_dictionary(D)
sage: D.is_optimal()
False
sage: D.is_feasible()
True
sage: D.objective_value()
4000
sage: D.basic_solution()
(400, 0)

final_dictionary()

Return the final dictionary of the simplex method applied to self.

See run_simplex_method() for the description of possibilities.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.final_dictionary()
sage: D.is_optimal()
True


TESTS:

sage: P.final_dictionary() is P.final_dictionary()
False

final_revised_dictionary()

Return the final dictionary of the revised simplex method applied to self.

See run_revised_simplex_method() for the description of possibilities.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.final_revised_dictionary()
sage: D.is_optimal()
True


TESTS:

sage: P.final_revised_dictionary() is P.final_revised_dictionary()
False

initial_dictionary()

Construct the initial dictionary of self.

The initial dictionary “defines” slack_variables() in terms of the decision_variables(), i.e. it has slack variables as basic ones.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()

inject_variables(scope=None, verbose=True)

Inject variables of self into scope.

INPUT:

• scope – namespace (default: global)
• verbose – if True (default), names of injected variables will be printed

OUTPUT:

• none

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: P.inject_variables()
Defining x0, x1, x2, x3, x4
sage: 3*x1 + x2
x2 + 3*x1

revised_dictionary(*x_B)

Construct a revised dictionary for self.

INPUT:

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary("x1", "x2")
sage: D.basic_variables()
(x1, x2)


If basic variables are not given the initial dictionary is constructed:

sage: P.revised_dictionary().basic_variables()
(x3, x4)
sage: P.initial_dictionary().basic_variables()
(x3, x4)


Unless it is infeasible, in which case a feasible dictionary for the auxiliary problem is constructed:

sage: A = ([1, 1], [3, 1], [-1,-1])
sage: b = (1000, 1500, -400)
sage: P = LPProblemStandardForm(A, b, c)
sage: P.initial_dictionary().is_feasible()
False
sage: P.revised_dictionary().basic_variables()
(x3, x4, x0)

run_revised_simplex_method()

Apply the revised simplex method to solve self and show the steps.

OUTPUT:

• a string with $$\LaTeX$$ code of intermediate dictionaries

Note

You can access the final_revised_dictionary(), which can be one of the following:

• an optimal dictionary with the auxiliary_variable() among basic_variables() and a non-zero optimal value indicating that self is infeasible;
• a non-optimal dictionary that has marked entering variable for which there is no choice of the leaving variable, indicating that self is unbounded;
• an optimal dictionary.

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: P.run_revised_simplex_method()
\renewcommand{\arraystretch}{1.500000}
\begin{array}{l}
...
\text{Entering: $x_{1}$. Leaving: $x_{0}$.}\\
...
\text{Entering: $x_{5}$. Leaving: $x_{4}$.}\\
...
\text{Entering: $x_{2}$. Leaving: $x_{3}$.}\\
...
\text{The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.}
\end{array}

run_simplex_method()

Apply the simplex method to solve self and show the steps.

OUTPUT:

• a string with $$\LaTeX$$ code of intermediate dictionaries

Note

You can access the final_dictionary(), which can be one of the following:

• an optimal dictionary for the auxiliary_problem() with a non-zero optimal value indicating that self is infeasible;
• a non-optimal dictionary for self that has marked entering variable for which there is no choice of the leaving variable, indicating that self is unbounded;
• an optimal dictionary for self.

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: P.run_simplex_method()  # not tested


You should use the typeset mode as the command above generates long $$\LaTeX$$ code:

sage: print P.run_simplex_method()
\begin{gather*}
...
\text{The initial dictionary is infeasible, solving auxiliary problem.}\displaybreak[0]\\
...
\text{Entering: $x_{0}$. Leaving: $x_{5}$.}\displaybreak[0]\\
...
\text{Entering: $x_{1}$. Leaving: $x_{0}$.}\displaybreak[0]\\
...
\text{Back to the original problem.}\displaybreak[0]\\
...
\text{Entering: $x_{5}$. Leaving: $x_{4}$.}\displaybreak[0]\\
...
\text{Entering: $x_{2}$. Leaving: $x_{3}$.}\displaybreak[0]\\
...
\text{The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.}
\end{gather*}

slack_variables()

Return slack variables of self.

Slack variables are differences between the constant terms and left hand sides of the constraints.

If you want to give custom names to slack variables, you have to do so during construction of the problem.

OUTPUT:

• a tuple

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: P.slack_variables()
(x3, x4)
sage: P = LPProblemStandardForm(A, b, c, ["C", "B"],
....:     slack_variables=["L", "F"])
sage: P.slack_variables()
(L, F)

class sage.numerical.interactive_simplex_method.LPRevisedDictionary(problem, basic_variables)

Construct a revised dictionary for an LP problem.

INPUT:

OUTPUT:

A revised dictionary encodes the same relations as a regular dictionary, but stores only what is “necessary to efficiently compute data for the simplex method”.

Let the original problem be

$\begin{split}\begin{array}{l} \pm \max cx \\ Ax \leq b \\ x \geq 0 \end{array}\end{split}$

Let $$\bar{x}$$ be the vector of decision_variables() $$x$$ followed by the slack_variables(). Let $$\bar{c}$$ be the vector of objective_coefficients() $$c$$ followed by zeroes for all slack variables. Let $$\bar{A} = (A | I)$$ be the matrix of constraint_coefficients() $$A$$ augmented by the identity matrix as columns corresponding to the slack variables. Then the problem above can be written as

$\begin{split}\begin{array}{l} \pm \max \bar{c} \bar{x} \\ \bar{A} \bar{x} = b \\ \bar{x} \geq 0 \end{array}\end{split}$

and any dictionary is a system of equations equivalent to $$\bar{A} \bar{x} = b$$, but resolved for basic_variables() $$x_B$$ in terms of nonbasic_variables() $$x_N$$ together with the expression for the objective in terms of $$x_N$$. Let c_B() and c_N() be vectors “splitting $$\bar{c}$$ into basic and non-basic parts”. Let B() and A_N() be the splitting of $$\bar{A}$$. Then the corresponding dictionary is

$\begin{split}\begin{array}{|l|} \hline x_B = B^{-1} b - B^{-1} A_N x_N\\ \hline z = y b + \left(c_N - y^T A_N\right) x_N\\ \hline \end{array}\end{split}$

where $$y = c_B^T B^{-1}$$. To proceed with the simplex method, it is not necessary to compute all entries of this dictionary. On the other hand, any entry is easy to compute, if you know $$B^{-1}$$, so we keep track of it through the update steps.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: from sage.numerical.interactive_simplex_method \
....:     import LPRevisedDictionary
sage: D = LPRevisedDictionary(P, [1, 2])
sage: D.basic_variables()
(x1, x2)
sage: D
LP problem dictionary (use typeset mode to see details)


The same dictionary can be constructed through the problem:

sage: P.revised_dictionary(1, 2) == D
True


When this dictionary is typeset, you will see two tables like these ones:

$\begin{split}\renewcommand{\arraystretch}{1.500000} \begin{array}{l} \begin{array}{l|r|rr||r||r} x_B & c_B & & \!\!\!\!\!\!\!\! B^{-1} & y & B^{-1} b \\ \hline x_{1} & 10 & -\frac{1}{2} & \frac{1}{2} & \frac{5}{2} & 250 \\ x_{2} & 5 & \frac{3}{2} & -\frac{1}{2} & \frac{5}{2} & 750 \\ \end{array}\\ \\ \begin{array}{r|rr} x_N & x_{3} & x_{4} \\ \hline c_N^T & 0 & 0 \\ y^T A_N & \frac{5}{2} & \frac{5}{2} \\ \hline c_N^T - y^T A_N & -\frac{5}{2} & -\frac{5}{2} \\ \end{array} \end{array}\end{split}$

More details will be shown if entering and leaving variables are set, but in any case the top table shows $$B^{-1}$$ and a few extra columns, while the bottom one shows several rows: these are related to columns and rows of dictionary entries.

A(v)

Return the column of constraint coefficients corresponding to v.

INPUT:

• v – a variable, its name, or its index

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.A(1)
(1, 3)
sage: D.A(0)
(-1, -1)
sage: D.A("x3")
(1, 0)

A_N()

Return the $$A_N$$ matrix, constraint coefficients of non-basic variables.

OUTPUT:

• a matrix

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.A_N()
[1 1]
[3 1]

B()

Return the $$B$$ matrix, i.e. constraint coefficients of basic variables.

OUTPUT:

• a matrix

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary(1, 2)
sage: D.B()
[1 1]
[3 1]

B_inverse()

Return the inverse of the B() matrix.

This inverse matrix is stored and computed during dictionary update in a more efficient way than generic inversion.

OUTPUT:

• a matrix

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary(1, 2)
sage: D.B_inverse()
[-1/2  1/2]
[ 3/2 -1/2]

E()

Return the eta matrix between self and the next dictionary.

OUTPUT:

• a matrix

If $$B_{\mathrm{old}}$$ is the current matrix $$B$$ and $$B_{\mathrm{new}}$$ is the $$B$$ matrix of the next dictionary (after the update step), then $$B_{\mathrm{new}} = B_{\mathrm{old}} E$$.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.enter(1)
sage: D.leave(4)
sage: D.E()
[1 1]
[0 3]

E_inverse()

Return the inverse of the matrix E().

This inverse matrix is computed in a more efficient way than generic inversion.

OUTPUT:

• a matrix

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.enter(1)
sage: D.leave(4)
sage: D.E_inverse()
[   1 -1/3]
[   0  1/3]

basic_indices()

Return the basic indices of self.

Note

Basic indices are indices of basic_variables() in the list of generators of the coordinate_ring() of the problem() of self, they may not coincide with the indices of variables which are parts of their names. (They will for the default indexed names.)

OUTPUT:

• a list.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.basic_indices()
[3, 4]

basic_variables()

Return the basic variables of self.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.basic_variables()
(x3, x4)

c_B()

Return the $$c_B$$ vector, objective coefficients of basic variables.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary(1, 2)
sage: D.c_B()
(10, 5)

c_N()

Return the $$c_N$$ vector, objective coefficients of non-basic variables.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.c_N()
(10, 5)

constant_terms()

Return constant terms in the relations of self.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.constant_terms()
(1000, 1500)

dictionary()

Return a regular LP dictionary matching self.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.dictionary()
LP problem dictionary (use typeset mode to see details)

entering_coefficients()

Return coefficients of the entering variable.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.enter(1)
sage: D.entering_coefficients()
(1, 3)

leaving_coefficients()

Return coefficients of the leaving variable.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary(2, 3)
sage: D.leave(3)
sage: D.leaving_coefficients()
(-2, -1)

nonbasic_indices()

Return the non-basic indices of self.

Note

Non-basic indices are indices of nonbasic_variables() in the list of generators of the coordinate_ring() of the problem() of self, they may not coincide with the indices of variables which are parts of their names. (They will for the default indexed names.)

OUTPUT:

• a list

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.nonbasic_indices()
[1, 2]

nonbasic_variables()

Return non-basic variables of self.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.nonbasic_variables()
(x1, x2)

objective_coefficients()

Return coefficients of the objective of self.

OUTPUT:

• a vector

These are coefficients of non-basic variables when basic variables are eliminated.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.objective_coefficients()
(10, 5)

objective_value()

Return the value of the objective at the basic solution of self.

OUTPUT:

• a number

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.objective_value()
0

problem()

Return the original problem.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.problem() is P
True

update()

Update self using previously set entering and leaving variables.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.objective_value()
0
sage: D.enter("x1")
sage: D.leave("x4")
sage: D.update()
sage: D.objective_value()
5000

x_B()

Return the basic variables of self.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.basic_variables()
(x3, x4)

x_N()

Return non-basic variables of self.

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.nonbasic_variables()
(x1, x2)

y()

Return the $$y$$ vector, the product of c_B() and B_inverse().

OUTPUT:

• a vector

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = LPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.y()
(0, 0)

sage.numerical.interactive_simplex_method.random_dictionary(m, n, bound=5, special_probability=0.2)

Construct a random dictionary.

INPUT:

• m – the number of constraints/basic variables
• n – the number of decision/non-basic variables
• bound – (default: 5) a bound on dictionary entries
• special_probability – (default: 0.2) probability of constructing a potentially infeasible or potentially optimal dictionary

OUTPUT:

EXAMPLES:

sage: from sage.numerical.interactive_simplex_method \
....:     import random_dictionary
sage: random_dictionary(3, 4)
LP problem dictionary (use typeset mode to see details)

sage.numerical.interactive_simplex_method.variable(R, v)

Interpret v as a variable of R.

INPUT:

• R – a polynomial ring
• v – a variable of R or convertible into R, a string with the name of a variable of R or an index of a variable in R

OUTPUT:

• a variable of R

EXAMPLES:

sage: from sage.numerical.interactive_simplex_method \
....:     import variable
sage: R = PolynomialRing(QQ, "x3, y5, x5, y")
sage: R.inject_variables()
Defining x3, y5, x5, y
sage: variable(R, "x3")
x3
sage: variable(R, x3)
x3
sage: variable(R, 3)
x3
sage: variable(R, 0)
Traceback (most recent call last):
...
ValueError: there is no variable with the given index
sage: variable(R, 5)
Traceback (most recent call last):
...
ValueError: the given index is ambiguous
sage: variable(R, 2 * x3)
Traceback (most recent call last):
...
ValueError: cannot interpret given data as a variable
sage: variable(R, "z")
Traceback (most recent call last):
...
ValueError: cannot interpret given data as a variable


#### Previous topic

Numerical Root Finding and Optimization

#### Next topic

Generic Backend for LP solvers