Select-Then-Decompose Strategy

• Select-Then-Decompose Strategy is a two-phase method that first selects a key element (e.g., candidate solution or evidence subset) and then decomposes it into actionable subcomponents.
• It is applied in diverse fields like LLM inference, reinforcement learning, and table reasoning by tailoring the granularity based on reward, confidence, or complexity criteria.
• The strategy improves efficiency by focusing computational resources on promising segments, enabling adaptive task decomposition and feedback-driven refinement.

Searching arXiv for papers on “Select-Then-Decompose Strategy” and related decomposition methods. Searching arXiv for dynamic decomposition, adaptive task decomposition, and selection-based decomposition in LLMs and related domains. Select-Then-Decompose Strategy is a general problem-solving pattern in which a system first selects a promising object of attention—such as a candidate solution, a pair of assets, a decomposition approach, a relevant evidence subset, or a subgoal—and then decomposes that object into smaller units for further optimization, verification, or execution. Across contemporary work, the pattern appears in LLM inference scaling, task decomposition, hierarchical reinforcement learning, question answering, table reasoning, visual question answering, optimization, and human planning. What varies across instantiations is the unit being selected, the granularity of decomposition, and the criterion used to couple the two stages. In recent work, the strategy has increasingly shifted from a rigid pipeline to a feedback-driven loop in which selection and decomposition co-evolve under task-specific reward, confidence, or complexity signals (Light et al., 23 Feb 2025).

1. Conceptual definition and recurring structure

The strategy is most naturally described as a two-phase scheme. A first stage selects a target—such as the best current completion, a decomposition method, a pair of assets, a relevant sub-table, or a subgoal. A second stage decomposes that target into smaller components that can be executed, refined, or recombined. In its simplest form, the ordering is literal: select first, then decompose. In more elaborate systems, the ordering is preserved at the top level but becomes embedded in a recursive or closed-loop procedure.

Several papers make this ordering explicit. In DISC, the top-level control is summarized as “Select → Decompose → Sample → Select → Decompose → …,” with the decomposition target chosen by $$\arg\min\{ h(y^{*a} \mid \text{context}), h(y^{*b} \mid \text{context}) \}$$ (Light et al., 23 Feb 2025). In the adaptive STD framework for LLM task decomposition, the process is defined as a closed-loop problem-solving process composed of selection, execution, and verification, where the selection module chooses among $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$ and the validation module accepts a solution only if $C \ge T$ (Liu et al., 20 Oct 2025). In TRIALS for pair trading, a high-level policy selects a pair and a low-level policy then performs a series of trading actions, preserving the select-then-decompose pattern while enabling end-to-end credit assignment (Han et al., 2023).

A consistent theme is that decomposition is not valuable in isolation. It is useful when tied to a prior decision about what deserves additional structure. This is also visible in DecompT5 pretraining, where the data creation stage first selects comparable text pairs and then trains a seq2seq model to bridge complementary content, and in Dater, which first reduces a large table to a compact sub-table and only then decomposes the question into executable sub-questions (Zhou et al., 2022, Ye et al., 2023).

The strategy therefore spans two regimes. In one regime, selection identifies an internal object within a task instance, such as a solution prefix, evidence subset, or graph bottleneck. In the other, selection chooses among decomposition policies themselves, as in adaptive STD, or among algorithmic paradigms, as in learned routing between monolithic and decomposition-based MINLP solvers (Liu et al., 20 Oct 2025, Mitrai et al., 2023).

2. Algorithmic forms in LLMs

In LLM research, Select-Then-Decompose has evolved from a static pipeline into adaptive control over granularity, search, and verification. DISC is the clearest example of this shift. Given a prompt $x$, a pretrained autoregressive LLM policy $\pi$ generates text $y$, and a reward model $R(x \cdot y) \in [0,1]$ evaluates correctness. DISC first samples completions from the current context and selects the highest-reward one $y_k^*$ using greedy step search. It then partitions the selected step using a fraction $\alpha$, typically in the range $0.15 \le \alpha \le 0.25$, estimates a priority metric $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$0 for the resulting segments, and recursively refines the lower-priority segment (Light et al., 23 Feb 2025).

DISC also ties selection to compute allocation through a negative-binomial stopping rule,

$$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$1

with the global budget constrained by $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$2. Two priority metrics are formalized. DISC-Q uses rollout-based expected outcome reward, and DISC-Z uses a standardized advantage,

