Solvers¶

The solvers module in SymPy implements methods for solving equations.

Algebraic equations¶

Use solve() to solve algebraic equations. We suppose all equations are equaled to 0, so solving x**2 == 1 translates into the following code:

>>> from sympy.solvers import solve
>>> from sympy import Symbol
>>> x = Symbol('x')
>>> solve(x**2 - 1, x)
[-1, 1]

The first argument for solve() is an equation (equaled to zero) and the second argument is the symbol that we want to solve the equation for.

sympy.solvers.solvers.solve(f, *symbols, **flags)[source]¶

Algebraically solves equations and systems of equations.

Currently supported are:

univariate polynomial,
transcendental
piecewise combinations of the above
systems of linear and polynomial equations
sytems containing relational expressions.

Input is formed as:

f
- a single Expr or Poly that must be zero,
- an Equality
- a Relational expression or boolean
- iterable of one or more of the above
symbols (object(s) to solve for) specified as
- none given (other non-numeric objects will be used)
- single symbol
- denested list of symbols e.g. solve(f, x, y)
- ordered iterable of symbols e.g. solve(f, [x, y])
flags

‘dict’=True (default is False)

return list (perhaps empty) of solution mappings

‘set’=True (default is False)

return list of symbols and set of tuple(s) of solution(s)

‘exclude=[] (default)’

don’t try to solve for any of the free symbols in exclude; if expressions are given, the free symbols in them will be extracted automatically.

‘check=True (default)’

If False, don’t do any testing of solutions. This can be useful if one wants to include solutions that make any denominator zero.

‘numerical=True (default)’

do a fast numerical check if f has only one symbol.

‘minimal=True (default is False)’

a very fast, minimal testing.

‘warning=True (default is False)’

show a warning if checksol() could not conclude.

‘simplify=True (default)’

simplify all but cubic and quartic solutions before returning them and (if check is not False) use the general simplify function on the solutions and the expression obtained when they are substituted into the function which should be zero

‘force=True (default is False)’

make positive all symbols without assumptions regarding sign.

‘rational=True (default)’

recast Floats as Rational; if this option is not used, the system containing floats may fail to solve because of issues with polys. If rational=None, Floats will be recast as rationals but the answer will be recast as Floats. If the flag is False then nothing will be done to the Floats.

‘manual=True (default is False)’

do not use the polys/matrix method to solve a system of equations, solve them one at a time as you might “manually”.

‘implicit=True (default is False)’

allows solve to return a solution for a pattern in terms of other functions that contain that pattern; this is only needed if the pattern is inside of some invertible function like cos, exp, ....

‘particular=True (default is False)’

instructs solve to try to find a particular solution to a linear system with as many zeros as possible; this is very expensive

‘quick=True (default is False)’

when using particular=True, use a fast heuristic instead to find a solution with many zeros (instead of using the very slow method guaranteed to find the largest number of zeros possible)

Notes

assumptions aren’t checked when \(solve()\) input involves relationals or bools.

When the solutions are checked, those that make any denominator zero are automatically excluded. If you do not want to exclude such solutions then use the check=False option:

>>> from sympy import sin, limit
>>> solve(sin(x)/x)  # 0 is excluded
[pi]

If check=False then a solution to the numerator being zero is found: x = 0. In this case, this is a spurious solution since sin(x)/x has the well known limit (without dicontinuity) of 1 at x = 0:

>>> solve(sin(x)/x, check=False)
[0, pi]

In the following case, however, the limit exists and is equal to the the value of x = 0 that is excluded when check=True:

>>> eq = x**2*(1/x - z**2/x)
>>> solve(eq, x)
[]
>>> solve(eq, x, check=False)
[0]
>>> limit(eq, x, 0, '-')
0
>>> limit(eq, x, 0, '+')
0

Examples

The output varies according to the input and can be seen by example:

>>> from sympy import solve, Poly, Eq, Function, exp
>>> from sympy.abc import x, y, z, a, b
>>> f = Function('f')

boolean or univariate Relational

>>> solve(x < 3)
And(im(x) == 0, re(x) < 3)

to always get a list of solution mappings, use flag dict=True

>>> solve(x - 3, dict=True)
[{x: 3}]
>>> solve([x - 3, y - 1], dict=True)
[{x: 3, y: 1}]

to get a list of symbols and set of solution(s) use flag set=True

>>> solve([x**2 - 3, y - 1], set=True)
([x, y], set([(-sqrt(3), 1), (sqrt(3), 1)]))

single expression and single symbol that is in the expression

