Datasets:

AIML-TUDA
/

SLR-Bench-French

dataset_info:
  - config_name: v1-All
    features:
      - name: id
        dtype: int64
      - name: prompt
        dtype: string
      - name: ground-truth rule
        dtype: string
      - name: validation program
        dtype: string
      - name: symbols
        dtype: string
      - name: curriculum level
        dtype: int64
      - name: curriculum tier
        dtype: string
      - name: rule sampling
        dtype: string
      - name: rule complexity
        dtype: string
      - name: background sampling
        dtype: string
      - name: problem size
        dtype: int64
      - name: vocabulary predicates
        dtype: int64
      - name: vocabulary car constants
        dtype: string
      - name: validation_program_shortcuts
        dtype: string
    splits:
      - name: train
        num_bytes: 1330104923
        num_examples: 18053
      - name: validation
        num_bytes: 13434480
        num_examples: 200
      - name: test
        num_bytes: 66517564
        num_examples: 1000
    download_size: 267176369
    dataset_size: 1410056967
  - config_name: v1-Basic
    features:
      - name: id
        dtype: int64
      - name: prompt
        dtype: string
      - name: ground-truth rule
        dtype: string
      - name: validation program
        dtype: string
      - name: symbols
        dtype: string
      - name: curriculum level
        dtype: int64
      - name: curriculum tier
        dtype: string
      - name: rule sampling
        dtype: string
      - name: rule complexity
        dtype: string
      - name: background sampling
        dtype: string
      - name: problem size
        dtype: int64
      - name: vocabulary predicates
        dtype: int64
      - name: vocabulary car constants
        dtype: string
      - name: validation_program_shortcuts
        dtype: string
    splits:
      - name: train
        num_bytes: 18444548
        num_examples: 3053
      - name: validation
        num_bytes: 248756
        num_examples: 50
      - name: test
        num_bytes: 1237822
        num_examples: 250
    download_size: 2388614
    dataset_size: 19931126
  - config_name: v1-Easy
    features:
      - name: id
        dtype: int64
      - name: prompt
        dtype: string
      - name: ground-truth rule
        dtype: string
      - name: validation program
        dtype: string
      - name: symbols
        dtype: string
      - name: curriculum level
        dtype: int64
      - name: curriculum tier
        dtype: string
      - name: rule sampling
        dtype: string
      - name: rule complexity
        dtype: string
      - name: background sampling
        dtype: string
      - name: problem size
        dtype: int64
      - name: vocabulary predicates
        dtype: int64
      - name: vocabulary car constants
        dtype: string
      - name: validation_program_shortcuts
        dtype: string
    splits:
      - name: train
        num_bytes: 72416519
        num_examples: 5000
      - name: validation
        num_bytes: 725110
        num_examples: 50
      - name: test
        num_bytes: 3625594
        num_examples: 250
    download_size: 12185724
    dataset_size: 76767223
  - config_name: v1-Hard
    features:
      - name: id
        dtype: int64
      - name: prompt
        dtype: string
      - name: ground-truth rule
        dtype: string
      - name: validation program
        dtype: string
      - name: symbols
        dtype: string
      - name: curriculum level
        dtype: int64
      - name: curriculum tier
        dtype: string
      - name: rule sampling
        dtype: string
      - name: rule complexity
        dtype: string
      - name: background sampling
        dtype: string
      - name: problem size
        dtype: int64
      - name: vocabulary predicates
        dtype: int64
      - name: vocabulary car constants
        dtype: string
      - name: validation_program_shortcuts
        dtype: string
    splits:
      - name: train
        num_bytes: 882263577
        num_examples: 5000
      - name: validation
        num_bytes: 8879542
        num_examples: 50
      - name: test
        num_bytes: 43999572
        num_examples: 250
    download_size: 181804147
    dataset_size: 935142691
  - config_name: v1-Medium
    features:
      - name: id
        dtype: int64
      - name: prompt
        dtype: string
      - name: ground-truth rule
        dtype: string
      - name: validation program
        dtype: string
      - name: symbols
        dtype: string
      - name: curriculum level
        dtype: int64
      - name: curriculum tier
        dtype: string
      - name: rule sampling
        dtype: string
      - name: rule complexity
        dtype: string
      - name: background sampling
        dtype: string
      - name: problem size
        dtype: int64
      - name: vocabulary predicates
        dtype: int64
      - name: vocabulary car constants
        dtype: string
      - name: validation_program_shortcuts
        dtype: string
    splits:
      - name: train
        num_bytes: 356980279
        num_examples: 5000
      - name: validation
        num_bytes: 3581072
        num_examples: 50
      - name: test
        num_bytes: 17654576
        num_examples: 250
    download_size: 70815052
    dataset_size: 378215927
