1 Introduction↩︎

Spatial reasoning is becoming increasingly important across many research domains, including autonomous driving, navigation, and robotics [1]–[3]. However, LLMs still exhibit significant limitations in spatial reasoning, especially as spatial context becomes more complex [4]. Such tasks require models to compose multiple relations while maintaining a consistent understanding of where entities are located relative to one another. In multi-hop settings, these relations become harder to track, leading to accumulated errors and inconsistent spatial interpretations [5], [6]. Even strong LLMs struggle on benchmarks like StepGame [5], SpartQA [7], and ReSQ [8] without specialized prompting or step-by-step reasoning traces [9]–[11]. However, these methods still rely largely on natural language reasoning, forcing models to infer geometry and layout implicitly from text.

This contrasts with human reasoning. For complex spatial descriptions, people often use sketches, diagrams, or grids to externalize the scene into a simplified structure rather than reasoning in words alone [12], [13]. This reflects the idea of schematization, which makes spatial structure easier to perceive and reason over [14]. Similarly, Figure 1 shows that natural language-based LLM reasoning must track relations implicitly across multiple steps, which can cause hallucinated relations or multi-hop errors [10], while a grid makes the structure explicit. This motivates a central question, that is, can explicit spatial representations serve as a more effective reasoning medium for language models rather than natural language alone?

To investigate this, we compare reasoning directly from natural language stories against different reasoning modalities. Here, modality refers to the text-based representation of a spatial story used for inference. These alternatives explicitly encode the scene’s spatial structure, including extracted relational triples and layout-based forms. ¹ As illustrated in the example in Figure 1, explicit structure (e.g., grid-based layouts) can offer a more effective medium for multi-hop spatial reasoning than text alone. Based on this intuition, we propose a grid-grounding framework that converts spatial stories into explicit 2D grids by encoding spatial relations between entities. The resulting grids are then fed back to the language model for multi-hop spatial question answering.

However, reasoning with structured representations is not always necessary; in some cases, natural language-based reasoning can be sufficient depending on model ability and problem complexity. To address these challenges, we introduce a switching metric that estimates when a model should rely on natural language and when it should use structured spatial representations. The metric combines trustworthiness and complexity signals from each instance to enable principled modality selection rather than reasoning with a fixed modality.

Across multiple spatial reasoning benchmarks, our framework improves accuracy by large margins: up to 42% on StepGame [15], 8% on SpaRTUN [8], and 5% on ReSQ [8]. These results highlight the importance of treating visualization and structured symbolic representations not just as outputs but as a reasoning medium.

In summary, our contributions are: (1) We investigate whether changing the reasoning modality from natural language to explicit spatial structure improves multi-hop spatial reasoning. We also introduce a grid-based grounding framework that converts spatial stories into structured 2D layouts for reasoning. (2) We propose an adaptive switching framework that uses trustworthiness and complexity signals to decide when a model should reason with natural language and when it should switch to a structured representation, taking a step toward principled modality selection in LLM’s reasoning.

2 Related Work↩︎

Recent studies show that language models struggle with multi-hop spatial reasoning across benchmarks such as StepGame [5], [15], SpartQA [7], SpaRTUN [8], ReSQ [8], and SpaRP [10]. Even strong models such as GPT-4 remain brittle in spatial inference, often making elementary reasoning errors and failing to compose spatial relations reliably [10], [16], [17].

Prior work has addressed these failures through two broad directions. One line of work incorporates external symbolic or structured reasoning components to support spatial reasoning, such as combining LLM-based relation extraction with Answer Set Programming [18]–[20] or Prolog [9], enforcing logical constraints during fine-tuning [6], or using graph neural networks to model multi-step spatial dependencies [21], [22]. These methods often require additional training or external solvers to improve spatial reasoning. In contrast, we study how the representation provided to the language model itself affects spatial reasoning at inference time.

A closer line of work studies whether spatial reasoning improves when intermediate reasoning is represented differently. Tree-of-Thought prompting explores multiple reasoning paths for multi-hop spatial inference [15], while Chain-of-Symbol [23] and coordinate-based formulations [24] show that symbolic or quantitative representations can improve spatial reasoning. Our work aligns with this direction but compares multiple reasoning representations, including natural language, relational triples and coordinate layouts, and introduces grid grounding as a geometry-preserving representation for LLM reasoning.

Finally, to use computationally intensive reasoning strategies more efficiently, recent work has explored adaptive inference approaches that allocate additional reasoning only when needed. Methods such as DOTS [25], Route-to-Reason [26], AdaptThink [27], Thinkless [28], AdaCoT [29], and RouteLLM [30] select reasoning depth or route across models based on task difficulty, confidence, or expected utility. CodeSteer [31] similarly guides LLMs between text and code generation for symbolic tasks. These works provide an important precedent for adaptive inference but primarily frame switching as routing between models, reasoning depths, or generation modes. In contrast, our work studies training-free switching at the level of spatial representation, using trustworthiness and complexity signals to decide when to reason in natural language and when to switch to an explicit geometry-preserving representation such as a grid.

3 Methodology↩︎

3.0.0.1 Problem Definition:

We consider a spatial question answering task where, given a spatial narrative (\(S\)) and a question (\(Q\)), the model answers the question by inferring the spatial relations between two or more entities. The answer can be either in Yes/No form or as a multi-class label from a fixed set of spatial relations, such as left and above. This is a challenging problem because relations between entities can be implicit, and the model often needs to reason across multiple relations to infer the correct answer.

To address this problem, we hypothesize that, depending on the context, some modalities can simplify reasoning more effectively than natural language. Figure 1 illustrates this with a multi-hop story where inferring the relation between \(G\) and \(N\) requires tracking several intermediate entities in text and can be complex, while the grid makes the relevant relation more clear. Therefore, we design a framework to analyze the input and model output and switch between text and structured modalities when needed. The overall pipeline is shown in Figure 3. It has two main components: (i) assessing problem complexity and model trustworthiness, and (ii) converting the narrative into alternative reasoning modalities. The assessment module identifies cases where natural language-based reasoning is unreliable or the narrative is too complex and triggers a switch to a structured modality.

Building upon this pipeline, we examine relational triples, coordinate-based layouts, and grids as alternative representations for reasoning and study how switching from natural language-based reasoning to a suitable structured modality affects model performance. We next describe the reasoning modalities and switching policy.

3.1 Mapping to Multiple Reasoning Modalities↩︎

We transform each spatial narrative and question into multiple reasoning modalities, including qualitative and quantitative spatial representations. Qualitative representations capture symbolic relations, such as relative direction or containment, while quantitative representations make spatial arrangements explicit through coordinate-based layouts. Grid-based representations lie between these two by organizing entities in a discrete row-column layout. Each modality is then used independently for reasoning. Figure 2 illustrates the modalities considered in our framework, discussed as follows.

1. Original Text: This is the baseline where the model reasons directly over the original story, question, and answer options in natural language form.

2. Relational Triples: For this modality, we use few-shot in-context learning to extract pairwise spatial relations from the story as triples of the form {head, relation, tail}. This process converts the narrative into a qualitative spatial representation, especially when a sentence contains multiple relations or requires coreference resolution. For example, from "a medium purple object is inside and touching block H," we extract {head: medium purple object, relation: tangential-proper-part, tail: block H}. These triples include directional relations, such as left, right, above and below, as well as topological relations such as disconnected, externally connected, partially overlapping, equal, tangential proper part, non-tangential proper part, tangential proper part inverse, non-tangential proper part inverse, when needed [32]. As shown in Figure 2 (i), the model receives the relational triples with the question and infers the final answer.

3. Grids: For this modality, we map extracted spatial relations into a two-dimensional grid that assigns relative positions to entities while satisfying directional and topological constraints. Topological relations are encoded with compact tags, such as #dc for disconnected. We generate the grid using a Python program with predefined relation templates that translate extracted relation triples into grid placements. The resulting full grid serves as a symbolic textual representation of the complete scene. We also construct the pruned grid, which retains only question-relevant entities identified by the model based on story and question, reducing noisy context and isolating the relations needed for the answer. Figure 2 (ii-iii) shows both grid settings. We provide the model with either the full grid or the pruned grid, containing only question-relevant entities such as \(N\) and \(G\), together with the question for reasoning.

4. Coordinate-based Layout: This is a quantitative representation where we give the extracted spatial relations between entities as input to Prolog [33]. Prolog provides a numerical solution that obeys the constraints of the problem, yielding a coordinate assignment for all entities. For example, if \(x_E\) and \(y_E\) denote the horizontal and vertical coordinates of an entity \(E\), then as shown in Figure 2 (iv), right(G,S) is encoded as \(x_G = x_S + 1,\; y_G = y_S\), placing \(G\) one unit to the right of \(S\). Solving all constraints yields a relative coordinate layout, such as (S, 1, 0) and (G, 2, 0). The generated coordinates and question are then fed into the model to perform coordinate-based reasoning.

3.2 Switching Between Modalities↩︎

Natural language-based reasoning can be effective for some spatial narratives, but its reliability depends on the model’s spatial reasoning ability and the instance complexity [10], [16]. As shown in Figure 3, complex stories may require composing several relations across intermediate entities to infer the relation between \(G\) and \(N\). Natural language-based reasoning must track these relations implicitly, while an effective structured representation, such as a grid, makes them explicit and supports more direct and potentially less error-prone inference.

Based on this, we guide modality choice using two factors: trustworthiness, which reflects the reliability of the model’s natural language-based spatial reasoning, and complexity, which captures the difficulty of the spatial problem. Following [34], [35], we decompose trustworthiness into faithfulness and plausibility, which we adapt to spatial reasoning as described next.

3.2.1 Faithfulness↩︎

Faithfulness, denoted as \(F\), measures whether the model’s answer is based on the supporting sentences it identifies from the spatial narrative and whether its reasoning is consistent with those sentences. For example, in the narrative "Y is positioned below L and to the right; D is upper right of L", a question about the relation of \(Y\) to \(L\) should rely only on the first sentence. If the model uses irrelevant evidence or derives an unsupported relation, its reasoning is not faithful. To compute \(F\), we ask the model to provide supporting sentences along with its answer and evaluate them using two checks:

(i) Sufficiency tests whether the supporting sentences alone recover the original answer. We provide only the supporting sentences to the model and score 1 if the answer matches and 0 otherwise.

(ii) Necessity tests whether the stated supporting sentences are absolutely required to derive the answer. We remove them from the story and score 1 if the model responds with “don’t know,” and 0 otherwise.

\(F\) is the average of sufficiency and necessity. An \(F\) score of 1.0 indicates that the model consistently relies on the cited supporting sentences to produce its answer, reflecting faithful reasoning rather than arbitrary guessing.

3.2.2 Plausibility↩︎

Plausibility, denoted as \(P\), measures whether the model’s supporting sentences yield a logically consistent and stable interpretation under benign transformations. We decompose it into two factors: paraphrase stability and flip consistency.

(i) Paraphrase Stability (\(PS\)) measures whether the model preserves the same underlying spatial logic under lexical variability and linguistic difficulty. Similar to \(F\), we use the supporting sentences generated by the model and create three variants using an LLM (GPT-5-mini [36]): (a) linguistically similar, which paraphrases the sentence while retaining the original type of spatial expression, such as a clock-face direction (e.g., the supporting sentence "T is above I at 2 o’clock" becomes "T is at the center and I is at the 2 o’clock position"); (b) Canonical, which rewrites relations into simplified qualitative relations from our predefined relation set (e.g., "T upper-right position to I"); and (c) hinted, which adds a hint to ease interpretation (e.g., hint: recognize the clockwise position here, 2 o’clock is usually upper-right from the center). We run the model on these variants and compute \(PS\) the frequency of the most common answer among the three responses. This score lies in \([0,1]\), where higher values indicate more stable reasoning across paraphrased forms.

(ii) Flip Consistency (\(FC\)) tests whether the model applies inverse spatial reasoning consistently with its original answer. Using an LLM, we generate a flipped question from the supporting sentences by reversing entity order for relation questions or negating the relation for yes/no questions. We compare the flipped answer with the expected inverse of the original response. \(FC\) is 1 for a correct inverse, 0.5 for a partially correct answer in cases when the expected answer is multi-label, and 0 otherwise. Details are provided in Appendix 8.

\(P\) is computed as the average of paraphrase stability and flip-consistency. A \(P\) score of 1.0 indicates that the model’s response remains stable under paraphrases and logically consistent under equivalent inversions.

3.2.3 Complexity↩︎

