---
title: Recursive Decomposition with Dependencies
url: https://www.emergentmind.com/topics/recursive-decomposition-with-dependencies-rdd
type: topic
---

# Recursive Decomposition with Dependencies

Recursive Decomposition with Dependencies (RDD) is a unified framework for divide-and-conquer reasoning, function decomposition, and sensitivity analysis that incorporates explicit modeling of dependencies between sub-tasks or variable groups. RDD establishes a structured approach to breaking complex reasoning or analytic problems into recursively solvable components while rigorously capturing inter-component dependencies. This methodology applies across language-model reasoning, formal mathematical derivation, model explainability, and functional decomposition in settings with nontrivial input interactions [2505.02576, 2602.07559, 2307.01777, 2310.06567].

## 1. Formal Definition and Theoretical Framework

RDD is formally defined by its recursive structure and explicit dependency representation. The canonical setting considers a root problem $x_0 \in T^\ell$ (with token vocabulary $T$ and prompt length $\ell$), a model $\mathcal{M}_\theta$ (e.g., LLM or arbitrary function), and a classifier or separator for unit/base cases $\mathcal{C}$ [2505.02576]. The recursive procedure generates sub-problems $X_1,\ldots,X_w$, and for each, recursively determines whether it is atomic (unit) or requires further decomposition.

**Success probabilities** at each step are characterized as:

- $\varphi_d(c, n) = \Pr[\text{decompose correct} \mid \text{class}=c, \text{difficulty}=n]$
- $\varphi_u(c, n) = \Pr[\text{unit-solve correct} \mid \dots]$
- $\varphi_m(c, n) = \Pr[\text{merge correct} \mid \dots]$

End-to-end accuracy propagates as:

$$
\varphi_{\mathrm{RDD}}(x_0) = \varphi_d(c_0, n_0) \cdot \varphi_m(c_0, n_0) \cdot \prod_{i=1}^w \mathbb{E}\left[
\mathbb{I}\{\mathcal{C}(X_i)\} \cdot \varphi_u(c_i, n_i) +
\mathbb{I}\{\neg \mathcal{C}(X_i)\} \cdot \varphi_{\mathrm{RDD}}(X_i)
\right]
$$

Two key desiderata are required for RDD to outperform monolithic (direct) solving: the product $\varphi_d(x_0) \cdot \varphi_m(x_0)$ must exceed $\varphi_u(x_0)$, and all unit sub-problems must be strictly easier, i.e., $\varphi_u(X_i) > \varphi_u(x_0)$ [2505.02576].

Dependency structure is captured through directed acyclic graphs (DAGs), where each node represents a sub-problem and edges encode dependency (i.e., sub-problem $A$ requires the output of $B$). This modeling is critical for problems with inherent structure, such as function composition, symbolic mathematics, or interacting variable groups [2602.07559, 2307.01777].

## 2. Algorithmic Structure and Dependency Scheduling

The canonical RDD algorithm employs a two-stage scheduler—breadth-first search (BFS) for decomposition and depth-first search (DFS) for solving and merging (see pseudocode in [2505.02576]). Each sub-problem receives a unique identifier. Dependencies are referenced in sub-problem descriptions (e.g., placeholders like `{P-2}` denote required sub-solutions).

Execution must respect a legal topological order over the dependency DAG: no sub-problem is solved before all its dependencies are available. Schedulers statically analyze the dependency structure and dynamically orchestrate recursive solution and merge steps. In formal contexts (e.g., symbolic mathematics), rules for decomposition and sub-problem generation are mathematically verifiable and can be automatically checked for acyclicity and coverage [2602.07559].

**Representative pseudocode (from [2505.02576], BFS+DFS):**
```python
def SolveBDD(problem):
    ScheduleBFS(problem)     # Build the decomposition graph
    return ScheduleDFS(problem, set())  # Solve/merge recursively
```
Decomposition, unit-solving, and merging each correspond to separate metaprompts or operations.

## 3. Dependency Typologies and Verification

Dependencies can be:
- *Syntactic*: Sub-problems depend explicitly on others' outputs (e.g., Length Reversal tasks, compositional derivatives) [2602.07559].
- *Structural*: Recursion follows variable interaction structure or function partition (e.g., non-separable variable groups in feature attribution) [2307.01777].
- *Probabilistic*: Dependency arises from input distribution or joint law; decomposition and projections must respect dependency structure (e.g., dependent Hoeffding decompositions) [2310.06567].

In some settings, dependencies are verifiable:
- **Mathematical recursion**: Each decomposition step must (V1) strictly decrease problem complexity, (V2) guarantee child solutions participate in the parent solution, and (V3) be grounded in a formal rule (e.g., chain, product, sum rule in calculus) [2602.07559]. Every dependency edge is checked “by construction.”
- **Feature attribution**: Feature sets are recursively merged only if pairwise dependency (interaction) is detected, ensuring that all cross-group dependencies are minimized and all within-group interactions are captured [2307.01777].

