skelfresearch/minimal-core-benchmark

Minimal-Core Benchmark

77 constraint-satisfaction and optimisation problems across seven domains. Each one comes as plain English plus a machine-checkable spec. A deterministic oracle scores any proposed answer.

It is built to measure one thing: when a language model reads a problem in English, does it get the answer right? That covers turning the text into a solver program (autoformalization), and answering directly with no solver at all.

Released with From Errors to Proofs: Minimal-Core-Guided Repair for Neuro-Symbolic Constraint Solving, Dipankar Sarkar, IJCAI-ECAI 2026 Workshop on Logic and Symbolic Reasoning (LogiSymb).

Paper: https://arxiv.org/abs/2608.14771

Code: github.com/sarkar-dipankar/minimal-core-benchmark (this package is built from commit b607ea2; the instances are unchanged since 330d980).

The oracle idea

The ground truth never comes from a language model.

• Every instance has a structured spec: variables, value domains, a typed constraint list, an optional objective.
• A trusted encoder (benchmark/reference.py) turns the spec, not the English text, into Answer Set Programming. clingo then decides feasibility and the optimum. So the labels are correct by construction.
• Every system answers in one shape: an assignment {variable: value}. That is the assign(Var, Value) relation. A colouring, a roster, a seating plan and a knapsack packing are all just sets of assign atoms.
• The oracle (benchmark/verify.py) checks that assignment against the spec. It needs no solver and no model. It reports constraints satisfied, feasibility, and objective value.

One oracle scores every pipeline the same way, the symbolic one and any prompting baseline. On an infeasible instance the right answer is no assignment. Committing to any assignment there counts as a fabricated solution.

The English description states every constraint in the spec. A model is never penalised for information it was not given.

Counts

Every number below is computed from data/instances.jsonl.

	Instances
Total	77
Feasible (feasible: true)	63
Infeasible (feasible: false)	14
Optimisation (has_objective: true, all knapsack, all max)	11

Domain	feasible	tight	infeasible	stress	xl	Total
graph_coloring	4	4	5	3	3	19
scheduling	4	2	2	2	2	12
knapsack	5	4	0	2	0	11
team_assignment	4	2	3	1	1	11
seating	3	2	2	1	1	9
timetabling	3	2	2	1	1	9
latin_square	2	1	0	1	2	6
Total	25	17	14	11	10	77

What the variants probe:

• feasible: clearly worded and solvable.
• tight: solvable but numerically tight (capacity equals demand, k equals the chromatic number). Probes a false "unsatisfiable" from over-formalisation.
• infeasible: clearly worded but over-constrained. The correct answer is to report unsatisfiability. Probes invented solutions.
• stress: larger instances, 12 to 56 decision variables.
• xl: the largest, 20 to 120 decision variables, feasibility only.

Across all 77 instances there are 1,431 decision variables and 2,682 constraints. Per instance: 4 to 120 variables, 1 to 900 constraints.

Constraint type	Count
not_equal	2,391
capacity	131
all_different	70
min_count	62
equal	15
weighted_capacity	11
forbidden	2

verify.py also implements required and exact_count. No shipped instance uses them.

Schema

One config, default, one split, train. One row per benchmark/problems/<id>.json.

Column	Type	What it is
id	string	Instance id, same as the file name.
domain	string	One of the seven domains above.
variant	string	feasible, tight, infeasible, stress or xl.
size	int	The generator's size parameter. Usually the variable count. For latin_square it is the side length n (n x n variables).
feasible	bool	Ground truth: does a valid assignment exist?
optimal_value	float, null	Ground-truth optimum. Set on the 11 optimisation instances only.
has_objective	bool	Filter column. True when objective is set.
objective_sense	string, null	max or min. Only max occurs.
n_variables	int	Filter column. len(variables).
n_constraints	int	Filter column. len(constraints).
constraint_types	list of string	Filter column. Sorted distinct constraint types in the instance.
nl_description	string	The English problem. This is the model input.
variables	list of string	Decision variables, in spec order.
domains	JSON string	{variable: [value, ...]}.
constraints	JSON string	[{"type": ..., ...}, ...].
objective	JSON string, null	{"sense": "max", "weights": {variable: {value: number}}}.
reference_witness	JSON string, null	One valid assignment found by clingo. Null on the 14 infeasible instances. For debugging and scoring only. Never show it to a system under test.
file	string	Source path in the GitHub repo.