Complexity, denoted as \(C\), measures the difficulty of a given spatial reasoning instance. We quantify this difficulty for each spatial reasoning instance using a weighted combination of seven factors that capture the linguistic and multi-hop reasoning demands of the problem. Given the story, support sentences, and question, we use an LLM (GPT-5-mini [36]) to evaluate support sentences, identify entities, flag hard language patterns, and estimate coreference-based difficulty where applicable. Based on these, we derive seven complementary factors. (i) Support Burden (\(SB\)) measures the number of supporting sentences derived by the model required for reasoning. (ii) Chain Length (\(CL\)) captures the actual multi-hop depth of the instance independent of the current model. This anchors complexity to the actual problem size. (iii) Selection Difficulty (\(SD\)) measures the fraction of story sentences that are not part of the supporting sentences, capturing the difficulty of filtering irrelevant context faced by the model. (iv) Hard Language (\(HL\)) captures the difficulty of linguistically complex spatial expressions, such as clock-face directions, directional phrases, nested relations, and coreference-dependent mentions. The LLM first identifies such expressions and assigns each one a difficulty score \(d_i \in [0,1]\). Then we compute \[HL = 0.6 \cdot \max_i d_i + 0.4 \cdot \frac{1}{n}\sum_{i=1}^{n} d_i .\] This weighting emphasizes the hardest expression, capturing the risk of one difficult phrase affecting the reasoning chain, while the average term accounts for overall linguistic difficulty. (v) Diagonal Burden (\(DB\)) measures the fraction of extracted relations that are diagonal, i.e., composed of two simultaneous axis-aligned directions like lower-left. (vi) Entity Load (EL) captures the burden of tracking multiple distinct entities. (vii) Coreference Difficulty (\(CF\)) estimates the burden of resolving entity references that require multi-step relational interpretation. Since no instance-level complexity score is available, we estimate complexity using proxy signals. For count-based factors such as Support Burden, Chain Length, and Entity Load, we use the saturating function \(\mathrm{sat}(x,c)=\frac{x}{x+c}\) to map raw counts to ([0,1]). This normalization is needed because these factors are raw counts whose scale varies across datasets, and their difficulty contribution should increase sharply at lower values but saturate once the instance is already highly challenging. Here, \(c\) is a dataset-specific reference value set to the median of the corresponding feature so that moderate counts receive intermediate scores, while larger counts approach 1 without increasing linearly. These components are further combined into a normalized scalar \(C \in [0,1]\), with dataset-specific weights reported in Appendix 8.

Decision rule. The aim of the switching policy is to avoid structured reasoning when the instance is simple and the model’s natural language-based answer is reliable. Reliability is measured using trustworthiness \(T = 0.6F + 0.4P\), where \(F\) denotes faithfulness and \(P\) denotes plausibility. The policy keeps natural language-based reasoning when complexity is low \((C < \tau_c)\) and trustworthiness is high \((T > \tau_t)\); otherwise, it switches to grid-based reasoning. The thresholds \(\tau_c\) for complexity and \(\tau_t\) for trustworthiness are tuned on the validation set for each dataset and model, with details in Appendix 8. For efficiency, we use short-circuit computation to avoid estimating signals that do not directly trigger the switching decision. More details are provided in Appendix 8.1.

4 Experimental Results↩︎

Datasets: We evaluate on three textual spatial reasoning benchmarks. SpaRTUN includes synthetic spatial narratives with Yes/No (YN) and Find Relations (FR) questions [8]. StepGame tests controlled multi-hop FR reasoning with increasing relational depth and distractors [15]. ReSQ contains YN questions over human-written real-world spatial descriptions [8]. Table 1 summarizes the statistics of the datasets. Due to cost, we evaluate randomly sampled subsets with a fixed seed of 0, preserving the original test-set distribution.

Evaluation Metrics: We report exact-match accuracy for all datasets. For multi-label FR questions, a prediction is correct only if it matches the complete ground-truth relation set [8]. We report accuracy per hop-depth for StepGame. We evaluate across different model families, including LLaMA 3.1 [37], Qwen3 [38], and GPT-5.1 [39].

5pt

4.1 Results and Discussion↩︎

RQ1. Can mapping to grids simplify multi-hop reasoning and improve performance?

Table 2 demonstrates the results on StepGame. We observe that the grid-based representations yield the strongest overall performance, especially at higher hops, where text-only reasoning declines sharply. LLaMA3.1-70B benefits most from pruned grids, suggesting that reducing irrelevant spatial context helps non-reasoning models. Representations requiring more numerical manipulation, such as coordinate layouts, are more effective for stronger models such as Qwen3-32B and GPT-5.1 [38], [39]. Appendix 9 further shows that this pattern holds for small language models, where grid-based representations improve overall accuracy by up to 25%.

Table 3 further demonstrates that structured spatial representations improve reasoning on SpaRTUN, especially for Find Relations (FR) questions, where models must recover multiple object relations. Pruned grids also perform well on Yes/No (YN) questions, often achieving the best or second-best accuracy for each model. Reasoning models such as Qwen3-32B benefit substantially from grid-based reasoning, improving overall accuracy by up to 8%, due to more accurate relation extraction during grid construction. For GPT-5.1, text-only reasoning is strong, but pruned grids still improve performance by focusing on the most relevant spatial objects. Finally, Chain of Symbol (CoS) is also competitive with grid-based reasoning in several settings, suggesting that symbolic intermediate forms can help when questions require tracking multiple relations. Appendix 9 shows that for smaller models, grid-based reasoning remains competitive with text-based reasoning on SpaRTUN. We also analyze representation quality and grid construction behavior in Appendix 11.

1.6pt

We evaluate ReSQ to test generalizability on realistic spatial descriptions and report results in Table 3. Here, grids are constructed directly from extracted relations using LLMs. GPT-based construction performs best, while same-model construction remains competitive with the baselines, showing that open-source models can be used for grid construction with minimal accuracy loss. Since ReSQ contains only up to two hops of reasoning, the accuracy gains are smaller than those on StepGame. However, grid-based representations consistently outperform the baselines by up to 5%. Appendix 9 shows similar gains with grid-based reasoning on ReSQ for small language models. Overall, grids help most when reasoning requires composing many relations, while pruning reduces noisy context. Text-only reasoning often fails on multi-step composition, while grid-based reasoning can fail due to relation extraction or grid construction errors. Because the two modalities fail for different reasons, switching between them can be useful. We analyze relation extraction, grid construction, modality disagreement, and error types in Appendices 11 and 12.

