Sympy

zLanqing/codex-claude-academic-skills/scientific-toolkit-skill/references/scientific-skills/sympy

by zLanqing7ed6377f0efb6a38951b48ef03b19d996e454b1fhttps://github.com/sympy/sympy/blob/master/LICENSEListed Oct 9, 2026Updated Oct 9, 2026

Use this skill when working with symbolic mathematics in Python. This skill should be used for symbolic computation tasks including solving equations algebraically, performing calculus operations (derivatives, integrals, limits), manipulating algebraic expressions, working with matrices symbolically, physics calculations, number theory problems, geometry computations, and generating executable code from mathematical expressions. Apply this skill when the user needs exact symbolic results rather than numerical approximations, or when working with mathematical formulas that contain variables and parameters.

Instructions onlyData & AnalyticsSoftware Development
AI-generated overview

Guides symbolic mathematics in Python with SymPy, covering algebra, calculus, matrices, physics and code generation.

What it does
This skill provides instructions and reference material for using the SymPy Python library to perform exact symbolic computation instead of numerical approximation. It covers creating symbols and expressions, simplification, calculus (derivatives, integrals, limits, series), equation solving, symbolic matrices and linear algebra, physics and mechanics, advanced topics such as number theory and geometry, and code generation via lambdify, codegen and LaTeX output. It produces symbolic results, executable functions and formatted mathematical output, and points to five bundled reference files for deeper detail.
When to use it
Use it when a task requires exact symbolic results rather than numerical approximations, such as solving equations algebraically, differentiating or integrating expressions, or manipulating formulas containing variables and parameters. It also fits symbolic matrix work, physics calculations, number theory and geometry problems, and converting mathematical expressions into executable code or LaTeX.
Requirements
Requires Python with the SymPy library installed; examples also reference NumPy, Matplotlib and SciPy for numerical evaluation and plotting. No credentials or network access are needed. The skill ships no scripts, only instructions and reference documents.

SymPy - Symbolic Mathematics in Python

Overview

SymPy is a Python library for symbolic mathematics that enables exact computation using mathematical symbols rather than numerical approximations. This skill provides comprehensive guidance for performing symbolic algebra, calculus, linear algebra, equation solving, physics calculations, and code generation using SymPy.

When to Use This Skill

Use this skill when:

  • Solving equations symbolically (algebraic, differential, systems of equations)
  • Performing calculus operations (derivatives, integrals, limits, series)
  • Manipulating and simplifying algebraic expressions
  • Working with matrices and linear algebra symbolically
  • Doing physics calculations (mechanics, quantum mechanics, vector analysis)
  • Number theory computations (primes, factorization, modular arithmetic)
  • Geometric calculations (2D/3D geometry, analytic geometry)
  • Converting mathematical expressions to executable code (Python, C, Fortran)
  • Generating LaTeX or other formatted mathematical output
  • Needing exact mathematical results (e.g., sqrt(2) not 1.414...)

Core Capabilities

1. Symbolic Computation Basics

Creating symbols and expressions:

python
from sympy import symbols, Symbolx, y, z = symbols('x y z')expr = x**2 + 2*x + 1
# With assumptionsx = symbols('x', real=True, positive=True)n = symbols('n', integer=True)

Simplification and manipulation:

python
from sympy import simplify, expand, factor, cancelsimplify(sin(x)**2 + cos(x)**2)  # Returns 1expand((x + 1)**3)  # x**3 + 3*x**2 + 3*x + 1factor(x**2 - 1)    # (x - 1)*(x + 1)

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

2. Calculus

Derivatives:

python
from sympy import diffdiff(x**2, x)        # 2*xdiff(x**4, x, 3)     # 24*x (third derivative)diff(x**2*y**3, x, y)  # 6*x*y**2 (partial derivatives)

Integrals:

python
from sympy import integrate, oointegrate(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:

python
from sympy import limit, serieslimit(sin(x)/x, x, 0)  # 1series(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:

python
from sympy import solveset, solve, Eqsolveset(x**2 - 4, x)  # {-2, 2}solve(Eq(x**2, 4), x)  # [-2, 2]

Systems of equations:

python
from sympy import linsolve, nonlinsolvelinsolve([x + y - 2, x - y], x, y)  # {(1, 1)} (linear)nonlinsolve([x**2 + y - 2, x + y**2 - 3], x, y)  # (nonlinear)

Differential equations:

python
from sympy import Function, dsolve, Derivativef = 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:

python
from sympy import Matrix, eye, zerosM = Matrix([[1, 2], [3, 4]])M_inv = M**-1  # InverseM.det()        # DeterminantM.T            # Transpose

Eigenvalues and eigenvectors:

python
eigenvals = M.eigenvals()  # {eigenvalue: multiplicity}eigenvects = M.eigenvects()  # [(eigenval, mult, [eigenvectors])]P, D = M.diagonalize()  # M = P*D*P^-1

Solving linear systems:

python
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:

python
from sympy.physics.mechanics import dynamicsymbols, LagrangesMethodfrom sympy import symbols
# Define systemq = 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 methodLM = LagrangesMethod(L, [q])

Vector analysis:

python
from sympy.physics.vector import ReferenceFrame, dot, crossN = ReferenceFrame('N')v1 = 3*N.x + 4*N.yv2 = 1*N.x + 2*N.zdot(v1, v2)  # Dot productcross(v1, v2)  # Cross product

Quantum mechanics:

python
from sympy.physics.quantum import Ket, Bra, Commutatorpsi = 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:

python
from sympy import lambdifyimport numpy as np
expr = x**2 + 2*x + 1f = lambdify(x, expr, 'numpy')  # Create NumPy functionx_vals = np.linspace(0, 10, 100)y_vals = f(x_vals)  # Fast numerical evaluation

Generate C/Fortran code:

python
from sympy.utilities.codegen import codegen[(c_name, c_code), (h_name, h_header)] = codegen(    ('my_func', expr), 'C')

LaTeX output:

python
from sympy import latexlatex_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

python
from sympy import symbolsx, y, z = symbols('x y z')# Now x, y, z can be used in expressions

2. Use Assumptions for Better Simplification

python
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

python
from sympy import Rational, S# Correct (exact):expr = Rational(1, 2) * xexpr = S(1)/2 * x
# Incorrect (floating-point):expr = 0.5 * x  # Creates approximate value

4. Numerical Evaluation When Needed

python
from sympy import pi, sqrtresult = sqrt(8) + piresult.evalf()    # 5.96371554103586result.evalf(50)  # 50 digits of precision

5. Convert to NumPy for Performance

python
# 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:

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

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

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

    • Load when: Working with matrices or linear algebra problems

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

    • Load when: Physics calculations or mechanics problems

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

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

  5. 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

python
from sympy import symbols, solve, simplifyx = symbols('x')
# Solve equationequation = x**2 - 5*x + 6solutions = solve(equation, x)  # [2, 3]
# Verify solutionsfor sol in solutions:    result = simplify(equation.subs(x, sol))    assert result == 0

Pattern 2: Symbolic to Numeric Pipeline

python
# 1. Define symbolic problemx, y = symbols('x y')expr = sin(x) + cos(y)
# 2. Manipulate symbolicallysimplified = simplify(expr)derivative = diff(simplified, x)
# 3. Convert to numerical functionf = lambdify((x, y), derivative, 'numpy')
# 4. Evaluate numericallyresults = f(x_data, y_data)

Pattern 3: Document Mathematical Results

python
# Compute result symbolicallyintegral_expr = Integral(x**2, (x, 0, 1))result = integral_expr.doit()
# Generate documentationprint(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

python
import numpy as npfrom 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

python
import matplotlib.pyplot as pltimport numpy as npfrom 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

python
from scipy.optimize import fsolvefrom sympy import symbols, lambdify
# Define equation symbolicallyx = symbols('x')equation = x**3 - 2*x - 5
# Convert to numerical functionf = lambdify(x, equation, 'numpy')
# Solve numerically with initial guesssolution = fsolve(f, 2)

Quick Reference: Most Common Functions

python
# Symbolsfrom sympy import symbols, Symbolx, y = symbols('x y')
# Basic operationsfrom sympy import simplify, expand, factor, collect, cancelfrom sympy import sqrt, exp, log, sin, cos, tan, pi, E, I, oo
# Calculusfrom sympy import diff, integrate, limit, series, Derivative, Integral
# Solvingfrom sympy import solve, solveset, linsolve, nonlinsolve, dsolve
# Matricesfrom sympy import Matrix, eye, zeros, ones, diag
# Logic and setsfrom sympy import And, Or, Not, Implies, FiniteSet, Interval, Union
# Outputfrom sympy import latex, pprint, lambdify, init_printing
# Utilitiesfrom sympy import evalf, N, nsimplify

Getting Started Examples

Example 1: Solve Quadratic Equation

python
from sympy import symbols, solve, sqrtx = symbols('x')solution = solve(x**2 - 5*x + 6, x)# [2, 3]

Example 2: Calculate Derivative

python
from sympy import symbols, diff, sinx = symbols('x')f = sin(x**2)df_dx = diff(f, x)# 2*x*cos(x**2)

Example 3: Evaluate Integral

python
from sympy import symbols, integrate, expx = symbols('x')integral = integrate(x * exp(-x**2), (x, 0, oo))# 1/2

Example 4: Matrix Eigenvalues

python
from sympy import MatrixM = Matrix([[1, 2], [2, 1]])eigenvals = M.eigenvals()# {3: 1, -1: 1}

Example 5: Generate Python Function

python
from sympy import symbols, lambdifyimport numpy as npx = symbols('x')expr = x**2 + 2*x + 1f = lambdify(x, expr, 'numpy')f(np.array([1, 2, 3]))# array([ 4,  9, 16])

Troubleshooting Common Issues

  1. "NameError: name 'x' is not defined"

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

  2. Unexpected numerical results

    • Issue: Using floating-point numbers like 0.5 instead of Rational(1, 2)
    • Solution: Use Rational() or S() for exact arithmetic

  3. Slow performance in loops

    • Issue: Using subs() and evalf() repeatedly
    • Solution: Use lambdify() to create a fast numerical function

  4. "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

  5. 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

Source and attribution

Source:zLanqing/codex-claude-academic-skillsinscientific-toolkit-skill/references/scientific-skills/sympyat commit7ed6377

License: https://github.com/sympy/sympy/blob/master/LICENSE

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

More from zLanqing/codex-claude-academic-skills

Statsmodels

zLanqing

Guides statistical modeling in Python with statsmodels, covering regression, GLM, discrete choice, time series and diagnostics.

Data & AnalyticsOct 9, 2026

Seaborn

zLanqing

Guides creation of statistical charts with the seaborn Python library, covering plot types, palettes, theming and multi-panel figures.

Data & AnalyticsOct 9, 2026

Scikit Learn

zLanqing

Guides scikit-learn machine learning in Python, covering supervised and unsupervised learning, preprocessing, evaluation and pipelines.

Includes scripts
Data & AnalyticsOct 9, 2026

Qutip

zLanqing

Guides quantum physics simulation with QuTiP for open and closed quantum systems, solvers, and analysis.

Research & AnalysisOct 9, 2026

Pymoo

zLanqing

Guides multi-objective optimization in Python with pymoo, covering algorithms, constraints, benchmarks, decision making and plots.

Includes scripts
Data & AnalyticsOct 9, 2026

Networkx

zLanqing

Guides creating, analyzing, and visualizing graphs and networks in Python with NetworkX.

Data & AnalyticsOct 9, 2026

More in Data & Analytics

Audit Xls

anthropics

Featured

Audits spreadsheet formulas and financial models for errors, hardcodes, and integrity issues, then reports findings.

Data & Analytics39Kupdated 2 weeks ago

Comps Analysis

anthropics

Featured

Builds institutional-grade comparable company analyses as Excel spreadsheets with operating metrics, valuation multiples and statistics.

Data & Analytics39Kupdated 2 weeks ago

Audit Xls

anthropics

Featured

Audits spreadsheet formulas and financial models for errors, hardcodes, and integrity issues, then reports findings.

Data & Analytics39Kupdated 2 weeks ago

Audit Xls

anthropics

Featured

Audits spreadsheet formulas and financial models for errors, hardcodes, and integrity issues, then reports findings.

Data & Analytics39Kupdated 2 weeks ago

Comps Analysis

anthropics

Featured

Builds institutional-grade comparable company analyses as Excel spreadsheets with operating metrics, valuation multiples and statistics.

Data & Analytics39Kupdated 2 weeks ago

Audit Xls

anthropics

Featured

Audits spreadsheet formulas and financial models for errors, hardcodes, and integrity issues, then reports findings.

Data & Analytics39Kupdated 2 weeks ago