FOQCS-LCU: Efficient Block Encoding for Spin Models

• FOQCS-LCU is a depth-oriented LCU framework that explicitly stores Pauli-string X/Z supports to enable a shallow, parallel SELECT oracle.
• It employs structure-aware PREPARE circuits based on Dicke states to efficiently load coefficients and overcome synthesis bottlenecks.
• The method minimizes controlled-block encoding overhead by exploiting trivial control, achieving additive depth scaling in matrix polynomial block encodings.

FOQCS-LCU is a structured linear-combination-of-unitaries framework for block encoding operators expressed as Pauli-string sums. The acronym stands for Fast One-Qubit Controlled Select Linear Combination of Unitaries. Its defining move is to replace the standard binary-indexed, multiply controlled SELECT oracle of LCU by a check-matrix-style representation in which the $X$- and $Z$-support of each Pauli string are stored explicitly in two ancilla registers and applied through two parallel layers of two-qubit gates. Introduced as a compact LCU formulation for practical block encodings of structured spin Hamiltonians and then extended to products, powers, and matrix polynomials, FOQCS-LCU is characterized by a shallow SELECT oracle, structure-aware PREPARE circuits based on Dicke states, and a “trivially controlled” property that makes controlled block encodings unusually inexpensive (Chiara et al., 28 Jul 2025, Nibbi et al., 26 Jan 2026).

1. Origin and defining objective

FOQCS-LCU was introduced as a variant of standard LCU block encoding aimed at the practical bottleneck of explicit circuit synthesis. In ordinary prepare-select-unprepare constructions, one writes

$H=\sum_{m=0}^{M-1}\alpha_m U_m,$

prepares an ancilla superposition over the index $m$, and applies

$$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$

The standard difficulty is that SELECT typically requires multiply controlled applications of the $U_m$, which become deep and hardware-unfriendly. FOQCS-LCU was designed specifically to eliminate that depth bottleneck for Pauli-structured operators while preserving the usual LCU semantics of postselected block encoding (Chiara et al., 28 Jul 2025).

The later matrix-polynomial work treats FOQCS-LCU not merely as a standalone Hamiltonian block encoding, but as the primitive from which one can assemble block encodings of products, powers, and

$p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$

In that extension, the practical claim is no longer only that a single block encoding is shallow, but that polynomial block encodings can be made additively shallow in $n$ and $d$, and that controlled versions remain similarly inexpensive (Nibbi et al., 26 Jan 2026).

A plausible summary is that FOQCS-LCU is best viewed as a depth-oriented re-engineering of LCU rather than a new abstract model of block encoding. Its central tradeoff is explicit throughout the literature: more ancillas, much less SELECT depth (Chiara et al., 28 Jul 2025, Nibbi et al., 26 Jan 2026).

2. Algebraic formulation and block-encoding structure

The FOQCS-LCU formulation begins from the usual Pauli-string LCU setting but rewrites the Hamiltonian in separated $X/Z$ index form. For an $Z$0-qubit target matrix,

$Z$1

where $Z$2. The coefficient normalization is

$Z$3

The right and left preparation oracles are

$Z$4

$Z$5

The resulting FOQCS-LCU circuit has the form

$Z$6

acting on $Z$7 ancilla qubits and an $Z$8-qubit system register. Postselection of the ancillas onto $Z$9 yields the normalized action of $H=\sum_{m=0}^{M-1}\alpha_m U_m,$0 on the system. The block-encoding notion used is the standard one: a unitary $H=\sum_{m=0}^{M-1}\alpha_m U_m,$1 is an $H=\sum_{m=0}^{M-1}\alpha_m U_m,$2-block encoding of $H=\sum_{m=0}^{M-1}\alpha_m U_m,$3 if

$H=\sum_{m=0}^{M-1}\alpha_m U_m,$4

In the idealized circuit formulas used in the matrix-polynomial construction, the constructions are exact and $H=\sum_{m=0}^{M-1}\alpha_m U_m,$5 (Nibbi et al., 26 Jan 2026).

This decomposition can also be described in check-matrix language. For a single qubit,

$H=\sum_{m=0}^{M-1}\alpha_m U_m,$6

with

$H=\sum_{m=0}^{M-1}\alpha_m U_m,$7

FOQCS-LCU stores the two binary strings $H=\sum_{m=0}^{M-1}\alpha_m U_m,$8 and $H=\sum_{m=0}^{M-1}\alpha_m U_m,$9 directly in ancilla registers, so the Pauli support pattern is encoded distributively rather than by a single binary term label (Chiara et al., 28 Jul 2025).