RQ2. Is the switching policy based on trustworthiness and complexity effective? Table 4 demonstrates that across models, adaptive switching often matches or outperforms grid-only reasoning while switching to the grid modality for only a subset of instances. The oracle result provides an upper bound by selecting the correct route whenever either text-only or grid-based reasoning gives the correct answer. This shows that larger gains are possible if switching decisions can more accurately identify when each modality is useful. Figure 4 further explains why trustworthiness and complexity signals help. Text-only accuracy declines in low-trust and high-complexity regions, while adaptive switching remains more stable by routing difficult cases to the grid modality. Additional analysis in Appendix 8.2.1 and 12 show that the two signals are complementary: trustworthiness and complexity individually result in weaker routing accuracy in most settings, while the combined adaptive policy gives the strongest performance across models. Their correlations with adaptive switch accuracy also follow the expected pattern, with trust-related factors generally positive and complexity-related factors generally negative, indicating that the policy captures both unreliable answers and intrinsically difficult instances.

2.2pt

Failure Modes. To better understand when switching helps, we analyze failures based on the original problem and model reasoning. Switching is most effective when a model fails to reason correctly in text on a multi-hop reasoning problem. In such cases, our switching mechanism can recover up to 82.4% of text-based reasoning failures. By contrast, failures involving linguistically difficult cases remain harder to recover because many residual errors arise during relation extraction in grid construction. A detailed discussion can be found in Appendix 12. Overall, these findings show that trustworthiness and complexity provide useful signals for modality switching.

RQ3. How can adaptive switching balance accuracy and computational cost? Adaptive switching provides a practical way to trade off accuracy and cost by invoking grid-based reasoning only when text-only reasoning is unreliable or the instance is complex. Across both reasoning and non-reasoning models, switching preserves or slightly improves accuracy over fixed routes while avoiding unnecessary structured reasoning calls. The savings are most meaningful when grid construction is expensive, since the model can remain on the cheaper text path for easier or more trustworthy instances. On SpaRTUN, adaptive switching, including the switching cost itself, reduces average token cost by up to 12% relative to always using the grid pipeline while maintaining accuracy competitive with grid-only reasoning baselines. Table 4 shows that, on StepGame, GPT-5.1 has the highest share of switches triggered by complexity alone among the compared models. Since complexity estimation is relatively costly for StepGame, this increases the total cost by about 11%. We provide the full token-cost breakdown, including trust-only, complexity-only, and combined switching variants, in Appendix 11.3. Overall, these results show that adaptive switching offers a useful cost–accuracy trade-off when structured reasoning is costly, especially when switch-decision triggers are more balanced across signals.

5 Conclusion↩︎

We study whether grounding spatial narratives into structured representations helps language models reason more effectively. Across StepGame, SpaRTUN, and ReSQ, our grid-based grounding framework yields the largest and most consistent improvements over natural language-based reasoning, especially as reasoning depth and spatial complexity increase. We further investigate when structured grounding is most useful and build a switching policy that decides this based on model and problem instance, showing that adaptive use of structured reasoning leads to stronger performance and efficiency over baselines. Together, these findings position structured grounding as an effective medium for spatial reasoning and highlight adaptive modality selection as a key ingredient for reliable reasoning.

Limitations↩︎

Our framework depends on reliable intermediate spatial structure construction. Grid-based reasoning is helpful only when relation extraction and grid construction accurately reflect the original narrative; otherwise, extraction errors can propagate and reduce downstream accuracy. We partially mitigate this through line-by-line relation extraction, verification, and coreference-aware processing, but future work could improve this component through spatial-relation extraction fine-tuning.

Another limitation is that adaptive switching introduces computational overhead because trustworthiness and complexity signals must be computed before routing. Although short-circuit computation reduces unnecessary checks, the switching signal is not free and can sometimes offset the savings from avoiding grid construction. Future work could develop cheaper routing signals or learned routing policies that better predict when structured reasoning will improve the answer.

6 Acknowledgements↩︎

This project is partially supported by the Office of Naval Research (ONR) under grant N00014-23-1-2417, the Michigan State University Distinguished Fellowship, and Lambda Labs. Any opinions, findings, conclusions, or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the Office of Naval Research, Michigan State University, or Lambda Labs.

7 Experimental Setup↩︎

All local experiments were conducted on a single NVIDIA GH200 GPU with 96GB memory. Unless otherwise stated, local inference used greedy decoding with temperature \(0.0\). GPT-5.1 [39] was accessed through the OpenAI Responses API with reasoning effort set to none. The switching thresholds are selected on the validation split and then fixed for test evaluation. To ensure reproducibility, all sampled subsets use a fixed random seed of 0, and the same evaluated instances are used across comparable settings. We use the Qwen3 family  [38], including Qwen3-8B, Qwen3-14B, and Qwen3-32B, with temperature 0.7 to enable their explicit reasoning mode and LLaMA3.1 [37], including LLaMA3.1-8B and LLaMA3.1-70B, with temperature 0.0. All prompts and evaluation scripts were identical across experimental conditions to ensure fair comparison between reasoning modalities; these are available in the code for reproducibility.

8 Switching Implementation↩︎

This section details how the adaptive switching policy is implemented, including the construction of the trustworthiness and complexity signals, the dataset-specific weighting of complexity factors, and the threshold-selection procedure. We also describe the short-circuit computation used to reduce switching overhead and analyze how the signals align with text-only accuracy.

Trust Signal We define trustworthiness as \(T = 0.6F + 0.4P\), giving slightly higher weight to faithfulness than plausibility. This choice reflects the role of the two signals in the switching decision. Faithfulness directly checks whether the model’s answer is grounded in the story evidence, so it should dominate the trust score: if the answer is not supported by the relevant spatial facts, then a high plausibility or stability score may only indicate that the model is consistently confident in an unsupported answer. Plausibility is still important because it tests whether the answer remains stable under benign transformations, but we treat it as a secondary signal that can reinforce, rather than override, evidence grounding. Empirically, we use a conservative gap between the two weights: changing either weight by \(0.1\) would make the score closer to an equal weighting, while a larger gap would make plausibility too weak to affect borderline cases. Thus, the \(0.6/0.4\) split encodes a minimal preference for faithfulness while still allowing plausibility to influence the final trust decision.

Dataset-specific \(C\) configuration. The components of \(C\) are selectively activated and weighted based on the dominant difficulty sources in each dataset. Table 5 reports the weight configuration used in our runs. For StepGame, the weights emphasize structural multi-hop difficulty: support burden, chain length, selection difficulty, diagonal burden, and entity load are all active because the dataset contains controlled relation chains with distractor sentences and explicit directional composition. Selection Difficulty (SD) is therefore used for StepGame to capture how hard it is to identify the relevant supporting chain among distractor relations.

