Skip to main content
affpapa.org
RU EN
skill CX Codex

math-help — Claude Code skill: what it does, how to install

Reference guide for the agent's math cognitive stack, showing when to use SymPy, Z3, SciPy, Lean 4, or verification scripts.

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

What math-help does

The skill serves as a navigation map for mathematical computations and theorem checks. It categorizes tasks across distinct layers, from symbolic algebra in SymPy and constraint verification in Z3 to tutoring hints and formal proofs in Lean 4.

Inside, the guide documents CLI syntax with uv run python for repository scripts like sympy_compute.py, z3_solve.py, and math_scratchpad.py. For numerical workloads, it lists NumPy with 160 functions, SciPy with 289 functions, and mpmath with 153 arbitrary-precision functions. Plotting is handled through math_plot.py with 2D, 3D, and LaTeX rendering support.

The frontmatter sets user-invocable: false. You do not call it directly as a command. The assistant retrieves this guide automatically whenever triggered by phrases like "math help" or questions about which tool to pick.

What it helps with

  • choose the right math tool for symbolic, numerical, or formal tasks
  • find ready CLI commands for limits, differentiation, and integrals in SymPy
  • verify satisfiability and solve constraint proofs with Z3
  • validate step-by-step mathematical reasoning via math_scratchpad.py

Example prompts for the agent

  • math help: how do I solve an equation with sympy_compute.py?
  • which tool should I use to check a chain of reasoning steps?
  • how do I run numerical minimization with scipy_compute.py?

How to install math-help

1Skills CLI (Vercel)

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

2Manually: put the files in place

~/.claude/skills/math-help/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/math-help/

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

Questions about math-help

How do I install math-help in Claude Code?

Run npx skills add parcadei/Continuous-Claude-v3 --skill math-help -a claude-code. The file will be saved to ~/.claude/skills/math-help/SKILL.md.

What does the math-help skill do?

It gives the agent a reference architecture for mathematical tools, detailing execution commands for SymPy, Z3, SciPy, NumPy, mpmath, and plotting utilities.

Can I trigger math-help manually?

No, it defines user-invocable: false. The model accesses the guide automatically when prompted with math queries or trigger words like which tool.

Source text

SKILL.md · MIT 
---
name: math-help
description: Guide to the math cognitive stack - what tools exist and when to use each
triggers: ["help", "guide", "how do I", "what math", "math help", "math tools", "which tool", "math tutorial"]
user-invocable: false
---

# Math Cognitive Stack Guide

Cognitive prosthetics for exact mathematical computation. This guide helps you choose the right tool for your math task.

## Quick Reference

| I want to... | Use this | Example |
|--------------|----------|---------|
| Solve equations | sympy_compute.py solve | `solve "x**2 - 4 = 0" --var x` |
| Integrate/differentiate | sympy_compute.py | `integrate "sin(x)" --var x` |
| Compute limits | sympy_compute.py limit | `limit "sin(x)/x" --var x --to 0` |
| Matrix operations | sympy_compute.py / numpy_compute.py | `det "[[1,2],[3,4]]"` |
| Verify a reasoning step | math_scratchpad.py verify | `verify "x = 2 implies x^2 = 4"` |
| Check a proof chain | math_scratchpad.py chain | `chain --steps '[...]'` |
| Get progressive hints | math_tutor.py hint | `hint "Solve x^2 - 4 = 0" --level 2` |
| Generate practice problems | math_tutor.py generate | `generate --topic algebra --difficulty 2` |
| Prove a theorem (constraints) | z3_solve.py prove | `prove "x + y == y + x" --vars x y` |
| Check satisfiability | z3_solve.py sat | `sat "x > 0, x < 10, x*x == 49"` |
| Optimize with constraints | z3_solve.py optimize | `optimize "x + y" --constraints "..."` |
| Plot 2D/3D functions | math_plot.py | `plot2d "sin(x)" --range -10 10` |
| Arbitrary precision | mpmath_compute.py | `pi --dps 100` |
| Numerical optimization | scipy_compute.py | `minimize "x**2 + 2*x" "5"` |
| Formal machine proof | Lean 4 (lean4 skill) | `/lean4` |

