An Examination on the Effectiveness of Divide-and-Conquer Prompting in Large Language Models

## Abstract

Abstract Foundation models, such as Large language Models (LLMs), have attracted significant amount of interest due to their large number of applications. However, when handling tasks involving repetitive sub-tasks and/or deceptive contents, such as arithmetic calculation and article-level fake news detection, simple instructional prompts suffer from inaccurate responses. Existing works show that more complicated prompting strategies, such as Chain-of-Thoughts and Least-to-Most, can unlock LLM’s powerful capacity in diverse areas. Recent researches reveal that simple divide-and-conquer prompting strategy, i.e. simply dividing the input sequence to multiple sub-inputs, can also substantially improve LLM’s performance in some specific tasks such as misinformation detection.
In this paper, we aim at examining the utility of divide-and-conquer prompting strategy and answer on which kind of tasks this strategy gets advantages. Specifically, we provide a theoretic analysis to divide-and-conquer prompting strategy and help us identify the specific tasks where DaC prompting can bring performance boost with theoretic guarantee.
We then present two cases ( large integer arithmetic and fact verification ) where experimental results aligns with our theoretic analysis.

## 1 Introduction

Large language models (LLM) based on the Transformer architecture have led to major breakthroughs in natural language processing and other related fields in artificial intelligence(Brown et al., ; ; Touvron et al., ). State-of-the-art general-purpose language models have demonstrated remarkable advancements in various domains, including question answering, graph learning, reading comprehension, text generation, and machine translation (Chen et al., ; Tan et al., ; Hendy et al., ; Mao et al., ; Zong and Krishnamachari, ). These developments paves the way towards general-purpose problem solvers (Bubeck et al., ).

However, as pointed out in (Wei et al., ), significant challenges arise when scale-up models are applied to tasks involved with long solution paths, such as those requiring mathematical or knowledge reasoning. A series theoretic works attribute this challenge to Parallelism Tradeoff (Merrill and Sabharwal, ), a fundamental limitation of Transformers. Specifically, unlike Recurrent Neural Network whose computational depth is linear to the input sequence length (i.e., the depth is $O(n)$, where $n$ is the input sequence length), Transformer does not contain any recurrent structure. Such design, while achieving superior parallelizability than RNN, makes Transformers suffer from limited expressive power. proved that the expressive power of fixed-depth log-precision Transformer, which is very close to the most commonly applied Transformer architecture for LLMs, is bounded by constant-depth logspace-uniform threshold circuits. Thus, they fail to accurately tackle the tasks requiring long solution paths.

Figure: Figure 1: An illustrative example of hallucination detection with entangled problem solving (i.e., directly forward all inputs into the LLM) and divide-and-conquer problem solving (i.e., divide the problem inputs to parallel sub-tasks and tackle them parallelly). The sentence marked with red back font in the material is the evidence that contradict with the first claim in summary (marked with red font).
Refer to caption: x1.png

To address this challenge, carefully designed prompting strategies have been developed to tackle tasks that requires stronger expressive power (Feng et al., ). A series of works focus on prompting the LLM with instructions or context samples to output the intermediate steps that derive the final answer in an autoregressive manner, such as Chain-of-Thoughts (CoT) (Wei et al., ; Wang et al., ; Zhou et al., ; Chen et al., ). Some works further apply programs to guide LLM to strictly follow designated reasoning steps (Yao et al., ). Theoretically, these prompting strategies convert the role of Transformer from the complete problem solver to a sub-problem solver in a dynamic programming or tree searching algorithm (Merrill and Sabharwal, ). In this way, these prompting strategies expand the expressive power of the LLMs and successfully improve the reasoning and searching of LLMs (Feng et al., ).

In contrast to such methods that apply instruction, context sample or program to decompose the whole reasoning process to multiple intermediate steps, in some tasks, researchers report that LLM’s performance can also be boosted by simply dividing the input sequences to multiple sub-inputs and then merge the responses from LLMs on all sub-inputs, as shown in Fig. 1. For example, propose that in automated evaluation, LLM’s performance can be further boosted by first dividing the input text to sentences and then evaluating them one by one.
Intuitively, this paradigm benefits the tasks in a way similar to human brains, especially when the tasks are too hard or too complex. For example, when reviewing a long academic paper, some reviewers produce low-quality reviews (Garcia et al., ; Tennant and Ross-Hellauer, ; Cortes and Lawrence, ) containing hallucination-like intermediate errors, such as pointing out some ‘missing baselines’ that have already been sufficiently discussed by authors. To avoid such mistakes, experienced reviewers usually think slowly (Kahneman, ) to follow a Divide-and-Conquer paradigm to handle this task. Specifically, they decompose the paper review as examinations of multiple central opinions and then retrieve corpus to verify them respectively.

However, unlike Chain-of-Thoughts whose advance in expressive power is supported by theoretic analysis (Feng et al., ), the performance boost from Divide-and-Conquer paradigm is lack of rigorous theoretic support. As a result, we are not aware of the conditions under which the Divide-and-Conquer paradigm can acquire more accurate answers. To tackle this challenge, in this paper, we aim at understanding the utility of DaC prompting. More specifically, we attempt to answer the following two research questions:

- 1.
RQ1: Compared to straightforward instructional prompting, does DaC have theoretically guaranteed advantages similar as CoT and its variants?
- 2.
RQ2: Compared CoT and its variants, what utility and limitations does DaC have?

To answer these questions, we first provide a theoretic paradigm that can help us analyze how divide-and-conquer strategy expand the expressive power of fixed-depth log-precision Transformer on a given task. In this way, we provide a framework that can provide theoretic guarantee to DaC paradigm in various tasks. In this way, we present some conditions under which DaC have advantages compared to other prompting strategies.
We then empirically evaluate DaC prompting and representative baselines on tasks that satisfy the proposed conditions and are challenging to existing prompting strategies even on state-of-the-art LLMs: Large Integer Multiplication, Hallucination Detection, Article-level Fact Verification (Cheng and Zhang, ; Li et al., ; Wadden et al., ; Hu et al., ; Wu et al., ). These tasks either require very long reasoning paths (e.g. large integer multiplication) or contain deceptive contents (e.g. hallucination detection and fact verification), making existing methods like Chain-of-Thought prompting prone to intermediate errors. Our experimental results show that the proposed method outperforms the baselines on all three tasks, which supports our theoretic analysis.

Figure: Figure 2: The comparison between DaC and the existing methods for prompting. The ellipse marks represent sub-tasks, the right-angled rectangles represent sub-task solutions, and the rounded rectangles represent intermediate steps that entangle sub-task and sub-solutions. The different shades in Tree of Thoughts (subfigure D) indicate the rates of different search directions. In CoT (Chain-of-Thoughts), CoT-SC and ToT, the Large Language Models must simultaneously generating and resolving sub-tasks. Least-to-Most (also Decomposed Prompting) disentangle sub-task generation and resolution. However, its sub-task resolution and resolution assembly process are intertwined as it sequentially attach new sub-tasks onto the previous resolution. Different from them, DaC totally disentangle the sub-task generation, sub-task resolution, and resolution assembly process.
Refer to caption: extracted/5706320/Thoughts.jpg

## 2 Related Work

### 2.1 Expressive Power of Transformer

As discussed in previous works (Merrill and Sabharwal, ; Feng et al., ), the expressive power of fixed-length log-precision transformers, which are widely applied in modern Pre-trained Large Language Models, is actually much more limited than people’s expects. give a theoretic proof that the expressive power of fixed-length log-precision transformers is upper-bounded with ${\sf TC^{0}}$.
further extend their analysis to explain that a lot of common problems exceed the expressive power of fixed-length log-precision transformers. Such results explains why the powerful LLM may make some ridiculous mistakes and how CoT improve the performance.

