---
pretty_name: Integrals
license: mit
language:
- en
tags:
- mathematics
- symbolic-integration
size_categories:
- 1K<n<10K
configs:
- config_name: default
  data_files:
  - split: test
    path: integrals.jsonl
---

# Integrals

1,000 indefinite integrals of a single elementary term, such as $\int -5x^{8}\,dx$ or
$\int 4x\sin(15x + 9)\,dx$, each with a reference antiderivative. Each one alone is a
routine exercise. The paper
[On the Fragility of Tasks under Composition: Implicit Budgeting in Language Models](https://arxiv.org/abs/2610.27190)
sums k of them into one integrand and asks a model for the antiderivative of the whole,
so each term must still be integrated correctly when it shares the prompt with others.
The code for those experiments is at
[github.com/chenpanli/fragility](https://github.com/chenpanli/fragility).

```python
from datasets import load_dataset

pool = load_dataset("chenpanli/integrals", split="test")
```

## Problems

There are five categories of 200 problems each, stored in this order (`atom-0000` to
`atom-0199` are polynomials, and so on). Here $a$ ranges over $[-5, 5]$, $n$ and $b$ over
$[-15, 15]$, all three nonzero, and $c$ over $[-15, 15]$.

| Category | Integrand |
| --- | --- |
| `polynomial` | $a x^n$, including negative powers |
| `trigonometric` | $a \sin(bx+c)$, $a \cos(bx+c)$ or $a \tan(bx+c)$ |
| `exponential` | $a e^{bx}$ |
| `logarithmic_rational` | $a \ln(bx+c)$ or $a / (bx+c)$ |
| `integration_primitive` | $a x \cdot g(bx+c)$ for $g \in \{\exp, \sin, \cos, \ln, \arctan\}$, which needs integration by parts |

Every problem is solvable: SymPy found an elementary antiderivative for it, and that
antiderivative passed the same checker that grades model answers. Of 1,272 random
draws, the 272 that repeated an earlier integrand were dropped; none failed either check.

## How it was made

`generation/experiments/integrals/generate_dataset.py` draws the integrands, solves and
checks them, and writes `integrals.manifest.json` with the seed, the parameter ranges and
the rejection counts. To rebuild the pool (under a minute on one CPU core):

```bash
pip install -r generation/requirements.txt
cd generation
PYTHONPATH=src python experiments/integrals/generate_dataset.py -n 1000
cmp datasets/integrals/atomic.jsonl ../integrals.jsonl    # identical
```

`generation/src/llm/` holds the modules the script imports from the paper's code:
`integral_utils.py` (the sampler), and `verification.py` with the `parser/` package it
uses (the checker, identical to the code repository's copies).

## Fields

| Field | Meaning |
| --- | --- |
| `id` | Stable id, `atom-0000` to `atom-0999`. Every composed prompt in the paper refers to problems by this id. |
| `integrand` | The integrand in SymPy syntax, e.g. `-5*x**8`. |
| `integrand_latex` | The integrand in LaTeX, e.g. `- 5 x^{8}`. |
| `integrand_latex_integral` | The integral as it appears in the prompt, e.g. `\int - 5 x^{8} \, dx`. |
| `reference_antiderivative` | One antiderivative in SymPy syntax, e.g. `-5*x**9/9`. |
| `category` | One of the five categories above. |
| `variable` | Always `x`. |
| `stage`, `k` | Always `atomic` and `1`. |

## Grading

An answer is correct if its derivative equals the integrand, so any constant of
integration, and any form of the antiderivative, is accepted. The checker is
`check_antiderivative` in `generation/src/llm/core/math/verification.py`. It reads the
last `\boxed{}` of a model response, parses the LaTeX, differentiates it with SymPy and
compares the result to the integrand. If their difference does not expand to zero, it
evaluates both sides at complex sample points to reject wrong answers, then confirms the
rest by simplifying the difference.

```python
from llm.core.math.verification import check_antiderivative

result = check_antiderivative(r"... $\boxed{-\frac{5x^{9}}{9} + C}$", "-5*x**8",
                              symbol="x", input_kind="response")
result.verdict    # Verdict.CORRECT
```

## Citation

```bibtex
@inproceedings{li2026fragility,
  title     = {On the Fragility of Tasks under Composition: Implicit Budgeting in Language Models},
  author    = {Li, Chenpan and Brockmoeller, Thies and Jegelka, Stefanie and
               Gupta, Sharut and Karalias, Nikolaos},
  year      = {2026},
}
```