Skip to main content
skill CX Codex

limits-colimits — Claude Code skill: what it does, how to install

limits-colimits is a Claude Code skill that provides decision workflows for category theory limits and colimits, including Lean 4 proof formalization and SymPy calculations.

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 limits-colimits -a claude-code
Open on GitHub

What limits-colimits does

This skill guides Claude Code through category theory problems. It provides a decision tree to identify limit types like equalizers, pullbacks, and products, along with their dual colimit counterparts such as pushouts and coequalizers.

It outlines specific workflows for Lean 4 using the CategoryTheory.Limits namespace and universal property helpers like IsLimit.lift. For concrete sets, the skill triggers symbolic equation solving via scripts/sympy_compute.py using uv run.

Working with this skill requires lake for Lean builds and an execution environment with uv and Python for the SymPy script.

What it helps with

  • classify diagram types into limits or colimits
  • formalize universal cone properties using Lean 4
  • compute pullback equations with SymPy
  • verify limit preservation under right adjoint functors

Example prompts for the agent

  • Help me formulate the universal property of this pullback in Lean 4
  • Solve the equalizer condition f(a) == g(b) using the SymPy harness
  • Run lake build to verify my limit preservation proof

How to install limits-colimits

1Skills CLI (Vercel)

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

2Manually: put the files in place

~/.claude/skills/limits-colimits/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/limits-colimits/

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

Questions about limits-colimits

How to install limits-colimits in Claude Code?

Run npx skills add parcadei/Continuous-Claude-v3 --skill limits-colimits -a claude-code. The skill file will be placed in ~/.claude/skills/limits-colimits/SKILL.md.

What does limits-colimits do?

It provides a step-by-step reasoning tree for categorical limits and colimits, bridging abstract diagrams to Lean 4 constructs and SymPy solvers.

Which tool permissions are required?

The skill requests Bash and Read permissions to inspect files, execute SymPy calculations via uv, and run lake build.

Source text

SKILL.md · MIT
---
name: limits-colimits
description: "Problem-solving strategies for limits colimits in category theory"
allowed-tools: [Bash, Read]
---

# Limits Colimits

## When to Use

Use this skill when working on limits-colimits problems in category theory.

## Decision Tree


1. **Identify Limit Type**
   - Product: limit of discrete diagram
   - Equalizer: limit of parallel pair f, g: A -> B
   - Pullback: limit of A -> C <- B
   - Terminal object: limit of empty diagram
   - Lean 4: `CategoryTheory.Limits` namespace

2. **Verify Universal Property**
   - Cone from L with projections pi_i: L -> D_i
   - For any cone from X, unique morphism u: X -> L
   - Triangles commute: pi_i . u = cone_i
   - Lean 4: `IsLimit.lift` gives the unique morphism

3. **Colimit (Dual)**
   - Coproduct: colimit of discrete diagram
   - Coequalizer: colimit of parallel pair
   - Pushout: colimit of A <- C -> B
   - Initial object: colimit of empty diagram

4. **Compute Limits Concretely**
   - In Set: product = Cartesian product
   - Equalizer = {x | f(x) = g(x)}
   - Pullback = {(a,b) | f(a) = g(b)}
   - `sympy_compute.py solve "f(a) == g(b)"`

5. **Preservation**
   - Right adjoint preserves limits
   - Left adjoint preserves colimits
   - Representable functors preserve limits
   - Lean 4: `Adjunction.rightAdjointPreservesLimits`
   - See: `.claude/skills/lean4-limits/SKILL.md` for exact syntax


## Tool Commands

### Lean4_Limit
```bash
# Lean 4: import CategoryTheory.Limits.Shapes.Products
```

### Lean4_Universal
```bash
# Lean 4: IsLimit.lift cone -- unique morphism from universal property
```

### Sympy_Pullback
```bash
uv run python -m runtime.harness scripts/sympy_compute.py solve "f(a) == g(b)"
```

### Lean4_Build
```bash
lake build  # Compiler-in-the-loop verification
```

## 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 Science and research →

From the same set161

The whole set →
matrices matrices — a skill for matrix operations: identifies types, performs arithmetic, solves linear systems. Includes decompositions like LU, QR, SVD and works across Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode. CX Codex +1 1installs leann-search leann-search runs semantic code queries against a LEANN vector index when exact keyword matches fall short. CX Codex +1 ★ 3,951repo stars natural-transformations This skill guides category-theory work on natural transformations, with Lean 4 notation for checking naturality and applying related constructions. CX Codex +1 ★ 3,951repo stars categories-functors categories-functors — a skill for solving category and functor problems in category theory. Validates axioms, checks functor properties, and verifies proofs in Lean 4 via compiler. CX Codex +1 ★ 3,951repo stars llm-tuning-patterns The llm-tuning-patterns skill recommends LLM settings for theorem proving, code generation, and creative work. Use it to choose token limits and temperature for a specific task. CX Codex +1 ★ 3,951repo stars research-codebase research-codebase — a subagent that automatically documents your codebase. It spawns specialized agents in parallel to locate files, analyze code logic, find usage patterns, and synthesize findings into a single technical report. CX Codex ★ 3,951repo stars search-tools search-tools is a Claude Code skill that routes code searches to LEANN, AST-grep, Morph, or Grep based on the task. CX Codex +1 ★ 3,951repo stars modular-arithmetic Handles modular arithmetic problems in graph number theory. Activates when you need the extended Euclidean algorithm, the Chinese remainder theorem, Euler's theorem, quadratic residues, or order of elements. CX Codex +1 ★ 3,951repo stars

Project sponsors

Companies that keep this analytics open