---
title: Accelerated Quadratic Transform (QT)
url: https://www.emergentmind.com/topics/accelerated-quadratic-transform-qt
type: topic
---

# Accelerated Quadratic Transform (QT)

Searching arXiv for the cited papers and closely related quadratic transform work.
Accelerated Quadratic Transform (QT) denotes two distinct algorithmic notions in recent arXiv literature. In fractional programming for communications and signal processing, it refers to accelerated variants of the quadratic transform for multi-ratio optimization, including nonhomogeneous surrogate construction and Nesterov extrapolation, with explicit links to WMMSE [2312.05726]. In quantum optimization toolchains, the same phrase can denote accelerated quadratisation: a minimum-preserving transformation from higher-order pseudo-Boolean or PUBO objectives to QUBO, accelerated by graph-based local updates and structural control over density and auxiliary variables [2411.19934]. The shared theme is quadratic reformulation, but the transformed objects, correctness criteria, and notions of acceleration are different.

## 1. Terminological scope and formal definitions

In the communications literature, QT is a reformulation technique for problems whose objective contains fractionally structured terms, especially Rayleigh-quotient expressions. The core equivalence used in that setting is that a problem of the form
\[
\max_{\underline{x}\in\mathcal X} \sum_{i=1}^n s_i^H(\underline{x}) G_i^{-1}(\underline{x}) s_i(\underline{x})
\]
is equivalent, in terms of optimal \(\underline{x}\), to
\[
\max_{\underline{x}\in\mathcal X,\;\underline{y}} \sum_{i=1}^n \Big[2\Re\{s_i^H(\underline{x})y_i\} - y_i^H G_i(\underline{x}) y_i\Big],
\]
with optimal auxiliary variables
\[
y_i^\star = G_i^{-1}(\underline{x}) s_i(\underline{x}).
\]
The transformed objective is quadratic separately in each block \(x_i\) and each \(y_i\) [2312.05726].

In the quantum-toolchain literature, QT is used in the sense of quadratisation. A pseudo-Boolean function is
\[
f:\{0,1\}^n\to\mathbb R,
\]
with unique multilinear representation
\[
f(x_1,\ldots,x_n)=\sum_{S\subseteq\{1,\ldots,n\}} \alpha_S \prod_{j\in S} x_j.
\]
A PUBO is a pseudo-Boolean function of arbitrary degree, while a QUBO is a pseudo-Boolean function of degree at most \(2\). A quadratisation is a quadratic pseudo-Boolean function
\[
f'(\vec x,\vec y), \qquad \deg(f')=2,
\]
such that
\[
f(\vec x)=\min_{\vec y\in\{0,1\}^m} f'(\vec x,\vec y)\qquad \forall \vec x\in\{0,1\}^n.
\]
This minimum-preserving property is the defining correctness criterion [2411.19934].

