sympy

$29

Core Capabilities

1. Symbolic Computation Basics

Creating symbols and expressions:

from sympy import symbols, Symbol

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

expr = x**2 + 2*x + 1

# With assumptions

x = symbols('x', real=True, positive=True)

n = symbols('n', integer=True)

Simplification and manipulation:

from sympy import simplify, expand, factor, cancel

simplify(sin(x)**2 + cos(x)**2)  # Returns 1

expand((x + 1)**3)  # x**3 + 3*x**2 + 3*x + 1

factor(x**2 - 1)    # (x - 1)*(x + 1)

For detailed basics: See references/core-capabilities.md

2. Calculus

Derivatives:

from sympy import diff

diff(x**2, x)        # 2*x

diff(x**4, x, 3)     # 24*x (third derivative)

diff(x**2*y**3, x, y)  # 6*x*y**2 (partial derivatives)

Integrals:

from sympy import integrate, oo

integrate(x**2, x)              # x**3/3 (indefinite)

integrate(x**2, (x, 0, 1))      # 1/3 (definite)

integrate(exp(-x), (x, 0, oo))  # 1 (improper)

Limits and Series:

from sympy import limit, series

limit(sin(x)/x, x, 0)  # 1

series(exp(x), x, 0, 6)  # 1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)

For detailed calculus operations: See references/core-capabilities.md

3. Equation Solving

Algebraic equations:

from sympy import solveset, solve, Eq

solveset(x**2 - 4, x)  # {-2, 2}

solve(Eq(x**2, 4), x)  # [-2, 2]

Systems of equations:

from sympy import linsolve, nonlinsolve

linsolve([x + y - 2, x - y], x, y)  # {(1, 1)} (linear)

nonlinsolve([x**2 + y - 2, x + y**2 - 3], x, y)  # (nonlinear)

Differential equations:

from sympy import Function, dsolve, Derivative

f = symbols('f', cls=Function)

dsolve(Derivative(f(x), x) - f(x), f(x))  # Eq(f(x), C1*exp(x))

For detailed solving methods: See references/core-capabilities.md

4. Matrices and Linear Algebra

Matrix creation and operations:

from sympy import Matrix, eye, zeros

M = Matrix([[1, 2], [3, 4]])

M_inv = M**-1  # Inverse

M.det()        # Determinant

M.T            # Transpose

Eigenvalues and eigenvectors:

eigenvals = M.eigenvals()  # {eigenvalue: multiplicity}

eigenvects = M.eigenvects()  # [(eigenval, mult, [eigenvectors])]

P, D = M.diagonalize()  # M = P*D*P^-1

Solving linear systems:

A = Matrix([[1, 2], [3, 4]])

b = Matrix([5, 6])

x = A.solve(b)  # Solve Ax = b

For comprehensive linear algebra: See references/matrices-linear-algebra.md

5. Physics and Mechanics

Classical mechanics:

from sympy.physics.mechanics import dynamicsymbols, LagrangesMethod

from sympy import symbols

# Define system

q = dynamicsymbols('q')

m, g, l = symbols('m g l')

# Lagrangian (T - V)

L = m*(l*q.diff())**2/2 - m*g*l*(1 - cos(q))

# Apply Lagrange's method

LM = LagrangesMethod(L, [q])

Vector analysis:

from sympy.physics.vector import ReferenceFrame, dot, cross

N = ReferenceFrame('N')

v1 = 3*N.x + 4*N.y

v2 = 1*N.x + 2*N.z

dot(v1, v2)  # Dot product

cross(v1, v2)  # Cross product

Quantum mechanics:

from sympy.physics.quantum import Ket, Bra, Commutator

psi = Ket('psi')

A = Operator('A')

comm = Commutator(A, B).doit()

For detailed physics capabilities: See references/physics-mechanics.md

6. Advanced Mathematics

The skill includes comprehensive support for:

• Geometry: 2D/3D analytic geometry, points, lines, circles, polygons, transformations

• Number Theory: Primes, factorization, GCD/LCM, modular arithmetic, Diophantine equations

