# Math Skill

> A comprehensive mathematical reasoning skill for AI assistants — handles arithmetic to research-level problems with rigorous step-by-step reasoning, systematic verification, and transparent uncertainty handling

- **Type:** Skill
- **Install:** `agentstack add skill-wholiver-math-skill-math-skill`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Wholiver](https://agentstack.voostack.com/s/wholiver)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Wholiver](https://github.com/Wholiver)
- **Source:** https://github.com/Wholiver/Math.Skill
- **Website:** https://github.com/Wholiver/Math.Skill

## Install

```sh
agentstack add skill-wholiver-math-skill-math-skill
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Math.skill

## Skill Name

**Math.skill** — A comprehensive mathematical reasoning skill for AI assistants.

## Skill Purpose

Enable AI assistants to handle mathematical tasks across all difficulty levels — from basic arithmetic to research-level problems — with rigorous, step-by-step reasoning, systematic verification, and transparent uncertainty handling.

This skill enforces a disciplined mathematical workflow: every problem is parsed, modeled, solved with justifications, verified through multiple independent checks, and only then delivered as a final answer. The verification engine (see **Verification Engine** section) is the core differentiator — no answer is output without passing at least two verification methods.

## Scope of Application

This skill covers the following mathematical domains:

- **Foundations**: Arithmetic, number sense, order of operations, unit conversions
- **Algebra**: Algebraic expressions, polynomial operations, factoring, completing the square, rational expressions, radical expressions, exponents and logarithms
- **Equations**: Linear, quadratic, polynomial, rational, radical, exponential, logarithmic, absolute value equations
- **Inequalities**: Linear, quadratic, rational, absolute value, exponential, logarithmic inequalities; systems of inequalities
- **Functions**: Domain/range, composition, inverse, monotonicity, parity, periodicity, graphing, transformations, piecewise functions
- **Geometry**: Plane geometry, solid geometry, coordinate geometry, vector geometry, geometric transformations
- **Trigonometry**: Trigonometric functions, identities, equations, triangle solving, inverse trigonometric functions
- **Sequences and Series**: Arithmetic, geometric, recursive sequences; series convergence, summation formulas
- **Combinatorics**: Permutations, combinations, inclusion-exclusion, pigeonhole principle, generating functions
- **Probability and Statistics**: Classical probability, conditional probability, Bayes' theorem, distributions, expectation, variance, hypothesis testing, confidence intervals
- **Limits**: Limits of sequences and functions, one-sided limits, limits at infinity, epsilon-delta definitions, L'Hôpital's rule
- **Differentiation**: Derivative rules, implicit differentiation, logarithmic differentiation, higher-order derivatives, applications (tangents, rates, optimization, curve sketching)
- **Integration**: Indefinite and definite integrals, substitution, integration by parts, partial fractions, trigonometric integrals, improper integrals, applications (area, volume, arc length, work)
- **Multivariable Calculus**: Partial derivatives, gradients, directional derivatives, double/triple integrals, line integrals, surface integrals, divergence, curl, Green's/Stokes'/divergence theorems
- **Linear Algebra**: Matrices, determinants, vector spaces, linear transformations, eigenvalues/eigenvectors, diagonalization, inner product spaces, quadratic forms
- **Ordinary Differential Equations**: First-order, second-order linear, systems, Laplace transforms, series solutions, qualitative analysis
- **Complex Analysis**: Complex numbers, analytic functions, contour integration, residue theorem, conformal mapping
- **Real Analysis**: Completeness, sequences and series of functions, continuity, differentiation, Riemann integration, measure theory basics
- **Abstract Algebra**: Groups, rings, fields, homomorphisms, isomorphisms, quotient structures, Galois theory basics
- **Topology**: Metric spaces, topological spaces, continuity, compactness, connectedness, fundamental group basics
- **Number Theory**: Divisibility, congruences, prime numbers, Diophantine equations, modular arithmetic, cryptography basics
- **Discrete Mathematics**: Graph theory, recurrence relations, Boolean algebra, automata theory basics
- **Optimization**: Linear programming, nonlinear optimization, constrained optimization, Lagrange multipliers, convex optimization
- **Mathematical Modeling**: Model formulation, parameter estimation, model validation, sensitivity analysis
- **Proofs**: Direct proof, induction, contradiction, contrapositive, construction, exhaustion, epsilon-delta, combinatorial proofs
- **Counterexamples**: Systematic search for counterexamples to disprove conjectures or verify solution uniqueness
- **Solution Checking**: Verifying existing solutions, identifying errors, providing corrections
- **Problem Generation**: Creating well-posed problems with verified solutions at specified difficulty levels
- **Research-Level Problems**: Engaging with open or partially solved problems, clearly distinguishing known results from conjectures

## Out of Scope

This skill should NOT be invoked for:

- **Pure opinion questions**: "Is math beautiful?" — not a mathematical task
- **Non-mathematical creative writing**: Generating poems, stories, or essays not centered on mathematical reasoning
- **Factual lookup without reasoning**: "What is the capital of France?" — no mathematical reasoning required (use general knowledge or web search directly)
- **Pure code generation without math**: Writing a web server, a database query, or a UI component where no mathematical reasoning is needed
- **Conversational chat unrelated to math**: General small talk, emotional support, scheduling, etc.

Boundary cases: If a user asks "Explain the math behind RSA encryption," invoke this skill. If a user asks "Write a Python script to calculate prime numbers," invoke this skill (the core task is mathematical reasoning; code is implementation).

## Language Matching Rules

This skill adapts its language to the user's context:

- **Explicit specification**: If the user specifies an output language (e.g., "Answer in English"), use that language
- **Default**: If not specified, match the user's primary input language throughout the response
- **Mixed Chinese-English input**: Respond in the user's dominant language; keep mathematical terms in their standard form (e.g., "We compute the derivative" or "我们计算导数", not "我们计算导数derivative")
- **Formulas**: Always typeset mathematical formulas in LaTeX (`$inline$` and `$$display$$`)
- **Variable and theorem names**: May remain in English (e.g., "Rolle's Theorem") with a brief explanation or translation in the user's language if the concept may be unfamiliar
- **Answer-only mode**: Concise output with minimal but still present verification — user explicitly wants brevity
- **Detailed derivation mode**: Expand all key steps; show algebraic manipulations, substitutions, and intermediate results
- **Teach-like-a-teacher mode**: Use pedagogical language, explain the intuition behind each step, anticipate common questions, include "why this works" explanations
- **Rigorous proof mode**: Use formal mathematical language, state theorems explicitly, show quantifiers, verify all conditions before applying theorems

## Input Classification

Every input is first classified into one of the following categories. This classification determines the reasoning strategy, output template, and required verification methods.

For detailed classification rules including borderline cases and multi-category problems, see `modules/classification.md`.

| Category | Description | Typical Verification Methods |
|---|---|---|
| `calculation` | Pure numerical or symbolic computation | A, E |
| `algebra_simplification` | Simplify algebraic expressions | A, E, G |
| `equation_solving` | Solve a single equation | A, B, G |
| `system_of_equations` | Solve a system of equations | A, B, E |
| `inequality_solving` | Solve an inequality | B, C, E, G |
| `function_analysis` | Analyze function properties | E, G, H |
| `geometry` | Plane or solid geometry | B, G, H |
| `analytic_geometry` | Coordinate geometry problems | A, E, H |
| `trigonometry` | Trigonometric problems | A, E, G |
| `sequence` | Sequences and series | E, G, H |
| `combinatorics` | Counting and combinatorial problems | E, H, I |
| `probability_statistics` | Probability or statistics problems | E, H, K |
| `word_problem` | Word problems stated in natural language | A, E, F, H |
| `limit` | Limit evaluation | B, E, G, H |
| `differentiation` | Derivative computation or application | E, H, K |
| `integration` | Integral evaluation or application | D, E, H |
| `multivariable_calculus` | Partial derivatives, multiple integrals | E, H, K |
| `linear_algebra` | Matrix/vector/space problems | A, E, H, K |
| `ordinary_differential_equation` | ODE problems | A, E, H |
| `complex_analysis` | Complex function problems | E, H, K |
| `real_analysis` | Real analysis problems | G, H, J |
| `abstract_algebra` | Group/ring/field problems | A, H, J |
| `topology` | Topological space problems | H, I, J |
| `number_theory` | Number theory problems | E, H, I |
| `discrete_math` | Graph theory, recurrences, Boolean algebra | E, H, I |
| `optimization` | Optimization problems | A, C, E, H |
| `mathematical_modeling` | Model construction/validation | E, H, K |
| `proof` | Prove a statement | D, I, J |
| `counterexample` | Find a counterexample | A, I |
| `solution_checking` | Verify an existing solution | A, B, E, H |
| `problem_generation` | Generate a well-posed problem | A, E, H |
| `research_level_problem` | Open or partially solved problems | All applicable |
| `ambiguous_or_incomplete` | Problem is underspecified | N/A — request clarification first |
| `out_of_scope` | Not a mathematical task | N/A — decline or redirect |

If a problem spans multiple categories, classify by the primary mathematical operation required. If the problem is ambiguous (missing conditions, unclear goal, contradictory requirements), classify as `ambiguous_or_incomplete` and request clarification before proceeding.

## Mathematical Reasoning Workflow

All problems, regardless of difficulty, pass through this seven-step workflow. For step-by-step expansion of each step including worked examples, see `modules/reasoning_workflow.md`.

### Step 1: Problem Parsing

Extract and explicitly state:
- **Given conditions**: All stated facts, assumptions, constraints, and known values
- **Goal**: What is being asked — compute, prove, find, simplify, etc.
- **Variables and parameters**: Define all symbols; specify which are known constants, which are unknowns, which are parameters
- **Domains**: The domain of each variable (real numbers, integers, positive numbers, specific intervals, etc.)
- **Implicit conditions**: Hidden constraints (denominators not zero, radicands non-negative, log arguments positive, domain restrictions from function definitions, triangle inequality, etc.)
- **Sufficiency check**: Are the given conditions sufficient to determine a unique solution? If not, note whether multiple solutions, no solution, or parametric families are expected
- **Special properties**: Symmetry, parity, convexity, separability, or other structural properties that may simplify the problem

### Step 2: Mathematical Modeling

Translate the problem into a formal mathematical structure:
- Algebraic problems: Equations, inequalities, systems
- Function problems: Domain-range mappings, compositions
- Geometry: Points, lines, planes, angles, distance relations
- Probability: Sample space, events, probability measure
- Discrete math: Graphs, recurrences, Boolean expressions
- Linear algebra: Matrices, vector spaces, linear transformations
- Calculus: Functions with derivatives/integrals, differential equations
- Optimization: Objective function + constraint set
- Abstract math: Groups, rings, fields, topological spaces, metric spaces

### Step 3: Method Selection

Select the most direct and robust method from the available toolkit, considering efficiency and error-proneness:

- **Direct calculation**: Arithmetic, substitution, evaluation
- **Algebraic manipulation**: Factoring, expanding, completing the square, rationalizing, partial fractions
- **Discriminant analysis**: For quadratic forms and determining solution existence
- **Substitution and elimination**: System solving, change of variables
- **Inequality bounding**: AM-GM, Cauchy-Schwarz, triangle inequality, Jensen, Chebyshev
- **Monotonicity arguments**: Proving existence/uniqueness of solutions
- **Derivatives**: Optimization, rates of change, monotonicity, concavity
- **Integral transforms**: Laplace, Fourier for ODEs and PDEs
- **Limit techniques**: Squeeze theorem, L'Hôpital's rule, Taylor expansion, asymptotic analysis
- **Matrix operations**: Row reduction, eigenvalue decomposition, SVD
- **Induction**: For statements parameterized by natural numbers
- **Contradiction**: Assume the negation, derive an impossibility
- **Construction**: Explicitly build the object claimed to exist
- **Counterexample**: Find a single instance where the claim fails
- **Symmetry exploitation**: Parity, cyclic symmetry, homogeneity

If multiple methods are viable, briefly note trade-offs (e.g., "Method A is simpler but requires more computation; Method B is more elegant but requires familiarity with the Cauchy-Schwarz inequality").

### Step 4: Step-by-Step Solution

Execute the chosen method with complete mathematical justification:
- State every algebraic manipulation
- Cite every theorem by name when applied, and verify its hypotheses are satisfied
- Show non-trivial arithmetic steps explicitly
- Mark key intermediate results
- Maintain a clear logical flow — each step should follow from the previous one

### Step 5: Verification

Apply at least two verification methods from the Verification Engine. The specific methods are determined by problem classification (see **Input Classification** section). Record the verification steps and their outcomes.

### Step 6: Error Correction

If verification reveals an error:
- Backtrack to the last reliable intermediate result
- Identify the nature of the error (algebraic, logical, domain violation, sign error, etc.)
- Correct the step and propagate the correction forward
- Re-verify after correction
- If the error persists after two correction attempts, consider alternative methods

### Step 7: Final Answer

Present the final answer with:
- The answer itself in its simplest form (exact before approximate; e.g., `$\sqrt{2}$` not `$1.414$` unless explicitly requested)
- All conditions and domain restrictions explicitly stated
- A brief verification summary (which methods passed)
- Optional: notable pitfalls or common mistakes related to this problem type

## Verification Engine

Verification is the core of Math.skill. Every solution must pass at least two verification methods before being output. Never output an unverified solution.

For detailed procedures, worked examples, and method selection heuristics, see `modules/verification_engine.md`.

### Method A: Back-Substitution

Substitute the obtained solution back into the original equation(s) or conditions. Verify that all equalities hold and all inequality constraints are satisfied.

**Applicability**: Equations, systems of equations, ODEs, algebraic identities.

### Method B: Domain Check

Verify that every step respects domain constraints. Check that:
- No denominator becomes zero at the solution
- All radicands (even roots) remain non-negative
- All logarithm arguments remain positive
- All parameters remain within their stated domains
- The solution lies within the problem's stated domain

**Applicability**: All problem types.

### Method C: Boundary Check

Test the solution against boundary conditions and edge cases:
- Interval endpoints in inequalities
- Degenerate cases (zero, infinity, empty set)
- Parameter extremes within allowed ranges

**Applicability**: Inequalities, optimization, geometry (degenerate triangles, etc.).

### Method D: Reverse Derivation

Start from the answer and derive the original conditions. If the reverse path is valid, the forward solution is consistent (though not necessarily unique without additional checks).

**Applicability**: Proofs, algebraic derivations, calculus problems.

### Method E: Numerical Sampling

Choose representat

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Wholiver](https://github.com/Wholiver)
- **Source:** [Wholiver/Math.Skill](https://github.com/Wholiver/Math.Skill)
- **License:** MIT
- **Homepage:** https://github.com/Wholiver/Math.Skill

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** yes
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-wholiver-math-skill-math-skill
- Seller: https://agentstack.voostack.com/s/wholiver
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.