>>> solve(x - y, x)
[y]
>>> solve(x - 3, x)
[3]
>>> solve(Eq(x, 3), x)
[3]
>>> solve(Poly(x - 3), x)
[3]
>>> solve(x**2 - y**2, x, set=True)
([x], set([(-y,), (y,)]))
>>> solve(x**4 - 1, x, set=True)
([x], set([(-1,), (1,), (-I,), (I,)]))

single expression with no symbol that is in the expression
```
>>> solve(3, x)
[]
>>> solve(x - 3, y)
[]
```
single expression with no symbol given
In this case, all free symbols will be selected as potential symbols to solve for. If the equation is univariate then a list of solutions is returned; otherwise – as is the case when symbols are given as an iterable of length > 1 – a list of mappings will be returned.
>>> solve(x - 3) [3] >>> solve(x**2 - y**2) [{x: -y}, {x: y}] >>> solve(z**2*x**2 - z**2*y**2) [{x: -y}, {x: y}, {z: 0}] >>> solve(z**2*x - z**2*y**2) [{x: y**2}, {z: 0}]

when an object other than a Symbol is given as a symbol, it is isolated algebraically and an implicit solution may be obtained. This is mostly provided as a convenience to save one from replacing the object with a Symbol and solving for that Symbol. It will only work if the specified object can be replaced with a Symbol using the subs method.

>>> solve(f(x) - x, f(x))
[x]
>>> solve(f(x).diff(x) - f(x) - x, f(x).diff(x))
[x + f(x)]
>>> solve(f(x).diff(x) - f(x) - x, f(x))
[-x + Derivative(f(x), x)]
>>> solve(x + exp(x)**2, exp(x), set=True)
([exp(x)], set([(-sqrt(-x),), (sqrt(-x),)]))

>>> from sympy import Indexed, IndexedBase, Tuple, sqrt
>>> A = IndexedBase('A')
>>> eqs = Tuple(A[1] + A[2] - 3, A[1] - A[2] + 1)
>>> solve(eqs, eqs.atoms(Indexed))
{A[1]: 1, A[2]: 2}

To solve for a symbol implicitly, use ‘implicit=True’:

>>> solve(x + exp(x), x)
[-LambertW(1)]
>>> solve(x + exp(x), x, implicit=True)
[-exp(x)]

It is possible to solve for anything that can be targeted with subs:

>>> solve(x + 2 + sqrt(3), x + 2)
[-sqrt(3)]
>>> solve((x + 2 + sqrt(3), x + 4 + y), y, x + 2)
{y: -2 + sqrt(3), x + 2: -sqrt(3)}

Nothing heroic is done in this implicit solving so you may end up with a symbol still in the solution:

>>> eqs = (x*y + 3*y + sqrt(3), x + 4 + y)
>>> solve(eqs, y, x + 2)
{y: -sqrt(3)/(x + 3), x + 2: (-2*x - 6 + sqrt(3))/(x + 3)}
>>> solve(eqs, y*x, x)
{x: -y - 4, x*y: -3*y - sqrt(3)}

if you attempt to solve for a number remember that the number you have obtained does not necessarily mean that the value is equivalent to the expression obtained:

>>> solve(sqrt(2) - 1, 1)
[sqrt(2)]
>>> solve(x - y + 1, 1)  # /!\ -1 is targeted, too
[x/(y - 1)]
>>> [_.subs(z, -1) for _ in solve((x - y + 1).subs(-1, z), 1)]
[-x + y]

To solve for a function within a derivative, use dsolve.

single expression and more than 1 symbol

when there is a linear solution

>>> solve(x - y**2, x, y)
[{x: y**2}]
>>> solve(x**2 - y, x, y)
[{y: x**2}]

when undetermined coefficients are identified

that are linear

>>> solve((a + b)*x - b + 2, a, b)
{a: -2, b: 2}

that are nonlinear

>>> solve((a + b)*x - b**2 + 2, a, b, set=True)
([a, b], set([(-sqrt(2), sqrt(2)), (sqrt(2), -sqrt(2))]))

if there is no linear solution then the first successful attempt for a nonlinear solution will be returned

>>> solve(x**2 - y**2, x, y)
[{x: -y}, {x: y}]
>>> solve(x**2 - y**2/exp(x), x, y)
[{x: 2*LambertW(y/2)}]
>>> solve(x**2 - y**2/exp(x), y, x)
[{y: -x*exp(x/2)}, {y: x*exp(x/2)}]

iterable of one or more of the above