• Combinatorics: Permutations, combinations, partitions, group theory

• Logic and Sets: Boolean logic, set theory, finite and infinite sets

• Statistics: Probability distributions, random variables, expectation, variance

• Special Functions: Gamma, Bessel, orthogonal polynomials, hypergeometric functions

• Polynomials: Polynomial algebra, roots, factorization, Groebner bases

For detailed advanced topics: See references/advanced-topics.md

7. Code Generation and Output

Convert to executable functions:

from sympy import lambdify

import numpy as np

expr = x**2 + 2*x + 1

f = lambdify(x, expr, 'numpy')  # Create NumPy function

x_vals = np.linspace(0, 10, 100)

y_vals = f(x_vals)  # Fast numerical evaluation

Generate C/Fortran code:

from sympy.utilities.codegen import codegen

[(c_name, c_code), (h_name, h_header)] = codegen(

    ('my_func', expr), 'C'

)

LaTeX output:

from sympy import latex

latex_str = latex(expr)  # Convert to LaTeX for documents

For comprehensive code generation: See references/code-generation-printing.md

Working with SymPy: Best Practices

1. Always Define Symbols First

from sympy import symbols

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

# Now x, y, z can be used in expressions

2. Use Assumptions for Better Simplification

x = symbols('x', positive=True, real=True)

sqrt(x**2)  # Returns x (not Abs(x)) due to positive assumption

Common assumptions: real, positive, negative, integer, rational, complex, even, odd

3. Use Exact Arithmetic

from sympy import Rational, S

# Correct (exact):

expr = Rational(1, 2) * x

expr = S(1)/2 * x

# Incorrect (floating-point):

expr = 0.5 * x  # Creates approximate value

4. Numerical Evaluation When Needed

from sympy import pi, sqrt

result = sqrt(8) + pi

result.evalf()    # 5.96371554103586

result.evalf(50)  # 50 digits of precision

5. Convert to NumPy for Performance

# Slow for many evaluations:

for x_val in range(1000):

    result = expr.subs(x, x_val).evalf()

# Fast:

f = lambdify(x, expr, 'numpy')

results = f(np.arange(1000))

6. Use Appropriate Solvers

• solveset: Algebraic equations (primary)

• linsolve: Linear systems

• nonlinsolve: Nonlinear systems

• dsolve: Differential equations

• solve: General purpose (legacy, but flexible)

Reference Files Structure

This skill uses modular reference files for different capabilities:

-

**core-capabilities.md**: Symbols, algebra, calculus, simplification, equation solving

• Load when: Basic symbolic computation, calculus, or solving equations

-

**matrices-linear-algebra.md**: Matrix operations, eigenvalues, linear systems

• Load when: Working with matrices or linear algebra problems

-

**physics-mechanics.md**: Classical mechanics, quantum mechanics, vectors, units

• Load when: Physics calculations or mechanics problems

-

**advanced-topics.md**: Geometry, number theory, combinatorics, logic, statistics

• Load when: Advanced mathematical topics beyond basic algebra and calculus

-

**code-generation-printing.md**: Lambdify, codegen, LaTeX output, printing

• Load when: Converting expressions to code or generating formatted output

Common Use Case Patterns

Pattern 1: Solve and Verify

from sympy import symbols, solve, simplify

x = symbols('x')

# Solve equation

equation = x**2 - 5*x + 6

solutions = solve(equation, x)  # [2, 3]

# Verify solutions

for sol in solutions:

    result = simplify(equation.subs(x, sol))

    assert result == 0

Pattern 2: Symbolic to Numeric Pipeline

# 1. Define symbolic problem

x, y = symbols('x y')

expr = sin(x) + cos(y)

# 2. Manipulate symbolically

simplified = simplify(expr)

derivative = diff(simplified, x)

# 3. Convert to numerical function

f = lambdify((x, y), derivative, 'numpy')

# 4. Evaluate numerically

results = f(x_data, y_data)

Pattern 3: Document Mathematical Results

# Compute result symbolically

integral_expr = Integral(x**2, (x, 0, 1))

result = integral_expr.doit()

# Generate documentation

