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 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.

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):

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.

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

@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},
}