Update README.md

README.md

@@ -1,3 +1,165 @@
----
-license: cc-by-4.0
----
+---
+license: cc-by-4.0
+language:
+  - en
+tags:
+  - Large Language Models
+  - Sequential Reasoning
+  - Knowledge Graphs
+  - Scaling Laws
+  - Synthetic Benchmarks
+  - Commonsense Reasoning
+  - Spatial Reasoning
+  - Pathfinding
+  - Logical Depth
+  - Backtracking
+  - Noise Robustness
+  - LLM Evaluation
+---
+
+# SeqBench: A Tunable Benchmark to Quantify Sequential Reasoning Limits of LLMs
+
+## Description
+
+SeqBench is a programmatically generated benchmark designed to rigorously evaluate and analyze the sequential reasoning capabilities of language models. Task instances involve pathfinding in 2D grid environments, requiring models to perform multi-step inference over a combination of relevant and distracting textual facts.
+
+The benchmark allows for fine-grained, orthogonal control over key complexity dimensions:
+
+1.  **Logical Depth (L)**: The number of actions in the ground-truth optimal solution.
+2.  **Backtracking Count (B)**: The number of locked doors on the optimal path that necessitate detours to find corresponding keys.
+3.  **Noise Ratio (N)**: The proportion of distracting (irrelevant) facts relative to supporting (relevant) facts in the problem description.
+
+This dataset (`seqBench_compact.jsonl.gz`) contains **7079 instances**, sampled to provide broad coverage across these complexity dimensions.
+
+Each instance provides:
+-   `instance_id`: A unique identifier for the specific problem variant.
+-   `context`: The natural language problem description presented to the model.
+-   `completion`: The ground-truth sequence of actions representing the optimal solution.
+-   `complexity_parameters`: A dictionary containing the specific L, B, and N values for the instance.
+-   `instance_metadata`: Additional information, including maze dimensions and agent/target names.
+-   `structural_details`: A JSON string detailing the underlying base maze configuration. This includes room coordinate mappings, adjacency lists, door/key states, and all canonical facts (before noise application).
+
+## Dataset Structure and Schema
+
+The dataset is provided in gzipped JSONL format (`seqBench_compact.jsonl.gz`). Each line is a JSON object representing a single problem instance with the following fields:
+
+*   **`instance_id`** (`string`): Unique identifier for the problem instance.
+*   **`context`** (`string`): Textual problem description.
+*   **`completion`** (`string`): Expected sequence of actions (e.g., ` "['action1: param1', 'action2: param2', ...]" `).
+*   **`complexity_parameters`** (`object`):
+    *   `logical_depth_L` (`int64`): Logical Depth (L).
+    *   `backtracking_count_B` (`int64`): Backtracking Count (B).
+    *   `noise_ratio_N` (`float64`): Applied Noise Ratio (N).
+*   **`instance_metadata`** (`object`):
+    *   `maze_rows` (`int64`): Number of rows in the maze grid.
+    *   `maze_cols` (`int64`): Number of columns in the maze grid.
+    *   `agent_name` (`string`): Agent's name.
+    *   `target_name` (`string`): Target/victim's name.
+*   **`structural_details`** (`string`): A JSON string containing:
+    *   `mappings` (`object`):
+        *   `coordinate_to_name` (`object`): Maps coordinate strings (e.g., "3,6") to original room identifiers (e.g., "D5").
+    *   `structure` (`object`):
+        *   `adjacency_list` (`object`): Maps coordinate strings to a list of directly connected coordinate strings.
+        *   `door_details` (`object`): Maps a door identifier string (lexicographically sorted coordinate strings joined by "_", e.g., "3,6_3,7") to an object: `{"status": "open" | "closed and locked", "key_id": "string"}`.
+        *   `key_locations` (`object`): Maps a `key_id` string to the coordinate string of the room containing the key.
+        *   `start_room_coord` (`string`): Coordinate string of the agent's starting room.
+        *   `end_room_coord` (`string`): Coordinate string of the victim's room.
+    *   `canonical_facts` (`list`): A list of objects, where each object represents a true factual statement about the base maze (before noise/shuffling). Each fact object has: `{"type": "string", "args": list_of_strings, "supporting": boolean}`. The `args` are specific to the `type` (e.g., for "connected_rooms", args might be `["coord1_str", "coord2_str", "status_str"]`).
+
+A machine-readable metadata file (`croissant.json`) is included in the metadata/ directory of the main repository to facilitate dataset discovery and integration.
+
+## Using `structural_details`
+
+The `structural_details` field offers a ground-truth representation of the maze.
+
+```python
+import gzip
+import json
+
+# Example: Load the first instance and inspect its structural_details
+file_path = "seqBench_compact.jsonl.gz" # Path to your dataset file
+instance_data = None
+try:
+    with gzip.open(file_path, "rt", encoding="utf-8") as f:
+        first_line = f.readline()
+        if first_line:
+            instance_data = json.loads(first_line)
+except FileNotFoundError:
+    print(f"Error: Dataset file not found at {file_path}")
+except Exception as e:
+    print(f"Error loading dataset: {e}")
+
+if instance_data:
+    print(f"Instance ID: {instance_data.get('instance_id', 'N/A')}")
+    
+    # Parse the structural_details string
+    structural_details_str = instance_data.get("structural_details")
+    if structural_details_str:
+        structural_details = json.loads(structural_details_str)
+        
+        structure = structural_details.get("structure", {})
+        start_coord_str = structure.get("start_room_coord")
+        print(f"Start Room Coordinate String: {start_coord_str}")
+        
+        # Example: Door details for a hypothetical door
+        # Note: Door keys are formed by sorting coordinate strings and joining with '_'
+        coord1_str, coord2_str = "3,6", "3,7" # Replace with actual coordinates you want to check
+        door_dict_key = "_".join(sorted([coord1_str, coord2_str]))
+        door_info = structure.get("door_details", {}).get(door_dict_key)
+        if door_info:
+            print(f"Door info for {door_dict_key}: {door_info}")
+        else:
+            print(f"No direct door entry for {door_dict_key} (may not exist or names are different).")
+        
+        print(f"Key locations: {structure.get('key_locations', {})}")
+        
+        # print("First canonical fact:", structural_details.get("canonical_facts", [{}])[0])
+    else:
+        print("structural_details field is missing or empty.")
+
+# For a deeper understanding of the data generation pipeline and semantics, 
+# refer to the scripts (`maze.py`, `maze_loader.py`, `rooms.py`)
+# available in the main project repository.
+```
+
+## Dataset Statistics (for `seqBench_compact.jsonl.gz`)
+
+*   **Total Instances:** 7079
+*   **Logical Depth (L):**
+    *   Range: [3, 774]
+    *   Distribution: Instances span a wide range of L values. For L-bins of size 5 (e.g., L0-4, L5-9, etc.), there are typically 30-80 instances per bin in the lower to mid L-ranges.
+*   **Backtracking Count (B):**
+    *   Range: [0, 6]
+    *   Distribution:
+        *   B = 0: 441 instances
+        *   B = 1: 438 instances
+        *   B = 2: 565 instances
+        *   B = 3: 790 instances
+        *   B = 4: 1046 instances
+        *   B = 5: 1601 instances
+        *   B = 6: 2198 instances
+*   **Noise Ratio (N):**
+    *   Range: [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
+    *   Distribution: Instances are approximately evenly distributed across the 6 noise levels, each with roughly 1180 instances.
+*   **Combined Complexity:** The dataset is sampled to ensure coverage across (B, N) combinations (typically 60-380 instances per pair) and (L-bin, N) combinations (aiming for approximately 10 instances per L-bin of size 5 for each N, varying with the natural distribution of L).
+
+## Generation Process
+
+The benchmark instances are generated through a multi-stage process:
+1.  **Base Maze Generation**: Acyclic maze graphs are programmatically created on N x M grids.
+2.  **Rewind Construction**: A target number of backtracking maneuvers (B_target) are embedded by working backward from a goal room, strategically placing keys and locked doors.
+3.  **NLP Formulation**: For each base maze configuration, a list of canonical facts describing the environment and task is derived.
+4.  **Noise Application**: A specified `noise_ratio_N` is used to select a proportion of distracting (irrelevant) facts to include alongside supporting (relevant) facts, forming the final `context`.
+
+## Citation
+Please cite this work as:
+```bibtex
+@misc{anonymous2025seqbench,
+  author    = {Anonymous Submission},
+  title     = {SeqBench: A Tunable Benchmark to Quantify Sequential Reasoning Limits of LLMs},
+  year      = {2025},
+  publisher = {Proceedings of the Conference on Empirical Methods in Natural Language Processing},
+  note = {Special Theme: Interdisciplinary Recontextualization of NLP},
+  comment   = {Dataset accessible at https://huggingface.co/datasets/emnlp-submission/seqBench}
+}
+```