print(f"LaTeX: {latex(integral_expr)} = {latex(result)}")

print(f"Pretty: {pretty(integral_expr)} = {pretty(result)}")

print(f"Numerical: {result.evalf()}")

Integration with Scientific Workflows

With NumPy

import numpy as np

from sympy import symbols, lambdify

x = symbols('x')

expr = x**2 + 2*x + 1

f = lambdify(x, expr, 'numpy')

x_array = np.linspace(-5, 5, 100)

y_array = f(x_array)

With Matplotlib

import matplotlib.pyplot as plt

import numpy as np

from sympy import symbols, lambdify, sin

x = symbols('x')

expr = sin(x) / x

f = lambdify(x, expr, 'numpy')

x_vals = np.linspace(-10, 10, 1000)

y_vals = f(x_vals)

plt.plot(x_vals, y_vals)

plt.show()

With SciPy

from scipy.optimize import fsolve

from sympy import symbols, lambdify

# Define equation symbolically

x = symbols('x')

equation = x**3 - 2*x - 5

# Convert to numerical function

f = lambdify(x, equation, 'numpy')

# Solve numerically with initial guess

solution = fsolve(f, 2)

Quick Reference: Most Common Functions

# Symbols

from sympy import symbols, Symbol

x, y = symbols('x y')

# Basic operations

from sympy import simplify, expand, factor, collect, cancel

from sympy import sqrt, exp, log, sin, cos, tan, pi, E, I, oo

# Calculus

from sympy import diff, integrate, limit, series, Derivative, Integral

# Solving

from sympy import solve, solveset, linsolve, nonlinsolve, dsolve

# Matrices

from sympy import Matrix, eye, zeros, ones, diag

# Logic and sets

from sympy import And, Or, Not, Implies, FiniteSet, Interval, Union

# Output

from sympy import latex, pprint, lambdify, init_printing

# Utilities

from sympy import evalf, N, nsimplify

Getting Started Examples

Example 1: Solve Quadratic Equation

from sympy import symbols, solve, sqrt

x = symbols('x')

solution = solve(x**2 - 5*x + 6, x)

# [2, 3]

Example 2: Calculate Derivative

from sympy import symbols, diff, sin

x = symbols('x')

f = sin(x**2)

df_dx = diff(f, x)

# 2*x*cos(x**2)

Example 3: Evaluate Integral

from sympy import symbols, integrate, exp

x = symbols('x')

integral = integrate(x * exp(-x**2), (x, 0, oo))

# 1/2

Example 4: Matrix Eigenvalues

from sympy import Matrix

M = Matrix([[1, 2], [2, 1]])

eigenvals = M.eigenvals()

# {3: 1, -1: 1}

Example 5: Generate Python Function

from sympy import symbols, lambdify

import numpy as np

x = symbols('x')

expr = x**2 + 2*x + 1

f = lambdify(x, expr, 'numpy')

f(np.array([1, 2, 3]))

# array([ 4,  9, 16])

Troubleshooting Common Issues

-

"NameError: name 'x' is not defined"

• Solution: Always define symbols using symbols() before use

-

Unexpected numerical results

• Issue: Using floating-point numbers like 0.5 instead of Rational(1, 2)

• Solution: Use Rational() or S() for exact arithmetic

-

Slow performance in loops

• Issue: Using subs() and evalf() repeatedly

• Solution: Use lambdify() to create a fast numerical function

-

"Can't solve this equation"

• Try different solvers: solve, solveset, nsolve (numerical)

• Check if the equation is solvable algebraically

• Use numerical methods if no closed-form solution exists

-

Simplification not working as expected

• Try different simplification functions: simplify, factor, expand, trigsimp

• Add assumptions to symbols (e.g., positive=True)

• Use simplify(expr, force=True) for aggressive simplification

Additional Resources

• Official Documentation: https://docs.sympy.org/

• Tutorial: https://docs.sympy.org/latest/tutorials/intro-tutorial/index.html

• API Reference: https://docs.sympy.org/latest/reference/index.html

• Examples: https://github.com/sympy/sympy/tree/master/examples