---
title: Iterative Youla–Kučera Control Parameterization
url: https://www.emergentmind.com/topics/iterative-youla-kucera-parameterization
type: topic
---

# Iterative Youla–Kučera Control Parameterization

Searching arXiv for recent papers on iterative Youla–Kučera parameterization and related variants.
Iterative Youla–Kučera parameterization denotes a class of controller-synthesis and controller-learning constructions in which the classical Youla–Kučera parameter is updated, deployed, or composed across iterations while preserving a stability-structured design space. In the literature represented here, “iterative” appears in several distinct but related senses: as a feedforward iterative learning control law unified with feedback design through a single Youla parameter in robotic grasping [2407.19279]; as a staged loop-shaping procedure that adds narrow-band rejection filters sequentially for precision motion control [2508.14309]; and as an optimization or reinforcement-learning loop in which the search variable is a stable Youla parameter, so that every intermediate controller remains stabilizing by construction [2506.01226], [2304.03422], [2310.14098]. A further related line uses a Youla–Kučera–type convex parameterization inside an iterative symmetric Gauss–Seidel ADMM algorithm for $\mathcal H_\infty$ guaranteed-cost synthesis [2001.00708]. Taken together, these works present iterative Youla–Kučera parameterization not as a single algorithm, but as a design principle for organizing feedback, feedforward learning, loop shaping, and learning-based control around a stable free parameter.

## 1. Classical parameterization and the role of iteration

The common foundation is the classical Youla–Kučera result. For a plant \(P\) and a nominal stabilizing controller, all internally stabilizing controllers can be expressed through a stable, proper free parameter \(Q\). One formulation is
\[
C(z)\;=\;\frac{C_0(z)\;+\;Q(z)}{1\;-\;P(z)\,Q(z)},
\]
where \(Q(z)\) is any stable, proper transfer function chosen by the designer [2407.19279]. A doubly coprime version writes
\[
K(z)\;=\;(\widetilde X(z)\;-\;Q(z)\,M(z))^{-1}\bigl(\widetilde Y(z)\;+\;Q(z)\,N(z)\bigr),
\qquad Q(z)\in\mathcal{RH}_\infty,
\]
and in the special case that \(P\) is stable and strictly proper, this reduces to
\[
K(z)\;=\;\frac{Q(z)}{1 - P(z)\,Q(z)}
\]
with \(Q(z)\) any stable, proper transfer function [2310.14098].

In this setting, iteration does not alter the basic theorem; rather, it changes how \(Q\) is constructed or refined. One strand updates a feedforward signal across trials while tying the learning filter to the same \(Q\) that shapes the feedback loop [2407.19279]. Another strand decomposes a difficult high-order loop-shaping task into multiple stages, each introducing a low-order \(Q_k\) [2508.14309]. In learning-based control, the iterative element is the policy update: parameters of a stable Youla map are optimized by gradient methods or reinforcement learning while the closed loop remains in the stabilizing class throughout training [2506.01226], [2310.14098]. This suggests that the iterative aspect is architectural rather than purely algebraic: the Youla parameter becomes the object on which repeated refinement operates.

## 2. Unified feedback–feedforward iterative learning control

A concrete extension appears in grasping force control for a cable-driven robotic hand, where classical Youla parameterization is extended “into a feedforward iterative learning control algorithm (ILC)” [2407.19279]. The central feature is a unified design parameter: “The same Youla parameter \(Q(z)\) that shapes feedback also enters the feedforward (learning) filter” [2407.19279]. The architecture uses three design blocks:
\[
D(z)\;=\;\text{low-pass filter},\qquad Q(z)\;=\;\text{Youla parameter},\qquad L(z)\;=\;\text{learning filter}.
\]

The iterative update law is
\[
u_j^{f}(z)\;=\;D(z)\,\bigl[u_{j-1}^{f}(z)\;+\;L(z)\,e_{j-1}(z)\bigr],
\]
with \(e_j(k)=r(k)-y_j(k)\) [2407.19279]. When \(D(z)\approx 1\), this reduces to the familiar form
\[
u_j^{f}(z)\;=\;u_{j-1}^{f}(z)\;+\;L(z)\,e_{j-1}(z).
\]