involving relationals or bools
>>> solve([x < 3, x - 2])
And(im(x) == 0, re(x) == 2)
>>> solve([x > 3, x - 2])
False
when the system is linear
with a solution
>>> solve([x - 3], x)
{x: 3}
>>> solve((x + 5*y - 2, -3*x + 6*y - 15), x, y)
{x: -3, y: 1}
>>> solve((x + 5*y - 2, -3*x + 6*y - 15), x, y, z)
{x: -3, y: 1}
>>> solve((x + 5*y - 2, -3*x + 6*y - z), z, x, y)
{x: -5*y + 2, z: 21*y - 6}
without a solution
>>> solve([x + 3, x - 3])
[]
when the system is not linear
>>> solve([x**2 + y -2, y**2 - 4], x, y, set=True)
([x, y], set([(-2, -2), (0, 2), (2, -2)]))
if no symbols are given, all free symbols will be selected and a list of mappings returned
>>> solve([x - 2, x**2 + y])
[{x: 2, y: -4}]
>>> solve([x - 2, x**2 + f(x)], set([f(x), x]))
[{x: 2, f(x): -4}]
if any equation doesn’t depend on the symbol(s) given it will be eliminated from the equation set and an answer may be given implicitly in terms of variables that were not of interest
>>> solve([x - y, y - 3], x)
{x: y}

sympy.solvers.solvers.solve_linear(lhs, rhs=0, symbols=[], exclude=[])[source]¶

Return a tuple derived from f = lhs - rhs that is either:

(numerator, denominator) of f
If this comes back as (0, 1) it means that f is independent of the symbols in symbols, e.g:
y*cos(x)**2 + y*sin(x)**2 - y = y*(0) = 0
cos(x)**2 + sin(x)**2 = 1
If it comes back as (0, 0) there is no solution to the equation amongst the symbols given.

If the numerator is not zero then the function is guaranteed to be dependent on a symbol in symbols.
or

(symbol, solution) where symbol appears linearly in the numerator of f, is in symbols (if given) and is not in exclude (if given).

No simplification is done to f other than and mul=True expansion, so the solution will correspond strictly to a unique solution.

Examples

>>> from sympy.solvers.solvers import solve_linear
>>> from sympy.abc import x, y, z

These are linear in x and 1/x:

>>> solve_linear(x + y**2)
(x, -y**2)
>>> solve_linear(1/x - y**2)
(x, y**(-2))

When not linear in x or y then the numerator and denominator are returned.

>>> solve_linear(x**2/y**2 - 3)
(x**2 - 3*y**2, y**2)

If the numerator is a symbol then (0, 0) is returned if the solution for that symbol would have set any denominator to 0:

>>> solve_linear(1/(1/x - 2))
(0, 0)
>>> 1/(1/x) # to SymPy, this looks like x ...
x
>>> solve_linear(1/(1/x)) # so a solution is given
(x, 0)

If x is allowed to cancel, then this appears linear, but this sort of cancellation is not done so the solution will always satisfy the original expression without causing a division by zero error.

>>> solve_linear(x**2*(1/x - z**2/x))
(x**2*(-z**2 + 1), x)

You can give a list of what you prefer for x candidates:

>>> solve_linear(x + y + z, symbols=[y])
(y, -x - z)

You can also indicate what variables you don’t want to consider:

>>> solve_linear(x + y + z, exclude=[x, z])
(y, -x - z)

If only x was excluded then a solution for y or z might be obtained.

sympy.solvers.solvers.solve_linear_system(system, *symbols, **flags)[source]¶

Solve system of N linear equations with M variables, which means both under- and overdetermined systems are supported. The possible number of solutions is zero, one or infinite. Respectively, this procedure will return None or a dictionary with solutions. In the case of underdetermined systems, all arbitrary parameters are skipped. This may cause a situation in which an empty dictionary is returned. In that case, all symbols can be assigned arbitrary values.

Input to this functions is a Nx(M+1) matrix, which means it has to be in augmented form. If you prefer to enter N equations and M unknowns then use \(solve(Neqs, *Msymbols)\) instead. Note: a local copy of the matrix is made by this routine so the matrix that is passed will not be modified.

The algorithm used here is fraction-free Gaussian elimination, which results, after elimination, in an upper-triangular matrix. Then solutions are found using back-substitution. This approach is more efficient and compact than the Gauss-Jordan method.

>>> from sympy import Matrix, solve_linear_system
>>> from sympy.abc import x, y

Solve the following system:

   x + 4 y ==  2
-2 x +   y == 14

>>> system = Matrix(( (1, 4, 2), (-2, 1, 14)))
>>> solve_linear_system(system, x, y)
{x: -6, y: 2}

A degenerate system returns an empty dictionary.