### 2.2 Prompting Strategies of LLM

In this sub-section, we introduce the existing prompting and discuss their limitations and drawbacks. Following the notations in (Yao et al., ), we denote the Large Language Models with parameter $\theta$ as $p_{\theta}$ and use lower case letters $x,y,z$ to denote input sequence, result, and intermediate steps, respectively.

Input-Output (IO) Prompting is the standard prompting strategy that attach input $x$ with instructions and/or few-shot in-context-learning examples to aqcuaire a prompt, denoted as ${\sf prompt}(x)$ (Yao et al., ). The LLM takes ${\sf prompt}(x)$ as input and predict result, i.e. $y\sim p_{\theta}(y|{\sf prompt}(x))$.

Chain-of-Thought (CoT) Prompting (Wei et al., ) aims at simulating human’s thinking process that handles complicated task (e.g. combinational reasoning and mathematical calculation) in a step-by-step manner. More specifically, the LLM is guided to output a series of intermediate steps $z_{1},z_{2},...,z_{n}$ (also known as thoughts) autoregressively, i.e. $z_{i}\sim p_{\theta}(z_{i}|{\sf prompt}(x),z_{1},...,z_{i-1})$. Then the LLM output the prediction of result $y$ based on the thoughts, i.e. $y\sim p_{\theta}(z_{i}|{\sf prompt}(x),z_{1},...,z_{n})$.

Exploration-of-Thought (EoT) Prompting and Program-guided Prompting are two variants of CoT. EoT includes a series of CoT’s variants, such as Self-consistency with CoT (CoT-SC) prompting (Wang et al., ) and Tree-of-Thoughts (ToT) prompting (Yao et al., ), which aim at addressing the limitation of CoT in exploration. Their common central idea is to generate multiple chains of thought through sampling or proposing prompting and then ensemble them to acquire a final prediction.
Program-guided Prompting aims at controlling the LLM’s generation process with symbolic programs or pre-defined procedure (Zhu et al., ; Jung et al., ; Zhou et al., ; Khot et al., ; Creswell and Shanahan, ; Gao et al., ). Among them, the Least-to-Most (LtM) Prompting (Zhou et al., ) and Decomposed Prompting (Khot et al., ) are close to this work. They are the earliest attempts that explicitly prompt the LLM to decompose the task as a series of sub-tasks and sequentially tackle them. LtM prompt a LLM to iteratively raise sub-tasks and sequentially solve them to acquire the final resolution. Decomposed Prompting can regarded as a upgraded version of LtM. It introduces special notations into the prompt to represent program states and thus can call itself (i.e., recursion) or other modules (i.e., hierarchical decomposition), endowing it stronger expressive power. Such design increased the compositional generalization ability of LLMs in different areas, such as symbolic manipulation and multi-hop QA (Khot et al., ).

The aforementioned CoT and EoT families incorporate LLM with stronger expressive power than IO prompting. However, a critical issue of them is that, they could miss or ignore some important intermediate steps or contents (Liu et al., ).
This problem is even worse when we are handling tasks involved with long input (e.g. long documents and large numbers).
Typical examples include large number arithmetic calculation and fact verification in long documents. Compared to them, Least-to-Most prompting and Decomposed Prompting introduce explicit task decomposition to enumerate sub-tasks. However, their task decomposers are based on multi-round conversation or question-answering, which navigate the LLM through the deceptive content’s flow sequentially, and propagate the hallucination/deception in the contexts (Dziri et al., ; Yang and Ettinger, ), leading to decreased performance.

## 3 Preliminary of Divide-and-Conquer Prompting

In this section, we summarize and formalize Divide-and-Conquer prompting strategy. Divide-and-Conquer prompting strategy consists of three distinct stages: task decomposition stage, sub-task resolution stage, solution merge stage. In task decomposition stage, the LLM is prompted to explicitly decompose the task as a series of parallel homogeneous sub-tasks with smaller problem sizes (e.g. divide a long paragraph to sentences). Such design avoids the multi-round conversation or question-answering in LtM and Decomposed Prompting, making the model less prone to deception. After that, in sub-task resolution stage, the LLM is prompted to provide the solutions for every sub-task. Finally, in the solution merge stage, the LLM is prompted to assembly the solutions of subtasks and acquire the final answer.
To tackle tasks of different sizes, Divide-and-Conquer prompting strategy can be divided to two variants: Single-Level DaC Solver and Multi-Level DaC Solver.

Figure: Algorithm 1 Single-Level Divide-and-Conquer Solver $T(S,a,t,L,f)$

Single-level Divide-and-Conquer Solver decomposes the task in one call to the LLM, which expands the original task as a tree of one level. The algorithm is presented in the Alg. 1. The advantage of this variant is its simplicity and efficiency.
However, when the original input is too long, single-level Divide-and-Conquer Solver may acquire sub-tasks with large problem sizes that will still trigger intermediate errors. In such a case, following (Khot et al., ), we can recursively expand the task as a multi-level tree. More specifically, we repeat the aforementioned steps to further divide the sub-tasks hierarchically until they are easy enough to be handled by the LLM. This can be done through a recursion program as presented in Alg. 2. More discussions on the proposed method’s appliance scope, including its comparison with other prompting strategies and limitations, can be found in A.1

Figure: Algorithm 2 Multi-Level Divide-and-Conquer Solver Recursion $T(S,m,t,d,f,n,L)$

## 4 Main Theoretic Results

In this section, we provide theoretic analysis to the utility and limitations of the Divide-and-Conquer prompting. In the first subsection, we provide a comparison of IO prompting (common fixed-length instructional prompting) and DaC prompting in expressive power perspective. This part answers the first research question: the expressive power of IO prompting is a subset of DaC prompting.
In the second subsection, we provide a comparison between Chain-of-Thoughts and DaC prompting in expressive power. Our comparison suggests that, although the expressive power of DaC prompting is a subset of Chain-of-Thoughts, for tasks satisfying specific conditions, DaC prompting can solve the problem with lower average context window length when decoding the tokens. Such property is empirically proved to be helpful for reducing the intermediate error and thus boost the performance.

### 4.1 Divide-and-Conquer vs. IO Prompting

We show that the expressive power of Divide-and-Conquer is stronger than IO Prompting:

###### Theorem 4.1 .

We denote the set of problems that a fixed-precision transformer with fixed-length IO prompting can tackle as $S(IO)$. Similarly, we denote the set of problems that a fixed-precision transformer with DaC prompting can tackle as $S(DaC)$. Then we have the following results:

$$ $S(IO)\subset{\sf TC^{0}}\subseteq{\sf NC^{1}}\subseteq S(DaC)$ (1) $$

Proof Sketch: The conclusion that $S(IO)\subset{\sf TC^{0}}$ is a corollary of the main results in (Chiang et al., ). In this paper, we mainly focus on proving ${\sf NC^{1}}\subseteq S(DaC)$. Specifically, we exploit 2-color Binary Subtree Isomorphism (2-BSI) problem for the proof. In (Jenner et al., ), 2-BSI problem is proved to be an ${\sf NC^{1}}$-complete problem.
Its definition is:

###### Definition 1 .

2-color Binary Subtree Isomorphism problem is that, given a pattern 2-color
binary tree $t_{p}$ and a base 2-color binary tree $t_{b}$, a solver is required to judge whether the pattern tree is isomorphic to a sub-tree of $t_{b}$