The closed-loop error dynamics are written as
\[
e_j(z)=T_u(z)\,u_j^{f}(z)\;+\;T_r(z)\,r(z),
\]
where
\[
T_u(z)\;=\;-\bigl[I + P(z)\,C(z)\bigr]^{-1}P(z)\,C(z),\qquad
T_r(z)\;=\;\bigl[I + P(z)\,C(z)\bigr]^{-1}.
\]
Substitution of the learning law yields the one-step update
\[
e_{j+1}(z)\;=\;\bigl[\,I \;+\;T_u(z)\,L(z)\bigr]\;e_j(z).
\]
A particular choice,
\[
L(z)\;=\;\frac{1 + P(z)\,C_0(z)}{P(z)\,\bigl(C_0(z)+Q(z)\bigr)},
\]
makes the iteration-to-iteration multiplier “ideally zero (in exact-model arithmetic)” [2407.19279]. In practice, convergence is tied to
\[
\left\|\,I + T_u(z)\,L(z)\right\|_{\infty} < 1
\quad\Longrightarrow\quad
\lim_{j\to\infty} e_j(k)\to 0,
\]
which imposes stability and small-gain conditions on \(Q(z)\) [2407.19279].

The same paper emphasizes a one-to-one mapping between the desired closed-loop transfer and the Youla filter:
\[
G_c(z)\;=\;\frac{P(z)\bigl(C_0(z)+Q(z)\bigr)}{1+P(z)\,C_0(z)}.
\]
Accordingly, bandwidth, disturbance rejection, and robustness are shaped through \(G_c(z)\) via \(Q(z)\), while learning speed is governed by \(I+T_uL\) [2407.19279]. The implementation recipe is explicit: identify \(P(z)\), choose \(C_0(z)\), specify a desired \(G_c(z)\), solve for \(Q(z)\), form \(C(z)\) and \(L(z)\), pick \(D(z)\) as a low-pass, and run the ILC loop until convergence [2407.19279].

A common misconception is that ILC and Youla design are merely juxtaposed in this construction. The paper instead states that “both the feedback and feedforward controllers are parameterized over one unified design parameter” [2407.19279]. The significance is therefore not simply that learning is added to a feedback loop, but that the free Youla parameter coordinates both channels.

## 3. Iterative loop shaping for precision motion control

A different meaning of iterative Youla–Kučera parameterization is developed for “multi-band disturbance rejection using an iterative Youla-Kucera parameterization technique” [2508.14309]. Here the starting point is an inversion-based form. For a baseline loop gain \(L_0(z)=P(z)C_0(z)\), one sets
\[
L_0(z)\approx z^{-m}\,\hat L^{-1}(z),
\]
with \(\hat L^{-1}(z)\) a stable inversion, and obtains
\[
C_Q(z)\;=\;\frac{\,1 + z^{-m}\,\hat L^{-1}(z)\,Q(z)\,}{\,1 \;-\; z^{-m}\,Q(z)\,}.
\]
The corresponding sensitivity is approximated by
\[
S(z)\approx S_0(z)\,\bigl(1 - z^{-m}Q(z)\bigr),
\qquad
S_0(z)=\frac1{1+L_0(z)},
\]
so that \(Q(z)\) appears only in the shaping factor \(1-z^{-m}Q(z)\) [2508.14309]. The paper describes this as decoupling filter design from the plant.

The iterative algorithm is motivated by a numerical difficulty: “Directly designing a single high-order \(Q(z)\) for many narrow-band notches can be numerically ill-conditioned” [2508.14309]. The remedy is to build the loop shape in stages. For \(k=1,2,\dots,K\), a low-order \(Q_k(z)\in\mathcal S\) is designed for a small group of target frequencies, and the controller add-on is formed as
\[
\tilde C_k(z)
= \frac{\tilde C_{k-1}(z)\;+\;z^{-m}\,\hat L^{-1}(z)\,Q_k(z)}
{\,1 - z^{-m}\,Q_k(z)\,}.
\]
The augmented loop gain and sensitivity are then updated, with
\[
S_k(z)\approx S_0(z)\prod_{i=1}^k\bigl(1-z^{-m}Q_i(z)\bigr),
\]
and model-order reduction is applied at each stage [2508.14309].