>>> system = Matrix(( (0,0,0), (0,0,0) ))
>>> solve_linear_system(system, x, y)
{}

sympy.solvers.solvers.solve_linear_system_LU(matrix, syms)[source]¶

Solves the augmented matrix system using LUsolve and returns a dictionary in which solutions are keyed to the symbols of syms as ordered.

The matrix must be invertible.

Ordinary Differential equations (ODEs)¶

See ODE.

Partial Differential Equations (PDEs)¶

See PDE.

Deutils (Utilities for solving ODE’s and PDE’s)¶

sympy.solvers.deutils.ode_order(expr, func)[source]¶

Returns the order of a given differential equation with respect to func.

This function is implemented recursively.

Examples

>>> from sympy import Function
>>> from sympy.solvers.deutils import ode_order
>>> from sympy.abc import x
>>> f, g = map(Function, ['f', 'g'])
>>> ode_order(f(x).diff(x, 2) + f(x).diff(x)**2 +
... f(x).diff(x), f(x))
2
>>> ode_order(f(x).diff(x, 2) + g(x).diff(x, 3), f(x))
2
>>> ode_order(f(x).diff(x, 2) + g(x).diff(x, 3), g(x))
3

Recurrence Equations¶

sympy.solvers.recurr.rsolve(f, y, init=None)[source]¶

Solve univariate recurrence with rational coefficients.

Given \(k\)-th order linear recurrence \(\operatorname{L} y = f\), or equivalently:

\[a_{k}(n) y(n+k) + a_{k-1}(n) y(n+k-1) + \dots + a_{0}(n) y(n) = f(n)\]

where \(a_{i}(n)\), for \(i=0, \dots, k\), are polynomials or rational functions in \(n\), and \(f\) is a hypergeometric function or a sum of a fixed number of pairwise dissimilar hypergeometric terms in \(n\), finds all solutions or returns None, if none were found.

Initial conditions can be given as a dictionary in two forms:

{ n_0 : v_0, n_1 : v_1, ..., n_m : v_m }

{ y(n_0) : v_0, y(n_1) : v_1, ..., y(n_m) : v_m }

or as a list L of values:

L = [ v_0, v_1, ..., v_m ]

where L[i] = v_i, for \(i=0, \dots, m\), maps to \(y(n_i)\).

Systems of Polynomial Equations¶

sympy.solvers.polysys.solve_poly_system(seq, *gens, **args)[source]¶

Solve a system of polynomial equations.

Examples

>>> from sympy import solve_poly_system
>>> from sympy.abc import x, y

>>> solve_poly_system([x*y - 2*y, 2*y**2 - x**2], x, y)
[(0, 0), (2, -sqrt(2)), (2, sqrt(2))]

sympy.solvers.polysys.solve_triangulated(polys, *gens, **args)[source]¶

Solve a polynomial system using Gianni-Kalkbrenner algorithm.

The algorithm proceeds by computing one Groebner basis in the ground domain and then by iteratively computing polynomial factorizations in appropriately constructed algebraic extensions of the ground domain.

References

1. Patrizia Gianni, Teo Mora, Algebraic Solution of System of Polynomial Equations using Groebner Bases, AAECC-5 on Applied Algebra, Algebraic Algorithms and Error-Correcting Codes, LNCS 356 247–257, 1989

Examples

>>> from sympy.solvers.polysys import solve_triangulated
>>> from sympy.abc import x, y, z

>>> F = [x**2 + y + z - 1, x + y**2 + z - 1, x + y + z**2 - 1]

>>> solve_triangulated(F, x, y, z)
[(0, 0, 1), (0, 1, 0), (1, 0, 0)]

Diophantine Equations (DEs)¶

See Diophantine

Inequalities¶

See Inequality Solvers

Solvers¶

Algebraic equations¶

Ordinary Differential equations (ODEs)¶

Partial Differential Equations (PDEs)¶

Deutils (Utilities for solving ODE’s and PDE’s)¶

Recurrence Equations¶

Systems of Polynomial Equations¶

Diophantine Equations (DEs)¶

Inequalities¶

Table Of Contents

Previous topic

Next topic

This Page

Navigation

Solvers¶

Algebraic equations¶

Ordinary Differential equations (ODEs)¶

Partial Differential Equations (PDEs)¶

Deutils (Utilities for solving ODE’s and PDE’s)¶

Recurrence Equations¶

Systems of Polynomial Equations¶

Diophantine Equations (DEs)¶

Inequalities¶

Table Of Contents

Previous topic

Next topic

This Page

Quick search

Navigation