$$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$3

Lower $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$4 indicates greater room for improvement, so finer decomposition is applied where the tail probability of surpassing the current best trace is largest (Light et al., 23 Feb 2025).

A different LLM instantiation appears in the adaptive STD framework. There, selection is over decomposition methods rather than over trace segments. The selection prompt asks whether the task is logical, iterative, or divergent; the execution module applies the chosen approach; and the validation module produces a confidence score $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$5 and accepts if $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$6. If validation fails, the system switches by stage from $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$7 to Implicit $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$8 to Explicit $$\{\text{io}, \text{cot}, \text{ps}, \text{react}, \text{pe}, \text{dag\_flow}\}$$9, using uniform random sampling within a group and a default threshold $C \ge T$0 with maximum switching iterations $C \ge T$1 (Liu et al., 20 Oct 2025).

These two systems illustrate distinct but related meanings of the strategy. DISC selects an internal reasoning segment and decomposes it adaptively during inference. STD selects a decomposition policy conditioned on task characteristics, then verifies and possibly re-selects. A plausible implication is that Select-Then-Decompose in LLMs can operate both at the level of solution traces and at the level of decomposition policy selection.

3. Selection criteria: reward, confidence, and complexity

The strategy is defined less by a specific architecture than by the criterion used for selection. Across domains, three criteria recur: reward-based selection, confidence-based selection, and complexity-based selection.

Reward-based selection is central in DISC and TRIALS. In DISC, the reward model $C \ge T$2 determines the best completion at the current granularity, and rollout-derived $C \ge T$3 or $C \ge T$4 then decides which segment is harder or more improvable (Light et al., 23 Feb 2025). In TRIALS, the manager’s reward is the subsequent trading return achieved by the worker on unseen trading data, so pair selection is optimized directly against downstream trading performance rather than against static correlation or cointegration statistics (Han et al., 2023).

Confidence-based selection appears most explicitly in zero-shot VQA. There, a VLM first answers the original question and exposes a confidence signal through the top-1 probability $C \ge T$5, entropy $C \ge T$6, margin $C \ge T$7, or log-odds. The reported system instantiates selection using $C \ge T$8: decompose only if $C \ge T$9. If selected, the model generates a sub-question, answers it, and recomposes the final answer using the generated context. The paper reports that naive always-on decomposition induces many flips from originally correct answers to wrong ones, while selective decomposition retains error-correction benefits on low-confidence cases and avoids unnecessary error induction (Khan et al., 2023).

Complexity-based selection is the foundation of ACONIC and the convex MINLP routing framework. ACONIC reduces a task to a CSP via planning-as-satisfiability, computes a tree decomposition of the induced constraint graph, and uses treewidth and number of bags as the only complexity measures. Selection consists of choosing the bags and separators of a near-minimal tree decomposition as intervention points, after which decomposition exposes only bag-local constraints and shared boundary variables to the LLM (Zhou et al., 9 Oct 2025). In convex MINLP, the select stage is learned graph classification: a GNN predicts whether a given instance should be routed to a decomposition-based outer approximation algorithm or to a monolithic branch-and-bound method based on structural coupling in a graph representation of the optimization model (Mitrai et al., 2023).

These criteria differ operationally but serve the same function: they determine where decomposition is worth paying for. This suggests that Select-Then-Decompose is best viewed as a resource-allocation principle rather than a fixed procedural template.

4. Domain-specific instantiations

The strategy has been instantiated with different semantics in different application areas.

In pair trading, TRIALS models the universe of assets as $x$0, with a high-level action $x$1 selecting a pair and a low-level action $x$2 executing long/short/clear decisions. The per-step reward is

$x$3

and the cumulative return objective is $x$4. The high-level manager receives reward from out-of-sample trading performance, creating end-to-end credit assignment from trading back to pair selection (Han et al., 2023).

In hypothetical question decomposition, DecompT5 and DecompEntail separate question understanding from fact selection and final entailment. DecompT5 is built on T5-large and is further pre-trained for one epoch on $x$5M sentence pairs from RealNews plus $x$6K Project Gutenberg sentences for denoising. The article-pair selection criterion uses a 2-day window and SentenceBERT cosine similarity $x$7, while sentence-pair selection retains similarity in $x$8. At QA time, the system decompose-then-selects by generating aspects+facts hypotheses, correcting them with GPT-3, and aggregating with an entailment model, but the pretraining stage itself is select-then-decompose at the data level (Zhou et al., 2022).

