QFlowNet: Fast Unitary Synthesis

• The paper introduces QFlowNet, which leverages a GFlowNet and Transformer encoder to sequentially generate quantum circuits from sparse terminal feedback.
• It addresses challenges such as sparse rewards, lengthy training times, and limited diversity in decompositions during quantum compilation.
• Empirical results on 3-qubit benchmarks report a 99.7% success rate and superior inference efficiency compared to methods like genQC and Gumbel AlphaZero.

Searching arXiv for QFlowNet and closely related flow-based work to ground the article in current papers. Search results for "QFlowNet unitary synthesis GFlowNet Transformers arXiv":

• (Koo et al., 3 Mar 2026) — "QFlowNet: Fast, Diverse, and Efficient Unitary Synthesis with Generative Flow Networks"
• (Li et al., 2023) — "CFlowNets: Continuous Control with Generative Flow Networks"
• (Doo et al., 13 May 2026) — "Q-Flow: Stable and Expressive Reinforcement Learning with Flow-Based Policy"
• (Xu et al., 2022) — "Normalizing flow neural networks by JKO scheme"
• (Vaselli et al., 15 Aug 2025) — "It's not a FAD: first results in using Flows for unsupervised Anomaly Detection at 40 MHz at the Large Hadron Collider" QFlowNet is a unitary synthesis framework for quantum compilation that combines a Generative Flow Network (GFlowNet) with a Transformer-based encoder to generate quantum circuits sequentially from sparse terminal feedback. In the formulation introduced in "QFlowNet: Fast, Diverse, and Efficient Unitary Synthesis with Generative Flow Networks" (Koo et al., 3 Mar 2026), the target object is a quantum circuit whose unitary matches a given target unitary, while the learned policy is trained to sample terminal circuits with probability proportional to reward. The framework is designed to address four difficulties emphasized in prior reinforcement-learning-based synthesis pipelines: sparse rewards, dependence on reward shaping, long training times, and lack of diversity in the resulting decompositions (Koo et al., 3 Mar 2026).

1. Definition and problem setting

QFlowNet studies exact unitary synthesis in a discrete gate library. Given a target unitary

$U \in \mathbb{C}^{d\times d}, \qquad d=2^n,$

the task is to construct a circuit

$C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$

whose circuit unitary is

$V_C = a_l a_{l-1}\cdots a_1$

under the paper’s sequential construction convention

$V_{t+1}=V_t a_t, \qquad V_0=I.$

The search space grows exponentially as $O(|G|^l)$, so exhaustive enumeration rapidly becomes intractable (Koo et al., 3 Mar 2026).

The framework is motivated by the role of unitary synthesis as a subroutine of quantum compilation. Compilation must decompose a desired unitary into a basis gate set, and the paper emphasizes three practical desiderata: correctness, compactness, and hardware adaptability through multiple valid realizations (Koo et al., 3 Mar 2026). This is the immediate rationale for using a GFlowNet rather than a conventional RL policy: the target is not merely one high-quality circuit, but a distribution over valid circuits.

Two discrete gate sets are used:

$$G_1=\{H, Z, S, S^\dagger, T, T^\dagger, \mathrm{CNOT}\},$$

and

$$G_2=\{H, X, Z, \mathrm{CNOT}, \mathrm{CCNOT}, \mathrm{SWAP}\}.$$

Experiments are reported for 3-, 4-, and 5-qubit settings, with the strongest results on the 3-qubit benchmark (Koo et al., 3 Mar 2026).

A central representational decision is the use of a residual state

$s_t = U V_t^\dagger.$

This gives

$s_0 = U, \qquad s_{\mathrm f}=I.$

The paper identifies this as a main conceptual contribution: instead of learning to move from a fixed start $I$ to many target-dependent goals $C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$0, the model moves from a target-dependent start $C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$1 to a single universal goal $C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$2 (Koo et al., 3 Mar 2026). This suggests a path-finding view in residual-unitary space rather than a direct circuit-construction view.

2. State, action, reward, and termination formalism

At each step, QFlowNet maintains the partial circuit unitary $C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$3 and the residual unitary state