For SpaRTUN, the weights emphasize linguistic and grounding difficulty rather than distractor-chain selection. SpaRTUN contains richer spatial language, logical quantifiers, mixed topological and directional relations, and entity references that can require coreference-style interpretation. Therefore, hard language (HL) and coreference difficulty (CF) receive the largest weights, while support burden, chain length, and entity load are retained with smaller weights. Selection Difficulty (SD) is not used for SpaRTUN because the main difficulty is less about selecting a hidden support chain from controlled distractors and more about interpreting the linguistic and relational structure of the story.

1mm

Diagonal Burden (DB) is not considered for SpaRTUN because its relation inventory is based on RCC8 and directional primitives rather than explicit diagonal labels such as lower-left or upper-right. Coreference Difficulty (CF) is not considered for StepGame because entities are explicitly named and do not introduce reference ambiguity.

Saturating function caps. SB, CL, and EL use \(\text{sat}(x, c) = x/(x+c)\), where \(c\) is the half-saturation point. For SB and CL on StepGame we set \(c = 5\), as difficulty increases sharply up to 5 hops and exhibits diminishing returns beyond that. For SpaRTUN, where SB uses the number of identified support sentences rather than \(k_{\text{hop}}\), we set \(c = 3\) to reflect shorter support chains. For EL we set \(c = 6\) for StepGame and \(c = 10\) for SpaRTUN, aligned with the median entity count in each dataset.

Threshold selection. For each instance, the switching rule keeps natural language-based reasoning only when the text answer is sufficiently trustworthy and the instance is not too complex, i.e., \(T \ge \tau_t\) and \(C < \tau_c\); otherwise, it switches to grid-based reasoning. We tune the thresholds \((\tau_t,\tau_c)\) on a held-out validation split and report results on a disjoint test split. The validation split is stratified by question type and hop count where applicable, so the threshold search preserves the dataset distribution.

We perform a grid search over \(\tau_t,\tau_c \in \{0.05,0.10,\ldots,0.95\}\). For each candidate pair, we compute adaptive accuracy, switch rate, and the distribution of switch sources: switches caused only by low trustworthiness, switches caused only by high complexity, and switches caused by both. Our selection follows four criteria. First, we prefer candidates whose adaptive accuracy matches or exceeds the grid-only validation accuracy; if none satisfy this, we keep the top-accuracy candidates. Second, we prefer thresholds where all three switch sources contribute meaningfully, requiring at least \(10\%\) of switches from trust-only, complexity-only, and both-signal triggers; if no candidate satisfies this balance condition, we skip it. Third, among the remaining candidates, we prefer a lower switch rate to reduce unnecessary grid usage. Finally, ties are broken by higher adaptive accuracy, then lower switch rate, and then smaller \(\tau_t+\tau_c\). This procedure favors thresholds that are accurate, efficient, and use both signals rather than allowing either trustworthiness or complexity to become vestigial.

The thresholds used for the main model settings are reported together with the routing-cost analysis in Table 13. In additional smaller-model experiments, we use \((\tau_t,\tau_c)=(0.85,0.45)\) for Qwen3-8B and Qwen3-14B, and \((0.75,0.30)\) for LLaMA3.1-8B. The lower complexity threshold for LLaMA3.1-8B reflects its lower text-only robustness on moderately complex instances. Across exploratory runs, we observed that \((0.85,0.50)\) provides a reasonable default across datasets and models, and we suggest using it as the starting point for new datasets or extended experiments.

8.1 Short-Circuit Computation for Switching↩︎

To reduce the cost of adaptive switching, we avoid computing all trustworthiness and complexity signals when an earlier signal is sufficient to determine the route. We first check trustworthiness because low trust directly indicates that the model’s text-based answer is unreliable, making additional complexity estimation unnecessary for deciding whether to switch. Since trustworthiness is defined as \(T = 0.6F + 0.4P\) and \(P \in [0,1]\), the faithfulness score \(F\) provides an upper bound on the final trustworthiness value. After computing \(F\), the maximum possible trustworthiness is \(0.6F + 0.4\). If this upper bound is below the trust threshold \(\tau_t\), the instance is already untrustworthy and is switched to grid-based reasoning without computing \(P\) or \(C\).

If trust cannot be ruled out from \(F\) alone, we compute complexity \(C\). When \(C \geq \tau_c\), the instance is considered complex and is switched to grid-based reasoning without computing \(P\). We compute plausibility \(P\) only when the instance is not already switched by low faithfulness or high complexity. In that case, the final trustworthiness score \(T = 0.6F + 0.4P\) is computed, and the policy keeps natural-language reasoning only if \(T \geq \tau_t\) and \(C < \tau_c\); otherwise, it switches to grid-based reasoning.

8.2 Switching Analysis↩︎

8.2.1 Alignment Between Trustworthiness, Complexity, and Text Accuracy↩︎

Table 6 reports the correlation between each switching factor and text-only correctness on StepGame and SpaRTUN. This analysis tests whether the proposed signals identify when natural language-based reasoning is likely to succeed or fail. Since the switching policy first decides whether the text answer can be trusted, trustworthiness factors should correlate positively with text correctness, while complexity factors should correlate negatively.

On StepGame, the alignment is strong and consistent across models. Trustworthiness has a clear positive correlation with text correctness, especially through faithfulness \(F\) and its sufficiency component. This indicates that when the model’s answer can be recovered from its cited support, the text answer is much more likely to be correct. Plausibility \(P\), including paraphrase stability and flip consistency, is also positive, showing that stable and logically consistent answers tend to be more reliable. Complexity shows the opposite trend: support burden, chain length, hard language, selection difficulty, and entity load are generally negatively correlated with text correctness. This is expected because StepGame is designed around controlled multi-hop spatial reasoning, where longer chains, distractor sentences, and heavier support requirements make text-only reasoning harder. Diagonal burden is weaker for some models, but still generally negative.

SpaRTUN shows a more linguistically driven pattern. Trustworthiness remains positive, especially for LLaMA3.1-70B and GPT-5.1, where faithfulness and sufficiency are strongly aligned with text correctness. The necessity component is negative across models, which is desirable: when the model can still answer after the relevant support is removed, the original text answer is less likely to be reliable. Complexity is also negative overall, but the strongest factors differ from StepGame. Chain length is less dominant, while hard language and coreference difficulty are stronger predictors of text failure. This reflects SpaRTUN’s richer linguistic structure, where errors often come from resolving entity references, quantifiers, and mixed topological/directional descriptions rather than only from hop depth.

