Coherent Multiplication of Block Encodings

• Coherent Multiplication of Block Encodings is a method for unitarily composing block-encoded operators, achieving the product AB/(αβ) without mid-circuit measurement.
• The technique sequentially applies unitaries on disjoint ancilla registers, managing error propagation and normalization growth to maintain coherent circuit operation.
• Recent advances optimize ancilla usage and compiler abstractions, enabling effective implementation in QSP, QSVT, Hamiltonian simulation, and quantum linear-algebra routines.

Searching arXiv for the cited papers to ground the article in recent literature. Coherent multiplication of block encodings is the measurement-free composition of block-encoding unitaries so that the signal block of the composed unitary represents an operator product, typically $AB/(\alpha\beta)$ for block-encoded operators $A$ and $B$. In the standard formulation, the product is obtained by composing the underlying unitaries on disjoint ancilla registers and analyzing the joint projection onto the ancilla-zero subspace; no mid-circuit measurement or post-selection is performed, so the result remains a coherent unitary subroutine suitable for QSP, QSVT, qubitization, LCU-based constructions, Hamiltonian simulation, and quantum linear-algebra routines (Petrič et al., 20 Apr 2026). Subsequent work has broadened this picture to rectangular matrices, ancilla-efficient product gadgets, compiler-oriented abstractions, and lower bounds on the ancilla complexity of exact multiplication (Dong et al., 19 Sep 2025, Vasconcelos et al., 10 Jul 2025).

1. Formal definitions and semantic variants

The standard definition treats a unitary $U$ on $a+s$ qubits as an $(\alpha,a,\varepsilon)$-block-encoding of an operator $A$ on $s$ system qubits when

$$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$

Equivalently, the projected top-left block obeys

$$\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$$

Here $A$0 is the subnormalization, $A$1 is the ancilla count, and the error is measured in operator norm (Petrič et al., 20 Apr 2026).

This formulation extends naturally beyond square power-of-two matrices. A rectangular generalization treats $A$2 as an isometry from an input subspace to an output subspace, where $A$3 projects onto the relevant ancilla and data subspaces. A more relaxed convention, used in one recent product paper, describes a block-encoding simply as a unitary whose top-left block is $A$4, leaving the ancilla/data partition implicit when convenient (Dong et al., 19 Sep 2025).

Software frameworks encode these semantics differently. Qrisp stores the normalization $A$5 together with the unitary subroutine and retains the lecture-note error convention above (Petrič et al., 20 Apr 2026). Unitaria instead uses a subspace-based exact relation

$A$6

with explicit input and output subspaces and no default $A$7 field in the data structure (Deiml et al., 11 May 2026). Cobble restricts attention to exact block encodings in its core language and models multiplication denotationally as ordinary matrix multiplication while compiling it into a coherent circuit with tracked subnormalization (Yuan, 3 Nov 2025).

Across these variants, “coherent” has a stable meaning: the product is formed unitarily, with projection onto the success subspace used only in analysis or eventual outer-level post-selection, not as an intermediate computational step.

2. Standard coherent product construction

For two block encodings, the canonical circuit rule is sequential composition on disjoint ancillas. If $A$8 block-encodes $A$9 using ancilla register $B$0 of size $B$1, and $B$2 block-encodes $B$3 using ancilla register $B$4 of size $B$5, while both share the same system register $B$6, the composed unitary is

$B$7

In Qrisp’s interface, ancillas are prepared in $B$8 and $B$9, $U$0 is applied first on $U$1, then $U$2 on $U$3, and no measurement or post-selection occurs during the composition (Petrič et al., 20 Apr 2026).

With the joint ancilla projector onto $U$4, the signal block satisfies

$U$5

so the top-left block realizes the product of the individual signal blocks. The ordering is operationally important: applying $U$6 and then $U$7 yields $U$8, while the reverse order yields $U$9. Qrisp therefore fixes the convention that A @ B encodes $a+s$0 via $a+s$1 (Petrič et al., 20 Apr 2026).

This construction is the direct product analogue of the composition rules used much earlier in approximate circuit synthesis via block encodings. There, if $a+s$2 and $a+s$3 are approximate block encodings on disjoint ancillas and the same system register, then the coherent product unitary

$a+s$4

is an $a+s$5-block-encoding of $a+s$6, with additive gate cost and additive ancilla usage (Camps et al., 2020).

The absence of measurement is not merely a formal convenience. It is what allows the product unitary to be reused inside larger coherent transformations. Qrisp explicitly connects this to qubitization, QSP/QSVT, further products, and walk-operator constructions; ancillas may later be referenced by reflections around $a+s$7 rather than being measured (Petrič et al., 20 Apr 2026).

3. Error propagation, normalization, and spectral consequences

