LCNU: Linear Combination of Non-Unitaries

• LCNU is a method for implementing non-unitary linear maps using ancilla-assisted unitary operations, block encodings, and post-selection.
• It combines unitary primitives to simulate non-Hermitian dynamics, quantum machine learning layers, and complex operator decompositions with controlled normalization.
• Innovative LCNU techniques optimize resource use by transforming discarded ancilla outcomes into structured low-rank data for efficient recovery.

Linear Combination of Non-Unitaries (LCNU) denotes a family of constructions for realizing a target non-unitary linear map through ancilla-assisted unitary operations, block encodings, probabilistic postselection, or classical post-processing. In current usage, the term is not fully standardized: some works use LCNU as a design principle for building non-unitary layers from Linear Combination of Unitaries (LCU) primitives, some use it for block-encoding general non-unitary operators, and some describe the same objective without using the label explicitly. Across these formulations, the central idea is consistent: the target map is non-unitary, while the hardware-level primitives remain unitary and the non-unitary action is recovered through embedding, conditioning, or aggregation (Heredge et al., 2024, Daskin, 4 May 2026, Schillo et al., 9 Jan 2026).

1. Definition and formal setting

In the standard LCU setting, a target operator is written as

$A=\sum_{k=1}^K \alpha_k U_k,$

where the $U_k$ are unitaries and the coefficients $\alpha_k$ are generally complex. With $m=\lceil \log_2 K\rceil$ ancilla qubits and $s=\sum_{t=1}^K |\alpha_t|$, one prepares

$$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$

applies

$$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$

uncomputes with $B^\dagger$, and post-selects the ancilla in $|0\rangle$. The resulting system state is $(1/s)A|\psi\rangle$, and the success probability is $U_k$0 (Daskin, 4 May 2026). This is the canonical route by which a non-unitary linear map is effected through a larger unitary process.

Block encoding provides the closely related formulation in which a unitary $U_k$1 acting on ancillas and system satisfies

$U_k$2

Postselection or oblivious amplitude amplification then recovers the action of $U_k$3 up to normalization (Schillo et al., 9 Jan 2026). In this sense, LCNU is often best understood not as a separate primitive from LCU, but as the broader objective of realizing non-unitary operators through LCU, block encodings, or compositions of such gadgets.

Recent work extends this discrete picture to continuous linear combinations. For non-unitary dynamics generated by $U_k$4 with $U_k$5, the time-ordered propagator can be written exactly as an integral over unitary Hamiltonian evolutions,

$U_k$6

which is then truncated and quadrature-discretized into an LCU sum. This places LCNU in direct contact with Hamiltonian simulation, quantum differential equations, and non-Hermitian dynamics (An et al., 2023).

2. Circuit mechanisms and implementation paradigms

The most direct LCNU mechanism remains postselected coherent execution. In this model, one keeps only the ancilla branch associated with the desired block, and the non-unitary map appears as a subnormalized top-left block. This framework underlies quantum machine-learning layers, block-encoded sparse operators, and linear-dynamics solvers. A recurring resource cost is postselection overhead: if the success probability is $U_k$7, the expected number of repetitions is $U_k$8, and amplitude amplification can reduce that overhead at the price of additional circuit depth (Heredge et al., 2024).

A distinct development is the systematic use of ancilla outcomes that standard LCU would discard. An alternative LCU circuit with a Hadamard-prepared index register and a single rotation qubit produces $U_k$9 different ancilla outcomes, each corresponding to a different linear combination of the same unitary set. Stacking the resulting outcome states gives a matrix $\alpha_k$0 with factorization $\alpha_k$1 and rank bound $\alpha_k$2. This turns the usual “junk” branches into a structured low-rank object: classical matrix completion or least-squares recovery can reconstruct the target branch from partial data, and the same structure motivates candidate trapdoor-function and symmetric-encryption constructions (Daskin, 4 May 2026).

Another implementation paradigm avoids coherent combination entirely and estimates expectation values of non-unitary functions by classical aggregation. In LCU-CPP, one represents

$\alpha_k$3

where each $\alpha_k$4 is a constant multiplied unitary, estimates $\alpha_k$5 with the Hadamard test, and integrates classically. Quasi-Monte Carlo improves the integration layer: with low-discrepancy points mapped by the inverse CDF of $\alpha_k$6, the quadrature bias scales as $\alpha_k$7, while shot noise scales as $\alpha_k$8. This is an LCNU realization at the level of expectation values rather than state transformation (Kawamata et al., 17 Sep 2025).

These mechanisms clarify a common misconception. LCNU does not ordinarily mean that non-unitary gates are applied directly on hardware. In the cited constructions, the executed circuit remains unitary; non-unitarity emerges from postselection, from taking a particular encoded block, from combining outcome branches, or from classical post-processing of unitary measurements (Daskin, 4 May 2026).

3. Quantum machine learning and symmetry-aware layers

Heredge, West, Hollenberg, and Sevior use LCU as a non-unitary design principle for several quantum machine-learning layers in “Non-Unitary Quantum Machine Learning” (Heredge et al., 2024). The residual-network analogue is built from