$C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$4

Because $C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$5 is complex-valued, it is represented as a real tensor of shape

$C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$6

with separate channels for the real and imaginary parts (Koo et al., 3 Mar 2026).

The transition rule is induced by gate application:

$C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$7

so the next residual state is

$C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$8

An episode therefore generates a trajectory

$C=(a_1,a_2,\dots,a_l), \qquad a_t \in G,$9

Termination occurs either when the synthesized circuit matches the target under a fidelity threshold, or when the maximum length $V_C = a_l a_{l-1}\cdots a_1$0 is reached (Koo et al., 3 Mar 2026).

The fidelity used throughout is

$V_C = a_l a_{l-1}\cdots a_1$1

Terminal reward is maximally sparse:

$V_C = a_l a_{l-1}\cdots a_1$2

with

$V_C = a_l a_{l-1}\cdots a_1$3

There are no dense shaping rewards. Failed trajectories still receive a small positive reward, ensuring nonzero flow, while successful trajectories receive the large terminal reward that the Trajectory Balance objective propagates backward through the sampled sequence (Koo et al., 3 Mar 2026).

Benchmark targets are generated from random circuits with depths uniformly sampled from $V_C = a_l a_{l-1}\cdots a_1$4. For each target length $V_C = a_l a_{l-1}\cdots a_1$5, 100 distinct random circuits of depth $V_C = a_l a_{l-1}\cdots a_1$6 are generated and optimized with Qiskit transpile(..., optimization_level=1), and the resulting unitaries are used as test targets (Koo et al., 3 Mar 2026).

3. GFlowNet component and reward-proportional generation

QFlowNet uses a GFlowNet trained with the Trajectory Balance (TB) objective. The paper explicitly states that it does not use detailed balance, flow matching, or subtrajectory balance, and that it assumes a uniform backward policy so the backward term is omitted for simplicity (Koo et al., 3 Mar 2026).

The objective is to learn a distribution over terminal circuits such that

$V_C = a_l a_{l-1}\cdots a_1$7

In this application, the terminal objects are synthesized circuits or terminal trajectories. The operative loss is

$V_C = a_l a_{l-1}\cdots a_1$8

Here, $V_C = a_l a_{l-1}\cdots a_1$9 is the learned forward policy over discrete gates, and $V_{t+1}=V_t a_t, \qquad V_0=I.$0 is the learned partition function (Koo et al., 3 Mar 2026).

This formulation is meant to address sparse reward credit assignment without reward shaping. The paper stresses that only the terminal state receives either $V_{t+1}=V_t a_t, \qquad V_0=I.$1 or $V_{t+1}=V_t a_t, \qquad V_0=I.$2, but that TB backpropagates the terminal reward through the entire trajectory (Koo et al., 3 Mar 2026). In contrast to standard RL, which is described as tending to converge to one policy that maximizes expected return, the GFlowNet objective is intended to distribute probability mass across all successful terminal circuits rather than collapse to a single mode.

The diversity mechanism is therefore intrinsic to the stochastic generative policy. Multiple trajectories leading to rewarded terminal states can all receive positive probability, and repeated sampling from the forward policy yields distinct correct circuits (Koo et al., 3 Mar 2026). In the reward actually used here, all successful circuits receive the same terminal reward. The paper accordingly treats diversity as a formal consequence of reward-proportional sampling over multiple equally rewarded modes, whereas compactness is reported empirically rather than encoded directly in the reward (Koo et al., 3 Mar 2026).

For context, this design is closely aligned with the general GFlowNet principle of reward-proportional generation. In continuous-control settings, "CFlowNets: Continuous Control with Generative Flow Networks" (Li et al., 2023) extends the same principle to continuous state and action spaces by replacing discrete inflow/outflow sums with integrals and Monte Carlo approximations. QFlowNet differs in remaining entirely in a discrete gate-action regime, which avoids the parent-integration and inverse-model machinery required by CFlowNets (Li et al., 2023).

4. Transformer encoder and policy architecture

