File size: 4,292 Bytes
c88f17b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 | ---
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},
}
```
|