passagemath-polyhedra 10.6.37__cp314-cp314-musllinux_1_2_x86_64.whl

sage/numerical/linear_functions.pyx

@@ -0,0 +1,1648 @@
+# sage_setup: distribution = sagemath-polyhedra
+"""
+Linear Functions and Constraints
+
+This module implements linear functions (see :class:`LinearFunction`)
+in formal variables and chained (in)equalities between them (see
+:class:`LinearConstraint`). By convention, these are always written as
+either equalities or less-or-equal. For example::
+
+    sage: p = MixedIntegerLinearProgram()
+    sage: x = p.new_variable()
+    sage: f = 1 + x[1] + 2*x[2];  f     #  a linear function
+    1 + x_0 + 2*x_1
+    sage: type(f)
+    <class 'sage.numerical.linear_functions.LinearFunction'>
+
+    sage: c = (0 <= f);  c    # a constraint
+    0 <= 1 + x_0 + 2*x_1
+    sage: type(c)
+    <class 'sage.numerical.linear_functions.LinearConstraint'>
+
+Note that you can use this module without any reference to linear
+programming, it only implements linear functions over a base ring and
+constraints. However, for ease of demonstration we will always
+construct them out of linear programs (see
+:mod:`~sage.numerical.mip`).
+
+Constraints can be equations or (non-strict) inequalities. They can be
+chained::
+
+    sage: p = MixedIntegerLinearProgram()
+    sage: x = p.new_variable()
+    sage: x[0] == x[1] == x[2] == x[3]
+    x_0 == x_1 == x_2 == x_3
+
+    sage: ieq_01234 = x[0] <= x[1] <= x[2] <= x[3] <= x[4]
+    sage: ieq_01234
+    x_0 <= x_1 <= x_2 <= x_3 <= x_4
+
+If necessary, the direction of inequality is flipped to always write
+inequalities as less or equal::
+
+    sage: x[5] >= ieq_01234
+    x_0 <= x_1 <= x_2 <= x_3 <= x_4 <= x_5
+
+    sage: (x[5] <= x[6]) >= ieq_01234
+    x_0 <= x_1 <= x_2 <= x_3 <= x_4 <= x_5 <= x_6
+    sage: (x[5] <= x[6]) <= ieq_01234
+    x_5 <= x_6 <= x_0 <= x_1 <= x_2 <= x_3 <= x_4
+
+.. WARNING::
+
+    The implementation of chained inequalities uses a Python hack to
+    make it work, so it is not completely robust. In particular, while
+    constants are allowed, no two constants can appear next to
+    each other. The following does not work for example::
+
+        sage: x[0] <= 3 <= 4
+        True
+
+    If you really need this for some reason, you can explicitly convert
+    the constants to a :class:`LinearFunction`::
+
+        sage: from sage.numerical.linear_functions import LinearFunctionsParent
+        sage: LF = LinearFunctionsParent(QQ)
+        sage: x[1] <= LF(3) <= LF(4)
+        x_1 <= 3 <= 4
+
+TESTS:
+
+This was fixed in :issue:`24423`::
+
+    sage: p.<x> = MixedIntegerLinearProgram()
+    sage: from sage.numerical.linear_functions import LinearFunctionsParent
+    sage: LF = LinearFunctionsParent(QQ)
+    sage: 3 <= x[0] <= LF(4)
+    3 <= x_0 <= 4
+
+See :issue:`12091`::
+
+    sage: p = MixedIntegerLinearProgram()
+    sage: b = p.new_variable()
+    sage: b[0] <= b[1] <= 2
+    x_0 <= x_1 <= 2
+    sage: list(b[0] <= b[1] <= 2)
+    [x_0, x_1, 2]
+    sage: 1 >= b[1] >= 2*b[0]
+    2*x_0 <= x_1 <= 1
+    sage: b[2] >= b[1] >= 2*b[0]
+    2*x_0 <= x_1 <= x_2
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2012 Nathann Cohen <nathann.cohen@gmail.com>
+#       Copyright (C) 2012 Volker Braun <vbraun.name@gmail.com>
+#       Copyright (C) 2016 Jeroen Demeyer <jdemeyer@cage.ugent.be>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from cpython.object cimport Py_EQ, Py_GE, Py_LE, Py_GT, Py_LT
+
+from sage.misc.fast_methods cimport hash_by_id
+from sage.structure.parent cimport Parent
+from sage.structure.element cimport ModuleElement, Element
+from sage.misc.cachefunc import cached_function
+
+#*****************************************************************************
+#
+# Utility functions to test that something is a linear function / constraint
+#
+#*****************************************************************************
+
+cpdef is_LinearFunction(x):
+    """
+    Test whether ``x`` is a linear function.
+
+    INPUT:
+
+    - ``x`` -- anything
+
+    OUTPUT: boolean
+
+    EXAMPLES::
+
+        sage: p = MixedIntegerLinearProgram()
+        sage: x = p.new_variable()
+        sage: from sage.numerical.linear_functions import is_LinearFunction
+        sage: is_LinearFunction(x[0] - 2*x[2])
+        doctest:warning...
+        DeprecationWarning: The function is_LinearFunction is deprecated;
+        use 'isinstance(..., LinearFunction)' instead.
+        See https://github.com/sagemath/sage/issues/38184 for details.
+        True
+        sage: is_LinearFunction('a string')
+        False
+    """
+    from sage.misc.superseded import deprecation_cython
+    deprecation_cython(38184,
+                       "The function is_LinearFunction is deprecated; "
+                       "use 'isinstance(..., LinearFunction)' instead.")
+    return isinstance(x, LinearFunction)
+
+
+def is_LinearConstraint(x):
+    """
+    Test whether ``x`` is a linear constraint.
+
+    INPUT:
+
+    - ``x`` -- anything
+
+    OUTPUT: boolean
+
+    EXAMPLES::
+
+        sage: p = MixedIntegerLinearProgram()
+        sage: x = p.new_variable()
+        sage: ieq = (x[0] <= x[1])
+        sage: from sage.numerical.linear_functions import is_LinearConstraint
+        sage: is_LinearConstraint(ieq)
+        doctest:warning...
+        DeprecationWarning: The function is_LinearConstraint is deprecated;
+        use 'isinstance(..., LinearConstraint)' instead.
+        See https://github.com/sagemath/sage/issues/38184 for details.
+        True
+        sage: is_LinearConstraint('a string')
+        False
+    """
+    from sage.misc.superseded import deprecation_cython
+    deprecation_cython(38184,
+                       "The function is_LinearConstraint is deprecated; "
+                       "use 'isinstance(..., LinearConstraint)' instead.")
+    return isinstance(x, LinearConstraint)
+
+
+# ****************************************************************************
+#
+# Factory functions for the parents to ensure uniqueness
+#
+# ****************************************************************************
+
+@cached_function
+def LinearFunctionsParent(base_ring):
+    """
+    Return the parent for linear functions over ``base_ring``.
+
+    The output is cached, so only a single parent is ever constructed
+    for a given base ring.
+
+    INPUT:
+
+    - ``base_ring`` -- a ring; the coefficient ring for the linear
+      functions
+
+    OUTPUT: the parent of the linear functions over ``base_ring``
+
+    EXAMPLES::
+
+        sage: from sage.numerical.linear_functions import LinearFunctionsParent
+        sage: LinearFunctionsParent(QQ)
+        Linear functions over Rational Field
+    """
+    return LinearFunctionsParent_class(base_ring)
+
+
+@cached_function
+def LinearConstraintsParent(linear_functions_parent):
+    """
+    Return the parent for linear functions over ``base_ring``.
+
+    The output is cached, so only a single parent is ever constructed
+    for a given base ring.
+
+    INPUT:
+
+    - ``linear_functions_parent`` -- a
+       :class:`LinearFunctionsParent_class`; the type of linear
+       functions that the constraints are made out of
+
+    OUTPUT: the parent of the linear constraints with the given linear functions
+
+    EXAMPLES::
+
+        sage: from sage.numerical.linear_functions import (
+        ....:     LinearFunctionsParent, LinearConstraintsParent)
+        sage: LF = LinearFunctionsParent(QQ)
+        sage: LinearConstraintsParent(LF)
+        Linear constraints over Rational Field
+    """
+    return LinearConstraintsParent_class(linear_functions_parent)
+
+
+# ****************************************************************************
+#
+# Elements of linear functions or constraints
+#
+# ****************************************************************************
+
+cdef chained_comparator_left = None
+cdef chained_comparator_right = None
+cdef LinearConstraint chained_comparator_replace = None
+
+cdef class LinearFunctionOrConstraint(ModuleElement):
+    """
+    Base class for :class:`LinearFunction` and :class:`LinearConstraint`.
+
+    This class exists solely to implement chaining of inequalities
+    in constraints.
+    """
+    def __richcmp__(self, other, int op):
+        """
+        Create an inequality or equality object, possibly chaining
+        several together.
+
+        EXAMPLES::
+
+            sage: p.<x> = MixedIntegerLinearProgram()
+            sage: x[0].__le__(x[1])
+            x_0 <= x_1
+
+        ::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: from sage.numerical.linear_functions import LinearFunction
+            sage: LF({2 : 5, 3 : 2}) <= LF({2 : 3, 9 : 2})
+            5*x_2 + 2*x_3 <= 3*x_2 + 2*x_9
+
+            sage: LF({2 : 5, 3 : 2}) >= LF({2 : 3, 9 : 2})
+            3*x_2 + 2*x_9 <= 5*x_2 + 2*x_3
+
+            sage: LF({2 : 5, 3 : 2}) == LF({2 : 3, 9 : 2})
+            5*x_2 + 2*x_3 == 3*x_2 + 2*x_9
+
+        We can chain multiple (in)equalities::
+
+            sage: p.<b> = MixedIntegerLinearProgram()
+            sage: b[0] == 1 == b[1] == 2 == b[2] == 3
+            x_0 == 1 == x_1 == 2 == x_2 == 3
+            sage: b[0] <= 1 <= b[1] <= 2 <= b[2] <= 3
+            x_0 <= 1 <= x_1 <= 2 <= x_2 <= 3
+            sage: b[0] <= b[1] <= b[2] <= b[3]
+            x_0 <= x_1 <= x_2 <= x_3
+
+        Other comparison operators are not allowed::
+
+            sage: b[0] < b[1]
+            Traceback (most recent call last):
+            ...
+            ValueError: strict < is not allowed, use <= instead
+            sage: b[0] > b[1]
+            Traceback (most recent call last):
+            ...
+            ValueError: strict > is not allowed, use >= instead
+            sage: b[0] != b[1]
+            Traceback (most recent call last):
+            ...
+            ValueError: inequality != is not allowed, use one of <=, ==, >=
+
+        Mixing operators is also not allowed::
+
+            sage: 1 <= b[1] >= 2
+            Traceback (most recent call last):
+            ...
+            ValueError: incorrectly chained inequality
+            sage: 1 >= b[1] <= 2
+            Traceback (most recent call last):
+            ...
+            ValueError: incorrectly chained inequality
+            sage: 1 == b[1] <= 2
+            Traceback (most recent call last):
+            ...
+            ValueError: cannot mix equations and inequalities
+            sage: 1 >= b[1] == 2
+            Traceback (most recent call last):
+            ...
+            ValueError: cannot mix equations and inequalities
+
+        TESTS::
+
+            sage: p.<x> = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: cm = sage.structure.element.get_coercion_model()
+            sage: cm.explain(10, LF(1), operator.le)
+            Coercion on left operand via
+                Coercion map:
+                  From: Integer Ring
+                  To:   Linear functions over Real Double Field
+            Arithmetic performed after coercions.
+            Result lives in Linear functions over Real Double Field
+            Linear functions over Real Double Field
+
+            sage: operator.le(10, x[0])
+            10 <= x_0
+            sage: x[0] <= 1
+            x_0 <= 1
+            sage: x[0] >= 1
+            1 <= x_0
+            sage: 1 <= x[0]
+            1 <= x_0
+            sage: 1 >= x[0]
+            x_0 <= 1
+
+        This works with non-Sage types too, see :issue:`14540`::
+
+            sage: p.<b> = MixedIntegerLinearProgram()
+            sage: int(1) <= b[0] <= int(2)
+            1 <= x_0 <= 2
+            sage: int(1) >= b[0] >= int(2)
+            2 <= x_0 <= 1
+            sage: int(1) == b[0] == int(2)
+            1 == x_0 == 2
+            sage: float(0) <= b[0] <= int(1) <= b[1] <= float(2)
+            0 <= x_0 <= 1 <= x_1 <= 2
+        """
+        # Store the chaining variables and set them to None for now in
+        # order to have a sane state for any conversions below or when
+        # an exception is raised.
+        global chained_comparator_left
+        global chained_comparator_right
+        global chained_comparator_replace
+
+        chain_left = chained_comparator_left
+        chain_right = chained_comparator_right
+        chain_replace = chained_comparator_replace
+
+        chained_comparator_left = None
+        chained_comparator_right = None
+        chained_comparator_replace = None
+
+        # Assign {self, other} to {py_left, py_right} such that
+        # py_left <= py_right.
+        cdef bint equality = False
+        if op == Py_LE:
+            py_left, py_right = self, other
+        elif op == Py_GE:
+            py_left, py_right = other, self
+        elif op == Py_EQ:
+            py_left, py_right = self, other
+            equality = True
+        elif op == Py_LT:
+            raise ValueError("strict < is not allowed, use <= instead")
+        elif op == Py_GT:
+            raise ValueError("strict > is not allowed, use >= instead")
+        else:
+            raise ValueError("inequality != is not allowed, use one of <=, ==, >=")
+
+        # Convert py_left and py_right to constraints left and right,
+        # possibly replacing them to implement the hack below.
+        cdef LinearConstraint left = None
+        cdef LinearConstraint right = None
+
+        # HACK to allow chained constraints: Python translates
+        # x <= y <= z into:
+        #
+        #     temp = x <= y      # calls x.__richcmp__(y)
+        #     if temp:           # calls temp.__bool__()
+        #         return y <= z  # calls y.__richcmp__(z)
+        #     else:
+        #         return temp
+        #
+        # or, if x <= y is not implemented (for example, if x is a
+        # non-Sage type):
+        #
+        #     temp = y >= x      # calls y.__richcmp__(x)
+        #     if temp:           # calls temp.__bool__()
+        #         return y <= z  # calls y.__richcmp__(z)
+        #     else:
+        #         return temp
+        #
+        # but we would like x <= y <= z as output. The trick to make it
+        # work is to store x and y in the first call to __richcmp__
+        # and temp in the call to __bool__. Then we can replace x
+        # or y by x <= y in the second call to __richcmp__.
+        if chain_replace is not None:
+            if chain_replace.equality != equality:
+                raise ValueError("cannot mix equations and inequalities")
+
+            # First, check for correctly-chained inequalities
+            # x <= y <= z or z <= y <= x.
+            if py_left is chain_right:
+                left = chain_replace
+            elif py_right is chain_left:
+                right = chain_replace
+            # Next, check for incorrectly chained inequalities like
+            # x <= y >= z. If we are dealing with inequalities, this
+            # is an error. For an equality, we fix the chaining by
+            # reversing one of the sides.
+            elif py_left is chain_left:
+                if not equality:
+                    raise ValueError("incorrectly chained inequality")
+                chain_replace.constraints.reverse()
+                left = chain_replace
+            elif py_right is chain_right:
+                if not equality:
+                    raise ValueError("incorrectly chained inequality")
+                left = chain_replace
+                py_right = py_left
+
+        # Figure out the correct parent to work with: if we did a
+        # replacement, its parent takes priority.
+        if left is not None:
+            LC = left._parent
+        elif right is not None:
+            LC = right._parent
+        else:
+            LC = (<LinearFunctionOrConstraint>self)._parent
+
+            # We want the parent to be a LinearConstraintsParent
+            if not isinstance(LC, LinearConstraintsParent_class):
+                LC = LinearConstraintsParent(LC)
+
+        if left is None:
+            try:
+                left = <LinearConstraint?>py_left
+            except TypeError:
+                left = <LinearConstraint>LC(py_left, equality=equality)
+            else:
+                if left._parent is not LC:
+                    left = <LinearConstraint>LC(left.constraints, equality=left.equality)
+
+        if right is None:
+            try:
+                right = <LinearConstraint?>py_right
+            except TypeError:
+                right = <LinearConstraint>LC(py_right, equality=equality)
+            else:
+                if right._parent is not LC:
+                    right = <LinearConstraint>LC(right.constraints, equality=right.equality)
+
+        # Finally, chain the (in)equalities
+        if left.equality != equality or right.equality != equality:
+            raise ValueError("cannot mix equations and inequalities")
+        ret = LC(left.constraints + right.constraints, equality=equality)
+
+        # Everything done, so we set the chaining variables
+        chained_comparator_left = py_left
+        chained_comparator_right = py_right
+        chained_comparator_replace = None
+
+        return ret
+
+    def __hash__(self):
+        r"""
+        Return a hash from the ``id()``.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: f = LF({2 : 5, 3 : 2})
+            sage: hash(f)  # indirect doctest; random
+            103987752
+
+        Since we hash by ``id()``, linear functions and constraints are
+        only considered equal for sets and dicts if they are the same
+        object::
+
+            sage: f = LF.0
+            sage: set([f, f])
+            {x_0}
+            sage: set([f, f+0])
+            {x_0, x_0}
+            sage: len(set([f, f+1]))
+            2
+            sage: d = {}
+            sage: d[f] = 123
+            sage: d[f+0] = 456
+            sage: list(d)
+            [x_0, x_0]
+        """
+        return hash_by_id(<void*>self)
+
+
+#*****************************************************************************
+#
+# Parent of linear functions
+#
+#*****************************************************************************
+
+cdef class LinearFunctionsParent_class(Parent):
+    r"""
+    The parent for all linear functions over a fixed base ring.
+
+    .. warning::
+
+        You should use :func:`LinearFunctionsParent` to construct
+        instances of this class.
+
+    INPUT/OUTPUT: see :func:`LinearFunctionsParent`
+
+    EXAMPLES::
+
+        sage: from sage.numerical.linear_functions import LinearFunctionsParent_class
+        sage: LinearFunctionsParent_class
+        <class 'sage.numerical.linear_functions.LinearFunctionsParent_class'>
+    """
+    def __cinit__(self):
+        """
+        Cython initializer.
+
+        TESTS::
+
+            sage: from sage.numerical.linear_functions import LinearFunctionsParent_class
+            sage: LF = LinearFunctionsParent_class.__new__(LinearFunctionsParent_class)
+            sage: LF._multiplication_symbol
+            '*'
+        """
+        # Do not use coercion framework for __richcmp__
+        self.flags |= Parent_richcmp_element_without_coercion
+        self._multiplication_symbol = '*'
+
+    def __init__(self, base_ring):
+        """
+        The Python constructor.
+
+        TESTS::
+
+            sage: from sage.numerical.linear_functions import LinearFunctionsParent
+            sage: LinearFunctionsParent(RDF)
+            Linear functions over Real Double Field
+        """
+        from sage.categories.modules_with_basis import ModulesWithBasis
+        Parent.__init__(self, base=base_ring, category=ModulesWithBasis(base_ring))
+
+    def set_multiplication_symbol(self, symbol='*'):
+        """
+        Set the multiplication symbol when pretty-printing linear functions.
+
+        INPUT:
+
+        - ``symbol`` -- string (default: ``'*'``); the multiplication
+          symbol to be used
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: x = p.new_variable()
+            sage: f = -1-2*x[0]-3*x[1]
+            sage: LF = f.parent()
+            sage: LF._get_multiplication_symbol()
+            '*'
+            sage: f
+            -1 - 2*x_0 - 3*x_1
+            sage: LF.set_multiplication_symbol(' ')
+            sage: f
+            -1 - 2 x_0 - 3 x_1
+            sage: LF.set_multiplication_symbol()
+            sage: f
+            -1 - 2*x_0 - 3*x_1
+        """
+        self._multiplication_symbol = symbol
+
+    def _get_multiplication_symbol(self):
+        """
+        Return the multiplication symbol.
+
+        OUTPUT: string. By default, this is ``'*'``
+
+        EXAMPLES::
+
+            sage: LF = MixedIntegerLinearProgram().linear_functions_parent()
+            sage: LF._get_multiplication_symbol()
+            '*'
+        """
+        return self._multiplication_symbol
+
+    def tensor(self, free_module):
+        """
+        Return the tensor product with ``free_module``.
+
+        INPUT:
+
+        - ``free_module`` -- vector space or matrix space over the
+          same base ring
+
+        OUTPUT:
+
+        Instance of
+        :class:`sage.numerical.linear_tensor.LinearTensorParent_class`.
+
+        EXAMPLES::
+
+            sage: LF = MixedIntegerLinearProgram().linear_functions_parent()
+            sage: LF.tensor(RDF^3)
+            Tensor product of Vector space of dimension 3 over Real Double Field
+            and Linear functions over Real Double Field
+            sage: LF.tensor(QQ^2)
+            Traceback (most recent call last):
+            ...
+            ValueError: base rings must match
+        """
+        from sage.numerical.linear_tensor import LinearTensorParent
+        return LinearTensorParent(free_module, self)
+
+    def gen(self, i):
+        """
+        Return the linear variable `x_i`.
+
+        INPUT:
+
+        - ``i`` -- nonnegative integer
+
+        OUTPUT: the linear function `x_i`
+
+        EXAMPLES::
+
+            sage: LF = MixedIntegerLinearProgram().linear_functions_parent()
+            sage: LF.gen(23)
+            x_23
+        """
+        return LinearFunction(self, {i: 1})
+
+    def _repr_(self):
+        """
+        Return as string representation.
+
+        EXAMPLES::
+
+            sage: MixedIntegerLinearProgram().linear_functions_parent()
+            Linear functions over Real Double Field
+        """
+        return 'Linear functions over ' + str(self.base_ring())
+
+    cpdef _element_constructor_(self, x):
+        """
+        Construct a :class:`LinearFunction` from ``x``.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: LF._element_constructor_(123)
+            123
+            sage: LF(123)    # indirect doctest
+            123
+            sage: type(_)
+            <class 'sage.numerical.linear_functions.LinearFunction'>
+
+            sage: p_QQ = MixedIntegerLinearProgram(solver='ppl')
+            sage: LF_QQ = p_QQ.linear_functions_parent()
+            sage: f = LF({-1:1/2, 2:3/4});  f
+            0.5 + 0.75*x_2
+            sage: LF(f) is f
+            True
+            sage: LF_QQ(f)
+            1/2 + 3/4*x_2
+            sage: LF_QQ(f) is f
+            False
+        """
+        if isinstance(x, LinearFunction):
+            return LinearFunction(self, (<LinearFunction>x)._f)
+        return LinearFunction(self, x)
+
+    cpdef _coerce_map_from_(self, R):
+        """
+        Allow coercion of scalars into linear functions.
+
+        INPUT:
+
+        - ``R`` -- a ring
+
+        OUTPUT: boolean; whether there is a coercion map
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: parent = p.linear_functions_parent()
+            sage: parent.coerce(int(2))
+            2
+            sage: parent._coerce_map_from_(int)
+            True
+        """
+        from sage.structure.coerce import parent_is_real_numerical
+        if parent_is_real_numerical(R) or R is complex:
+            return True
+        return False
+
+    def _an_element_(self):
+        """
+        Return an element.
+
+        OUTPUT: a linear function
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram().linear_functions_parent()
+            sage: p._an_element_()
+            5*x_2 + 7*x_5
+            sage: p.an_element()   # indirect doctest
+            5*x_2 + 7*x_5
+        """
+        return self._element_constructor_({2:5, 5:7})
+
+
+#*****************************************************************************
+#
+# Elements of linear functions
+#
+#*****************************************************************************
+
+cdef class LinearFunction(LinearFunctionOrConstraint):
+    r"""
+    An elementary algebra to represent symbolic linear functions.
+
+    .. warning::
+
+        You should never instantiate :class:`LinearFunction`
+        manually. Use the element constructor in the parent
+        instead.
+
+    EXAMPLES:
+
+    For example, do this::
+
+        sage: p = MixedIntegerLinearProgram()
+        sage: parent = p.linear_functions_parent()
+        sage: parent({0 : 1, 3 : -8})
+        x_0 - 8*x_3
+
+    instead of this::
+
+        sage: from sage.numerical.linear_functions import LinearFunction
+        sage: LinearFunction(p.linear_functions_parent(), {0 : 1, 3 : -8})
+        x_0 - 8*x_3
+    """
+
+    def __init__(self, parent, f):
+        r"""
+        Constructor taking a dictionary or a numerical value as its argument.
+
+        A linear function is represented as a dictionary. The
+        values are the coefficient of the variable represented
+        by the keys ( which are integers ). The key ``-1``
+        corresponds to the constant term.
+
+        EXAMPLES:
+
+        With a dictionary::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: LF({0 : 1, 3 : -8})
+            x_0 - 8*x_3
+
+        Using the constructor with a numerical value::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: LF(25)
+            25
+        """
+        ModuleElement.__init__(self, parent)
+        R = self.base_ring()
+        if isinstance(f, dict):
+            self._f = dict( (int(key), R(value)) for key, value in f.iteritems() )
+        else:
+            self._f = {-1: R(f)}
+
+    cpdef iteritems(self):
+        """
+        Iterate over the index, coefficient pairs.
+
+        OUTPUT:
+
+        An iterator over the ``(key, coefficient)`` pairs. The keys
+        are integers indexing the variables. The key ``-1``
+        corresponds to the constant term.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram(solver = 'ppl')
+            sage: x = p.new_variable()
+            sage: f = 0.5 + 3/2*x[1] + 0.6*x[3]
+            sage: for id, coeff in sorted(f.iteritems()):
+            ....:     print('id = {}   coeff = {}'.format(id, coeff))
+            id = -1   coeff = 1/2
+            id = 0   coeff = 3/2
+            id = 1   coeff = 3/5
+        """
+        return self._f.iteritems()
+
+    def dict(self):
+        r"""
+        Return the dictionary corresponding to the Linear Function.
+
+        OUTPUT:
+
+        The linear function is represented as a dictionary. The value
+        are the coefficient of the variable represented by the keys (
+        which are integers ). The key ``-1`` corresponds to the
+        constant term.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: lf = LF({0 : 1, 3 : -8})
+            sage: lf.dict()
+            {0: 1.0, 3: -8.0}
+        """
+        return dict(self._f)
+
+    def coefficient(self, x):
+        r"""
+        Return one of the coefficients.
+
+        INPUT:
+
+        - ``x`` -- a linear variable or an integer; if an integer `i`
+          is passed, then `x_i` is used as linear variable
+
+        OUTPUT:
+
+        A base ring element. The coefficient of ``x`` in the linear
+        function. Pass ``-1`` for the constant term.
+
+        EXAMPLES::
+
+            sage: mip.<b> = MixedIntegerLinearProgram()
+            sage: lf = -8 * b[3] + b[0] - 5;  lf
+            -5 - 8*x_0 + x_1
+            sage: lf.coefficient(b[3])
+            -8.0
+            sage: lf.coefficient(0)      # x_0 is b[3]
+            -8.0
+            sage: lf.coefficient(4)
+            0.0
+            sage: lf.coefficient(-1)
+            -5.0
+
+        TESTS::
+
+            sage: lf.coefficient(b[3] + b[4])
+            Traceback (most recent call last):
+            ...
+            ValueError: x is a sum, must be a single variable
+            sage: lf.coefficient(2*b[3])
+            Traceback (most recent call last):
+            ...
+            ValueError: x must have a unit coefficient
+            sage: mip.<q> = MixedIntegerLinearProgram(solver='ppl')
+            sage: lf.coefficient(q[0])
+            Traceback (most recent call last):
+            ...
+            ValueError: x is from a different linear functions module
+        """
+        if isinstance(x, LinearFunction):
+            if self.parent() != x.parent():
+                raise ValueError('x is from a different linear functions module')
+            if len((<LinearFunction>x)._f) != 1:
+                raise ValueError('x is a sum, must be a single variable')
+            i, = (<LinearFunction>x)._f.keys()
+            if (<LinearFunction>x)._f[i] != 1:
+                raise ValueError('x must have a unit coefficient')
+        else:
+            i = int(x)
+        try:
+            return self._f[i]
+        except KeyError:
+            return self.parent().base_ring().zero()
+
+    cpdef _add_(self, b):
+        r"""
+        Defining the ``+`` operator.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: LF({0 : 1, 3 : -8}) + LF({2 : 5, 3 : 2}) - 16
+            -16 + x_0 + 5*x_2 - 6*x_3
+        """
+        e = dict(self._f)
+        for (id,coeff) in b.dict().iteritems():
+            e[id] = self._f.get(id,0) + coeff
+        P = self.parent()
+        return P(e)
+
+    cpdef _neg_(self):
+        r"""
+        Defining the - operator (opposite).
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: - LF({0 : 1, 3 : -8})
+            -1*x_0 + 8*x_3
+        """
+        P = self.parent()
+        return P({id: -coeff for id, coeff in self._f.iteritems()})
+
+    cpdef _sub_(self, b):
+        r"""
+        Defining the - operator (subtraction).
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: LF({2 : 5, 3 : 2}) - 3
+            -3 + 5*x_2 + 2*x_3
+            sage: LF({0 : 1, 3 : -8}) - LF({2 : 5, 3 : 2}) - 16
+            -16 + x_0 - 5*x_2 - 10*x_3
+        """
+        e = dict(self._f)
+        for id, coeff in b.dict().iteritems():
+            e[id] = self._f.get(id, 0) - coeff
+        P = self.parent()
+        return P(e)
+
+    cpdef _lmul_(self, Element b):
+        r"""
+        Multiplication by scalars.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: LF({2 : 5, 3 : 2}) * 3
+            15*x_2 + 6*x_3
+            sage: 3 * LF({2 : 5, 3 : 2})
+            15*x_2 + 6*x_3
+        """
+        P = self.parent()
+        return P(dict([(id,b*coeff) for (id, coeff) in self._f.iteritems()]))
+
+    cpdef _acted_upon_(self, x, bint self_on_left):
+        """
+        Act with scalars that do not have a natural coercion into
+        ``self.base_ring()``
+
+        EXAMPLES:
+
+        Note that there is no coercion from ``RR`` to ``QQ``, but you
+        can explicitly convert them::
+
+            sage: 1/2 * 0.6
+            0.300000000000000
+
+        If there were a coercion, then 0.6 would have been coerced into
+        6/10 and the result would have been rational. This is
+        undesirable, which is why there cannot be a coercion on the
+        level of the coefficient rings.
+
+        By declaring an action of ``RR`` on the linear functions over
+        ``QQ`` we make the following possible::
+
+            sage: p = MixedIntegerLinearProgram(solver='ppl')
+            sage: p.base_ring()
+            Rational Field
+            sage: x = p.new_variable()
+            sage: x[0] * 0.6
+            3/5*x_0
+
+            sage: vf = (2 + x[0]) * vector(ZZ, [3,4]);  vf
+            (6, 8) + (3, 4)*x_0
+            sage: vf.parent()
+            Tensor product of Vector space of dimension 2 over Rational Field
+            and Linear functions over Rational Field
+
+            sage: tf = x[0] * identity_matrix(2);  tf
+            [x_0 0  ]
+            [0   x_0]
+            sage: tf.parent()
+            Tensor product of Full MatrixSpace of 2 by 2 dense matrices over
+            Rational Field and Linear functions over Rational Field
+        """
+        R = self.base_ring()
+        try:
+            x_R = R(x)
+        except TypeError:
+            M = x.parent().base_extend(R)
+            x_M = M(x)
+            from sage.numerical.linear_tensor import LinearTensorParent
+            P = LinearTensorParent(M, self.parent())
+            tensor = dict()
+            for k, v in self._f.items():
+                tensor[k] = x_M * v
+            return P(tensor)
+        return self._rmul_(x_R)
+
+    def _coeff_formatter(self, coeff, constant_term=False):
+        """
+        Pretty-print multiplicative coefficient ``x``.
+
+        OUTPUT:
+
+        string, including a trailing space if the coefficient is not
+        one. Empty string otherwise.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LF = p.linear_functions_parent()
+            sage: f = LF(1);  type(f)
+            <class 'sage.numerical.linear_functions.LinearFunction'>
+            sage: f._coeff_formatter(1)
+            ''
+            sage: f._coeff_formatter(1, constant_term=True)
+            '1'
+            sage: f._coeff_formatter(RDF(12.0))
+            '12*'
+            sage: f._coeff_formatter(RDF(12.3))
+            '12.3*'
+
+            sage: p = MixedIntegerLinearProgram(solver='ppl')
+            sage: LF = p.linear_functions_parent()
+            sage: f = LF(1)
+            sage: f._coeff_formatter(13/45)
+            '13/45*'
+
+            sage: # needs sage.rings.number_field
+            sage: from sage.rings.number_field.number_field import QuadraticField
+            sage: K.<sqrt5> = QuadraticField(5, 'sqrt5')
+            sage: p = MixedIntegerLinearProgram(solver='interactivelp', base_ring=K)
+            sage: LF = p.linear_functions_parent()
+            sage: f = LF(1)
+            sage: f._coeff_formatter(sqrt5)
+            'sqrt5*'
+
+            sage: # needs sage.rings.number_field
+            sage: from sage.rings.qqbar import AA
+            sage: sqrt5 = AA(5).sqrt()
+            sage: p = MixedIntegerLinearProgram(solver='interactivelp', base_ring=AA)
+            sage: LF = p.linear_functions_parent()
+            sage: f = LF(1)
+            sage: f._coeff_formatter(sqrt5)
+            '2.236067977499790?*'
+        """
+        R = self.base_ring()
+        if coeff == R.one() and not constant_term:
+            return ''
+        try:
+            from sage.rings.integer_ring import ZZ
+            coeff = ZZ(coeff)
+        except (TypeError, ValueError):
+            pass
+        if constant_term:
+            return str(coeff)
+        else:
+            return str(coeff) + self.parent()._multiplication_symbol
+
+    def _repr_(self):
+        r"""
+        Return a string version of the linear function.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram(solver='GLPK')
+            sage: LF = p.linear_functions_parent()
+            sage: LF({-1: -15, 2 : -5.1, 3 : 2/3})
+            -15 - 5.1*x_2 + 0.6666666666666666*x_3
+            sage: p = MixedIntegerLinearProgram(solver='ppl')
+            sage: LF = p.linear_functions_parent()
+            sage: LF({-1: -15, 2 : -5.1, 3 : 2/3})
+            -15 - 51/10*x_2 + 2/3*x_3
+        """
+        cdef dict d = dict(self._f)
+        cdef bint first = True
+        t = ""
+
+        if -1 in d:
+            coeff = d.pop(-1)
+            if coeff:
+                t = self._coeff_formatter(coeff, constant_term=True)
+                first = False
+
+        cdef list l = sorted(d.items())
+        for id, coeff in l:
+            sign = coeff.sign()
+            if sign == 0:
+                continue
+            if not first:
+                if sign == -1:
+                    t += ' - '
+                if sign == +1:
+                    t += ' + '
+                t += self._coeff_formatter(abs(coeff)) + 'x_' + str(id)
+            else:
+                t += self._coeff_formatter(coeff) + 'x_' + str(id)
+            first = False
+
+        if first:
+            return '0'
+        else:
+            return t
+
+    cpdef is_zero(self):
+        """
+        Test whether ``self`` is zero.
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: x = p.new_variable()
+            sage: (x[1] - x[1] + 0*x[2]).is_zero()
+            True
+        """
+        for coeff in self._f.values():
+            if not coeff.is_zero():
+                return False
+        return True
+
+    cpdef equals(LinearFunction left, LinearFunction right):
+        """
+        Logically compare ``left`` and ``right``.
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: x = p.new_variable()
+            sage: (x[1] + 1).equals(3/3 + 1*x[1] + 0*x[2])
+            True
+        """
+        return (left-right).is_zero()
+
+
+#*****************************************************************************
+#
+# Parent of linear constraints
+#
+#*****************************************************************************
+
+cdef class LinearConstraintsParent_class(Parent):
+    """
+    Parent for :class:`LinearConstraint`.
+
+    .. warning::
+
+        This class has no reason to be instantiated by the user, and
+        is meant to be used by instances of
+        :class:`MixedIntegerLinearProgram`. Also, use the
+        :func:`LinearConstraintsParent` factory function.
+
+    INPUT/OUTPUT: see :func:`LinearFunctionsParent`
+
+    EXAMPLES::
+
+        sage: p = MixedIntegerLinearProgram()
+        sage: LC = p.linear_constraints_parent();  LC
+        Linear constraints over Real Double Field
+        sage: from sage.numerical.linear_functions import LinearConstraintsParent
+        sage: LinearConstraintsParent(p.linear_functions_parent()) is LC
+        True
+    """
+    def __cinit__(self, linear_functions_parent):
+        """
+        Cython initializer.
+
+        TESTS::
+
+            sage: from sage.numerical.linear_functions import LinearConstraintsParent_class
+            sage: from sage.numerical.linear_functions import LinearFunctionsParent
+            sage: LF = LinearFunctionsParent(RDF)
+            sage: LinearConstraintsParent_class.__new__(LinearConstraintsParent_class, LF)
+            Linear constraints over Real Double Field
+            sage: LinearConstraintsParent_class.__new__(LinearConstraintsParent_class, None)
+            Traceback (most recent call last):
+            ...
+            TypeError: Cannot convert NoneType to sage.numerical.linear_functions.LinearFunctionsParent_class
+        """
+        self._LF = <LinearFunctionsParent_class?>linear_functions_parent
+        # Do not use coercion framework for __richcmp__
+        self.flags |= Parent_richcmp_element_without_coercion
+
+    def __init__(self, linear_functions_parent):
+        """
+        The Python constructor.
+
+        INPUT/OUTPUT: see :func:`LinearFunctionsParent`
+
+        TESTS::
+
+            sage: from sage.numerical.linear_functions import LinearFunctionsParent
+            sage: LF = LinearFunctionsParent(RDF)
+            sage: from sage.numerical.linear_functions import LinearConstraintsParent
+            sage: LinearConstraintsParent(LF)
+            Linear constraints over Real Double Field
+            sage: LinearConstraintsParent(None)
+            Traceback (most recent call last):
+            ...
+            TypeError: Cannot convert NoneType to sage.numerical.linear_functions.LinearFunctionsParent_class
+        """
+        Parent.__init__(self)
+
+    def linear_functions_parent(self):
+        """
+        Return the parent for the linear functions.
+
+        EXAMPLES::
+
+            sage: LC = MixedIntegerLinearProgram().linear_constraints_parent()
+            sage: LC.linear_functions_parent()
+            Linear functions over Real Double Field
+        """
+        return self._LF
+
+    def _repr_(self):
+        """
+        Return a string representation.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: MixedIntegerLinearProgram().linear_constraints_parent()
+            Linear constraints over Real Double Field
+        """
+        return 'Linear constraints over ' + str(self.linear_functions_parent().base_ring())
+
+    cpdef _element_constructor_(self, left, right=None, equality=False):
+        """
+        Construct a :class:`LinearConstraint`.
+
+        INPUT:
+
+        - ``left`` -- a :class:`LinearFunction`, or something that can
+          be converted into one, a list/tuple of
+          :class:`LinearFunction`, or an existing
+          :class:`LinearConstraint`.
+
+        - ``right`` -- a :class:`LinearFunction` or ``None``
+          (default)
+
+        - ``equality`` -- boolean (default: ``True``); whether to
+          construct an equation or an inequality
+
+        OUTPUT: the :class:`LinearConstraint` constructed from the input data
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LC = p.linear_constraints_parent()
+            sage: LC._element_constructor_(1, 2)
+            1 <= 2
+
+            sage: x = p.new_variable()
+            sage: LC([x[0], x[1], x[2]])
+            x_0 <= x_1 <= x_2
+
+            sage: LC([x[0], x[1], x[2]], equality=True)
+            x_0 == x_1 == x_2
+
+            sage: type(_)
+            <class 'sage.numerical.linear_functions.LinearConstraint'>
+
+        TESTS::
+
+            sage: inequality = LC([x[0], 1/2*x[1], 3/4*x[2]]); inequality
+            x_0 <= 0.5*x_1 <= 0.75*x_2
+            sage: LC(inequality) is inequality
+            True
+            sage: p_QQ = MixedIntegerLinearProgram(solver='ppl')
+            sage: LC_QQ = p_QQ.linear_constraints_parent()
+            sage: LC_QQ(inequality)
+            x_0 <= 1/2*x_1 <= 3/4*x_2
+            sage: LC_QQ(inequality) is inequality
+            False
+        """
+        if right is None and isinstance(left, LinearConstraint):
+            if (left.parent() is self) and (left.is_equation() == equality):
+                return left
+            else:
+                return LinearConstraint(self, (<LinearConstraint>left).constraints,
+                                        equality=equality)
+        if right is None:
+            if isinstance(left, (list,tuple)):
+                return LinearConstraint(self, left, equality=equality)
+            else:
+                return LinearConstraint(self, [left], equality=equality)
+        else:
+            return LinearConstraint(self, [left, right], equality=equality)
+
+    cpdef _coerce_map_from_(self, R):
+        """
+        Allow coercion of scalars into linear functions.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: parent = p.linear_constraints_parent()
+            sage: parent.coerce(int(2))
+            trivial constraint starting with 2
+            sage: parent._coerce_map_from_(int)
+            True
+        """
+        return self.linear_functions_parent().has_coerce_map_from(R)
+
+    def _an_element_(self):
+        """
+        Return an element.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram().linear_functions_parent()
+            sage: p._an_element_()
+            5*x_2 + 7*x_5
+            sage: p.an_element()   # indirect doctest
+            5*x_2 + 7*x_5
+        """
+        LF = self.linear_functions_parent()
+        return self(0) <= LF.an_element()
+
+
+#*****************************************************************************
+#
+# Elements of linear constraints
+#
+#*****************************************************************************
+
+cdef class LinearConstraint(LinearFunctionOrConstraint):
+    """
+    A class to represent formal Linear Constraints.
+
+    A Linear Constraint being an inequality between
+    two linear functions, this class lets the user
+    write ``LinearFunction1 <= LinearFunction2``
+    to define the corresponding constraint, which
+    can potentially involve several layers of such
+    inequalities (``A <= B <= C``), or even equalities
+    like ``A == B == C``.
+
+    Trivial constraints (meaning that they have only one term and no
+    relation) are also allowed. They are required for the coercion
+    system to work.
+
+    .. warning::
+
+        This class has no reason to be instantiated by the user, and
+        is meant to be used by instances of
+        :class:`MixedIntegerLinearProgram`.
+
+    INPUT:
+
+    - ``parent`` -- the parent; a :class:`LinearConstraintsParent_class`
+
+    - ``terms`` -- list/tuple/iterable of two or more linear
+      functions (or things that can be converted into linear
+      functions)
+
+    - ``equality`` -- boolean (default: ``False``); whether the terms
+      are the entries of a chained less-or-equal (``<=``) inequality
+      or a chained equality
+
+    EXAMPLES::
+
+        sage: p = MixedIntegerLinearProgram()
+        sage: b = p.new_variable()
+        sage: b[2]+2*b[3] <= b[8]-5
+        x_0 + 2*x_1 <= -5 + x_2
+    """
+
+    def __init__(self, parent, terms, equality=False):
+        r"""
+        Constructor for ``LinearConstraint``.
+
+        INPUT:
+
+        See :class:`LinearConstraint`.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: b = p.new_variable()
+            sage: b[2]+2*b[3] <= b[8]-5
+            x_0 + 2*x_1 <= -5 + x_2
+        """
+        assert len(terms) > 0
+        super().__init__(parent)
+        self.equality = equality
+        LF = parent.linear_functions_parent()
+        self.constraints = [ LF(term) for term in terms ]
+
+    cpdef equals(LinearConstraint left, LinearConstraint right):
+        """
+        Compare ``left`` and ``right``.
+
+        OUTPUT:
+
+        boolean; whether all terms of ``left`` and ``right`` are
+        equal. Note that this is stronger than mathematical
+        equivalence of the relations.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: x = p.new_variable()
+            sage: (x[1] + 1 >= 2).equals(3/3 + 1*x[1] + 0*x[2] >= 8/4)
+            True
+            sage: (x[1] + 1 >= 2).equals(x[1] + 1-1 >= 1-1)
+            False
+        """
+        if len(left.constraints) != len(right.constraints):
+            return False
+        if left.equality != right.equality:
+            return False
+        cdef LinearFunction l, r
+        for i in range(len(left.constraints)):
+            l = <LinearFunction>(left.constraints[i])
+            r = <LinearFunction>(right.constraints[i])
+            if not l.equals(r):
+                return False
+        return True
+
+    def is_equation(self):
+        """
+        Whether the constraint is a chained equation.
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: b = p.new_variable()
+            sage: (b[0] == b[1]).is_equation()
+            True
+            sage: (b[0] <= b[1]).is_equation()
+            False
+        """
+        return self.equality
+
+    def is_less_or_equal(self):
+        """
+        Whether the constraint is a chained less-or_equal inequality.
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: b = p.new_variable()
+            sage: (b[0] == b[1]).is_less_or_equal()
+            False
+            sage: (b[0] <= b[1]).is_less_or_equal()
+            True
+        """
+        return not self.equality
+
+    def is_trivial(self):
+        """
+        Test whether the constraint is trivial.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: LC = p.linear_constraints_parent()
+            sage: ieq = LC(1,2);  ieq
+            1 <= 2
+            sage: ieq.is_trivial()
+            False
+
+            sage: ieq = LC(1);  ieq
+            trivial constraint starting with 1
+            sage: ieq.is_trivial()
+            True
+        """
+        return len(self.constraints) < 2
+
+    def __iter__(self):
+        """
+        Iterate over the terms of the chained (in)-equality.
+
+        OUTPUT:
+
+        A generator yielding the individual terms of the constraint in
+        left-to-right order.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: b = p.new_variable()
+            sage: ieq = 1 <= b[0] <= b[2] <= 3 <= b[3];  ieq
+            1 <= x_0 <= x_1 <= 3 <= x_2
+            sage: list(ieq)
+            [1, x_0, x_1, 3, x_2]
+            sage: for term in ieq:
+            ....:     print(term)
+            1
+            x_0
+            x_1
+            3
+            x_2
+        """
+        for term in self.constraints:
+            yield term
+
+    def equations(self):
+        """
+        Iterate over the unchained(!) equations.
+
+        OUTPUT:
+
+        An iterator over pairs ``(lhs, rhs)`` such that the individual
+        equations are ``lhs == rhs``.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: b = p.new_variable()
+            sage: eqns = 1 == b[0] == b[2] == 3 == b[3];  eqns
+            1 == x_0 == x_1 == 3 == x_2
+            sage: for lhs, rhs in eqns.equations():
+            ....:     print(str(lhs) + ' == ' + str(rhs))
+            1 == x_0
+            x_0 == x_1
+            x_1 == 3
+            3 == x_2
+        """
+        if not self.is_equation() or self.is_trivial():
+            return
+        term_iter = iter(self)
+        lhs = next(term_iter)
+        rhs = next(term_iter)
+        while True:
+            yield (lhs, rhs)
+            lhs = rhs
+            try:
+                rhs = next(term_iter)
+            except StopIteration:
+                return
+
+    def inequalities(self):
+        """
+        Iterate over the unchained(!) inequalities.
+
+        OUTPUT:
+
+        An iterator over pairs ``(lhs, rhs)`` such that the individual
+        equations are ``lhs <= rhs``.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: b = p.new_variable()
+            sage: ieq = 1 <= b[0] <= b[2] <= 3 <= b[3]; ieq
+            1 <= x_0 <= x_1 <= 3 <= x_2
+
+            sage: for lhs, rhs in ieq.inequalities():
+            ....:     print(str(lhs) + ' <= ' + str(rhs))
+            1 <= x_0
+            x_0 <= x_1
+            x_1 <= 3
+            3 <= x_2
+        """
+        if not self.is_less_or_equal() or self.is_trivial():
+            return
+        term_iter = iter(self)
+        lhs = next(term_iter)
+        rhs = next(term_iter)
+        while True:
+            yield (lhs, rhs)
+            lhs = rhs
+            try:
+                rhs = next(term_iter)
+            except StopIteration:
+                return
+
+    def _repr_(self):
+        r"""
+        Return a string representation of the constraint.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: b = p.new_variable()
+            sage: b[3] <= b[8] + 9
+            x_0 <= 9 + x_1
+
+            sage: LC = p.linear_constraints_parent()
+            sage: LC(b[3], b[8] + 9)
+            x_0 <= 9 + x_1
+            sage: LC(b[3])
+            trivial constraint starting with x_0
+        """
+        comparator = (' == ' if self.equality else ' <= ')
+        result = comparator.join(map(str, self))
+        if self.is_trivial():
+            return 'trivial constraint starting with ' + result
+        return result
+
+    def __bool__(self):
+        """
+        Part of the hack to allow chained (in)equalities.
+
+        EXAMPLES::
+
+            sage: p = MixedIntegerLinearProgram()
+            sage: b = p.new_variable()
+            sage: ieq = (b[3] <= b[8] + 9)
+            sage: ieq <= ieq <= ieq
+            x_0 <= 9 + x_1 <= x_0 <= 9 + x_1 <= x_0 <= 9 + x_1
+        """
+        global chained_comparator_replace
+        chained_comparator_replace = self
+        return True