Interactive Simplex Method

This module, meant for educational purposes only, supports learning and exploring of the simplex method.

Do you want to solve Linear Programs efficiently? use MixedIntegerLinearProgram instead.

The methods implemented here allow solving Linear Programming Problems (LPPs) in a number of ways, may require explicit (and correct!) description of steps and are likely to be much slower than “regular” LP solvers. 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.

  • Matthias Koeppe, Peijun Xiao (2015-07-05): allow different output styles.

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P
LP problem (use 'view(...)' or '%display typeset' for details)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P
LP problem (use 'view(...)' or '%display typeset' for details)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P

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

\[\begin{split}\begin{array}{l} \begin{array}{lcrcrcl} \max \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} 10 C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} 5 B \mspace{-6mu} \\ \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} B \mspace{-6mu}&\mspace{-6mu} \leq \mspace{-6mu}&\mspace{-6mu} 1000 \\ \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} 3 C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} B \mspace{-6mu}&\mspace{-6mu} \leq \mspace{-6mu}&\mspace{-6mu} 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()                                                                      # needs sage.plot
Graphics object consisting of 19 graphics primitives

>>> from sage.all import *
>>> P.plot()                                                                      # needs sage.plot
Graphics object consisting of 19 graphics primitives

P.plot()                                                                      # needs sage.plot

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

sage: InteractiveLPProblemStandardForm(A, b, c, ["C", "B"])
LP problem (use ...)

>>> from sage.all import *
>>> InteractiveLPProblemStandardForm(A, b, c, ["C", "B"])
LP problem (use ...)

InteractiveLPProblemStandardForm(A, b, c, ["C", "B"])

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

sage: P = P.standard_form()

>>> from sage.all import *
>>> P = P.standard_form()

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()
\begin{equation*}
...
The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.

>>> from sage.all import *
>>> P.run_simplex_method()
\begin{equation*}
...
The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.

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 ...)

>>> from sage.all import *
>>> D = P.initial_dictionary()
>>> D
LP problem dictionary (use ...)

D = P.initial_dictionary()
D

Using typeset mode as recommended, you’ll see

\[\begin{split}\renewcommand{\arraystretch}{1.5} \begin{array}{|rcrcrcr|} \hline x_{3} \mspace{-6mu}&\mspace{-6mu} = \mspace{-6mu}&\mspace{-6mu} 1000 \mspace{-6mu}&\mspace{-6mu} - \mspace{-6mu}&\mspace{-6mu} C \mspace{-6mu}&\mspace{-6mu} - \mspace{-6mu}&\mspace{-6mu} B\\ x_{4} \mspace{-6mu}&\mspace{-6mu} = \mspace{-6mu}&\mspace{-6mu} 1500 \mspace{-6mu}&\mspace{-6mu} - \mspace{-6mu}&\mspace{-6mu} 3 C \mspace{-6mu}&\mspace{-6mu} - \mspace{-6mu}&\mspace{-6mu} B\\ \hline z \mspace{-6mu}&\mspace{-6mu} = \mspace{-6mu}&\mspace{-6mu} 0 \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} 10 C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} 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

>>> from sage.all import *
>>> D.is_feasible()
True
>>> D.is_optimal()
False

D.is_feasible()
D.is_optimal()

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

>>> from sage.all import *
>>> D.basic_variables()
(x3, x4)
>>> D.basic_solution()
(0, 0)
>>> D.objective_value()
0

D.basic_variables()
D.basic_solution()
D.objective_value()

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()

>>> from sage.all import *
>>> D.enter("C")
>>> D.leave(Integer(4))
>>> D.update()

D.enter("C")
D.leave(4)
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

>>> from sage.all import *
>>> D.is_feasible()
True
>>> D.objective_value()
5000

D.is_feasible()
D.objective_value()

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

>>> from sage.all import *
>>> D.possible_entering()
[B]
>>> 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

D.possible_entering()
D.possible_leaving()

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.

Classes and functions

class sage.numerical.interactive_simplex_method.InteractiveLPProblem(A, b, c, x='x', constraint_type='<=', variable_type='', problem_type='max', base_ring=None, is_primal=True, objective_constant_term=0)[source]

Bases: SageObject

Construct an LP (Linear Programming) problem.

Note

This class is for educational purposes only: if you want to solve Linear Programs efficiently, use MixedIntegerLinearProgram instead.

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 nonnegative, nonpositive, and free variables

  • problem_type – (default: 'max') a string specifying the problem type: 'max', 'min', '-max', or '-min'

  • base_ring – (default: the fraction field of a common ring for all input coefficients) a field to which all input coefficients will be converted

  • is_primal – boolean (default: True); whether this problem is primal or dual: each problem is of course dual to its own dual, this flag is mostly for internal use and affects default variable names only

  • objective_constant_term – (default: 0) a constant term of the objective

EXAMPLES:

We will construct the following problem:

\[\begin{split}\begin{array}{l} \begin{array}{lcrcrcl} \max \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} 10 C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} 5 B \mspace{-6mu} \\ \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} B \mspace{-6mu}&\mspace{-6mu} \leq \mspace{-6mu}&\mspace{-6mu} 1000 \\ \mspace{-6mu}&\mspace{-6mu} \mspace{-6mu}&\mspace{-6mu} 3 C \mspace{-6mu}&\mspace{-6mu} + \mspace{-6mu}&\mspace{-6mu} B \mspace{-6mu}&\mspace{-6mu} \leq \mspace{-6mu}&\mspace{-6mu} 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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')

Same problem, but more explicitly:

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

>>> from sage.all import *
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"],
...     constraint_type='<=', variable_type='>=')

P = InteractiveLPProblem(A, b, c, ["C", "B"],
    constraint_type='<=', variable_type='>=')

Even more explicitly:

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

>>> from sage.all import *
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], problem_type='max',
...     constraint_type=["<=", "<="], variable_type=[">=", ">="])

P = InteractiveLPProblem(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()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.constraint_coefficients()
[1 1]
[3 1]
sage: P.A()
[1 1]
[3 1]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.constraint_coefficients()
[1 1]
[3 1]
>>> P.A()
[1 1]
[3 1]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.constraint_coefficients()
P.A()
Abcx()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.Abcx()
(
[1 1]
[3 1], (1000, 1500), (10, 5), (C, B)
)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.Abcx()
(
[1 1]
[3 1], (1000, 1500), (10, 5), (C, B)
)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.Abcx()
add_constraint(coefficients, constant_term, constraint_type='<=')[source]

Return a new LP problem by adding a constraint to``self``.

INPUT:

  • coefficients – coefficients of the new constraint

  • constant_term – a constant term of the new constraint

  • constraint_type – (default: '<=') a string indicating the constraint type of the new constraint

OUTPUT: an LP problem

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c)
sage: P1 = P.add_constraint(([2, 4]), 2000, "<=")
sage: P1.Abcx()
(
[1 1]
[3 1]
[2 4], (1000, 1500, 2000), (10, 5), (x1, x2)
)
sage: P1.constraint_types()
('<=', '<=', '<=')
sage: P.Abcx()
(
[1 1]
[3 1], (1000, 1500), (10, 5), (x1, x2)
)
sage: P.constraint_types()
('<=', '<=')
sage: P2 = P.add_constraint(([2, 4, 6]), 2000, "<=")
Traceback (most recent call last):
...
TypeError: number of columns must be the same, not 2 and 3
sage: P3 = P.add_constraint(([2, 4]), 2000, "<")
Traceback (most recent call last):
...
ValueError: unknown constraint type

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c)
>>> P1 = P.add_constraint(([Integer(2), Integer(4)]), Integer(2000), "<=")
>>> P1.Abcx()
(
[1 1]
[3 1]
[2 4], (1000, 1500, 2000), (10, 5), (x1, x2)
)
>>> P1.constraint_types()
('<=', '<=', '<=')
>>> P.Abcx()
(
[1 1]
[3 1], (1000, 1500), (10, 5), (x1, x2)
)
>>> P.constraint_types()
('<=', '<=')
>>> P2 = P.add_constraint(([Integer(2), Integer(4), Integer(6)]), Integer(2000), "<=")
Traceback (most recent call last):
...
TypeError: number of columns must be the same, not 2 and 3
>>> P3 = P.add_constraint(([Integer(2), Integer(4)]), Integer(2000), "<")
Traceback (most recent call last):
...
ValueError: unknown constraint type

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c)
P1 = P.add_constraint(([2, 4]), 2000, "<=")
P1.Abcx()
P1.constraint_types()
P.Abcx()
P.constraint_types()
P2 = P.add_constraint(([2, 4, 6]), 2000, "<=")
P3 = P.add_constraint(([2, 4]), 2000, "<")
b()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.constant_terms()
(1000, 1500)
sage: P.b()
(1000, 1500)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.constant_terms()
(1000, 1500)
>>> P.b()
(1000, 1500)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.constant_terms()
P.b()
base_ring()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.base_ring()
Rational Field

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.base_ring()
Rational Field

>>> c = (Integer(10), RealNumber('5.'))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.base_ring()
Real Field with 53 bits of precision

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.base_ring()
c = (10, 5.)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.base_ring()
c()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.objective_coefficients()
(10, 5)
sage: P.c()
(10, 5)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.objective_coefficients()
(10, 5)
>>> P.c()
(10, 5)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.objective_coefficients()
P.c()
constant_terms()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.constant_terms()
(1000, 1500)
sage: P.b()
(1000, 1500)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.constant_terms()
(1000, 1500)
>>> P.b()
(1000, 1500)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.constant_terms()
P.b()
constraint_coefficients()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.constraint_coefficients()
[1 1]
[3 1]
sage: P.A()
[1 1]
[3 1]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.constraint_coefficients()
[1 1]
[3 1]
>>> P.A()
[1 1]
[3 1]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.constraint_coefficients()
P.A()
constraint_types()[source]

Return a tuple listing the constraint types of all rows.

OUTPUT: a tuple of strings

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', constraint_type=["<=", "=="])
sage: P.constraint_types()
('<=', '==')

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', constraint_type=["<=", "=="])
>>> P.constraint_types()
('<=', '==')

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', constraint_type=["<=", "=="])
P.constraint_types()
decision_variables()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.decision_variables()
(C, B)
sage: P.x()
(C, B)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.decision_variables()
(C, B)
>>> P.x()
(C, B)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.decision_variables()
P.x()
dual(y=None)[source]

Construct the dual LP problem for self.

INPUT:

  • y – (default: depends on style()) a vector of dual decision variables or a string giving the base name

OUTPUT: an InteractiveLPProblem

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> DP = P.dual()
>>> DP.b() == P.c()
True
>>> DP.dual(["C", "B"]) == P
True

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
DP = P.dual()
DP.b() == P.c()
DP.dual(["C", "B"]) == P
feasible_set()[source]

Return the feasible set of self.

OUTPUT: a Polyhedron

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(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

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

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.feasible_set()
is_bounded()[source]

Check if self is bounded.

OUTPUT: True if self is bounded, False otherwise

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.is_bounded()
True

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.is_bounded()

Note that infeasible problems are always bounded:

sage: b = (-1000, 1500)
sage: P = InteractiveLPProblem(A, b, c, variable_type='>=')
sage: P.is_feasible()
False
sage: P.is_bounded()
True

>>> from sage.all import *
>>> b = (-Integer(1000), Integer(1500))
>>> P = InteractiveLPProblem(A, b, c, variable_type='>=')
>>> P.is_feasible()
False
>>> P.is_bounded()
True

b = (-1000, 1500)
P = InteractiveLPProblem(A, b, c, variable_type='>=')
P.is_feasible()
P.is_bounded()
is_feasible(*x)[source]

Check if self or given solution is feasible.

INPUT:

  • (optional) anything that can be interpreted as a valid solution for this problem, i.e. a sequence of values for all decision variables

OUTPUT:

  • True is this problem or given solution is feasible, False otherwise

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c, variable_type='>=')
sage: P.is_feasible()
True
sage: P.is_feasible(100, 200)
True
sage: P.is_feasible(1000, 200)
False
sage: P.is_feasible([1000, 200])
False
sage: P.is_feasible(1000)
Traceback (most recent call last):
...
TypeError: given input is not a solution for this problem

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, variable_type='>=')
>>> P.is_feasible()
True
>>> P.is_feasible(Integer(100), Integer(200))
True
>>> P.is_feasible(Integer(1000), Integer(200))
False
>>> P.is_feasible([Integer(1000), Integer(200)])
False
>>> P.is_feasible(Integer(1000))
Traceback (most recent call last):
...
TypeError: given input is not a solution for this problem

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, variable_type='>=')
P.is_feasible()
P.is_feasible(100, 200)
P.is_feasible(1000, 200)
P.is_feasible([1000, 200])
P.is_feasible(1000)
is_negative()[source]

Return True when the problem is of type '-max' or '-min'.

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.is_negative()
False
sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min')
sage: P.is_negative()
True

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.is_negative()
False
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min')
>>> P.is_negative()
True

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.is_negative()
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min')
P.is_negative()
is_optimal(*x)[source]

Check if given solution is feasible.

INPUT:

  • anything that can be interpreted as a valid solution for this problem, i.e. a sequence of values for all decision variables

OUTPUT: True if the given solution is optimal, False otherwise

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (15, 5)
sage: P = InteractiveLPProblem(A, b, c, variable_type='>=')
sage: P.is_optimal(100, 200)
False
sage: P.is_optimal(500, 0)
True
sage: P.is_optimal(499, 3)
True
sage: P.is_optimal(501, -3)
False

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(15), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, variable_type='>=')
>>> P.is_optimal(Integer(100), Integer(200))
False
>>> P.is_optimal(Integer(500), Integer(0))
True
>>> P.is_optimal(Integer(499), Integer(3))
True
>>> P.is_optimal(Integer(501), -Integer(3))
False

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (15, 5)
P = InteractiveLPProblem(A, b, c, variable_type='>=')
P.is_optimal(100, 200)
P.is_optimal(500, 0)
P.is_optimal(499, 3)
P.is_optimal(501, -3)
is_primal()[source]

Check if we consider this problem to be primal or dual.

This distinction affects only some automatically chosen variable names.

OUTPUT: boolean

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.is_primal()
True
>>> P.dual().is_primal()
False

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.is_primal()
P.dual().is_primal()
m()[source]

Return the number of constraints of self, i.e. \(m\).

OUTPUT: integer

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.n_constraints()
2
>>> P.m()
2

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.n_constraints()
P.m()
n()[source]

Return the number of decision variables of self, i.e. \(n\).

OUTPUT: integer

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.n_variables()
2
>>> P.n()
2

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.n_variables()
P.n()
n_constraints()[source]

Return the number of constraints of self, i.e. \(m\).

OUTPUT: integer

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.n_constraints()
2
>>> P.m()
2

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.n_constraints()
P.m()
n_variables()[source]

Return the number of decision variables of self, i.e. \(n\).

OUTPUT: integer

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.n_variables()
2
>>> P.n()
2

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.n_variables()
P.n()
objective_coefficients()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.objective_coefficients()
(10, 5)
sage: P.c()
(10, 5)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.objective_coefficients()
(10, 5)
>>> P.c()
(10, 5)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.objective_coefficients()
P.c()
objective_constant_term()[source]

Return the constant term of the objective.

OUTPUT: a number

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.objective_constant_term()
0
sage: P.optimal_value()
6250
sage: P = InteractiveLPProblem(A, b, c, ["C", "B"],
....:       variable_type='>=', objective_constant_term=-1250)
sage: P.objective_constant_term()
-1250
sage: P.optimal_value()
5000

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.objective_constant_term()
0
>>> P.optimal_value()
6250
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"],
...       variable_type='>=', objective_constant_term=-Integer(1250))
>>> P.objective_constant_term()
-1250
>>> P.optimal_value()
5000

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.objective_constant_term()
P.optimal_value()
P = InteractiveLPProblem(A, b, c, ["C", "B"],
      variable_type='>=', objective_constant_term=-1250)
P.objective_constant_term()
P.optimal_value()
objective_value(*x)[source]

Return the value of the objective on the given solution.

INPUT:

  • anything that can be interpreted as a valid solution for this problem, i.e. a sequence of values for all decision variables

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c, variable_type='>=')
sage: P.objective_value(100, 200)
2000

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, variable_type='>=')
>>> P.objective_value(Integer(100), Integer(200))
2000

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, variable_type='>=')
P.objective_value(100, 200)
optimal_solution()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.optimal_solution()
(250, 750)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.optimal_solution()
(250, 750)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.optimal_solution()
optimal_value()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.optimal_value()
6250

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.optimal_value()
6250

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.optimal_value()
plot(*args, **kwds)[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: p = P.plot()                                                          # needs sage.plot
sage: p.show()                                                              # needs sage.plot

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> p = P.plot()                                                          # needs sage.plot
>>> p.show()                                                              # needs sage.plot

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

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

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

>>> from sage.all import *
>>> p = P.plot(Integer(0), Integer(1000), Integer(0), Integer(1500))                                          # needs sage.plot
>>> p.show()                                                              # needs sage.plot

p = P.plot(0, 1000, 0, 1500)                                          # needs sage.plot
p.show()                                                              # needs sage.plot
plot_feasible_set(xmin=None, xmax=None, ymin=None, ymax=None, alpha=0.2)[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: p = P.plot_feasible_set()                                             # needs sage.plot
sage: p.show()                                                              # needs sage.plot

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> p = P.plot_feasible_set()                                             # needs sage.plot
>>> p.show()                                                              # needs sage.plot

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
p = P.plot_feasible_set()                                             # needs sage.plot
p.show()                                                              # needs sage.plot

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

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

>>> from sage.all import *
>>> p = P.plot_feasible_set(Integer(0), Integer(1000), Integer(0), Integer(1500))                             # needs sage.plot
>>> p.show()                                                              # needs sage.plot

p = P.plot_feasible_set(0, 1000, 0, 1500)                             # needs sage.plot
p.show()                                                              # needs sage.plot
problem_type()[source]

Return the problem type.

Needs to be used together with is_negative.

OUTPUT: string, one of 'max', 'min'

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.problem_type()
'max'
sage: P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min')
sage: P.problem_type()
'min'

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.problem_type()
'max'
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min')
>>> P.problem_type()
'min'

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.problem_type()
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=', problem_type='-min')
P.problem_type()
standard_form(transformation=False, **kwds)[source]

Construct the LP problem in standard form equivalent to self.

INPUT:

  • transformation – boolean (default: False); if True, a map converting solutions of the problem in standard form to the original one will be returned as well

  • you can pass (as keywords only) slack_variables, auxiliary_variable,``objective_name`` to the constructor of InteractiveLPProblemStandardForm

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblem(A, b, c, variable_type='>=')
sage: DP = P.dual()
sage: DPSF = DP.standard_form()
sage: DPSF.b()
(-10, -5)
sage: DPSF.slack_variables()
(y3, y4)
sage: DPSF = DP.standard_form(slack_variables=["L", "F"])
sage: DPSF.slack_variables()
(L, F)
sage: DPSF, f = DP.standard_form(True)
sage: f
Vector space morphism represented by the matrix:
[1 0]
[0 1]
Domain: Vector space of dimension 2 over Rational Field
Codomain: Vector space of dimension 2 over Rational Field

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, variable_type='>=')
>>> DP = P.dual()
>>> DPSF = DP.standard_form()
>>> DPSF.b()
(-10, -5)
>>> DPSF.slack_variables()
(y3, y4)
>>> DPSF = DP.standard_form(slack_variables=["L", "F"])
>>> DPSF.slack_variables()
(L, F)
>>> DPSF, f = DP.standard_form(True)
>>> f
Vector space morphism represented by the matrix:
[1 0]
[0 1]
Domain: Vector space of dimension 2 over Rational Field
Codomain: Vector space of dimension 2 over Rational Field

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, variable_type='>=')
DP = P.dual()
DPSF = DP.standard_form()
DPSF.b()
DPSF.slack_variables()
DPSF = DP.standard_form(slack_variables=["L", "F"])
DPSF.slack_variables()
DPSF, f = DP.standard_form(True)
f

A more complicated transformation map:

sage: P = InteractiveLPProblem(A, b, c, variable_type=["<=", ""],
....:                          objective_constant_term=42)
sage: PSF, f = P.standard_form(True)
sage: f
Vector space morphism represented by the matrix:
[-1  0]
[ 0  1]
[ 0 -1]
Domain: Vector space of dimension 3 over Rational Field
Codomain: Vector space of dimension 2 over Rational Field
sage: PSF.optimal_solution()
(0, 1000, 0)
sage: P.optimal_solution()
(0, 1000)
sage: P.is_optimal(PSF.optimal_solution())
Traceback (most recent call last):
...
TypeError: given input is not a solution for this problem
sage: P.is_optimal(f(PSF.optimal_solution()))
True
sage: PSF.optimal_value()
5042
sage: P.optimal_value()
5042

>>> from sage.all import *
>>> P = InteractiveLPProblem(A, b, c, variable_type=["<=", ""],
...                          objective_constant_term=Integer(42))
>>> PSF, f = P.standard_form(True)
>>> f
Vector space morphism represented by the matrix:
[-1  0]
[ 0  1]
[ 0 -1]
Domain: Vector space of dimension 3 over Rational Field
Codomain: Vector space of dimension 2 over Rational Field
>>> PSF.optimal_solution()
(0, 1000, 0)
>>> P.optimal_solution()
(0, 1000)
>>> P.is_optimal(PSF.optimal_solution())
Traceback (most recent call last):
...
TypeError: given input is not a solution for this problem
>>> P.is_optimal(f(PSF.optimal_solution()))
True
>>> PSF.optimal_value()
5042
>>> P.optimal_value()
5042

P = InteractiveLPProblem(A, b, c, variable_type=["<=", ""],
                         objective_constant_term=42)
PSF, f = P.standard_form(True)
f
PSF.optimal_solution()
P.optimal_solution()
P.is_optimal(PSF.optimal_solution())
P.is_optimal(f(PSF.optimal_solution()))
PSF.optimal_value()
P.optimal_value()
variable_types()[source]

Return a tuple listing the variable types of all decision variables.

OUTPUT: a tuple of strings

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type=[">=", ""])
>>> P.variable_types()
('>=', '')

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type=[">=", ""])
P.variable_types()
x()[source]

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 = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
sage: P.decision_variables()
(C, B)
sage: P.x()
(C, B)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
>>> P.decision_variables()
(C, B)
>>> P.x()
(C, B)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblem(A, b, c, ["C", "B"], variable_type='>=')
P.decision_variables()
P.x()
class sage.numerical.interactive_simplex_method.InteractiveLPProblemStandardForm(A, b, c, x='x', problem_type='max', slack_variables=None, auxiliary_variable=None, base_ring=None, is_primal=True, objective_name=None, objective_constant_term=0)[source]

Bases: InteractiveLPProblem

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

Note

This class is for educational purposes only: if you want to solve Linear Programs efficiently, use MixedIntegerLinearProgram instead.

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: depends on style()) a vector of slack variables or a string 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

  • base_ring – (default: the fraction field of a common ring for all input coefficients) a field to which all input coefficients will be converted

  • is_primal – boolean (default: True); whether this problem is primal or dual: each problem is of course dual to its own dual, this flag is mostly for internal use and affects default variable names only

  • objective_name – string or symbolic expression for the objective used in dictionaries (default: depends on style())

  • objective_constant_term – (default: 0) a constant term of the objective

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)

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

Unlike InteractiveLPProblem, 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)

>>> from sage.all import *
>>> P.decision_variables()
(x1, x2)
>>> P.slack_variables()
(x3, x4)

P.decision_variables()
P.slack_variables()
add_constraint(coefficients, constant_term, slack_variable=None)[source]

Return a new LP problem by adding a constraint to``self``.

INPUT:

  • coefficients – coefficients of the new constraint

  • constant_term – a constant term of the new constraint

  • slack_variable – (default: depends on style()) a string giving the name of the slack variable of the new constraint

OUTPUT: an LP problem in standard form

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: P.Abcx()
(
[1 1]
[3 1], (1000, 1500), (10, 5), (x1, x2)
)
sage: P.slack_variables()
(x3, x4)
sage: P1 = P.add_constraint(([2, 4]), 2000)
sage: P1.Abcx()
(
[1 1]
[3 1]
[2 4], (1000, 1500, 2000), (10, 5), (x1, x2)
)
sage: P1.slack_variables()
(x3, x4, x5)
sage: P2 = P.add_constraint(([2, 4]), 2000, slack_variable='c')
sage: P2.slack_variables()
(x3, x4, c)
sage: P3 = P.add_constraint(([2, 4, 6]), 2000)
Traceback (most recent call last):
...
TypeError: number of columns must be the same, not 2 and 3

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.Abcx()
(
[1 1]
[3 1], (1000, 1500), (10, 5), (x1, x2)
)
>>> P.slack_variables()
(x3, x4)
>>> P1 = P.add_constraint(([Integer(2), Integer(4)]), Integer(2000))
>>> P1.Abcx()
(
[1 1]
[3 1]
[2 4], (1000, 1500, 2000), (10, 5), (x1, x2)
)
>>> P1.slack_variables()
(x3, x4, x5)
>>> P2 = P.add_constraint(([Integer(2), Integer(4)]), Integer(2000), slack_variable='c')
>>> P2.slack_variables()
(x3, x4, c)
>>> P3 = P.add_constraint(([Integer(2), Integer(4), Integer(6)]), Integer(2000))
Traceback (most recent call last):
...
TypeError: number of columns must be the same, not 2 and 3

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
P.Abcx()
P.slack_variables()
P1 = P.add_constraint(([2, 4]), 2000)
P1.Abcx()
P1.slack_variables()
P2 = P.add_constraint(([2, 4]), 2000, slack_variable='c')
P2.slack_variables()
P3 = P.add_constraint(([2, 4, 6]), 2000)
auxiliary_problem(objective_name=None)[source]

Construct the auxiliary problem for self.

INPUT:

  • objective_name – string or symbolic expression for the objective used in dictionaries (default: depends on style())

OUTPUT: an LP problem in standard form

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: AP = P.auxiliary_problem()

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> AP = P.auxiliary_problem()

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
AP = P.auxiliary_problem()
auxiliary_variable()[source]

Return the auxiliary variable of self.

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

OUTPUT: a variable of the coordinate_ring() of self

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(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)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.auxiliary_variable()
x0
>>> P.decision_variables()
(x1, x2)
>>> AP = P.auxiliary_problem()
>>> AP.auxiliary_variable()
x0
>>> AP.decision_variables()
(x0, x1, x2)

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
P.auxiliary_variable()
P.decision_variables()
AP = P.auxiliary_problem()
AP.auxiliary_variable()
AP.decision_variables()
coordinate_ring()[source]

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 = InteractiveLPProblemStandardForm(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)

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

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
P.coordinate_ring()
P.base_ring()
P.auxiliary_variable()
P.decision_variables()
P.slack_variables()
dictionary(*x_B)[source]

Construct a dictionary for self with given basic variables.

INPUT:

  • basic variables for the dictionary to be constructed

OUTPUT: a dictionary

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.dictionary("x1", "x2")
sage: D.basic_variables()
(x1, x2)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.dictionary("x1", "x2")
>>> D.basic_variables()
(x1, x2)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.dictionary("x1", "x2")
D.basic_variables()
feasible_dictionary(auxiliary_dictionary)[source]

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: a feasible dictionary for self

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(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)

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

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
AP = P.auxiliary_problem()
D = AP.initial_dictionary()
D.enter(0)
D.leave(5)
D.update()
D.enter(1)
D.leave(0)
D.update()
D.is_optimal()
D.objective_value()
D.basic_solution()
D = P.feasible_dictionary(D)
D.is_optimal()
D.is_feasible()
D.objective_value()
D.basic_solution()
final_dictionary()[source]

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

See run_simplex_method() for the description of possibilities.

OUTPUT: a dictionary

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.final_dictionary()
>>> D.is_optimal()
True

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.final_dictionary()
D.is_optimal()
final_revised_dictionary()[source]

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

See run_revised_simplex_method() for the description of possibilities.