In (Jenner et al., ), the authors pointed out that the encoding of the problem will influence the hardness of the problem. In this paper, we focus on pointer list encoding of 2-BSI. Detailed information about the pointer list encoding of 2-BSI can be found in Appendix. For pointer list encoding of 2-BSI, we have the following theorem:

###### Theorem 4.2 .

There exists a log-precision transformer with fixed depth $L$ and hidden dimension $d$ that can solve the 2-BSI of any size with fixed-length prompt $m$ (for merge), $t$ (for sub-task tackling) and $d$ (for task decomposition).

Proof Sketch: The detailed proof is provided in the Appendix A.2. Here we give a brief flow of the proof. To prove this theorem, we first show an algorithm that can solve the problem with divide-and-conquer strategy. Then we prove that there exists a log-precision transformer with fixed depth $L$ and hidden dimension $d$ that can express the modules in the algorithms with different but fixed-length prompts. In this way, we can prove the theorem.

With the above theorem, we can prove that ${\sf NC^{1}}\subseteq S(DaC)$, which finishes the proof. With this theoretic results, we can answer the RQ 1:

Compared to IO prompting, DaC have theoretically guaranteed advantages in expressive power.

###### Theorem 4.1 .

###### Definition 1 .

###### Theorem 4.2 .

### 4.2 DaC vs. CoT

In this section, we compare Divide-and-Conquer with Chain-of-Thoughts in order to understand the utility and limitation of DaC prompting. The limitation of DaC prompting is that its expressive power is a subset of CoT prompting:

###### Proposition 4.3 .

We denote the set of problems that a fixed-precision transformer with DaC prompting can tackle as $S(DaC)$. Similarly, we denote the set of problems that a fixed-precision transformer with CoT prompting can tackle as $S(CoT)$ Then we have the following results:

$$ $S(DaC)\subseteq S(CoT)$ (2) $$

###### Proof.

The proof of this proposition is very straightforward. For any problem that DaC can solve, we can concatenate all outputs of LLM in dividing, tackling and merging as a sequence. Then we can prompt LLM with CoT to output this sequence. Thus, the problem set that DaC can resolve is a subset of CoT.
∎

The limitation revealed by the above theorem shows that compared to CoT, the appliance scope of Divide-and-Conquer is limited. However, by analyzing the average decoding context window size, we show that on specific tasks, divide and conquer can reduce the problem complexity:

###### Definition 2 .

Decoding Context Window Size: In auto-regressive decoding, each token is decoded from a window that covers all previous tokens. We denote the length of the window as the Decoding Context Window Size of the token.

###### Proposition 4.4 .

Suppose that a task contains $k$ sub-tasks, each of which does not rely on the answers of other sub-tasks. We define such sub-tasks as parallel sub-tasks. If an LLM tackle these sub-tasks sequentially with CoT, then the average decoding context window size of the sub-tasks’ resolution will be $C+\frac{\sum_{i=1}^{k}r_{i}-1}{2}$, where $r_{i}$ is the length of the response to the $i$-th sub-task and $C$ is the length of input context. If we tackle them parallely with DaC, then the average decoding context window size of the sub-tasks’ resolution will be $C+\sum_{i=1}^{k}\frac{(r_{i}-1)^{2}}{2\sum_{j=1}^{k}r_{j}}<C+\frac{\sum_{i=1}^
{k}r_{i}-1}{2}$.

The above proposition shows that when task contains a large amount of parallel sub-tasks, DaC is more helpful for reducing the average decoding context window size than CoT. Existing works have empirically showed that long decoding context window will propagate intermediate errors and thus increase the probability of generating hallucination (Yang and Ettinger, ). Thus, we can acquire a conclusion that DaC is competetive on tasks that contain a large amount of parallel sub-tasks and are bothered by intermediate errors and hallucination. With these theoretic results, we can answer the RQ 2:

Compared to CoT and its variants, DaC prompting’s expressive power is weaker. However, on tasks containing a large amount of parallel sub-tasks, DaC is more helpful.

###### Proposition 4.3 .

###### Proof.

###### Definition 2 .

###### Proposition 4.4 .

### 4.3 Advantages of DaC

The above analysis answer the two research questions that we proposed. By summarizing these two answers, we can acquire the two conditions such that when a task simultaneously satisfied both conditions, DaC bring performance boost:

- •
Condition 1: the task is harder than $S(IO)$, such as ${\sf TC^{0}}$-complete problems and ${\sf NC^{1}}$-complete problems.
- •
Condition 2: the task contains a large amount of parallel sub-tasks and is bothered by hallucinations or intermediate errors.

In Tab. 1, we present some sample tasks that satisfied the conditions. Also, we list some tasks that typically do not satisfy the conditions. This is helpful for guiding prompt engineering. Details are provided in Appendix A.6.

**Table 1: We list some exaple tasks that satisfy the conditions and some tasks that do not satisfy the conditions.**
| Applicable Tasks | Non-Applicable Tasks |
| --- | --- |
| Integer Multiplication | Integer Addition |
| Fact Verification | Multi-round QA |
| Consistency Evaluation | Planning |

## 5 Experiments

### 5.1 Case 1: Long Integer Arithmetic

In this case, we consider two tasks in long integer arithmetic: Multiplication, which satisfy the conditions we proposed, and Addition, which does not satisfy the first condition (^1^11Multiplication is a ${\sf TC^{0}}$-complete problem and can be divided to multiple parallel sub-tasks, while Addition is in $S(IO)$Barcelo et al. ()). Our experiment results will show that DaC prompting bring performance boost on multiplication and does not bring boost on integer addition.

Figure: Figure 3: Edit distance of DaC and baseline prompting strategies on GPT-3.5 and GPT-4 for Multiplication.
Refer to caption: x2.png

Figure: Figure 4: Edit distance of DaC and baseline prompting strategies on GPT-3.5 and GPT-4 for Addition.
Refer to caption: x3.png

**Table 2: Performance of different prompting methods on HaluEval dataset.**
| Strategies | GPT-3.5-Turbo | GPT-4 |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| F1 | Acc | Prec | Recall | F1 | Acc | Prec | Recall |  |
| IO-prompting | 61.69 | 61.27 | 62.11 | 61.28 | 64.07 | 72.66 | 93.41 | 48.76 |
| Chain-of-Thoughts | 46.85 | 64.26 | 91.36 | 31.50 | 71.05 | 76.10 | 90.08 | 58.66 |
| CoT-SC | 47.70 | 64.25 | 88.83 | 32.60 | 71.39 | 76.36 | 90.41 | 58.98 |
| Tree-of-Thoughts | 70.40 | 59.91 | 55.83 | 95.34 | 69.41 | 71.73 | 75.53 | 64.28 |
| Least-to-Most | 56.43 | 64.91 | 74.42 | 45.44 | 72.51 | 77.11 | 90.74 | 60.38 |
| Divide-and-Conquer | 74.84 | 75.55 | 77.41 | 72.03 | 76.92 | 78.99 | 85.36 | 70.01 |

Setup of baselines and DaC: In this task, our baselines include IO prompting, Chain of Thought (CoT), CoT-SC, Least-to-Most (LtM), and Decomposed Prompting (DeP).
Tree-of-Thoughts is not applicable. This is because that multiplication is deterministic calculation without requiring search in a tree. For DaC, we apply Multi-Level Divide-and-Conquer program-guided solver.

Results: Experimental results are shown in Fig. 3 and 4. As we can see, for integer addition which does not satisfy our proposed conditions, the performance of DaC, CoT and its variants does not significantly outperform IO prompting for both ChatGPT-3.5 and 4. However, for integer multiplication which satisfy our proposed conditions, under all settings, our proposed prompting strategy outperform all the baselines. This phenomenon indicate that our proposed conditions are useful for recognizing the tasks where DaC is more powerful.