## The Five Layers

### Layer 1: SymPy (Symbolic Algebra)

**When:** Exact algebraic computation - solving, calculus, simplification, matrix algebra.

**Key Commands:**
```bash
# Solve equation
uv run python -m runtime.harness scripts/sympy_compute.py \
    solve "x**2 - 5*x + 6 = 0" --var x --domain real

# Integrate
uv run python -m runtime.harness scripts/sympy_compute.py \
    integrate "sin(x)" --var x

# Definite integral
uv run python -m runtime.harness scripts/sympy_compute.py \
    integrate "x**2" --var x --bounds 0 1

# Differentiate (2nd order)
uv run python -m runtime.harness scripts/sympy_compute.py \
    diff "x**3" --var x --order 2

# Simplify (trig strategy)
uv run python -m runtime.harness scripts/sympy_compute.py \
    simplify "sin(x)**2 + cos(x)**2" --strategy trig

# Limit
uv run python -m runtime.harness scripts/sympy_compute.py \
    limit "sin(x)/x" --var x --to 0

# Matrix eigenvalues
uv run python -m runtime.harness scripts/sympy_compute.py \
    eigenvalues "[[1,2],[3,4]]"
```

**Best For:** Closed-form solutions, calculus, exact algebra.

### Layer 2: Z3 (Constraint Solving & Theorem Proving)

**When:** Proving theorems, checking satisfiability, constraint optimization.

**Key Commands:**
```bash
# Prove commutativity
uv run python -m runtime.harness scripts/cc_math/z3_solve.py \
    prove "x + y == y + x" --vars x y --type int

# Check satisfiability
uv run python -m runtime.harness scripts/cc_math/z3_solve.py \
    sat "x > 0, x < 10, x*x == 49" --type int

# Optimize
uv run python -m runtime.harness scripts/cc_math/z3_solve.py \
    optimize "x + y" --constraints "x >= 0, y >= 0, x + y <= 100" \
    --direction maximize --type real
```

**Best For:** Logical proofs, constraint satisfaction, optimization with constraints.

### Layer 3: Math Scratchpad (Reasoning Verification)

**When:** Verifying step-by-step reasoning, checking derivation chains.

**Key Commands:**
```bash
# Verify single step
uv run python -m runtime.harness scripts/cc_math/math_scratchpad.py \
    verify "x = 2 implies x^2 = 4"

# Verify with context
uv run python -m runtime.harness scripts/cc_math/math_scratchpad.py \
    verify "x^2 = 4" --context '{"x": 2}'

# Verify chain of reasoning
uv run python -m runtime.harness scripts/cc_math/math_scratchpad.py \
    chain --steps '["x^2 - 4 = 0", "(x-2)(x+2) = 0", "x = 2 or x = -2"]'

# Explain a step
uv run python -m runtime.harness scripts/cc_math/math_scratchpad.py \
    explain "d/dx(x^3) = 3*x^2"
```

**Best For:** Checking your work, validating derivations, step-by-step verification.

### Layer 4: Math Tutor (Educational)

**When:** Learning, getting hints, generating practice problems.

**Key Commands:**
```bash
# Step-by-step solution
uv run python scripts/cc_math/math_tutor.py steps "x**2 - 5*x + 6 = 0" --operation solve

# Progressive hint (level 1-5)
uv run python scripts/cc_math/math_tutor.py hint "Solve x**2 - 4 = 0" --level 2

# Generate practice problem
uv run python scripts/cc_math/math_tutor.py generate --topic algebra --difficulty 2
```

**Best For:** Learning, tutoring, practice.

### Layer 5: Lean 4 (Formal Proofs)

**When:** Rigorous machine-verified mathematical proofs, category theory, type theory.

**Access:** Use `/lean4` skill for full documentation.

**Best For:** Publication-grade proofs, dependent types, category theory.

## Numerical Tools

For numerical (not symbolic) computation:

### NumPy (160 functions)
```bash
# Matrix operations
uv run python scripts/cc_math/numpy_compute.py det "[[1,2],[3,4]]"
uv run python scripts/cc_math/numpy_compute.py inv "[[1,2],[3,4]]"
uv run python scripts/cc_math/numpy_compute.py eig "[[1,2],[3,4]]"
uv run python scripts/cc_math/numpy_compute.py svd "[[1,2,3],[4,5,6]]"

# Solve linear system
uv run python scripts/cc_math/numpy_compute.py solve "[[3,1],[1,2]]" "[9,8]"
```

### SciPy (289 functions)
```bash
# Minimize function
uv run python scripts/cc_math/scipy_compute.py minimize "x**2 + 2*x" "5"

# Find root
uv run python scripts/cc_math/scipy_compute.py root "x**3 - x - 2" "1.5"

# Curve fitting
uv run python scripts/cc_math/scipy_compute.py curve_fit "a*exp(-b*x)" "0,1,2,3" "1,0.6,0.4,0.2" "1,0.5"
```

### mpmath (153 functions, arbitrary precision)
```bash
# Pi to 100 decimal places
uv run python scripts/cc_math/mpmath_compute.py pi --dps 100

# Arbitrary precision sqrt
uv run python -m scripts.mpmath_compute mp_sqrt "2" --dps 100
```

## Visualization

### math_plot.py
```bash
# 2D plot
uv run python scripts/cc_math/math_plot.py plot2d "sin(x)" \
    --var x --range -10 10 --output plot.png

# 3D surface
uv run python scripts/cc_math/math_plot.py plot3d "x**2 + y**2" \
    --xvar x --yvar y --range 5 --output surface.html

# Multiple functions
uv run python scripts/cc_math/math_plot.py plot2d-multi "sin(x),cos(x)" \
    --var x --range -6.28 6.28 --output multi.png

# LaTeX rendering
uv run python scripts/cc_math/math_plot.py latex "\\int e^{-x^2} dx" --output equation.png
```

## Educational Features

### 5-Level Hint System

| Level | Category | What You Get |
|-------|----------|--------------|
| 1 | Conceptual | General direction, topic identification |
| 2 | Strategic | Approach to use, technique selection |
| 3 | Tactical | Specific steps, intermediate goals |
| 4 | Computational | Intermediate results, partial solutions |
| 5 | Answer | Full solution with explanation |

**Usage:**
```bash
# Start with conceptual hint
uv run python scripts/cc_math/math_tutor.py hint "integrate x*sin(x)" --level 1

# Get more specific guidance
uv run python scripts/cc_math/math_tutor.py hint "integrate x*sin(x)" --level 3
```

### Step-by-Step Solutions

```bash
uv run python scripts/cc_math/math_tutor.py steps "x**2 - 5*x + 6 = 0" --operation solve
```

Returns structured steps with:
- Step number and type
- From/to expressions
- Rule applied
- Justification

## Common Workflows

### Workflow 1: Solve and Verify
1. Solve with sympy_compute.py
2. Verify solution with math_scratchpad.py
3. Plot to visualize (optional)

```bash
# Solve
uv run python -m runtime.harness scripts/sympy_compute.py \
    solve "x**2 - 4 = 0" --var x

# Verify the solutions work
uv run python -m runtime.harness scripts/cc_math/math_scratchpad.py \
    verify "x = 2 implies x^2 - 4 = 0"
```

### Workflow 2: Learn a Concept
1. Generate practice problem with math_tutor.py
2. Use progressive hints (level 1, then 2, etc.)
3. Get full solution if stuck

```bash
# Generate problem
uv run python scripts/cc_math/math_tutor.py generate --topic calculus --difficulty 2

# Get hints progressively
uv run python scripts/cc_math/math_tutor.py hint "..." --level 1
uv run python scripts/cc_math/math_tutor.py hint "..." --level 2

# Full solution
uv run python scripts/cc_math/math_tutor.py steps "..." --operation integrate
```

### Workflow 3: Prove and Formalize
1. Check theorem with z3_solve.py (constraint-level proof)
2. If rigorous proof needed, use Lean 4

```bash
# Quick check with Z3
uv run python -m runtime.harness scripts/cc_math/z3_solve.py \
    prove "x*y == y*x" --vars x y --type int

# For formal proof, use /lean4 skill
```