OUTPUT: a revised dictionary

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.final_revised_dictionary()
>>> D.is_optimal()
True

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.final_revised_dictionary()
D.is_optimal()
initial_dictionary()[source]

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: a dictionary

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
inject_variables(scope=None, verbose=True)[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: P.inject_variables()
Defining x0, x1, x2, x3, x4
sage: 3*x1 + x2
x2 + 3*x1

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.inject_variables()
Defining x0, x1, x2, x3, x4
>>> Integer(3)*x1 + x2
x2 + 3*x1

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
P.inject_variables()
3*x1 + x2
objective_name()[source]

Return the objective name used in dictionaries for this problem.

OUTPUT: a symbolic expression

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: P.objective_name()
z
sage: sage.numerical.interactive_simplex_method.style("Vanderbei")
'Vanderbei'
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: P.objective_name()
zeta
sage: sage.numerical.interactive_simplex_method.style("UAlberta")
'UAlberta'
sage: P = InteractiveLPProblemStandardForm(A, b, c, objective_name='custom')
sage: P.objective_name()
custom

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.objective_name()
z
>>> sage.numerical.interactive_simplex_method.style("Vanderbei")
'Vanderbei'
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.objective_name()
zeta
>>> sage.numerical.interactive_simplex_method.style("UAlberta")
'UAlberta'
>>> P = InteractiveLPProblemStandardForm(A, b, c, objective_name='custom')
>>> P.objective_name()
custom

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
P.objective_name()
sage.numerical.interactive_simplex_method.style("Vanderbei")
P = InteractiveLPProblemStandardForm(A, b, c)
P.objective_name()
sage.numerical.interactive_simplex_method.style("UAlberta")
P = InteractiveLPProblemStandardForm(A, b, c, objective_name='custom')
P.objective_name()
static random_element(m, n, bound=5, special_probability=0.2, **kwds)[source]

Construct a random InteractiveLPProblemStandardForm.

INPUT:

  • m – the number of constraints/basic variables

  • n – the number of decision/non-basic variables

  • bound – (default: 5) a bound on coefficients

  • special_probability – (default: 0.2) probability of constructing a problem whose initial dictionary is allowed to be primal infeasible or dual feasible

All other keyword arguments are passed to the constructor.

EXAMPLES:

sage: InteractiveLPProblemStandardForm.random_element(3, 4)
LP problem (use 'view(...)' or '%display typeset' for details)

>>> from sage.all import *
>>> InteractiveLPProblemStandardForm.random_element(Integer(3), Integer(4))
LP problem (use 'view(...)' or '%display typeset' for details)

InteractiveLPProblemStandardForm.random_element(3, 4)
revised_dictionary(*x_B)[source]

Construct a revised dictionary for self.

INPUT:

OUTPUT: a revised dictionary

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary("x1", "x2")
>>> D.basic_variables()
(x1, x2)

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

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)

>>> from sage.all import *
>>> P.revised_dictionary().basic_variables()
(x3, x4)
>>> P.initial_dictionary().basic_variables()
(x3, x4)

P.revised_dictionary().basic_variables()
P.initial_dictionary().basic_variables()

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: P.initial_dictionary().is_feasible()
False
sage: P.revised_dictionary().basic_variables()
(x3, x4, x0)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1),-Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.initial_dictionary().is_feasible()
False
>>> P.revised_dictionary().basic_variables()
(x3, x4, x0)

A = ([1, 1], [3, 1], [-1,-1])
b = (1000, 1500, -400)
P = InteractiveLPProblemStandardForm(A, b, c)
P.initial_dictionary().is_feasible()
P.revised_dictionary().basic_variables()
run_revised_simplex_method()[source]

Apply the revised simplex method and return all steps.

OUTPUT:

  • HtmlFragment with HTML/\(\LaTeX\) code of all encountered 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 nonzero 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 = InteractiveLPProblemStandardForm(A, b, c)
sage: P.run_revised_simplex_method()
\begin{equation*}
...
\end{equation*}
Entering: $x_{1}$. Leaving: $x_{0}$.
\begin{equation*}
...
\end{equation*}
Entering: $x_{5}$. Leaving: $x_{4}$.
\begin{equation*}
...
\end{equation*}
Entering: $x_{2}$. Leaving: $x_{3}$.
\begin{equation*}
...
\end{equation*}
The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.run_revised_simplex_method()
\begin{equation*}
...
\end{equation*}
Entering: $x_{1}$. Leaving: $x_{0}$.
\begin{equation*}
...
\end{equation*}
Entering: $x_{5}$. Leaving: $x_{4}$.
\begin{equation*}
...
\end{equation*}
Entering: $x_{2}$. Leaving: $x_{3}$.
\begin{equation*}
...
\end{equation*}
The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
P.run_revised_simplex_method()
run_simplex_method()[source]

Apply the simplex method and return all steps and intermediate states.

OUTPUT:

  • HtmlFragment with HTML/\(\LaTeX\) code of all encountered dictionaries

Note

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

  • an optimal dictionary for the auxiliary_problem() with a nonzero 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 = InteractiveLPProblemStandardForm(A, b, c)
sage: P.run_simplex_method()
\begin{equation*}
...
\end{equation*}
The initial dictionary is infeasible, solving auxiliary problem.
...
Entering: $x_{0}$. Leaving: $x_{5}$.
...
Entering: $x_{1}$. Leaving: $x_{0}$.
...
Back to the original problem.
...
Entering: $x_{5}$. Leaving: $x_{4}$.
...
Entering: $x_{2}$. Leaving: $x_{3}$.
...
The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.run_simplex_method()
\begin{equation*}
...
\end{equation*}
The initial dictionary is infeasible, solving auxiliary problem.
...
Entering: $x_{0}$. Leaving: $x_{5}$.
...
Entering: $x_{1}$. Leaving: $x_{0}$.
...
Back to the original problem.
...
Entering: $x_{5}$. Leaving: $x_{4}$.
...
Entering: $x_{2}$. Leaving: $x_{3}$.
...
The optimal value: $6250$. An optimal solution: $\left(250,\,750\right)$.

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
P.run_simplex_method()
slack_variables()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: P.slack_variables()
(x3, x4)
sage: P = InteractiveLPProblemStandardForm(A, b, c, ["C", "B"],
....:     slack_variables=["L", "F"])
sage: P.slack_variables()
(L, F)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> P.slack_variables()
(x3, x4)
>>> P = InteractiveLPProblemStandardForm(A, b, c, ["C", "B"],
...     slack_variables=["L", "F"])
>>> P.slack_variables()
(L, F)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
P.slack_variables()
P = InteractiveLPProblemStandardForm(A, b, c, ["C", "B"],
    slack_variables=["L", "F"])
P.slack_variables()
class sage.numerical.interactive_simplex_method.LPAbstractDictionary[source]

Bases: SageObject

Abstract base class for dictionaries for LP problems.

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

add_row(nonbasic_coefficients, constant, basic_variable=None)[source]

Return a dictionary with an additional row based on a given dictionary.

INPUT:

  • nonbasic_coefficients – list of the coefficients for the new row (with which nonbasic variables are subtracted in the relation for the new basic variable)

  • constant – the constant term for the new row

  • basic_variable – (default: depends on style()) a string giving the name of the basic variable of the new row

OUTPUT: a new dictionary of the same class

EXAMPLES:

sage: A = ([-1, 1, 7], [8, 2, 13], [34, 17, 12])
sage: b = (2, 17, 6)
sage: c = (55/10, 21/10, 14/30)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.dictionary("x1", "x2", "x4")
sage: D1 = D.add_row([7, 11, 19], 42, basic_variable='c')
sage: D1.row_coefficients("c")
(7, 11, 19)

>>> from sage.all import *
>>> A = ([-Integer(1), Integer(1), Integer(7)], [Integer(8), Integer(2), Integer(13)], [Integer(34), Integer(17), Integer(12)])
>>> b = (Integer(2), Integer(17), Integer(6))
>>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10), Integer(14)/Integer(30))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.dictionary("x1", "x2", "x4")
>>> D1 = D.add_row([Integer(7), Integer(11), Integer(19)], Integer(42), basic_variable='c')
>>> D1.row_coefficients("c")
(7, 11, 19)

A = ([-1, 1, 7], [8, 2, 13], [34, 17, 12])
b = (2, 17, 6)
c = (55/10, 21/10, 14/30)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.dictionary("x1", "x2", "x4")
D1 = D.add_row([7, 11, 19], 42, basic_variable='c')
D1.row_coefficients("c")
base_ring()[source]

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 = InteractiveLPProblemStandardForm(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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.base_ring()
Rational Field
>>> D = P.revised_dictionary()
>>> D.base_ring()
Rational Field

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.base_ring()
D = P.revised_dictionary()
D.base_ring()
basic_solution(include_slack_variables=False)[source]

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 – boolean (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 = InteractiveLPProblemStandardForm(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)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.basic_solution()
(0, 0)
>>> D.basic_solution(True)
(0, 0, 1000, 1500)
>>> D = P.revised_dictionary()
>>> D.basic_solution()
(0, 0)
>>> D.basic_solution(True)
(0, 0, 1000, 1500)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.basic_solution()
D.basic_solution(True)
D = P.revised_dictionary()
D.basic_solution()
D.basic_solution(True)
basic_variables()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.basic_variables()
(x3, x4)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.basic_variables()
(x3, x4)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.basic_variables()
column_coefficients(v)[source]

Return the coefficients of a nonbasic variable.

INPUT:

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

OUTPUT: a vector of coefficients of a nonbasic variable

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.column_coefficients(Integer(1))
(1, 3)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.column_coefficients(1)
constant_terms()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.constant_terms()
(1000, 1500)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.constant_terms()
(1000, 1500)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.constant_terms()
coordinate_ring()[source]

Return the coordinate ring of self.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.coordinate_ring()
Multivariate Polynomial Ring in x0, x1, x2, x3, x4
over Rational Field
>>> D = P.revised_dictionary()
>>> D.coordinate_ring()
Multivariate Polynomial Ring in x0, x1, x2, x3, x4
over Rational Field

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.coordinate_ring()
D = P.revised_dictionary()
D.coordinate_ring()
dual_ratios()[source]

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 = InteractiveLPProblemStandardForm(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)]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.dictionary(Integer(2), Integer(3), Integer(5))
>>> D.leave(Integer(3))
>>> D.dual_ratios()
[(5/2, x1), (5, x4)]
>>> D = P.revised_dictionary(Integer(2), Integer(3), Integer(5))
>>> D.leave(Integer(3))
>>> D.dual_ratios()
[(5/2, x1), (5, x4)]

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.dictionary(2, 3, 5)
D.leave(3)
D.dual_ratios()
D = P.revised_dictionary(2, 3, 5)
D.leave(3)
D.dual_ratios()
enter(v)[source]

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. It is also possible to enter None to reset choice.

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.enter("x1")

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.enter("x1")

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

We can also use indices of variables:

sage: D.enter(1)

>>> from sage.all import *
>>> D.enter(Integer(1))

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)

