r-horizon-long-horizon-reasoning

name	r-horizon-long-horizon-reasoning
title	R-Horizon: How Far Can Your Large Reasoning Model Really Go in Breadth and Depth?
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2510.08189
keywords	["reasoning","benchmark","long-horizon","query-composition","large-reasoning-models"]
description	Construct multi-step reasoning benchmarks with interdependent problems to evaluate and improve long-horizon reasoning in large reasoning models. Enables evaluation of reasoning depth and breadth beyond single-step tasks.

R-Horizon: Evaluating and Improving Long-Horizon Reasoning

Large reasoning models show surprising limitations in extended reasoning chains. Current benchmarks focus on single-horizon tasks, missing critical evaluation of how well models handle multi-step interdependent problems or allocate thinking across multiple sub-tasks.

R-Horizon addresses this by constructing reasoning tasks where multiple problems depend on each other, creating true long-horizon reasoning scenarios. This reveals whether models can sustain reasoning quality across deep chains or whether they degrade as reasoning depth increases.

Core Concept

The framework constructs multi-step reasoning problems through query composition: building dependent sub-problems where solutions to earlier steps inform later steps. This naturally extends single-horizon reasoning benchmarks into long-horizon evaluation suites.

Key insight: models need to not only reason deeply but allocate their reasoning budget efficiently across multiple interconnected sub-problems.

Architecture Overview

• Query Composition Engine: Takes base reasoning problems and creates dependency chains
• Controlled Depth Variation: Generate problems at varying reasoning depths to test breadth and depth separately
• Reward Integration: Connects with Reinforcement Learning with Verified Rewards (RLVR) for both evaluation and training
• Benchmark Reusability: Creates persistent evaluation benchmarks across multiple reasoning models

Implementation Steps

The core workflow involves three stages: problem generation, composition, and evaluation.

Stage 1: Base Problem Selection

Start with high-quality reasoning problems. For mathematical reasoning, extract problems from benchmarks like AIME or Math competition datasets:

# Load base reasoning problems
base_problems = load_benchmark_problems(
    source='aime_2024',
    difficulty='high'
)

# Filter for composability
composable = [
    p for p in base_problems
    if can_create_dependency(p)
]

Stage 2: Dependency Graph Construction

Create chains where problem N+1 depends on solution to problem N. Build a dependency graph that represents the reasoning structure:

def ():
    
    chain = []
     i  (chain_length):
        base = problems[i]
         i == :
            chain.append(base)
        :
            
            dependent = inject_dependency(base, chain[i-])
            chain.append(dependent)
     chain


depth_3_chains = create_composition_chain(problems, chain_length=)
depth_5_chains = create_composition_chain(problems, chain_length=)
depth_8_chains = create_composition_chain(problems, chain_length=)