### 5.2 Case 2: Fact Verification of Long Text

In the previous section, we show that for arithmetic tasks, our proposed conditions are discerning to the tasks where divide-and-conquer has advantages.
In this section, we further present our conditions can be applied to natural language tasks. Specifically, we present the performance of baselines and Divide-and-Conquer on fact verification of long text. In this task, the LLM is required to whether a long corpus is aligned with base knowledge. This task satisfied the proposed two conditions. For the first condition, we can reduce a 2-BTI problem to fact verification by describing the two trees with natural language. In this way, we can convert the trees to two paragraphs and what we need to do is to ask the LLM to judge whether the two paragraphs are aligned or not. For the second condition, since we are tackling long text, then each sentence can be regarded as parallel sub-tasks. We select two benchmarks of fact verification: Fact-Verification for Hallucination Detection and Fact-Verification for Misinformation Detection

#### 5.2.1 Hallucination Detection

Although Large Language Models have achieved impressive performance on various NLP tasks, they are bothered by hallucination problem (Manakul et al., ), especially when the generated content or the input context is too long for the user to have a thoroughly review (Zhang et al., ). In this paper, we focus on evaluating the performance of different strategies in guiding LLM to recognize inconsistency between given context and model response with hallucination.

**Table 3: Performance of different prompting methods on SciFact dataset.**
| Strategies | GPT-3.5-Turbo | GPT-4 |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| F1 | G-M | Prec | Recall | F1 | G-M | Prec | Recall |  |
| Io-Prompting | 72.12 | 72.77 | 83.22 | 63.64 | 69.15 | 71.77 | 94.44 | 54.55 |
| Chain-of-Thoughts | 56.09 | 60.64 | 90.48 | 40.64 | 74.03 | 75.79 | 94.21 | 60.96 |
| CoT-SC | 56.83 | 61.44 | 91.67 | 41.18 | 70.09 | 73.45 | 100.0 | 53.95 |
| Tree-of-Thoughts | 69.91 | 73.30 | 53.74 | 100.0 | 77.34 | 78.00 | 88.89 | 68.45 |
| Least-to-Most | 54.08 | 54.15 | 51.46 | 56.99 | 73.56 | 74.25 | 85.21 | 64.71 |
| Divide-and-Conquer | 76.88 | 77.13 | 83.65 | 71.12 | 81.11 | 81.24 | 76.67 | 86.10 |

Task Setup: We use the HaluEval-Summary dataset. It is one of the three datasets in HaluEval benchmark for hallucination detection, which contains the hallucination generated by ChatGPT-3.5. HaluEval-Summary have the longest context and generated contents among all three tasks in this benchmark (Li et al., ). Thus, detecting hallucination on this dataset requires repeatedly verify each sentence in the response, making standard prompting strategies acquire the worst accuracy across all three tasks. We report the Accuracy, F1 score (the hallucination pairs are positive samples), Precision and Recall.

Setup of baselines, ablation variants and DaC: In this task, our baselines include IO prompting, Chain of Thought, CoT-SC, Tree-of-Thoughts Least-to-Most, and Decomposed Prompting.
In this task, the sub-tasks are verifying fragments of the summary, which are homogeneous and do not require recurssion. In such a setting, Decomposed Prompting is equivalent to LtM. For this task, we apply single level Divide-and-Conquer solver to decompose the summary to multiple sentences, handle them separately and then merge the conclusions of all sentences. The details are in Appendix.

Results: Experimental results are shown in Tab. 2.
For both GPT-3.5 and GPT-4, our proposed prompting strategy outperform the baselines, presenting the advantage of DaC. More specifically, compared to IO-prompting, DaC achieved better performance in general, indicating the advantage brought by stronger expressive power. Meanwhile, compared to CoT and CoT-SC results, DaC clearly achieved much better recall. Tree-of-Thoughts, benefited by its searching ability, acquired significantly better recall score compared to other baselines. However, its significantly lower precision substantially harm its overall performance and leads to accuracy that is even worse than standard IO-prompting.
In contrary, DaC carefully checked all sentences, locate the one containing factual error and merge the answers.

#### 5.2.2 Misinformation Detection

The increasing abuse of misinformation toward manipulating public opinions on social media has been observed in different areas, such as healthcare (e.g. the recent COVID-19 pandemic) (Sharma et al., , ). This threat is increasingly serious due to LLM’s capacity in content generation (Li et al., ; Weidinger et al., ; Zhang et al., ). This challenge raise the importance of fact-verification, which aims at judging the authenticity of an article based on a collection of evidence from verified source (Whitehouse et al., ; Zhang and Gao, ). In this experiment, we present that DaC can outperform other baselines in fact-verification involved with news article.

Task Setup: In this experiment, we mainly adopt SciFact dataset (Wadden et al., ). In SciFact dataset, each sample is a pair of news and evidence, where the evidence is the abstract of a peer-reviewed paper and the news is a sentence of claim. To better simulate the real-world scenario where news on social media usually appears as an paragraph of post, following , we generate a dataset of paragraph-level misinformation based on SciFact dataset. Specifically, for a given claim, we apply ChatGPT-4 to extend the claim as an article based on the evidence. For this task, similar as hallucination detection, we apply single level Divide-and-Conquer solver to decompose the news article to multiple sentences, handle them separately and then merge the conclusions of all sentences. Also, the baselines in this experiments are the same as Hallucination Detection. The evaluation metrics includes F1 score, G-Mean score (geometric mean of precision and recall), Precision and Recall. We do not apply accuracy as the positive and negative classes are not balanced.

Results: Experimental results are shown in Tab. 3. Notably, GPT-3.5 incorporated with our proposed prompting strategy even outperform the performance of GPT-4 incorporated with IO-prompting, Least-to-Most, CoT and CoT-SC, which have significantly lower recall scores, indicating their proneness to deception. Only Tree-of-Thoughts, which is benefited by its advantage in exploring various options, acquired the best results among all baselines, but is still defeated by DaC. Moreover, as we can see, for GPT-4 the performance of CoT-SC is even worse than CoT, which is supposed to be a specific case of CoT-SC without exploration. These results suggests that, when facing deceptive contents generated on purpose, existing works’ improvement may not be robust.

## 6 Conclusions

In this paper, we analyze the utility and limitations of divide-and-conquer prompting strategy. We first provide theoretic analysis to Divide-and-Conquer prompting and compare it with representative prompting strategies. Based on these theoretic results, we summarize two conditions under which a task is suitable for Divide-and-Conquer prompting. After that we present empirical results that validated our theoretic analysis.

## Appendix A Appendix

### A.1 Discussions and Limitations

In summary, the proposed method has following advantages:

Comparison with IO-Prompting: Superiority in Expressive Power As we proved in Sec. 4, Compared to IO-prompting, DaC has stronger expressive power and thus can solve harder problems.

Comparison with CoT and EoT: Disentangling the task decomposition and task resolution Compared to the prompting family of CoT and EoT, DaC explicitly separate the task decomposition stage and task resolution stage. Therefore, we can acquire explicit decomposed sub-task rather than intermediate thoughts proposed during decoding. Consequently, we can explicitly enumerate all sub-tasks output by the decomposition module and avoid the model from missing important sub-tasks.