>>> from sage.all import *
>>> P.inject_variables()
Defining x0, x1, x2, x3, x4
>>> D.enter(x1)

P.inject_variables()
D.enter(x1)

The same works for revised dictionaries as well:

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

>>> from sage.all import *
>>> D = P.revised_dictionary()
>>> D.enter(x1)

D = P.revised_dictionary()
D.enter(x1)
entering()[source]

Return the currently chosen entering variable.

OUTPUT: a variable if the entering one was chosen, otherwise None

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.entering() is None
True
sage: D.enter(1)
sage: D.entering()
x1

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.entering() is None
True
>>> D.enter(Integer(1))
>>> D.entering()
x1

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.entering() is None
D.enter(1)
D.entering()
entering_coefficients()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.enter(1)
sage: D.entering_coefficients()
(1, 3)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.enter(Integer(1))
>>> D.entering_coefficients()
(1, 3)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.enter(1)
D.entering_coefficients()
is_dual_feasible()[source]

Check if self is dual feasible.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.is_dual_feasible()
False
>>> D = P.revised_dictionary()
>>> D.is_dual_feasible()
False

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.is_dual_feasible()
D = P.revised_dictionary()
D.is_dual_feasible()
is_feasible()[source]

Check if self is feasible.

OUTPUT:

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.is_feasible()
True
>>> D = P.revised_dictionary()
>>> D.is_feasible()
True

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.is_feasible()
D = P.revised_dictionary()
D.is_feasible()
is_optimal()[source]

Check if self is optimal.

OUTPUT:

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.is_optimal()
False
>>> D = P.revised_dictionary()
>>> D.is_optimal()
False
>>> D = P.revised_dictionary(Integer(1), Integer(2))
>>> D.is_optimal()
True

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.is_optimal()
D = P.revised_dictionary()
D.is_optimal()
D = P.revised_dictionary(1, 2)
D.is_optimal()
leave(v)[source]

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. It is also possible to leave None to reset choice.

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.leave("x4")

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.leave("x4")

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

We can also use indices of variables:

sage: D.leave(4)

>>> from sage.all import *
>>> D.leave(Integer(4))

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)

>>> from sage.all import *
>>> P.inject_variables()
Defining x0, x1, x2, x3, x4
>>> D.leave(x4)

P.inject_variables()
D.leave(x4)

The same works for revised dictionaries as well:

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

>>> from sage.all import *
>>> D = P.revised_dictionary()
>>> D.leave(x4)

D = P.revised_dictionary()
D.leave(x4)
leaving()[source]

Return the currently chosen leaving variable.

OUTPUT: a variable if the leaving one was chosen, otherwise None

EXAMPLES:

sage: A = ([1, 1], [3, 1])
sage: b = (1000, 1500)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.leaving() is None
True
sage: D.leave(4)
sage: D.leaving()
x4

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.leaving() is None
True
>>> D.leave(Integer(4))
>>> D.leaving()
x4

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.leaving() is None
D.leave(4)
D.leaving()
leaving_coefficients()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.dictionary(2, 3)
sage: D.leave(3)
sage: D.leaving_coefficients()
(-2, -1)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.dictionary(Integer(2), Integer(3))
>>> D.leave(Integer(3))
>>> D.leaving_coefficients()
(-2, -1)

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

The same works for revised dictionaries as well:

sage: D = P.revised_dictionary(2, 3)
sage: D.leave(3)
sage: D.leaving_coefficients()
(-2, -1)

>>> from sage.all import *
>>> D = P.revised_dictionary(Integer(2), Integer(3))
>>> D.leave(Integer(3))
>>> D.leaving_coefficients()
(-2, -1)

D = P.revised_dictionary(2, 3)
D.leave(3)
D.leaving_coefficients()
nonbasic_variables()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.nonbasic_variables()
(x1, x2)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.nonbasic_variables()
(x1, x2)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.nonbasic_variables()
objective_coefficients()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.objective_coefficients()
(10, 5)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.objective_coefficients()
(10, 5)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.objective_coefficients()
objective_name()[source]

Return the objective name of self.

OUTPUT: a symbolic expression

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.objective_name()
z

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.objective_name()
objective_value()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.objective_value()
0

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.objective_value()
0

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.objective_value()
possible_dual_simplex_method_steps()[source]

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 = InteractiveLPProblemStandardForm(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])]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.dictionary(Integer(2), Integer(3))
>>> D.possible_dual_simplex_method_steps()
[(x3, [x1])]
>>> D = P.revised_dictionary(Integer(2), Integer(3))
>>> D.possible_dual_simplex_method_steps()
[(x3, [x1])]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.dictionary(2, 3)
D.possible_dual_simplex_method_steps()
D = P.revised_dictionary(2, 3)
D.possible_dual_simplex_method_steps()
possible_entering()[source]

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 = InteractiveLPProblemStandardForm(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]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.possible_entering()
[x1, x2]
>>> D = P.revised_dictionary()
>>> D.possible_entering()
[x1, x2]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.possible_entering()
D = P.revised_dictionary()
D.possible_entering()
possible_leaving()[source]

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 = InteractiveLPProblemStandardForm(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]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.enter(Integer(1))
>>> D.possible_leaving()
[x4]
>>> D = P.revised_dictionary()
>>> D.enter(Integer(1))
>>> D.possible_leaving()
[x4]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.enter(1)
D.possible_leaving()
D = P.revised_dictionary()
D.enter(1)
D.possible_leaving()
possible_simplex_method_steps()[source]

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 = InteractiveLPProblemStandardForm(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])]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.possible_simplex_method_steps()
[(x1, [x4]), (x2, [x3])]
>>> D = P.revised_dictionary()
>>> D.possible_simplex_method_steps()
[(x1, [x4]), (x2, [x3])]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.possible_simplex_method_steps()
D = P.revised_dictionary()
D.possible_simplex_method_steps()
ratios()[source]

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 = InteractiveLPProblemStandardForm(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)]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.enter(Integer(1))
>>> D.ratios()
[(1000, x3), (500, x4)]
>>> D = P.revised_dictionary()
>>> D.enter(Integer(1))
>>> D.ratios()
[(1000, x3), (500, x4)]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.enter(1)
D.ratios()
D = P.revised_dictionary()
D.enter(1)
D.ratios()
row_coefficients(v)[source]

Return the coefficients of the basic variable v.

These are the coefficients with which nonbasic variables are subtracted in the relation for v.

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: a vector of coefficients of a basic variable

EXAMPLES:

sage: A = ([-1, 1], [8, 2])
sage: b = (2, 17)
sage: c = (55/10, 21/10)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.final_dictionary()
sage: D.row_coefficients("x1")
(1/10, -1/5)

>>> from sage.all import *
>>> A = ([-Integer(1), Integer(1)], [Integer(8), Integer(2)])
>>> b = (Integer(2), Integer(17))
>>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.final_dictionary()
>>> D.row_coefficients("x1")
(1/10, -1/5)

A = ([-1, 1], [8, 2])
b = (2, 17)
c = (55/10, 21/10)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.final_dictionary()
D.row_coefficients("x1")

We can also use indices of variables:

sage: D.row_coefficients(1)
(1/10, -1/5)

>>> from sage.all import *
>>> D.row_coefficients(Integer(1))
(1/10, -1/5)

D.row_coefficients(1)

Or use variable names without quotes after injecting them:

sage: P.inject_variables()
Defining x0, x1, x2, x3, x4
sage: D.row_coefficients(x1)
(1/10, -1/5)

>>> from sage.all import *
>>> P.inject_variables()
Defining x0, x1, x2, x3, x4
>>> D.row_coefficients(x1)
(1/10, -1/5)

P.inject_variables()
D.row_coefficients(x1)
run_dual_simplex_method()[source]

Apply the dual simplex method and return all steps/intermediate states.

If either entering or leaving variables were already set, they will be used.

OUTPUT:

  • HtmlFragment with HTML/\(\LaTeX\) code of all encountered dictionaries

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.run_dual_simplex_method()
Traceback (most recent call last):
...
ValueError: leaving variables can be determined for feasible
dictionaries with a set entering variable or for dual feasible
dictionaries

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.run_dual_simplex_method()
Traceback (most recent call last):
...
ValueError: leaving variables can be determined for feasible
dictionaries with a set entering variable or for dual feasible
dictionaries

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.run_dual_simplex_method()

Let’s start with a dual feasible dictionary then:

sage: D = P.dictionary(2, 3, 5)
sage: D.is_dual_feasible()
True
sage: D.is_optimal()
False
sage: D.run_dual_simplex_method()
\begin{equation*}
...
\end{equation*}
Leaving: $x_{3}$. Entering: $x_{1}$.
\begin{equation*}
...
\end{equation*}
sage: D.is_optimal()
True

>>> from sage.all import *
>>> D = P.dictionary(Integer(2), Integer(3), Integer(5))
>>> D.is_dual_feasible()
True
>>> D.is_optimal()
False
>>> D.run_dual_simplex_method()
\begin{equation*}
...
\end{equation*}
Leaving: $x_{3}$. Entering: $x_{1}$.
\begin{equation*}
...
\end{equation*}
>>> D.is_optimal()
True

D = P.dictionary(2, 3, 5)
D.is_dual_feasible()
D.is_optimal()
D.run_dual_simplex_method()
D.is_optimal()

This method detects infeasible problems:

sage: A = ([1, 0],)
sage: b = (-1,)
sage: c = (0, -1)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.run_dual_simplex_method()
\begin{equation*}
...
\end{equation*}
The problem is infeasible because of $x_{3}$ constraint.

>>> from sage.all import *
>>> A = ([Integer(1), Integer(0)],)
>>> b = (-Integer(1),)
>>> c = (Integer(0), -Integer(1))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.run_dual_simplex_method()
\begin{equation*}
...
\end{equation*}
The problem is infeasible because of $x_{3}$ constraint.

A = ([1, 0],)
b = (-1,)
c = (0, -1)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.run_dual_simplex_method()
run_simplex_method()[source]

Apply the simplex method and return all steps and intermediate states.

If either entering or leaving variables were already set, they will be used.

OUTPUT:

  • HtmlFragment with HTML/\(\LaTeX\) code of all encountered dictionaries

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.run_simplex_method()
Traceback (most recent call last):
...
ValueError: entering variables can be determined for feasible
dictionaries or for dual feasible dictionaries with a set leaving
variable

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.run_simplex_method()
Traceback (most recent call last):
...
ValueError: entering variables can be determined for feasible
dictionaries or for dual feasible dictionaries with a set leaving
variable

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.run_simplex_method()

Let’s start with a feasible dictionary then:

sage: D = P.dictionary(1, 3, 4)
sage: D.is_feasible()
True
sage: D.is_optimal()
False
sage: D.run_simplex_method()
\begin{equation*}
...
\end{equation*}
Entering: $x_{5}$. Leaving: $x_{4}$.
\begin{equation*}
...
\end{equation*}
Entering: $x_{2}$. Leaving: $x_{3}$.
\begin{equation*}
...
\end{equation*}
sage: D.is_optimal()
True

>>> from sage.all import *
>>> D = P.dictionary(Integer(1), Integer(3), Integer(4))
>>> D.is_feasible()
True
>>> D.is_optimal()
False
>>> D.run_simplex_method()
\begin{equation*}
...
\end{equation*}
Entering: $x_{5}$. Leaving: $x_{4}$.
\begin{equation*}
...
\end{equation*}
Entering: $x_{2}$. Leaving: $x_{3}$.
\begin{equation*}
...
\end{equation*}
>>> D.is_optimal()
True

D = P.dictionary(1, 3, 4)
D.is_feasible()
D.is_optimal()
D.run_simplex_method()
D.is_optimal()

This method detects unbounded problems:

sage: A = ([1, 0],)
sage: b = (1,)
sage: c = (0, 1)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.run_simplex_method()
\begin{equation*}
...
\end{equation*}
The problem is unbounded in $x_{2}$ direction.

>>> from sage.all import *
>>> A = ([Integer(1), Integer(0)],)
>>> b = (Integer(1),)
>>> c = (Integer(0), Integer(1))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.run_simplex_method()
\begin{equation*}
...
\end{equation*}
The problem is unbounded in $x_{2}$ direction.

A = ([1, 0],)
b = (1,)
c = (0, 1)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.run_simplex_method()
update()[source]

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 = InteractiveLPProblemStandardForm(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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.objective_value()
0
>>> D.enter("x1")
>>> D.leave("x4")
>>> D.update()
>>> D.objective_value()
5000

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.objective_value()
D.enter("x1")
D.leave("x4")
D.update()
D.objective_value()
class sage.numerical.interactive_simplex_method.LPDictionary(A, b, c, objective_value, basic_variables, nonbasic_variables, objective_name)[source]

Bases: LPAbstractDictionary

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 – list of basic variables \(x_B\)

  • nonbasic_variables – list of non-basic variables \(x_N\)

  • objective_name – a “name” for the objective \(z\)

OUTPUT: a dictionary for an LP problem

Note

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

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D
LP problem dictionary (use ...)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D
LP problem dictionary (use ...)

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

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

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

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

Return a dictionary with an additional row based on a given dictionary.

INPUT:

  • nonbasic_coefficients – list of the coefficients for the new row (with which nonbasic variables are subtracted in the relation for the new basic variable)

  • constant – the constant term for the new row

  • basic_variable – (default: depends on style()) a string giving the name of the basic variable of the new row

OUTPUT: a dictionary

EXAMPLES:

sage: A = ([-1, 1, 7], [8, 2, 13], [34, 17, 12])
sage: b = (2, 17, 6)
sage: c = (55/10, 21/10, 14/30)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.dictionary("x1", "x2", "x4")
sage: D1 = D.add_row([7, 11, 19], 42, basic_variable='c')
sage: D1.row_coefficients("c")
(7, 11, 19)
sage: D1.constant_terms()[-1]
42
sage: D1.basic_variables()[-1]
c

>>> from sage.all import *
>>> A = ([-Integer(1), Integer(1), Integer(7)], [Integer(8), Integer(2), Integer(13)], [Integer(34), Integer(17), Integer(12)])
>>> b = (Integer(2), Integer(17), Integer(6))
>>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10), Integer(14)/Integer(30))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.dictionary("x1", "x2", "x4")
>>> D1 = D.add_row([Integer(7), Integer(11), Integer(19)], Integer(42), basic_variable='c')
>>> D1.row_coefficients("c")
(7, 11, 19)
>>> D1.constant_terms()[-Integer(1)]
42
>>> D1.basic_variables()[-Integer(1)]
c

A = ([-1, 1, 7], [8, 2, 13], [34, 17, 12])
b = (2, 17, 6)
c = (55/10, 21/10, 14/30)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.dictionary("x1", "x2", "x4")
D1 = D.add_row([7, 11, 19], 42, basic_variable='c')
D1.row_coefficients("c")
D1.constant_terms()[-1]
D1.basic_variables()[-1]
basic_variables()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.basic_variables()
(x3, x4)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.basic_variables()
(x3, x4)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.basic_variables()
column_coefficients(v)[source]

Return coefficients of a nonbasic variable.

INPUT:

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

OUTPUT: a vector

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.column_coefficients(Integer(1))
(1, 3)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.column_coefficients(1)
constant_terms()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.constant_terms()
(1000, 1500)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.constant_terms()
(1000, 1500)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.constant_terms()
nonbasic_variables()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.nonbasic_variables()
(x1, x2)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.nonbasic_variables()
(x1, x2)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.nonbasic_variables()
objective_coefficients()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.objective_coefficients()
(10, 5)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.objective_coefficients()
(10, 5)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.objective_coefficients()
objective_name()[source]

Return the objective name of self.

OUTPUT: a symbolic expression

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.objective_name()
z

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.objective_name()
objective_value()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.initial_dictionary()
sage: D.objective_value()
0

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.objective_value()
0

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.objective_value()
static random_element(m, n, bound=5, special_probability=0.2)[source]

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: an LP problem dictionary

EXAMPLES:

sage: from sage.numerical.interactive_simplex_method \
....:     import random_dictionary
sage: random_dictionary(3, 4)  # indirect doctest
LP problem dictionary (use 'view(...)' or '%display typeset' for details)

>>> from sage.all import *
>>> from sage.numerical.interactive_simplex_method     import random_dictionary
>>> random_dictionary(Integer(3), Integer(4))  # indirect doctest
LP problem dictionary (use 'view(...)' or '%display typeset' for details)

from sage.numerical.interactive_simplex_method \
    import random_dictionary
random_dictionary(3, 4)  # indirect doctest
row_coefficients(v)[source]

Return the coefficients of the basic variable v.

These are the coefficients with which nonbasic variables are subtracted in the relation for v.

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: a vector of coefficients of a basic variable

EXAMPLES:

sage: A = ([-1, 1], [8, 2])
sage: b = (2, 17)
sage: c = (55/10, 21/10)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.final_dictionary()
sage: D.row_coefficients("x1")
(1/10, -1/5)

>>> from sage.all import *
>>> A = ([-Integer(1), Integer(1)], [Integer(8), Integer(2)])
>>> b = (Integer(2), Integer(17))
>>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.final_dictionary()
>>> D.row_coefficients("x1")
(1/10, -1/5)

A = ([-1, 1], [8, 2])
b = (2, 17)
c = (55/10, 21/10)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.final_dictionary()
D.row_coefficients("x1")

We can also use indices of variables:

sage: D.row_coefficients(1)
(1/10, -1/5)

>>> from sage.all import *
>>> D.row_coefficients(Integer(1))
(1/10, -1/5)

D.row_coefficients(1)

Or use variable names without quotes after injecting them:

sage: P.inject_variables()
Defining x0, x1, x2, x3, x4
sage: D.row_coefficients(x1)
(1/10, -1/5)