In table reasoning, Dater first selects relevant rows and columns from a large table to form a sub-table $x$9, then decomposes a complex question into abstract sub-questions with masked numbers. Each sub-question is parsed to SQL, executed over $\pi$0, and numerically filled before final aggregation. The paper reports that the average number of cells is reduced from $\pi$1 to $\pi$2 on WikiTableQuestions, from $\pi$3 to $\pi$4 on TabFact, and from $\pi$5 to $\pi$6 on FetaQA, and that the method outperforms strong baselines on all three datasets (Ye et al., 2023).

In visual question answering, the strategy is used as selective second-guessing. A base VQA model predicts an answer once; only if the answer is insufficiently confident does the system generate and answer a sub-question, then recompute the main answer with the auxiliary context. The result is a confidence-aware decomposition policy rather than universal decomposition (Khan et al., 2023).

In constructive preference elicitation, part-wise coactive learning selects a part $\pi$7 and optimizes only that part while fixing the remainder of the configuration. The decomposition is grounded in a GAI-style partition of features into $\pi$8, so that $\pi$9. The paper reports that part-wise inference can be up to exponentially less computationally demanding than inference over full configurations and establishes an average conditional regret bound that scales as $y$0 plus a term involving $y$1 (Dragone et al., 2017).

5. Empirical behavior and efficiency trade-offs

A major reason the strategy has attracted attention is that decomposition is not uniformly beneficial. The empirical record is instead dominated by performance–cost trade-offs.

In DISC, experiments on APPS, MATH500, and LiveCodeBench show that dynamic decomposition outperforms fixed token-level, sentence-level, and single-step decompositions, reducing the pass@10 error rate by $y$2, $y$3, and $y$4 respectively (Light et al., 23 Feb 2025). The same study reports that mean reward increases with deeper steps, variance decreases, planned token/line splits often propose many partitions that are never searched under budget, and DISC uses fewer, more impactful partitions. On APPS, DISC raises Llama’s pass rate from $y$5 to $y$6 and Mistral’s from $y$7 to $y$8 in the reported model ablation (Light et al., 23 Feb 2025).

In adaptive STD, the central empirical claim is not raw accuracy alone but Pareto efficiency. On HumanEval and HotpotQA, STD attains near-optimal performance while using only $y$9 of the average token cost. The reported benchmark values include GSM8K $R(x \cdot y) \in [0,1]$0 with $R(x \cdot y) \in [0,1]$1 tokens and $R(x \cdot y) \in [0,1]$2 API calls, MATH $R(x \cdot y) \in [0,1]$3 with $R(x \cdot y) \in [0,1]$4 tokens and $R(x \cdot y) \in [0,1]$5 API calls, HumanEval $R(x \cdot y) \in [0,1]$6 with $R(x \cdot y) \in [0,1]$7 tokens and $R(x \cdot y) \in [0,1]$8 API calls, and HotpotQA $R(x \cdot y) \in [0,1]$9 with $y_k^*$0 tokens and $y_k^*$1 API calls (Liu et al., 20 Oct 2025). The same paper reports that implicit approaches account for roughly $y_k^*$2 of selections and explicit approaches for roughly $y_k^*$3, with CoT and P{paper_content}E more common in math, ReAct more common in coding, and P{paper_content}E (DAG) more common in writing and text comprehension (Liu et al., 20 Oct 2025).

In VQA, the empirical profile is explicitly non-monotonic. The decomposition curve shows that as the threshold $y_k^*$4 increases and more questions are decomposed, accuracy first rises and then falls below baseline because error induction overtakes error correction (Khan et al., 2023). The reported gains are especially large in non-natural image domains: for BLIP-2 13B, PathVQA improves by $y_k^*$5, VQA-RAD by $y_k^*$6, and SLAKE by up to $y_k^*$7 under selective decomposition (Khan et al., 2023).

In table reasoning, the benefit of selection is visible in both efficiency and accuracy. Removing evidence decomposition lowers TabFact accuracy from $y_k^*$8 to $y_k^*$9 and WikiTableQuestions test denotation accuracy from $\alpha$0 to $\alpha$1, while removing question decomposition lowers WikiTableQuestions test accuracy further to $\alpha$2 (Ye et al., 2023).