Comparison with LtM and Decomposed Prompting: Parallel Sub-task Handler and Sequential Sub-task Handler Similar as DaC, some program-guided prompting like LtM and Decomposed Prompting also explicitly separate the task decomposition stage and task resolution stage. However, they are mainly designed for multi-step reasoning for complex tasks. Thus, they sequentially tackle the sub-tasks and assembly the resolutions. As a result, they tend to follow the flow of the deceptive contents, leading to proneness to deceptive content.

Although DaC DaC surpasses the baselines on the proposed tasks, it still has some limitations.
The first issue is that the appliance scope of DaC is still limited.
More specifically, CoT, EoT, LtM and DaC are based on different algorithmic paradigms, learning to different Appliance Scopes. As pointed out by , CoT and LtM can be considered as a neural dynamic programming algorithm. Thus, CoT is more suitable for tasks that can be bridged to dynamic programming, such as multi-step question answering. Differently, EoT is based on exploration and search, which is more suitable for planning and search, such as Game of 24 (Yao et al., ). DaC is based on Divide-and-Conquer algorithm. Thus, it is more suitable for tasks that can be decomposed to a series sub-tasks that are disjoint or only slightly overlapped. Our future work will focus on further expand the appliance scope of DaC to more areas like question answering.

### A.2 Proof to Theorem 4.2

Before providing the proof, we first formally define how to organize the inputs (i.e., two 2-color trees) as a sequence. We assume that we acquire two trees $t_{p}$ of size $n$ and $t_{b}$ of size $m$. They are organized as two sequences of nodes with a random order. Each node has three variables: color, left child index, and right child index. If any child is null, then the index is filled with 0. Then we can organize them as as two sequences ${\bf X}_{p}\in\mathbb{R}^{n\times 3}$ and ${\bf X}_{b}\in\mathbb{R}^{n^{\prime}\times 3}$, where each item in the sequence is a vector of 3 dimensions. The first dimension is the index of the left child, the second dimension is the index of the right child, the third dimension is the color indicator (0 or 1). In addition, we have a root vector ${\bf r}$ with three dimensions. The first dimension is the index of the root node of $t_{p}$ (i.e., pointing to the root node of $t_{p}$) and the second is the index of the root node of $t_{b}$ (i.e., pointing to the root node of $t_{b}$). The third dimension of ${\bf r}$ is filled with 0 0 to make it have same dimension as the items in ${\bf X}_{p}$ and ${\bf X}_{b}$. This expression of trees is also called as pointer list encoding according to (Jenner et al., ). Note that in the following proof, we assume that all indices start from 1. Thus 0 is regarded as a NULL pointer.

Following the proof flow we provided in Sec. 4.2, we first provide the following divide-and-conquer algorithm that can solve the above problem:

Figure: Algorithm 3 Recursion Divide-and-Conquer Algorithm for 2-BSI $BSI({\bf r},{\bf X}_{p},{\bf X}_{b},m,t,d,f,w)$

Figure: Algorithm 4 Implementation of $d({\bf r},{\bf X}_{p},{\bf X}_{b})$ when the depth of the tree indicated by ${\bf r}$ is not longer than 2

Figure: Algorithm 5 Implementation of $t({\bf r},{\bf X}_{p},{\bf X}_{b})$ when the depth of the tree indicated by ${\bf r}$ is not longer than 2

Figure: Algorithm 6 Implementation of $m({\bf r},{\bf X}_{p},{\bf X}_{b},{\bf v}_{l},{\bf v}_{r})$

The algorithm described above is a typical divide-and-conquer algorithm for solving rooted tree isomorphism. Its justification can be found in many textbooks introducing algorithms, such as Introduction to Algorithms (Cormen et al., ). Here we provide the detailed definition and implementation of problem size metric $f(\cdot)$, hyper-parameter $w$, merge function $m()$, sub-task tackling function $t(\cdot)$, task decomposition function $d(\cdot)$:

- •
$w=1$, and $f({\bf r},{\bf X}_{p},{\bf X}_{b})$ is defined as the depth of the pattern tree $t_{p}$ indicated with root vector ${\bf r}$. Although precisely calculating $f({\bf r},{\bf X}_{p},{\bf X}_{b})$ is of $O(n)$, judging whether $f({\bf r},{\bf X}_{p},{\bf X}_{b})>1$ only require us to check whether the root node has child. If not, then return False.
- •
$d({\bf r},{\bf X}_{p},{\bf X}_{b})={\bf r}_{l},{\bf r}_{r}$ returns two new root vectors ${\bf r}_{l},{\bf r}_{r}$. Both $r_{l},r_{r}$ have the same second and third dimension as ${\bf r}$. The ${\bf r}_{l}$’s first dimension is updated to be the index of the left child of the root node that ${\bf r}$ points to. The ${\bf r}_{r}$’s first dimension is updated to be the index of the right child of the root node that ${\bf r}$ points to. The updating function can be written as:
- •
$t({\bf r},{\bf X}_{p},{\bf X}_{b})={\bf v}$ returns a 0-1 indicator vector ${\bf v}\in\mathbb{R}^{m}$ with the same length of the base tree size. If there exists a subtree with node $i$ as root that is isomorphic with pattern tree $t_{p}$ defined with inputs ${\bf r},{\bf X}_{p},{\bf X}_{b}$, then the ${\bf v}[i]$ is 1. Otherwise, ${\bf v}[i]$ is 0. When the pattern tree’s depth is not higher than 1 (i.e., 1-node tree), $t({\bf r},{\bf X}_{p},{\bf X}_{b})$ is equivalent to output a 0-1 vector indicating the nodes in the base tree that have the same color of the root node of pattern tree. The implementation is provided in Alg. 5.
- •
$m({\bf r},{\bf X}_{p},{\bf X}_{b},{\bf v}_{l},{\bf v}_{l})={\bf v}$ merge the results ${\bf v}_{l},{\bf v}_{l}$ to acquire a 0-1 indicator vector ${\bf v}\in\mathbb{R}^{m}$ with the same length of the base tree size. If there exists a subtree with node $i$ as root that is isomorphic with pattern tree $t_{p}$ defined with inputs ${\bf r},{\bf X}_{p},{\bf X}_{b}$, then the ${\bf v}[i]$ is 1. Otherwise, ${\bf v}[i]$ is 0. This function can be implemented by checking whether the pattern root’s children have a perfect match with each node’s children. Since each node has at most two children, checking the perfect match can be done in constant time. The implementation is provided in Alg. 6.

After providing the detailed implementation of the functions $d(\cdot),t(\cdot),m(\cdot)$, we are going to prove that there exists one unified transformer that can handle all these tasks with different prompts $d,t,m$. First, we will provide the following Lemma:

###### Lemma A.1 .

Any fixed-size logic circuit that only contains multi-fan-in AND gates, multi-fan-in OR gates, NOT gates and has no recurrent structure can be precisely simulated by a multi-layer perceptron (MLP) with ReLU activation function and a width of $O(|Input|+|Circuit|)$ and a depth of $O(|Circuit|)$, where $|Input|$ denotes the size of input and $|Circuit|$ denotes the number of gates in the circuit.

###### Proof.

Assume that we are given a series of input pins with logic variable of 0 or 1, organized as a 0-1 vector ${\bf x}\in\mathbb{R}^{h}$. We first prove that all gates can be simulated by a two-layer perceptron. Then we can serialize all gates in the circuits and stack their corresponding 2-layer simulators accordingly to acquire a MLP simulator. An AND gate that take ${\bf x}$ as input can be simulated as:

$$ $\text{AND}({\bf x})=\sigma(w_{A}{\bf x}-h+1)$ (3) $$