The graph structure and decomposition procedure enforce global acyclicity and facilitate topological curriculum ordering for training or analysis.

## 4. Error Recovery and Robustness

RDD incorporates an explicit error recovery mechanism during the merge step [2505.02576]. Model prompts are crafted to instruct correction of sub-solution errors if any are detected at the merge interface. If a sub-solution is missing, malformed, or irreparably incorrect, the system can treat the root as a unit problem and attempt a direct solution as fallback.

Empirically, this recovery behavior corrects 10–15 % of upstream sub-task errors in large language model reasoning settings. Error analysis shows that most remaining failures originate in unit-solving steps, with merging and decomposition proving relatively stable [2505.02576].

## 5. Complexity and Efficiency

Computational complexity of RDD depends on the recursion depth $d$, maximal branching factor $w$, and the per-step computational or model inference cost $C$ (e.g., LLM forward pass):

- Number of decomposition calls: $O((w^{d+1} – 1)/(w–1))$.
- Practical cost is often much lower due to early termination at unit subproblems.
- In independent decomposition (no dependencies), cost is $O(w^d)$.
- With balanced decomposition and logarithmic depth (for many tasks), cost reduces to $O(C \cdot \log N)$ for $N$ primitive input units.
- Worst-case (full expansion, no unit cases) is $O(C \cdot N)$.

RDD achieves significant computational savings in reasoning tasks: in large-scale LLM benchmarks, it reduces GPU time and context usage by 40–80% over strong baselines, with shorter, fewer calls and smaller context/outputs [2505.02576].

In model explainability (e.g., Shapley Sets), recursive group finding and value assignment scales as $O(n \log n)$ model evaluations due to log-depth recursive splitting in group identification [2307.01777].

## 6. Applications in Reasoning, Explainability, and Sensitivity Analysis

RDD frameworks have been instantiated in several distinct domains:

**1. Generic LLM Reasoning**:  
RDD enables scalable divide-and-conquer problem solving for complex sequence and logic tasks (e.g., Letter Concatenation, Length Reversal), supporting variable and cross-step dependencies, and task-agnostic application with generic or in-context prompting [2505.02576].

**2. Symbolic and Curriculum Learning**:  
VERIFY-RL implements RDD for curriculum-based RL policy optimization in mathematical reasoning, with explicit verification that each subproblem is strictly simpler, solution-relevant, and rule-grounded. Verified dependencies yield 40% relative accuracy gains and double success rates on the hardest problem levels [2602.07559].

**3. Model Explainability**:  
Shapley Sets uses RDD to identify minimal non-separable variable groups via recursive dependency testing and assigns group-level feature value attributions. This method resolves attribution ambiguity in the presence of feature interactions and maintains classical fairness axioms at the group level [2307.01777].

**4. Sensitivity Analysis with Dependent Inputs**:  
Hoeffding decomposition with dependencies provides an RDD-based expansion of arbitrary $f(X)$ in $L^2$ spaces, yielding unique additive components for all $u \subseteq \{1,\dots,d\}$. Recursive oblique projection accounts for dependencies by construction, enabling interpretable global sensitivity indices that decompose structural and correlative effects even under strong dependencies [2310.06567].

## 7. Empirical Findings and Theoretical Guarantees

Empirical evaluation in language-model reasoning exhibits large performance margins for RDD over major chain-of-thought and least-to-most baselines. In compute-matched settings, RDD yields 10–40 percentage point accuracy improvements on hardest task instances, with transition points for clear superiority as sequence complexity increases [2505.02576]. Verification-based RDD achieves 100% rate of valid decompositions, as opposed to many invalid or noisy subproblems in uncontrolled methods [2602.07559].

In model explainability, recursive decomposition confers theoretical guarantees:
- Additive group-level attribution precisely matches Shapley value over non-interacting super-features [2307.01777].
- Sensitivity indices in the Hoeffding decomposition maintain interpretability and orthogonality properties under weak dependency assumptions, with explicit variance-covariance accounting [2310.06567].

Axiomatic properties such as efficiency, dummy, symmetry, and additivity are preserved at the groupwise or decomposed level, restoring foundational fairness principles absent in naive conditional attribution approaches.

---

**References:**  
- [2505.02576] Recursive Decomposition with Dependencies for Generic Divide-and-Conquer Reasoning  
- [2602.07559] VERIFY-RL: Verifiable Recursive Decomposition for Reinforcement Learning in Mathematical Reasoning  
- [2307.01777] Shapley Sets: Feature Attribution via Recursive Function Decomposition  
- [2310.06567] Hoeffding decomposition of black-box models with dependent inputs

Source: https://www.emergentmind.com/topics/recursive-decomposition-with-dependencies-rdd