The state encoder is a hybrid CNN-Transformer module referred to as Unitary_encoder. Its role is to map the residual unitary tensor to a dense latent representation for the policy network (Koo et al., 3 Mar 2026). The justification given is that unitary matrices exhibit non-local correlations, so self-attention is a natural choice for modeling long-range structure.

The input is

$V_{t+1}=V_t a_t, \qquad V_0=I.$3

A $V_{t+1}=V_t a_t, \qquad V_0=I.$4 convolution first projects the 2-channel input to feature dimension

$V_{t+1}=V_t a_t, \qquad V_0=I.$5

A PositionalEncoding2D is added over the $V_{t+1}=V_t a_t, \qquad V_0=I.$6 grid. The first Transformer stage is a SpatialTransformerSelfAttn block with depth 4 and 8 attention heads, preserving spatial resolution. A DownBlock2D then reduces the resolution from

$V_{t+1}=V_t a_t, \qquad V_0=I.$7

while increasing the feature dimension to

$V_{t+1}=V_t a_t, \qquad V_0=I.$8

A second SpatialTransformerSelfAttn block again uses depth 4 and 8 heads. A final $V_{t+1}=V_t a_t, \qquad V_0=I.$9 convolution maps to the embedding dimension

$O(|G|^l)$0

(Koo et al., 3 Mar 2026).

The encoder output is globally averaged:

$O(|G|^l)$1

An MLP policy_head then maps this embedding to action logits via

• linear $O(|G|^l)$2,
• ReLU,
• linear $O(|G|^l)$3, thereby defining the forward policy

$O(|G|^l)$4

The paper does not explicitly specify layer normalization details, Transformer-block dropout, exact MLP ratios inside the attention blocks, or the exact sequence length after flattening, so these are not part of the canonical definition (Koo et al., 3 Mar 2026).

This architecture is specific to matrix-valued residual-unitary states. It should not be conflated with flow models in the normalizing-flow sense. For example, "Normalizing flow neural networks by JKO scheme" (Xu et al., 2022) studies invertible neural ODE transport with explicit likelihood computation, whereas QFlowNet uses a GFlowNet over discrete gate trajectories rather than a likelihood-based continuous transport (Xu et al., 2022).

5. Training protocol and empirical results

QFlowNet does not rely on a fixed supervised dataset. Training targets are generated online: for each trajectory in each batch, a random circuit depth is sampled uniformly from $O(|G|^l)$5, a random circuit of that depth is generated, its unitary $O(|G|^l)$6 is computed, and that unitary becomes the target for the episode (Koo et al., 3 Mar 2026).

For the 3-qubit experiment, the reported optimization setup is:

• 100,000 training steps,
• batch size 2048,
• Adam,
• learning rate $O(|G|^l)$7.

For larger systems, the paper reports 50,000 steps with batch size 1024 for 4 qubits and 50,000 steps with batch size 128 for 5 qubits, explicitly attributing the reduction to memory limitations (Koo et al., 3 Mar 2026). No special exploration strategy such as $O(|G|^l)$8-greedy, entropy bonuses, temperature annealing, or MCTS is described; exploration arises from stochastic sampling from the learned forward policy.

The main quantitative result is an overall success rate of 99.7% on a 3-qubit benchmark covering target lengths 1–12. Performance remains very high up to depth 10 and reaches 96% success even on the hardest depth-12 instances (Koo et al., 3 Mar 2026). The primary evaluation metric counts a target as solved if any of up to 1024 sampled candidate circuits achieves

$O(|G|^l)$9

The paper compares QFlowNet against genQC and Gumbel AlphaZero. The comparison to genQC emphasizes inference efficiency: for depth-8+ circuits, genQC requires increasingly many samples, and by depth 12 it needs nearly 70 attempts on average, whereas QFlowNet needs only 1–2 attempts on average across the full complexity range (Koo et al., 3 Mar 2026). The comparison to Gumbel AlphaZero emphasizes training cost: QFlowNet converges in about 2 days on the 3-qubit task, whereas Gumbel AlphaZero requires over 10 days; Figure 1(b) is summarized as QFlowNet training in 1–2 days and Gumbel AlphaZero requiring 6.5–10 days depending on scale (Koo et al., 3 Mar 2026).

