Skip to main content
skill CX Codex

residues — Claude Code skill: compute residues in complex analysis

A Claude Code skill for solving residue problems in complex analysis. Computes residues at poles, identifies pole order, and applies the residue theorem through SymPy and Z3.

MIT ★ 3,951 updated 2026-01-26

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add parcadei/Continuous-Claude-v3 --skill residues -a claude-code
Open on GitHub

What residues does

The skill provides structured methods for residue calculation: simple poles via Res(f, z₀) = lim(z→z₀) (z − z₀)f(z), poles of order n through derivatives, essential singularities via Laurent series. Computations run through sympy_compute.py commands for limits, differentiation, and series expansion, plus z3_solve.py for verifying whether poles lie inside an integration contour.

A decision tree guides you through singularity types: first identify whether it's a simple pole or higher order, then compute the residue with the appropriate method, then apply the residue theorem—the integral around a closed curve equals 2πi times the sum of residues inside. Requires Python and SymPy and Z3 libraries.

What it helps with

  • compute the residue of a function at a pole
  • determine the order of a pole
  • find residues at essential singularities using Laurent series
  • evaluate a contour integral via the residue theorem
  • check whether a pole lies inside the integration contour

Example prompts for the agent

  • Use residues to find the residue of 1/((z-1)*(z-2)) at z=1
  • Determine the pole order of e^(1/z) at zero and compute its residue
  • Apply residues to calculate the integral around |z|=3 for a function with poles inside

How to install residues

1Skills CLI (Vercel)

npx skills add parcadei/Continuous-Claude-v3 --skill residues -a claude-code

2Manually: put the files in place

~/.claude/skills/residues/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/residues/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about residues

How do I install residues in Claude Code?

Run npx skills add parcadei/Continuous-Claude-v3 --skill residues -a claude-code, then check the documentation at ~/.claude/skills/residues/SKILL.md.

What does residues do?

It provides tools for computing residues at poles and essential singularities, identifying pole order, and applying the residue theorem to evaluate integrals around closed contours.

What dependencies does residues need?

The skill uses SymPy for symbolic computation (limits, derivatives, series) and Z3 for logical verification. Both must be installed in your Python environment.

Source text

SKILL.md · MIT
---
name: residues
description: "Problem-solving strategies for residues in complex analysis"
allowed-tools: [Bash, Read]
---

# Residues

## When to Use

Use this skill when working on residues problems in complex analysis.

## Decision Tree


1. **Computing Residues**
   - Simple pole at z0:
     * Res(f, z0) = lim_{z->z0} (z - z0)f(z)
     * `sympy_compute.py limit "(z - z0)*f(z)" --var z --at z0`
   - Pole of order n:
     * Res(f, z0) = (1/(n-1)!) * lim d^{n-1}/dz^{n-1}[(z-z0)^n f(z)]
     * `sympy_compute.py diff "((z-z0)**n)*f(z)" --var z --order n-1`
   - L'Hopital shortcut for f = g/h with simple pole:
     * Res(f, z0) = g(z0)/h'(z0)

2. **Identify Pole Order**
   - Simple pole: (z - z0)f(z) has finite limit
   - Order n: (z - z0)^n f(z) has finite limit, but (z - z0)^{n-1} f(z) doesn't
   - `sympy_compute.py limit "(z - z0)**n * f(z)" --var z --at z0`

3. **Essential Singularities**
   - Neither pole nor removable (e.g., e^{1/z} at z=0)
   - Compute residue via Laurent series
   - `sympy_compute.py series "exp(1/z)" --var z --at 0`

4. **Apply Residue Theorem**
   - oint_C f(z)dz = 2*pi*i * (sum of residues inside C)
   - Count only poles INSIDE the contour
   - `z3_solve.py prove "pole_inside_contour"`


## Tool Commands

### Sympy_Residue
```bash
uv run python -m runtime.harness scripts/sympy_compute.py residue "1/((z-1)*(z-2))" --var z --at 1
```

### Sympy_Limit
```bash
uv run python -m runtime.harness scripts/sympy_compute.py limit "(z - z0)*f(z)" --var z --at z0
```

