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