Nonlocal Unitary-Synthesis in Quantum Systems

• Nonlocal unitary-synthesis is the study of implementing unitary operators under subsystem locality constraints using resources like LOCC, entanglement, and controlled operations.
• Key methodologies involve Schmidt rank analysis, oracle reductions, and variational as well as hardware-aware compilation to optimize resource use and T-count in fault-tolerant models.
• Recent advances address challenges such as symmetry obstructions, fidelity gaps in sequential protocols, and scalability limits in synthesizing complex quantum dynamics.

The nonlocal unitary-synthesis problem concerns the realization, approximation, or structural characterization of unitary operators whose implementation is nontrivial because the admissible resources are constrained by subsystem locality, entanglement assistance, restricted gate sets, oracle access, symmetry, or hardware connectivity. In the bipartite setting, the central question is how a unitary that is not a tensor product can be implemented by LOCC with prior entanglement or reduced to controlled form; in fault-tolerant compilation, the question becomes the asymptotic cost of synthesizing arbitrary $n$-qubit unitaries in models such as Clifford+T; and in quantum complexity theory, it becomes the Aaronson–Kuperberg question of whether arbitrary unitaries can be generated from compact classical-oracle access (Chen et al., 2014, Tan, 30 Sep 2025, Brakerski et al., 11 May 2026).

1. Formalizations and basic notions

In the bipartite literature, a unitary on $\mathcal H_A\otimes \mathcal H_B$ is local if it is of the form $U_A\otimes U_B$, equivalently Schmidt rank $1$, and nonlocal otherwise. The Schmidt rank of an operator $U$ is the minimum $r$ such that

$U=\sum_{j=1}^r A_j\otimes B_j,$

with $\{A_j\}$ and $\{B_j\}$ linearly independent. A unitary is a controlled unitary if it is locally equivalent to

$$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$

and two unitaries are locally equivalent if they differ only by local unitaries applied before and after the target operation (Chen et al., 2014).

A distinct, complexity-theoretic formulation treats synthesis as an oracle reduction problem. A query algorithm $\mathcal H_A\otimes \mathcal H_B$0 solves the unitary synthesis problem for dimension-$\mathcal H_A\otimes \mathcal H_B$1 unitaries with query complexity $\mathcal H_A\otimes \mathcal H_B$2, oracle input length $\mathcal H_A\otimes \mathcal H_B$3, and error $\mathcal H_A\otimes \mathcal H_B$4 if for every $\mathcal H_A\otimes \mathcal H_B$5 there exists a Boolean function $\mathcal H_A\otimes \mathcal H_B$6 such that $\mathcal H_A\otimes \mathcal H_B$7, making $\mathcal H_A\otimes \mathcal H_B$8 queries to $\mathcal H_A\otimes \mathcal H_B$9, implements $U_A\otimes U_B$0 up to diamond-distance error $U_A\otimes U_B$1. The Aaronson–Kuperberg question asks whether one can achieve error $U_A\otimes U_B$2 with

$U_A\otimes U_B$3

The formulation explicitly separates query complexity from oracle input length, and highlights the two trivial endpoints $U_A\otimes U_B$4 and $U_A\otimes U_B$5 (Brakerski et al., 11 May 2026).

A further abstraction replaces individual target unitaries by a family of partial isometries $U_A\otimes U_B$6. In that framework, worst-case synthesis is measured by diamond norm against a channel completion, while average-case or distributional synthesis is defined on an entangled input state and requires correct action on the given register while preserving entanglement with an inaccessible purifier. This makes explicit that unitary synthesis is not merely state preparation; it is a transformation task on unknown inputs that may be entangled with reference systems (Bostanci et al., 2023).

These formulations show that “nonlocal” is not a single notion. Depending on context, it can mean nonfactorizability across subsystems, action on only one part of an entangled state, logical interactions that are nonadjacent on sparse hardware, or synthesis from compact classical advice.

2. Structural classification by Schmidt rank and controlled form

A major structural line of work asks when nonlocal unitaries are nevertheless forced into controlled form. For Schmidt-rank-three bipartite unitaries, one result proved that any bipartite nonlocal unitary of Schmidt rank $U_A\otimes U_B$7 on a $U_A\otimes U_B$8 system is locally equivalent to a controlled unitary whenever $U_A\otimes U_B$9. In the same work, a practical criterion was given: if

$1$0

then $1$1 is controlled from the $1$2 side iff all products $1$3 and $1$4 are normal and mutually commuting. The paper also proved that for unitary operators, SL-equivalence collapses to ordinary local-unitary equivalence (Chen et al., 2014).

