Recursive Decomposition with Dependencies

• RDD is a unified framework that recursively decomposes complex tasks into manageable sub-problems while explicitly capturing dependencies between them.
• It employs a two-stage scheduling using breadth-first search for decomposition and depth-first search for solving, ensuring legal topological order over a dependency DAG.
• Empirical results show that RDD improves accuracy by 10–40% over monolithic solving and reduces computation time by up to 80% in various reasoning, explainability, and sensitivity analysis applications.

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 (Hernández-Gutiérrez et al., 5 May 2025, Qasim et al., 7 Feb 2026, Sivill et al., 2023, Idrissi et al., 2023).

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}$ (Hernández-Gutiérrez et al., 5 May 2025). 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 $T$0 must exceed $T$1, and all unit sub-problems must be strictly easier, i.e., $T$2 (Hernández-Gutiérrez et al., 5 May 2025).

Dependency structure is captured through directed acyclic graphs (DAGs), where each node represents a sub-problem and edges encode dependency (i.e., sub-problem $T$3 requires the output of $T$4). This modeling is critical for problems with inherent structure, such as function composition, symbolic mathematics, or interacting variable groups (Qasim et al., 7 Feb 2026, Sivill et al., 2023).

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 (Hernández-Gutiérrez et al., 5 May 2025)). 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 (Qasim et al., 7 Feb 2026).

Representative pseudocode (from (Hernández-Gutiérrez et al., 5 May 2025), BFS+DFS):

$\ell$7 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) (Qasim et al., 7 Feb 2026).
• Structural: Recursion follows variable interaction structure or function partition (e.g., non-separable variable groups in feature attribution) (Sivill et al., 2023).
• Probabilistic: Dependency arises from input distribution or joint law; decomposition and projections must respect dependency structure (e.g., dependent Hoeffding decompositions) (Idrissi et al., 2023).

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) (Qasim et al., 7 Feb 2026). 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 (Sivill et al., 2023).

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 (Hernández-Gutiérrez et al., 5 May 2025). 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 LLM reasoning settings. Error analysis shows that most remaining failures originate in unit-solving steps, with merging and decomposition proving relatively stable (Hernández-Gutiérrez et al., 5 May 2025).

5. Complexity and Efficiency

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

• Number of decomposition calls: $T$8.
• Practical cost is often much lower due to early termination at unit subproblems.
• In independent decomposition (no dependencies), cost is $T$9.
• With balanced decomposition and logarithmic depth (for many tasks), cost reduces to $\ell$0 for $\ell$1 primitive input units.
• Worst-case (full expansion, no unit cases) is $\ell$2.

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 (Hernández-Gutiérrez et al., 5 May 2025).

In model explainability (e.g., Shapley Sets), recursive group finding and value assignment scales as $\ell$3 model evaluations due to log-depth recursive splitting in group identification (Sivill et al., 2023).

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 (Hernández-Gutiérrez et al., 5 May 2025).

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 (Qasim et al., 7 Feb 2026).

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 (Sivill et al., 2023).

4. Sensitivity Analysis with Dependent Inputs:

Hoeffding decomposition with dependencies provides an RDD-based expansion of arbitrary $\ell$4 in $\ell$5 spaces, yielding unique additive components for all $\ell$6. Recursive oblique projection accounts for dependencies by construction, enabling interpretable global sensitivity indices that decompose structural and correlative effects even under strong dependencies (Idrissi et al., 2023).

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 (Hernández-Gutiérrez et al., 5 May 2025). Verification-based RDD achieves 100% rate of valid decompositions, as opposed to many invalid or noisy subproblems in uncontrolled methods (Qasim et al., 7 Feb 2026).

In model explainability, recursive decomposition confers theoretical guarantees:

• Additive group-level attribution precisely matches Shapley value over non-interacting super-features (Sivill et al., 2023).
• Sensitivity indices in the Hoeffding decomposition maintain interpretability and orthogonality properties under weak dependency assumptions, with explicit variance-covariance accounting (Idrissi et al., 2023).

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:

• (Hernández-Gutiérrez et al., 5 May 2025) Recursive Decomposition with Dependencies for Generic Divide-and-Conquer Reasoning
• (Qasim et al., 7 Feb 2026) VERIFY-RL: Verifiable Recursive Decomposition for Reinforcement Learning in Mathematical Reasoning
• (Sivill et al., 2023) Shapley Sets: Feature Attribution via Recursive Function Decomposition
• (Idrissi et al., 2023) Hoeffding decomposition of black-box models with dependent inputs