README.md

---
license: cc-by-4.0
language:
  - en
tags:
  - Large Language Models
  - LLM Evaluation
  - Sequential Reasoning
  - Scaling Laws
  - Synthetic Benchmarks
  - Commonsense Reasoning
  - Spatial Reasoning
  - Knowledge Graphs
---

# 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}
}
```