where $\sigma$ is the ReLU activation function, and $w_{A}$ is a weight vector with all dimensions equal to 1. If some dimensions of ${\bf x}$ are not the input of the gate, we can set the corresponding dimensions in the weight vector as 0 and adjust the $h$ as the input pin number. Similarly, an OR gate that take ${\bf x}$ as input can be simulated as:

$$ $\text{OR}({\bf x})=1-\sigma(w_{O}{\bf x}+h+1)$ (4) $$

where $\sigma$ is the ReLU activation function, and $w_{O}$ is a weight vector with all dimensions equal to -1. A NOT gate is different, since it only takes one input pin. In such a case, we denote the index of the input pin as $i$, then we can simulate a NOT gate as:

$$ $\text{NOT}({\bf x})=\sigma(w_{N}{\bf x}+1)$ (5) $$

where $w_{N}$ is a weight is a weight vector whose $i$-th dimension equals to -1 and all other dimensions equal to 0.
Also, since the $x$ is a 0-1 vector, the activation function is equivalent to a identical function to $x$:

$$ ${\bf x}=\sigma({\bf x})$ (6) $$

To construct a MLP that can simulate a fixed-size logic circuit without recurrent structure, we apply the circuit serialization in (Merrill and Sabharwal, ) which order the gates based on topological order. In this way, we can represent the circuit as a sequence GATE[1], GATE[2], GATE[3],…,GATE[L], where each GATE[i]’s input only contains the output of the previous gates and the original input ${\bf x}$. Therefore, we can construct a $2L$-layer MLP base on the above serialization. Specifically, the $2i$-th and $2i+1$-th layers of the MLP will simulate the $GATE[i]$ as well as copy all previous inputs with activation function and concatenate them together. This can be done by concatenate an identical matrix on the GATE’s weight vector ($w_{A}$, $w_{O}$ or $w_{N}$). In this way, we can construct a MLP that precisely simulate the circuit. Since every time we concatenate the output of a gate with the input of it, the input dimension number of the final layer can be bounded by $O(|{\bf x}|+L)$. In the worst case, for a circuit of size $L$, we needs $2L$ layers to precisely simulate it. However, in many cases, a lot of gates in the circuits can be run parallelly. In such cases, the MLP could be much more shallow.

∎

Now, we can start to prove our main theorem:

###### Theorem A.2 .

There exists a log-precision transformer with fixed depth and hidden dimension that can solve the 2-BSI of any size with fixed-length prompt $m$ (for merge), $t$ (for sub-task tackling) and $d$ (for task decomposition).

###### Proof.

We prove this theorem by constructing a Transformer that can tackle this problem. First we define how to organize the input given ${\bf r},{\bf X_{p}},{\bf X_{b}}$ and the prompt. Specifically, we construct a feature sequence ${\bf X}\in\mathbb{R}^{(3+n+n^{\prime})\times 7}$. Each item in this sequence is a feature of 7 dimensions, indicating a token. The first two dimensions indicate whether the token is a prompt (’00’), a root vector (’01’), a pattern tree node (’10’), or a base tree node (’11’). The third to fifth dimensions carries the information about the token. For a prompt token, ’100’ indicates merge prompt $m$, ’010’ indicates sub-task tackling prompt $t$, and ’001’ indicates task decomposition prompt $d$. For other cases, these three dimensions are with the same formula as the three dimensions in ${\bf r},{\bf X}_{p},{\bf X}_{b}$. The rest two dimensions are allocated specifically for the merge function $m(\cdot)$ to store ${\bf v}_{l}$ and ${\bf v}_{r}$. More specifically, for the feature of token indicating the $i$-th base tree node, its sixth dimension is ${\bf v}_{l}[i]$ and its seventh dimension is ${\bf v}_{r}[i]$. For other tokens, these two dimensions are filled with 0. In ${\bf X}[1]$ we store the prompt token. In ${\bf X}[2]$ and ${\bf X}[3]$ we store the input root vector ${\bf r}$ duplicately. We store the same token twice so that we can tackle ${\bf r}_{l}$ and ${\bf r}_{r}$ separately. To separate this two token, we use the last dimension, which was padded as 0 in ${\bf r}$, to distinguish them. ${\bf X}[2,5]$ is set as 0 and ${\bf X}[3,5]$ is set as 1. From ${\bf X}[4]$ to ${\bf X}[3+n]$, we store ${\bf X}_{p}$. From ${\bf X}[4+n]$ to ${\bf X}[3+n+n^{\prime}]$, we store ${\bf X}_{b}$. For all node indices of pattern tree, we add them by 3. For all node indices of base tree, we add them by 3+n, so that the indices can be applied to directly retrieve the positional embeddings.

Figure: Algorithm 7 Logic circuit for MLP of the second Transformer layer

After preparing the inputs, we start to construct our Transformer. The transformer first attach the position index for each token (positional embedding). After that, the inputs are forwarded into a transformer with depth of 2. Each transformer layer contains a multi-head attention layer followed by a MLP. As proved by (Merrill and Sabharwal, ; Feng et al., ), the attention layer of Transformer can retrieve the feature of tokens whose positional embeddings satisfy specific conditions. For multi-head attention, different heads can retrieve tokens with different conditions. In the following construction, we will use this conclusion to construct attention heads with different functions.

In the first Transformer layer, the function of each attention head is defined as:

- •
Head 1 only attends to the token itself to store $X[i]$ for token $i$.
- •
Head 2 attends to the token with a positional embedding matches the ${\bf X}[i,3]$ and copy this token’s 5-dimension feature. For tree node tokens, this head’s job is to retrieve the feature of ${\bf X}[i]$’s left child. For root vector tokens, this head’s job is to retrieve the feature of pattern tree root node. For the first token (prompt token), this head’s retrieved feature will not be applied in the afterwards layers and thus does not influence the correctness of the model.
- •
Similar as Head 2, Head 3 attends to the token with a positional embedding matches the ${\bf X}[i,4]$ and copy this token’s 5-dimension feature. This head’s job is to retrieve the feature of ${\bf X}[i]$’s right child. For root vector tokens, this head’s job is to retrieve the feature of base tree root node.
- •
Head 4 attends to the first token (prompt token) and copy this token’s 7-dimension feature. This head’s job is to retrieve the prompt indicator.
- •
Head 5 attends to the second token (root token) and copy this token’s 7-dimension feature. This head’s job is to retrieve the root information.

With the above 5 heads, the attention layer will output a 35-dimension feature for each token. We denote these features as ${\bf X}^{\prime}\in\mathbb{R}^{(3+n+n^{\prime})\times 35}$. After that, these features are forwarded into a MLP fitting identical mapping to acquire the input features for the second Transformer layer.

In the second Transformer layer, the function of each attention head is defined as:

- •
Head 1 only attends to the token itself to store $X^{\prime}[i]$ for token $i$.
- •
Head 2 attends to the token with a positional embedding matches the ${\bf X}^{\prime}[i,31]$ and copy this token’s 1-7 dimension features (${\bf X}^{\prime}[{\bf X}^{\prime}[i,31],1:7]$). This head’s job is to broadcast the feature of the pattern tree root node to every token.

With the above 2 heads, the attention layer will output a 42-dimension feature for each token. We denote these features as ${\bf X}^{\prime\prime}\in\mathbb{R}^{(3+n+n^{\prime})\times 42}$.
For root vector token, only the features from head 1 and head 4 are useful. For base tree node tokens, all 42 dimensions are useful. Then each token’s feature are parallely forwarded into a MLP. We will use this MLP to fit the logical circuit described in Alg. 7. The function of Alg. 7 is to aggregate the functions of $m(\cdot),t(\cdot),d(\cdot)$ together and assign the correct value based on the prompt indicator. In Alg. 7, all operations are AND, OR, NOT, SELECTOR, and ASSIGN and there is not loop. Thus, it is a static logical circuit and can be implemented with multi-fan-in AND, OR, NOT gates. Thus, it can be precisely simulated by a MLP according to our Lemma A.1.

