PyGeoX

Datasets for training and evaluating language models on geometric constraint solving: reading a natural-language description of a diagram and producing the point coordinates and circle radii that satisfy every stated constraint, checked by per-constraint residuals rather than against a single ground-truth coordinate file.

Companion to Internalizing Geometric Law: Learning from Solver Residuals for Precision-Critical Generation. Code and the agent harness: Huawei-AI4Math/PyGeoX.

Evaluation suites (900 problems)

Config	Rows	What it is
bench	450	Procedural problems, 150 each at Easy / Medium / Hard. Same pipeline as the training corpus but disjoint from it.
wild	150	Human-written exam geometry adapted from ZhongKaoGeo, MathVerse and MathVista.
cad	150	Detail-drawing geometry (pitch circles, fillets, ogee blends, tangent belt runs) phrased as drawing annotations.
mech	150	Inverse mechanism synthesis, e.g. locating a fixed pivot so a linkage reaches prescribed positions.

All four are self-contained. Every row carries the description, the reference PyGeoX code and a reference solution, so scoring never needs a second file.

Training corpora

Config	Rows	Task
gcs-rl	46,977	RL prompts for geometry constraint solving
codegen-sft	46,977	SFT, natural-language description → PyGeoX code
gcs-sft	15,738	SFT, solve geometry (NL → coordinates), merged master with per-variant reward labels

from datasets import load_dataset
bench = load_dataset("rafaelcabral96/PyGeoX", "bench")
cad   = load_dataset("rafaelcabral96/PyGeoX", "cad")

Note on the viewer. Several subsets contain free-form nested objects (Objs, possible_solution, answer_schema) whose keys vary per example. The evaluation harness downloads the raw .jsonl files and parses them line by line with json, which always works. The Hugging Face viewer may not fully render the nested fields.

Download

pip install huggingface_hub
python load_pygeox.py --root ./PyGeoX        # downloads everything + extracts the archives
# --- or ---
hf download rafaelcabral96/PyGeoX --repo-type dataset --local-dir ./PyGeoX
cd ./PyGeoX/data && unzip -q PyGeoX-GCS-RL-Code.zip

The archives are only needed for the training corpora, whose rows reference their reward ground truth by source_file. The four evaluation suites need nothing extracted.

Scoring a model

The metric throughout is the solving rate: the fraction of problems where every constraint is satisfied to ‖r‖₂² < 1e-3.

from pygeox import agent_tools
from pygeox.synthetic.llm_client import create_scene_from_json

# bench rows: rebuild the scene from the record's own scene spec
scene = create_scene_from_json(domain=10, json_data=record, generate_objective_function=True)
reward, details = scene.reward.reward_function(pred_points, pred_circles)

# wild / cad / mech rows: execute the shipped reference code, then verify
ns = {}
exec(record["full_code"].split("scene.solver.numerical")[0], ns, ns)
scene = ns["scene"]; agent_tools.prepare(scene)
result = agent_tools.verify(scene, pred_points, pred_circles)   # per-constraint residuals
result["solved"]        # -> bool

Suite details

bench — procedural, 450

Fields: unique_id, difficulty (easy/medium/hard), nl_description, pygeox_code, Objs, Rels, Points, extra_rel, possible_solution.

Difficulty is set by the number of primary polygons: Easy ≈ 13 objects and 8 constraints, Medium ≈ 15 and 10, Hard ≈ 23 and 16. Because the generator is shared with the training corpus, bench is a held-out sample of the training distribution: the right instrument for comparing reward designs under otherwise identical conditions, and not a claim of general geometry ability.

wild — exam geometry, 150

Fields: id, source, source_id, nl_description, full_code, possible_solution.

Provenance of the 150 released problems:

Source	Problems
MathVerse	72
ZhongKaoGeo	62
MathVista	16

Only the diagram description is kept; the question that followed it ("compute angle ABC") is removed, so the task becomes construction rather than question answering. The PyGeoX formalization was written afterwards, so the phrasing was never shaped by our DSL.

This is genuinely out of distribution. Comparing the DSL primitives each problem's ground-truth code uses, 99.0% of wild problems exercise a primitive combination occurring nowhere in bench, and 37.4% use at least one primitive bench never uses. A typical bench item averages 454 characters and enumerates every object up front; the wild mean is 138 characters and assumes the reader supplies the standard conventions.

cad and mech — engineering, 150 each

Fields: unique_id, problem_id, domain, template, tier (1–4), nl_description, answer_schema, full_code, possible_solution, implicit_facts, branch_facts.

Hand-authored from parameterized templates, every problem a manually verified natural-language / PyGeoX pair. The vocabulary deliberately avoids classical-geometry and kinematics terminology: cad states tangency through its physical consequence rather than by name ("runs smoothly out of", "no kink") and gives diameters rather than radii; mech avoids coupler, rocker, Grashof and degrees of freedom, so a model is scored on geometry rather than on whether it recognizes the jargon.

Each candidate had to pass eight automated checks before admission: the scene builds, the reference solution is exact well below tolerance, the figure is non-degenerate, the answer schema is sound, the constraint Jacobian is well conditioned at the reference, the problem carries margin against the tolerance, the intended configuration is locally unique, and any disambiguating clause in the prose is load-bearing (an alternate branch violating only that clause is confirmed to fail).

tier is authoring complexity, 1 (simplest) to 4 (hardest); tier 4 is 50 problems in each suite.

gcs-sft — geometry-solving SFT (merged master)

One deduplicated file keyed by (problem, completion). Each row's splits map records, per training variant (sar, sar_sd, mse, mse_sd, sparse, plus the full base), whether that variant includes it and with what reward/weight. Reconstruct any variant:

rows    = [r for r in ds if r["splits"]["mse_sd"]["in"]]
weights = [r["splits"]["mse_sd"].get("weight", 1.0) for r in rows]

codegen-sft — NL → PyGeoX code

messages = (user: diagram description + "Please generate PyGeoX code…", assistant: fenced python block), plus problem_id, source_file, difficulty.

gcs-rl — RL prompts

messages (system + user), source_file (→ reward ground truth inside PyGeoX-GCS-RL-Code.zip), difficulty.

Citation

@article{cabral2026internalizinggeometriclaw,
  title={Internalizing Geometric Law: Learning from Solver Residuals for Precision-Critical Generation},
  author={Cabral, Rafael and Pang, Zixi and Shou, Ziyi and Shen, Xin},
  journal={arXiv preprint arXiv:2606.09278},
  year={2026}
}

License

MIT