Supervised Chain of Thought

## Abstract

Abstract Large Language Models (LLMs) have revolutionized natural language processing and hold immense potential for advancing Artificial Intelligence. However, the core architecture of most mainstream LLMs—the Transformer—has inherent limitations in computational depth, rendering them theoretically incapable of solving many reasoning tasks that demand increasingly deep computations. Chain of Thought (CoT) prompting has emerged as a technique to address these architectural limitations, as evidenced by several theoretical studies. It offers a promising approach to solving complex reasoning tasks that were previously beyond the capabilities of these models.
Despite its successes, CoT and its variants (such as Tree of Thought, Graph of Thought, etc.) rely on a “one-prompt-for-all” approach, using a single prompt structure (e.g., “think step by step”) for a wide range of tasks—from counting and sorting to solving mathematical and algorithmic problems. This approach poses significant challenges for models to generate the correct reasoning steps, as the model must navigate through a vast prompt template space to find the appropriate template for each task.
In this work, we build upon previous theoretical analyses of CoT to demonstrate how the one-prompt-for-all approach can negatively affect the computability of LLMs. We partition the solution process into two spaces: the prompt space and the answer space. Our findings show that task-specific supervision is essential for navigating the prompt space accurately and achieving optimal performance. Through experiments with state-of-the-art LLMs, we reveal a gap in reasoning performance when supervision is applied versus when it is not.
Our goal is to provide deeper insights into the mechanisms underlying CoT, offering guidance for the effective design of CoT variants. Additionally, we underscore the limitations of traditional “unsupervised” prompting methods, arguing that users of CoT cannot simply “sit back” and rely entirely on the model. Instead, we advocate for task-specific “supervised” CoT, enriched with human knowledge, to enable more effective reasoning in LLMs.

## 1 Introduction

The advent of large language models (LLMs) (Achiam et al., ) has ushered in a new era for natural language processing and artificial intelligence (Kojima et al., ; Zhao et al., ). These models exhibit remarkable capabilities across various domains (Thirunavukarasu et al., ; Wei et al., ; Valmeekam et al., ; Zhang et al., ), achieving near-human performance in tasks such as knowledge retrieval and articulation (Chang et al., ). However, concerns have been raised regarding their reasoning abilities (Valmeekam et al., ; Zhang et al., ). These tasks range from fundamental operations like counting, sorting, and multiplication (Dziri et al., ), to more complex challenges such as mathematical problem-solving, algorithm design, and coding (Xu et al., ; Thirunavukarasu et al., ).
Previous research has explored several factors contributing to these reasoning deficiencies, including training optimizations (Thorburn & Kruger, ), tokenization methods (Singh & Strouse, ), and dataset choices (Ye et al., ). Among these, the architecture of the model plays a pivotal role in determining its reasoning capabilities (Raghu et al., ; Zhang et al., ; Delétang et al., ). The backbone architecture of most mainstream LLMs—the Transformer (with finite precision) (Vaswani, )—has intrinsic limitations related to computational depth (Li et al., ). Specifically, the attention mechanism within Transformers can perform only a fixed number of sequential computational steps (Li et al., ; Zhang et al., ; Sanford et al., ; Dehghani et al., ), leading to constant-depth modeling (Li et al., ). As a result, when relying solely on the Transformer’s internal reasoning, the model’s computability is restricted to TC^0 (Li et al., ; Feng et al., ), which confines it to solving tasks of limited complexity and length (Figure 1.c-d).

The emergence of Chain of Thought (CoT) (Wei et al., ) has transformed the computational limitations imposed by architectural design. Specifically, it overcomes the constant depth limitation of a model’s internal (latent space) reasoning by extending the reasoning process into the “text” space through prompting (Li et al., ; Zhang et al., ; Feng et al., ). As demonstrated by both theoretical (Li et al., ; Zhang et al., ; Feng et al., ) and empirical research (Li et al., ; Zhang et al., ), CoT effectively enhances the reasoning depth of Transformer-based models (with finite precision), achieving “Turing Completeness” under ideal conditions (Li et al., ; Zhang et al., ). While the theoretical analysis of CoT focuses on the model’s upper bound computational power, which may not always align with real-world performance, a deep understanding of the CoT mechanism—particularly how it breaks architectural constraints—is crucial for designing better prompts that maximize the computational potential of real-world LLMs. This understanding also forms the basis for our analysis of “supervised” CoT and our prompt search space theories. Therefore, our work first revisits the underlying mechanisms of CoT from a computational perspective, integrating insights from prior research (Li et al., ; Zhang et al., ; Feng et al., ) to demystify them in a clear, yet comprehensive manner, enriched by our unique perspective.

Figure: Figure 1: (a) Without supervision during CoT, the model generates its own step template for recurrent computation. This template can be incorrect, leading to task failure. (b) With human supervision, the task performance under CoT can be properly guided. (c) When CoT is not employed, the model relies solely on its internal reasoning via the Transformer architecture. (d) The Transformer can only perform constant-depth sequential computations. We assume that this Transformer neither memorizes the results nor performs bit-level (circuit) reasoning; instead, reasoning occurs at the neuron (hidden state) level.
Refer to caption: x1.png

Although theoretical analysis has proven the existence of solutions for (almost) any problem using CoT, based on computability and Turing Completeness theory, the actual discovery of those solutions can be much more challenging. This is akin to how a Turing machine can model solutions for any problem (Boolos et al., ) but finding the exact Turing machine for a specific NP problem could be difficult. These challenges arise from two main factors for LLMs with CoT. First, the model must develop the correct “step-by-step” template, which essentially embodies the algorithm used for solving the problem (Figure 1.a-b). For instance, the “steps” for solving a graph search problem using depth-first search (DFS) differ from those of a breadth-first search (BFS) algorithm. Second, even after the template (algorithm) is established, finding the solution might require extensive reasoning and exploration to achieve the optimal outcomes. For example, using the BFS template to locate a target node in a tree involves traversing multiple paths in the search space that can be computationally expensive and error-prone.

The vanilla design of CoT is “unsupervised” Barlow (); Zhang et al. (), meaning that the model generates its step template without task-specific supervision from humans. Specifically, when prompted to “think step by step”, LLMs autonomously generate a step template (algorithm) it needs to follow—for instance, generating previously visited paths at each step—and then proceeding to search for answers based on this self-generated template (Figure 1.a). Clearly, this naive CoT approach can lead to poor performance, as the model may generate sub-optimal step templates (algorithms), which hinder the search process. For example, a problem requiring DFS might be unnecessarily attempted with a BFS template generated by the vanilla CoT, incurring high inference costs and likely delivering incorrect answers (Figure 1.a).