3. SELECT compression and structure-aware PREPARE

The distinctive circuit innovation of FOQCS-LCU is the SELECT oracle. Instead of conditionally applying one entire $m$0 under a multi-qubit control register, FOQCS-LCU applies the $m$1- and $m$2-patterns sitewise: $m$3 where $m$4 is the $m$5-th system qubit. For a fixed ancilla basis state $m$6,

$m$7

Because the controlled-$m$8 gates act on distinct targets, they form one parallel layer; the controlled-$m$9 gates form a second parallel layer. Accordingly, the logical SELECT depth is exactly two: one layer of $$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$0 CNOTs and one layer of $$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$1 CZs, with no Toffolis and no generic multiply controlled unitaries (Chiara et al., 28 Jul 2025).

This is only half of the FOQCS-LCU story. Once SELECT becomes cheap, PREPARE becomes the dominant cost. The 2025 construction therefore develops tailored Dicke-state routines for coefficient loading. The relevant state families include the single-excitation Dicke state

$$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$2

its unbalanced version

$$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$3

the constrained two-excitation states

$$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$4

and the correlated “double Dicke” states such as

$$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$5

These states encode one-body terms, fixed-distance two-body terms, and the correlated $$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$6 support needed for $$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$7-type terms (Chiara et al., 28 Jul 2025).

The reported CNOT counts are explicit. The basic subroutine $$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$8 uses $$\mathrm{SELECT}=\sum_{m=0}^{M-1}|m\rangle\langle m|\otimes U_m.$$9 CNOTs; $U_m$0 uses $U_m$1; $U_m$2 uses $U_m$3; and $U_m$4 uses $U_m$5. For the prepared states themselves,

$U_m$6

$U_m$7

The unbalanced versions have the same CNOT count as the balanced ones; only phase gates and rotation angles change (Chiara et al., 28 Jul 2025).

4. Products, powers, and matrix polynomials

The 2026 extension uses FOQCS-LCU as an input primitive for matrix polynomial block encoding. If $U_m$8 and $U_m$9 each admit FOQCS-LCU encodings, then their product $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$0 can be block encoded by stacking FOQCS gadgets with separate ancilla pairs. Repeating this $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$1 times yields a direct block encoding of $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$2 using $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$3 copies of $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$4, $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$5, and $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$6 select layers. The construction is explicitly not a nested reuse of the original block encoding in the QSVT sense; it is assembled as a larger LCU-type gadget (Nibbi et al., 26 Jan 2026).

To pass from powers to a polynomial,

$p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$7

the paper adds an outer LCU indexed by $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$8. The degree register is encoded in unary: $p_d(H)=a_0 I+a_1H+\cdots+a_d H^d.$9 This avoids multi-controlled selection of the power $n$0: the first $n$1 ones in the unary string activate the first $n$2 FOQCS-LCU blocks.

The polynomial coefficients are folded into the outer LCU by

$n$3

The outer preparation oracles are

$n$4

$n$5

Their unary state-preparation circuits are explicit CRY ladders with parallel phase gates, using

$n$6

and each of $n$7 and $n$8 requires only $n$9 CNOTs (Nibbi et al., 26 Jan 2026).

The main theorem states that the

$d$0

circuit implements a block encoding of $d$1. After postselection, the constructed action is exactly the desired polynomial up to a global phase: $d$2

The main performance claim is a depth statement. Standard approaches such as QSVT give depth scaling

$d$3

so for spin chains with block-encoding depth linear in $d$4, total depth is $d$5. FOQCS-LCU changes this to an additive form: the extra depth overhead for going from $d$6 to $d$7 is linear in $d$8 with no dependence on system size or on the cost of block encoding $d$9. For the spin models analyzed, the total CNOT depth has the form

$X/Z$0

rather than $X/Z$1 (Nibbi et al., 26 Jan 2026).

5. Trivial control and explicit resource estimates

A second defining property of FOQCS-LCU is that controlled block encodings are unusually cheap. The key lemma is structural: if a unitary decomposes as

$X/Z$2

and the $X/Z$3 share a common eigenstate $X/Z$4 with eigenvalue $X/Z$5, then on input $X/Z$6 only the $X/Z$7 need to be controlled. FOQCS-LCU satisfies this because

$X/Z$8

for any system state $X/Z$9. Thus, when the ancillas start in $Z$00, one controls only $Z$01 and $Z$02, not the select layer (Nibbi et al., 26 Jan 2026).

The later paper adds an assumption that

$Z$03