>>> from sage.all import *
>>> P.inject_variables()
Defining x0, x1, x2, x3, x4
>>> D.row_coefficients(x1)
(1/10, -1/5)

P.inject_variables()
D.row_coefficients(x1)
update()[source]

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 = InteractiveLPProblemStandardForm(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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.initial_dictionary()
>>> D.objective_value()
0
>>> D.enter("x1")
>>> D.leave("x4")
>>> D.update()
>>> D.objective_value()
5000

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.initial_dictionary()
D.objective_value()
D.enter("x1")
D.leave("x4")
D.update()
D.objective_value()
class sage.numerical.interactive_simplex_method.LPRevisedDictionary(problem, basic_variables)[source]

Bases: LPAbstractDictionary

Construct a revised dictionary for an LP problem.

INPUT:

OUTPUT: a revised dictionary for an LP problem

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 = InteractiveLPProblemStandardForm(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 ...)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> from sage.numerical.interactive_simplex_method     import LPRevisedDictionary
>>> D = LPRevisedDictionary(P, [Integer(1), Integer(2)])
>>> D.basic_variables()
(x1, x2)
>>> D
LP problem dictionary (use ...)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
from sage.numerical.interactive_simplex_method \
    import LPRevisedDictionary
D = LPRevisedDictionary(P, [1, 2])
D.basic_variables()
D

The same dictionary can be constructed through the problem:

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

>>> from sage.all import *
>>> P.revised_dictionary(Integer(1), Integer(2)) == D
True

P.revised_dictionary(1, 2) == D

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 & & \mspace{-16mu} 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 \\ \hline 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)[source]

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 = InteractiveLPProblemStandardForm(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)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.A(Integer(1))
(1, 3)
>>> D.A(Integer(0))
(-1, -1)
>>> D.A("x3")
(1, 0)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.A(1)
D.A(0)
D.A("x3")
A_N()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.A_N()
[1 1]
[3 1]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.A_N()
[1 1]
[3 1]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.A_N()
B()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary(1, 2)
sage: D.B()
[1 1]
[3 1]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary(Integer(1), Integer(2))
>>> D.B()
[1 1]
[3 1]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary(1, 2)
D.B()
B_inverse()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary(1, 2)
sage: D.B_inverse()
[-1/2  1/2]
[ 3/2 -1/2]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary(Integer(1), Integer(2))
>>> D.B_inverse()
[-1/2  1/2]
[ 3/2 -1/2]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary(1, 2)
D.B_inverse()
E()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.enter(1)
sage: D.leave(4)
sage: D.E()
[1 1]
[0 3]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.enter(Integer(1))
>>> D.leave(Integer(4))
>>> D.E()
[1 1]
[0 3]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.enter(1)
D.leave(4)
D.E()
E_inverse()[source]

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 = InteractiveLPProblemStandardForm(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]

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.enter(Integer(1))
>>> D.leave(Integer(4))
>>> D.E_inverse()
[   1 -1/3]
[   0  1/3]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.enter(1)
D.leave(4)
D.E_inverse()
add_row(nonbasic_coefficients, constant, basic_variable=None)[source]

Return a dictionary with an additional row based on a given dictionary.

The implementation of this method for revised dictionaries adds a new inequality constraint to the problem, in which the given \(basic_variable\) becomes the slack variable. The resulting dictionary (with \(basic_variable\) added to the basis) will have the given \(nonbasic_coefficients\) and \(constant\) as a new row.

INPUT:

  • nonbasic_coefficients – list of the coefficients for the new row (with which nonbasic variables are subtracted in the relation for the new basic variable)

  • constant – the constant term for the new row

  • basic_variable – (default: depends on style()) a string giving the name of the basic variable of the new row

OUTPUT: a revised dictionary

EXAMPLES:

sage: A = ([-1, 1111, 3, 17], [8, 222, 7, 6],
....: [3, 7, 17, 5], [9, 5, 7, 3])
sage: b = (2, 17, 11, 27)
sage: c = (5/133, 1/10, 1/18, 47/3)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.final_revised_dictionary()
sage: D1 = D.add_row([7, 11, 13, 9], 42)
sage: D1.row_coefficients("x9")
(7, 11, 13, 9)
sage: D1.constant_terms()[-1]
42
sage: D1.basic_variables()[-1]
x9

sage: A = ([-9, 7, 48, 31, 23], [5, 2, 9, 13, 98],
....: [14, 15, 97, 49, 1], [9, 5, 7, 3, 17],
....: [119, 7, 121, 5, 111])
sage: b = (33, 27, 1, 272, 61)
sage: c = (51/133, 1/100, 149/18, 47/37, 13/17)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary("x1", "x2", "x3", "x4", "x5")
sage: D2 = D.add_row([5 ,7, 11, 13, 9], 99, basic_variable='c')
sage: D2.row_coefficients("c")
(5, 7, 11, 13, 9)
sage: D2.constant_terms()[-1]
99
sage: D2.basic_variables()[-1]
c

sage: D = P.revised_dictionary(0, 1, 2, 3, 4)
sage: D.add_row([1, 2, 3, 4, 5, 6], 0)
Traceback (most recent call last):
...
ValueError: the sum of coefficients of nonbasic slack variables has
to be equal to -1 when inserting a row into a dictionary for the
auxiliary problem
sage: D3 = D.add_row([1, 2, 3, 4, 5, -15], 0)
sage: D3.row_coefficients(11)
(1, 2, 3, 4, 5, -15)

>>> from sage.all import *
>>> A = ([-Integer(1), Integer(1111), Integer(3), Integer(17)], [Integer(8), Integer(222), Integer(7), Integer(6)],
... [Integer(3), Integer(7), Integer(17), Integer(5)], [Integer(9), Integer(5), Integer(7), Integer(3)])
>>> b = (Integer(2), Integer(17), Integer(11), Integer(27))
>>> c = (Integer(5)/Integer(133), Integer(1)/Integer(10), Integer(1)/Integer(18), Integer(47)/Integer(3))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.final_revised_dictionary()
>>> D1 = D.add_row([Integer(7), Integer(11), Integer(13), Integer(9)], Integer(42))
>>> D1.row_coefficients("x9")
(7, 11, 13, 9)
>>> D1.constant_terms()[-Integer(1)]
42
>>> D1.basic_variables()[-Integer(1)]
x9

>>> A = ([-Integer(9), Integer(7), Integer(48), Integer(31), Integer(23)], [Integer(5), Integer(2), Integer(9), Integer(13), Integer(98)],
... [Integer(14), Integer(15), Integer(97), Integer(49), Integer(1)], [Integer(9), Integer(5), Integer(7), Integer(3), Integer(17)],
... [Integer(119), Integer(7), Integer(121), Integer(5), Integer(111)])
>>> b = (Integer(33), Integer(27), Integer(1), Integer(272), Integer(61))
>>> c = (Integer(51)/Integer(133), Integer(1)/Integer(100), Integer(149)/Integer(18), Integer(47)/Integer(37), Integer(13)/Integer(17))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary("x1", "x2", "x3", "x4", "x5")
>>> D2 = D.add_row([Integer(5) ,Integer(7), Integer(11), Integer(13), Integer(9)], Integer(99), basic_variable='c')
>>> D2.row_coefficients("c")
(5, 7, 11, 13, 9)
>>> D2.constant_terms()[-Integer(1)]
99
>>> D2.basic_variables()[-Integer(1)]
c

>>> D = P.revised_dictionary(Integer(0), Integer(1), Integer(2), Integer(3), Integer(4))
>>> D.add_row([Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6)], Integer(0))
Traceback (most recent call last):
...
ValueError: the sum of coefficients of nonbasic slack variables has
to be equal to -1 when inserting a row into a dictionary for the
auxiliary problem
>>> D3 = D.add_row([Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), -Integer(15)], Integer(0))
>>> D3.row_coefficients(Integer(11))
(1, 2, 3, 4, 5, -15)

A = ([-1, 1111, 3, 17], [8, 222, 7, 6],
[3, 7, 17, 5], [9, 5, 7, 3])
b = (2, 17, 11, 27)
c = (5/133, 1/10, 1/18, 47/3)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.final_revised_dictionary()
D1 = D.add_row([7, 11, 13, 9], 42)
D1.row_coefficients("x9")
D1.constant_terms()[-1]
D1.basic_variables()[-1]
A = ([-9, 7, 48, 31, 23], [5, 2, 9, 13, 98],
[14, 15, 97, 49, 1], [9, 5, 7, 3, 17],
[119, 7, 121, 5, 111])
b = (33, 27, 1, 272, 61)
c = (51/133, 1/100, 149/18, 47/37, 13/17)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary("x1", "x2", "x3", "x4", "x5")
D2 = D.add_row([5 ,7, 11, 13, 9], 99, basic_variable='c')
D2.row_coefficients("c")
D2.constant_terms()[-1]
D2.basic_variables()[-1]
D = P.revised_dictionary(0, 1, 2, 3, 4)
D.add_row([1, 2, 3, 4, 5, 6], 0)
D3 = D.add_row([1, 2, 3, 4, 5, -15], 0)
D3.row_coefficients(11)
basic_indices()[source]

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: list

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.basic_indices()
[3, 4]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.basic_indices()
basic_variables()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.basic_variables()
(x3, x4)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.basic_variables()
(x3, x4)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.basic_variables()
c_B()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary(1, 2)
sage: D.c_B()
(10, 5)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary(Integer(1), Integer(2))
>>> D.c_B()
(10, 5)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary(1, 2)
D.c_B()
c_N()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.c_N()
(10, 5)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.c_N()
(10, 5)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.c_N()
column_coefficients(v)[source]

