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