Variants of Chain of Thought, such as Tree-of-Thought (Yao et al., ) and Graph-of-Thought (Besta et al., ), aim to improve the search process within the answer space, rather than the prompt space, and remain unsupervised. These “X-of-thought” approaches still rely on a “one-prompt-for-all” strategy, where the model autonomously devises a step template (algorithm) for each task. Once the template is established, these approaches help navigate the answer space more effectively. For instance, Graph-of-Thought encourages the model to frequently revisit previously generated steps, while Tree-of-Thought allows the model to generate multiple possible next steps before selecting the most promising one. However, the step template itself (algorithm) is still generated by the model and can be poorly suited to the problem (Figure 1.a), especially when task-specific supervision (guidance) is lacking.

In this work, we thoroughly investigate the distinction between prompt space and answer space in the CoT process. Building on insights from previous theoretical analyses of CoT (Li et al., ), we explore why “supervision” is necessary and how it can be provided to guide the model in finding the optimal steps. We conduct extensive experiments on structured reasoning tasks, demonstrating that task-specific “supervised” CoT is crucial for achieving optimal solutions and highlighting the performance gap when supervision is used versus when it is not. Our work is the first of its kind to focus on prompt space exploration and offers valuable insights into understanding and designing effective prompt techniques for reasoning tasks.

## 2 Demystifying CoT: A Straightforward Understanding

In this section, we summarize key findings from previous theoretical analyses (Li et al., ; Zhang et al., ; Feng et al., ) of CoT prompting, presenting them in a unified and accessible manner. The conclusions drawn here will serve as a foundation for our subsequent analysis of supervised CoT.

Figure: Figure 2: Comparison between recurrence and autoregression.
Refer to caption: extracted/5936630/CoT_de.png

### 2.1 Limitations of Transformer Architecture

Transformers, unlike recurrent networks, are not designed to perform reasoning over an arbitrary number of sequential steps (depth) internally. Specifically, in a Transformer model, the hidden state $\mathbf{h}_{\texttt{t-1}}$ at time step t-1 is not reused when calculating $\mathbf{h}_{\texttt{t}}$ (Figure 2.b), as it would be in recurrent networks like RNN (Figure 2.a). Instead, the hidden state $\mathbf{h}$ is passed forward only through the layers of the Transformer (Dehghani et al., ) (Figure 1.c), not through time, which means that the number of sequential steps is fixed and limited for any given Transformer architecture (Li et al., ; Zhang et al., ; Elbayad et al., ).
In contrast, Recurrent Neural Networks (RNNs) (Grossberg, ) allow the hidden state $\mathbf{h}$ to be passed through time steps via recurrent connections (Figure 2.a), enabling sequential computation over $\mathbf{h}$ through an arbitrary number of input tokens. This capability allows RNNs to perform deeper reasoning over $\mathbf{h}$, which is essential for solving complex tasks (Zhang et al., ).

The hidden state $\mathbf{h}$ plays a crucial role in reasoning, as it stores both reasoning memory and intermediate reasoning results (Zhang et al., ). The ability to sequentially compute and update $\mathbf{h}$ over time allows a model to build reasoning depth, which is necessary for addressing complex problems. This depth advantage provided by recurrent connections cannot be replicated by autoregressive models.
Autoregressive models, instead of passing the hidden state $\mathbf{h}_{\texttt{t}}$ forward, pass the generated token $\text{y}_{\texttt{t}}$. However, y cannot replace the role of $\mathbf{h}$ for the following reasons:
y is a discrete value extracted from $\mathbf{h}$ and only contains partial information (Figure 2.b), making it insufficient for continued reasoning in many tasks.
y exists outside the latent space where $\mathbf{h}$ operates (Figure 2.b), meaning it cannot be used for computation in the same way that $\mathbf{h}$ can (Zhang et al., ).

### 2.2 Nature of Reasoning

Reasoning inherently requires sequential depth. For tasks with input of length n, reasoning is typically performed step by step to arrive at the final result. Examples include counting (incrementing a counter iteratively), playing chess (updating the board state iteratively), and searching (marking visited nodes iteratively). To solve a given task, there is a theoretical lower bound on the required depth of computation (Sanford et al., ). Since models like Transformers can only perform a constant number of sequential reasoning steps over the hidden state $\mathbf{h}$, they are unable to solve reasoning tasks where the depth requirement increases with the length of the input.

Consider chess as an example. For a sequence of chess moves, $\mathbf{x}_{\texttt{n}}=(\text{x}_{\texttt{1}},\text{x}_{\texttt{2}},\dots,
\text{x}_{\texttt{n}})$, to validate the n-th move, the n-th board state $\mathbf{h}_{\texttt{n}}$ must be calculated. This requires n sequential computations, as the n-th board state depends not only on the sequence of moves $\mathbf{x}$ but also on the previous board state $\mathbf{h}_{\texttt{n-1}}$. While a neural network could memorize the mapping from $\mathbf{x}_{\texttt{n}}$ to the correct $\mathbf{h}$ (Arpit et al., ), bypassing the need for sequential computation, memorization is much more resource-intensive than reasoning. This is because memorization would require storing all possible permutations of $\mathbf{x}_{\texttt{n}}$ and their corresponding resulted board states, an exponential challenge that eventually demands infinite memory to store instances of arbitrary length.

Thus, in the example of simulating a chess game, the model’s internal representation $\mathbf{h}$, which encodes the board state, must be sequentially computed n times to simulate the game. Transformers, which lack the infinite precision needed for memorization, cannot perform such tasks, as their hidden states $\mathbf{h}$ are computed a fixed number of times, regardless of the input length.

### 2.3 CoT + Autoregressive = Recurrent

As previous studies have shown Li et al. (); Zhang et al. (); Feng et al. (), Chain of Thought (CoT) effectively bridges the gap between autoregressive Liang et al. (); Liu et al. () models and recurrent structures Zhang et al. () within large language models (LLMs). Instead of merely outputting tokens to answer questions, CoT also generates intermediate steps which are not part of the answers. These intermediate steps, represented as a sequence of natural language tokens $(\text{o}_{\texttt{1}},\text{o}_{\texttt{2}},\dots,\text{o}_{\texttt{k}})$, act as a discretization of the latent information $\mathbf{h}_{\texttt{n}}$ (Figure 2.c). Given that natural language is a powerful medium for encoding nearly any type of information, $\mathbf{h}$ is effectively transformed into a token sequence $\mathbf{o}$, which is then converted back into a vector $\mathbf{h}$ via the embedding layer. In this way, computational information is preserved through a process of discretization followed by vectorization, represented as: $\mathbf{h}_{t}\xRightarrow{\text{discritization}}(\text{o}_{\texttt{1}},\text{
o}_{\texttt{2}},\cdots,\text{o}_{\texttt{k}})\xRightarrow{\text{vectorization}
}\mathbf{h}_{\texttt{t+1}}$ (Figure 2.c). This approach, effectively achieve the same effect as $\mathbf{h}_{t}\Rightarrow\mathbf{h}_{\texttt{t+1}}$ in the RNN-like recurrent network, allowing $\mathbf{h}$ to be recurrently updated by the network.