$\alpha_k$9

implemented with one ancilla qubit prepared as $m=\lceil \log_2 K\rceil$0, a controlled application of $m=\lceil \log_2 K\rceil$1, and ancilla postselection. The layer success probability is

$m=\lceil \log_2 K\rceil$2

with $m=\lceil \log_2 K\rceil$3, and the total success probability for $m=\lceil \log_2 K\rceil$4 residual layers is $m=\lceil \log_2 K\rceil$5. In a two-block example with one skip, the loss decomposes into a deep unitary term, a shallow unitary term, and a non-unitary cross term; the shallow component does not exhibit barren plateaus, and the reported numerics show sub-exponential gradient-variance decay with qubit number.

The same paper constructs a quantum analogue of average pooling for amplitude-encoded images. For a $m=\lceil \log_2 K\rceil$6 window,

$m=\lceil \log_2 K\rceil$7

where $m=\lceil \log_2 K\rceil$8 are pixel translations implemented by quantum arithmetic. Because $m=\lceil \log_2 K\rceil$9, the layer is intrinsically non-unitary and is realized as an equal-weight LCU over $s=\sum_{t=1}^K |\alpha_t|$0 shift unitaries. The reported Fashion-MNIST results show that as $s=\sum_{t=1}^K |\alpha_t|$1 increases the success probability decreases initially and then levels off, while for fixed $s=\sum_{t=1}^K |\alpha_t|$2 no clear trend is observed with image size $s=\sum_{t=1}^K |\alpha_t|$3. By exploiting closure of subtraction operators under composition, the construction uses $s=\sum_{t=1}^K |\alpha_t|$4 single-qubit-controlled subtraction gates per spatial register rather than $s=\sum_{t=1}^K |\alpha_t|$5 multi-controlled operators.

The third machine-learning construction is a linear combination of irreducible subspace projectors. For a finite group $s=\sum_{t=1}^K |\alpha_t|$6 with unitary representation $s=\sum_{t=1}^K |\alpha_t|$7, the projector onto irrep $s=\sum_{t=1}^K |\alpha_t|$8 is

$s=\sum_{t=1}^K |\alpha_t|$9

A layer of the form $$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$0 allows selective amplification of symmetry sectors while keeping the state in an exponentially large space unless one projects fully. For point clouds with permutation symmetry, the reported sphere-vs-torus classification experiment with $$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$1 points and kernel SVM on state overlaps peaks at an intermediate mixing hyperparameter $$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$2, outperforming both $$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$3 and $$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$4. The same framework, via Schur–Weyl duality, yields a rotationally invariant encoding of four 3D points by projecting to the $$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$5 irrep of $$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$6; after projection, the overlap between encodings of the same cloud under arbitrary global rotations remains $$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$7.

4. Non-unitary dynamics, differential equations, and randomized LCHS

A major LCNU line of work concerns linear non-unitary dynamics. The original LCHS construction writes the propagator of

$$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$8

as a linear combination of unitary Hamiltonian simulations. In the simplest form,

$$B|0\rangle_{\mathrm{anc}}=\frac{1}{\sqrt{s}}\sum_{t=1}^K \sqrt{\alpha_t}\,|t\rangle_{\mathrm{anc}},$$9

which is then truncated and discretized into a finite LCU over unitary time evolutions. This avoids converting the problem into a dilated linear system and achieves optimal state-preparation cost $$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$0 in the homogeneous case (An et al., 2023).

A later refinement replaces the Cauchy kernel by a near-exponentially decaying family

$$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$1

giving

$$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$2

This permits truncation to $$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$3 with $$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$4, composite Gaussian quadrature with $$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$5, and a total number of unitary terms

$$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$6

For time-independent homogeneous dynamics, the query complexity becomes

$$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$7

while the time-dependent case has exponent $$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$8. The paper characterizes this as near-optimal dependence on all parameters (An et al., 2023).

Randomization modifies the same LCNU principle rather than replacing it. In random-LCHS, the outer LCU layer is sampled instead of coherently prepared: one samples $$\mathrm{Select}(U)=\sum_{t=1}^K |t\rangle\langle t|\otimes U_t,$$9 with probability proportional to $B^\dagger$0 and executes the corresponding unitary block $B^\dagger$1. The inner Hamiltonian simulation layer can remain deterministic or be randomized with c-qDrift. For the randomized inner layer, the diamond-norm error satisfies

$B^\dagger$2

where $B^\dagger$3 is the number of segments. The observable-driven variant estimates final-time observables directly with an unbiased Monte Carlo estimator, and the symmetry-aware variant pairs sampled local terms according to physical symmetries; the reported numerics on PT-symmetric TFIM and interacting Hatano–Nelson show average final-state-error reductions of approximately $B^\dagger$4 and $B^\dagger$5, respectively, at fixed sampling budget (Yang et al., 9 Sep 2025).

5. Structured operators, Pauli sums, and sparse matrix access

