Cracking Equations: A Beginner’s Guide to SymPy#

Symbols and Expressions#

In SymPy, mathematical variables are represented by “symbols.�?Unlike regular Python variables, these symbols are placeholders for mathematical expressions.

1
from sympy import symbols
2

3
x, y = symbols('x y')
4
expr = x + y
5
print(expr)

Output:
x + y

Here, x and y are symbolic variables, and expr is the symbolic expression x + y.

Using symbols('x', real=True, positive=True), you can specify assumptions about your symbols, such as them being real or positive. These assumptions can influence the behavior of certain operations, especially simplifications and solutions.

Expression Simplification Basics#

One of the handy features of SymPy is its ability to simplify expressions. For instance:

1
from sympy import simplify
2

3
expr = (x**2 + 2*x + 1) / (x + 1)
4
simplified_expr = simplify(expr)
5
print(simplified_expr)

If x != -1, the result will typically simplify to x + 1. Sympy considers symbolic conditions �?if the denominator can be factored and canceled, it often will. In some cases (like x = -1), the expression is not defined, but the symbolic form still simplifies under the assumption that x �?-1.

Expand, Factor, and Simplify#

SymPy offers various algebraic manipulation functions. Some of the most commonly used are expand, factor, and simplify.

• expand(): Expands a product into a sum of terms.
• factor(): Factors an expression into irreducible factors.
• simplify(): Applies multiple heuristics to produce a simpler-looking expression.

Example:

1
from sympy import expand, factor
2

3
expr = (x + 1)*(x - 2)
4
expanded_expr = expand(expr)
5
factored_expr = factor(expanded_expr)
6

7
print("Expanded:", expanded_expr)
8
print("Factored:", factored_expr)

Output:
Expanded: x^2 - x - 2
Factored: (x + 1)*(x - 2)

SymPy can also handle more advanced expansions, such as expansion of trigonometric expressions or expansions in multiple variables.

Substitution#

Substitution allows you to replace any of the variables in an expression with specific values or other symbolic expressions. This is done using the .subs() method:

1
expr = x**2 + y
2
subbed_expr1 = expr.subs(x, 3)        # Replace x with 3
3
subbed_expr2 = expr.subs({x: 3, y: 2}) # Replace x with 3 and y with 2
4

5
print(subbed_expr1)  # 9 + y
6
print(subbed_expr2)  # 11

Substitution is one of the most powerful ways to quickly evaluate expressions at specific points, or to transform one symbolic expression into another.

Common Pitfalls#

One common misunderstanding involves the difference between Python arithmetic and symbolic arithmetic:

1. If you do x = 3 before making your symbolic variable, you won’t get the symbolic variable you expect.
2. If you forget to import SymPy’s symbols or fail to create them properly, you may end up with plain Python integers or floats.

Always ensure you separate your Python variables from your SymPy symbolic variables when working with symbolic math.

solve vs. solveset#

• solve: The older function that returns solutions in a somewhat flexible format, often used for polynomial and algebraic equations.
• solveset: The newer function that aims for a more consistent and set-based approach to solutions.

Example with solve:

1
from sympy import solve, Eq
2

3
expr = x**2 - 4
4
solutions = solve(Eq(expr, 0), x)
5
print(solutions)

Output:
[ -2, 2 ]

Example with solveset:

1
from sympy import solveset, S
2

3
solutions_set = solveset(x**2 - 4, x, domain=S.Complexes)
4
print(solutions_set)

Output:
{-2, 2}

The output’s data type differs between the two, but the result is similar. For many basic tasks, you can use either function.

Symbolic vs. Numeric Solutions#

SymPy can return symbolic solutions if they exist, but you can also request approximate numeric solutions. For instance, with nroots (for polynomials) or by converting a symbolic solution to a floating-point number using evalf():

1
from sympy import nroots, evalf
2

3
poly_expr = x**3 - x - 1
4
numeric_solutions = nroots(poly_expr)
5
print(numeric_solutions)  # Approximate roots
6

7
# For a simpler expression:
8
sym_solution = solve(poly_expr, x)
9
print([sol.evalf() for sol in sym_solution])  # Evaluate each solution numerically

Systems of Equations#

Solving multiple simultaneous equations is straightforward by passing a list of expressions and a list of variables:

1
solutions = solve([
2
    Eq(x + y, 3),
3
    Eq(x - y, 1)
4
], [x, y])
5

6
print(solutions)  # {x: 2, y: 1}

Using solveset for systems is more involved, but it can sometimes yield more consistent set-based solutions.

Derivatives and Higher-Order Derivatives#

You can compute derivatives using diff. First, create your symbolic function, then apply diff(expr, variable, order).

1
from sympy import diff
2

3
f = x**3 + x**2 + 1
4
df_dx = diff(f, x)
5
d2f_dx2 = diff(f, x, 2)
6

7
print("First derivative:", df_dx)
8
print("Second derivative:", d2f_dx2)

Output:
First derivative: 3x^2 + 2x
Second derivative: 6*x + 2

You can also compute partial derivatives of multivariate functions:

1
f_xy = x**2 * y**3
2
df_dx_xy = diff(f_xy, x)
3
df_dy_xy = diff(f_xy, y)

Integrals (Definite and Indefinite)#

SymPy can do indefinite and definite integrals via the integrate() function.

• Indefinite integral:

1
from sympy import integrate
2

3
expr = x**2
4
indef_int = integrate(expr, (x,))
5
print(indef_int)  # x^3/3