In the earlier chess example, the LLM generates intermediate reasoning steps as natural language strings during the CoT process. Specifically, it produces a sequence of tokens (e.g., in English) to describe the board state $\mathbf{h}_{\texttt{k}}$ after the first k moves, detailing the positions of pieces such as the bishop and the king. In the subsequent computation, the LLM reads this board description up to move k and uses it to calculate the k+1-th board state, thereby avoiding the need to re-compute the reasoning from scratch—something Transformers cannot do internally due to their non-recurrent architecture.

In conclusion, LLMs with CoT effectively extend the reasoning process from the model’s internal latent space $\mathbb{H}$ to a natural language-based token space $\mathbb{O}$. Thanks to the powerful encoding ability of natural language, intermediate reasoning steps are encoded and stored in text form, which the model can reuse in subsequent computations. This approach significantly increases the model’s reasoning depth to $T(\texttt{n})$, where $T(\texttt{n})$ is the number of CoT steps performed. Under ideal theoretical conditions—such as infinite CoT steps and perfect information conversion between latent and text space—LLMs with CoT can achieve Turing completeness, theoretically solving any problem, including those beyond symbolic tasks (e.g. recognizing regular languages). This theoretical analysis provides strong guidance for designing effective “supervised” CoT approaches, which we introduce in subsequent sections.

Figure: Figure 3: A visualization of CoT search space, which decomposed into prompt space and answer space for a given problem.
Refer to caption: extracted/5936630/space_theory.png

## 3 CoT Search Space = Prompt Space + Answer Space

While theory suggests CoT-augmented LLMs can solve any problem Li et al. (), finding solutions in practice is much harder. CoT is limited by a finite number of steps, and the conversion from latent states $\mathbf{h}$ to token sequences $\mathbf{o}$ is imperfect. Consequently, only partial information is extracted at each step, making it crucial to identify the right data to continue the correct computation.
We decompose the CoT reasoning into two components: template search within the prompt space and answer search within the answer space. We show how effective navigation of the prompt space can simplify answer space complexity and reveal limitations of unsupervised “X-of-thought” methods.

### 3.1 Prompt Space

The latent vector $\mathbf{h}$ contains rich intermediate information when processing a task, including counters, sums, flags for binary indicators, and more. When LLMs are prompted to “think step by step” along with the task instance, they generate a step template, specifying which information from $\mathbf{h}$ to extract and discretize into tokens $(\text{o}_{\texttt{1}},\text{o}_{\texttt{2}},\dots,\text{o}_{\texttt{k}})$. Ideally, as $\texttt{k}\mathbf{\to}\mathbf{\infty}$—meaning the length of the CoT is arbitrarily long—all vectorized information in $\mathbf{h}$ can be fully textualized, achieving true recurrence through autoregression. However, with limited k, only partial information is discretized.

If we define the amount of information stored in $\mathbf{h}$ as m bits, and each CoT step extracts up to s bits of information into $\mathbf{o}$, each unique step template specifies a way to extract s bits from the full m-bit space. Thus, the total number of potential step templates is $C(\texttt{m},\texttt{s})=\frac{\texttt{m}!}{\texttt{s}!(\texttt{m}-\texttt{s})!}$, which estimates the number of ways information can be extracted via CoT at each step. Each template defines an extraction of unique s bits of information.

For example, in the chess simulation case, $\mathbf{h}$ encodes details such as the <current board layout>, <the next player>, <board status>, <number of pieces taken by each player> and so on. When given the instruction to “think step by step”, the model decides which information to extract based on the step template it generates. Extracting the wrong information might hinder reasoning in subsequent steps as recurrence can not be effectively performed on the needed information.

The prompt search complexity $C(\texttt{m},\texttt{s})$ depends on both m, the total information in $\mathbf{h}$, and s, the amount of information each CoT step can extract. If a model is sufficiently trained, the total amount of encoded information in $\mathbf{h}$ is proportional to the dimension size of $\mathbf{h}$ (Allen-Zhu & Li, ), d, denoted by $\texttt{m}\propto\texttt{d}$. In this context, m represents the size of the search space, while s correlates with the length of CoT tokens $\mathbf{o}$, as longer CoT steps tend to extract more information from $\mathbf{h}$. Thus, s serves as the search step size.
In practice, step template search is not entirely random. Models often find relevant templates using heuristics, which significantly reduces the search complexity of $C(\texttt{m},\texttt{s})$. However, identifying the optimal template remains challenging, and using an incorrect template can severely degrade performance, as demonstrated in our experiments.

In conclusion, the step (prompt) template defines how information is extracted and used recurrently in the CoT process. Finding the correct template is equivalent to discovering the algorithm for solving a given task, determining what information is needed at each step and how it should be used to compute the next state (Figure 3 left).

### 3.2 Answer Space

Once the model “decides” on the steps to follow during CoT, it performs reasoning accordingly. With a specific step (prompt) template $\mathrm{p}i$ chosen from the prompt space $\mathcal{P}$, CoT iteratively executes $\mathbf{h}_{t}\xRightarrow{\mathrm{p}_{i}}(\text{o}^{{(i)}}_{\texttt{1}},\text
{o}^{{(i)}}_{\texttt{2}},\dots,\text{o}^{{(i)}}_{\texttt{k}})\xRightarrow{}
\mathbf{h}_{\texttt{t+1}}$ to update $\mathbf{h}$ and calculate the next state, continuing this process until reaching the final state (solution). The complexity of finding solutions in the answer space depends on both the choice of $\mathrm{p}_{i}$ and the nature of the task itself.

Each task embeds a different level of complexity in its answer space. For instance, in the chess simulation task of <finding a set of actions leading to game end>, the answer space $\mathcal{S}=(\mathbf{s}_{1},\mathbf{s}_{2},\dots,\mathbf{s}_{\infty})$ contains all possible combinations of action sequences $\mathbf{s}$. The solution set $\mathcal{CR}\subset\mathcal{S}$ includes all valid action sequences that lead to the end of the game, being a subset of the entire answer space $\mathcal{S}$. Solving the problem requires identifying one single correct action sequence $\mathbf{s}_{\texttt{correct}}=(\text{y}_{\texttt{1}},\text{y}_{\texttt{2}},
\dots,\text{y}_{\texttt{T}})\in\mathcal{CR}$.