For sums of Pauli strings, one route to LCNU is to transform the operator into a unitary linear combination before restoring the original target. Given

$B^\dagger$6

with Pauli strings $B^\dagger$7, a stabilizer-based construction chooses commuting strings $B^\dagger$8 so that $B^\dagger$9 are pairwise anti-commuting. Then

$|0\rangle$0

is unitary, because $|0\rangle$1. Ancilla tagging and a controlled correction $|0\rangle$2 yield a block encoding of $|0\rangle$3 with normalization $|0\rangle$4 and postselection success probability $|0\rangle$5. For $|0\rangle$6, the ancilla size can be chosen as $|0\rangle$7, while a linear-ancilla variant trades success probability for substantial reductions in depth and two-qubit gate count (Schillo et al., 9 Jan 2026).

A different sparse-structure program uses explicitly non-unitary basis elements. In the sigma-basis approach, one decomposes

$|0\rangle$8

where $|0\rangle$9. Each sigma term is completed to a unitary $(1/s)A|\psi\rangle$0 acting on one extra ancilla, and this leads to block encodings and Hadamard-test circuits for VQAs. For PDE discretizations, the main gain is term-count compression: the paper reports $(1/s)A|\psi\rangle$1 for 1D Poisson, $(1/s)A|\psi\rangle$2 for 1D Heat with Neumann boundary conditions, and $(1/s)A|\psi\rangle$3 for 1D Wave with Neumann boundary conditions (Gnanasekaran et al., 4 Jul 2025).

The same structural viewpoint appears in Carleman-linearized systems. An arbitrary square matrix is decomposed into an LCNU

$(1/s)A|\psi\rangle$4

where each $(1/s)A|\psi\rangle$5 is unitary or non-unitary but admits an efficient unitary completion. For the 3-dimensional Carleman-linearized lattice Boltzmann equation, the number of terms scales as

$(1/s)A|\psi\rangle$6

where $(1/s)A|\psi\rangle$7 is the Carleman truncation order and $(1/s)A|\psi\rangle$8 is the number of discrete velocities, and $(1/s)A|\psi\rangle$9 is completely independent of both the number of temporal and spatial discretization points. In the PREP/SELECT route, the T cost scales as

$U_k$00

while the variational quantum linear solver requires $U_k$01 circuits per iteration, with worst-case T-gate cost $U_k$02 among them (Demirdjian et al., 1 May 2026).

6. Convergence, normalization, and open technical issues

One of the central technical bottlenecks in LCNU is not merely gate count but normalization. Coherent realizations inherit a success amplitude inversely proportional to the LCU or block-encoding normalization, so approximation schemes with rapidly growing coefficient $U_k$03-norm can become impractical even if the operator error is small. A recent Fourier-extension method addresses this directly. Writing $U_k$04 with Hermitian $U_k$05 and $U_k$06, one approximates each Hermitian part by a sine series on a smoothly extended periodic interval, giving

$U_k$07

which uses $U_k$08 unitaries. The approximation error decays exponentially, so $U_k$09, and the paper reports empirically that $U_k$10. Consequently, the block-encoding subnormalization satisfies

$U_k$11

with $U_k$12. This is the double-logarithmic inverse-error behavior highlighted by the paper (Brearley et al., 25 Jan 2026).

The literature also shows that “failed” branches need not be wasted. In all-outcome LCU, the target branch may have smaller strict postselection probability than standard LCU, but every ancilla outcome contributes to the low-rank matrix $U_k$13. In LCU-CPP, one abandons coherent realization altogether and instead trades block-encoding depth for shallow Hadamard tests and classical integration. These alternatives shift the resource bottleneck from postselection to sample complexity, conditioning, or matrix-completion assumptions (Daskin, 4 May 2026, Kawamata et al., 17 Sep 2025).

Terminology remains a live issue. Some papers explicitly define LCNU as the task of effecting a non-unitary operator by combining unitaries with ancilla-aided LCU; some use it for any block-encoding of a non-unitary operator; some describe the same constructions entirely in LCU or block-encoding language. This suggests that LCNU is presently best treated as an umbrella term for a family of non-unitary realization strategies rather than as a uniquely fixed circuit model. The main open questions identified in the recent literature follow that breadth: characterizing when non-unitary cross terms in quantum ResNets remain both trainability-enhancing and classically hard, compiling efficient character unitaries for group-theoretic projectors, establishing rigorous data-dependent success-probability bounds for pooling and projection layers, and providing formal security reductions for ancilla-outcome-based cryptographic constructions (Heredge et al., 2024, Daskin, 4 May 2026).

Across quantum machine learning, non-Hermitian dynamics, sparse structured linear algebra, and expectation-value estimation, LCNU has therefore evolved into a general methodology for importing intrinsically non-unitary operations into quantum algorithms while retaining unitary hardware primitives. Its current research frontier lies less in the abstract existence of such decompositions than in controlling normalization, exploiting discarded branches, matching structure to basis choice, and deciding when coherent realization, randomized sampling, or classical post-processing yields the most favorable resource profile.