If

$a+s$8

and one writes

$a+s$9

then the product block expands as

$(\alpha,a,\varepsilon)$0

Using $(\alpha,a,\varepsilon)$1 and $(\alpha,a,\varepsilon)$2, Qrisp gives the bound

$(\alpha,a,\varepsilon)$3

hence

$(\alpha,a,\varepsilon)$4

In terms of top-left block error, the propagation rule is

$(\alpha,a,\varepsilon)$5

(Petrič et al., 20 Apr 2026).

Related work gives closely aligned first-order statements. The rectangular product construction for arbitrary dimensions states that if the packing permutations are exact, then the resulting $(\alpha,a,\varepsilon)$6 block-encoding has normalization $(\alpha,a,\varepsilon)$7 and error

$(\alpha,a,\varepsilon)$8

matching the standard folklore bound up to higher-order terms (Dong et al., 19 Sep 2025).

The multiplicative growth of normalization is often the dominant algorithmic issue. In QSVT-based linear solvers, the relevant quantity is not the classical condition number alone but the subnormalized condition number

$(\alpha,a,\varepsilon)$9

so coherent multiplication of separate encodings of $A$0 and $A$1 produces a product with effective normalization $A$2 and corresponding cost scaling with $A$3. One empirical study of quantum preconditioning for CFD matrices found that separate coherent multiplication “introduces excessive subnormalisation factors, negating improvements in $A$4,” whereas classical pre-multiplication followed by a single encoding could substantially improve the effective condition number. In the reported $A$5 example, this alternative reduced the number of QSVT phase factors by a factor of $A$6 (Lapworth et al., 28 Feb 2025).

That study also introduced “preamplified quantum multiplication,” in which singular-value amplification is applied separately to the operands before coherent multiplication so that the effective normalization becomes $A$7. The reported conclusion was that, for the CFD instances considered, attainable amplification factors were too modest to overcome the extra query overhead (Lapworth et al., 28 Feb 2025).

4. Ancilla complexity and alternative product gadgets

Ancilla growth is the main structural cost of coherent multiplication, and recent work has produced several distinct regimes.

Construction	Ancilla/qubit usage	Characteristic feature
Standard concatenation	$A$8	Direct stacking of disjoint-ancilla unitaries
Rectangular packing construction	$A$9 total qubits	Arbitrary rectangular dimensions
Cobble binary product	$s$0	Reused ancilla register plus one tracker
Exact $s$1-factor MCM multiplication	$s$2 measurement ancilla	Proven optimal in that model
Near-identity approximate multiplication	$s$3 with $s$4	Error $s$5

For a single matrix-matrix product of rectangular matrices, one construction achieves a coherent block-encoding of $s$6 using

$s$7

total qubits and gate overhead

$s$8

by introducing a structured packing permutation that colocalizes the useful overlap dimension while preserving coherence. In the square power-of-two regime, this uses strictly fewer qubits than the standard additive-ancilla construction whenever the shared inner dimension is smaller than both embedding dimensions (Dong et al., 19 Sep 2025).

The same paper extends coherent product arithmetic to Kronecker and Hadamard products. For Kronecker products, basis permutations $s$9 and $$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$0 gather the desired subblocks into the top-left corner; a “two-CNOT” gadget replaces SWAP with two CNOTs. For Hadamard products, coherent replication operators $$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$1 and $$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$2 implemented by $$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$3 CNOTs select the diagonal subblocks of a Kronecker product. Both constructions preserve coherence and inherit the normalization $$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$4 (Dong et al., 19 Sep 2025).

For long products, the ancilla question becomes asymptotic. One line of work proves that any universal MCM-style circuit for exact coherent multiplication of $$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$5 block encodings must use at least

$$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$6

measurement ancilla qubits, and that a modified compression gadget saturates this bound. In that gadget, a counter is incremented whenever an intermediate block-encoding ancilla enters the bad subspace, so the all-good branch is the unique branch with counter $$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$7 (Vasconcelos et al., 10 Jul 2025).

The same work also shows that the lower bound is specific to exact multiplication. In the near-identity regime

$$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$8

a $$\left\|A-\alpha\big((\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)\big)\right\|\le \varepsilon.$$9-bit modular counter yields an approximate multiplication gadget with

$$\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$$0

so a single measurement ancilla ($$\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$$1) gives $$\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$$2 error (Vasconcelos et al., 10 Jul 2025). This does not contradict the exact lower bound; it exploits approximation together with a specific closeness-to-identity assumption.

5. Programming abstractions and compiler support