domains, constraints, objective and reference_witness ship as JSON strings on purpose. domains and reference_witness are keyed by variable name, with 399 distinct names across the set. constraints mixes 7 different key sets. As nested columns they would not fit one schema. Parse them with json.loads. The upstream field _reference_witness is renamed reference_witness.

To rebuild the original spec dict from a row:

import json

def to_spec(row):
    spec = {k: row[k] for k in ("id", "domain", "size", "variant", "nl_description",
                                "variables", "feasible", "optimal_value")}
    for k in ("domains", "constraints", "objective"):
        spec[k] = json.loads(row[k]) if row[k] is not None else None
    return spec

raw/

raw/benchmark/ and raw/savanty/ are exact copies of the release directories, minus __pycache__. raw/savanty/asp_runtime.py is the small clingo wrapper the oracle and encoder import. LICENSE, CITATION.cff and requirements.txt sit beside them. No config points at raw/. It is there so nothing from the release is lost, and so the oracle runs straight from this repo.

Verify with clingo

The oracle itself needs only Python. Recomputing ground truth needs clingo (pip install clingo). Run from raw/ so benchmark and savanty import as packages:

import json
from datasets import load_dataset
from benchmark.reference import ground_truth
from benchmark.verify import verify

rows = load_dataset("skelfresearch/minimal-core-benchmark", split="train")
agree = opt = wit = 0
for row in rows:
    spec = to_spec(row)                      # helper above
    gt = ground_truth(spec)                  # trusted spec -> ASP -> clingo
    agree += gt["feasible"] == row["feasible"]
    opt += gt["optimal_value"] == row["optimal_value"]
    if row["reference_witness"]:
        r = verify(spec, json.loads(row["reference_witness"]))
        wit += r.feasible and r.csr == 1.0
print(agree, opt, wit)                       # 77 77 63

We ran this check on the release files with clingo 5.8.2. The recomputed feasibility label matches on all 77 instances. The recomputed optimum matches on all 11 optimisation instances. All 63 reference witnesses pass the oracle with every constraint satisfied.

To score your own system, map its output to {variable: value} and call verify(spec, assignment). Pass None when it reports the problem unsatisfiable.

Reproduce or regenerate

Generation is deterministic. Fixed structures, no random numbers. From the GitHub repo root:

pip install clingo
python -m benchmark.build_dataset

benchmark/generators.py emits the 77 specs. build_dataset.py labels each one with reference.ground_truth and rewrites benchmark/problems/. It aborts if any variant disagrees with its label, for example an infeasible instance that turns out solvable. We regenerated the specs from generators.py and compared them field by field with the shipped files: same 77 ids, 0 differences.

To rebuild this package from a checkout:

python3 build_hf.py /path/to/minimal-core-benchmark .

build_hf.py is stdlib only. Two runs give byte-identical output.

License

MIT, same as the source repo. See raw/LICENSE.

Citation

@inproceedings{sarkar2026minimalcore,
  title     = {From Errors to Proofs: Minimal-Core-Guided Repair for
               Neuro-Symbolic Constraint Solving},
  author    = {Sarkar, Dipankar},
  booktitle = {IJCAI-ECAI 2026 Workshop on Logic and Symbolic Reasoning (LogiSymb)},
  year      = {2026},
  eprint    = {2608.14771},
  archivePrefix = {arXiv},
  url       = {https://arxiv.org/abs/2608.14771}
}

Links

• Paper: https://arxiv.org/abs/2608.14771
• Benchmark code and oracle: https://github.com/sarkar-dipankar/minimal-core-benchmark
• Savanty, the natural-language to constraint-solver system this benchmark evaluates: https://github.com/Skelf-Research/savanty

Which of your pipeline's answers would survive an oracle that never trusts the model?