Multi-band notch shaping is realized through the polynomial pair
\[
A_\zeta(z)
= \prod_{i=1}^n\bigl(1-2\zeta\cos\omega_i\,z^{-1}+\zeta^2\,z^{-2}\bigr),
\qquad \zeta\in\{\alpha,\beta\},\;0<\alpha<\beta\le1,
\]
together with
\[
1 - z^{-m}Q(z)
= \frac{A_\beta(z)}{A_\alpha(z)}\;K(z),
\]
where \(K(z)\) is chosen to ensure causality and properness [2508.14309]. The paper identifies two design knobs. Depth tuning uses \(Q(z)\mapsto gQ(z)\), \(0\le g\le 1\), so that smaller \(g\) gives less notch depth and less off-band amplification. Width adjustment chooses \(\alpha\) and \(\beta\) to set the 3 dB bandwidth \(B\) [2508.14309].

The paper places strong emphasis on numerical robustness and waterbed management. High-order all-band designs can place poles and zeros extremely close to \(|z|=1\), and finite-precision arithmetic can then cause pole migration outside the unit circle and erratic sensitivity [2508.14309]. The staged procedure avoids having to design more than a handful of notches at once; model-order reduction strips away spurious high-frequency dynamics; and depth scaling \(g\) makes the waterbed trade-off explicit [2508.14309]. In a dual-stage hard-disk-drive case study, twelve narrow-band disturbance frequencies are grouped into six pairs, yielding “deep (30–50 dB) attenuation at all twelve frequencies,” with “up to 10 dB deeper notches and smoother off-band behavior” than a conventional ESPRC multi-second-order-notch approach; reduced-order controllers of 48th and 24th order closely match the full 240th-order design [2508.14309].

This formulation addresses a second common misconception: iterative Youla design is not necessarily about repeating the same learning trial. In precision motion control, “iterative” refers instead to staged synthesis of the final feedback architecture, each stage remaining inside an all-stabilizing Youla–Kučera form [2508.14309].

## 4. Stable-by-design learning and the Youla parameter as policy class

In learning-based control, iterative Youla–Kučera parameterization appears as repeated optimization over a stable controller class. One framework studies “parameterizations of stabilizing nonlinear policies for learning-based control” and proposes “a structure based on a nonlinear version of the Youla-Kucera parameterization combined with robust neural networks such as the recurrent equilibrium network (REN)” [2506.01226]. The plant is partially observed,
\[
x_{t+1}=f\bigl(x_t,\eta_t,u_t\bigr)+w_t,\qquad y_t=h(x_t)+v_t,
\]
and a stabilizing nominal output-feedback controller and observer generate an innovation
\[
\tilde y_t=y_t-\hat y_t.
\]
The Youla augmentation adds
\[
\tilde u_t=\Q(\eta_t,\tilde y_t),
\]
yielding the controller
\[
u_t =k(s_t,\eta_t,y_t)\;+\;h_q\bigl(q_t,\eta_t,y_t-h(\hat x_t)\bigr)
\]
with internal state \(q_t\) for the Youla map [2506.01226].

The principal claim is structural: “By construction, any choice of \(\Q\) that itself is contracting & Lipschitz preserves closed-loop stability” in the disturbance-free setting, and under disturbances a weaker “d-tube contraction and Lipschitzness” is maintained [2506.01226]. The REN architecture parameterizes \(\Q\) through unconstrained weight-bias parameters \((W,b)\), with slope-restricted activations, so that if the associated linear-time-invariant model is contracting and the activation slopes are \(\le 1\), the REN is contracting and Lipschitz for all \((W,b)\) [2506.01226]. Optimization is then iterative in the usual machine-learning sense:
\[
\theta_{k+1}=\theta_k \;-\;\eta_k\,\nabla_\theta J(\theta_k),
\]
where \(\theta=(W,b)\) parameterizes \(\Q_\theta\) and \(J(\theta)\) is an expected finite-horizon cost [2506.01226]. The paper states that the parameterization is unconstrained and can be searched over with first-order methods while “always ensuring closed-loop stability by construction” [2506.01226].

