Update README.md

README.md

@@ -33,3 +33,206 @@ configs:
   - split: test
     path: data/test-*
 ---
+## Dataset Description
+- **Language(s) (NLP):** English
+- **Point of Contact:** [Ahmad Omar](mailto:ahmad.omar@example.com)
+- **License:** [CC BY](https://creativecommons.org/licenses/by/4.0/)
+
+# House-Classification-Benchmark: An Example Benchmark Created with SLR
+
+[![GitHub](https://img.shields.io/badge/Code-GitHub-blue)](https://github.com/ml-research/ScalableLogicalReasoning)
+[![arXiv](https://img.shields.io/badge/arXiv-2506.15787-b31b1b.svg)](https://arxiv.org/abs/2506.15787)
+[![Original SLR-Bench](https://img.shields.io/badge/SLR--Bench-Original-orange)](https://huggingface.co/datasets/AIML-TUDA/SLR-Bench)
+
+> **Demonstrate the flexibility of SLR:** This benchmark showcases how the [SLR framework](https://github.com/ml-research/ScalableLogicalReasoning) can be used to create custom logical reasoning benchmarks beyond the train classification domain.
+
+**House-Classification-Benchmark** is an example benchmark demonstrating the capabilities of the SLR (Scalable Logical Reasoning) framework to generate domain-specific inductive logic programming tasks. Instead of classifying trains (as in the original SLR-Bench), this benchmark focuses on classifying houses as **modern** or **traditional** based on their room composition and attributes such as wall color, roof type, garden type, garage type, window type, and number of windows.
+
+## About SLR
+
+The [SLR framework](https://github.com/ml-research/ScalableLogicalReasoning) enables automatic generation of logical reasoning tasks with controllable complexity, making it easy to:
+- 🔨 **Generate custom reasoning tasks** in any domain with your own predicates and constants
+- 🧩 **Control task difficulty** through systematic complexity scaling
+- 🧠 **Evaluate LLMs symbolically** using deterministic validation programs
+- 📈 **Build curriculum learning benchmarks** tailored to your specific domain
+
+This House-Classification-Benchmark serves as a practical example of how to use SLR for creating domain-specific benchmarks.
+
+---
+
+## Benchmark Overview
+
+- **Domain:** House classification (modern vs. traditional)
+- **Structure:** Houses composed of multiple Rooms with various attributes
+- **Curriculum:** 10 complexity levels (level 1-10)
+- **Tasks per level:** 50 test instances
+- **Total tasks:** 500 instances
+- **Predicates:** 7 room attributes (wall_color, roof_type, garden, garage, window type, window count, room number)
+- **Application:** Evaluate LLMs on house classification logical reasoning tasks
+
+---
+
+## Benchmark Structure
+
+### Levels 1-10
+The benchmark progressively increases in complexity across 10 levels:
+
+- **Level 1:** Simple rules with minimal predicates, small problem sizes (few rooms per house)
+- **Levels 2-4:** Gradual increase in rule complexity and number of rooms per house
+- **Levels 5-7:** Introduction of more complex logical combinations across multiple room attributes
+- **Levels 8-10:** Advanced reasoning with longer rules, more rooms, and larger problem sizes
+
+Each level systematically varies:
+- **Rule length:** Number of predicates in the ground-truth rule
+- **Problem size:** Number of positive and negative house examples
+- **Room complexity:** Number of rooms per house and their attribute diversity
+- **Background sampling:** Distribution strategy for room attributes
+
+---
+
+## Quick Start
+
+### Loading the Dataset
+```python
+from datasets import load_dataset
+
+# Load a specific level (e.g., level 1)
+ds = load_dataset("ahmad21omar/House-Classification-Benchmark")
+
+# Access the test split
+test_data = ds["test"]
+
+```
+
+### Evaluate using SLR's Symbolic Judge
+Requires the [`evaluate`](https://huggingface.co/docs/evaluate/) library and a Prolog interpreter (e.g., [SWI-Prolog](https://www.swi-prolog.org/)).
+
+```bash
+pip install evaluate
+sudo apt-get install swi-prolog
+```
+
+#### Example Usage
+
+```python
+from evaluate import load
+
+# Load the symbolic judge
+symbolic_judge = load("AIML-TUDA/VerifiableRewardsForScalableLogicalReasoning")
+
+# Example: evaluate ground-truth rules (replace with model predictions)
+rules = test_data["ground-truth rule"]  # Your model's predicted rules
+references = [
+    {
+        "validation_program": p,
+        "evaluation_config": {
+            "positive_predicate": "modern",
+            "negative_predicate": "traditional"
+        }
+    } for p in test_data["validation program"]
+]
+
+results = symbolic_judge.compute(predictions=rules, references=references)
+print(f"Accuracy: {results['accuracy']:.2%}")
+```
+
+## House Domain Predicates
+
+The benchmark uses the following predicates to describe houses and their rooms:
+
+- **has_room(House, Room):** Specifies that Room is part of the House. Room identifiers: room0_1, room0_2, room1_1, room1_2, etc.
+- **room_num(Room, Room_number):** Position/number of the room within the house. Values: 1, 2, 3, ...
+- **has_wall_color(Room, Color):** Wall color of the room. Values: 'red', 'blue', 'green', 'yellow', 'white'
+- **has_roof_type(Room, Roof_type):** Type of roof. Values: 'flat', 'gabled', 'hipped', 'none'
+- **has_garden(Room, Garden_type):** Garden type associated with the room. Values: 'flower', 'vegetable', 'herb', 'none'
+- **has_garage(Room, Garage_type):** Garage type. Values: 'attached', 'detached', 'none'
+- **has_window(Room, Window_type):** Window type. Values: 'bay', 'casement', 'sliding', 'none'
+- **window_num(Room, Number_of_windows):** Number of windows in the room. Values: 0, 1, 2, 3, 4
+
+---
+
+## Example Task
+
+### Prompt:
+```
+You are a classifier for a logical reasoning task. Each House is composed of one or more Rooms, 
+and each Room is characterized by a set of properties, represented as ground atoms over a fixed 
+set of predicates. The label (modern or traditional) of a House is to be determined from its composition.
+
+To describe the Houses we define a set of predicates and grounding domains:
+- 'has_room(House, Room)': Room can be room0_1, room0_2, room1_1, room1_2.
+- 'room_num(Room, Room_number)': Room_number can be 1, 2.
+- 'has_wall_color(Room, Color)': Color can be red, blue, green, yellow, white.
+- 'has_roof_type(Room, Roof_type)': Roof_type can be flat, gabled, hipped, none.
+- 'has_garden(Room, Garden_type)': Garden_type can be flower, vegetable, herb, none.
+- 'has_garage(Room, Garage_type)': Garage_type can be attached, detached, none.
+- 'has_window(Room, Window_type)': Window_type can be bay, casement, sliding, none.
+- 'window_num(Room, Number_of_windows)': Number_of_windows can be 0, 1, 2, 3, 4.
+
+You are provided with positive and negative examples in the form of modern(t) or traditional(t) 
+for each House t, together with background knowledge consisting of ground facts over the above 
+predicates which describe its composition.
+
+modern(house0).
+has_room(house0, room0_1).
+room_num(room0_1, 1).
+has_wall_color(room0_1, blue).
+has_roof_type(room0_1, gabled).
+has_garden(room0_1, flower).
+has_garage(room0_1, none).
+has_window(room0_1, bay).
+window_num(room0_1, 3).
+
+traditional(house1).
+has_room(house1, room1_1).
+room_num(room1_1, 1).
+has_wall_color(room1_1, red).
+has_roof_type(room1_1, flat).
+has_garden(room1_1, none).
+has_garage(room1_1, detached).
+has_window(room1_1, casement).
+window_num(room1_1, 2).
+
+Your task: Formulate a hypothesis as a Prolog rule 'modern(House) :- Body.' 
+that correctly separates modern from traditional houses.
+```
+
+### Solution Example:
+```prolog
+modern(House) :- has_room(House, Room), has_garden(Room, flower).
+```
+
+---
+
+## Creating Your Own Benchmark with SLR
+
+This benchmark was generated using the [SLR framework](https://github.com/ml-research/ScalableLogicalReasoning). You can create your own domain-specific benchmarks by:
+
+1. **Define your domain vocabulary:** Specify predicates and constants relevant to your task (e.g., houses, rooms, attributes)
+2. **Configure complexity levels:** Set parameters for rule length, problem size, and sampling strategies
+3. **Generate tasks:** Use SLR's automatic generation pipeline
+4. **Evaluate models:** Apply the symbolic judge for deterministic evaluation
+
+Visit the [SLR GitHub repository](https://github.com/ml-research/ScalableLogicalReasoning) for detailed instructions and code examples.
+
+
+## Citation
+
+If you use this benchmark, please cite the original SLR framework:
+
+```bibtex
+@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}, 
+}
+```
+
+---
+
+## Acknowledgements
+
+This benchmark was created using the [SLR framework](https://github.com/ml-research/ScalableLogicalReasoning) developed by the AIML Lab at TU Darmstadt. Special thanks to Lukas Helff for the original SLR-Bench inspiration.
+