| Setting | Object transformed | Correctness notion |
|---|---|---|
| Fractional programming | Sum of weighted ratios or related FP objectives | Equivalent optimal \(\underline{x}\) and identical optimal values |
| Quantum quadratisation | Higher-order PBF / PUBO | \(f(\vec x)=\min_{\vec y} f'(\vec x,\vec y)\) |

A common source of confusion is that both uses of QT are genuinely “quadratic transforms,” yet they operate on different mathematical objects. In the first, the transform decouples ratios by auxiliary variables. In the second, it reduces polynomial degree by introducing auxiliary binary variables. This suggests a shared reformulation motif rather than a single unified algorithm.

## 2. Fractional-programming QT and its relation to MM and WMMSE

The fractional-programming formulation studied in "Accelerating Quadratic Transform and WMMSE" [2312.05726] centers on multi-ratio problems with
\[
M_i(\underline{x}) = \big(A_i x_i\big)^H\Bigg(\sum_{j=1}^n B_{ij} x_j x_j^H B_{ij}^H\Bigg)^{-1}\big(A_i x_i\big),
\]
where \(A_i\in\mathbb C^{\ell\times d}\), \(B_{ij}\in\mathbb C^{\ell\times d}\), and \(x_j\in\mathbb C^d\). The primary problem is
\[
\begin{aligned}
\text{maximize} \quad & f_o(\underline{x})=\sum_{i=1}^n \omega_i M_i(\underline{x})\\
\text{subject to} \quad & x_i\in\mathcal X_i,\quad i=1,\ldots,n,
\end{aligned}
\]
with \(\omega_i>0\) and convex sets \(\mathcal X_i\).

With the identifications
\[
s_i(\underline{x})=A_i x_i,\qquad G_i(\underline{x})=\sum_{j=1}^n B_{ij}x_jx_j^H B_{ij}^H,
\]
the QT objective becomes
\[
f_q(\underline{x},\underline{y})
= \sum_{i=1}^n \omega_i\Bigg[2\Re\{x_i^H A_i^H y_i\} -\sum_{j=1}^n y_i^H B_{ij} x_j x_j^H B_{ij}^H y_i\Bigg]
= \sum_{i=1}^n \Big[2\Re\{\omega_i x_i^H A_i^H y_i\}-x_i^H D_i x_i\Big],
\]
where
\[
D_i = \sum_{j=1}^n \omega_j B_{ji}^H y_j y_j^H B_{ji}.
\]
For fixed \(\underline{x}\), the auxiliary update is
\[
y_i^\star=\Bigg(\sum_{j=1}^n B_{ij} x_j x_j^H B_{ij}^H\Bigg)^{-1}(A_i x_i),
\]
and for fixed \(\underline{y}\), the \(x_i\)-update is the ellipsoidal projection
\[
x_i^\star=\arg\min_{x_i\in\mathcal X_i}\big\|D_i^{1/2}(x_i-\omega_i D_i^{-1}A_i^H y_i)\big\|_2.
\]
In the unconstrained case, or if the center lies in \(\mathcal X_i\), this reduces to \(x_i^\star=\omega_i D_i^{-1}A_i^H y_i\).

The standard QT iterations are an MM procedure. With
\[
\mathcal Y(\underline{x})=\underline{y},\qquad
y_i=\Big(\sum_{j=1}^n B_{ij}x_jx_j^H B_{ij}^H\Big)^{-1}A_i x_i,
\]
the surrogate
\[
r_q(\underline{x}\mid \underline{x}^{k-1})=f_q\big(\underline{x},\mathcal Y(\underline{x}^{k-1})\big)
\]
is a lower bound on \(f_o(\underline{x})\), and it is tight at the current point. Shen and Yu’s MM interpretation therefore yields monotone increase of \(f_o\) and convergence to a stationary point for differentiable \(f_o\) [2312.05726].

The same framework recovers WMMSE for the logarithmic objective
\[
g_o(\underline{x})=\sum_{i=1}^n \mu_i \log\big(1+M_i(\underline{x})\big),
\qquad \|x_i\|_2^2\le \rho.
\]
Using the Lagrangian dual transform, one constructs a lower bound
\[
h(\underline{x},\underline{t})
=\sum_{i=1}^n \mu_i(1+t_i)\,\hat M_i(\underline{x})
+\sum_{i=1}^n \big[\mu_i\log(1+t_i)-\mu_i t_i\big],
\]
with \(t_i^\star=M_i(\underline{x})\). Once \(\mu_i(1+t_i)\) are regarded as weights, QT applies to \(\hat M_i\). The classical WMMSE algorithm is retrieved when the homogeneous QT is used with the usual identifications between beamformers, receive filters, and weights; \(y_i\) is essentially a scaled MMSE receiver, while \(t_i\) plays the role of WMMSE weights [2312.05726].

## 3. Acceleration by nonhomogeneous surrogates and Nesterov extrapolation

The acceleration mechanism in the fractional-programming literature proceeds through a nonhomogeneous bound. For Hermitian \(L,K\in\mathbb C^{d\times d}\) with \(L\preceq K\),
\[
x^H L x \le x^H K x + 2\Re\{x^H(L-K)z\} + z^H(K-L)z,
\]
with equality when \(z=x\). Choosing \(L=D_i\) and \(K=\lambda_i I\) with \(\lambda_i\ge \lambda_{\max}(D_i)\) yields the nonhomogeneous QT objective
\[
\begin{aligned}
f_t(\underline{x},\underline{y},\underline{z})
&= \sum_{i=1}^n \Big[
2\Re\{\omega_i x_i^H A_i^H y_i + x_i^H(\lambda_i I-D_i)z_i\}\\
&\qquad\qquad + z_i^H(D_i-\lambda_i I)z_i - \lambda_i x_i^H x_i
\Big].
\end{aligned}
\]
The resulting \(x_i\)-update becomes a spherical projection,
\[
x_i^\star
=\mathcal P_{\mathcal X_i}\Big(z_i + \tfrac{1}{\lambda_i}(\omega_i A_i^H y_i - D_i z_i)\Big).
\]

After updating \(\underline{y}\), the paper derives
\[
\omega_i A_i^H y_i^k - D_i^k x_i^{k-1}
= \frac12 \frac{\partial f_o(\underline{x}^{k-1})}{\partial x_i^c},
\]
so the nonhomogeneous QT iteration is exactly
\[
x_i^k
= \mathcal P_{\mathcal X_i}\Big(x_i^{k-1}+\tfrac{1}{2\lambda_i^k}\frac{\partial f_o(\underline{x}^{k-1})}{\partial x_i^c}\Big).
\]
In this form, nonhomogeneous QT is a gradient projection method rather than merely an MM construction [2312.05726].

The local convergence-rate analysis is carried out near a strict local maximizer \(\underline{x}^*\) inside a Euclidean ball
\[
\mathcal X=\{\underline{x}:\|\underline{x}-\underline{x}^*\|_2\le R\},
\]
under a negative-definite Hessian condition and an \(L\)-Lipschitz Hessian. Letting
\[
v_k=f_o(\underline{x}^*)-f_o(\underline{x}^k),
\]
the paper proves
\[
v_1 \le \frac{\Lambda R^2}{2}+\frac{L R^3}{6},
\qquad
v_k \le \frac{2\Lambda R^2+\frac{2}{3}LR^3}{k+3},\quad k\ge 2,
\]
with \(\Lambda=\Lambda_q\) for standard QT and \(\Lambda=\Lambda_t\) for nonhomogeneous QT. Both therefore achieve an \(O(1/k)\) local objective-error rate, and because \(0\le \Lambda_q\le \Lambda_t\), the standard QT has the tighter surrogate and the better constant.

Acceleration is then obtained by Nesterov extrapolation on the primal variables:
\[
\nu_i^{k-1}=x_i^{k-1}+\eta_{k-1}(x_i^{k-1}-x_i^{k-2}),
\qquad
\eta_k=\max\left\{\frac{k-2}{k+1},0\right\}.
\]
The extrapolated update is
\[
x_i^k=\mathcal P_{\mathcal X_i}\Big(\nu_i^{k-1}
+\frac{1}{2\lambda_i^k}\frac{\partial f_o(\underline{\nu}^{k-1})}{\partial x_i^c}\Big).
\]
Under a \(C\)-Lipschitz continuity assumption on \(\nabla f_o\) and \(\lambda_i^k=1/(2C)\), the paper gives
\[
f_o(\underline{x}^*)-f_o(\underline{x}^k)
\le \frac{2C\,[f_o(\underline{x}^*)-f_o(\underline{x}^0)]}{(k+1)^2},
\qquad k\ge 1,
\]
that is, an \(O(1/k^2)\) rate [2312.05726].

A common misconception is that this accelerated QT remains a pure MM algorithm. It does not: the extrapolated variant is justified from the gradient-projection perspective, and it may not be strictly monotone at every step.

## 4. Communications applications: ISAC and massive MIMO

Two application domains are used to instantiate the accelerated fractional-programming QT. The first is integrated sensing and communications (ISAC), where the objective is
\[
\max \; J_\theta + \omega_1\mathrm{SINR}_1 + \omega_2\mathrm{SINR}_2
\]
subject to \(\|w_i\|_2^2\le P_{\max}\). Here
\[
J_\theta=\alpha w_1^H \dot{A}^H Q^{-1}\dot{A} w_1,
\]
while \(\mathrm{SINR}_1\) and \(\mathrm{SINR}_2\) have the same ratio structure as the general model. QT introduces \(y_r\in\mathbb C^{N_r}\) for the Fisher-information term and \(y_1,y_2\in\mathbb C^N\) for the SINRs; the corresponding updates for \(y_r,y_1,y_2\) are closed-form, and the homogeneous QT yields closed-form updates for \(w_1,w_2\) involving \((\eta_i I+D_i)^{-1}\) with \(\eta_i\) chosen by bisection to satisfy the power constraint [2312.05726].

For the nonhomogeneous QT in ISAC, the primal updates are first-order:
\[
\hat w_1=z_1+\tfrac{1}{\lambda_1}(\alpha \dot A^H y_r+\omega_1 H_{11}^H y_1-D_1 z_1),\qquad
\hat w_2=z_2+\tfrac{1}{\lambda_2}(\omega_2 H_{22}^H y_2-D_2 z_2),
\]
followed by projection onto the power ball. Extrapolation is added at the level of \(w_i\). With network parameters \(M=64\), \(N=2\), \(N_r=72\), \(\omega_1=\omega_2=10^5\), \(\sigma_1^2=\sigma_2^2=\sigma_r^2=-80\) dBm, and \(P_{\max}=20\) dBm, all three algorithms—QT, GQT, and EQT—achieve essentially the same objective; QT is slightly faster in iterations, but GQT and EQT converge much faster in time, in about \(0.02\) s, while QT has not converged by \(0.05\) s [2312.05726].

The second application is weighted sum-rate maximization in multi-cell massive MIMO:
\[
\begin{aligned}
\text{maximize}\quad &
\sum_{\ell=1}^L \sum_{q=1}^Q \mu_{\ell q}\log\big(1+\mathrm{SINR}_{\ell q}\big)\\
\text{subject to}\quad &
\sum_{q=1}^Q \|w_{\ell q}\|_2^2 \le P_{\max},\quad \ell=1,\ldots,L.
\end{aligned}
\]
The classical WMMSE precoder update requires repeated inversion of \(M\times M\) matrices per BS and per bisection iteration, which is described as very expensive when \(M\) is large. The GQT reformulation replaces this by updates of the form
\[
\hat w_{\ell q}
=z_{\ell q}+\frac{1}{\hat\lambda_\ell}\Big(\mu_{\ell q}(1+t_{\ell q})H_{\ell q,\ell}^H y_{\ell q}-\hat D_\ell z_{\ell q}\Big),
\]
followed by projection to satisfy the per-BS power constraint. No large \(M\times M\) matrix inversions appear in this GQT-based beamforming; only \(N\times N\) inversions are required for the receive filters, with \(N\ll M\) [2312.05726].

In the 7-cell wrapped-around network with 6 users per cell, \(M=128\), \(N=4\), \(P_{\max}=20\) dBm, and noise \(-90\) dBm, QT converges in fewer iterations than GQT and EQT, consistent with the tighter surrogate. In time, however, GQT and especially EQT converge much faster, and the speedup over QT is substantial because large matrix inversions dominate QT and WMMSE in this regime [2312.05726].

## 5. Accelerated quadratisation for quantum toolchains

In "It's Quick to be Square: Fast Quadratisation for Quantum Toolchains" [2411.19934], acceleration refers not to iterative convergence of a continuous optimization method but to classical preprocessing for PUBO-to-QUBO transformation. The setting is the standard pseudo-Boolean, PUBO, and QUBO formalism on \(\{0,1\}\)-variables. QUBO is treated as the hardware-friendly abstraction for many NISQ-level platforms because typical devices only support \(2\)-local couplings.

The primitive reduction uses a standard Boros-style gadget. To replace \(x_i x_j\) by a new auxiliary binary \(y_h\), the construction adds
\[
p(x_i,x_j,y_h)=3y_h+x_i x_j-2x_i y_h-2x_j y_h,
\]
which satisfies
\[
x_i x_j=y_h \Rightarrow p=0,\qquad x_i x_j\ne y_h \Rightarrow p>0.
\]
By adding a sufficiently large positive multiple \(c\,p\), the optimum enforces \(y_h=x_i x_j\). Repeated pair reductions yield a quadratic function. The baseline iterative algorithm differs only in its choice of the next variable pair to reduce. Earlier heuristics were Dense, Medium, and Sparse: Dense chooses the pair appearing most often across all monomials and tends to maximize degree-\(2\) density \(d_2\); Sparse chooses a first pair from a highest-degree monomial and tends to minimize \(d_2\). Dense and Medium, however, are described as computationally prohibitive, leading to runtimes of days even for modest instances because they repeatedly recompute pair frequencies over all monomials [2411.19934].

The accelerated alternative is Local Structure Reduction (LSR), a two-stage algorithm based on a multigraph \(G_f=(V_f,E_f)\). Each variable \(x_i\) is a node. For each monomial \(m=\alpha_S\prod_{j\in S} x_j\) with monomial index \(z\), and each unordered pair \(\{i,j\}\subseteq S\), the graph contains an edge \((i,j,z)\). The multiplicity
\[
\beta_f(i,j)=|E_f^{i,j}|
\]
counts how many monomials contain both \(x_i\) and \(x_j\), and
\[
R_f:\beta \mapsto \{\{i,j\}:\beta_f(i,j)=\beta\}
\]
organizes pairs by multiplicity. The key observation is that pair-frequency counting can be replaced by local inspection of edge multiplicities.

Several structural properties enable the speedup. If \(\beta_f(i,j)>1\), then some higher-order monomial contains \(x_i,x_j\). If one reduces \(x_i x_j\), the affected monomials are exactly those indexed by
\[
Z=\{z:(i,j,z)\in E_f^{i,j}\}.
\]
Penalty-term edges are invariant under later reductions, so they may be stored separately from the graph used for structural decisions. Only edges incident to \(i\) or \(j\) can change, and only nodes connected to both are relevant for nontrivial updates. This locality turns the update cost into a function of the neighborhood around the chosen pair rather than the full monomial set [2411.19934].

Stage 1 of LSR is graph-based. With the ordered multiplicity set \(B_f=\{\beta_1<\beta_2<\dots<\beta_{|B|}\}\), the algorithm defines
\[
\tilde\beta_q=\beta_{\lceil q\cdot |B_f|\rceil},
\]
selects a random pair from \(R_f(\tilde\beta_q)\), replaces occurrences of the pair by a new variable, updates only the affected monomials and graph neighborhoods, and adds the Boros gadget to a separate penalty pseudo-Boolean function. This percentile parameter \(q\in[0,1]\) continuously interpolates between Dense-like behavior at \(q=1.0\) and Sparse-like behavior near \(0\).

Stage 2 begins when the graph has no multi-edges:
\[
\forall i,j\in V:\beta(i,j)\le 1.
\]
At that point, remaining degree-\(>2\) monomials share no variable pairs and can be reduced independently by a multi-replacement Boros scheme. For a monomial \(m=x_1x_2\cdots x_k\), multiple disjoint pairs can be replaced in one step, halving the degree roughly in one iteration. The paper states that \(|m|\) becomes about \(|m|/2\) after one `multi_reduce`, so \(\tau=\Theta(\log |m|)\) iterations are sufficient, but each iteration costs \(\Theta(|m|)\), making the total cost per monomial \(\Theta(|m|)\) [2411.19934].

Correctness remains the usual minimum-preserving condition:
\[
f(\vec x)=\min_{\vec y} f'(\vec x,\vec y)
\]
for sufficiently large user-chosen \(c>0\). The graph is described as an organizational and efficiency device; it does not alter the semantics of the reduction.

## 6. Structural trade-offs, complexity, and limitations across the two lineages

The two accelerated QT lineages optimize different bottlenecks. In the fractional-programming setting, the bottleneck is wall-clock convergence of iterative solvers. Standard QT often converges in fewer iterations because its surrogate is tighter, but its per-iteration cost can be high due to matrix inversions and ellipsoidal projections. GQT and EQT replace the \(x\)-update by matrix-vector products and Euclidean projections, so they may require more iterations yet less time overall; the paper explicitly notes that QT converges in fewer iterations but is slower in time, whereas GQT and EQT are faster in time because their iterations are cheaper [2312.05726].

In the quantum-toolchain setting, the bottleneck is classical preprocessing time for quadratisation together with control of the resulting QUBO structure. For Stage 1 of LSR, preprocessing builds a monomial dictionary, the multigraph, and the multiplicity map. Per iteration, pair selection costs
\[
\mathcal O(\log |B_{f_{t-1}}|),
\]
identification of affected monomials costs
\[
\mathcal O(\beta_{f_{t-1}}(i,j)),
\]
and graph and monomial updates scale with
\[
\mathcal O\Big(\log |B_{f_{t-1}}|\cdot \sum_{z\in Z}|m_z|\Big),
\]
where the summation is local to monomials containing the selected pair. The paper emphasizes that this is close to the best possible asymptotic complexity up to logarithmic factors, because any reduction step must touch at least \(\beta_{f_{t-1}}(i,j)\) monomials [2411.19934].

The structural control parameter \(q\) creates a direct trade-off between auxiliary-variable count and degree-\(2\) density \(d_2\). At \(q=1.0\), LSR behaves like Dense: fewer iterations, fewer new variables, and higher \(d_2\). Lower \(q\) yields more iterations, more auxiliary variables, and lower \(d_2\). This is relevant because, in NISQ-oriented pipelines, the number of variables affects qubit count, while \(d_2\) affects embedding into hardware graphs, chain lengths on annealers, and ansatz connectivity for QAOA. On random degree-\(4\) pseudo-Boolean functions with uniform densities \(d_1=d_2=d_3=d_4\), monomial-based Dense and Medium exceed a day beyond about \(39\) variables, while LSR runs in seconds; its runtime curves for \(q=0.5\), \(0.8\), and \(1.0\) are very similar, so the selection policy affects structure more than runtime [2411.19934].

These two literatures also have distinct limitations. In fractional programming, the \(O(1/k^2)\) guarantee for the extrapolated method assumes a global Lipschitz constant \(C\) for \(\nabla f_o\), and the convergence-rate analysis for QT and nonhomogeneous QT is local, around a strict local optimum. Moreover, accelerated QT is not guaranteed to be monotone at every step because it is no longer a pure MM procedure [2312.05726]. In quantum quadratisation, the penalty scaling \(c\) is left to the user, hardware-specific information is not yet integrated into pair selection, and the implementation uses standard Python dictionaries rather than perfect hashing or hand-optimized data structures. The paper also notes possible parallelization of Stage 2 and, under locality conditions, Stage 1, but does not implement it [2411.19934].

A persistent misconception is that “acceleration” has a uniform meaning across all uses of QT. In fact, the communications usage refers to convergence-rate and wall-clock acceleration of an iterative FP solver, while the quantum-toolchain usage refers to asymptotically and empirically faster construction of a minimum-preserving QUBO representation. The phrase therefore names two separate, domain-specific quadratic reformulation programs rather than a single canonical algorithm.

Source: https://www.emergentmind.com/topics/accelerated-quadratic-transform-qt