• Definite integral:

1
def_int = integrate(expr, (x, 0, 2))
2
print(def_int)  # Evaluate �?x^2) dx from 0 to 2

For more complex functions, SymPy can often find closed-form solutions if they exist. Otherwise, it may leave your result in terms of special functions or fail to integrate in symbolic form (in which case you can resort to numerical approximation methods).

Limits and Series Expansions#

• Limit:

1
from sympy import limit
2

3
lim_expr = limit((x**2 - 4)/(x - 2), x, 2)
4
print(lim_expr)  # 4

• Series expansion (Maclaurin or Taylor series):

1
from sympy import series
2

3
series_expansion = (sympy.sin(x)).series(x, 0, 6)
4
print(series_expansion)

This might output x - x^3/6 + x^5/120 + O(x^6). You can also perform expansions around points other than 0.

Creating Matrices#

You can create matrices using Matrix:

1
from sympy import Matrix
2

3
M = Matrix([
4
    [1, x],
5
    [y, 2]
6
])
7
print(M)

Output:
Matrix([[1, x], [y, 2]])

Matrix Operations#

• Determinant:

1
det_M = M.det()
2
print(det_M)  # 1*(2) - x*(y) = 2 - x*y

• Inverse:

1
inv_M = M.inv()
2
print(inv_M)

SymPy will provide a symbolic inverse if it exists. If the determinant is 0, the matrix isn’t invertible.

Eigenvalues and Eigenvectors#

You can compute eigenvalues and eigenvectors symbolically:

1
eigs = M.eigenvects()
2
for val, mult, vects in eigs:
3
    print("Eigenvalue:", val)
4
    print("Multiplicity:", mult)
5
    print("Eigenvectors:", vects)

These tasks can be particularly useful in advanced linear algebra, control systems, or any domain reliant on matrix computations.

Symbolic Summations#

Use summation(expr, (index, start, end)):

1
from sympy import summation, Symbol, oo
2

3
n = Symbol('n', positive=True)
4
sum_expr = 1/n**2
5
sum_infinite = summation(sum_expr, (n, 1, oo))
6
print(sum_infinite)  # pi^2/6

In this example, SymPy recognizes the Riemann Zeta function for the sum of 1/n^2 from n=1 to infinity.

Products#

Similarly, product(expr, (index, start, end)) can compute products symbolically:

1
from sympy import product
2

3
prod_expr = product(x, (x, 1, 3))
4
print(prod_expr)

This will compute 1 * 2 * 3 for x, returning 6 (for a numeric limit). If x is a symbolic variable, you’ll see a different structure reflecting the symbolic result.

Gamma and Zeta Functions#

1
from sympy import gamma, zeta
2

3
g_expr = gamma(x)
4
z_expr = zeta(x)

These are recognized by SymPy’s integrator, simplifier, and solver.

Polynomial Tools#

SymPy allows you to manipulate polynomials with the Poly class:

1
from sympy import Poly
2

3
p = Poly(x**3 + 2*x**2 + 3*x + 4, x)
4
print(p.degree())    # 3
5
print(p.factor_list())

The factor_list() method provides a systematic factorization over integers.

Custom Functions#

If you can’t find a suitable built-in function, you can define your own symbolic function:

1
from sympy import Function
2

3
f = Function('f')(x)
4
df_dx = diff(f, x)

This symbolic function can be constrained to satisfy certain rules or equations if you integrate it into SymPy’s solver or differential equations module.

Ordinary Differential Equations#

1
from sympy import dsolve, Function, Eq
2

3
f = Function('f')(x)
4
ode = Eq(f.diff(x, 2) + f, 0)
5
solution = dsolve(ode)
6
print(solution)

For the second-order homogeneous equation f”(x) + f(x) = 0, you’ll get a general solution like f(x) = C1sin(x) + C2cos(x).

Systems of ODEs#

You can also solve systems of ODEs by passing multiple equations to dsolve. Each function must be defined separately (e.g., f1(x), f2(x)).

Initial Value and Boundary Value Problems#

By providing conditions such as f(0)=1, f’(0)=0, you can integrate initial value constraints into the solution:

1
solution_ivp = dsolve(Eq(f.diff(x, 2) + f, 0),
2
                      ics={f.subs(x, 0): 0, f.diff(x).subs(x, 0): 1})
3
print(solution_ivp)

Assumptions System#

SymPy’s assumptions system allows you to specify whether a symbol is positive, real, integer, etc. This can affect simplification outcomes. For example:

1
a = symbols('a', positive=True)
2
b = symbols('b', negative=True)

SymPy might then simplify expressions like sqrt(a**2) to a, whereas for a general symbol x, sqrt(x^2) remains |x|.

Lambdify for Numeric Computation#

If you need to switch from symbolic to numeric computations (say, evaluate the expression at a large set of numeric points), you can use lambdify. This function converts a SymPy expression into a standard Python function that can be evaluated quickly.

1
import numpy as np
2
from sympy import lambdify
3

4
expr = x**2 + 2*x + 1
5
f_numeric = lambdify(x, expr, 'numpy')
6

7
xs = np.linspace(-5, 5, 100)
8
results = f_numeric(xs)

Plotting#

SymPy has a built-in plotting library (limited but convenient for quick checks). For instance:

1
from sympy.plotting import plot
2

3
plot(expr, (x, -5, 5))

However, many users prefer external libraries like matplotlib or Plotly once they’ve turned their SymPy expressions into numeric functions.