A stronger later theorem removed the $1$5 restriction and established that any bipartite unitary of Schmidt rank $1$6 is locally equivalent to a controlled unitary. The same paper extended the analysis to the multipartite setting: every Schmidt-rank-three multipartite unitary is either controlled by one system or collectively controlled by two systems. For $1$7-qubit systems, it further identified a parity effect. The family

$1$8

is a Schmidt-rank-three $1$9-qubit unitary, and for odd $U$0 it is not a controlled unitary, whereas for any even $U$1, every Schmidt-rank-three $U$2-qubit unitary is controlled (Chen et al., 2014).

This structural theory has direct implementation consequences. When $U$3, any Schmidt-rank-three bipartite unitary can be implemented by LOCC using a maximally entangled state of Schmidt rank

$U$4

That bound arises because local equivalence to a controlled unitary converts an abstract classification theorem into a concrete synthesis route (Chen et al., 2014).

A common misconception is that low Schmidt rank automatically implies bidirectional control symmetry. The rank-three results show otherwise: Schmidt-rank-three controlled unitaries need not be controlled from both sides, and multipartite rank-three unitaries can require collective control by two systems rather than one (Chen et al., 2014, Chen et al., 2014).

3. Entanglement-assisted protocols, resource lower bounds, and sequential limits

A fully general bipartite nonlocal unitary can always be implemented by teleporting one subsystem to the other party, applying the unitary locally, and teleporting back. The point of resource-efficient synthesis is that this baseline is not always optimal. A general lower bound states that any entangled resource state used to implement a bipartite unitary by LOCC or separable operations must have Schmidt rank at least the Schmidt rank of the target unitary, and at least its entangling strength (Yu et al., 2010).

Large families of unitaries admit better protocols through finite-group structure. If

$U$5

where $U$6 is a projective unitary representation of a finite group $U$7, then $U$8 can be executed using a maximally entangled ancilla of Schmidt rank $U$9, local controlled operations, a local Fourier-type transform, and two rounds of classical communication. The total classical communication cost is $r$0 bits. Controlled unitaries are recovered as a special case, and when the effective group size equals $r$1, the protocol matches teleportation rather than exceeding it (Yu et al., 2010).

A different synthesis model asks whether a genuinely entangling global unitary can be implemented sequentially using only local interactions between each qubit and an itinerant ancilla, with each qubit touched once and the ancilla decoupling at the end. A no-go theorem rules out exact deterministic realization in general. The obstruction can be seen in Kraus form or via operator-Schmidt decomposition: the last ancilla-qubit unitary cannot both maintain unitarity and erase the ancilla’s information content for a genuinely entangling target (Saberi, 2011).

The same work reformulated approximate sequential synthesis as a variational matrix-product-operator optimization with Frobenius-norm cost

$r$2

For ancilla dimension $r$3, the reported approximate fidelities were $r$4 for CNOT and CZ, $r$5 for CPHASE, $r$6 for SWAP, and $r$7 for Toffoli and Fredkin. The resulting “fidelity gap” is interpreted as a measure of the target gate’s globalness (Saberi, 2011).

4. Arbitrary-unitary compilation under gate-set and hardware constraints

For arbitrary $r$8-qubit unitaries in the standard fault-tolerant model, the key resource is the T-count of a Clifford+T circuit. A recent asymptotic improvement showed that for any $r$9 and $U=\sum_{j=1}^r A_j\otimes B_j,$0, letting

$U=\sum_{j=1}^r A_j\otimes B_j,$1

there exists a Clifford+T circuit that $U=\sum_{j=1}^r A_j\otimes B_j,$2-approximates $U=\sum_{j=1}^r A_j\otimes B_j,$3 using

$U=\sum_{j=1}^r A_j\otimes B_j,$4

T gates and

$U=\sum_{j=1}^r A_j\otimes B_j,$5

ancilla qubits. For constant $U=\sum_{j=1}^r A_j\otimes B_j,$6, this gives the headline bound $U=\sum_{j=1}^r A_j\otimes B_j,$7, improving the previous best upper bound $U=\sum_{j=1}^r A_j\otimes B_j,$8, while the best known lower bound remains $U=\sum_{j=1}^r A_j\otimes B_j,$9. The construction combines recursive cosine-sine decomposition with a generalization of the Gosset–Kothari–Wu diagonal-unitary method to multi-controlled $\{A_j\}$0-qubit unitaries, and the improvement comes from regrouping many single-qubit-controlled factors into larger $\{A_j\}$1-qubit controlled blocks (Tan, 30 Sep 2025).