Related deep-RL work develops a “modular framework for stabilizing deep reinforcement learning control” using Youla–Kučera parameterization to define the search domain [2304.03422], and then a broader framework for “optimizing over all stable behavior” [2310.14098]. In these works, one long persistently exciting input-output trajectory is used to build Hankel matrices of depth \(L\), and Willems’ fundamental lemma is used to represent valid trajectories and predict a one-step-ahead output from a coefficient vector \(\alpha\) [2304.03422], [2310.14098]. This produces a data-driven internal model without identifying \((A,B,C,D)\).

The Youla parameter \(Q\) is then represented either as a stable linear operator or as a nonlinear neural operator. In the nonlinear construction, jointly trained networks \(\hat f_\theta\) and \(V_\theta\) enforce a global contraction condition
\[
V_\theta\bigl(f_\theta(z)\bigr)\le \beta V_\theta(z),
\qquad 0<\beta<1,
\]
so that every parameter vector \(\theta\) defines a globally stable operator \(Q_\theta\) [2304.03422]. The overall RL objective is the standard discounted return
\[
J(\theta)=\E\Bigl[\sum_{t=0}^\infty \gamma^t r(s_t,a_t)\Bigr],
\]
and actor–critic or related methods can update \(\theta\) without explicit stability projections because “every intermediate policy” yields a stabilizing controller [2304.03422], [2310.14098].

These results frame iteration as search over the Youla parameter rather than search over arbitrary controller coefficients. A plausible implication is that the Youla parameter functions as a stability-preserving coordinate chart for optimization: improvement steps may be nonconvex and data-driven, but they remain confined to a set of stabilizing policies.

## 5. Data-driven and nonlinear realizations

The data-driven formulations add a further layer to iterative Youla–Kučera parameterization by replacing identified models with behavioral constructions. Using input-output data \(\{u_t,y_t\}\), Hankel matrices \(H_L(u)\) and \(H_L(y)\) encode all length-\(L\) trajectories of the unknown LTI plant under the assumptions of Willems’ lemma [2304.03422], [2310.14098]. At each time step, one solves
\[
\begin{bmatrix}H_L(u)\ H_L(y)\end{bmatrix}\alpha
=
\begin{bmatrix}\bar u\\\bar y\end{bmatrix}
\]
for \(\alpha\), computes the shifted output \(\bar y'=H'_L(y)\alpha\), forms the error command \(\hat r_t=e_t+\bar y_L\), and feeds that signal into the stable Youla operator \(Q\) [2310.14098]. Theorem 2.1 in the latter work states that for a stable, strictly proper LTI plant and stable LTI parameter \(Q\), the purely data-driven algorithm reproduces exactly the classical Youla control law \(K=Q/(1-PQ)\) [2310.14098].

