```
>>> from sympy import *
>>> x, y, z = symbols('x y z')
>>> init_printing(use_unicode=True)
```

Recall from the *gotchas* section of this
tutorial that symbolic equations in SymPy are not represented by `=` or
`==`, but by `Eq`.

```
>>> Eq(x, y)
x = y
```

However, there is an even easier way. In SymPy, any expression not in an
`Eq` is automatically assumed to equal 0 by the solving functions. Since \(a
= b\) if and only if \(a - b = 0\), this means that instead of using `x == y`,
you can just use `x - y`. For example

```
>>> solveset(Eq(x**2, 1), x)
{-1, 1}
>>> solveset(Eq(x**2 - 1, 0), x)
{-1, 1}
>>> solveset(x**2 - 1, x)
{-1, 1}
```

This is particularly useful if the equation you wish to solve is already equal
to 0. Instead of typing `solveset(Eq(expr, 0), x)`, you can just use
`solveset(expr, x)`.

The main function for solving algebraic equations is `solveset`.
The syntax for `solveset` is `solveset(equation, variable=None, domain=S.Complexes)`
Where `equations` may be in the form of `Eq` instances or expressions
that are assumed to be equal to zero.

Please note that there is an another function called as `solve` which
can also be used to solve equations. The syntax is `solve(equations, variables)`
However, it is recommended to use `solveset` instead.

When solving a single equation, the output of `solveset` is a `FiniteSet` or
an `Interval` or `ImageSet` of the solutions.

```
>>> solveset(x**2 - x, x)
{0, 1}
>>> solveset(x - x, x, domain=S.Reals)
ℝ
>>> solveset(sin(x) - 1, x, domain=S.Reals)
⎧ π ⎫
⎨2⋅n⋅π + ─ | n ∊ ℤ⎬
⎩ 2 ⎭
```

If there are no solutions, an `EmptySet` is returned and if it
is not able to find solutions then a `ConditionSet` is returned.

```
>>> solveset(exp(x), x) # No solution exists
∅
>>> solveset(cos(x) - x, x) # Not able to find solution
{x | x ∊ ℂ ∧ -x + cos(x) = 0}
```

In the `solveset` module, the linear system of equations is solved using `linsolve`.
In future we would be able to use linsolve directly from `solveset`. Following
is an example of the syntax of `linsolve`.

List of Equations Form:

>>> linsolve([x + y + z - 1, x + y + 2*z - 3 ], (x, y, z)) {(-y - 1, y, 2)}

Augmented Matrix Form:

>>> linsolve(Matrix(([1, 1, 1, 1], [1, 1, 2, 3])), (x, y, z)) {(-y - 1, y, 2)}

A*x = b Form

>>> M = Matrix(((1, 1, 1, 1), (1, 1, 2, 3))) >>> system = A, b = M[:, :-1], M[:, -1] >>> linsolve(system, x, y, z) {(-y - 1, y, 2)}

Note

The order of solution corresponds the order of given symbols.

`solveset` reports each solution only once. To get the solutions of a
polynomial including multiplicity use `roots`.

```
>>> solveset(x**3 - 6*x**2 + 9*x, x)
{0, 3}
>>> roots(x**3 - 6*x**2 + 9*x, x)
{0: 1, 3: 2}
```

The output `{0: 1, 3: 2}` of `roots` means that `0` is a root of
multiplicity 1 and `3` is a root of multiplicity 2.

Note

Currently `solveset` is not capable of solving the following types of equations:

- Non-linear multivariate system
- Equations solvable by LambertW (Transcendental equation solver).

`solve` can be used for such cases:

```
>>> solve([x*y - 1, x - 2], x, y)
[(2, 1/2)]
>>> solve(x*exp(x) - 1, x )
[LambertW(1)]
```

To solve differential equations, use `dsolve`. First, create an undefined
function by passing `cls=Function` to the `symbols` function.

```
>>> f, g = symbols('f g', cls=Function)
```

`f` and `g` are now undefined functions. We can call `f(x)`, and it
will represent an unknown function.

```
>>> f(x)
f(x)
```

Derivatives of `f(x)` are unevaluated.

```
>>> f(x).diff(x)
d
──(f(x))
dx
```

(see the *Derivatives* section for more on
derivatives).

To represent the differential equation \(f''(x) - 2f'(x) + f(x) = \sin(x)\), we would thus use

```
>>> diffeq = Eq(f(x).diff(x, x) - 2*f(x).diff(x) + f(x), sin(x))
>>> diffeq
2
d d
f(x) - 2⋅──(f(x)) + ───(f(x)) = sin(x)
dx 2
dx
```

To solve the ODE, pass it and the function to solve for to `dsolve`.

```
>>> dsolve(diffeq, f(x))
x cos(x)
f(x) = (C₁ + C₂⋅x)⋅ℯ + ──────
2
```

`dsolve` returns an instance of `Eq`. This is because in general,
solutions to differential equations cannot be solved explicitly for the
function.

```
>>> dsolve(f(x).diff(x)*(1 - sin(f(x))), f(x))
f(x) + cos(f(x)) = C₁
```

The arbitrary constants in the solutions from dsolve are symbols of the form
`C1`, `C2`, `C3`, and so on.