Approximate synthesis has also been approached through Lie-algebraic parameterization. An SRBB-based scalable quantum neural network represents arbitrary $\{A_j\}$2 operators as structured products of exponentials of a Standard Recursive Block Basis, with one approximation layer $\{A_j\}$3. The work identifies $\{A_j\}$4 as a special anomaly, derives closed-form post-reduction counts such as

$\{A_j\}$5

for $\{A_j\}$6, and validates the method on sparse and dense targets up to $\{A_j\}$7 qubits in PennyLane using Adam and Nelder–Mead optimizers (Belli et al., 2024).

Exact synthesis of exactly synthesizable Clifford+T unitaries has also been cast as a sequential decision problem and attacked with deep reinforcement learning. Using Gumbel AlphaZero, residual-unitary observations $\{A_j\}$8, and explicit action masking for cancellations such as $\{A_j\}$9 and $\{B_j\}$0, separate models were trained for $\{B_j\}$1 and $\{B_j\}$2 qubits. The method synthesizes random circuits up to $\{B_j\}$3 qubits and up to $\{B_j\}$4 gates, often outperforming QuantumCircuitOpt, MIN-T-SYNTH, and Synthetiq in synthesis time on larger small-scale instances, while usually requiring around $\{B_j\}$5–$\{B_j\}$6 seconds per synthesis on simple cases (Rietsch et al., 2024).

On sparse superconducting hardware, exact synthesis has been made architecture-aware at the decomposition stage rather than treated as routing afterthought. A block-ZXZ-based method integrates greedy qubit mapping, adaptive Gray code selection with optional swapping, and a heuristic for reducing CNOTs in long-range ladders. Benchmarks on the $\{B_j\}$7-qubit IQM Garnet square lattice and the $\{B_j\}$8-qubit IBM Marrakesh heavy-hex architecture, for $\{B_j\}$9 to $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$0 qubits, reported CNOT count reductions of up to $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$1 on IQM Garnet and up to $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$2 on IBM Marrakesh relative to the best competing transpiler, together with speedups of up to $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$3. It was also the only tested method capable of transpiling circuits beyond $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$4 qubits within a $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$5-minute time limit across both architectures (Perkkola et al., 26 Apr 2026).

5. Oracle models, complexity classes, and lower bounds

The complexity-theoretic nonlocal unitary-synthesis problem asks whether arbitrary unitary dynamics can be reduced to classical oracle access. One barrier is already present at a single query. There exist $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$6-qubit unitaries $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$7 such that no quantum polynomial-time oracle algorithm $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$8 can implement $$\sum_{j=1}^{d_A} |j\rangle\langle j|\otimes U_j \quad\text{or}\quad \sum_{j=1}^{d_B} V_j\otimes |j\rangle\langle j|,$$9, even approximately, if it makes only one quantum query to a Boolean function $\mathcal H_A\otimes \mathcal H_B$00. The lower bound is proved by reformulating synthesis as an Oracle State Distinguishing Game and controlling the adversary’s success via spectral relaxations and random matrix theory. Relative to a random oracle, the same argument yields quantum cryptographic primitives secure against all one-query adversaries (Lombardi et al., 2023).

This was extended to the 1.5-query regime. In that setting, the central quantity is an all-subsets operator deviation

$\mathcal H_A\otimes \mathcal H_B$01

Under a per-sample operator-size assumption, the paper proves

$\mathcal H_A\otimes \mathcal H_B$02

with stronger bounds $\mathcal H_A\otimes \mathcal H_B$03 or $\mathcal H_A\otimes \mathcal H_B$04 under block-orthogonality, sparsity, or effective-dimension assumptions. This extends the one-query barrier to a fractional-query setting and implies security of pseudorandom state constructions against 1.5-query adversaries under the stated structural conditions (Huang, 17 Aug 2025).

A broader obstruction emerges from pseudorandom-unitary theory. If scalable pseudorandom unitaries are obtained through the prevailing random-oracle-model paradigm, then they would imply a positive solution to the Aaronson–Kuperberg unitary synthesis problem. Yet any unitary synthesis algorithm of this kind must use a classical oracle with input length essentially

$\mathcal H_A\otimes \mathcal H_B$05

more precisely with bounds such as

$\mathcal H_A\otimes \mathcal H_B$06

for net constructions. This rules out existing scalable PRU candidates built from ROMs with input length about $\mathcal H_A\otimes \mathcal H_B$07 (Brakerski et al., 11 May 2026).

