Skip to main content
skill CX Codex

lebesgue-measure — Claude Code skill: measure theory problem-solving

A skill for measure theory tasks focused on Lebesgue measure. Provides decision trees and computational tools to work through outer measure construction, the Carathéodory criterion, and properties of measurable sets.

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 lebesgue-measure -a claude-code
Open on GitHub

What lebesgue-measure does

This skill outlines approaches to core problems in measure theory. It covers outer measure as an infimum of interval lengths, Carathéodory's criterion for measurability, essential properties such as translation invariance and sigma-additivity, and regularity theorems (inner and outer).

Built-in commands handle symbolic work: sympy_compute.py sums interval lengths and simplifies expressions about Borel sets, while z3_solve.py proves the Carathéodory criterion formally. Computation runs through Bash and Read operations—the only permitted tools.

Best suited for graduate students and researchers working through Lebesgue measure systematically. Assumes comfort with measure-theoretic language and notation.

What it helps with

  • compute outer measure of a set via infimum of interval-length sums
  • verify measurability using the Carathéodory criterion
  • establish inner and outer regularity of Lebesgue measure
  • simplify expressions involving countable unions of Borel sets
  • confirm measure is invariant under translation

Example prompts for the agent

  • Calculate the outer measure of set A by running sympy_compute.py sum "length(I_n)" --var n
  • Verify that E satisfies measurability through z3_solve.py prove "caratheodory_criterion"
  • Simplify a countable-union expression over open sets with sympy_compute.py simplify

How to install lebesgue-measure

1Skills CLI (Vercel)

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

2Manually: put the files in place

~/.claude/skills/lebesgue-measure/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/lebesgue-measure/

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

Questions about lebesgue-measure

How do I install lebesgue-measure in Claude Code?

Run npx skills add parcadei/Continuous-Claude-v3 --skill lebesgue-measure -a claude-code, then open ~/.claude/skills/lebesgue-measure/SKILL.md.

What does lebesgue-measure do?

The skill provides structured approaches to Lebesgue measure problems: outer measure construction, Carathéodory measurability, regularity, and key properties. It includes symbolic computation and proof tools.

What tools are available in this skill?

Bash and Read operations. These run sympy_compute.py for interval-sum calculations and expression simplification, and z3_solve.py for formal proofs of the Carathéodory criterion.

Source text

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

# Lebesgue Measure

## When to Use

Use this skill when working on lebesgue-measure problems in measure theory.

## Decision Tree


1. **Outer measure construction**
   - m*(A) = inf{sum |I_n| : A subset union(I_n)}
   - `sympy_compute.py sum "length(I_n)" --var n`

2. **Caratheodory criterion**
   - E is measurable if: m*(A) = m*(A & E) + m*(A & E^c) for all A
   - `z3_solve.py prove "caratheodory_criterion"`

3. **Lebesgue measure properties**
   - Translation invariant: m(E + x) = m(E)
   - sigma-additive on measurable sets
   - m([a,b]) = b - a

4. **Regularity theorems**
   - Inner regularity: m(E) = sup{m(K) : K compact, K subset E}
   - Outer regularity: m(E) = inf{m(U) : U open, E subset U}


## Tool Commands

### Sympy_Outer_Measure
```bash
uv run python -m runtime.harness scripts/sympy_compute.py sum "length(I_n)" --var n --from 1 --to oo
```

### Z3_Caratheodory
```bash
uv run python -m runtime.harness scripts/z3_solve.py prove "mu(A) == mu(A & E) + mu(A & E_complement)"
```

### Sympy_Borel_Sets
```bash
uv run python -m runtime.harness scripts/sympy_compute.py simplify "open_set_countable_union"
```

## Key Techniques

*From indexed textbooks:*

- [Measure, Integration  Real Analysis (... (Z-Library)] Lebesgue measure on the Lebesgue measurable sets does have one small advantage over Lebesgue measure on the Borel sets: every subset of a set with (outer) measure 0 is Lebesgue measurable but is not necessarily a Borel set. However, any natural process that produces a subset of R will produce a Borel set. Thus this small advantage does not often come up in practice.
- [Measure, Integration  Real Analysis (... (Z-Library)] B j j You have probably long suspected that not every subset of R is a Borel set. Now j j j j Section 2D Lebesgue Measure restricted to the Borel sets, is a measure. Borel sets Outer measure is a measure on (R, of R.
- [Measure, Integration  Real Analysis (... (Z-Library)] The terminology Lebesgue set would make good sense in parallel to the termi- nology Borel set. However, Lebesgue set has another meaning, so we need to use Lebesgue measurable set. Every Lebesgue measurable set differs from a Borel set by a set with outer measure 0.
- [Measure, Integration  Real Analysis (... (Z-Library)] If you go at a leisurely pace, then covering Chapters 1–5 in the rst semester may be a good goal. If you go a bit faster, then covering Chapters 1–6 in the rst semester may be more appropriate. For a second-semester course, covering some subset of Chapters 6 through 12 should produce a good course.
- [Measure, Integration  Real Analysis (... (Z-Library)] Egorov’s Theorem, which states that pointwise convergence of a sequence of measurable functions is close to uniform convergence, has multiple applications in later chapters. Luzin’s Theorem, back in the context of R, sounds spectacular but has no other uses in this book and thus can be skipped if you are pressed for time. Chapter 4: The highlight of this chapter is the Lebesgue Differentiation Theorem, which allows us to differentiate an integral.

## 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 →
plan-agent It researches a codebase and relevant guidance, then writes an implementation plan with phases, files, acceptance criteria, and tests. Use it to map out a feature before changing the project. CX Codex ★ 3,951repo stars sleuth sleuth — a subagent that systematically debugs issues by forming diagnostic questions, tracing code paths, analyzing logs, and documenting findings in a structured report. CX Codex ★ 3,951repo stars scribe scribe — a Claude Code subagent for tracking progress across sessions. It logs decisions, completed steps, and file lists into markdown handoffs and ledgers. CX Codex ★ 3,951repo stars parallel-agents The parallel-agents skill lays out a background-run and file-based workflow for coordinating agents. Use it to track parallel tasks without pulling each agent’s full response into context. CX Codex +1 ★ 3,951repo stars second-order-odes second-order-odes guides Claude Code through analytical and numerical workflows for solving second-order ordinary differential equations. CX Codex +1 ★ 3,951repo stars math-model-selector The math-model-selector skill helps identify a mathematical framework when you have a problem but aren’t sure how to formalize it. Use it to choose a direction before working through the calculations. CX Codex +1 ★ 3,951repo stars first-order-odes first-order-odes — a skill for classifying and solving first-order differential equations. Guides you through equation type detection, selects a solution method, and provides commands for both analytical and numerical solving. CX Codex +1 ★ 3,951repo stars operator-theory operator-theory — a skill for Claude Code with strategies for functional analysis: bounded operator verification, spectral theory, compact operators. Runs Z3 and SymPy for proofs and computations. CX Codex +1 ★ 3,951repo stars

Project sponsors

Companies that keep this analytics open