# Poly solvers#

This module provides functions for solving systems of linear equations that are used internally in sympy.

Low-level linear systems solver.

sympy.polys.solvers.solve_lin_sys(eqs, ring, _raw=True)[source]#

Solve a system of linear equations from a PolynomialRing

Parameters:

eqs: list[PolyElement]

The linear equations to be solved as elements of a PolynomialRing (assumed equal to zero).

ring: PolynomialRing

The polynomial ring from which eqs are drawn. The generators of this ring are the unknowns to be solved for and the domain of the ring is the domain of the coefficients of the system of equations.

_raw: bool

If _raw is False, the keys and values in the returned dictionary will be of type Expr (and the unit of the field will be removed from the keys) otherwise the low-level polys types will be returned, e.g. PolyElement: PythonRational.

Returns:

None if the system has no solution.

dict[Symbol, Expr] if _raw=False

dict[Symbol, DomainElement] if _raw=True.

Explanation

Solves a system of linear equations given as PolyElement instances of a PolynomialRing. The basic arithmetic is carried out using instance of DomainElement which is more efficient than Expr for the most common inputs.

While this is a public function it is intended primarily for internal use so its interface is not necessarily convenient. Users are suggested to use the sympy.solvers.solveset.linsolve() function (which uses this function internally) instead.

Examples

>>> from sympy import symbols
>>> from sympy.polys.solvers import solve_lin_sys, sympy_eqs_to_ring
>>> x, y = symbols('x, y')
>>> eqs = [x - y, x + y - 2]
>>> eqs_ring, ring = sympy_eqs_to_ring(eqs, [x, y])
>>> solve_lin_sys(eqs_ring, ring)
{y: 1, x: 1}


Passing _raw=False returns the same result except that the keys are Expr rather than low-level poly types.

>>> solve_lin_sys(eqs_ring, ring, _raw=False)
{x: 1, y: 1}


sympy_eqs_to_ring

prepares the inputs to solve_lin_sys.

linsolve

linsolve uses solve_lin_sys internally.

sympy.solvers.solvers.solve

solve uses solve_lin_sys internally.

sympy.polys.solvers.eqs_to_matrix(eqs_coeffs, eqs_rhs, gens, domain)[source]#

Get matrix from linear equations in dict format.

Parameters:

eqs_coeffs: list[dict[Symbol, DomainElement]]

The left hand sides of the equations as dicts mapping from symbols to coefficients where the coefficients are instances of DomainElement.

eqs_rhs: list[DomainElements]

The right hand sides of the equations as instances of DomainElement.

gens: list[Symbol]

The unknowns in the system of equations.

domain: Domain

The domain for coefficients of both lhs and rhs.

Returns:

The augmented matrix representation of the system as a DomainMatrix.

Explanation

Get the matrix representation of a system of linear equations represented as dicts with low-level DomainElement coefficients. This is an internal function that is used by solve_lin_sys.

Examples

>>> from sympy import symbols, ZZ
>>> from sympy.polys.solvers import eqs_to_matrix
>>> x, y = symbols('x, y')
>>> eqs_coeff = [{x:ZZ(1), y:ZZ(1)}, {x:ZZ(1), y:ZZ(-1)}]
>>> eqs_rhs = [ZZ(0), ZZ(-1)]
>>> eqs_to_matrix(eqs_coeff, eqs_rhs, [x, y], ZZ)
DomainMatrix([[1, 1, 0], [1, -1, 1]], (2, 3), ZZ)

sympy.polys.solvers.sympy_eqs_to_ring(eqs, symbols)[source]#

Convert a system of equations from Expr to a PolyRing

Parameters:

eqs: List of Expr

A list of equations as Expr instances

symbols: List of Symbol

A list of the symbols that are the unknowns in the system of equations.

Returns:

Tuple[List[PolyElement], Ring]: The equations as PolyElement instances

and the ring of polynomials within which each equation is represented.

Explanation

High-level functions like solve expect Expr as inputs but can use solve_lin_sys internally. This function converts equations from Expr to the low-level poly types used by the solve_lin_sys function.

Examples

>>> from sympy import symbols
>>> from sympy.polys.solvers import sympy_eqs_to_ring
>>> a, x, y = symbols('a, x, y')
>>> eqs = [x-y, x+a*y]
>>> eqs_ring, ring = sympy_eqs_to_ring(eqs, [x, y])
>>> eqs_ring
[x - y, x + a*y]
>>> type(eqs_ring)
<class 'sympy.polys.rings.PolyElement'>
>>> ring
ZZ(a)[x,y]


With the equations in this form they can be passed to solve_lin_sys:

>>> from sympy.polys.solvers import solve_lin_sys
>>> solve_lin_sys(eqs_ring, ring)
{y: 0, x: 0}

sympy.polys.solvers._solve_lin_sys(eqs_coeffs, eqs_rhs, ring)[source]#

Solve a linear system from dict of PolynomialRing coefficients

Explanation

This is an internal function used by solve_lin_sys() after the equations have been preprocessed. The role of this function is to split the system into connected components and pass those to _solve_lin_sys_component().

Examples

Setup a system for $$x-y=0$$ and $$x+y=2$$ and solve:

>>> from sympy import symbols, sring
>>> from sympy.polys.solvers import _solve_lin_sys
>>> x, y = symbols('x, y')
>>> R, (xr, yr) = sring([x, y], [x, y])
>>> eqs = [{xr:R.one, yr:-R.one}, {xr:R.one, yr:R.one}]
>>> eqs_rhs = [R.zero, -2*R.one]
>>> _solve_lin_sys(eqs, eqs_rhs, R)
{y: 1, x: 1}


solve_lin_sys

This function is used internally by solve_lin_sys().

sympy.polys.solvers._solve_lin_sys_component(eqs_coeffs, eqs_rhs, ring)[source]#

Solve a linear system from dict of PolynomialRing coefficients

Explanation

This is an internal function used by solve_lin_sys() after the equations have been preprocessed. After _solve_lin_sys() splits the system into connected components this function is called for each component. The system of equations is solved using Gauss-Jordan elimination with division followed by back-substitution.

Examples

Setup a system for $$x-y=0$$ and $$x+y=2$$ and solve:

>>> from sympy import symbols, sring
>>> from sympy.polys.solvers import _solve_lin_sys_component
>>> x, y = symbols('x, y')
>>> R, (xr, yr) = sring([x, y], [x, y])
>>> eqs = [{xr:R.one, yr:-R.one}, {xr:R.one, yr:R.one}]
>>> eqs_rhs = [R.zero, -2*R.one]
>>> _solve_lin_sys_component(eqs, eqs_rhs, R)
{y: 1, x: 1}


solve_lin_sys
This function is used internally by solve_lin_sys().