### Sympy_Laurent
```bash
uv run python -m runtime.harness scripts/sympy_compute.py series "exp(1/z)" --var z --at 0
```

### Z3_Pole_Inside
```bash
uv run python -m runtime.harness scripts/z3_solve.py prove "abs(z0) < R"
```

## Key Techniques

*From indexed textbooks:*

- [Complex analysis  an introduction to... (Z-Library)] The fact that the calculus of residues yields complex rather than real integrals is no dis¬ (49) with g(z) — z, we obtain <»» i>(”)=25 / f^w) = 2vi / /'(*) /(z) - w z dz. If (49) is applied with g(z) = zm, equation (50) is replaced by 2iri I |z-zo| = /'(*) f(z) - w zm dz. The right-hand member represents an analytic function of w for \w — ir0| < 8.
- [Complex analysis  an introduction to... (Z-Library)] What are the possible values of r dz J \/l — z2 over a closed curve in the region? THE CALCULUS OF RESIDUES The results of the preceding section have shown that the determination of line integrals of analytic functions over closed curves can be reduced to the determination of periods. Under certain circumstances it turns out that the periods can be found without or with very little computation.
- [Complex analysis  an introduction to... (Z-Library)] Hint: Sketch the image of the imaginary axis and apply the argument principle to a large half disk. Evaluation of Definite Integrals. The calculus of residues pro¬ vides a very efficient tool for the evaluation of definite integrals.
- [Complex analysis  an introduction to... (Z-Library)] The particular function 1 /(z — ay) has a vanishing period. The constant Rj which produces this result is called the residue of f(z) at the point ay. We repeat the definition in the following form: It is helpful to use such self-explanatory notations as R = Res!
- [Complex Analysis (Elias M. Stein, Ram... (Z-Library)] Cauchy, 1826 There is a general principle in the theory, already implicit in Riemann’s work, which states that analytic functions are in an essential way charac- terized by their singularities. That is to say, globally analytic functions are “eectively” determined by their zeros, and meromorphic functions by their zeros and poles. While these assertions cannot be formulated as precise general theorems, there are nevertheless signicant instances where this principle applies.

## Cognitive Tools Reference

See `.claude/skills/math-mode/SKILL.md` for full tool documentation.

© parcadei · MIT · parcadei/Continuous-Claude-v3

Similar skills

All skills for AI and ML →

From the same set161

The whole set →
numerical-integration A skill for numerical integration in mathematical analysis tasks. Guides you through selecting a quadrature method, setting tolerances, and computing integrals via scipy and sympy. CX Codex +1 ★ 3,951repo stars groups Structures problem-solving in group theory. Activates when the agent needs to verify group axioms, test subgroups, or prove homomorphisms. CX Codex +1 ★ 3,951repo stars agentic-workflow The agentic-workflow skill organizes implementation work into research, planning, validation, coding, and review. Separate agents handle each stage in the background. CX Codex +1 ★ 3,951repo stars graph-algorithms graph-algorithms — a Claude Code skill with a decision tree for graph algorithm problems: traversals, shortest paths, spanning trees, network flow, and spectral analysis. Runs Z3 and SymPy via uv run from inside the agent. CX Codex +1 ★ 3,951repo stars hilbert-spaces Solves functional analysis problems involving Hilbert spaces. Use it for orthogonal decomposition, projection theorems, Riesz representation, and computations on orthonormal bases. CX Codex +1 ★ 3,951repo stars debug-agent debug-agent — a subagent that investigates root causes by exploring the codebase, analyzing logs, finding patterns, and writing a detailed report with fix recommendations. CX Codex ★ 3,951repo stars interpolation Guides Claude Code through selecting and running numerical interpolation workflows, from Lagrange polynomials to SciPy splines. CX Codex +1 ★ 3,951repo stars gradient-methods gradient-methods is a Claude Code skill that helps choose gradient-based optimization methods and step sizes, and diagnose convergence in minimization problems. CX Codex +1 ★ 3,951repo stars

Project sponsors

Companies that keep this analytics open