If a fixed step (prompt) template for this task, such as $\mathrm{p}_{0}=$ <extract current board configuration at each step>, is used, the CoT process iteratively extracts the current board description and use it for calculating next board state in $\mathbf{h}$ to identify the valid next move $\text{y}_{\texttt{i}}$, eventually forming the correct answer $\mathbf{s}_{\texttt{correct}}=(\text{y}_{\texttt{1}},\text{y}_{\texttt{2}},
\dots,\text{y}_{\texttt{T}})$. The complexity of navigating the answer space can be roughly measured by:

$$ $\frac{\texttt{len}(\mathcal{CR})}{\texttt{len}(\mathcal{S})}\ \ \ \ \ \ |\ \ \ \ \mathrm{p}$ (1) $$

This ratio measures the proportion of the solution space $\mathcal{CR}$ relative to the entire answer space $\mathcal{S}$, given a specific template $\mathrm{p}$. If the chosen template $\mathrm{p}$ extracts irrelevant information—such as determining which player is next at each step—the ratio simplifies to $\frac{\texttt{len}(\mathcal{CR})}{\texttt{len}(\mathcal{S})}$. In this case, each $\text{y}_{\texttt{i}}$ would be generated randomly, as $\mathbf{h}$ can not be computed iteratively over useful information needed for extracting correct $\text{y}_{t}exttt{i}$, making the correct answer only discoverable by chance.

Correctly identifying the step template $\mathrm{p}$ is crucial for reducing the complexity of $\frac{\texttt{len}(\mathcal{CR})}{\texttt{len}(\mathcal{S})}\ |\ \mathrm{p}$, as $\mathrm{p}$ dictates what information is recurrently overlayed in the process $\mathbf{h}_{\texttt{t}}\Rightarrow\mathbf{h}_{\texttt{t+1}}$ and in turn what can be calculated, essentially acting as the “algorithm” for solving tasks in the CoT process. In the chess example, the optimal template would be <extract current board configuration at each step>, allowing the model to reason over the board state iteratively, i.e., $\mathbf{h}_{\texttt{t}}\xRightarrow{\texttt{board state}}\mathbf{h}_{\texttt{t
+1}}$. With the correct board state computed recurrently, the valid next move $\text{y}_{\texttt{t}}$ can be effortlessly derived from $\mathbf{h}_{\texttt{t}}$ (Figure 3 right).
However, using a less relevant template, such as <extract the number of pieces on the board at each step>, would expand the search space nearly to $\frac{\texttt{len}(\mathcal{CR})}{\texttt{len}(\mathcal{S})}$, as the number of pieces doesn’t provide useful information for determining the next valid move. Consequently, the model would have to recalculate the board state at each step from previously generated moves $\text{y}_{\texttt{1
}}$, which requires $O(n)$ depth–Transformers, limited by constant depth, cannot handle. As a result, the next action yt+1 would not benefit from the CoT process.

### 3.3 CoT as an Unsupervised Task Solver

CoT operates in an unsupervised manner for any given task, relying on a single universal prompt, Think Step by Step, and leaving it to the model to generate its own step template $\mathrm{p}\in\mathcal{P}$ for extracting information at each step. Since humans do not supervise step completion, the generation of steps—i.e., determining which information to extract from $\mathbf{h}$ and compute recurrently—comes primarily from the model’s heuristics.
For example, in counting tasks, LLMs use learned heuristics to extract a Counter value from $\mathbf{h}$ and perform recurrent updates. However, these unsupervised, heuristic-driven templates are often unreliable, as the model lacks the knowledge to identify key components for some computation or tasks with complicated descriptions, as demonstrated in previous work Valmeekam et al. () and our experiments.

### 3.4 CoT Variants as Unsupervised Helpers for Navigating Answer Space

In practice, the answer space $\mathcal{S}$ can be large and complex, and even with the optimal step (prompt) template $\mathrm{p}$, CoT can make errors. Various CoT variants, such as Tree-of-Thought (ToT) and Graph-of-Thought (GoT), have been proposed to mitigate these mistakes in solution searching. While these “X-of-thought” approaches don’t dictate which specific information to extract at each step like $\mathrm{p}$ does, they improve solution finding by exploring multiple paths and self-verifying.
For instance, ToT explores multiple instances in the answer space simultaneously under some given template $\mathrm{p}$, unlike the single-path exploration of CoT. Specifically, information extracted from the current hidden state $\mathbf{h}\texttt{t}$ using $\mathrm{p}$ is used to generate q possible answers for the next step, denoted as $(\text{y}^{\texttt{(1)}}_{\texttt{t+1}},\text{y}^{\texttt{(2)}}_{\texttt{t+1}}
,\dots,\text{y}^{\texttt{(q)}}_{\texttt{t+1}})$. Each answer leads to a different next state $\mathbf{h}_{\texttt{t+1}}$.
In the example of <finding a set of actions leading to game end>, the board state at step t is extracted into descriptions using the correct template $\mathrm{p}$ and to form $\mathbf{h}_{\texttt{t+1}}$, and instead of producing a single next move $\text{y}_{\texttt{t+1}}$ from $\mathbf{h}$, multiple actions are derived. Each derived action along with previous actions forms a unique path that leads to a potential solution in $\mathcal{S}$. Since some paths may fail (e.g., leading to a non-ending game), exploring multiple paths simultaneously increases the efficiency of searching the answer space. The visualization is shown in Figure 4.

Figure: Figure 4: ToT mechanism. $\mathbf{h}_{\texttt{t}}$ is transitioned into different $\mathbf{h}_{\texttt{t+1}}$, to explore more in answer space. How state is transitioned is dictated by the step template of CoT, which goes beyond what ToT offers.

Similarly, GoT improves search accuracy by iteratively revisiting previously generated partial answers. However, none of these approaches are supervised, as the model is not informed of the correct step template $\mathrm{p}$ and generates it on its own, extracting information at each step accordingly. X-of-Thought still relies on a “one-prompt-for-all” approach and only aids in finding answers after $\mathrm{p}\in\mathcal{P}$ is fixed. As we have shown, this can lead to poor outcomes, since $\mathrm{p}$ directly influences the complexity of the answer space, and X-of-Thought may be too late to correct errors in some cases.

## 4 Experiments

In this section, we conduct experiments to demonstrate the importance of supervision in the CoT process. Specifically, we design scenarios where the correct step template is provided through supervision, and compare them to cases where incorrect steps are simulated by the model. Our results show significant performance degradation when the step templates are incorrectly derived, highlighting the need for human supervision to ensure reliable task performance with LLMs.