where $Z$04 and $Z$05 have $Z$06 as eigenstate with eigenvalue $Z$07, while $Z$08 and $Z$09 contain only $Z$10 single-qubit gates. For the spin-model circuits considered there, $Z$11 and $Z$12 are each a single $Z$13 gate. Consequently, the controlled FOQCS-LCU block encoding requires only two extra CNOTs. For matrix polynomials the simplification is even stronger: controlling the full polynomial block encoding requires controlling only the first $Z$14 in $Z$15 and the last $Z$16 in $Z$17, giving at most four extra CNOTs total, independent of $Z$18 and $Z$19 (Nibbi et al., 26 Jan 2026).

For the 1D XYZ Heisenberg model,

$Z$20

the non-asymptotic resource counts in the polynomial paper are:

Construction	CNOT depth (all-to-all)	Qubits
FOQCS-LCU	$Z$21	$Z$22
Controlled FOQCS-LCU	$Z$23	$Z$24
Polynomial $Z$25	$Z$26	$Z$27
Controlled polynomial $Z$28	$Z$29	$Z$30

On square-grid hardware the corresponding XYZ depths are $Z$31, $Z$32, $Z$33, and $Z$34, respectively. The same additive pattern appears for the XXZ and Ising examples: $Z$35

$Z$36

$Z$37

$Z$38

The practical point is explicit in the formulas: total gate count still grows like $Z$39, but depth is additive in $Z$40 and $Z$41, not multiplicative (Nibbi et al., 26 Jan 2026).

6. Spin-model scope, limitations, and place within LCU research

FOQCS-LCU has been worked out explicitly for spin Hamiltonians such as the 1D XYZ Heisenberg, 1D XXZ Heisenberg, and 1D Ising models, with square-grid nearest-neighbor mappings and detailed non-asymptotic gate counts (Nibbi et al., 26 Jan 2026). In the original construction, representative applications also included Heisenberg and spin-glass Hamiltonians, where the check-matrix representation and Dicke-state preparation expose repeated support patterns that standard structure-agnostic LCU would not exploit efficiently. For those examples, the paper reports an order-of-magnitude improvement in CNOT count over conventional LCU, and states that FOQCS-LCU scales as $Z$42 for Heisenberg and $Z$43 for spin glass (Chiara et al., 28 Jul 2025).

The framework is nonetheless limited by its central tradeoff. The base block encoding uses $Z$44 ancillas for the $Z$45 support registers, and the polynomial construction uses

$Z$46

qubits in the general theorem, with explicit tables giving

$Z$47

depending on architecture (Nibbi et al., 26 Jan 2026). This suggests that FOQCS-LCU is depth-efficient rather than qubit-frugal. A second limitation is dependence on efficient implementations of $Z$48 and $Z$49. For arbitrary matrices, naive state preparation would be exponentially costly; the practical claims in the FOQCS-LCU papers rely on structured Hamiltonians whose coefficients admit compact Dicke-state-based or model-specific preparations (Chiara et al., 28 Jul 2025, Nibbi et al., 26 Jan 2026).

A third limitation is the usual normalization and postselection cost of LCU. FOQCS-LCU uses the same $Z$50-type normalization as ordinary Pauli-string LCU: $Z$51 and for matrix polynomials the outer normalization is

$Z$52

The papers note that $Z$53 is not worse than standard Pauli-string LCU normalization, but postselection cost remains inherent (Nibbi et al., 26 Jan 2026).

Within the broader LCU landscape, FOQCS-LCU occupies a specific niche. It is a deterministic, Pauli-structured, ancilla-rich method that makes coherent block encodings shallow and easily controllable. Other recent LCU directions instead trade coherence for sampling overhead through randomization or grouped virtual/coherent hybrids, using Hadamard-test-based estimators or reduction-factor tradeoffs rather than constant-depth SELECT oracles (Sun et al., 18 Jun 2025, Wada et al., 6 Dec 2025). A plausible implication is that FOQCS-LCU is complementary to those approaches: it addresses the circuit-depth bottleneck of coherent block encoding, whereas randomized and hybrid LCU frameworks address the depth–sampling tradeoff by weakening the requirement of exact coherent realization.

In that sense, FOQCS-LCU is not simply “an LCU method.” It is a particular answer to the question of how one should compile structured Pauli LCUs when shallow depth and inexpensive control are the primary constraints: store support explicitly, parallelize SELECT, encode coefficients with structured Dicke-state routines, and exploit the trivial eigenstate of select to make controlled versions nearly free (Chiara et al., 28 Jul 2025, Nibbi et al., 26 Jan 2026).