Overall, the two datasets validate different parts of the switching signal. StepGame supports the structural complexity factors, because difficulty is mainly controlled by multi-hop depth, support burden, and distractor burden. SpaRTUN supports the linguistic and grounding factors, because correctness depends more on evidence grounding, hard language, and coreference resolution. These trends justify using both trustworthiness and complexity: trustworthiness captures whether the text answer is faithful and stable, while complexity captures whether the instance itself is likely to make text-only reasoning unreliable.

4pt

9 Modalities in Small Language Models↩︎

Behavior of Small Language Models.

Table 7 compares smaller open-source models on StepGame across text, relational triples, coordinates, grids, and ToT-CoT prompting. The results demonstrate that structured spatial representations become more useful as hop length increases. Text-only reasoning is competitive for short chains, especially at one hop, but drops as the model must compose multiple relations for reasoning. Relational triples make the extracted relations explicit but still require internal symbolic composition. In contrast, grids externalize the spatial layout, making them the most stable representation overall. Pruned grids further reduce irrelevant entities and keep the reasoning context compact, while full grids preserve the full scene but may force smaller models to reason over unnecessary entities. This matters less for stronger reasoning models: Qwen models show similar full-grid and pruned-grid performance, whereas LLaMA3.1-8B benefits more clearly from pruning. Coordinate representations also help, but their reliance on positional comparison and numerical or symbolic manipulation makes them less consistently reliable than grids.

Table 8 extends the analysis to SpaRTUN, which includes both Yes/No and Find-Relation questions. Here, grid-based methods are not always dominant because they depend on the quality of upstream relation extraction. For LLaMA3.1-8B, CoS performs best, suggesting that very weak models may benefit more from guided symbolic reasoning than from grids built from noisy extracted relations. For Qwen3-8B, performance varies by question type: CoS is strongest on YN questions, relational triples perform best on FR and overall accuracy, while pruned grids remain competitive. For Qwen3-14B, pruned grids perform best overall and are especially strong on Find-Relation questions, improving overall accuracy from 64.90% to 72.97%. This suggests that compact structured layouts become more useful when the model can extract relations more reliably.

To test generalization beyond StepGame and SpaRTUN, we also evaluate ReSQ, where grids are constructed using GPT-5.1 from relations extracted by each model. Since ReSQ contains shorter Yes/No spatial reasoning chains, gains from grid grounding are smaller than on StepGame but still model-dependent. For LLaMA3.1-8B, text-only reasoning remains strongest. In contrast, Qwen3-8B and Qwen3-14B benefit from grid grounding, with full or pruned grids giving the best accuracy on ReSQ. This suggests that when relation extraction is reliable enough, grid-based layouts help focus the model on the spatial evidence relevant to the question. Relational triples show less consistent gains, making them useful in some cases but less reliable than grids for ReSQ.

5pt

2.0pt

10 Switching on Small Language Models↩︎

3.2pt

Table 9 shows adaptive switching remains close to or improve over grid-only performance for small open-source models. This indicates that the switching policy can preserve the benefit of structured reasoning while still selecting text when it is reliable enough. The switch rate also reflects model strength. Weaker models such as LLaMA3.1-8B switch most often, with a 94.0% switch rate, suggesting that their text-only answers are rarely reliable enough for multi-hop spatial reasoning. In contrast, Qwen3-14B switches less often at 65.6% and achieves the best adaptive accuracy. This suggests that stronger reasoning models can rely on text-based reasoning more selectively while still benefiting from grid-based reasoning on harder or less trustworthy instances. The remaining gap to oracle accuracy shows that better modality selection could further improve performance, especially in deciding when text is sufficient and when grid grounding is necessary.

11 Ablation Study↩︎

We conduct ablation studies to isolate the contribution and reliability of each component in our structured reasoning pipeline. First, we evaluate ground-truth intermediate representations to estimate the upper bound of relational triples, full grids, and pruned grids when upstream extraction noise is removed. Second, we analyze construction reliability by separating errors from relation extraction and errors introduced during grid construction. Third, we evaluate the spatial relation extraction module itself, comparing the baseline extraction setting with our sentence-level, context-aware extraction pipeline. Finally, we analyze adaptive routing cost and signal-specific contribution by comparing trust-only, complexity-only, and full switching policies. Together, these ablations show where performance gains come from, when grid-based reasoning is limited by upstream extraction, and how switching balances accuracy with computational cost.

11.1 Ground-Truth Representation Upper Bound↩︎

To isolate upstream relation extraction errors, we evaluate reasoning directly on ground-truth intermediate representations in Table 10. Specifically, we compare reasoning over ground-truth relational triples, ground-truth full grids, and ground-truth pruned grids. Ground-truth full grids are constructed directly from ground-truth relational triples using our grid-construction pipeline, while pruning is performed model-wise before applying the same construction code. We use model-wise pruning rather than dataset-provided reasoning annotations because the annotations are Prolog-based and answer-oriented, and do not translate directly into the entity set needed for grid construction. This is especially important for Find-Relations multi-label questions, where pruning must retain the queried entities and enough surrounding context to preserve the answer. Model-wise pruning is therefore more consistent with the deployed pipeline, remains dataset-agnostic, and attributes pruning errors to the same model used for reasoning. Ground-truth triples are passed directly to the model without any spatial layout construction. This analysis measures the upper bound of each representation when extraction noise is removed.

3pt

Ground-truth grids substantially outperform relational triples, especially on both datasets where deeper multi-hop spatial reasoning benefits from explicit structured layouts. This suggests that even perfect qualitative relational triples are often insufficient on their own and that models benefit from representations that combine qualitative relations with an explicit quantitative spatial structure.

For Qwen3-32B, pruning remains nearly identical to full grids on both SpaRTUN and StepGame, likely because the model already performs strongly on structured reasoning tasks, consistent with observations in the Qwen3 technical report [38]. On SpaRTUN, pruning itself is also a harder task because many Yes/No questions contain quantifiers while Find Relation questions often require complete block-level reasoning. As a result, the pruned and full grids produce identical answers for 91.6% of examples overall on a subset of \(n=561\) samples (50% of our test set while maintaining the same split proportions), with agreement reaching 95.8% for YN questions and 86.7% for FR questions. This suggests that much of the useful spatial structure in SpaRTUN must often be preserved even after pruning.