The objective of our experiments is not to evaluate the reasoning performance of different LLMs, but to emphasize the critical role that “supervision” plays in CoT. Comparing the abilities of various models is beyond the scope of this work.

### 4.1 Experiments Designs

Although we used chess simulation as an example of reasoning with CoT due to its resemblance to real-life complex reasoning tasks, tasks involving chess boards and actions can be difficult to implement and evaluate. Instead, we follow previous work Zhang et al. (); Delétang et al. () by focusing on more fundamental reasoning tasks for LLMs. Specifically, we evaluate tasks at three levels of computability: Regular (R), Context-Free (CF), and Context-Sensitive (CS), each corresponding to tasks solvable by different levels of computational power, from deterministic automata all the way to linear bounded automata (restricted Turing machines).
These tasks involve operations such as counting, sorting, and number addition—basic operations that are required by more complex algorithmic problems (like NP problems). Each task has a strong dependency on identifying the correct step template, thus allowing us to clearly observe the impact of selection on step template on CoT performance.

All of these tasks require a level of computability beyond the capabilities of the Transformer’s internal architecture Delétang et al. (). Specifically, they demand a minimum computational depth that scales linearly with input length, surpassing the constant depth inherent to Transformer models. Thus, solving these tasks necessitates the use of CoT, and correctly identifying the information to extract during CoT is crucial for resuming computation and building the necessary depth.

We use GPT-4-o classic, a version that eliminates the use of external tools (e.g., calculators or programs) and functions solely based on the model itself. We test each task using instances sampled according to previous work (Zhang et al., ). To ensure that factors such as long-context information retrieval and tokenization do not affect the results, we follow the setup from prior research and conduct controlled experiments. Details of our experimental design, including length sampling, task specifications, format adjustments, and prompt usage, are provided in the Appendix.

We extend the previous findings on expert models Delétang et al. (), which are specifically trained for particular tasks, to our experiments with LLMs. Due to differences in experimental settings, the results from expert models are presented for reference rather than direct comparison. Unlike prior research, which reports the best performance out of $N$ trials Delétang et al. (); Zhang et al. () for each task instance, we report the average one-trail performance across all tested instances. Our focus is on practical usability beyond the theoretical upper-bound computability analysis in previous work. The final results are shown in Table 1.

Table: Table 1: Main results across three levels of reasoning tasks. For LLMs without CoT, intermediate steps are explicitly prohibited in the prompt. In CoT generation, “CR Supervised” refers to when we provide the correct supervision. “IN Supervised” refers to when seemingly correct but suboptimal step templates are provided, simulating scenarios where the model makes mistakes in navigating the prompt space and derives incorrect step templates. Bolded numbers indicate performance greater than or equal to 0.9, while red indicates low performance (below 0.2). Results for RNN, Tape-RNN and Transformer are trained expert model by previous research (Delétang et al., ), they are solely used for reference and not compared with LLMs as it follows slightly different experiment settings.

**Table 2: Variant of CoT in performing each task. Each task is named using the first two letters in Table 1.**
| Model | R | CF | CS |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| MA | PC | CN | SM | RL | MA | OF | AD | MU | SO |  |
| Unsupervised CoT | 0.96 | 0.94 | 0.78 | 0.92 | 0.80 | 0.82 | 0.80 | 0.84 | 0.14 | 0.36 |
| Unsupervised ToT | 0.92 | 0.90 | 0.92 | 0.36 | 0.88 | 0.78 | 0.82 | 0.94 | 0.18 | 0.66 |
| Unsupervised GoT | 1.00 | 0.98 | 0.90 | 0.72 | 0.92 | 0.88 | 0.82 | 0.92 | 0.20 | 0.80 |
| Correctly supervised CoT | 1.00 | 1.00 | 1.00 | 0.96 | 0.96 | 0.94 | 0.92 | 0.88 | 0.44 | 0.90 |

### 4.2 Main Result

Recurrence is key for reasoning. As demonstrated in both expert models (RNN, Tape-RNN, and Transformers) and LLMs, recurrence is the determining factor for solving tasks in each category. Specifically, expert models like RNN and Tape-RNN show the ability to solve tasks across various categories with over 90% accuracy, depending on their memory architecture. Transformers, however, are limited by their shallow depth of reasoning, as shown earlier, and fail to solve any tasks. Similarly, LLMs without CoT, relying solely on internal Transformer reasoning, achieved $0\%$ performance on most tasks, with low performance on others likely due to guessing. When CoT augments LLMs with recurrent computational power, accuracy improves significantly. These comparisons highlight the critical role of recurrence in a model’s computability, reinforcing the analysis we previously discussed.

Role of Step Template in Reasoning Performance: Supervision Is Essential.
We provide human supervision for all tasks, and we observed that, due to the relatively simple nature of the tasks, the model makes mistakes in finding the optimal step template less frequently. As a result, it is difficult to clearly observe the performance gap between optimal and non-optimal step templates. To address this, we introduce two types of supervision for each task: Correct Supervision (CR Supervised), where the model is guided with optimal steps to demonstrate the best possible performance, and Incorrect Supervision (IN Supervised), which simulates scenarios where the model derives incorrect steps to show how performance can degrade. We present examples of these supervised scenarios for each task in Table 3.

**Table 3: Examples of correct and incorrect steps for performed reasoning tasks.**
| Task | Correct Supervision Example | Incorrect Supervision Example |
| --- | --- | --- |
| Modular Arithmetic | Write down partial sums after each step | Write down paired sums of each two values at each step |
| Parity Check | Write down “even” or “odd” counter after each word in each step | Write down whether the word is a target word at each step |
| Cycle Navigation | Write down which state you are in at each step | Write down the total number of “forward” at each step |
| Stack Manipulation | Write down the resulting stack at each step | Write down the number of operations performed up to that step |
| Reverse List | Write down the partially reversed list after each step from the back | Write down the value to be added to the reversed list and the remaining original list |
| Modular Arithmetic | Write down the formula with reduced values in the performed operations at each step | Write down the result of each performed operation at each step |

From Table 1, we observe that providing supervision yields noticeable improvements over the unsupervised “step-by-step” approach. Specifically, errors caused by the model’s own derived step templates are eliminated with correct supervision, resulting in better performance scores. In contrast, when the step template is intentionally set up incorrectly, we observe a significant performance degradation, with some tasks performing as poorly as they would without using CoT.

To explain this further, when a step template is incorrectly specified (e.g., outputting the sum up to the current step for a task that requires counting appearances), the useful counter information $\mathbf{c}$ in $\mathbf{h}_{\texttt{t}}$ is not extracted. As a result, $\mathbf{c}$ is not carried forward into the next state $\mathbf{h}_{\texttt{t+1}}$, leading to a failure in resuming the necessary calculations. While the wrongly specified information (e.g., the partial sum) is recurrently calculated, it does not lead to the correct final answer for the task.