On 4 qubits, performance is reported as strong on simple circuits, reaching 100% for easy cases, but dropping sharply with target length, to around 48% at length 5 and below 10% for lengths 8 and above. For 5 qubits, experiments are reported but detailed per-length quantitative values are not spelled out in the text (Koo et al., 3 Mar 2026).

Two additional empirical properties are highlighted. First, compactness: many synthesized circuits match the Qiskit-optimized baseline length, and many fall below the diagonal in the length-comparison plot, meaning that QFlowNet often finds circuits shorter than the Qiskit baseline despite having no explicit length penalty in the reward (Koo et al., 3 Mar 2026). Second, diversity: among 1024 samples for a fixed target, the model frequently discovers dozens, and often hundreds, of distinct valid decompositions (Koo et al., 3 Mar 2026).

6. Scope, limitations, and conceptual placement

The main limitation identified in the paper is scalability of the input representation. Because the state is a full residual unitary represented as

$$G_1=\{H, Z, S, S^\dagger, T, T^\dagger, \mathrm{CNOT}\},$$0

memory and compute scale roughly as

$$G_1=\{H, Z, S, S^\dagger, T, T^\dagger, \mathrm{CNOT}\},$$1

which is given as the main reason performance degrades beyond 3 qubits (Koo et al., 3 Mar 2026). The benchmark distribution is also restricted: targets are not arbitrary Haar-random unitaries, but unitaries reachable by circuits of bounded length $$G_1=\{H, Z, S, S^\dagger, T, T^\dagger, \mathrm{CNOT}\},$$2 from the chosen gate set. Gate-set dependence is explicit; retraining would be needed for a different gate library (Koo et al., 3 Mar 2026).

The framework is presented as an exact synthesis method, but experimental success is operationalized through the numerical threshold $$G_1=\{H, Z, S, S^\dagger, T, T^\dagger, \mathrm{CNOT}\},$$3. The paper does not yet handle continuous gate parameters or directly optimize approximate-synthesis objectives (Koo et al., 3 Mar 2026). Likewise, the reward does not explicitly optimize for shorter circuits, lower CNOT count, or hardware-aware constraints; compactness is therefore an empirical outcome rather than a formal guarantee.

A common terminological confusion is with Q-Flow. "Q-Flow: Stable and Expressive Reinforcement Learning with Flow-Based Policy" (Doo et al., 13 May 2026) is not a QFlowNet paper; it is an offline RL actor-critic framework with continuous flow-based policies and a learned intermediate value function over latent flow states. The name similarity is superficial, and the two methods solve different problems: QFlowNet targets discrete quantum gate synthesis with a GFlowNet and Transformer, whereas Q-Flow targets expressive policy optimization in offline RL (Doo et al., 13 May 2026).

A second possible confusion concerns normalizing flows and continuous transport models. Work such as "It's not a FAD: first results in using Flows for unsupervised Anomaly Detection at 40 MHz at the Large Hadron Collider" (Vaselli et al., 15 Aug 2025) studies Continuous Normalizing Flows for anomaly detection and repurposes the learned vector field as a hardware-friendly score. That line of work is relevant to flow-based modeling broadly, but it is methodologically distinct from QFlowNet’s GFlowNet-based reward-proportional generation over discrete gate sequences (Vaselli et al., 15 Aug 2025).

Within the GFlowNet literature, the most direct conceptual relative is CFlowNets: both inherit the objective of sampling terminal objects proportionally to reward, but they diverge on state/action topology and training mechanics. QFlowNet remains in a discrete action space and uses Trajectory Balance on target-conditioned residual-unitary trajectories, while CFlowNets formulate continuous inflow/outflow constraints and approximate them by Monte Carlo integration (Li et al., 2023). A plausible implication is that QFlowNet’s main contribution is not extending GFlowNets to continuity, but demonstrating that GFlowNet-style reward-proportional generation can be effective in sparse-reward quantum compilation when paired with a representation capable of encoding non-local unitary structure (Koo et al., 3 Mar 2026).