11.2 Construction Reliability↩︎

Since the grid-based route depends on the quality of the intermediate structure, we separately analyze the reliability of relation extraction and grid construction. This section reports how accurately spatial relations are extracted from text and how reliably those relations are converted into valid grid representations for downstream reasoning.

3.2pt

11.2.1 Relation extraction and grid construction fidelity.↩︎

Table 11 evaluates two sources of error in the structured pipeline: relation extraction and grid construction. Relation extraction is evaluated as a relation-level matching problem, measuring how many predicted spatial triples match the gold triples. Grid construction is different: it evaluates whether a complete grid layout faithfully encodes the target relation graph. In this setting, recall measures how many intended relations are preserved in the grid, while precision can decrease if the concrete placement of objects induces additional spatial relations that were not explicitly specified in the ground-truth relations.

This distinction matters most for SpaRTUN. Unlike StepGame, which mainly contains controlled directional relations, SpaRTUN includes directional, topological, distance-based, and RCC-style relations. Encoding all of these constraints into a single discrete row-column grid is a harder geometric realization problem and can become computationally difficult in the presence of mixed spatial constraints. Even when the ground-truth relations are used, the grid achieves very high recall but slightly lower precision, because assigning each entity a concrete grid position can introduce extra directional cues between pairs that are not explicitly constrained in the original relation graph. Thus, the grid should be viewed as a compact reasoning interface rather than a perfect reconstruction of every spatial relation.

The ground-truth relations results show that the grid construction procedure itself is reliable: it is perfect on StepGame and preserves almost all gold relations on SpaRTUN. When predicted relations are used, performance decreases, especially on SpaRTUN, showing that most remaining errors come from upstream relation extraction and from the difficulty of realizing richer spatial graphs in a single grid. This supports our design choice: the goal is not to solve exact geometric realization for every spatial relation in a story but to test whether a structured grid representation can still provide a useful intermediate reasoning interface for LLMs.

11.2.2 Spatial Relation Extraction↩︎

Grid construction relies on extracted spatial relations heavily. Therefore, we evaluate relation extraction as a preprocessing step. The task converts each spatial story into triples of the form (head, relation, tail), which are then passed to the grid-construction module.

Our extraction pipeline processes the story sentence by sentence rather than extracting all relations in one pass. For StepGame, we use line-by-line extraction module with in-context learning, which helps the model focus on local directional relations. For SpaRTUN, we use the same sentence-level extraction followed by a coreference-aware refinement pass, where each line is reprocessed using the previous two lines and the already extracted relations as context. This is important for SpaRTUN because its stories contain richer language, pronouns, and entity references that require coreference resolution for better relation extraction. To assess whether this decomposition is necessary, we compare our pipeline against a baseline that gives the model the full story at once and asks it to extract all spatial relations in a single call. The baseline requires the model to resolve relation extraction, entity grounding, and coreference jointly, which leads to missed or noisy triples. In contrast, our sentence-level extraction with context-aware refinement decomposes the task into smaller decisions and improves extraction accuracy by about 20% on both datasets. This improvement is important because errors in relation extraction directly propagate to grid construction and downstream reasoning.

4pt

11.3 Cost Analysis↩︎

Table 13 reports the average token cost per record for adaptive routing across StepGame and SpaRTUN. We compare the fixed text-only route, the fixed grid pipeline, the cost of computing each switching signal, and the final adaptive route. The switch total includes both the switching-signal cost and the cost of the selected reasoning path.

The main observation is that adaptive switching changes the cost–accuracy tradeoff differently across datasets. On StepGame, adaptive switching improves or preserves accuracy relative to the fixed grid route, while token cost varies by model: it decreases slightly for Qwen3-32B, remains close for LLaMA3.1-70B, and increases for GPT-5.1. This mixed pattern indicates that, for StepGame, the switching signal is useful mainly as a routing and accuracy mechanism rather than as a guaranteed token-saving mechanism. Since the grid pipeline is already highly effective on this dataset, the additional cost of computing the switch decision can offset the savings from routing some examples through the text path.

SpaRTUN shows a different pattern. Here, adaptive switching reduces average token cost relative to always using the grid pipeline across all three models, while keeping accuracy competitive with the stronger fixed route. This suggests that the routing policy is more cost-effective when the dataset contains a mixture of examples, some that benefit from structured reasoning and others that can remain on the cheaper text-only path. The reduction is largest for GPT-5.1; however, because GPT-5.1 also has lower costs across most fixed and adaptive rows, we interpret this as partly a model-specific efficiency effect rather than only an effect of routing. The single-signal rows help explain why the combined policy is preferable. In these ablations, one signal is disabled while the other remains active: trust-only routing zeroes out the complexity signal and uses the trust threshold \(\tau_t\), while complexity-only routing zeroes out the trustworthiness signal and uses the complexity threshold \(\tau_c\). Each signal provides useful but incomplete information. Trustworthiness captures whether the model’s current text answer appears grounded and stable, while complexity captures factors that make the instance difficult before or during reasoning. As shown in Table 6, these factors correlate with adaptive correctness in the expected directions: trust-related factors are mostly positive, while complexity-related factors are mostly negative. This suggests that the signals reflect different aspects of model behavior, including cases where the model can overcome apparent difficulty and cases where perceived difficulty corresponds to actual failure.

Together, the two signals are stronger in terms of accuracy because they solve complementary cases. Trust-only routing can miss examples that look reliable but are structurally difficult, while complexity-only routing can over-switch examples that look difficult but are still answered correctly in text. The full adaptive policy combines evidence reliability with instance difficulty, giving a more stable accuracy-cost tradeoff than either signal alone. Overall, adaptive switching should be interpreted as a helpful token-reduction method in some settings and as a mechanism for allocating expensive structured reasoning to examples where the model is more likely to need it.

2.4pt

12 Error Analysis↩︎

This appendix analyzes the main failure modes behind text-only reasoning, grid-based reasoning, and adaptive switching. We focus on three diagnostic views: the error taxonomy, disagreements between text and grid routes, and how often switching recovers different categories of text-only failures.

12.1 Error Taxonomy↩︎

We use error analysis as a diagnostic tool to understand when switching from text-only reasoning to grid-based reasoning helps, and when it can still fail. This analysis is separate from the larger switching experiments reported in the main results. It is conducted on a diagnostic subset of the StepGame test set for which we inspect model traces, generated grids, and gold grids.