Figure: Figure 5: Average success rate in deriving correct step template in each level of tasks.
Refer to caption: extracted/5936630/hit_ratio.png

CoT Variants are Useful in Navigating Answer Space.
We compare the results of different CoT variants for the same tasks. As shown in Table 2,
both ToT and GoT improve performance over naive CoT. However, this improvement is due to correcting “incorrect calculations” during computation, not from improvements in step-template selection. ToT provides little benefit, as the tasks typically have only one path to the solution. In contrast, GoT shows greater accuracy gains, thanks to its self-revisiting mechanism,

Prompt Space Analysis. We further analyzed the model’s performance in navigating the prompt space, i.e., finding the correct (optimal) step template for each task. As shown in Figure 5, all tasks involve relatively simple calculations, and the model exhibits a high average success rate in identifying the correct template. Specifically, the success rate for R-type tasks exceeds 90%. As task complexity increases, we observe a slight decline, with CS tasks showing an 84% success rate in extracting the correct information during CoT. We further include case studies showcasing how “sub-optimal” steps are derived from unsupervised CoT process, which are shown in Figure 1 and Appendix Figure 6, 7 and 8.

Lastly, we showcase how incorrect navigation in the prompt space leads to uncorrectable results. As shown in Appendix Figures 9 and 10, the incorrect step template results in incorrect information extraction, leading to a wrongly computed next state and ultimately increasing the difficulty of searching the answer space.

## 5 Supervised CoT: Users’ Perspective

### 5.1 How to Supervise?

As we’ve demonstrated, providing correct supervision is crucial for helping the model achieve accurate results. A natural question arises: how can effective supervision be derived? The key to good supervision lies in understanding CoT’s underlying mechanism, which essentially involves relaying information through the text space. For tasks requiring multiple steps, users need to identify what each step is and what key information should be extracted at each step.

While this might seem straightforward in the basic reasoning tasks used in our experiments, it becomes more complex for challenging tasks, where correctly identifying the information requires careful task analysis. Therefore, human knowledge is critical for enhancing the model’s computational abilities and can directly influence task success. However, this supervision adds a substantial workload, as each task demands a unique understanding of its computational structure.

Again, Supervised CoT requires clearly stating what should be outputted as text at each step, as this information will be used to construct the next $\mathbf{h}$, which we have shown before. Users need to provide as specific instructions as possible to detail what intermediate steps need to be outputted at each ”think-step-by-step” step.

### 5.2 When to Supervise?

As we’ve observed, using an incorrect step template—whether model-derived or human-injected—can result in significant performance degradation. Based on this, it’s important to avoid providing supervision unless you are reasonably confident that the steps will not hinder the reasoning process. In cases of uncertainty, it may be better to rely on the model’s own heuristics.

## 6 Conclusions

Our work offers a unique perspective on the mechanics of Chain of Thought (CoT) prompting and its role in enhancing model reasoning. Through theoretical analysis and practical insights, we show how CoT transforms latent information into text space, enabling iterative and resumable reasoning steps that expand a model’s computational depth.
We further connect the model’s problem-solving capabilities with the complexities of finding solutions. Our analysis of prompt space and answer space underscores the importance of identifying the correct step template to simplify navigation—an often overlooked aspect in prompt-related research. The success of CoT hinges not only on generating steps but on extracting the right information at each stage.
Our experiments demonstrate that incorrect step templates can severely impact reasoning, reinforcing the importance of supervision. Even small errors in template selection can lead to significant failures. Our findings combine theoretical analysis and experimental evidence, offering valuable insights into CoT’s limitations and potential for improving reasoning tasks in large language models.

## Appendix A Appendix

### A.1 Experimental Design

Our experimental setup carefully addresses potential pitfalls that could influence the model’s performance, specifically focusing on tokenization and context length. Tokenization issues can significantly affect how models handle specific tasks, often leading to failures not tied to the model’s reasoning ability. To counter this, we reformatted task instances to eliminate tokenization biases. Moreover, LLMs often struggle with retrieving information from long contexts, leading to hallucinations or forgotten data during extended reasoning processes. This tends to degrade accuracy, as models fail to maintain accurate references to the initial task elements throughout longer sequences. While these challenges are important in real-world applications of LLMs, they are outside the scope of our investigation, which prioritizes analyzing the effect of using different step template.
To maintain a controlled environment, we restrict task lengths from 10 to 20 elements. This threshold was determined from preliminary analysis, where longer task sequences often introduced issues not related to reasoning but to the model’s internal optimization process. When the task sequence exceeds 25 steps, models can divide output over multiple contexts, which distorts accurate information retrieval. By maintaining a manageable length, we isolate and evaluate the differences between reasoning with and without CoT, avoiding disruptions caused by excessive context length. For each task, we generate 50 instances using a pre-written script and the results are examined by humans.

#### Task Design

Each task involves simple rule-based iterations, emphasizing memory access and iterative processes. The challenge for the model lies in its ability to execute these tasks within the constraints of its architecture and memory systems. Below, we describe each task in detail, including sample inputs and outputs.
For the Regular (R) class tasks, we include the following:

- 1.
Modular Arithmetic: Given a sequence of $n$ numbers and basic operations (+, -), compute the result modulo 5. For example, the input $4+2-3$ should yield 3.
- 2.
Parity Check: Determine if the word ”banana” appears an even number of times in a list containing the words ”apple” and ”banana.” For example, the input ("banana", "apple", "banana") yields True.
- 3.
Cycle Navigation: Based on a sequence of actions (”forward,” ”backward,” ”stay”), determine the final position in a 5-state cycle starting from state 1. For example, ("forward", "stay", "backward") will return state 1.

For the Context-Free (CF) class tasks, we use the following:

- 1.
Stack Manipulation: Given a list of fruit names representing a stack and a sequence of stack operations, compute the final stack. For example, applying (pop "banana", push "orange") to ("apple", "banana", "grape") results in ("apple", "orange", "grape").
- 2.
Reverse List: Reverse a list of vegetable names. For example, ("carrot", "potato", "onion") becomes ("onion", "potato", "carrot").
- 3.
Modular Arithmetic (Complex): Compute the result of an arithmetic expression with $n$ operations modulo 5. For instance, $((2+4)\times(3-1))\mod 5$ yields 0.

For the Context-Sensitive (CS) class tasks, we evaluate the following:

- 1.
Odd First: Extract all items at odd positions from a list of animal names, followed by those at even positions. For example, ("dog", "cat", "elephant", "tiger") yields ("dog", "elephant", "cat", "tiger").
- 2.
Addition: Given two large numbers with $n$ digits, calculate their sum. For instance, the input $123456+987654$ yields 1,111,110.
- 3.
Multiplication: Multiply two large numbers with $n$ digits. For instance, the input $345\times 567$ yields 195,615.
- 4.
Sorting: Sort a list of integers using the insertion sort algorithm. For example, the input (8, 3, 5, 1) would result in (1, 3, 5, 8).

Figure: Figure 6: The model-derived template, <extract next move>, is sub-optimal and leads to incorrect results. The resulting partial list is not recurrently generated and computed, and the final list is only generated at the end. Note that the full output is not shown due to its length.
Refer to caption: extracted/5936630/reverse_derived.png

Figure: Figure 7: Model-derived template: <write down each element at next position>, which is sub-optimal and leads to incorrect results. The partial list is not computed recurrently during the step, and the final list is only generated at the end. Note that the full output is not shown due to its length.
Refer to caption: extracted/5936630/oddf_derived.png

Figure: Figure 8: Model-derived template: <extract whether to swap at each step in bubble sort>, which is sub-optimal and leads to incorrect results. The partial sorted list is not computed recurrently. Note that the full output is omitted due to its length.
Refer to caption: extracted/5936630/sort_derived.png

Figure: Figure 9: Case study of performing simple arithmetic under a wrong template (intentionally provided through supervision). Since the cumulative sum is not derived iteratively, the intended value cannot be computed recurrently through CoT, leading to incorrect results. The correct step template for this task should be <write down the calculated total value up to each step>. Note that the full output is omitted due to its length.
Refer to caption: extracted/5936630/wrong_super_arith.png

Figure: Figure 10: Case study of performing stack manipulation under a wrong template, yielding incorrect results (intentionally provided through supervision). Since the stack status is not iteratively updated and passed to the next state, the results cannot be tracked effectively. Tracking the total number of items in the stack is not useful for deriving the final stack. The correct step template for this task should be <write down the current stack status at each step>. Note that the full output is omitted due to its length.
Refer to caption: extracted/5936630/wrong_super_stack.png

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: See Weaknesses Above.
soundness: 2
strengths: The paper effectively addresses the limitations of Transformer-based LLMs in handling complex reasoning tasks, particularly due to computational depth constraints, making a strong case for exploring alternatives like CoT prompting.

By analyzing Transformer limitations and explaining how CoT extends reasoning capabilities, the paper provides a robust theoretical foundation, linking CoT’s potential to overcoming computational constraints.

Introducing task-specific “supervised” CoT as an alternative to the “one-prompt-for-all” method is innovative, aiming to enhance reasoning accuracy and flexibility by tailoring prompts to specific tasks.

The paper’s emphasis on refining prompt design and reasoning strategies to address current gaps in CoT applications highlights its real-world relevance and potential for impactful advancements in LLM reasoning.
summary: This paper examines the limitations of Transformer-based Large Language Models (LLMs) in handling complex reasoning tasks, due to their limited computational depth. Chain of Thought (CoT) prompting, while promising, often applies a "one-prompt-for-all" approach across diverse tasks, which can hinder the model’s ability to generate accurate reasoning steps. The authors build on theoretical analyses of CoT, proposing that task-specific supervision is necessary to effectively navigate the prompt space and enhance reasoning accuracy. Through experiments, they demonstrate that supervised CoT—enriched with human guidance—improves performance over unsupervised prompting, advocating for a more tailored approach to maximize LLMs’ reasoning capabilities.
weaknesses: While the theoretical foundation of CoT and supervised prompting is well-explained, there is little mention of extensive empirical results to support the effectiveness of the proposed supervised CoT approach. Without comprehensive experiments, the practical impact and robustness of the approach may be less convincing.

The introduction is densely packed with technical details and may be challenging for readers unfamiliar with computational depth limitations and CoT theory. Simplifying or clarifying certain concepts could improve accessibility for a broader audience.

Although task-specific “supervised” CoT is presented as an improvement over unsupervised CoT, it requires additional human guidance, which may limit scalability and applicability in cases where expert supervision is costly or unavailable.

The paper could be strengthened by comparing supervised CoT with other advanced prompting or finetuning techniques that address reasoning depth or diversity. This would contextualize the performance of supervised CoT against other methods and provide clearer insights into its unique benefits and trade-offs.

More importantly, the presentation and readability of this paper may be far below what ICLR requires. For instance, every figure in this paper is extremely blurry and poorly designed.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: **L280**: Why does the answer space in chess have infinite cardinality? The number of answers is bounded, so it should not be infinite.

**L306**: "would expand the search space nearly to len(CR)/len(S) , as the number of pieces doesn’t provide useful information for determining the next valid move. Could the authors clarify their definition of "useful" information? For example, if only two kings remain, it’s clear that the game is over.

**Table 2**: could you clarify (average) number of output tokens (steps) taken for each technique
soundness: 3
strengths: The authors address an important shortcoming of Transformers: unlike recurrent networks, they are not able to perform reasoning over an arbitrary number of sequential steps (depth). Since the number of sequential steps in transformers is fixed and limited by the number of layers, CoT provides a discretized approach to adding a hidden state in autoregressive transformers at each step. The authors then formulate CoT reasoning into 'prompt space' and 'answer space' and demonstrate the complexity of prompt space C(m,s) as a function of information (m bits) in hidden state h and information (s bits) in CoT step distcretized into token
The authors further show the relationship between the solution space CR and the entire answer space S, given a specific template p. They argue that selecting an appropriate prompt p (from the prompt space) is crucial for reducing the complexity of the answer space. Based on this argument, the authors contend that unsupervised CoT relies on heuristic-driven templates in the prompt space, which are often unreliable and result in a low chance of reaching the correct solution. To address this challenge, they propose using supervision to sample more informative prompt templates p from the prompt space, increasing the likelihood of discovering the correct solution in the answer space.
summary: This paper addresses an existing shortcoming in Chain-of-Thought (CoT) prompting, where a "one-prompt-for-all" approach is leveraged to generate reasoning steps. Previous research has shown that the transformer architecture has computational limitations in performing sequential computation. CoT has helped mitigate the "constant depth" limitation of transformers' internal reasoning.
The authors explain that all existing variants of "Chain-of-Thought" (such as vanilla chain of thought, Tree of Thought, and Graph of Thought) are unsupervised, meaning that the model generates its step template without task-specific supervision from humans. The unsupervised nature of these "X-of-Thought" methods results in underperformance. The authors reformulate the problem into "prompt space" and "answer space" and demonstrate how task-specific supervision is essential for accurately navigating the prompt space, simplifying the answer space, and achieving optimal performance. Through experiments with state-of-the-art LLMs, the authors reveal a significant gap in reasoning performance when supervision is applied versus when it is not.
They use GPT-4 to show how supervised CoT can significantly improve model performance across various tasks (such as sorting and parity checking) and can match the performance of RNNs and Tape-RNNs, which inherently solve tasks requiring deeper reasoning through their hidden states.
weaknesses: * **Unclear Focus on Discovery vs. Throughput**: While the paper's motivation is reasonable, it is unclear whether the authors aim to increase the chance of discovering the correct solution or the model's throughput (e.g., number of output tokens) by selecting the right prompt from the prompt space. In some examples, such as BFS versus DFS, different path lengths (number of output tokens) result in correct answers, but this is not clearly addressed.
* **Questionable Claim on Heuristic-Driven Templates**: The authors argue that prompt templates in unsupervised CoT come from heuristics. However, CoT often includes few-shot examples, so it is unclear why the authors believe the templates are heuristic-based rather than a result of the model’s generalization capabilities from the examples.
* **Lack of Clarity on Supervised Step Template Methodology**: It is unclear what techniques the authors use to provide "correct step templates" through supervision. They do not explain how these templates are validated (e.g., prompt engineering on a validation set) or why a language model cannot deduce the step template from a few-shot example.
* **Lack of Practical Framework**: The authors argue that selecting the correct "step template" (e.g., "Write down partial sums after each step") becomes more complex for challenging tasks. However, they don’t provide any systematic framework for discovering the correct prompt template beyond prompt engineering, which limits the paper’s practicality.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: 1. Autoregressive models can also rely on large context windows, and in fact the vast majority of inference processes in LLM have intermediate steps that do not exceed the context window. So why do recurrent and autoregressive models differ in this paradigm when the only difference between them is implicit and explicit hidden state transfer?

