K-Dense-AI/scientific-agent-skills / skills/sympy
sympy
VerifiedPerforms exact symbolic mathematics with SymPy for algebra, calculus, equation solving, symbolic linear algebra, physics, and lambdify or LaTeX code generation. Use when a task needs symbolic results, explicit assumptions, or exact arithmetic; use NumPy or SciPy for purely numerical workloads.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 13.0 KB |
| references/advanced-topics.md | markdown | 13.9 KB |
| references/code-generation-printing.md | markdown | 14.9 KB |
| references/core-capabilities.md | markdown | 9.4 KB |
| references/core_capabilities.md | markdown | 5.1 KB |
| references/matrices-linear-algebra.md | markdown | 10.2 KB |
| references/physics-mechanics.md | markdown | 14.7 KB |
| references/review.md | markdown | 5.9 KB |
references/core_capabilities.md
View on GitHub# Core Capabilities
Examples in this reference are ordered session fragments: run earlier imports and
setup first. Tested with SymPy 1.14.0; exceptions are explicitly marked illustrative.
Symbolic computation basics, calculus, equation solving, matrices and linear algebra,
physics and mechanics, advanced mathematics, and code generation and output. Per-topic
detail is in the other reference files in this directory.
## Core Capabilities
### 1. Symbolic Computation Basics
**Creating symbols and expressions:**
```python
from sympy import symbols, Symbol
x, y, z = symbols('x y z')
expr = x**2 + 2*x + 1
# With assumptions
xp = symbols('xp', positive=True) # Keep x generic for later solving examples
n = symbols('n', integer=True)
```
**Simplification and manipulation:**
```python
from sympy import simplify, expand, factor, cancel, sin, cos, exp
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 `core-capabilities.md`
### 2. Calculus
**Derivatives:**
```python
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:**
```python
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:**
```python
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 `core-capabilities.md`
### 3. Equation Solving
**Algebraic equations:**
```python
from sympy import solveset, solve, Eq
solveset(x**2 - 4, x) # {-2, 2}
solve(Eq(x**2, 4), x) # [-2, 2]
```
**Systems of equations:**
```python
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:**
```python
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 `core-capabilities.md`
### 4. Matrices and Linear Algebra
**Matrix creation and operations:**
```python
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:**
```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])
solution = A.solve(b) # Solve Ax = b; keep x as a Symbol
```
**For comprehensive linear algebra:** See `matrices-linear-algebra.md`
### 5. Physics and Mechanics
**Classical mechanics:**
```python
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])
LM.form_lagranges_equations()
state_derivatives = LM.rhs()
```
**Vector analysis:**
```python
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:**
```python
from sympy.physics.quantum import Ket, Bra, Operator, Commutator
A, B = Operator('A'), Operator('B')
psi = Ket('psi')
comm = Commutator(A, B).doit()
```
**For detailed physics capabilities:** See `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 `advanced-topics.md`
### 7. Code Generation and Output
**Convert to executable functions:**
```python
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:**
```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 latex
latex_str = latex(expr) # Convert to LaTeX for documents
```
**For comprehensive code generation:** See `code-generation-printing.md`
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| planning-and-task-breakdownaddyosmani/agent-skillsBreaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| screenpipethedotmack/claude-memSearch screen and audio history recorded by Screenpipe and optionally save selected context into claude-mem. Use when the user asks to recall desktop activity, a meeting, or something seen in another app through Screenpipe. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |
| contact-widgetnexu-io/open-designSelf-contained floating chat widget with welcome screen, social links, meeting button, and message input. Single HTML file, zero dependencies. | Stars: 108k | Updated | Claude CodeCodex | Verified | Install |
| meeting-notesnexu-io/open-designMeeting notes page — title bar with attendees, agenda checklist, decisions block, action items table with owners + dates, and a "next meeting" footer. Use when the brief mentions "meeting notes", "minutes", "1:1 notes", "all-hands recap", or "会议纪要". | Stars: 108k | Updated | Claude CodeCodex | Verified | Install |