We classify errors at two levels. Input-level labels describe structural properties of the story that make an instance difficult independent of the model’s behavior. Output-level labels describe the specific failure mode exhibited by the model. Since a single example may involve both a difficult input structure and an incorrect model behavior, labels are not mutually exclusive.

Input-level labels. Composite spatial marks stories that contain diagonal or composite directional relations, such as upper-right or clock-face expressions like “at the 7 o’clock position.” These cases require decomposing a relation across two spatial axes. Multi-hop marks stories where the question cannot be answered from a single stated relation and instead requires chaining two or more relations across sentences. For example, the model may need to invert “H is right of Z” into “Z is left of H” and then compose it with another relation such as “H is upper-right of G.”

6pt

Output-level labels. For text-only failures, we assign one or more of four labels using a GPT-based classifier that observes the story, question, gold answer, and sentence-level reasoning trace. Multi-hop reasoning failure is assigned when the model has access to the necessary relations but fails to compose them correctly. Composite failure is assigned when the gold answer is diagonal but the model collapses it to a single axis, for example predicting below when the gold answer is lower-left. Linguistic difficulty is assigned when the model misinterprets non-canonical spatial language, including clock-face references, informal directional phrases, or unusual prepositions. Hallucination is assigned when the reasoning trace introduces a relation that is not grounded in the story.

For grid failures, we use a parallel classifier that also observes the generated grid and the gold-standard grid. We attribute each grid failure to either relation-extraction failure, where the grid is incorrectly constructed because the extracted relations do not match the gold relations, or grid-reasoning failure, where the grid is correctly constructed but the model misreads or fails to reason well over the layout.

12.2 Reasoning Modality Disagreement↩︎

Before analyzing individual error types, we first compare whether text-only and grid-based reasoning succeed on the same subset of examples. This helps separate two effects: cases where the grid recovers an error made by text-only reasoning and cases where the grid introduces a new error even though text-only reasoning was correct. This disagreement analysis is computed on the same diagnostic StepGame subset and is intended to explain the behavior of the switching policy rather than replace the larger-scale switching results in the main experiments.

Table 14 shows that grid-based reasoning frequently corrects text-only failures across models. This effect is especially visible for smaller or weaker models, where Grid\(✔\) Text\(\times\) is much larger than Text\(✔\) Grid\(\times\). However, the grid is not universally beneficial. In some cases, text-only reasoning gives the correct answer while the grid route fails, either because relation extraction produces an imperfect grid or because the model misreads the generated layout. These disagreements support the need for a selective switching policy rather than a fixed choice of reasoning modality.

3pt

3pt

12.3 Diagnostic Switching Analysis↩︎

We next analyze how the switching policy behaves on text-only failures in the diagnostic StepGame subset. Tables 15 and 16 report which text-only failures are routed to the grid, which switched cases are recovered, and which failures remain after grid-based reasoning. We split the analysis into stronger models and smaller/open models for readability, while keeping the same error categories and metrics across both tables. For this analysis, we randomly sample 250 instances from the switching test set. We use this subset to keep the evaluation computationally tractable, as computing these diagnostics requires LLM-based analysis with models such as GPT.

Tables 15 and 16 show that multi-hop reasoning failures are the most consistently recoverable category once the policy routes an instance to the grid. Among stronger models, recovery for multi-hop failures is 80.6% for GPT-5.1, 82.4% for Qwen3-32B, and 83.6% for LLaMA3.1-70B. The same trend appears for the smaller/open models, with 82.3% recovery for Qwen3-14B, 83.1% for Qwen3-8B, and 82.9% for LLaMA3.1-8B among switched multi-hop failure cases. This indicates that grid-based reasoning is particularly helpful when the text-only route fails because it cannot compose spatial relations across multiple steps.

However, the overall benefit of switching still depends on whether the model can construct and use the grid reliably. This is clearest for LLaMA3.1-8B: although switched multi-hop failures are often recovered, the model has many text-only failures overall and reaches only 36.8% adaptive accuracy on the diagnostic subset, recovering 10.2% of text-only failures. This suggests that switching frequently is not sufficient when the upstream relation extraction and grid-use pipeline are weak. In contrast, Qwen3-8B and Qwen3-14B achieve much higher adaptive accuracies, showing that smaller models can benefit substantially from switching when their structured pipeline is strong enough.

Composite failures are less consistently recovered than multi-hop failures. Their recovery rates are lower for all models, ranging from 36.4% for LLaMA3.1-70B to 57.1% for Qwen3-14B. This suggests that composite or diagonal spatial relations remain difficult because the pipeline must first extract, decompose, and encode the relation correctly before grid reasoning can help.

The residual failure columns further show that relation extraction is the main bottleneck in many switched failures. For Qwen3-8B and LLaMA3.1-8B, all observed remaining grid failures in this diagnostic subset are attributed to relation-extraction errors. For GPT-5.1, Qwen3-32B, Qwen3-14B, and LLaMA3.1-70B, some remaining failures are instead due to grid reasoning, meaning that the grid may be sufficiently informative but the model still misreads the layout or reverses the reference frame. Overall, these diagnostics support the main conclusion that switching is most useful for recoverable multi-hop composition errors, while its ceiling is limited by relation extraction quality and by the model’s ability to interpret the constructed grid.

13 Examples↩︎

13.1 StepGame↩︎

Figures 5 and 6 show StepGame examples using Qwen3-8B for question answering and relation extraction, with grids constructed deterministically from extracted relations. The examples include a case where grids recover a multi-hop text-only failure and a case where grid reasoning still fails because the model misreads row and column positions.

13.2 SpaRTUN↩︎

Figures 7, 8, and 9 show SpaRTUN examples using Qwen3-32B for question answering and relation extraction. These examples focus on topological and containment reasoning, where grids encode nested boxes with bracketed structures and RCC8-style relations such as tpp, ntpp, and dc.

13.3 ReSQ↩︎

Figures 10 and 11 show qualitative examples from ReSQ using Qwen3-32B for question answering and relation extraction, and GPT-5.1 for grid construction. The grid is represented as a \(5\times5\) markdown table with directional tags such as #above(X), #below(X), #left(X), #right(X), #front(X), #behind(X), and #near(X).

13.4 Switching↩︎

Figure 12 shows a StepGame switching example using Qwen3-8B as the candidate model and gpt-5-mini for complexity signals. The example shows that an answer can appear faithful to its cited support while still being implausible under stability checks. Together with high complexity, this triggers a switch to grid-based reasoning, which recovers the gold answer.

References↩︎