The same paper analyzes noise robustness of the data-driven internal model. With zero-mean Gaussian output noise, the internal Hankel dynamics matrix \(H^+H'\) has spectral radius \(<1+\epsilon_N\to 1\) with high probability as \(N\to\infty\) [2310.14098]. This does not state exact asymptotic closed-loop performance under noise, but it does show that the data-driven simulator remains contractive rather than numerically explosive.

For stable linear operators, the paper gives an explicit factorization: a discrete-time matrix \(A_q\) is Schur if and only if there exist orthogonal \(U,V\), a diagonal \(D\) with \(\|D\|<1\), and lower-triangular \(L\) with positive diagonal such that
\[
A_q=L^{-1}UDV^\top L.
\]
The associated quadratic Lyapunov function yields automatic Schur stability [2310.14098]. For nonlinear operators, a Lyapunov-network construction rescales the proposal dynamics whenever a one-step decrease condition is violated, guaranteeing global exponential stability of the autonomous dynamics of \(Q\) for every \(\theta\) [2310.14098].

These constructions show that iterative Youla–Kučera parameterization extends beyond rational transfer-function tuning. The stable free parameter can be realized through recurrent neural architectures, Lyapunov-certified operators, or data-driven behavioral simulators, provided the surrounding architecture retains the Youla property that stable \(Q\) implies closed-loop stability.

## 6. Convex variants, optimization structure, and scope

A further related development uses “a variant of the Youla-Kucera parameterization” to convexify static \(\mathcal H_\infty\) guaranteed-cost control under parametric uncertainty [2001.00708]. The parameter is no longer the standard transfer-function \(Q\), but a static “Youla-like” matrix variable
\[
W=\begin{bmatrix}W_1&W_2\\ W_2^\top&W_3\end{bmatrix},
\qquad
K=W_2^\top W_1^{-1},
\]
with convex constraints
\[
W\succeq 0,\qquad \Theta_1(W,\mu)\preceq 0,\qquad \mu>0.
\]
Under affine polyhedral uncertainty, the same Riccati-type inequality is enforced at each extreme vertex [2001.00708].

The optimization is then solved by a symmetric Gauss–Seidel ADMM algorithm. Consensus variables \(Y_0=W\), \(Y_i=\mathcal G_i(W,\mu)\), and \(Y_{N+1}=\mu\) define an augmented Lagrangian, and each iteration consists of a parallel \(Y\)-update, a backward sweep for an intermediate \(\bar\mu\) and \(W\), a forward sweep refining \(\mu\), and a dual update
\[
Z^{k+1}=Z^k + \tau\sigma\bigl(Y^{k+1}-\mathcal H(W^{k+1},\mu^{k+1})\bigr),
\qquad \tau\in\Bigl(0,\frac{1+\sqrt5}{2}\Bigr)
\]
[2001.00708]. Under the paper’s assumptions, the sequence converges to a KKT point, primal and dual residuals vanish, and in the stated special case “global linear convergence is guaranteed” [2001.00708].

This line is not an “iterative Youla–Kučera parameterization” in the same sense as staged loop shaping or ILC, because the iteration is in the optimizer rather than in the control architecture. Nonetheless, it belongs to the broader family of iterative Youla-based methods: the stabilizing-controller search is transferred to a parameter space with more favorable computational structure, and iteration occurs there.

## 7. Interpretation, trade-offs, and recurring themes

Across these formulations, several themes recur. First, the free parameter is chosen so that stability is inherited structurally. In classical linear settings, \(Q\in\mathcal{RH}_\infty\) yields internally stabilizing controllers [2310.14098]. In the ILC extension, the same \(Q(z)\) determines both the feedback controller and the learning filter [2407.19279]. In precision motion control, each low-order \(Q_k\) is inserted through an inversion-based all-stabilizing architecture [2508.14309]. In nonlinear learning-based control, a contracting and Lipschitz Youla map preserves closed-loop stability properties, or a disturbance-tube analogue thereof [2506.01226].

Second, the principal trade-offs are repeatedly expressed through \(Q\). In robotic force control, bandwidth, disturbance rejection, and robustness are shaped through \(G_c(z)\) via \(Q(z)\), while learning speed depends on the loop gain \(I+T_uL\) [2407.19279]. In precision loop shaping, smaller depth scaling \(g\) sacrifices notch depth for less off-band sensitivity amplification, and notch width is separately adjustable [2508.14309]. In learning-based settings, the policy class remains stability-certified, but optimization remains nonconvex and thus generally offers only convergence to a stationary point under standard assumptions [2506.01226].

Third, the word “iterative” carries multiple technical meanings. It may denote iteration over trials in ILC [2407.19279], staged composition of controller add-ons in multi-band notch synthesis [2508.14309], repeated policy updates in deep RL or gradient-based search [2304.03422], [2310.14098], [2506.01226], or iterative splitting in convex optimization [2001.00708]. A common misconception is to treat these as incompatible usages. The literature instead suggests a unifying interpretation: once controller synthesis is reparameterized by a stable Youla variable, many forms of repeated refinement become admissible without leaving the stabilizing set.

Finally, the recent body of work expands the scope of Youla–Kučera methods beyond classical LTI feedback synthesis. The parameter can mediate feedback–feedforward unification, multi-band sensitivity shaping, data-driven internal modeling, neural nonlinear control, and convex robust control. This suggests that “iterative Youla–Kučera parameterization” is best understood as a family of architectures in which repeated design, learning, or optimization steps are performed on a stabilizing free parameter rather than directly on the controller itself [2407.19279], [2508.14309], [2506.01226], [2310.14098].

Source: https://www.emergentmind.com/topics/iterative-youla-kucera-parameterization