Return the coefficients of a nonbasic variable.

INPUT:

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

OUTPUT: a vector

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.column_coefficients(Integer(1))
(1, 3)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.column_coefficients(1)
constant_terms()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.constant_terms()
(1000, 1500)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.constant_terms()
(1000, 1500)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.constant_terms()
dictionary()[source]

Return a regular LP dictionary matching self.

OUTPUT: an LP dictionary

EXAMPLES:

sage: A = ([1, 1], [3, 1], [-1, -1])
sage: b = (1000, 1500, -400)
sage: c = (10, 5)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.dictionary()
LP problem dictionary (use ...)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)], [-Integer(1), -Integer(1)])
>>> b = (Integer(1000), Integer(1500), -Integer(400))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.dictionary()
LP problem dictionary (use ...)

A = ([1, 1], [3, 1], [-1, -1])
b = (1000, 1500, -400)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.dictionary()
nonbasic_indices()[source]

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: list

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.nonbasic_indices()
[1, 2]

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.nonbasic_indices()
nonbasic_variables()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.nonbasic_variables()
(x1, x2)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.nonbasic_variables()
(x1, x2)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.nonbasic_variables()
objective_coefficients()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.objective_coefficients()
(10, 5)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.objective_coefficients()
(10, 5)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.objective_coefficients()
objective_name()[source]

Return the objective name of self.

OUTPUT: a symbolic expression

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.objective_name()
z

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.objective_name()
objective_value()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.objective_value()
0

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.objective_value()
0

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.objective_value()
problem()[source]

Return the original problem.

OUTPUT: an LP problem in standard form

EXAMPLES:

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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.problem() is P
True

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.problem() is P
row_coefficients(v)[source]

Return the coefficients of the basic variable v.

These are the coefficients with which nonbasic variables are subtracted in the relation for v.

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: a vector of coefficients of a basic variable

EXAMPLES:

sage: A = ([-1, 1], [8, 2])
sage: b = (2, 17)
sage: c = (55/10, 21/10)
sage: P = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.row_coefficients("x3")
(-1, 1)

>>> from sage.all import *
>>> A = ([-Integer(1), Integer(1)], [Integer(8), Integer(2)])
>>> b = (Integer(2), Integer(17))
>>> c = (Integer(55)/Integer(10), Integer(21)/Integer(10))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.row_coefficients("x3")
(-1, 1)

A = ([-1, 1], [8, 2])
b = (2, 17)
c = (55/10, 21/10)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.row_coefficients("x3")

We can also use indices of variables:

sage: D.row_coefficients(3)
(-1, 1)

>>> from sage.all import *
>>> D.row_coefficients(Integer(3))
(-1, 1)

D.row_coefficients(3)

Or variable names without quotes after injecting them:

sage: P.inject_variables()
Defining x0, x1, x2, x3, x4
sage: D.row_coefficients(x3)
(-1, 1)

>>> from sage.all import *
>>> P.inject_variables()
Defining x0, x1, x2, x3, x4
>>> D.row_coefficients(x3)
(-1, 1)

P.inject_variables()
D.row_coefficients(x3)
update()[source]

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 = InteractiveLPProblemStandardForm(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

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.objective_value()
0
>>> D.enter("x1")
>>> D.leave("x4")
>>> D.update()
>>> D.objective_value()
5000

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.objective_value()
D.enter("x1")
D.leave("x4")
D.update()
D.objective_value()
x_B()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.basic_variables()
(x3, x4)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.basic_variables()
(x3, x4)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.basic_variables()
x_N()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.nonbasic_variables()
(x1, x2)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.nonbasic_variables()
(x1, x2)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.nonbasic_variables()
y()[source]

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 = InteractiveLPProblemStandardForm(A, b, c)
sage: D = P.revised_dictionary()
sage: D.y()
(0, 0)

>>> from sage.all import *
>>> A = ([Integer(1), Integer(1)], [Integer(3), Integer(1)])
>>> b = (Integer(1000), Integer(1500))
>>> c = (Integer(10), Integer(5))
>>> P = InteractiveLPProblemStandardForm(A, b, c)
>>> D = P.revised_dictionary()
>>> D.y()
(0, 0)

A = ([1, 1], [3, 1])
b = (1000, 1500)
c = (10, 5)
P = InteractiveLPProblemStandardForm(A, b, c)
D = P.revised_dictionary()
D.y()
sage.numerical.interactive_simplex_method.default_variable_name(variable)[source]

Return default variable name for the current style().

INPUT:

  • variable – string describing requested name

OUTPUT: string with the requested name for current style

EXAMPLES:

sage: sage.numerical.interactive_simplex_method.default_variable_name("primal slack")
'x'
sage: sage.numerical.interactive_simplex_method.style('Vanderbei')
'Vanderbei'
sage: sage.numerical.interactive_simplex_method.default_variable_name("primal slack")
'w'
sage: sage.numerical.interactive_simplex_method.style('UAlberta')
'UAlberta'

>>> from sage.all import *
>>> sage.numerical.interactive_simplex_method.default_variable_name("primal slack")
'x'
>>> sage.numerical.interactive_simplex_method.style('Vanderbei')
'Vanderbei'
>>> sage.numerical.interactive_simplex_method.default_variable_name("primal slack")
'w'
>>> sage.numerical.interactive_simplex_method.style('UAlberta')
'UAlberta'

sage.numerical.interactive_simplex_method.default_variable_name("primal slack")
sage.numerical.interactive_simplex_method.style('Vanderbei')
sage.numerical.interactive_simplex_method.default_variable_name("primal slack")
sage.numerical.interactive_simplex_method.style('UAlberta')
sage.numerical.interactive_simplex_method.random_dictionary(m, n, bound=5, special_probability=0.2)[source]

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: an LP problem dictionary

EXAMPLES:

sage: from sage.numerical.interactive_simplex_method \
....:     import random_dictionary
sage: random_dictionary(3, 4)  # indirect doctest
LP problem dictionary (use 'view(...)' or '%display typeset' for details)

>>> from sage.all import *
>>> from sage.numerical.interactive_simplex_method     import random_dictionary
>>> random_dictionary(Integer(3), Integer(4))  # indirect doctest
LP problem dictionary (use 'view(...)' or '%display typeset' for details)

from sage.numerical.interactive_simplex_method \
    import random_dictionary
random_dictionary(3, 4)  # indirect doctest
sage.numerical.interactive_simplex_method.style(new_style=None)[source]

Set or get the current style of problems and dictionaries.

INPUT:

  • new_style – string or None (default)

OUTPUT:

  • a string with current style (same as new_style if it was given)

If the input is not recognized as a valid style, a ValueError exception is raised.

Currently supported styles are:

  • ‘UAlberta’ (default): Follows the style used in the Math 373 course on Mathematical Programming and Optimization at the University of Alberta, Edmonton, Canada; based on Chvatal’s book.

    • Objective functions of dictionaries are printed at the bottom.

    Variable names default to

    • \(z\) for primal objective

    • \(z\) for dual objective

    • \(w\) for auxiliary objective

    • \(x_1, x_2, \dots, x_n\) for primal decision variables

    • \(x_{n+1}, x_{n+2}, \dots, x_{n+m}\) for primal slack variables

    • \(y_1, y_2, \dots, y_m\) for dual decision variables

    • \(y_{m+1}, y_{m+2}, \dots, y_{m+n}\) for dual slack variables

  • ‘Vanderbei’: Follows the style of Robert Vanderbei’s textbook, Linear Programming – Foundations and Extensions.

    • Objective functions of dictionaries are printed at the top.

    Variable names default to

    • \(zeta\) for primal objective

    • \(xi\) for dual objective

    • \(xi\) for auxiliary objective

    • \(x_1, x_2, \dots, x_n\) for primal decision variables

    • \(w_1, w_2, \dots, w_m\) for primal slack variables

    • \(y_1, y_2, \dots, y_m\) for dual decision variables

    • \(z_1, z_2, \dots, z_n\) for dual slack variables

EXAMPLES:

sage: sage.numerical.interactive_simplex_method.style()
'UAlberta'
sage: sage.numerical.interactive_simplex_method.style('Vanderbei')
'Vanderbei'
sage: sage.numerical.interactive_simplex_method.style('Doesntexist')
Traceback (most recent call last):
...
ValueError: Style must be one of: UAlberta, Vanderbei
sage: sage.numerical.interactive_simplex_method.style('UAlberta')
'UAlberta'

>>> from sage.all import *
>>> sage.numerical.interactive_simplex_method.style()
'UAlberta'
>>> sage.numerical.interactive_simplex_method.style('Vanderbei')
'Vanderbei'
>>> sage.numerical.interactive_simplex_method.style('Doesntexist')
Traceback (most recent call last):
...
ValueError: Style must be one of: UAlberta, Vanderbei
>>> sage.numerical.interactive_simplex_method.style('UAlberta')
'UAlberta'

sage.numerical.interactive_simplex_method.style()
sage.numerical.interactive_simplex_method.style('Vanderbei')
sage.numerical.interactive_simplex_method.style('Doesntexist')
sage.numerical.interactive_simplex_method.style('UAlberta')
sage.numerical.interactive_simplex_method.variable(v)[source]

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

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

from sage.numerical.interactive_simplex_method \
    import variable
R = PolynomialRing(QQ, "x3, y5, x5, y")
R.inject_variables()
variable(R, "x3")
variable(R, x3)
variable(R, 3)
variable(R, 0)
variable(R, 5)
variable(R, 2 * x3)
variable(R, "z")