After acquiring the ${\bf y}\in\mathbb{R}^{7}$ for each token, we can organize them as a feature sequence ${\bf Y}\in\mathbb{R}^{(3+n+n^{\prime})\times 7}$. When the prompt is $d$, we return ${\bf Y}[2,3:5]$ as ${\bf r}_{l}$ and ${\bf Y}[3,3:5]$ as ${\bf r}_{r}$. If the prompt is $t$ or $m$, then we can output ${\bf Y}[3+n+1:3+n+n^{\prime},5]$ as the expected ${\bf v}$.

∎

###### Lemma A.1 .

###### Proof.

###### Theorem A.2 .

###### Proof.

### A.3 Justification to Proposition 4.4

Suppose that the LLM is auto-regressively decoding $n$ tokens from an input context window with length of $C$. Then the decoding window of the $i$-th token is $C+i-1$. Thus, the average window size will be:

$$ $\frac{\sum_{i=1}^{n}(C+i-1)}{n}=\frac{C+n-1}{2}$ (7) $$

Thus, when we sequentially decode all the sub-task resolutions, the total length of the decoded sequence will be $\sum_{i=1}^{k}r_{i}$. Thus the average window size will be:

$$ $C+\frac{\sum_{i=1}^{k}r_{i}-1}{2}$ (8) $$

Meanwhile, when we apply Divide-and-Conquer, we parallely decode each sub-task’s resolution. Thus, for each sub-task, total window size will be $C\sum_{j=1}^{k}r_{j}+\sum_{i=1}^{k}\frac{(r_{i}-1)r_{i}}{2}$. Thus the average window size will be $C+\sum_{i=1}^{k}\frac{(r_{i}-1)r_{i}}{2\sum_{j=1}^{k}r_{j}}$.
Meanwhile, with Jensen inequility, we have:

$$ $\sum_{i=1}^{k}(r_{i}-1)r_{i}<\sum_{i=1}^{k}(r_{i}-0.5)^{2}\leq(\sum_{i=1}^{k}( r_{i}-0.5))^{2}\leq(\sum_{i=1}^{k}r_{i}-0.5k)^{2}$ (9) $$

Thus, when $k\geq 2$, we have:

$$ $\sum_{i=1}^{k}(r_{i}-1)r_{i}<(\sum_{i=1}^{k}r_{i}-1)^{2}$ (10) $$

Thus, we have:

$$ $C+\sum_{i=1}^{k}\frac{(r_{i}-1)^{2}}{2\sum_{j=1}^{k}r_{j}}<C+\frac{\sum_{i=1}^ {k}r_{i}-1}{2}$ (11) $$

### A.4 Prompting Details of DaC

Multiplication of Long Integers: Suppose we have two $2n$-digit numbers $AB$ and $CD$, where $A,B,C,D$ are all $n$-digit numbers. Then we can break $AB\times CD$ as $(A\times C\times 10^{2n})+(A\times D\times 10^{n})+(B\times C\times 10^{n})+(B
\times D)$, where the calculation in each bracket pair is disjoint with others bracket pairs. We only need to compute the results of multiplication in each bracket pair parallelly and then merge all of them with addition:

Decomposer Prompt $d$: Please split the string a from the middle as two separated strings. The lengths of the two separated strings should be as close as possible. Please only return the two strings separated by a comma and do not return anything else.

Sub-task Tackling Prompt $t$: (1)Please compute $a*b$. (2) Please only return the final results and do not return anything else (ensure disentangled-sub-process principle).

Merge Prompt $m$: Please compute $x=a*10^{2n}+b*10^{n}$ and $y=c*10^{n}+d$. Based on the above calculation, please compute $x+y$ carefully step by step.

Hallucination Detection in Long Context:
We divide the summary to sentences. After that, we paralelly verify the sentences. Finally, we merge the verification to each sentence:

Decomposer Prompt $d$: Please help me segment the following paragraph as sentences. The separated sentence should be output as: #Statement 1#: …#Statement 2#: …Do not say anything else. Just return the statements in the given format.
Paragraph

Sub-task Tackling Prompt $t$: I want you to act as a factual contradiction checker. You are given a set of statements and a document. Among the statements, there might be one or more statement that contains contradictions with the document. Please find the problematic statement if it exist by analyzing the statements one by one. For each statement, please make a choice:

- •
A: The statement is totally aligned with the document for sure.
- •
B: The statement contradicts with the document.

Merge Prompt $m$: Based on the above analysis, please tell me, does any statement above contain contradiction with the document?.

Fact-Verification for Misinformation Detection:
Similar as hallucination detection, we divide the summary to sentences. After that, we paralelly verify the sentences. Finally, we merge the verification to each sentence. Thus, our decomposer prompt and sub-task tackling prompt are the same as hallucination detection. The only difference is the merge prompt.

Merge Prompt $m$: If we connect the above statements to be a news article, based on the above analyzation, please answer me: Is there any contradiction between the document and the article?

Figure: Figure 5: Comparison of Least-to-Most (LtM) Prompting and Decomposed Prompting (DeP).
Refer to caption: x4.png

### A.5 Decomposed Prompting and Least to Most

Least-to-Most (LtM) Prompting (Zhou et al., ) and Decomposed Prompting (Khot et al., ) are two similar works to our work. They both propose to explicitly prompt the LLM to decompose the task as a series of sub-tasks and sequentially tackle them. In Fig .2, we merge these two methods. Here, we will provide more detailed comparison of them, which is shown in Fig. 5. Decomposed Prompting can regarded as a upgraded version of LtM. It introduces special notations into the prompt to represent program states so that when sequentially tackling the sub-tasks, it can call heterogeneous modules to tackle them. Such design enable the LLM to call external programs (e.g., retrieval documents on WikiPedia and program based calculator) and/or itself (i.e., recursion). Such design endows it stronger expressive power and increases the compositional generalization ability of LLMs in different areas, such as symbolic manipulation and multi-hop QA (Khot et al., ). Also, it endows LLM the ability to do open-domain QA by retrieving from external knowledge base.

### A.6 Typical Tasks that Satisfy and Dissatisfy the Proposed Conditions

To better assist the prompt engineering on different tasks, we list the typical tasks that satisfy and dissatisfy the proposed conditions. In common tasks, the following tasks satisfy the proposed conditions. For such tasks, searching good decomposition prompt for DaC is likely to be helpful for the performance:

- 1.
Multiplication
- 2.
Fact Verification on Long Text
- 3.
Auto Evaluation on Long Text
- 4.
Article-level Summary

The following tasks typically do not satisfy the proposed conditions. For such tasks, searching good decomposition prompt for DaC is not very likely to be helpful for the performance:

- 1.
Addition: It is too simple and violate the condition 1
- 2.
Division: It does not contain parallel sub-tasks, thus violate condition 2
- 3.
Multi-Round Question-Answering: It is a typical sequential task, thus violate condition 2
- 4.
Planning: It is a typical sequential task, thus violate condition 2

### A.7 More Discussions on Sequential Sub-task Tackling and Parallel Sub-task Tackling

Figure: Figure 6: Toy example of Sequential Sub-task Tackling and Parallel Sub-task Tackling in long integer multiplication
Refer to caption: x5.png

Figure: Figure 7: Toy example of Sequential Sub-task Tackling and Parallel Sub-task Tackling in hallucination detection
Refer to caption: x6.png