A major recent development is the treatment of block encodings as first-class programming objects rather than ad hoc circuit constructions. Qrisp’s BlockEncoding interface stores the normalization and the unitary subroutine, supports arithmetic composition, and exposes algorithmic methods such as .qubitization(), .chebyshev(k), .poly(...), .inv(), and .sim(t,N). In this interface, A @ B is exactly the coherent product construction above, with automatic ancilla management and .resources(...) support for gate counts, circuit depth, and qubit usage (Petrič et al., 20 Apr 2026).

Unitaria adopts a more general subspace-based model. Its multiplication node is conceptually “simply given by the sequential application $$\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$$3,” but the implementation inserts internal basis permutations so that the output subspace of $$\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$$4 aligns with the input subspace of $$\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$$5. The normalization becomes $$\gamma_A\gamma_B`, while verification can be performed through a matrix-arithmetic evaluation path that computes the product directly on encoded matrices and vectors without depending on ancilla qubits or state-vector circuit simulation (<a href="/papers/2605.10768" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Deiml et al., 11 May 2026</a>).</p> <p>Cobble embeds coherent multiplication into a domain-specific compilation pipeline for quantum computational linear algebra. In the exact setting used there, multiplication is expressed with an infix operator, compiled by sequencing the factor circuits, reusing the larger ancilla register, and adding one success-tracking ancilla in the binary case. Its cost model records that queries add, subnormalizations multiply, and ancilla usage becomes</p> <p>$$\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$6

for a binary product. Cobble further rewrites repeated products of a common Hermitian base into a single QSVT stage through polynomial fusion, which in one regression benchmark reduced the reported cost from $\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$7 to $\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$8 (Yuan, 3 Nov 2025).

These frameworks all preserve the central coherent semantics, but they expose different optimization levers. Qrisp foregrounds circuit construction and resource estimation, Unitaria separates encoding semantics from approximation and emphasizes classical verification, and Cobble integrates multiplication into a cost-guided compiler that can replace naive product chains by QSVT-based realizations when symbolic structure permits.

6. Algorithmic roles, specialized realizations, and common pitfalls

Coherent multiplication is a basic subroutine for QSP/QSVT, polynomial filtering, matrix inversion, Hamiltonian simulation, and linear-system solvers. Qrisp explicitly notes that while repeated multiplication can build polynomials such as $\left\|(\langle 0^a|\otimes I_s)U(|0^a\rangle\otimes I_s)-A/\alpha\right\|\le \tilde\varepsilon,\qquad \tilde\varepsilon=\varepsilon/\alpha.$9, one should generally prefer .poly(...) or .chebyshev(k) because raw multiplication grows ancilla count and depth linearly with degree, whereas qubitization and QSP/GQSP realize the same transform with near-optimal query complexity (Petrič et al., 20 Apr 2026).

The same distinction appears in compiler work. Cobble treats direct multiplication as the baseline coherent realization, but uses polynomial fusion to replace power series in a common Hermitian base by a single QSVT block, substantially reducing both query count and subnormalization in favorable cases (Yuan, 3 Nov 2025). This suggests that coherent multiplication is best viewed as a primitive to be deployed selectively rather than as the universally optimal way to realize matrix functions.

A specialized exact regime appears in finite-group computation. For discrete subgroups such as $A$00 and $A$01, reversible arithmetic circuits implement a coherent group multiplication gate

$A$02

with clean ancillas and $A$03. Because the ancillas are uncomputed, products compose coherently with unit success probability and no oblivious amplitude amplification is required. In Fourier space, the same multiplication becomes block diagonal over irreducible representations (Lamm et al., 2024).

Several common misconceptions are addressed directly by the literature. Coherent multiplication is not the same as executing the non-unitary map by post-selection: Qrisp’s apply_rus may use post-selection to emulate the non-unitary action on a state, but the multiplication itself remains coherent until such a readout is explicitly requested (Petrič et al., 20 Apr 2026). Nor is ancilla reduction free: qubit-efficient products often trade qubits for structured permutations, extra gate overhead, or model-specific assumptions (Dong et al., 19 Sep 2025, Vasconcelos et al., 10 Jul 2025). Finally, the dominant bottleneck is frequently not operator-norm approximation error but normalization growth. In preconditioned linear-system settings, the multiplication of subnormalization factors can overwhelm improvements in the spectrum of the matrix product (Lapworth et al., 28 Feb 2025).

Current limitations are correspondingly practical. Qrisp notes that more efficient product constructions, specifically Dong–Li–Xue “Products between block-encodings,” are planned for integration; its current error tracking is conservative; and controlled block-encodings and variable-time amplitude amplification are handled within specific algorithm modules rather than a general-purpose product utility (Petrič et al., 20 Apr 2026). More broadly, recent compiler and library work separates coherent multiplication into a stable semantic core and a rapidly evolving layer of ancilla management, error accounting, and structure-exploiting optimization.