## Choosing the Right Tool

```
Is it SYMBOLIC (exact answers)?
  └─ Yes → Use SymPy
      ├─ Equations → sympy_compute.py solve
      ├─ Calculus → sympy_compute.py integrate/diff/limit
      └─ Simplify → sympy_compute.py simplify

Is it a PROOF or CONSTRAINT problem?
  └─ Yes → Use Z3
      ├─ True/False theorem → z3_solve.py prove
      ├─ Find values → z3_solve.py sat
      └─ Optimize → z3_solve.py optimize

Is it NUMERICAL (approximate answers)?
  └─ Yes → Use NumPy/SciPy
      ├─ Linear algebra → numpy_compute.py
      ├─ Optimization → scipy_compute.py minimize
      └─ High precision → mpmath_compute.py

Need to VERIFY reasoning?
  └─ Yes → Use Math Scratchpad
      ├─ Single step → math_scratchpad.py verify
      └─ Chain → math_scratchpad.py chain

Want to LEARN/PRACTICE?
  └─ Yes → Use Math Tutor
      ├─ Hints → math_tutor.py hint
      └─ Practice → math_tutor.py generate

Need MACHINE-VERIFIED formal proof?
  └─ Yes → Use Lean 4 (see /lean4 skill)
```

## Related Skills

- `/math` or `/math-mode` - Quick access to the orchestration skill
- `/lean4` - Formal theorem proving with Lean 4
- `/lean4-functors` - Category theory functors
- `/lean4-nat-trans` - Natural transformations
- `/lean4-limits` - Limits and colimits

## Requirements

All math scripts are installed via:
```bash
uv sync
```

Dependencies: sympy, z3-solver, numpy, scipy, mpmath, matplotlib, plotly

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

Similar skills

Everything for Science and research →
math-proof-judge official Anthropic A subagent that runs a hard math proof step by step: plans each round's questions, reads the answers, and assembles proof.md. ★ 44,635repo stars statistics-math pluginagentmarketplace A coding-agent skill with Python recipes for statistics, probability, linear algebra and regression. Useful when you need to compute metrics or test a hypothesis. CX Codex +1 432installs math-reasoning lingzhi227 Derives equations, writes proofs, formalizes research problems, and produces publication-ready LaTeX markup for research papers. CX Codex +1 2,200installs math-teacher jamesrochabrun Generates playful, browser-based math playgrounds with interactive graphs and game mechanics. Helps learners explore arithmetic, algebra, and calculus visually. CX Codex +1 871installs math-olympiad official Anthropic Solves IMO, Putnam and USAMO problems and checks proofs with separate agents that never see the reasoning trace. ★ 44,635repo stars pixijs-math pixijs A skill covering coordinates, matrices, shapes and hit testing in PixiJS v8. Useful when a point has to move between coordinate spaces or a container needs a custom hit area. CX Codex +1 5,900installs

From the same set77

refactor Runs refactoring through analysis, planning, implementation, review and test validation. Use it when restructuring code while preserving behaviour. CX Codex +1 621installs recall-reasoning Searches previous sessions for working approaches, failed attempts, and build context. Useful when tackling tasks similar to past work. CX Codex +1 601installs graceful-degradation A skill that has the agent check optional services up front and explain what broke and how to fix it instead of returning nothing. CX Codex +1 599installs explore A skill for reading unfamiliar projects: a quick structure pass, a deep analysis, or a map of layers and dependencies. It never edits code. CX Codex +1 577installs sub-agents Configures specialized Claude Code sub-agents with isolated contexts, dedicated models, and restricted toolsets for specific coding workflows. CX Codex +1 533installs security A security audit skill: scans code for vulnerabilities, checks dependencies and secrets, then re-verifies after fixes. CX Codex +1 530installs research-agent A subagent that gathers external documentation, code examples and best practices through MCP tools, then writes a handoff for the next agent. CX Codex +1 528installs perplexity-search Runs Perplexity AI web search, deep research, and chain-of-thought reasoning directly from the agent terminal. CX Codex +1 524installs

Project sponsors

Companies that keep this analytics open
Gold sponsor
Nutra.Club

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor