Controller–Generator Decomposition

• Controller–Generator Decomposition is a modular approach that separates high-level planning (controller) from detailed action generation (generator) in learning systems.
• It underpins advances in neural program synthesis and robotic locomotion by enabling independent optimization and rigorous performance analysis.
• Comparative studies demonstrate that explicit subgoal planning improves compositional generalization and robustness across diverse domains.

Controller–Generator Decomposition is a systems-level architectural principle that separates high-level planning (controller) from detailed action generation (generator) within learning-based frameworks. This decomposition underpins recent advances in both neural program synthesis and physically plausible robot locomotion, imposing modularity that allows each stage to be independently optimized and scrutinized for reliability, expressiveness, and generalization.

1. Formal Definition and Motivation

Controller–generator decomposition divides an agent’s operation into two explicit, sequential stages:

• The controller (alternately: Subgoal Model, high-level planner) translates the current situation or specification into a subgoal or reference trajectory. This model is responsible for long-range structure, subtask decomposition, or encoding priors extracted from data (e.g., combinatorial program structures or natural movement cycles).
• The generator (alternately: Synthesizer Model, torque controller) produces concrete actions, programs, or motor commands conditioned on the reference or subgoal from the controller, and is typically tasked with realizing these proposals within the constraints of a domain-specific language (DSL) or a physical system.

This modularization allows systems to exploit structure where available (e.g., compositionality in programs, kinematic regularities in human locomotion) while delegating low-level adaptation and control to powerful data-driven or reinforcement-learning (RL) optimizers. The decomposition also facilitates transparency and interpretability of intermediate decisions (Zenkner et al., 11 Mar 2025, Ates et al., 21 Nov 2025).

2. Program Synthesis: ExeDec Architecture

In neural program synthesis, ExeDec exemplifies controller–generator decomposition by bifurcating the synthesis pipeline into a Subgoal Model (controller) and a Synthesizer Model (generator):

• Subgoal Model (Controller): At each iteration $t$, inputs the current I/O specification $X_t = \{(I_i, O_i^{(t)})\}_{i=1}^n$ and outputs a predicted subgoal specification $G_t = \{(I_i, O_i^{(t+1)})\}_{i=1}^n$, effectively rewriting the desired outputs intermediary towards the final target. This is modeled as $G_t = \arg\max_{G'} P_\theta(G' | X_t)$.
• Synthesizer Model (Generator): Receives subgoal $G_t$, produces a program $p_t \in \mathcal{P}$ mapping each input $I_i$ to $O_i^{(t+1)}$, that is, $p_t = \arg\max_{p'} Q_\phi(p' | G_t)$.

This process iterates: executing $p_t$ to get updated outputs, forming a new specification $X_{t+1}$, and repeating until a termination condition (final spec matched or budget exhausted).

Training in ExeDec proceeds by teacher forcing on ground-truth decompositions with two loss terms:

• Subgoal loss: $$\, -\sum_{t=0}^{T-1}\sum_{i=1}^n \log P_\theta(G^{\ast (t)} | X^{\ast (t)}) \,$$
• Synthesis loss: $$\, -\sum_{t=0}^{T-1}\sum_{i=1}^n \log Q_\phi(p^{\ast(t)} | G^{\ast(t)}) \,$$

Joint optimization of $\theta$ and $\phi$ enforces both accurate subgoal tasking and robust subprogram generation (Zenkner et al., 11 Mar 2025).

3. Comparative Effectiveness: ExeDec vs. REGISM

Ablation via REGISM (Repeated Execution-Guided Invoking of Synthesis Model) omits the controller, relying entirely on repeated generator invocation over the evolving I/O specification. Empirical evaluation on DeepCoder-style program synthesis tasks reveals:

Category	Train	Length	Compose	Switch	NewOp
ExeDec	0.64	0.52	0.55	0.57	0.60
REGISM	0.60	0.45	0.53	0.55	0.59

• ExeDec exhibits superior accuracy, especially under length generalization and compositionality demands (e.g., +7 points on “Length”), due to its explicit subgoal decomposition.
• REGISM’s results approach ExeDec’s, and sometimes align more closely with ground-truth decompositions, indicating that execution-guided iterative synthesis is highly competitive in robustness (Zenkner et al., 11 Mar 2025).

4. Concrete Worked Example: Program Synthesis

Consider a DeepCoder task: compute $y = \text{Scanl1}(\max, x_0)$ with

$x_0 = [42, -48] \rightarrow y = [42, 42]$

ExeDec’s decomposition proceeds:

• Step 1 (Controller predicts subgoal): $G_0 = \{x_1 = [-48, 42]\}$
• Generator produces subprogram: $x_1 = \text{Sort}(x_0)$; executing yields $x_1 = [-48, 42]$
• Step 2 (Controller predicts subgoal): $G_1 = \{x_2 = [42, 42]\}$
• Generator produces subprogram: $x_2 = \text{Zip}(\max, x_0, x_1)$; executing yields the target

Final synthesized program:

x1 = Sort(x0) x2 = Zip(max, x0, x1) # yields final y

This illustrates controller–generator alternation: planning an intermediate subgoal, then generating a program step realizing that target (Zenkner et al., 11 Mar 2025).

5. Robotic Locomotion: Frequency-Based Gait Generator and PPO Controller

Controller–generator decomposition is also central in robotic locomotion. In frequency-based bipedal walking (Ates et al., 21 Nov 2025):

• Gait Generator (Controller): A multilayer perceptron, trained on MoCap data in the Fourier domain, produces a periodic reference gait $\hat{Q} = f_\theta(x) \in \mathbb{R}^{32\times 6}$ conditioned on speed and morphology $x = [v, \ell_r, \ell_l]$.
• PPO Torque Controller (Generator): Operates at 100 Hz, mapping proprioceptive observations and reference angles/velocities to continuous torque actions $a_t \in \mathbb{R}^7$.

The controller is only re-invoked when speed or morphology changes; the generator tracks the reference at every step, with a reward blending imitation of the spectral reference and direct task success. This two-stage approach enables velocity tracking within $\pm10\%$ up to 1.8 m/s, robust ramp walking ($>80\%$ success up to $15^\circ$), and graceful degradation on noisy terrains (Ates et al., 21 Nov 2025).

6. Domain Dependence, Limitations, and Future Directions

• Domain Sensitivity: In string-based program domains (e.g., RobustFill), explicit subgoal controllers yield nearly perfect accuracy and tightly match ground-truth decompositions. In list-based DSLs (like DeepCoder), controller accuracy degrades, with a tendency to over-decompose, and the generator’s robustness compensates mainly through iterative correction (Zenkner et al., 11 Mar 2025).
• Subgoal Search Complexity: Explicit controllers excel when the subgoal search space is constrained and well-structured; in dynamic, high-dimensional, or operation-rich domains, iterative generation with execution feedback dominates.
• Open Problems: Future research targets improved controller objectives (e.g., end-to-end or minimal-decomposition learning) and hybrid schemes that dynamically arbitrate between explicit subgoal planning and generator-driven iteration.

A plausible implication is that the modularity of controller–generator decomposition remains beneficial, but the optimal design and the relative import of each component is domain- and task-dependent.

7. Summary and Significance

Controller–generator decomposition provides a principled separation of planning and realization in both program synthesis and control robotics. In supervised synthesis (ExeDec), it enables explicit compositional generalization and subgoal interpretability; in RL-driven motor skills, it embeds structured motion priors as targets for robust, low-level adaptation. While explicit controllers can boost performance, performance margins depend on the task domain’s subgoal tractability and generator’s ability to recover from imperfect proposals. The approach’s modularity facilitates transfer, ablation, and rigorous component-level analysis, marking it as a foundational principle in current machine learning and systems research (Zenkner et al., 11 Mar 2025, Ates et al., 21 Nov 2025).