The unitary-complexity framework generalizes these questions beyond worst-case oracle synthesis. In that setting, the Uhlmann Transformation Problem formalizes the task of locally transforming one purification into another. The problem $\mathcal H_A\otimes \mathcal H_B$08 is complete for $\mathcal H_A\otimes \mathcal H_B$09, while $\mathcal H_A\otimes \mathcal H_B$10 is complete for $\mathcal H_A\otimes \mathcal H_B$11. The significance is that many apparently different nonlocal transformation tasks—decoding noisy channels, breaking falsifiable quantum cryptographic assumptions, implementing optimal prover strategies, and decoding Hawking radiation—can be expressed as unitary synthesis problems of this type (Bostanci et al., 2023).

6. Symmetry obstructions and adjacent operational variants

Locality alone does not forbid universal unitary synthesis, but locality combined with a continuous symmetry does. For a symmetry group $\mathcal H_A\otimes \mathcal H_B$12, the relevant comparison is between all symmetric unitaries $\mathcal H_A\otimes \mathcal H_B$13 and the subgroup $\mathcal H_A\otimes \mathcal H_B$14 generated by $\mathcal H_A\otimes \mathcal H_B$15-local symmetric unitaries. For continuous groups such as $\mathcal H_A\otimes \mathcal H_B$16 and $\mathcal H_A\otimes \mathcal H_B$17, generic symmetric unitaries cannot be implemented, even approximately, by composing fixed-$\mathcal H_A\otimes \mathcal H_B$18 local symmetric unitaries. In the $\mathcal H_A\otimes \mathcal H_B$19 case, the paper derives the exact dimension gap

$\mathcal H_A\otimes \mathcal H_B$20

and shows that a $\mathcal H_A\otimes \mathcal H_B$21-local $\mathcal H_A\otimes \mathcal H_B$22-invariant synthesis must satisfy $\mathcal H_A\otimes \mathcal H_B$23 for all $\mathcal H_A\otimes \mathcal H_B$24, where $\mathcal H_A\otimes \mathcal H_B$25 are the $\mathcal H_A\otimes \mathcal H_B$26-body phases. The obstruction can be circumvented by catalysis: an ancilla returned to its initial state restores universality, and the paper gives 2-local $\mathcal H_A\otimes \mathcal H_B$27-invariant constructions using couplings of the form $\mathcal H_A\otimes \mathcal H_B$28 and $\mathcal H_A\otimes \mathcal H_B$29 (Marvian, 2020).

A different adjacent problem concerns which input states can be turned into Bell-nonlocal resources by a global unitary. For two qubits, the set of Bell–CHSH-local states $\mathcal H_A\otimes \mathcal H_B$30 and the set of absolutely Bell–CHSH-local states

$\mathcal H_A\otimes \mathcal H_B$31

are both convex and compact. The set $\mathcal H_A\otimes \mathcal H_B$32 is nontrivial: it contains entangled Werner states with

$\mathcal H_A\otimes \mathcal H_B$33

which remain Bell–CHSH local under every global unitary. A Hermitian witness $\mathcal H_A\otimes \mathcal H_B$34 separates states that are merely local from those that are absolutely local (Roy et al., 2016).

There are also protocols that transfer the result of a unitary action without synthesizing the distributed gate itself. In a photonic setting with SPDC-generated spatial entanglement, a unitary acting on one photon can be made available on the remote photon after an appropriate projection, so that a remote user can “nonlocally access the result of an arbitrary unitary operator on an arbitrary input state.” The experimentally validated one-dimensional phase masks yielded similarities of $\mathcal H_A\otimes \mathcal H_B$35, $\mathcal H_A\otimes \mathcal H_B$36, $\mathcal H_A\otimes \mathcal H_B$37, and $\mathcal H_A\otimes \mathcal H_B$38; an arbitrary-input test reported average similarity $\mathcal H_A\otimes \mathcal H_B$39; and two-dimensional examples achieved $\mathcal H_A\otimes \mathcal H_B$40 and $\mathcal H_A\otimes \mathcal H_B$41. The paper explicitly distinguishes this from full LOCC synthesis of a nonlocal gate: it is remote evaluation or transfer of a unitary’s action, mediated by entanglement and postselection (Paneru et al., 2024).

Taken together, these results show that the nonlocal unitary-synthesis problem is not a single theorem or algorithmic template. It is a research program spanning classification by Schmidt rank, entanglement-assisted distributed implementation, fault-tolerant and hardware-aware compilation, oracle lower bounds, and symmetry-induced no-go theorems. A plausible implication is that progress in one formulation does not automatically transfer to the others: controlled-unitary reductions, T-count improvements, oracle lower bounds, and symmetry obstructions address distinct bottlenecks, even when they concern the same underlying task of realizing nonlocal quantum dynamics.