Sequential Sub-task Tackling and Parallel Sub-task Tackling are two different paradigm in decomposing complex tasks as sub-task to tackle. The first one decompose a complex tasks as a series of sub-tasks. In this series, each sub-task relies on the previous one’s output as input or context. The second one decompose a complex tasks as a set of sub-tasks, each of which does not rely on others. Two examples for multiplication and hallucination detection are provided in Fig 6 and 7

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: How do the token usage and inference time of DaC compare to those of CoT?
soundness: 3
strengths: The authors conducted a theoretical analysis of the Divide-and-Conquer prompting method, which is helpful for understanding the reasoning capabilities of large language models (LLMs) and is timely.

Providing the conditions under which DaC brings a performance boost has practical application value.
summary: This paper investigates the effectiveness of Divide-and-Conquer (DaC) Prompting. The author first provides a theoretical framework that can analyze how the divide-and-conquer strategy expands the expressive power of a fixed-depth log-precision Transformer. In this context, the author presents some conditions under which DaC has advantages compared to other prompting strategies. The author empirically validates this theory on tasks such as Large Integer Multiplication, Hallucination Detection, and Article-level Fact Verification, which require very long reasoning paths or contain deceptive contents.
weaknesses: In the task decomposition stage of Algorithm 1 and Algorithm 2, hallucinations or intermediate errors also seem to occur. Based on the current version of the paper, it is not clear whether the errors in CoT stem from the subtask solutions rather than the subtask decomposition. I suggest conducting further statistical analysis on the types of errors in CoT and DaC.

Considering that the applicability of DaC may not be as broad as CoT and that the reasoning process may require more tokens, the potential impact of this paper might not be as significant as Feng et al. 2023. Therefore, this work appears to be somewhat incremental.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: Please refer to the weaknesses part.
soundness: 3
strengths: 1. The paper mainly focuses on the theoretical view of a prompting strategy and tries to find experimental results that align with the theoretical results, which should be encouraged.
summary: This paper tries to analyze the utility of the divide-and-conquer prompting strategy and answer the questions on which kind of tasks this strategy has advantages. The paper provides a theoretical analysis of the divide-and-conquer prompting strategy to identify the specific tasks where DaC prompting can bring a performance boost with a theoretic guarantee. The paper claims to present two cases where experimental results align with our theoretical analysis.
weaknesses: 1. The presentation of the paper should be improved. For example, for the method, which is the main difference between ToT and DaC, from the description of the paper, it looks like DaC prompts LLMs to perform subtask decomposition first and then solve each subtask, while ToT does not distinguish between subtasks and general intermediate reasoning steps, just perform a tree-based reasoning process. Then, from Figure 2, DaC seems to solve tasks with homogeneous decomposition, is there any situation in which the depth of each subtask is not the same?
2. The proof part is also a little bit confusing for me. For example, theorem 4.1 seems trivial to me as all IO prompts can be seen as special cases of DaC prompts, which means IO prompts are a subset of DaC prompts, then the set of problems IO prompts can solve is also a subset of problems DaC prompts can solve, so there must be S(IO) in S(DaC).

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: 1. The writing and presentation of the paper need further improvement.
There are some missing symbols and wrong words in line 33, line 197, line 343, line 436, and etc.
2. The publications of the references need to be corrected such as Zhou et al., 2022.
soundness: 2
strengths: 1. The paper theoretically proves the DaC and proposes two conditions that DaC needs to satisfy to bring performance improvement.
2. The paper select two tasks (large integer arithmetic and fact verification) for experiments to make validation on theoretic analysis.
summary: The paper examines the utility of divide-and-conquer prompting strategy, and summarizes two conditions under which DaC leads to performance gains when tasks satisfy both of these conditions. Meanwhile, the paper lists three applicable tasks and three inapplicable tasks, and conduct experiments on two tasks: large integer arithmetic and fact verification to make validation.
weaknesses: 1. The concept in condition 2 is too general, what does it mean to be subject to hallucinations or intermediate errors, and I think most tasks suffer from this problem, can this definition be more specific?

2. In the applicable and inapplicable tasks, I think the granularity of the 6 tasks is completely different, and the paper proposes to conduct experiments on two tasks large integer arithmetic and fact verification. Integer Multiplication and Integer Addition belong to large integer arithmetic. However, the remaining four tasks are not proposed at the same granularity, and the reasons for the selection of the six tasks should be described in detail in this paper. In addition to the three tasks that are applicable, what other tasks are applicable?

3. In this paper, how is the answer extraction of the LLMs to make experimental statistics. Can the 100% on some metrics in Table 3 be analyzed in detail?

4. DaC generally performs better in Integer Addition as the model capacity increases (GPT-3.5->GPT-4). At the same time, on the HaluEval dataset, baselines have a large difference in the performance of the two LLMs, while the DaC method has the similar performance as GPT3.5 in GPT-4. It is necessary to further explore the influence of the model parameters on DaC.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: 1. How does DaC prompting compare with the latest prompting techniques or methods in terms of performance and computational efficiency?
2. Could the authors provide further insights into the robustness of DaC prompting and discuss potential sources of error or failure in the context of their case studies?
soundness: 2
strengths: 1. The theoretical claims are backed by empirical evidence from two distinct case studies, providing a comprehensive view of DaC's utility in both arithmetic and natural language processing tasks.
2. The study addresses a significant challenge in the application of LLMs, where tasks requiring long solution paths or dealing with complex and deceptive content are concerned. The findings have practical implications for prompt engineering in LLMs.
summary: The paper presents a theoretical and empirical analysis of the divide-and-conquer (DaC) prompting strategy in the context of large language models (LLMs). The authors argue that DaC can improve the performance of LLMs on specific tasks, particularly those involving repetitive sub-tasks or deceptive contents. The paper provides a theoretical framework to identify tasks where DaC prompting can be advantageous and supports these claims with experimental results from two case studies: large integer arithmetic and fact verification.
weaknesses: 1. While the paper makes a strong case for DaC in specific tasks, it does not explore its applicability in a broader range of tasks or domains, which might limit the generalizability of the findings.
2. At present, it is difficult to claim that the idea of the divide-and-conquer prompting strategy is novel, as there are many prompting strategies for LLM in-context learning. Besides, the paper doesn't compare with recent studies, such as Graph of Thoughts, and Program of Thoughts.
3. The theoretical analysis, while comprehensive, may be challenging for readers without a strong background in computational complexity theory, potentially reducing the accessibility of the paper.

Meta-review: This paper investigates the Divide-and-Conquer (DaC) prompting strategy for LLMs, combining theoretical and empirical analyses. It introduces a framework to identify tasks where DaC prompting enhances performance, particularly for tasks involving long reasoning paths, repetitive subtasks, or deceptive content. The findings are validated with experiments on large integer multiplication, hallucination detection, and fact verification, demonstrating DaC's advantages under specific conditions.

The reviewers mentioned several critical points about the paper, which need further investigation:

1. The reviewers raised concerns about the generalizability of the findings. DaC is one of the many prompting techniques out there. The paper should also study those techniques.  

2. Robustness and failure analysis are missing and need more investigation. In the rebuttal, the authors attempted to address these concerns.

3. The rationale behind selecting six tasks needs to be presented properly as their granularity seems different. The authors attempted to justify this also; however, it does not seem to be a convincing response. 

4. One reviewer also thinks that the contribution is incremental given that Feng et al. 2023 already presented similar studies. 

5. The writing also needs to be improved. Two reviewers pointed this out. The poofs presented in the paper also also confusing.

Decision: Reject