WorksPhysics and Astronomy
Scalable Quantum Computational Science: A Perspective from Block-Encodings and Polynomial Transformations
Abstract
Significant developments made in quantum hardware and error correction recently have been driving quantum computing towards practical utility. However, gaps remain between abstract quantum algorithmic development and practical applications in computational sciences. In this Perspective article, we propose several properties that scalable quantum computational science methods should possess. We further discuss how block-encodings and polynomial transformations can potentially serve as a unified framework with the desired properties. Recent advancements on these topics are presented including construction and assembly of block-encodings, and various generalizations of quantum signal processing (QSP) algorithms to perform polynomial transformations. The scalability of QSP methods on parallel and distributed quantum architectures is also highlighted. Promising applications in simulation and observable estimation in chemistry, physics, and optimization problems are presented. We hope this Perspective serves as a gentle introduction of state-of-the-art quantum algorithms to the computational science community, and inspires future development on scalable quantum computational science methodologies that bridge theory and practice.
Introduction
Progress in quantum hardware1–9, fault-tolerance10–13, quantum control14–16, and quantum algorithms17–21 in the past decades has made large-scale quantum computers closer than ever. Just as how classical computers accelerated discoveries in the past century22–24, quantum computers, especially fault-tolerant (FT) ones, can be a powerful addition to the toolbox of computational scientists to accelerate understanding and discoveries in science and engineering. Recent advancements have indeed started to push quantum computing from small-to utility-scale applications, together with the help of classical high-performance computing (HPC) systems25.
No doubt that classical HPC plays important roles in quantum, but scaling quantum computational methods themselves faces many challenges. For one, there remains a huge gap between quantum algorithm development and practical applications in computational science. Quantum computers work in a fundamentally different way than classical ones. Historically, most fault-tolerant quantum algorithms were discovered by mathematicians or computer scientists, where the original analysis is very different from what computational scientists use on a daily basis. From a practical perspective, the limited availability of real quantum hardware resources makes it challenging for computational scientists to perform extensive experimental execution of quantum algorithms on actual hardware for problems of interest to iterate and improve algorithm construction.
Bridging this gap is of critical importance for sustained development of quantum computational science. This is not only because computational scientists often know the most demanding practical applications that can test the ultimate limit of any computing machines but also because they have the best classical computational methods that can help benchmark performance of quantum computers and pin down applications for practical quantum advantage. Advocating quantum computational methods in domain applications is particularly important in the coming early fault-tolerant era (with a logical qubit error rate of ). This is a regime where the complexity of quantum computing methods will increase enough such that they are likely capable of tackling problems beyond classical computers. While at the same time, simple reasoning that we can perform at the current stage on the performance of quantum algorithms may become very limited. To overcome this gap, beyond continued improvement on quantum hardware, demystifying fault-tolerant quantum algorithms for computational scientists is essential for bridging theory and practice.
In this Perspective, we define properties that scalable quantum computational science methods should possess. Searching over the current algorithmic landscape, we identify a class of key quantum algorithmic primitives, the quantum signal processing (QSP) algorithm26–28 and its generalizations21,29–38, which satisfies these properties and can serve as a core primitive for scalable quantum computational science methodology development. We provide a pedagogical overview of the two building blocks of QSP algorithms, i.e., the block-encoding and polynomial transforms, and review the most recent development of this family of algorithms. We discuss error tradeoffs between block-encoding and polynomial transforms, as well as basic tools to construct them and assemble them in a modular fashion into complex quantum computing methods. Whenever possible, we provide explicit quantum circuits and focus on connections from abstract algorithms to practical applications in chemistry, physics, and other domain applications. We hope our work helps to demystify QSP algorithms for computational scientists and inspire future community efforts toward methodology development in scalable quantum computational science.
The rest of the article is organized as follows. We define notions of scalable quantum computational science methods and introduce basic notations in Sec. II. § 2 and IV each describes the art in the two pillars of QSP algorithms, i.e., block-encoding and polynomial transforms. § 2.2 briefly discusses ways to scale QSP algorithms to parallel and distributed quantum architectures. § 2.3 provide illustrative examples on common applications in physical science and beyond, followed by conclusion in Sec. VII.
Quest for Scalable Quantum Computational Science
Computational science aims to efficiently simulate physical systems and processes with computers. This idea, while simple as it sounds, presents significant challenges for classical computers. As a result, significant sacrifice on accuracy is needed to accommodate computation of practical relevance into classical computers of reasonable size. This unfortunately leads to the loss of predictive power for a large class of problems.
The power of quantum computers can potentially allow us to escape this doom by making a much better tradeoff between accuracy and efficiency, providing that a collection of scalable quantum computational methods can be developed to finally achieve predictive power for computational problems. While it is challenging to establish all quantum computational methods all at once, we can nonetheless outline a set of properties for such methods. The properties we will present are somewhat different from the current status of the field; the goal is to open the opportunity of constructing a quantum computational science paradigm that significantly differs from the classical ones. We present this set of properties below:
Property 1. Exhibit well-characterized and quantifiable resource cost. The methods should possess well-defined bounds that quantify key quantities such as error rates, time complexity, qubit count, energy consumption, and gate count. These bounds must at least enable their estimation based on other measurable parameters. This is in sharp contrast with current NISQ algorithms that are heuristic or variational in nature. We note that opportunities still exist for heuristic algorithms on quantum computers.
Property 2. Be resource-efficient and possess a flexible trade-off between various resource types. For a given application problem, the computing method should be able to be easily adapted to various versions that can be implemented in an efficient manner on available resources and hardware (serial, parallel, and distributed). The notion of efficiency should be precisely defined, but may vary from application to applications and may depend on the best known classical algorithm runtime to solve that problem. The method should maintain an optimal trade-off between accuracy and resource cost, space (classical and quantum), and time (gate depth and sample complexity) cost.
Property 3. Adaptability, programmability, and modularity. The method should be sufficiently adaptable to accommodate diverse types of applications that can take different inputs and may require different levels of outputs, including hybrid implementations that integrate classical and quantum data. It should also exhibit scalability, enabling the incremental incorporation of additional functionalities when required by the application. The method should be easy enough to program, allowing a tunable level of abstraction and modular assembly from gates to arithmetic to modules.
These properties can then serve as a reference for the development of methods.
Block-encoding and Polynomial Transformation as Promising Candidates
Searching through the landscape of existing quantum computing algorithms, we identify primitives that best satisfy these properties: quantum signal processing (QSP) algorithms and their variants. In the following, we briefly explain how the two building blocks of QSP algorithms, block-encoding (BE) and polynomial transformations, make QSP-type algorithms strong candidates for future quantum computational science methods.
It is well established that block-encoding and polynomial transformations possess well-characterized resource costs for given error thresholds21. These bounds enable the estimation of fundamental resource requirements such as error rates, gate counts, qubit counts, time complexity, and query complexity for a given quantum algorithm, as we will present in § 2 and IV. In contrast to variational or heuristic methods that depend on classical training parameters, block-encoding and polynomial transformations offer a clear and systematic framework for analyzing the trade-off between computational efficiency and accuracy. Additionally, block-encoding and polynomial transformations provide modular implementation schemes and different-level of abstractions that can be adapted to different hardware platforms. These methods also offer a straightforward means of accommodating arbitrary input data and support the possibility of incremental implementations. Given the versatility of function approximation achievable within the QSP framework, these approaches can be applied to a broad range of practical problems.
Nonetheless, the potential advantages of block-encoding techniques and polynomial methods are currently constrained by the limited circuit sizes achievable on current quantum devices. These methods are, however, anticipated to become practical within Fault-Tolerant Application-Scale Quantum (FASQ) systems39 and Fault-Tolerant Quantum Computing (FTQC)40, thereby positioning block-encoding and polynomial transformations as strong candidate techniques in practical applications.
With these three properties being potentially addressed through ongoing research on block-encoding and polynomial transformations, further advances are likely to emerge from the development of new methods that advance the current state of the art. Figure 1 illustrates the central concept discussed in this work, emphasizing various versions of polynomial transformations and block-encoding as central techniques for addressing different applications.
Figure 1. Figure illustrates an overview of block-encoding and polynomial transformation techniques as building blocks of scalable quantum computational science for various applications. Each algorithmic primitive in the middle (light grey) can be used to tackle different applications in the outer part (light blue). For example, the dark color aims to perform Hamiltonian simulation by combining modular-QSP with approximate block-encoding.
Additionally, Figure 1 presents a general workflow for both techniques. In the block-encoding framework, the system of interest is defined and subsequently encoded based on the available computational resources (e.g., number of qubits). For polynomial transformations, one specifies a target observable (e.g., energy) and the corresponding function that represents the computation (e.g., time evolution), which is then adapted using a suitable set of approximation methods. We
note that the early version of block-encoding is also called "qubitization"41, because after block-encoding each singular value or eigenvalue of the block-encoded matrix lives in a block. However, later generalizations of QSP methods can achieve a much broader class of computations. Therefore, in this work, we will use the combination of block-encoding and polynomial transform to refer to the broader class of related quantum algorithms. All of these methods are discussed in detail in § 2 and IV.
A Primer and Notations
We begin this section by introducing the foundational primitives necessary to understand both block-encoding and polynomial transformations necessary for the rest of the paper, summarized as a representative circuit in Table I. While many introductory references42,43 offer more extensive and pedagogically detailed discussions, the focus here is limited to the key concepts most relevant to the analyses presented in subsequent sections of this work.
Qubits: The smallest unit of information in quantum computing is a qubit: a quantum analog of the classical bit. A qubit is a two-level system, whose state can be in a quantum superposition of and :
where is the set of complex numbers, and is the Dirac bra-ket notation to represent a quantum state. A collection of many qubits can also exhibit other quantum properties such as entanglement. For an -qubit state, the vector representation is a -dimensional column vector, with the dimension doubling for each additional qubit, , . The complex coefficients , known as probability amplitudes, satisfy the Born rule .
One-qubit Rotation: Any single qubit gate can be represented as a general rotation over a given axis ,
where is a unit vector and denotes the Pauli matrices. The matrix representation is presented in Table I. Through the work we will use the convention. Only a small set of discrete gates are required to achieve universal quantum computation, as established by the Solovay-Kitaev theorem44. A common universal set is , where , , are single-qubit gates, while CNOT is a two-qubit controlled-NOT gate, analogous to its classical counterpart.
Multiqubit controlled-. A controlled- is illustrated in Table I, in which one qubit serves as the control and the other as the target. The operation gate works as follows: if the control qubit is in the , the unitary is applied to the target qubit, and the identity operation is applied if the qubit is in . In the context of polynomial transformations, as exemplified by Generalized-QSP in Section IV A, it is often useful to define a controlled- operation conditioned on the state instead of . This operation can be implemented by adding conjugated gates on the control qubit, as illustrated in Table I. In addition to two-qubit gates, multi-control multi-target quantum gates can be defined whose implementation is based on using as few two-qubit gates as possible, potentially supported by ancilla qubits45,46.
Projector and projector-controlled operation. The previous controlled operations can be generalized through the use of projection operators (also projectors). A projector is defined as an operator where . Then a projector -controlled operation, i.e., can be defined that selectively apply to the subspace flagged or projected by .
For instance, the controlled- in the previous paragraph is a special case where the projector (or ). This projection is essential for polynomial transformations, as it enables the application of a given operation to a specific subspace where the block-encoded matrix lives and the polynomial transformation happens.
Measurement and post-selection. Measurement allows extraction of classical information from quantum computation. Measurement is particularly important for QSP methods, because the desired computation results are often only block-encoded, or exist in a subspace of the entire unitary. Therefore a measurement is necessary to extract or post-select the computational outcome. § 2 will provide an example of this.
| Quantum Circuit Representation | Equation | Description | Matrix |
| General rotation circuit | General rotation on the Bloch sphere. Any single-qubit gate can be synthesized using this rotation. For . | ||
| Controlled- circuit | General control-1 gate. This is a matrix controlled by the first qubit when it is in state . | ||
| Controlled- circuit with gates | General control-0 gate controlled by state . The gates serve as an easy implementation trick based on a controlled- gate. | ||
| Projector-controlled- circuit | General projector operator. Apply onto the subspace . For QSP subroutines this is usually the projector. | ||
| Measurement projection within a unitary implementation | Measurement projection within a unitary implementation. Extracts information in the subspace where block-encoding lives. | ||
| Partial trace over qubit register | Partial trace over qubit register . Discard to obtain a density matrix on register rather than performing a projective measurement. |
Table 1. Quantum gates and useful circuit implementations used in this work for block-encodings and polynomial transformations.
Block-Encodings and Construction Techniques
Building on the motivation and notations in previous section, we now turn to the theory and practice for constructing block-encodings. Sec. III A introduces block-encoding (BE) from a general perspective of matrix dilation theory, presents a few explicit mathematical constructions of BEs, and highlight the importance of approximate BEs as computationally more efficient alternative to exact BEs. Sec. III B builds on these dilation theory and present methods to assemble multiple BEs together, including realizing addition, subtraction, multiplication of BEs. Sec. III C give several explicit circuits for constructing and assembling BEs, most of which are known from previous work. Sec. III D compiles existing software tools for generating explicit circuits for BEs and benchmarks their performance using simple molecular systems.
Block-Encoding and Unitary Matrix Dilation
The idea of block-encoding is simple – any amplitude or matrix where computation needs to be performed upon using quantum computers first has to be encoded inside a unitary matrix. Block-encoding refers to the process of encoding the amplitude or matrix as a block of a larger unitary matrix. This process necessarily requires introducing ancillary qubits due to the enlarged Hilbert space. Interestingly, this process of embedding a matrix into a larger matrix with some properties has been studied in applied math under a different name, matrix dilation47, independent of quantum computing development.
Specifically, for a general (can be non-normal) matrix , a unitary dilation of is
such that is a unitary matrix. Ref.41 shows that has a unitary dilation if and only if (i.e., is a contraction). This means any matrix can be encoded as a sub-matrix of a unitary that can be later encoded onto a quantum computer using a quantum circuit. There are several different ways of producing a unitary dilation. More formal definitions deal with algebraic contractions of the matrix on a separable Hilbert space47. In the following, we discuss some unitary dilations of the matrix and the applicability of each of them.
Unitary Dilation of Hermitian Matrices. The most widely known unitary dilation is for Hermitian matrix. Given a Hermitian matrix , one can construct a unitary matrix such that
The parameter is a rescaling constant that is required for the unitarity of the whole matrix , and is the matrix norm. The choice of location as upper left block in of Eq. (4) is only by convention. can be encoded in any other location of as well. Using the measurement projection from Table I, we can show that
Unitary Dilation via Polar Decomposition. For general square matrix that are not necessarily Hermitian, its polar decomposition always exists, where is unitary and is a positive semi-definite Hermitian matrix defined as , also known as the left polar decomposition. Then we can prove that
is a unitary dilation of by simply verifying . As a special case, let with as a global phase, the unitary dilation can be written as
These different form for representing a matrix can be important in quantum circuit realization of (approximate) block-encodings.
Unitary dilation via Hermitian Dilation in . Now we consider a slightly different way of dilating a general non-square (non-normal) matrix . We first construct a Hermitian dilation . Next, a dilation of in can be constructed using the previously developed method. This construction via an intermediate step of a Hermitian matrix enables us to use properties of Hermitian matrices even when the matrix is not Hermitian. This can sometimes be helpful to simplify our block-encodings.
One of the simple way to recast any matrix (including non-normal) into a Hermitian matrix is by defining
In this way, we can use two additional ancilla to block-encode a non-normal matrix . Moreover, the eigenvalues of always appears in pairs with opposite signs, and it can be shown that the eigenvalues of are actually for . This is a key relationship in connecting results for eigenvalues of Hermitian matrices to results for singular values of general matrices.
Building on our previous results on the block-encoding of a rescaled Hamiltonian , and by incorporating the auxiliary operator , we can construct a unitary operator that serves as a block-encoding of an arbitrary matrix using Eq. (8):
where
Here, is block-encoded in the block. It can be moved to the diagonal block by simply multiply
This particular dilation of is important when one needs to have a BE that is also Hermitian. As an application, this particular approach can be useful for chiral symmetry in non-Hermitian systems48.
Unitary Dilation with Minimum Dimension. Let , so , and if and only if is unitary. It follows that . Since is a contraction, so both and are positive definite. This means there exist non-singular matrices such that
and . Define
then
is a unitary dilation of . In fact, this is the unitary dilation of with the smallest dimension.
Unitary Dilation in General Space. At the other end of the spectrum, it can be useful to construct a very large unitary dilation with a much enlarged large Hilbert space, as this will proven to be useful for assemble block-encodings.
Any unitary dilation in
developed above admits a simple generalization to the space of in the following way. Consider the block matrix where each block is defined as , , , , , and all the other blocks are zero:
It can be shown that is indeed a unitary dilation of for arbitrary $k\geq 2.
Approximate BEs. Previous methods implement an exact dilation of a matrix . Nevertheless, depending on the size of the matrix and the sparsity the exact implementation can be resource-intensive to implement49. This inspires the study of approximate BEs.
In general, for a given matrix that block-encode , we said that is an approximation of with error , if
Such approximations have been studied using the Fast Approximate BLock-encoding (FABLE) algorithm that block-encodes an arbitrary matrix in using one- and two-qubit gates50. Modifications of the same algorithm have been implemented that perform better in sparse matrices and lose efficiency when there are symmetries in it, called S-FABLE and LS-FABLE51. Recursive implementations have also been proposed to construct approximations that use smaller block-encodings, easy to implement, and utilize ancilla qubits for the efficient synthesis of block-encodings52.
Recently, quantum-classical variational algorithms have also been studied for block encoding for applications in non-Hermitian dynamics and open quantum systems53, suggesting the importance of efficient block-encoding methods for quantum simulations. Ideas from perturbation theory and similarity transform known in many-body physics and quantum chemistry can also be used to construct approximate block-encodings. Introducing approximation in block-encodings has important consequences for error analysis of QSP algorithms, as we will discuss in Sec. IV E.
Methods To Assemble Block-Encodings
Once block-encodings are constructed for individual matrices, ways to assemble multiple block-encodings together will be important for scalable computation. In particular, elementary arithmetic such as addition, subtraction, and multiplication between block-encodings will be desired.
Addition and Subtraction. Given two block-encoding matrices of as , respectively, using the unitary dilation form, we can implement the addition or subtraction using the dilation of the form
where are unitary. By multiplication of these matrices and conjugation using we have
which allows us to implement addition on the upper left corner and subtraction on the upper right.
This process can be implemented iteratively to sum many matrices, in similar spirit as the linear combination of unitaries method54. If there is a constant scaling factor for each matrix as in Eq. (4), the result will also apply but only change the success probability to get the proper result. This success probability can be boosted using recent techniques of amplitude amplification55.
Multiplication and Power. Using the results from the previous dilations, we can combine two different block-encoding to form the multiplication of two matrices, given in the general dilation on the space for
It is easy to verify that
which means that we can form the multiplication of by simple multiplying their block-encodings together. The particular block-encoding can be implemented using an architecture based on qutrits.
In addition, this method can be generalized to multiplication of matrices. Given , and given their dilation as . Therefore, what we have
is a unitary dilation of . Note that the total resource requirement for encoding each is , where the number of ancilla qubits is . Observe that the number of ancilla qubits needed scales only in a logarithmic form as the number of matrices which are being multiplied, as also pointed out by a recent work56. This is analogous to the case of the LCU approach (where unitaries are summed up to produce the block-encoding of sums of matrices instead of products), where the number of ancilla qubits is also equal to where is the total number of unitaries that is summed up.
Quantum Circuit Realization
There are many ways to realize a block-encoding circuits based on the properties of the matrix being block-encoded. Designing efficient implementation of BE circuits itself is an active area of research49,56,57. The problem is challenging as the structure of the matrix being block-encoded has to be properly exploited by quantum circuits to achieve efficient block-encoding49. The structure of a matrix is often basis-dependent, which makes it even more challenging. Some algorithms leverage the structure of the sparsity matrix to perform efficient block-encoding50,58. We review some existing methods for constructing BE circuits.
Block-encoding of Sparse Matrices.58 For sparse and well-structured matrices, we can block-encode a matrix $A\in , where and the number of qubits, given a sequence of operators in the following way, depicted as a quantum circuit in Figure 2.
Figure 2. Circuit to block-encode a sparse matrix .
The operation applies a set of Hadamard gates to the second register, where is the register size. The second register implements the encoding of the matrix element of , as the following
The third register implements the mod operation to the two registers . While this implementation provides an exact, step-by-step circuit construction for building a block encoding, the following method can be considered easier to construct and more intuitive. However, for sparse matrices, the current implementation remains more efficient.
Linear Combination of Unitaries. One naive way to construct BEs is the Linear Combination of Unitaries (LCU) method54. For this technique, each operator can be decomposed as a sum of unitary operators , such as
where are the coefficients. This circuit can be implemented as depicted in Figure 3, using two operators, called select and prepare, denoted as and , respectively.
Figure 3. Circuit to assemble the linear combination of unitaries.
The non-unitary operator is now block-encoded, for most cases, in the upper-left corner. Then after a post-selection of the state, refer to Table I, where is the extra Hilbert space necessary to block-encode the system ( for given in Eq. (25)), we can implement the non-unitary operator for a given initial state . Now we will explain each implementation.
Prepare circuit. The purpose of the prepare state is to implement a quantum state that encodes all the decomposition coefficients of the matrix , defined as:
Here, denotes the normalization factor. The main idea is to encode each coefficient and select the corresponding unitary operator based on its value.
Various approaches exist for implementing the prepare operation, which refers to the method of state preparation employed in quantum circuit applications such as Quantum Phase Estimation (QPE). In this work, for illustrative purposes, we employ the "Divide-and-Conquer" method59 that allows us to implement the LCU. The prepare circuit is depicted in Figure 4.
Figure 4. Circuit to implement the prepare operation . Here the angles can be efficiently calculated for a given state.
The inverse prepare circuit can be calculated by flipping the initial circuit state and changing the phase of the gates, following the inverse operation in Table I.
In Sec. III.D we present a compendium list of software to implement block-encodings.
Select circuit. The select operation apply a given unitary to the state , that means:
The following quantum circuit depicts the implementation of the select operation using multi-controlled gates.
Figure 5. Circuit to assemble the select operation using multi-control gates.
The previous implementation of encoding each qubit position in a qubit gate is known as a multiplex gate with controls, which will have possible controlled-unitary gates for a different implementation. In this case each represent a Pauli string that represents a gate. More efficient methods for decomposing these quantum gates have been proposed in the literature46 that requires a decomposition for a -qubit multi-controlled gate proportional .
Projecting to the correct sector. The end of the implementation will have the matrix by projecting the state to the block-encoding of :
While the LCU method can be used to encode a Hamiltonian into a larger Hilbert space, its effectiveness strongly depends on the success probability of measuring the subspace. This probability decreases as the norm of the encoded matrix increases. To address this limitation, techniques that amplify the success probability have been developed, such as oblivious amplitude amplification60. This technique requires that the matrix be antisymmetric for the amplification to be possible. Usually this condition is possible for the majority of the systems.
LCU is known for its conceptual and implementation simplicity. Moreover, the LCU method is not just reserved for block-encoding methods; it can also serve as the main tool for the simulation of the time evolution operator by expressing the exponential term as a Taylor series and implementing it usually on an LCU structure. This approach will be explained in more detail in § 2.3 A, also in the context of Hamiltonian simulation.
Software to construct block-encodings and Benchmarking
In this section, we present the quantum software frameworks that support BE methods. Approximate block-encoding techniques such as FABLE, S-FABLE, and LS-FABLE, have been implemented by the Quantum Computing Lab61 and are accessible through PennyLane62, providing a dedicated FABLE operator and tutorials for constructing block-encoded unitaries.
Variational (quantum–classical) block-encoding approaches are supported by Classiq’s hybrid variational quantum linear solver (VQLS) modules63, using classical optimization together with LCU quantum circuits. This provides a flexible variational route to approximate block-encoded representations without requiring full ancilla-based unitaries.
For methods based on LCU, many platforms offer explicit implementations. OpenFermion64 implements lcu_util for Hamiltonian synthesis; Riverlane’s pauli_lcu65 provides Pauli-term combinations; Google Qualtran66 enables chemistry resource estimation through block-encoded LCUs; and both PennyLane67 and Qrisp68 supply LCU primitives. Classiq63 additionally supports hybrid extensions.
Sparse-matrix block-encodings have been demonstrated in the Explicit-Block-Encodings repository69, while supporting frameworks such as Sequential-Quantum-Gate-Decomposer70, QGOpt71, and GateDecompositions.jl72 focus on efficient gate synthesis and multiplexor optimization. Additional primitives for divide-and-conquer state preparation73, unary iteration74, and amplitude-amplification appear in PennyLane75, Classiq76, and Qrisp77. For Taylor-series LCUs and time-evolution applications, Quantum/CQCL’s qtnm-tts78 and QITE79 repositories offer open implementations. All referenced toolkits are summarized in Table II.
| Method | Associated SDKs / Frameworks |
| Approximate block-encoding (FABLE / S-FABLE / LS-FABLE) | FABLE61, PennyLane62 |
| Variational (quantum–classical) BE | Classiq VQLS module63 |
| Sparse-matrix BE | Explicit-Block-Encodings69 |
| LCU (Linear Combination of Unitaries) | OpenFermion64, Riverlane65, Qualtran66, PennyLane67, Qrisp68, Classiq63 |
| Divide-and-Conquer state-prep | DCSP73 |
| Unary iteration for multi-controls | PennyLane74 |
| Efficient gate decomposition / multiplexor optimization | Sequential-Quantum-Gate-Decomposer70, QGOpt71, GateDecompositions.jl72 |
| Amplitude / Oblivious amplitude amplification | PennyLane75, Classiq76, Qrisp77 |
| Taylor-series LCU (time evolution) | qtnm-tts78, QITE79 |
Table II. Summary of publicly available SDKs and repositories implementing block-encoding techniques.
In order to compare the performance of different quantum software frameworks, without any integrated circuit optimization, in implementing block-encoded Hamiltonians, we examined the gate statistics obtained for the H molecular system. Block-encoded unitaries representing the H Hamiltonian were constructed and decomposed using three major platforms: Qiskit, PyTKET, and Cirq. The interatomic distance was fixed at Å, and one- and two-electron integrals were calculated with the STO-3G basis using PySCF. We perform BE for both first- and second-quantization representation. For this minimal basis, there are only two molecular orbitals ( and ), giving two-electrons each with four spin-orbitals. Under first-quantization, this is mapped to 4 qubits. For the second-quantized case, the Hamiltonian operators were mapped to qubits with both the Jordan–Wigner and Bravyi–Kitaev transformations and normalized by their spectral norm to ensure unitary block-encodings.
Each normalized Hamiltonian was simulated as with a.u. using the prepare and select construction described in § 2 C. Gate counts were extracted automatically after decomposition to the basis and before any circuit optimization passes. Since PyTKET and Cirq do not directly support large () unitaries, the full block-encoding was recursively divided into eight sub-unitaries using the cosine–sine decomposition (CSD), and the total counts were summed. All simulations were performed in Python 3.12 on Ubuntu 22.04, and all scripts, integral data, and notebooks are provided in our GitHub repository for reproducibility80.
Polynomial Transforms and Angle Finding
One way to represent any computation on the BEs is via a polynomial. Over the past decade, QSP algorithms have been developed to effectively realize desired polynomial transformations on the BEs21,28,29,33,34,84–88. In this section, we review existing art to perform polynomial transforms. We start from QSP and GQSP that can perform a single polynomial transform of one variable in Sec. IV A. This is followed by the -QSP algorithm that can perform multiple polynomial transforms simultaneously of a single variable in Sec. IV B. Sec. IV C discusses algorithms that can perform a polynomial transform of multiple commuting or non-commuting variables. Sec. IV D presents ways to assemble polynomials together as well as considerations of building robustness into QSP algorithms, i.e., the idea of algorithmic-level error correction (ALEC). We continue the topic of robust QSP with a discussion of error tradeoffs between BEs and polynomial transforms in Sec. IV E. Finally, Sec. IV F reviews existing software tools for QSP angle finding. Figure 6 presents an overview of all the quantum circuits for polynomial transformations discussed in this work.
Figure 6. Zoo of polynomial transformations realized by QSP algorithms. The original formulation of single-variable single-polynomial transform (a) and the generalized QSP (b) that remove the parity constraint on the polynomials. More recent development of parallel QSP that is suitable on parallel quantum architectures (c). Generalization to the multi-variate polynomial as in M-QSP (d) and multiple polynomials of a single-variable as in QSP (e). Circuit diagrams of normal QSP (f) and M-QSP (g) explicitly with projectors and additional ancilla to impart the signal processing rotations. In M-QSP the quantum gate has a probability to be the operator or . For structured noise, a recovery QSP sequence can be concatenated after a faulty QSP to obtain a robust QSP sequence that suppresses overall error at the algorithmic level (h). The curved boundary boxes represent faulty signal processing gates. The corresponding QSVT circuit can be constructed similarly by using two different projectors in the circuit instead of one.
| Framework | CNOT | |||
| First Quantization | ||||
| Qiskit81 | 896 | 528 | 20 | 235 |
| PyTKET*82 | 1297 | 1570 | 2552 | 342 |
| Cirq*83 | 903 | 392 | 258 | 282 |
| Second Quantization (Jordan–Wigner) | ||||
| Qiskit | 2217 | 1478 | – | 423 |
| PyTKET* | 1300 | 1587 | 2519 | 343 |
| Cirq* | 812 | 364 | 253 | 297 |
| Second Quantization (Bravyi–Kitaev) | ||||
| Qiskit | 915 | 532 | 20 | 236 |
| PyTKET* | 1313 | 1554 | 2524 | 346 |
| Cirq* | 843 | 373 | 252 | 298 |
Table III. Gate counts for block-encoded unitaries of the H molecular Hamiltonian under first- and second-quantization (Jordan–Wigner and Bravyi–Kitaev) mappings. Note that the asterisk (*) denotes frameworks that do not directly support decomposition of the full 5-qubit block-encoded unitary. Therefore, the unitary was recursively decomposed into sixteen 8 × 8 (3-qubit) subunitaries using the cosine–sine decomposition (CSD), and total gate counts were obtained by summing over all subcircuits.
Single polynomial transformation of a single variable
The standard form of QSP interleaves two orthogonal single-qubit rotations, the signal operator and the signal processing operator . The signal operator is fixed and rotates the qubit by the same angle in every iteration, while the signal processing operator are varied to control the shape of the polynomial transformation applied as illustrated in Figure 6a.
If is a -rotation operator with rotation angle , then the signal operator can be expressed as
The signal processing operator can be a -rotation given by
which rotates the qubit by angle . For a sequence of tuple , the overall unitary operation on the qubit can be expressed as
The block-form realized by is of the form,
where, , and are polynomials of that satisfy the following conditions:
(expressivity) , ,
(parity) has parity ,
(unitarity) , .
The current approach implements a polynomial transformation for a single variable . Additionally, connections have been found with space-time dual quantum circuits and Lorentz transformations when considering a complex parameter89. While useful, most practical applications require applying it to a matrix. In order to do that, it is necessary to implement a block-encoding of the desired matrix and project over the subspace where the matrix lies in the expanded Hilbert space41. Figure 6f depicts the circuit implementation.
Extending the work of QSP, Generalized Quantum Signal Processing (GQSP)84 proposed to replace the fixed-axis qubit signal processing operator with an arbitrary rotation illustrated in Figure 6b. The signal operator in the standard GQSP is given by which is a -controlled application of the desired unitary operator of the form , , as shown in Table I. The signal processing operator given by
is an arbitrary rotation tensored with identity operator . Interleaving and . It is just necessary to define one parameter for the sequence that realizes the following block form,
The constraints on the polynomials thus realized are
,
.
This generalization lifts the second parity constraints imposed by QSP and can realize Laurent polynomials with complex coefficients as well, unlike QSP, which can only realize Laurent polynomials with real coefficients. GQSP has also been proven to have connections with other areas that could potentially be applied to different fields, such as the nonlinear Fourier transform90. Moreover, in applications like Hamiltonian simulation, it has been shown that GQSP can double the efficiency of the implementation over traditional methods[91].
Multiple polynomial transformations of a single variable
In QSP (32) and GQSP (34), a single control qubit is used to implement polynomial transformations on the eigenvalues of a target unitary , yielding a unitary of the form
where each entry is a (real for QSP, complex for GQSP) polynomial in . These techniques realize two polynomials and (under some constraints) that transform a given unitary (the signal). This is useful, but the polynomials realized are still only two.
By introducing an ancilla with -qubits (instead of 1), the QSP algorithm can be generalized to simultaneously realize polynomial transformations of a single variable in one circuit. This has recently been accomplished by the so-called -QSP [33,34] algorithm as depicted in Figure 6e. More specifically, given any unitary as a signal that one would like to transform over, it is possible to construct a quantum circuit that uses calls a projector controlled- operation (block-encoding of )
that realizes degree- polynomial transformations over simultaneously
for a given polynomial matrix . The shape of the polynomials are controlled by the unitary operations on the -qubit ancilla . The degree of each such polynomial is no more than . Similarly, if we have a unitary and complex polynomial matrix with constraints on its singular values, it is possible to construct a quantum circuit with calls to controlled- to realize a polynomial matrix . The QSP and QSVT are useful in implementing a more general polynomial transformation framework with applications in quantum amplitude estimation and encoding multivariate functions.
One polynomial multi-variables
Many important problems involve functions of multiple variables. Multivariate quantum signal processing provides a framework to address such problems. The operators involved in such protocols can be either commuting operators corresponding to the abelian case[92], or non-commuting operators corresponding to the non-abelian case[93] [35].
The bivariate form of the abelian M-QSP can be useful for interrogating joint properties of two commuting signals and encoded in operators and respectively. Such a protocol of length can be defined by a length- binary string and a set of phases such that the desired unitary can be realized by a sequence of operators given by30
where as illustrated in Figure 6d and the generalization for matrices in Figure 6g. The M-QSP ansatz in Eq. (38) can generate complicated multivariable transformations of eigenvalues of commuting variables, finding applications in multi-channel discrimination problems30 and providing a pathway for coherent control of the dynamics of multiple commuting subsystems efficiently.
One important application of the non-abelian QSP is realizing polynomial transformations on systems involving the position and momentum quadratures of a qumode (oscillators) coupled to a qubit[93] [16, 35]. Given access to -rotations parameterized by a set of phases on the qubit, a desirable unitary of non-commuting operators and on the joint oscillator-qubit system can be obtained via the following sequence,
where is a block-encoding of the operator and is a block-encoding of the other quadrature operator . This sequence implements a bivariate Laurent polynomial transformation on the non-commuting operators and of the form
where the complex coefficients and are determined from the phases .
Polynomial Assembly and Algorithmic-level Error Correction
Having explored the diverse forms of Quantum Signal Processing (QSP) in the previous sections, spanning cases for multiple variables (both commuting and non-commuting), multi-polynomials, and higher dimensions, assembling them in a modular way becomes important for scalability. The modular QSP approach as proposed by Ref.[94] builds on combining LEGO-like blocks of QSP-based operators called gadgets, which block-encode multi-variable functions. Such gadgets can be constructed from the Abelian M-QSP approach discussed in the previous section. Basic arithmetic operations like inversion, negation, multiplication, etc., can be defined on gadgets thus obtained, such that arranging various gadgets can realize the desirable super operator consisting of multiple multivariate polynomials.
In the early fault-tolerant era, small gate errors in a long quantum computation can still accumulate to a degree that is non-negligible. Analyzing the performance of fault-tolerant quantum algorithms with structured or small logical errors is therefore an important problem. The iterative nature of QSP algorithms provides algorithmic structures for gate error to propagate in a structured fashion into algorithms. This provides a pathway to analyze and correct errors in QSP at the algorithmic level.
Ref.37 proposed a way to analyze error propagation in QSP via perturbation theory. In particular, a coherent error of is assumed to happen for all signal processing rotation angles, for some small . A procedure was proposed to efficiently propagate these local gate errors to the entire QSP algorithm level. Moreover, once these algorithm-level errors are known, it becomes possible to correct these errors by appending a recovery QSP sequence after the original one, such that the overall errors from the two QSP sequences cancel each other out. This is the basic idea of algorithmic-level error correction protocol[95], as shown in Figure 6h. Future generalizations of this protocol to stochastic error and combination with standard error-correcting code could serve as more powerful ways to curb errors at the algorithmic level.
Error Tradeoff Between Block-Encodings and Polynomial Transforms
Taking block-encoding and polynomial transforms together as QSP algorithms, there are important algorithmic-level error tradeoffs that we discuss in this section.
Deterministic case. Suppose an approximate block-encoding for a matrix has error . Query these approximate block-encodings times in a circuit to realize a degree- polynomial transform; the overall error in the worst case will simply add up to produce . On the other hand, assuming the degree- polynomial approximation to the target function has an error of (we know the precise form of this function approximation theory; for example, Ref.28 derived this for Hamiltonian simulation), then it immediately follows that the maximally allowed error on block-encoding has to satisfy such that the block-encoding error does not ruin the long circuits that QSP performs for polynomial transform. Solving for , we have
This puts an error bound on thinking about any approximate block-encoding strategies in QSP algorithm constructions for a fixed degree-. Alternatively, if we are given a fixed approximate block-encoding, solving the above for
where is a critical degree as a function of the block-encoding error and the target function . This suggests that any QSP algorithms longer than the query depth may not be useful anymore.
For a QSP-based real-time evolution29 (see § 2.3 A and Eq. (49)), (42) becomes
and (43) becomes
For , approaches infinity which means the QSP polynomial degree can be arbitrarily large since no error from block-encoding will be accumulated.
For a GQSP-based real-time evolution38 (see § 2.3 A and Eq. (52)), (42) becomes
and (43) becomes
For , this becomes , which diverges to infinity as expected at a rate slower than but faster than .
Stochastic case. While the above error tradeoff discussion assumes deterministic errors on both the block-encoding and the polynomial transform, when running QSP-type of algorithms on early fault-tolerant quantum computers, stochastic errors will be inevitable. The structure of the error tradeoff will be richer in this case and can be analyzed in the following way.
Suppose is an approximate block encoding of labeled by projector
where is close to a target Hamiltonian . Assume we would like to realize a target non-linear transform with a degree- polynomial transform using QSP for being the QSP phase angles. The noise and errors on the QSP phase angles render the final polynomial transformation to be .
Software to find phase angles
The early work on QSP determines the qubit rotation phases through algorithms similar to Remez exchange algorithms in digital signal processing[96] and numerical optimizations21. However, this approach becomes unstable as the polynomial degree increases, often failing to find valid phase angles for high-degree transformations. A later work[97] proposed improved optimization strategies capable of accurately approximating polynomials of degree greater than with error below using symmetric phase factors. An implementation of this symmetric phase factor optimization can be found in the qspack codebase[98]. pyqsp package[99] has many implementation of state-of-the-art phase finding algorithms as well. Later improvements based on gradient-free fixed-point iteration techniques[100, 101] and on methods derived from nonlinear Fourier analysis (NLFA)[102, 103] have been developed to enhance stability. Ref. 90 has python implementation of the newer phase finding algorithms.
To overcome numerical instability and avoid explicit polynomial root finding, several analytical and algebraic approaches have been developed. One method[104] relies on decomposing trigonometric polynomial factors and updating the phases one by one through algebraic relations, thereby achieving stable phase extraction. Another work[105] achieves machine-precision phase recovery by recursively decomposing the target unitary into a product of lower-degree unitaries , halving the effective polynomial degree at each step. In addition, a small perturbation was introduced to stabilize near-vanishing highest-order terms, referred to as capitalization. Once further decomposition is not feasible, a system of nonlinear equations derived from recursive polynomial relations is solved, eliminating the need for direct root finding. More recently, Ref.[106] formulates QSP angle finding using Prony’s method, also avoiding root finding with stable factorization.
The angle finding algorithm based on Prony’s method for QSP has been generalized to GQSP107 recently. The GQSP angle-finding algorithm includes truncating the target polynomial of degree using methods such as Remez exchange. Following truncation, the function is partitioned as a linear combination of a finite set of simpler functions that satisfy certain constraints for being an integer. Phase factors for each can be calculated using several direct methods, like root finding, or indirect methods, like optimization using L-BFGS. Other quantum software providers like Pennylane[108] also have python implementations of phase angle finding methods for QSVT.
Scalable to Parallel and Distributed Architectures
Scaling up the number of qubits on a single quantum chip has its own challenge in control and fabrication. Multiple quantum chips with interconnects are emerging quantum computing architecture that can overcome these challenges[110, 112] [109, 111]. Future distributed quantum hardware requires parallel and distributed quantum computational science methods. We review recent progress on parallel (§ 2.2 A) and distributed (§ 2.2 B) quantum signal processing algorithms in this section.
From Serial to Parallel QSP
To split a long QSP algorithm into multiple shorter ones, one idea is to break a high-degree polynomial into a collection of many low-degree ones. There are two fundamentally different ideas for achieving this. One is to factorize the polynomial into a product of low-degree ones. The other is to slice the polynomial into a collection of many piecewise smooth functions, where the polynomial for each input segment is naturally well-approximated by a low-degree one (for example, cubic splines).
Ref.31 provides the first construction of a parallel QSP algorithm via the first route – polynomial factorization (Figure 6c). The parallel QSP algorithm factorizes a large-degree polynomial of a special form, where each small-degree polynomial is then executed on a separate quantum computer. Finally, a generalized SWAP test is applied to the output of each quantum computer to “glue” the short polynomial together into a larger one. The algorithm can reduce a depth QSP algorithm into parallel threads of depth QSP algorithm with a sampling overhead of , thus achieving a space-time resource tradeoff. This parallel QSP algorithm has important applications to entropy estimation and partition function evaluation – two useful subroutines for simulating physical sciences. We also note several other recent advances in parallel Hamiltonian simulation113.
From Parallel to Distributed QSP
Parallel QSP achieves a space-time tradeoff by distributing the polynomial transformation into different QPUs. However, the generalized SWAP test stage used to stitch all the individual polynomials together still requires controlled SWAP operations between two QPUs, rendering it not fully distributed.
As is known from quantum information theory, classical communication combined with quantum entanglement can establish a quantum communication channel to teleport either a quantum state or a quantum gate from one QPU to the other. This means that the controlled SWAP operation, and more generally, the entire generalized SWAP test, can be realized by consuming pre-shared entanglement with classical communication between all the QPUs, achieving a fully distributed QSP algorithm. Indeed, this has been achieved in a recent work[114]. It was shown that there is a constant-depth realization of the generalized SWAP test stage in parallel QSP by consuming GHZ state with a width of for parallel threads (independent of the number of qubits in each local QPU). The key to achieving this is the construction of a multi-party SWAP test subroutine with parallel Toffoli gates and constant-depth fanout gates.
Applications
Using the previous techniques in block-encoding and polynomial transformation, we present some applications in this section. Secs. VI A and VI B start with a pedagogical overview of existing methods for two common computational tasks for physical science, i.e., the real- and imaginary-time evolution. Sec. VI C describes the use of the QSP algorithm in expectation value and parameter estimation from a Bayesian perspective, highlighting its adaptability to both NISQ and fault-tolerant eras. Secs. VI D, VI E, and VI F then provide examples of how QSP can be used to tackle problems in chemistry, physics, and optimization problems. We note that there are many other important application problems[116, 117, 118] [52, 115] that are not explicitly discussed in this section, but the philosophy of BE and polynomial transform should generally apply.
Real-Time Evolution
Simulating real-time dynamics governed by quantum Hamiltonians is foundational for applications using the time-dependent Schrödinger’s equation (TDSE). If the Hamiltonian is time-independent, then TDSE gives the solution: . Therefore, we want efficient representation and implementation of the unitary time evolution operator for practical large-scale computations on quantum devices. Beyond Trotter, one well-known way to do this is using linear combination of unitaries over a truncated Taylor series expansion of [119]. In addition, the original QSP algorithm$[120] can realize Hamiltonian simulation by combined with LCU due to the parity constraint on QSP polynomials. This makes the algorithm incoherent, meaning that measurement on some ancilla qubits are required to post-select the simulation results. GQSP can directly simulate the complex exponential because the parity constraint on the polynomial transform it can realize is lifted. Between these two works, there are some effort to addressed the post-selection problem by using amplitude amplification (AA) techniques on top of the LCU QSP Hamiltonian simulation. Because of the importance of AA technique, we give a brief overview of it and highlight one fully coherent Hamiltonian simulation technique$55.
By applying Euler’s theorem, we get . Both of the summands have definite parity, even and odd, respectively. By using QSP, we can find polynomial approximations to each one of them separately. Using Jacobi-Anger expansion, each summand can be expressed as an infinite sum of well-known family of polynomials such as Chebyshev polynomials and Bessel functions. We can obtain -approximations to and by truncating these infinite series at a sufficiently large index , which can be determined by a function , defined as where is the Lambert- function. Putting these all together,
degrees of polynomial are needed to simulate for time , where is a normalization factor.$29
For a fully coherent Hamiltonian simulation, if we are provided a single copy of an initial state , we must be able to prepare a time-evolved state such that with success probability of at least $1-\delta. However, for QSP-LCU, we cannot do further coherent computations, which limits our success probability. By employing conventional amplitude amplification (AA), our query complexity becomes[121]
There is another way of block-encoding that does not require AA. For this approach from Ref.$[121], we aim to approximate as a polynomial, where is the input variable and is a real parameter representing the effective time of simulation. We may design such a polynomial by estimating the even extension of the complex exponential (EECE), , which is always an even function. For , the function becomes . But this requires all the eigenvalues of to be positive. Fortunately, this can be done for arbitrary , where we can block-encode a normalized Hamiltonian with eigenvalues in the range . With our encoding of , we can use a linear pre-transformation to block-encode an operator whose spectrum is proportional to that of but shrunken to be in the range for some chosen . This leads us to block-encode the final rescaled Hamiltonian , which is fairly easy. Here, is the identity operator of size $2^n\times2^n$. Let be the block-encoding of the qubit operator and be a block encoding of . Then we can construct a block encoding of . We may easily construct with an -rotation applied to an ancilla qubit,
where is the -rotation through an angle . Equivalently, the block encoding of is . This additional x-rotation is not costly and can be cheaply prepared from QSP.
We may introduce another ancilla qubit to obtain an encoded operator $1/2(I+\beta H/\alpha)=:\widetilde{H}$, which has eigenvalues in the range . In total, with the addition of two ancilla qubits, we can block encode the rescaled Hamiltonian . If the initial Hamiltonian were encoded in the matrix element of a unitary, then the procedure encodes in the matrix element of a new unitary. This improved algorithm achieves fully coherent one-shot Hamiltonian simulation$[121] with query complexity of
GQSP also provides us with an algorithm for Hamiltonian simulation, where we can implement an -approximation of and for with a polynomial of
degree by query a block-encoding of 38.
Imaginary-Time Evolution
Imaginary time evolution (ITE) is a powerful tool for ground state finding[122] and quantum Gibbs-state preparation[123]. In the ground state finding problem, ITE can be considered as “cooling” the system down to its ground state$[124]. We consider a transformation from real time to imaginary time , called Wick rotation. Substituting into the TDSE, we obtain the ITE state , where is the eigen energy of eigen wavefunction and are the complex amplitude coefficients. For , all the terms decay exponentially, but the ground state wave function decays the most slowly because of the lowest energy in its exponential. Therefore, after evolving for a sufficiently long time , the higher energy wavefunctions get filtered out, while the ground state remains.
Another useful application is Gibbs state preparation. For a quantum system with Hamiltonian and inverse temperature , the Gibbs state has the following density matrix: , where is the Boltzmann constant. When the initial state is maximally mixed and represents the inverse temperature, then the ITE state becomes the Gibbs state. In quantum computing, Gibbs sampling acts as an efficient subroutine for quantum simulation of thermal systems[125, 126, 127, 128], quantum machine learning[129], optimization and probabilistic inference[130, 131], studying open quantum systems[132], and thermalization processes[126].
ITE requires implementing the nonunitary operator , which cannot be directly realized on quantum hardware. A general strategy is to embed this non-unitary map into a larger unitary through block encoding, then recover the desired transformation by postselection. Several modern QITE algorithms can be understood within this unified framework, including series-expansion–based block encoding, polynomial approximations, and hardware-efficient neural-network circuits.
Ref.[133] develops a fragmented master QITE algorithm that prepares the normalized state , where , and is the minimum eigenvalue of . The method relies on primitives that block-encode an -approximation of using an ancilla register and a combination of Chebyshev and Fourier expansions. In the Chebyshev-based primitive, one assumes oracle access to a block-encoding of the Hamiltonian . A truncated Chebyshev series approximates the imaginary-time propagator, requiring queries to , with classical preprocessing cost . For small , asymptotically scales as .
In contrast, the Fourier-based primitive assumes access to a unitary oracle containing the real-time evolution for a fixed time . A Fourier expansion of the propagator yields an implementation requiring queries to and and gates per query, where the gates are obtained in classical runtime , and is the gate complexity of , and . The master QITE algorithm chains these primitives so that the overall query cost is essentially the sum of the Chebyshev and Fourier contributions, achieving trace-distance error .
An alternative approach, presented in ref.[134], approximates directly using low-degree polynomials. In this formulation, represents a rescaled eigenvalue of the Hamiltonian in , so approximating reproduces the imaginary-time amplification of the low-energy eigencomponents. By selecting a stabilization shift , the algorithm maintains a constant success probability lower bound near , where is the initial ground-state overlap. Assuming is not exponentially small, the method prepares the normalized ITE state with error using controlled-Pauli queries and only one ancilla qubit.
Moving from polynomial approximations to a more hardware-oriented perspective, neural-network quantum circuits offer an alternative mechanism for implementing imaginary-time evolution. Ref.[135] shows that restricted and deep Boltzmann Machine-type circuits can exactly block-encode each Trotter step . These ansätze are closed under imaginary-time propagation and therefore yield exact thermal states (and ground states in the limit ) with analytic circuit parameters. For -local Hamiltonians, the qubit count scales linearly with system size and total imaginary time , and mid-circuit measurement allows either constant circuit width with depth or ancillas with depth .
Expectation Value and Parameter Estimation
In the context of estimating the expectation values of observables and other parameters (such as the overlap of two states), one can think of QSP polynomials as being likelihood functions that facilitate estimating the values of parameters through Bayesian inference methods. That is, consider Bayes’ rule
where and are the probabilities of observing outcomes and , respectively. reads as “the probability of observing conditioned on being observed,” and similarly for (the likelihood function). is known as the prior distribution. That is, it represents our current best guess for what the distribution of measurement outcomes is prior to performing any additional measurements. is known as the posterior distribution. That is, it represents our best post-measurement guess as to what the distribution of outcomes is, given that our measurement yielded outcome . Bayesian inference refers to an iterative process of repeated measurements, updating the prior distribution in the next iteration with the posterior distribution of the current iteration.
The versatility of QSP allows us to design likelihood functions that improve the information gain per measurement beyond what is achievable using independent measurements. Furthermore, because the QSP degree is an integer that we control, we can easily interpolate between the low information gain (shallow circuit) and optimal information gain (deep circuit) regimes. This suggests that adapting near-term algorithms that admit shallow circuits (but have suboptimal runtime scaling) to utilize QSP in some fashion will be a fruitful strategy for bridging the gap between the near-term and the fault-tolerant eras.
Let us illustrate this idea with a simple example: estimating the overlap of two states: , where each state is prepared as . The conventional method of estimating this overlap parameter is the SWAP test, which utilizes the circuit given in Figure 7.
Figure 7. The circuit used for the SWAP test.
The probability of a measurement of the ancilla qubit yielding the outcome is . Denote . Estimating the parameter to precision using a sequence of independent measurements of the ancilla will incur a runtime that scales as . We now illustrate how this can be improved to using a variation of the method outlined in the supplementary information of Ref.[136].
Suppose we could prepare a QSP polynomial that is a step function on the interval centered about some value . That is,
Sampling from a QSP circuit corresponding to this polynomial will yield a probability of measuring the ancilla to be . Thus, if we prepare this QSP circuit and the measurement outcome is , then we know that the value of must be in the range . Similarly, if the measurement outcome is we know is in the interval .
If we perform a sequence of measurements wherein we iteratively choose to subdivide the interval in which we know it must be, then we can estimate the value of to precision with measurements. In practice, we cannot prepare an exact step function. We can only prepare an approximate step function with a rising edge centered about with width using a QSP degree that scales as .[121] We need to be smaller than to some constant multiplicative factor in order for the method to achieve precision with high probability. Thus, the total runtime of this method scales as .
These concepts of using QSP polynomials and likelihood functions to speed up estimation subroutines beyond can be extended to observable expectation value estimation as well. For example, the authors of Ref.[137] showed how to estimate the expectation value of observables with scaling using either phase estimation or amplitude estimation (both of which can be formulated as QSP sequences[138] [21]) as subroutines.
The tunability of the QSP degree allows one to use QSP techniques to accelerate estimation subroutines beyond within a given circuit depth budget. This is highly desirable in contexts such as quantum chemistry, where the scaling is known to lead to prohibitively long runtimes[139]. For example, Ref.[140] developed a method called -VQE, which incorporates quantum phase estimation as a subroutine of the variational quantum eigensolver (VQE)[141] in such a way that the number of samples scales as . Here, is a user-tunable parameter that controls whether the algorithm is more “QPE-like” or “VQE-like.” When , one retains the shallow circuit depth and measurement counts of VQE. Similarly, when , one obtains the deep circuit depths and measurement counts of QPE. Similarly, Ref.[142] showed how one could design likelihood functions that increase the information gain per measurement for the purpose of reducing the number of measurements needed for VQE. The circuits used in this work bear a strong resemblance to QSP sequences, suggesting it is likely that this method could be formulated in terms of QSP. Furthermore, other classes of likelihood functions could be designed using QSP as a framework.
For example, the use of QSP to accelerate the SWAP test can be easily extended to accelerate the estimation of Pauli string expectation values in VQE by replacing the SWAP test circuit with a Hadamard test circuit. Additionally, one could consider using polynomials that approximate smoother functions such as Gaussian curves. In this modified scheme, one would use Bayesian inference where the likelihood functions and prior distributions are both Gaussian functions. This is similar to how Bayesian inference has been incorporated into quantum phase estimation to improve its noise robustness.[143, 144]
Chemistry
Chemistry problems of interest can be broadly divided into two categories: static (e.g., electronic ground-state energy estimation, finite-temperature state preparation) and dynamic (e.g., electron dynamics, reaction dynamics). In sharp contrast to doing quantum chemistry on classical computers, where methods for treating state preparation and dynamics are entirely different, QSP algorithms allow treating both static and dynamic problems on equal footing with minimal methodology change.
In one of such useful algorithms for electron dynamics, an -orbital free-fermionic Hamiltonian with sparse one-electron integrals can be block-encoded (combined with QSP) with a circuit depth of [145]. For interacting fermions, multiple techniques are connected together to achieve the desired result. One such technique involves transforming the Hamiltonian into the interaction picture and then block-encoding the Hamiltonians[146].
It is also possible to develop similar techniques in the second quantization framework. A low-rank recursive block-encoding strategy can be used to implement a single Trotter step via qubitization and then extended to multiple steps[147]. The target unitary evolution is obtained only with finite success probability due to ancillary qubits used in block encoding, which can be improved by means of amplitude amplification (AA) referred to in § 2.3 A. Similar to Trotter methods, randomized QSP-based algorithms have also been developed that mix different polynomials, effectively halving the overall cost of Hamiltonian simulation87.
Since finite-temperature quantum chemistry problems are inherently non-unitary, block-encoding reduces the challenge of operating them on quantum computers. For static problems, a resource-efficient approach uses just one ancillary qubit to block-encode the system Hamiltonian within a unitary operator. This enables a polynomial approximation to the partition function, and for Gibbs state preparation in the canonical ensemble, a polynomial approximation to (see § 2.3 B) is applied[148]. For a recent review on quantum computing for chemistry beyond the ground state, see Ref.[149].
Simulating chemical reaction dynamics. A well-followed approach to solve chemistry problems is to adopt the Born-Oppenheimer (BO) approximation, where the electrons are treated quantum mechanically but the nuclei classically. While this is useful for many applications and can be solved on classical computers approximately, the BO approximation breaks down in important problems involving highly coupled nuclei-electron dynamics, including but not limited to photo-induced vision processes[150], photovoltaic energy conversion[151], and proton-coupled electron transfer (PCET)[152, 153, 154]. These are challenging to solve on classical computers accurately, as they involve dealing with an added exponential scaling of nuclear quantum degrees of freedom that couples to the electrons.
On quantum computers, simulating the full electron-nuclei dynamics is polynomial scaling as shown in Ref. 155 for Trotter algorithms. Just as for spin systems that product formulas and QSP can have different performance in various parameter regimes[156], QSP algorithms may provide advantage over Trotter algorithms for chemical reactions in some regime. Here, we outline a QSP-based quantum computational framework for molecular reaction dynamics. While not all initial quantum states can be prepared efficiently, physically motivated states such as molecular ground states can often be created and used as inputs for subsequent dynamical simulation.
We begin by constructing a block-encoding of all total Hamiltonian of the entire reactant system in second- or first-quantization. For first-quantized simulations, wavelet bases are an attractive option because they offer orthogonality, tunable locality, and structured sparsity, which help reduce the cost of block-encoding[157, 158]. After encoding the Hamiltonian, an initial state needs to be prepared using QSP or other algorithms. Note that this initial state does not have to be ground state as chemical reactions may often happen from excited or a finite-temperature state. Locality in the initial reactant state can be exploited to improve the efficiency of this state preparation as the molecules may actually be far apart thus not interacting that much.
For non–Born–Oppenheimer (non-BO) simulations, we encode the full system Hamiltonian , where are the electronic kinetic energy, nuclear kinetic energy, electron-nuclear interaction, electron-electron interaction, and nuclear-nuclear interaction, respectively. This contrasts with the Born–Oppenheimer Hamiltonian where nuclear motion is treated parametrically. Since the kinetic and Coulomb operators possess distinct algebraic structure and sparsity, this should be leveraged to improve the efficiency of the block-encoding circuit.
Following the state preparation, we can then evolve the molecular system under the total Hamiltonian using QSP algorithms. Note that in realistic chemical reactions, there will be energy dissipation from the system to solvent or environment, which may need additional dissipative algorithms to be used to capture that[159]. After evolving the molecular system, relevant observables (dipole moment, bond order, and population on products) can be extracted. One way to measure an observable is to find the Pauli representation of and measure each Pauli strings. Another less obvious way is to first construct a block-encoding of and then using variants of the Hadamard test on the block-encoding to obtain the expectation value by measure the single ancilla qubit. The adaptive measurement scheme in Sec. VIC can be naturally incorporated.
If we select observables that distinguish reactants from products (e.g., spatial distributions, occupation numbers, vibrational signatures). One example is that for population transfer to products, we measure the projector onto the product subspace.
A minimal example. In order to illustrate the convergence between the exact evolution and QSP-simulated energies for different polynomial orders, we compared QSP-based simulations with the exact time evolution of the H molecular Hamiltonian (Jordan–Wigner mapping) for the initial state which corresponds to the computational basis state (Figure 8a). Additionally, we calculate the occupation number for the same system and compare for different polynomial degrees in Figure 8b.
Figure 8. a) Comparison between the exact and QSP-simulated time evolution of the H molecular Hamiltonian (Jordan–Wigner mapping of molecular orbitals) using the STO-3G basis. The initial state corresponds to the computational basis state . Increasing the polynomial order improves the agreement between the QSP-based simulation and the exact energy evolution. The system is in excited state with an energy of roughly -0.3 Ha. b) Occupation number on qubit 3 (spin-up of the molecular orbital) as a function of time for the same initial state. The time evolution is in atomic units (a.u.) equal to , for the Hartree energy unit.
Physics
While the line between what problems fall under “chemistry” and “physics” is blurred, one can think of the dividing line as follows. In ab initio chemistry, one is (in general) attempting to find properties of molecules modeled by lattices with arbitrary all-to-all connectivity (i.e. long-range interactions) for the purposes of studying chemical reaction mechanisms. In physics, it is often the case that one is often interested in studying condensed matter systems, which can be modeled by lattice model Hamiltonians containing nearest-neighbor interaction terms for purposes such as studying phase transitions, magnetic properties, and superconductivity. For example, the transverse Ising model
describes a lattice of spin- particles with nearest-neighbor coupling strength subject to a magnetic field with strength . The particles only interact with each other in the -direction. The direction of the magnetic field runs perpendicular to this interaction in the -direction. One can also consider the Heisenberg model Hamiltonian,
which models a lattice of spin- systems that can interact in all directions and are subject to an external -direction magnetic field. In order to illustrate this we consider a 3-spin system from Eq. (55) to simulate the magnetization.
For this system we will consider and , but the circuit structure does not depend on these values. Based on the structure of the LCU given in Figure 3, a concrete realization of block-encoding for this system is given by Figure 9a, where the prepare operation based on Figure 4 is given in Figure 9b. The angles that represent the state preparation are . The values that are 0.0 do not represent any quantum gate. While narrow, as the number of spin systems increases, the number of required qubits also grows as , where is the number of spins considered.
Figure 9. a) Complete circuit for block-encoding the Ising system with using the LCU method. The Hamiltonian consists of five distinct terms, requiring ancilla qubits for the encoding. The multi-controlled fanout gates (shaded) need to be compiled to available gate sets on given hardware. b) State preparation circuit. Some quantum gates do not appear in the circuit because their corresponding rotation angles are equal to zero.
Once Eq. (57) is block-encoded, we can implement time-evolution of the Hamiltonian . This block-encoding can also be implemented with previous methods discussed in this work in § 2 C. The circuit implementation is shown in Figure 10 using the GQSP from Sec. IV A. The set of angles can be found using different frameworks for polynomial transformation explained in Sec. IV F.
Figure 10. Circuit representation of time evolution simulation of the Ising model for , using Generalized Quantum Signal Processing. The post-measurement will apply the polynomial transformation of the quantum state .
Figure 11 shows the simulation results for the magnetization, for an initial state , obtained using GQSP for different orders of magnitude. Higher degrees allow for more accurate simulations at later times.
Figure 11. Magnetization for an Ising model of 3-spins in Eq. (57) for different GQSP degrees (circle) as compared with the exact result (solid).
Platforms such as transmon qubits are themselves lattices of two-level systems with nearest-neighbor connectivity; therefore, it should not be surprising that problems involving such lattice Hamiltonians are key targets for achieving early quantum advantage60 as the qubit connectivity of the machine closely matches that of the interactions in these Hamiltonians. Quantum signal processing can be readily applied to both static and dynamic problems for such lattice Hamiltonians in much the same way as for chemistry problems. Quantum Phase Estimation, for example, is known to be a particular case of a QSP polynomial61 and is used for solving for the
ground state energy of such Hamiltonians at zero temperature. Similarly, eigenstate filtering can be used as a preparation method for the ground state. Block-encoding and QSP can be readily used to perform real-time evolution of the Hamiltonian with respect to some initial state, followed by the estimation of an observable such as the magnetization or spin correlation functions using one of the methods described in § 2.3 C. Real-time evolution of a Hamiltonian is also an important primitive in some algorithms designed to solve for static properties in methods such as Krylov subspace diagonalization.[162, 163] For finite temperature state preparation, one can use QSP to prepare Gibbs distribution states by preparing polynomials that are exponentials of the inverse temperature [161].
Optimization
While one can observe that estimating the ground state of a Hamiltonian drives many applications in chemistry and physics (§ 2.3 D–VI E), it also extends to optimization problems. Quantum computers are promising platforms for solving discrete optimization problems, such as MaxCut, minimum vertex cover, and graph coloring, which can all be formulated by quadratic unconstrained binary optimization (QUBO) problems[164]. These problems share a common structure: minimizing a polynomial function of binary variables. The cost function can be mapped to a Hamiltonian whose ground state encodes the optimal solution. However, finding the exact ground state of such Hamiltonians is generally NP-hard, and classical approaches become computationally infeasible for large system sizes due to the exponential scaling of the Hilbert space. Consequently, classical algorithms rely on heuristic or probabilistic methods that yield only approximate solutions.
In the NISQ era, several non-QSP quantum algorithms have been proposed to approximate ground states of optimization Hamiltonians. Examples include the quantum approximate optimization algorithm (QAOA)[165], ITE (§ 2.3 B), and adiabatic quantum evolution[166]. Each method faces specific limitations: QAOA often suffers from barren plateaus that impede gradient-based optimization[167]; adiabatic evolution typically requires deep circuits and long coherence times; and ITE block-encoding (ITE-BE) schemes demand a large number of shots to achieve reliable post-selection (§ 2.3 B). Nonetheless, the ITE-BE method demonstrates competitive performance for problems such as MaxCut, requiring only qubits and circuit depth, where and denote the number of edges and vertices in the graph, respectively[168]. The algorithm converges to the ground state when the imaginary time is sufficiently large as compared to the inverse gap of the Hamiltonian. This algorithm can also be hybridized with QAOA, yielding a tradeoff between the QAOA circuit depth and the imaginary time : a longer allows convergence with a shallow circuit, while a higher yields faster convergence with increased post-selection probability.
Beyond these non-QSP ground-state-finding strategies, QSP provides a polynomial-transformation–based approach to ground-state preparation. When an initial state with a sufficient overlap with the ground state can be efficiently prepared, and the spectral gap is bounded from below, QSP-based ground state filtering algorithms[169] achieve near-optimal query complexity for ground state preparation. Even when the spectral gap is unknown, such algorithms can still prepare the ground state with finite success probability. Conceptually, ITE-BE and QSP-based filtering can both be viewed as ground-state-finding frameworks: the former suppresses excited-state amplitudes through imaginary-time dynamics, while the latter constructs a spectral filter polynomial that amplifies the ground-state component directly within the QSP formalism.
Conclusion
We present a forward-looking Perspective on scalable quantum computational science. Several properties that a quantum computational science method should possess is defined. We highlight the role of block-encoding and polynomial transforms as potential candidates for developing a unified framework for computational science problems. In addition to explain the theory and methods, we also survey current software tools available, and provide illustrative example applications in chemistry and physics, as well as the connection to optimization. Given the rapid development on quantum error correction and hardware, our Perspective provides a timely contribution that helps to bridge the gap between theoretical quantum algorithm community and practical computational scientists.
Many open challenges remain in order to fully unleash the power of quantum computers for computational science problems. For one, as the most important building block, optimal explicit circuit constructions of exact and approximate block-encodings for practical applications are far from established. We think there are ample rooms for constructing approximate block-encodings without violating the design principles outlined. Moreover, the utility of -QSP and M-QSP are much less explored. Discover new applications that can fully leverage these advanced algorithmic structures will be significant for the community. In addition, understanding the performance of QSP algorithms on practical early fault-tolerant serial and distributed quantum computers will be important to unveil a new era of quantum computing method development as quantum machines evolve and mature.
On the software side, results on QSP are mostly scattered. An open-source quantum computing software platform dedicated to QSP method development that has convenient interface with domain application software packages should be established. Phase-angle finding algorithm and automatic block-encoding compilation and circuit construction should be integrated. To enable QSP algorithms executed on near-term and early fault-tolerant hardware, abstractions of multiqubit gate should be broken and hardware-level details such as pulse-engineering and quantum control techniques should be integrated together with QSP algorithm. This co-design perspective help to minimize the overall resource cost and bring quantum advantage closer. We look forward to engage domain computational scientists with expertise on practical applications to develop QSP algorithms, and broadly, to embrace scalable quantum computational science.
Acknowledgments
This work is supported by the U.S. Department of Energy, Office of Science, Advanced Scientific Computing Research, under contract number DE-SC0025384. This work is also supported in part by NSF OSI and MPS division under award number 2531350 via a subcontract from Duke University.
References
- [91]Berry, D. W., Motlagh, D., Pantaleoni, G., & Wiebe, N. (2024). Doubling the efficiency of hamiltonian simulation via generalized quantum signal processing. Phys. Rev. A, 110, 012612.
- [92]Rossi, Z. M., & Chuang, I. L. (2022). Multivariable quantum signal processing (M-QSP): prophecies of the two-headed oracle. Quantum, 6, 811.
- [93]Liu, Y., Martyn, J. M., Sinanan-Singh, J., Smith, K. C., Girvin, S. M., & Chuang, I. L. (2025). Toward mixed analog-digital quantum signal processing: Quantum ad/da conversion and the fourier transform. IEEE Transactions on Signal Processing, 73, 3641–3655.
- [94]Zane M Rossi, Jack L Ceroni, and Isaac L Chuang. Modular quantum signal processing in many variables. arXiv preprint arXiv:2309.16665, 2023.DOI
- [95]Andrew K. Tan, Yuan Liu, Minh C. Tran, and Isaac L. Chuang. Error correction of quantum algorithms: Arbitrarily accurate recovery of noisy quantum signal processing. arXiv:2301.08542, 2023.arxiv.org/abs/2301.08542
- [96]Pachón, R., & Trefethen, L. N. (2009). Barycentric-remez algorithms for best polynomial approximation in the chebfun system. BIT Numerical Mathematics, 49(4), 721–741.
- [97]Dong, Y., Meng, X., Whaley, K. B., & Lin, L. (2021). Efficient phase-factor evaluation in quantum signal processing. Phys. Rev. A, 103, 042419.
- [98]Dong, Y., Meng, X., Whaley, K. B., & Lin, L. (2021). Qsppack. https://github.com/qsppack/QSPPACKgithub.com/qsppack/QSPPACK
- [99]Chuang, I., Tan, A., & Martyn, J. M. (2020). PyQSP: Python Quantum Signal Processing. https://github.com/ichuang/pyqspgithub.com/ichuang/pyqsp
- [100]Dong, Y., Lin, L., Ni, H., & Wang, J. (2024). Infinite quantum signal processing. Quantum, 8, 1558.
- [101]Ni, H., & Ying, L. (2024). Fast phase factor finding for quantum signal processing.
- [102]Alexis, M., Mnatsakanyan, G., & Thiele, C. (2024). Quantum signal processing and nonlinear fourier analysis. Revista Matemática Complutense, 37, 655–694.
- [103]Alexis, M., Lin, L., Mnatsakanyan, G., Thiele, C., & Wang, J. (2026). Infinite quantum signal processing for arbitrary szegő functions. Communications on Pure and Applied Mathematics, 79(1), 123–174.
- [104]Haah, J. (2019). Product Decomposition of Periodic Functions in Quantum Signal Processing. Quantum, 3, 190.
- [105]Chao, R., Ding, D., Gilyen, A., Huang, C., & Szegedy, M. (2020). Finding angles for quantum signal processing with machine precision.
- [106]Ying, L., Yamamoto, S., & Yoshikawa, N. (2022). Stable factorization for phase factors of quantum signal processing Robust angle finding for generalized quantum signal processing. Quantum, 6, 842.
- [108]Lane, P., Ang, J., Carini, G., Chen, Y., Chuang, I., DeMarco, M., Econoмou, S., Eickbusch, A., Faraon, A., & Kai-Mei Fu, S. G. et . al . (2024). PennyLane qsp phase angle Arquinc: architectures for multimode superconducting quantum computers. In ACM Transactions on Quantum Computing (Vol. 5, Number 3, pp. 1–59).
- [110]Li, L., De Santis, L., Harris, I. B., Chen, K. C., Gao, Y., Christen, I., Choi, H., Trusheim, M., Song, Y., Errando-Herranz, C., al., . et ., Main, D., Drmota, D. P., Nadlinger, E. M., Aingley, A., Agrawal, B. C., Nichol, R., Srinivas, G., Araneda, D. M., & Lucas, D. (2024). Heterogeneous integration of spin-photon interfaces with a cmos platform Distributed quantum computing across an optical network link. Nature Nature, 630(8015), 70–76.
- [112]Beals, R., Brierley, S., Gray, O., Harrow, A. W., Kutin, S., Linden, N., Shepherd, D., Slater, M., Zhang, Z., Wang, Q., & Ying, M. (2013). Efficient distributed quantum computing Parallel Quantum Algorithm for Hamiltonian Simulation. Proceedings of the Royal Society A: Mathematical, Physical and Engineering Sciences Quantum, 469(2153), 20120686.
- [114]Goldstein-Gelb, B., Liu, K., Martyn, J. M., Zhou, H. (Harry) ., Ding, Y., Liu, Y., Guseynov, N., Huang, X., & Liu, N. (2025). Compass: A distributed multi-party swap test for parallel quantum algorithms Gate construction of block-encoding for hamiltonians needed for simulating partial differential equations. In Under review.
- [116]Chen, Y.-H., Kalev, A., & Hen, I. (2021). Quantum algorithm for time-dependent hamiltonian simulation by permutation expansion. PRX Quantum, 2, 023034.
- [117]Kane, C. F., Hariprakash, S., Modi, N. S., Kreshchuk, A., & Bauer, C. W. (2025). Block encoding bosons by signal processing. Quantum, 9, 1747.
- [118]Ding, Z., Li, X., & Lin, L. (2024). Simulating open quantum systems using hamiltonian simulations. PRX Quantum, 5, 020332.
- [119]Berry, D. W., Childs, A. M., Cleve, R., Kothari, R., & Somma, R. D. (2015). Simulating hamiltonian dynamics with a truncated taylor series. Physical Review Letters, 114(9), 090502.
- [120]Low, G. H., & Chuang, I. L. (2017). Optimal hamiltonian simulation by quantum signal processing. Physical Review Letters, 118(1), 010501.
- [121]Martyn, J. M., Liu, Y., Chin, Z. E., & Chuang, I. L. (2023). Efficient fully-coherent quantum signal processing algorithms for real-time dynamics simulation. The Journal of Chemical Physics, 158(2), 024106.
- [122]McArdle, S., Jones, T., Endo, S., Li, Y., Benjamin, S. C., & Yamazaki, W. (2019). Variational ansatz-based quantum simulation of imaginary time evolution. Npj Quantum Information, 5(1).
- [123]Kosugi, T., Nishiya, Y., Nishi, H., & Matsushita, Y. I. (2022). Probabilistic imaginary-time evolution by using forward and backward real-time evolution with a single ancilla: first-quantized eigensolver of quantum chemistry for ground states. Physical Review A, 105(2), 022426.
- [124]Motlagh, D., Shokrian Zini, M., Arrazola, J. M., & Wiebe, N. (2024). Ground state preparation via dynamical cooling.
- [125]Poulin, D., & Wocjan, P. (2009). Sampling from the thermal quantum gibbs state and evaluating partition functions with a quantum computer. Physical Review Letters, 103(2), 022302.
- [126]Rouzé, C., Sticlк, D., & Alhambra, Á. M. (2024). Efficient thermalization and universal quantum computing with quantum gibbs samplers.
- [127]Rajakumar, J., & Watson, J. D. (2024). Gibbs sampling gives quantum advantage at constant temperatures with o(1)-local hamiltonians.
- [128]Bergamaschi, T., Chen, C.-F., & Liu, Y. (2024). Quantum computational advantage with constant-temperature gibbs sampling. In IEEE 65th Annual Symposium on Foundations of Computer Science (FOCS), page 1063–1085.
- [129]Koopmans, L., & Benedetti, M. (2024). On the sample complexity of quantum boltzmann machine learning. Communications Physics, 7(1).
- [130]Low, G. H., Yoder, T. J., & Chuang, I. L. (2014). Quantum inference on bayesian networks. Physical Review A, 89(6), 062314.
- [131]Fathallah, W., Amor, N. B., & Leray, P. (2024). Approximate inference on optimized quantum bayesian networks. International Journal of Approximate Reasoning, 175, 109307.
- [132]Cohn, F., Yang, K., Najafi, B., Jones, B., & Freericks, J. K. (2020). Minimal effective gibbs ansatz: A simple protocol for extracting an accurate thermal representation for quantum simulation. Physical Review A, 102(2).
- [133]Silva, T. L., Taddei, M. M., Carrazza, S., & Aolita, L. (2023). Fragmented imaginary-time evolution for early-stage quantum signal processors. Scientific Reports, 13(1), 18258.
- [134]Zhang, L., Lai, J., Wu, X., & Wang, X. (2025). Quantum imaginary-time evolution with polynomial resources in time.
- [135]Rajap, E., & Rule, E. (2025). Exact block encoding of imaginary time evolution with universal quantum neural networks. Phys. Rev. Res., 7, 013306.
- [136]Liu, Y., Meitei, O. R., Chin, Z. E., Dutt, A., Tao, M., Chuang, I. L., & Voorhis, T. V. (2023). Bootstrap embedding on a quantum computer. J. Chem. Theory Comput., 19(8), 2230–2247.
- [137]Knill, E., Ortiz, G., & Somma, R. D. (2023). Optimal quantum measurements of expectation values of observables. Phys. Rev. A, 75(1), 012328.
- [138]Rall, P., & Fuller, B. (2023). Amplitude estimation from quantum signal processing. Quantum, 7, 937.
- [139]Gonthier, J. F., Radin, M. D., Buda, C., Duskocil, E. J., Abuan, C. M., & Romero, J. (2022). Measurements as a roadblock to near-term practical quantum advantage in chemistry: Resource analysis. In Phys. Rev. Res. (Vol. 4, Number 3, p. 033154).
- [140]Wang, D., Higgott, O., & Brierley, S. (2019). Accelerated variational quantum eigensolver. Phys. Rev. Lett., 122(14), 140504.
- [141]Peruzzo, A., McClean, J., Shadbolt, P., Yung, M.-H., Zhou, X.-Q., Love, P. J., Aspuru-Guzik, A., & O’Brien, J. L. (2014). A variational eigenvalue solver on a photonic quantum processor. Nat Commun, 5(1), 4213.
- [142]Wang, G., Koh, D. E., Johnson, P. D., & Cao, Y. (2021). Minimizing estimation runtime on noisy quantum computers. PRX Quantum, 2(1), 010346.
- [143]Wiebe, N., & Granade, C. (2016). Efficient bayesian phase estimation. Phys. Rev. Lett., 117, 010503.
- [144]Paesani, S., Gentile, A. A., Santagati, R., Wang, J., Wiebe, N., Tew, D. P., O’Brien, J. L., & Thompson, M. G. (2017). Experimental bayesian quantum phase estimation on a silicon photonic chip. Phys. Rev. Lett., 118, 100503.
- [145]Maarten Stroeks, Daan Lenterman, Barbara Terhal, and Yaroslav Herasymenko. Solving free fermion problems on a quantum computer. arXiv preprint arXiv:2409.04550, 2024.arXiv
- [146]Babbush, R., Berry, D. W., McClean, J. R., & Neven, H. (2019). Quantum simulation of chemistry with sublinear scaling in basis size. Npj Quantum Information, 5(1).
- [147]Low, G. H., Su, Y., Tong, Y., & Tran, M. C. (2023). Complexity of implementing trotter steps. PRX Quantum, 4(2).
- [148]Powers, C., Bassman Oftelie, L., Camps, D., & de Jong, W. A. (2022). Exploring finite temperature properties of materials with quantum computers.
- [149]Bidart, A., Vaish, P., Kabengele, T., Pang, Y., Liu, Y., & Rubenstein, B. M. (2025). Quantum computing beyond ground state electronic structure: A review of progress toward quantum chemistry out of the ground state.
- [150]Ruckenbauer, M., Barbatti, M., Müller, T., & Lischka, H. (2013). Nonadiabatic photodynamics of a retinal model in polar and nonpolar environment. The Journal of Physical Chemistry A, 117(13), 2790–2799.
- [151]Stier, W., & Prezhdo, O. V. (2003). Non-adiabatic molecular dynamics simulation of ultrafast solar cell electron transfer. Journal of Molecular Structure: THEOCHEM, 630(1), 33–43.
- [152]Hammes-Schiffer, S., & Soudackov, A. V. (2008). Proton-coupled electron transfer in solution, proteins, and electrochemistry. The Journal of Physical Chemistry B, 112(45), 14108–14123.
- [153]Soudackov, A., & Hammes-Schiffer, S. (2000). Derivation of rate expressions for nonadiabatic proton-coupled electron transfer reactions in solution. The Journal of Chemical Physics, 113(6), 2385–2396.
- [154]Soudackov, A., Hatcher, E., & Hammes-Schiffer, S. (2004). Quantum and dynamical effects of proton donor-acceptor vibrational motion in nonadiabatic proton-coupled electron transfer reactions. The Journal of Chemical Physics, 122(1), 014505.
- [156]Childs, A. M., Maslov, D., Nam, Y., Ross, N. J., & Su, Y. (2018). Toward the first quantum simulation with quantum speedup. Proceedings of the National Academy of Sciences, 115(38), 9456–9461.
- [157]Georges, T. N., Berntson, B. K., Izsák, R., & Ivanov, A. V. (2025). Quantum simulations of chemistry in first quantization and by abasis set. Npj Quantum Information, 11(1).
- [158]White, S. R., & Lindsey, M. J. (2023). Nested gaussian basis sets.
- [159]Lin, L. (2025). Dissipative preparation of many-body quantum states: Toward practical quantum advantage. APL Computational Physics, 1(1).
- [161]Martyn, J. H., Rossi, Z. M., Andrecka, A. K., & Chuang, I. L. (2021). Grand unification of quantum algorithms. PRX Quantum, 2, 040203.
- [162]Cortes, C. L., & Gray, S. K. (2022). Quantum Krylov subspace algorithms for ground- and excited-state energy estimation. Physical Review A, 105(2), 022417.
- [163]Yoshioka, N., Amico, M., Kirby, W., Jurcevic, P., Dutt, A., Fuller, B., Garion, S., Haas, H., Hamamura, I., Alexander, I., Rajati, M., Minervini, Z., Motta, M., Pokharel, B., Rivero, P., Sharma, K., Wood, C. J., Javadi-Abhari, A., & Mezzacapo, A. (2025). Krylov diagonalization of large many-body Hamiltonians on a quantum processor. Nature Communications, 16(1), 5014.
- [164]Muzander, Y., & Tayur, S. (2025). Five starter problems: Solving quadratic unconstrained binary optimization models on quantum computers.
- [165]Farhi, E., Goldstone, J., & Gutmann, S. (2014). A quantum approximate optimization algorithm.
- [166]Born, M., & Fock, V. (1928). Beweis des Adiab atensatzes. Zeitschrift für Physik, 51(3), 165–180.
- [167]McLean, J. R., Boixo, S., Smelyanskiy, V. N., Babbush, R., & Neven, H. (2018). Barren plateaus in quantum neural network training landscapes. Nature Communications, 9(1), 4812.
- [168]Zhong, D., Francis, A., & Ermal, R. (2025). Classical optimization with imaginary-time block encoding on quantum computers: The maxcut problem. Phys. Rev. A, 112, 042420.
- [169]Lin, L., & Tong, Y. (2020). Near-optimal ground state preparation. Quantum, 4, 372.










