Elevated Formulas: Transforming Equations with SymPy#

3.1 Installation#

You can install SymPy via pip:

1
pip install sympy

Alternatively, if you use Anaconda or Miniconda:

1
conda install sympy

Once installation is complete, open a Python session (or Jupyter notebook) and import the library:

1
import sympy
2
from sympy import symbols, Eq, solve

3.2 Basic Structure#

SymPy revolves around symbolic objects. You define symbolic variables (or “symbols�? that represent mathematical unknowns. After that, build expressions, manipulate them, and observe the results in symbolic form. The modular nature of SymPy also allows you to import specific functionalities (like sympy.solvers, sympy.integrals), enabling a more flexible development style.

4.1 Declaring Symbols#

In SymPy, you typically declare your variables as symbols. For example:

1
from sympy import Symbol
2

3
x = Symbol('x')
4
y = Symbol('y')

Alternatively, you can declare multiple symbols with a single command:

1
from sympy import symbols
2

3
x, y, z = symbols('x y z')

You can also add assumptions, such as positive=True or real=True, to guide SymPy’s reasoning about the symbol:

1
a = Symbol('a', positive=True)
2
b = Symbol('b', real=True)

Having these assumptions in place can help with certain simplifications or solutions.

4.2 Basic Arithmetic and Expressions#

Once you have symbols, you can start creating expressions:

1
expr1 = x + 2*y
2
expr2 = (x**2 + y**2)**0.5
3
expr3 = (x + 1)*(y + 2)

SymPy will store these expressions in symbolic form. You can then combine or manipulate them:

1
combined_expr = expr1 + expr2
2
mul_expr = expr3 * (x - y)

4.3 Simplification Techniques#

One of SymPy’s strong points is the ability to simplify expressions:

• sympy.simplify(expr): Applies heuristic simplifying strategies.
• sympy.factor(expr): Factors an expression.
• sympy.expand(expr): Expands an expression.
• sympy.cancel(expr): Cancels common factors in numerator and denominator.
• sympy.radsimp(expr): Rationalizes denominators.

Here is a quick example:

1
from sympy import simplify, factor, expand, cancel, radsimp
2

3
expr = (x**2 - y**2)/(x - y)
4
print("Original:", expr)
5
print("Simplified:", simplify(expr))  # => x + y
6
print("Factored:", factor(x**3 + y**3))  # => (x + y)*(x^2 - x*y + y^2)
7
print("Expanded:", expand((x + y)**3))  # => x^3 + 3*x^2*y + 3*x*y^2 + y^3
8

9
rational_expr = (x**2 - 2*x + 1)/(x - 1)
10
print("Canceled:", cancel(rational_expr))  # => x - 1

5.1 Solving Equations#

SymPy’s solvers are among its most powerful features. You can solve equations, systems of equations, and inequalities. The primary function for basic algebraic solutions is solve.

1
from sympy import Eq, solve
2

3
x = Symbol('x')
4
equation = Eq(x**2 - 1, 0)
5
solutions = solve(equation, x)
6
print(solutions)  # => [-1, 1]

1
x, y = symbols('x y')
2
eq1 = Eq(x + y, 2)
3
eq2 = Eq(x - y, 0)
4
solutions = solve((eq1, eq2), (x, y))
5
print(solutions)  # => {x: 1, y: 1}

5.2 Working with Polynomials#

Polynomials are a staple of symbolic mathematics. SymPy accommodates polynomial factorization, partial fraction decomposition, and other manipulations. For an example of polynomial factorization:

1
from sympy import factor, expand
2

3
x, y = symbols('x y')
4
poly_expr = x**3 + 3*x**2*y + 3*x*y**2 + y**3
5
print(factor(poly_expr))  # => (x + y)**3
6

7
expanded = expand(poly_expr)
8
print(expanded)  # => x^3 + 3*x^2*y + 3*x*y^2 + y^3

For partial fraction decomposition:

1
from sympy import apart
2

3
rational_expr = (x + 1)/(x*(x + 2))
4
print(apart(rational_expr))  # => 1/x - 1/(x + 2)

5.3 Calculus (Derivatives and Integrals)#

Symbolic calculus in SymPy is a highlight for many users. You can quickly do derivatives and integrals:

1
from sympy import diff, integrate
2

3
f = x**3 + 2*x + 1
4
f_prime = diff(f, x)  # First derivative
5
f_second = diff(f, (x, 2))  # Second derivative
6
print(f_prime, f_second)  # => 3*x^2 + 2, 6*x
7

8
f_int = integrate(f, x)  # Indefinite integral
9
print(f_int)  # => x^4/4 + x^2 + x + C
10

11
# Definite integral from 0 to 2
12
f_int_def = integrate(f, (x, 0, 2))
13
print(f_int_def)  # => 14

5.4 Series Expansion#

The series function expands expressions as a power series around a given point. This is particularly useful in mathematical analyses, approximations, and expansions in calculus:

1
from sympy import series, sin
2

3
# Expand sin(x) around x=0, up to x^5
4
sin_series = sin(x).series(x, 0, 6)
5
print(sin_series)
6
# => x - x^3/6 + x^5/120 + O(x^6)

6.1 Symbolic Matrices and Linear Algebra#

SymPy also supports matrices with symbolic entries:

1
from sympy import Matrix
2

3
A = Matrix([[x, 1], [1, y]])
4
print("Matrix A:")
5
print(A)
6

7
# Determinant
8
det_A = A.det()
9
print("Det(A) =", det_A)
10

11
# Inverse, if invertible
12
inv_A = A.inv()
13
print("A^-1:")
14
print(inv_A)

You can do eigenvalue and eigenvector computations on symbolic matrices, which is extremely powerful in theoretical linear algebra.

6.2 Differential Equations#

The dsolve function solves ordinary differential equations (ODEs). For example, consider a simple first-order ODE:

1
from sympy import Function, dsolve, Eq, Derivative
2

3
f = Function('f')(x)
4
ode = Eq(Derivative(f, x), f)
5
solution = dsolve(ode)
6
print(solution)  # => f(x) = C1*exp(x)

SymPy can handle higher-order ODEs, systems of ODEs, and certain PDEs, although PDE solving is more limited than ODE solving.

6.3 Limits and Asymptotic Behavior#

You can compute limits symbolically, which is crucial for analyzing the asymptotic behavior of functions:

1
from sympy import limit, oo
2

3
expr = (x**2 + 2*x + 1)/(x**3 - 1)
4
lim_infinity = limit(expr, x, oo)
5
print(lim_infinity)  # => 0
6

7
lim_1 = limit(expr, x, 1)
8
print(lim_1)  # => 3

For more sophisticated analyses, combining series expansions with limits can give in-depth views of behavior near singularities.

6.4 Assumption System#

When dealing with symbolic computations, assumptions about variables often guide the simplifications and solutions. For example, if x is assumed to be a positive real, certain absolute value expressions can simplify differently than if x is any complex number.

1
p = Symbol('p', positive=True)
2
expr = (p**2)**(1/Symbol('n', positive=True))
3
# With positivity assumed, this expression can simplify more aggressively
4
print(simplify(expr))

SymPy’s assumption system is extensive, allowing you to specify if a symbol is integer, real, rational, prime, composite, and more.

7.1 Advanced Simplification Strategies#

While simplify() is a great “general-purpose�?function, you might need more targeted functions for complicated expressions:

• trigsimp(expr): Simplifies trigonometric expressions, combining or separating terms.
• logcombine(expr): Combines logarithmic terms.
• powsimp(expr): Merges exponents with common bases.

For example, if you have a complicated trigonometric identity:

1
from sympy import sin, cos, trigsimp
2

3
trig_expr = sin(x)**2 + cos(x)**2
4
print(trig_expr)        # => sin(x)**2 + cos(x)**2
5
print(trigsimp(trig_expr))  # => 1

7.2 Custom Transformations#

You can create your own transformation rules using SymPy’s replace or subs methods, allowing you to strategically rewrite expressions:

1
expr = sin(x)**4
2

3
# Replace sin(x)^2 with 1 - cos(x)^2
4
expr_transformed = expr.replace(
5
    lambda e: e.is_Pow and e.base == sin(x) and e.exp == 2,
6
    lambda e: 1 - cos(x)**2
7
)
8
print(expr_transformed)

Combine these strategies with advanced manipulations to achieve highly customized transformations.

7.3 Lambert W Function and Special Functions#

The Lambert W function is the inverse of f(w) = w e^w, which appears often in specific equations like x e^x = a. SymPy recognizes such expressions and can represent them in the Lambert W form. Special functions like Bessel, Airy, Gamma, PolyGamma, and Zeta are also supported.

1
from sympy import LambertW, solve, exp
2

3
x = Symbol('x', real=True)
4
equation = Eq(x*exp(x), 2)
5
solution = solve(equation, x)
6
print(solution)  # => [LambertW(2)]

7.4 Polynomial Factorization and Groebner Bases#

For more intricate algebraic geometry or polynomial system problems, the Groebner basis is an essential tool. It helps solve systems of polynomial equations and analyze their structure. You can compute Groebner bases using sympy.polys.polytools.groebner.

1
from sympy.polys.polytools import groebner
2
from sympy.polys.orderings import lex
3

4
f1 = x**2 + y**2 - 1
5
f2 = x**2 - y
6
G = groebner([f1, f2], x, y, order=lex)
7
print(G)  # => Groebner basis in lex order

These techniques enable advanced algebraic manipulations, often used in research and cutting-edge engineering problems.

8.1 Summary of Core SymPy Functions#

8.2 Common Symbolic Methods#