2. Can the performance of LLM be improved by fine-tuning it for the dataset used?

3. Is it possible to give an automated, generalized supervision design methodology based on the described analysis of unsupervised CoT？
soundness: 3
strengths: 1. The paper is well-structured, with clear explanations of core concepts such as prompt space and answer space, and the step-by-step breakdown of task examples provides a clear understanding of the benefits of CoT. 
2. While CoT itself is an established technique, this work takes a novel approach by critically analyzing the limitations of traditional, unsupervised CoT.
summary: This paper explores the concept of Chain of Thought in Large Language Models and emphasizes the importance of supervision for optimal reasoning performance. The Transformer-based architecture of most LLMs faces depth limitations, making it difficult to handle complex reasoning tasks. CoT has emerged as a strategy to overcome these limitations by guiding models through intermediate reasoning steps. However, conventional "unsupervised" CoT, where a single, generalized prompt is used, struggles with accuracy across varied tasks because it lacks tailored guidance for each task. The authors argue that dividing CoT into "prompt space" (step template selection) and "answer space" (iterative solution process) reveals the need for supervised CoT, where human-provided task-specific prompts significantly improve reasoning accuracy. The findings advocate for a more interactive CoT approach that requires human involvement in guiding complex tasks, providing insights into more effective CoT designs for improved reasoning depth and reliability in LLMs.
weaknesses: 1. Although this paper discusses the importance of supervised CoT, this supervision is in the form of case-by-case human feedback. This paper does not draw a conclusion on how to make supervision based on the proposed theory.  While the paper demonstrates that task-specific supervision improves reasoning, it does not discuss the feasibility or cost of providing this supervision at scale. Implementing supervised CoT across various applications would likely demand substantial domain expertise and time. 

2. The explanation of recurrent and autoregressive learning in section II of the article does not correspond to reality. In fact, the hidden state of models such as Transformer moves over the sequence in time in the form of a KV cache. Although I can understand that this form of hidden state is not reflective of global information with a limited context window, and that information beyond the window requires a memory to represent it. However the way the understanding is presented in the paper may be not a good reflection of the real cases.

3. The experiments focus on straightforward tasks, which limits the generalizability of the findings. Including more complex tasks with multi-step dependencies and nuanced, open-ended reasoning would strengthen the evidence for supervised CoT's broader applicability.

---

confidence: 3
contribution: 1
initial_rating: 1
presentation: 2
questions: Please refer to weaknesses
soundness: 1
strengths: - The authors provide a comprehensive summary of previous works which aim to understand the mechanism of CoT reasoning
- The authors offer an interesting perspective on the role of CoT prompts
summary: The authors pose existing CoT prompting methods as an "unsupervised" method for reasoning in LLMs, and suggest that task-specific "supervision", i.e., CoT prompts that inform the model how to solve the given task, can enable more effective reasoning in LLMs.

The paper summarizes existing works on understanding CoT reasoning, some of which interpret LLMs equipped with CoT as recurrent networks, in which the hidden states are intermediately represented as a series of discrete states, i.e., reasoning tokens. Based on this formulation, the authors analyze the CoT search space in terms of the "prompt space" and "answer space". The authors suggest that standard CoT prompting relies on the model itself to navigate the prompt and answer space, with previous X-of-thought methods being unsupervised "helpers" to navigate the prompt space. The authors suggest that "supervised CoT", or prompts that outline the correct steps required to solved the task, can inform the model of the correct "prompt template" within the prompt space.

The authors evaluate task-specific RNNs and transformers, as well as LLMs with unsupervised and supervised CoT prompts (crafted by the authors) under three classes of tasks: regular (R), context-free (CF), and context-sensitive (CS). While task-specific models can solve all classes of tasks reliably, vanilla LLMs suffer in CF and CS. Unsupervised CoT improves performance but shows limitations in CS. Supervised CoT solves this limitation, and while incorrect supervision (misleading prompts) degrades performance.

Based on this, the authors conclude that recursion and "supervision" of the prompt space is essential for reasoning performance.
weaknesses: - **The conclusions are already well-established**: It is widely recognized that LLM task performance varies based on the given prompt, a fact that has driven the growth of prompt engineering as a specialized field. Similarly, it is not surprising that LLMs can demonstrate improved reasoning abilities when guided by prompts with structured reasoning steps.

- **Theoretical analysis offers limited insights and could benefit from further rigor**: The theoretical analysis in Section 3 provides an interesting analogy on the mechanism of CoT reasoning. However, some definitions and assumptions could be more precisely defined, and there is limited mathematical derivation that leads to meaningful conclusions. The main takeaway seems to be that both the prompt space (approach to the problem) and the answer space (execution of reasoning steps) are large. While this may serve as the motivation for the experiments, it does not provide theoretical support for its conclusions. Valid theoretical justification for a well-known phenomenon can be a meaningful conclusion, but further development of the analysis would be needed to provide such justification in this case.

*This section was written by the reviewer, re-worded using ChatGPT, and manually checked by the reviewer.*