GlassGSM / README.md
reza2ei's picture
Duplicate from reza2ei/GlassGSM
2998f00
|
Raw History Blame Contribute Delete
8.04 kB
metadata
license: mit
language:
  - en
pretty_name: GlassGSM
size_categories:
  - 10K<n<100K
task_categories:
  - text-classification
tags:
  - math
  - robustness
  - perturbation
  - benchmark
  - causal-inference
  - gsm8k
  - math-reasoning
configs:
  - config_name: glassgsm
    default: true
    data_files:
      - split: full
        path: data/glassgsm/twins.parquet
  - config_name: glassgsm_bases
    data_files:
      - split: full
        path: data/glassgsm/bases.parquet
  - config_name: glassgsm_pooled
    data_files:
      - split: full
        path: data/glassgsm/pooled_bases.parquet

GlassGSM

Meaning-preserving "twins" of the 1,319 GSM8K test problems, each labeled with whether the solver (gpt-4o-mini) that solved the original problem fails on the twin. The data supports the study of conditional causal difficulty (how fragile a task a model can already solve is to a rewrite that leaves the answer unchanged) and was released with the paper Fragility Is Not Reducible to Hardness: Conditional Causal Difficulty for LLMs. It is the grade-school companion of GlassMATH.

No twin is written by a language model. All three perturbation families are applied by deterministic, seeded code, so every twin is reproducible from the released scripts and carries no artifact of a generator model. A language model enters only twice, both of them downstream of the perturbation: as the solver whose outcomes become the labels, and as the No-Op judge in the audit described below.

Code: https://github.com/upwork/Conditional_Causal_Difficulty_for_LLMs/ (training and evaluation of Frail-π, and the scripts that build this release).

What is in a row

A base is an original GSM8K problem. A twin is the same problem after one perturbation that must not change the gold answer. Each twin was posed to the solver and compared against the solver's result on the base problem.

family what is done
entity_rename person names are replaced with names from a neutral pool
sentence_reorder the problem's sentences are reordered
injection one or more setup sentences from a different GSM8K problem are injected; injection_ops is how many (1, 3, 5, 7, or 9)

Fragility rises with perturbation dose: the original GSM-IC leaves 3.7% of problems fragile, while GlassGSM raises this to 44.9% over the pooled doses (see the table below).

Configs

config one row is rows
glassgsm one twin × one run setting m 32,858
glassgsm_bases one base problem × m, with base-level aggregates 6,595
glassgsm_pooled one base problem, pooled over all doses (unique twin texts) 1,319

Each config has a single split named full. No train/test split is shipped; the paper uses repeated random problem-level splits, so split by base_id, never by row: all twins of a base share a label structure and a base text.

Twin fields (glassgsm)

field type meaning
uid string unique row key solver/m{m}/twin_id (twin_id alone is only unique within one m)
base_id string original problem id; gsmic_adv-N is index N of the GSM8K test split
twin_id string twin id within a run
m int run setting (1, 3, 5, 7, 9)
solver string solver model whose outputs produced the labels (gpt-4o-mini for every row)
family / injection_ops / operator perturbation family, number of injected sentences (null for non-injection), and the raw operator tag
complexity, complexity_score declared complexity proxy: a heuristic score in [0, 1] computed from the problem text (it correlates with problem length); complexity is medium for every row
base_text, twin_text string original and perturbed problem
gold_answer string final answer, extracted from GSM8K (####)
base_solved bool the solver answered the base correctly (modal answer of 5 samples at temperature 0.2)
delta int Y(base) - Y(twin) in {-1, 0, 1}; 1 means the twin is wrong where the base was right
broke bool delta == 1. It implies base_solved. Fragility is defined on rows where base_solved is true

Base fields (glassgsm_bases)

base_id, m, solver, complexity, complexity_score, base_text, gold_answer, base_solved plus n_twins, d_obs (mean delta over the base's twins) and d_wc (max delta). They are exact aggregates of the twin rows, shipped separately so they do not leak into twin-level modeling as if they were per-twin labels.

Pooled fields (glassgsm_pooled)

base_id, solver, complexity_score, base_text, gold_answer, base_solved (majority over the five doses), n_unique_twins (twins pooled over all doses, deduplicated on (base_id, twin_text)), pi (break rate over those twins, the CCD; meaningful only where base_solved), d_obs (mean delta), fragile (d_obs > 0.05, the paper's definition, over all problems) and ccd_fragile (base_solved and pi > 0.05).

Statistics

Break rate = share of twins on a solved base that the solver gets wrong. Fragile problems = share of all problems whose mean effect d_obs exceeds 0.05 (the paper's definition). CCD-fragile = share of solved problems whose break rate pi exceeds 0.05.

Solver: gpt-4o-mini (temperature 0.2, 5 samples per prompt, modal answer).

m twins base problems break rate on solved bases fragile problems zero-effect problems
1 1,319 1,319 6.6% 6.2% 92.0%
3 3,957 1,319 8.8% 17.8% 79.3%
5 6,594 1,319 10.7% 27.4% 69.7%
7 9,210 1,319 11.6% 34.1% 62.9%
9 11,778 1,319 12.5% 39.6% 56.9%
pooled 18,309 unique 1,319 n/a 44.9% 48.6%

Pooled over doses, 47.7% of the 1,242 solved problems are CCD-fragile. Fragility rises steadily with dose. The pooled row is the GlassGSM row of the paper's Table 1 (44.9% fragile, 48.6% zero-effect, 13.9 unique twins per problem); the original GSM-IC leaves 3.7% of problems fragile. Per-dose figures come from the glassgsm config and the pooled figures from glassgsm_pooled.

Construction and audit

Twins come from the three operator families above, and every one of them is produced by deterministic, seeded code rather than by an LLM rewrite. Entity renaming substitutes recognised person names consistently from a fixed gender-neutral pool; sentence reordering applies a hash-seeded shuffle of the setup sentences and leaves the question sentence last; injection splices in setup sentences copied verbatim from a hash-chosen different GSM8K problem. The same seed reproduces the same corpus, and each twin carries exactly one family. Before release every (base, twin) pair is passed through a full-corpus filter: an LLM adjudicator checks that the twin does not change or invalidate the gold answer, and deterministic checks drop pairs with entity-name collisions, gold-answer-number collisions, or an extra question. This corpus is the audited, resampled mix of those surviving pairs (no new LLM calls were made to build it).

Provenance and licensing

Base problems and gold answers originate from GSM8K (MIT); injected sentences also come from GSM8K. Perturbations and labels are new. The release is under the MIT license; the upstream notice is reproduced in NOTICE.md.

Loading

import pandas as pd

twins = pd.read_parquet("data/glassgsm/twins.parquet")
solved = twins[(twins["solver"] == "gpt-4o-mini") & (twins["m"] == 9) & twins["base_solved"]]

Citation

@misc{rezaei2026fragilityreduciblehardnessconditional,
      title={Fragility Is Not Reducible to Hardness: Conditional Causal Difficulty for LLMs},
      author={Mohammad Reza Rezaei and Dingxian Wang and Nikhil Verma and Sajjad Pakdamansavoji and Andrew Rabinovich and Zhao Chen},
      year={2026},
      eprint={2611.02065},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={https://arxiv.org/abs/2611.02065},
}