configs:
  - config_name: v1-All
    data_files:
      - split: train
        path: v1-All/train-*
      - split: validation
        path: v1-All/validation-*
      - split: test
        path: v1-All/test-*
  - config_name: v1-Basic
    data_files:
      - split: train
        path: v1-Basic/train-*
      - split: validation
        path: v1-Basic/validation-*
      - split: test
        path: v1-Basic/test-*
  - config_name: v1-Easy
    data_files:
      - split: train
        path: v1-Easy/train-*
      - split: validation
        path: v1-Easy/validation-*
      - split: test
        path: v1-Easy/test-*
  - config_name: v1-Hard
    data_files:
      - split: train
        path: v1-Hard/train-*
      - split: validation
        path: v1-Hard/validation-*
      - split: test
        path: v1-Hard/test-*
  - config_name: v1-Medium
    data_files:
      - split: train
        path: v1-Medium/train-*
      - split: validation
        path: v1-Medium/validation-*
      - split: test
        path: v1-Medium/test-*
license: cc-by-4.0
language:
  - fr
tags:
  - logic
  - inductive
  - reasoning
pretty_name: Scalable Logical Reasoning Benchmark
size_categories:
  - 1K<n<10K

Dataset Description

Language(s) (NLP): French
Point of Contact: Lukas Helff
License: CC BY

🧠 SLR-Bench-French: Scalable Logical Reasoning Benchmark (French Edition)

SLR-Bench Multilingual Versions:

SLR-Bench-French is the French-language pendant of the original SLR-Bench dataset. It follows the same symbolic structure, evaluation framework, and curriculum as the English version but provides all natural-language task prompts translated into French.

This enables systematic evaluation and training of Large Language Models (LLMs) in logical reasoning in French, supporting both multilingual reasoning and cross-lingual generalization research.

DS Overview

Curriculum: 20 complexity levels, grouped into 4 broad tiers (basic, easy, medium, hard)
Tasks: >19,000, each comprising: A natural language prompt, an executable validation program for automatic evaluation, and a latent ground-truth rule.
Application: SLR-Bench can used to evaluate conventional and reasoning LLMs (e.g., GPT-4o, Llama-3, Gemini, DeepSeek-R1) and to train models via curriculum learning.

Key Features of SLR

🔨 Automatic Task Generation: Synthesize new inductive reasoning tasks with controllable complexity, novel logic rules, and natural language prompts—no need for human annotation.
🧩 Programmable & Scalable: Specify your own logic vocabulary, grammar, rule distributions, and task parameters; supports curriculum-style scaling and out-of-distribution task creation.
🧠 Symbolic, Automated Evaluation: Deterministically verify LLM outputs via the validation program, not MCQA, LLM judge, or exact matching.
📈 Curriculum Learning: Use SLR-Bench, a structured 20-level benchmark, for evaluating and training models across a span of logical challenges.

Quick Start

Loading the Dataset

from datasets import load_dataset
# Load SLR-Bench test split
ds = load_dataset("AIML-TUDA/SLR-Bench-French", "v1-All", split="test")

Evaluate using SLR-Bench

Requires the evaluate library and a Prolog interpreter installed on your system (e.g., SWI-Prolog). Install the required dependencies via:

pip install evaluate
sudo apt-get install swi-prolog

Example Usage

from evaluate import load
symbolic_judge = load("AIML-TUDA/VerifiableRewardsForScalableLogicalReasoning")
rules = ds["ground-truth rule"]  # For demo only—use model predictions in practice
references = [
    {
        "validation_program": p,
        "evaluation_config": {
            "positive_predicate": "est",
            "negative_predicate": "ouest"
        }
    } for p in ds["validation program"]
]

results = symbolic_judge.compute(predictions=rules, references=references)
print(results)

Note: For real evaluation, replace rules with your model's predicted rules. Here, we use ground-truth rules for demonstration only.

Example results:

{'accuracy': 1.0,
 'partial_score': 1.0,
 'syntax_score': 1.0,
 'detailed_results': [{'is_correct': True,'partial_score': 1.0,'syntax_valid': True,'error': None,'exec_time1': 0.014362812042236328},
                      {'is_correct': True,'partial_score': 1.0,'syntax_valid': True,'error': None,'exec_time1': 0.012364625930786133}]
}

Dataset Columns

Column Name	Type	Description
id	`int64`	Unique identifier for each dataset entry (row).
prompt	`string`	The instruction prompt of the logical reasoning task.
ground-truth rule	`string`	The latent logical rule that solves the given task.
validation program	`string`	The executable logic program used by the symbolic judge to verify candidate model solutions for the task.
symbols	`string`	Symbolic representation of the bckground knowledge
curriculum level	`int64`	The specific level (1-20) in the SLR-Bench curriculum that this task belongs to, reflecting difficulty.
curriculum tier	`string`	The broader difficulty tier grouping multiple levels (e.g., "basic", "easy", "medium", "hard").
rule sampling	`string`	The policy or method used to generate the ground-truth rule (e.g., "uniform", "llm-guided").
rule complexity	`string`	The length of the logic rule, counting the number of used predicates without the has_car predicate.
background sampling	`string`	The policy used to sample background knowledge for the task (e.g., "mirror", "uniform").
problem size	`int64`	Total number of labeled examples (positive + negative) provided in the task instance.
vocabulary predicates	`int64`	Number of unique predicate symbols available in the vocabulary for constructing rules and background knowledge.
vocabulary car constants	`string`	List of car constant symbols (e.g., "car1", "car2", ...) available in the vocabulary for the task.

SLR-Bench Curriculum

Stage	Level	#Consts	#Preds	κ (Problem Size)	Bπ (Background)	Rlen (Rule len)	Rsample (Rule Sample)	Comb. Size
Basic	1	1	5	2	mirror	1	uniform	10³
	2	1	5	2	mirror	1-2	uniform	10³
	3	1	5	4	mirror	1-2	uniform	10⁵
	4	2	5	4	mirror	1-2	uniform	10¹⁰
	5	2	5	6	mirror	1-2	uniform	10¹⁶
Easy	6	2	5	6	uniform	1-2	uniform/llm	10¹⁶
	7	2	6	6	uniform	1-2	uniform/llm	10²⁴
	8	2-3	6	8	uniform	1-2	uniform/llm	10³²
	9	2-3	6	10	uniform	2-3	uniform/llm	10⁴⁰
	10	2-3	7	12	uniform	2-3	uniform/llm	10⁵⁵
Medium	11	2-4	7	14	uniform	2-3	uniform/llm	10⁶⁵
	12	2-4	9	16	uniform	3-4	uniform/llm	10¹²⁰
	13	4-6	9	18	uniform	3-4	uniform/llm	10²⁷¹
	14	4-6	9	20	uniform	4-5	uniform/llm	10³⁰⁰
	15	4-6	9	22	uniform	4-5	uniform/llm	10³³⁰
Hard	16	5-6	10	24	uniform	4-5	uniform/llm	10⁵⁰⁷
	17	5-6	10	26	uniform	4-5	uniform/llm	10⁵⁴⁹
	18	5-6	12	28	uniform	4-5	uniform/llm	10⁸⁰⁵
	19	5-6	12	30	uniform	5	uniform/llm	10⁸⁶¹
	20	5-6	12	32	uniform	5	uniform/llm	10⁹¹⁹

SLR-Bench Curriculum: level-wise configurations, detailing language and task parameters for each difficulty stage. Language complexity is systematically increased by expanding the number of car constants and predicates. Task configuration grows via adapting problem size, background sampling, rule length, and rule sampling strategy. The final column reports the approximate combinatorial size of unique tasks available at each level.

Licensing Information

SLR-Bench is made available under the CC BY license.

Citation

If you use this dataset or framework, please cite:

@incollection{helff2025slrautomatedsynthesisscalable,
      title={SLR: Automated Synthesis for Scalable Logical Reasoning}, 
      author={Lukas Helff and Ahmad Omar and Felix Friedrich and Antonia Wüst and Hikaru Shindo and Rupert Mitchell and Tim Woydt and Patrick Schramowski and Wolfgang Stammer and Kristian Kersting},
      year={2025},
      booktitle ={Working Notes of the NeurIPS Workshop on Foundations of Reasoning in Language Models},
      url={https://arxiv.org/abs/2506.15787}, 
}