These results collectively reject a uniform rule such as “more decomposition is always better.” The more precise pattern is that decomposition pays when the selection stage accurately identifies instances, substeps, or representations for which additional structure changes the decision boundary or reduces wasted computation.

6. Theoretical interpretations and limitations

The strategy also has a theoretical interpretation. In the recent analysis of chain-of-thought as tree-structured decomposition, a large classification problem with $\alpha$3 classes is decomposed into a rooted $\alpha$4-ary tree of depth $\alpha$5 with $\alpha$6. Direct prediction has error

$\alpha$7

while a balanced decomposed predictor satisfies

$\alpha$8

The paper identifies a critical degree threshold $\alpha$9 and shows that increasing depth helps only when $0.15 \le \alpha \le 0.25$0; below that threshold, additional “thinking” is detrimental (Nadgir et al., 10 Apr 2026). This gives Select-Then-Decompose a quantitative bias: the value of decomposition depends on the branching factor and depth, not merely on the existence of intermediate steps.

A different theoretical account comes from human planning. In graph-structured tasks, the resource-rational framework defines

$0.15 \le \alpha \le 0.25$1

with $0.15 \le \alpha \le 0.25$2, and evaluates a subgoal set $0.15 \le \alpha \le 0.25$3 through the Bellman recursion

$0.15 \le \alpha \le 0.25$4

The paper reports that human responses are more consistent with this framework than with two alternative normative accounts and are most consistent with betweenness centrality, which functions as an efficient approximation to the selection stage (Correa et al., 2022).

Despite these theoretical advances, the literature also records several limitations. DISC becomes unstable at high sampling temperature because $0.15 \le \alpha \le 0.25$5 estimates become noisy; poor priority metrics misallocate compute; refinement stops when splitting is impossible or when metric precision is achieved (Light et al., 23 Feb 2025). STD relies solely on prompting for selection, so weak selection models may degrade overall performance, and the study does not investigate representation formats or external tools beyond the selected experimental scope (Liu et al., 20 Oct 2025). DecompEntail depends on GPT-3 for factual correction, which the paper notes is less interpretable than deterministic information retrieval (Zhou et al., 2022). ACONIC inherits the computational burden of obtaining high-quality tree decompositions, and its empirical validation is limited to SATBench and Spider (Zhou et al., 9 Oct 2025).

These constraints indicate that Select-Then-Decompose is not a universal recipe. Its success depends on the quality of the selection signal, the cost of decomposition, and the compatibility between decomposition granularity and the underlying solver or model.

7. Practical synthesis and relation to fixed decomposition

Across the literature, fixed decomposition serves as the main foil. Token-level, sentence-level, line-level, and single-shot strategies all instantiate decomposition without adaptive selection. Their limitation is that they spend computation uniformly or according to handcrafted boundaries. Select-Then-Decompose systems instead try to localize where structure should be introduced.

The practical guidance converges on a small set of recurrent principles. Dynamic LLM inference should interleave selection and decomposition, allocate samples with a negative-binomial rule under a budget constraint, and keep temperatures relatively low to stabilize metric estimates (Light et al., 23 Feb 2025). Adaptive task decomposition should characterize tasks along logical, iterative, and divergent dimensions, use a selection module to pick among decomposition styles, and verify outputs with a thresholded confidence score before escalating to more expensive approaches (Liu et al., 20 Oct 2025). Table reasoning should select evidence before decomposing questions so that symbolic execution operates on a compact, schema-relevant sub-table (Ye et al., 2023). VQA should decompose only low-confidence questions, because indiscriminate decomposition increases error induction (Khan et al., 2023). Constraint-heavy tasks should be decomposed only after analyzing their induced complexity through treewidth and bag structure (Zhou et al., 9 Oct 2025).

A useful way to summarize the strategy is that selection identifies where heterogeneity lies, and decomposition exploits that heterogeneity. In DISC, heterogeneity lies within reasoning traces. In adaptive STD, it lies across task types and decomposition policies. In TRIALS, it lies across candidate pairs and their tradability. In Dater, it lies across table regions and question substructures. In VQA, it lies across confidence strata. In ACONIC, it lies across graph-induced complexity regions.

This suggests a unifying interpretation. Select-Then-Decompose is not merely “choose, then split.” It is a control principle for routing limited computation toward the parts of a task, instance, representation, or policy space where finer granularity is most likely to improve utility relative to cost.