### Navigation

- index
- modules |
- next |
- previous |
- Numerical Optimization »

# Interactive Simplex Method

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

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

AUTHORS:

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

EXAMPLES:

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

Corn & Barley

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

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

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

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

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

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

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

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

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

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

    sage: P = P.standard_form()

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

The simplest way to use the simplex method is:

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

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

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

Using typeset mode as recommended, you’ll see

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

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

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

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

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

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

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

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

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

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

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

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

Note

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

class `sage.numerical.interactive_simplex_method.``LPAbstractDictionary`

  Bases: `sage.structure.sage_object.SageObject`

  Abstract base class for dictionaries for LP problems.

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

  `base_ring`()

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

    OUTPUT:

    - a ring

    EXAMPLES:

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

  `basic_solution`(include_slack_variables=False)

    Return the basic solution of `self`.

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

    INPUT:

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

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `coordinate_ring`()

    Return the coordinate ring of `self`.

    OUTPUT:

    - a polynomial ring in `auxiliary_variable()`, `decision_variables()`, and `slack_variables()` of `self` over the `base_ring()`

    EXAMPLES:

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

  `dual_ratios`()

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

    OUTPUT:

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

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

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

    EXAMPLES:

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

  `enter`(v)

    Set `v` as the entering variable of `self`.

    INPUT:

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

    OUTPUT:

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

    EXAMPLES:

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

    We can also use indices of variables:

        sage: D.enter(1)

    Or variable names without quotes after injecting them:

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

    The same works for revised dictionaries as well:

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

  `is_dual_feasible`()

    Check if `self` is dual feasible.

    OUTPUT:

    - `True` if all `objective_coefficients()` are non-positive, `False` otherwise

    EXAMPLES:

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

  `is_feasible`()

    Check if `self` is feasible.

    OUTPUT:

    - `True` if all `constant_terms()` are non-negative,``False`` otherwise

    EXAMPLES:

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

  `is_optimal`()

    Check if `self` is optimal.

    OUTPUT:

    - `True` if `self` `is_feasible()` and `is_dual_feasible()` (i.e. all `constant_terms()` are non-negative and all `objective_coefficients()` are non-positive), `False` otherwise.

    EXAMPLES:

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

  `leave`(v)

    Set `v` as the leaving variable of `self`.

    INPUT:

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

    OUTPUT:

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

    EXAMPLES:

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

    We can also use indices of variables:

        sage: D.leave(4)

    Or variable names without quotes after injecting them:

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

    The same works for revised dictionaries as well:

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

  `possible_dual_simplex_method_steps`()

    Return possible dual simplex method steps for `self`.

    OUTPUT:

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

    EXAMPLES:

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

  `possible_entering`()

    Return possible entering variables for `self`.

    OUTPUT:

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

    EXAMPLES:

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

  `possible_leaving`()

    Return possible leaving variables for `self`.

    OUTPUT:

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

    EXAMPLES:

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

  `possible_simplex_method_steps`()

    Return possible simplex method steps for `self`.

    OUTPUT:

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

    EXAMPLES:

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

  `ratios`()

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

    OUTPUT:

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

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

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

    EXAMPLES:

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

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

  Bases: `sage.numerical.interactive_simplex_method.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` – a list of basic variables \(x_B\)
  - `nonbasic_variables` – a list of non-basic variables \(x_N\)
  - `objective_variable` – an objective variable \(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 `LPProblemStandardForm`.

  EXAMPLES:

  The intended way to use this class is indirect:

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

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

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

  `ELLUL`(entering, leaving)

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

    INPUT:

    - `entering` – the entering variable
    - `leaving` – the leaving variable

    OUTPUT:

    - a string with LaTeX code for `self` before and after update

    EXAMPLES:

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

    This is how the above output looks when rendered:

    \[\begin{split}\renewcommand{\arraystretch}{1.5} \begin{array}{|rcrcrcr|} \hline x_{3} \!\!\!&\!\!\! = \!\!\!&\!\!\! 1000 \!\!\!&\!\!\! - \!\!\!&\color{green}{\!\!\! x_{1} \!\!\!}&\!\!\! - \!\!\!&\!\!\! x_{2}\\ \color{red}{x_{4} \!\!\!}&\color{red}{\!\!\! = \!\!\!}&\color{red}{\!\!\! 1500 \!\!\!}&\color{red}{\!\!\! - \!\!\!}&\color{blue}{{\!\!\! 3 x_{1} \!\!\!}}&\color{red}{\!\!\! - \!\!\!}&\color{red}{\!\!\! x_{2}}\\ \hline z \!\!\!&\!\!\! = \!\!\!&\!\!\! 0 \!\!\!&\!\!\! + \!\!\!&\color{green}{\!\!\! 10 x_{1} \!\!\!}&\!\!\! + \!\!\!&\!\!\! 5 x_{2}\\ \hline \\ \hline x_{3} \!\!\!&\!\!\! = \!\!\!&\!\!\! 500 \!\!\!&\!\!\! + \!\!\!&\!\!\! \frac{1}{3} x_{4} \!\!\!&\!\!\! - \!\!\!&\!\!\! \frac{2}{3} x_{2}\\ x_{1} \!\!\!&\!\!\! = \!\!\!&\!\!\! 500 \!\!\!&\!\!\! - \!\!\!&\!\!\! \frac{1}{3} x_{4} \!\!\!&\!\!\! - \!\!\!&\!\!\! \frac{1}{3} x_{2}\\ \hline z \!\!\!&\!\!\! = \!\!\!&\!\!\! 5000 \!\!\!&\!\!\! - \!\!\!&\!\!\! \frac{10}{3} x_{4} \!\!\!&\!\!\! + \!\!\!&\!\!\! \frac{5}{3} x_{2}\\ \hline \end{array}\end{split}\]

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

  `basic_variables`()

    Return the basic variables of `self`.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `constant_terms`()

    Return the constant terms of relations of `self`.

    OUTPUT:

    - a vector.

    EXAMPLES:

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

  `entering_coefficients`()

    Return coefficients of the entering variable.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `leaving_coefficients`()

    Return coefficients of the leaving variable.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `nonbasic_variables`()

    Return non-basic variables of `self`.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `objective_coefficients`()

    Return coefficients of the objective of `self`.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `objective_value`()

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

    OUTPUT:

    - a number

    EXAMPLES:

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

  `update`()

    Update `self` using previously set entering and leaving variables.

    EXAMPLES:

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

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

  Bases: `sage.structure.sage_object.SageObject`

  Construct an LP (Linear Programming) problem.

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

  INPUT:

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

  EXAMPLES:

  We will construct the following problem:

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

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

  Same problem, but more explicitly:

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

  Even more explicitly:

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

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

  `A`()

    Return coefficients of constraints of `self`, i.e. \(A\).

    OUTPUT:

    - a matrix

    EXAMPLES:

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

  `Abcx`()

    Return \(A\), \(b\), \(c\), and \(x\) of `self` as a tuple.

    OUTPUT:

    - a tuple

    EXAMPLES:

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

  `b`()

    Return constant terms of constraints of `self`, i.e. \(b\).

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `base_ring`()

    Return the base ring of `self`.

    Note

    The base ring of LP problems is always a field.

    OUTPUT:

    - a ring

    EXAMPLES:

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

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

  `c`()

    Return coefficients of the objective of `self`, i.e. \(c\).

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `constant_terms`()

    Return constant terms of constraints of `self`, i.e. \(b\).

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `constraint_coefficients`()

    Return coefficients of constraints of `self`, i.e. \(A\).

    OUTPUT:

    - a matrix

    EXAMPLES:

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

  `decision_variables`()

    Return decision variables of `self`, i.e. \(x\).

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `dual`(y=None)

    Construct the dual LP problem for `self`.

    INPUT:

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

    OUTPUT:

    - an `LPProblem`

    EXAMPLES:

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

  `feasible_set`()

    Return the feasible set of `self`.

    OUTPUT:

    - a `Polyhedron`

    EXAMPLES:

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

  `is_bounded`()

    Check if `self` is bounded.

    OUTPUT:

    - `True` is `self` is bounded, `False` otherwise

    EXAMPLES:

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

  `is_feasible`()

    Check if `self` is feasible.

    OUTPUT:

    - `True` is `self` is feasible, `False` otherwise

    EXAMPLES:

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

  `m`()

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

    OUTPUT:

    - an integer

    EXAMPLES:

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

  `n`()

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

    OUTPUT:

    - an integer

    EXAMPLES:

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

  `n_constraints`()

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

    OUTPUT:

    - an integer

    EXAMPLES:

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

  `n_variables`()

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

    OUTPUT:

    - an integer

    EXAMPLES:

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

  `objective_coefficients`()

    Return coefficients of the objective of `self`, i.e. \(c\).

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `optimal_solution`()

    Return an optimal solution of `self`.

    OUTPUT:

    - a vector or `None` if there are no optimal solutions

    EXAMPLES:

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

  `optimal_value`()

    Return the optimal value for `self`.

    OUTPUT:

    - a number if the problem is bounded, \(\pm \infty\) if it is unbounded, or `None` if it is infeasible

    EXAMPLES:

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

  `plot`(*args, **kwds)

    Return a plot for solving `self` graphically.

    INPUT:

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

    OUTPUT:

    - a plot

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

    EXAMPLES:

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

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

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

    TESTS:

    We check that zero objective can be dealt with:

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

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

    Return a plot of the feasible set of `self`.

    INPUT:

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

    OUTPUT:

    - a plot

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

    EXAMPLES:

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

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

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

  `standard_form`()

    Construct the LP problem in standard form equivalent to `self`.

    OUTPUT:

    - an `LPProblemStandardForm`

    EXAMPLES:

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

  `x`()

    Return decision variables of `self`, i.e. \(x\).

    OUTPUT:

    - a vector

    EXAMPLES:

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

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

  Bases: `sage.numerical.interactive_simplex_method.LPProblem`

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

  The used standard form is:

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

  INPUT:

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

  EXAMPLES:

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

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

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

  `auxiliary_problem`()

    Construct the auxiliary problem for `self`.

    OUTPUT:

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

  `auxiliary_variable`()

    Return the auxiliary variable of `self`.

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

    OUTPUT:

    - 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 = LPProblemStandardForm(A, b, c)
        sage: P.auxiliary_variable()
        x0
        sage: P.decision_variables()
        (x1, x2)
        sage: AP = P.auxiliary_problem()
        sage: AP.auxiliary_variable()
        x0
        sage: AP.decision_variables()
        (x0, x1, x2)

  `coordinate_ring`()

    Return the coordinate ring of `self`.

    OUTPUT:

    - a polynomial ring over the `base_ring()` of `self` in the `auxiliary_variable()`, `decision_variables()`, and `slack_variables()` with “neglex” order

    EXAMPLES:

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

  `dictionary`(*x_B)

    Construct a dictionary for `self` with given basic variables.

    INPUT:

    - basic variables for the dictionary to be constructed

    OUTPUT:

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

  `feasible_dictionary`(auxiliary_dictionary)

    Construct a feasible dictionary for `self`.

    INPUT:

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

    OUTPUT:

    - 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 = LPProblemStandardForm(A, b, c)
        sage: AP = P.auxiliary_problem()
        sage: D = AP.initial_dictionary()
        sage: D.enter(0)
        sage: D.leave(5)
        sage: D.update()
        sage: D.enter(1)
        sage: D.leave(0)
        sage: D.update()
        sage: D.is_optimal()
        True
        sage: D.objective_value()
        0
        sage: D.basic_solution()
        (0, 400, 0)
        sage: D = P.feasible_dictionary(D)
        sage: D.is_optimal()
        False
        sage: D.is_feasible()
        True
        sage: D.objective_value()
        4000
        sage: D.basic_solution()
        (400, 0)

  `final_dictionary`()

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

    See `run_simplex_method()` for the description of possibilities.

    OUTPUT:

    - a `dictionary`

    EXAMPLES:

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

    TESTS:

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

  `final_revised_dictionary`()

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

    See `run_revised_simplex_method()` for the description of possibilities.

    OUTPUT:

    - a `revised dictionary`

    EXAMPLES:

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

    TESTS:

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

  `initial_dictionary`()

    Construct the initial dictionary of `self`.

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

    OUTPUT:

    - a `dictionary`

    EXAMPLES:

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

  `inject_variables`(scope=None, verbose=True)

    Inject variables of `self` into `scope`.

    INPUT:

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

    OUTPUT:

    - none

    EXAMPLES:

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

  `revised_dictionary`(*x_B)

    Construct a revised dictionary for `self`.

    INPUT:

    - basic variables for the dictionary to be constructed; if not given, `slack_variables()` will be used, perhaps with the `auxiliary_variable()` to give a feasible dictionary

    OUTPUT:

    - a `revised dictionary`

    EXAMPLES:

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

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

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

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

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

  `run_revised_simplex_method`()

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

    OUTPUT:

    - a string with \(\LaTeX\) code of intermediate dictionaries

    Note

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

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

    EXAMPLES:

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

  `run_simplex_method`()

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

    OUTPUT:

    - a string with \(\LaTeX\) code of intermediate dictionaries

    Note

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

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

    EXAMPLES:

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

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

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

  `slack_variables`()

    Return slack variables of `self`.

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

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

    OUTPUT:

    - a tuple

    EXAMPLES:

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

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

  Bases: `sage.numerical.interactive_simplex_method.LPAbstractDictionary`

  Construct a revised dictionary for an LP problem.

  INPUT:

  - `problem` – an `LP problem in standard form`
  - `basic_variables` – a list of basic variables or their indices

  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 = LPProblemStandardForm(A, b, c)
      sage: from sage.numerical.interactive_simplex_method \
      ....:     import LPRevisedDictionary
      sage: D = LPRevisedDictionary(P, [1, 2])
      sage: D.basic_variables()
      (x1, x2)
      sage: D
      LP problem dictionary (use typeset mode to see details)

  The same dictionary can be constructed through the problem:

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

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

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

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

  `A`(v)

    Return the column of constraint coefficients corresponding to `v`.

    INPUT:

    - `v` – a variable, its name, or its index

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `A_N`()

    Return the \(A_N\) matrix, constraint coefficients of non-basic variables.

    OUTPUT:

    - a matrix

    EXAMPLES:

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

  `B`()

    Return the \(B\) matrix, i.e. constraint coefficients of basic variables.

    OUTPUT:

    - a matrix

    EXAMPLES:

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

  `B_inverse`()

    Return the inverse of the `B()` matrix.

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

    OUTPUT:

    - a matrix

    EXAMPLES:

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

  `E`()

    Return the eta matrix between `self` and the next dictionary.

    OUTPUT:

    - a matrix

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

    EXAMPLES:

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

  `E_inverse`()

    Return the inverse of the matrix `E()`.

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

    OUTPUT:

    - a matrix

    EXAMPLES:

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

  `basic_indices`()

    Return the basic indices of `self`.

    Note

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

    OUTPUT:

    - a list.

    EXAMPLES:

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

  `basic_variables`()

    Return the basic variables of `self`.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `c_B`()

    Return the \(c_B\) vector, objective coefficients of basic variables.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `c_N`()

    Return the \(c_N\) vector, objective coefficients of non-basic variables.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `constant_terms`()

    Return constant terms in the relations of `self`.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `dictionary`()

    Return a regular LP dictionary matching `self`.

    OUTPUT:

    - an `LP dictionary`

    EXAMPLES:

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

  `entering_coefficients`()

    Return coefficients of the entering variable.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `leaving_coefficients`()

    Return coefficients of the leaving variable.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `nonbasic_indices`()

    Return the non-basic indices of `self`.

    Note

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

    OUTPUT:

    - a list

    EXAMPLES:

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

  `nonbasic_variables`()

    Return non-basic variables of `self`.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `objective_coefficients`()

    Return coefficients of the objective of `self`.

    OUTPUT:

    - a vector

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

    EXAMPLES:

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

  `objective_value`()

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

    OUTPUT:

    - a number

    EXAMPLES:

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

  `problem`()

    Return the original problem.

    OUTPUT:

    - an `LP problem in standard form`

    EXAMPLES:

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

  `update`()

    Update `self` using previously set entering and leaving variables.

    EXAMPLES:

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

  `x_B`()

    Return the basic variables of `self`.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `x_N`()

    Return non-basic variables of `self`.

    OUTPUT:

    - a vector

    EXAMPLES:

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

  `y`()

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

    OUTPUT:

    - a vector

    EXAMPLES:

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

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

  Construct a random dictionary.

  INPUT:

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

  OUTPUT:

  - an `LP problem dictionary`

  EXAMPLES:

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

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

  Interpret `v` as a variable of `R`.

  INPUT:

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

  OUTPUT:

  - a variable of `R`

  EXAMPLES:

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

### Navigation

- index
- modules |
- next |
- previous |
- Numerical Optimization »