svPITE: A Python package for the state-vector-based probabilistic imaginary-time evolution algorithm
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.
Kai: I'm Kai.
Mira: And I'm Mira, here with Lev.
Kai: We're looking at the paper: "svPITE: A Python package for the state-vector-based probabilistic imaginary-time evolution algorithm".
Mira: Here's the gist of the paper. We present a Python package for ground-state preparation based on the probabilistic imaginary-time evolution algorithm, with particular focus on its state-vector-based implementation.
Kai: This work enables efficient tuning of initial parameters, facilitating systematic exploration and optimisation of the method’s performance.
Mira: Probabilistic ITE provides one such framework, in which non-unitary evolution e-Hˆ∆τ is realized via stochastic application of unitary operations combined with measurement and post-selection.
Kai: This approach enables the emulation of imaginary-time dynamics while remaining compatible with the constraints of quantum circuits.
Title and authors: Kai: So we're looking at this paper called "svPITE: A Python package for the state-vector-based probabilistic imaginary-time evolution algorithm". It seems they've put together a Python package that focuses specifically on the state-vector version of this probabilistic imaginary-time evolution method.
Mira: Yeah, it’s about ground state preparation using this ITE technique, which is often used for thermal simulations or finding the lowest energy states. The big focus here is on making it state-vector based so they can look closely at the algorithm itself without getting bogged down in all the statistical noise.
Lev: From an engineering side, that means they're isolating how fast it converges and how accurate their approximations are, separate from the randomness you get when you run a shot-based simulation. That’s important for figuring out if this method is actually reliable for real hardware.
Kai: Right, so they aren't just throwing up a simulation; they're building a tool to tune the initial parameters of the ITE algorithm systematically, which should help people explore how well it works across different setups.
Mira: Exactly. The paper points out that this state-vector approach corresponds to what you call the infinite-shot limit of the shot-based simulation, which means it’s super clean for methodological development. It lets them study intrinsic properties like convergence behavior and approximation accuracy independently of statistical fluctuations.
Lev: That cleanliness is what makes it useful for benchmarking, but I'm always thinking about how much overhead that state-vector representation adds when you try to run this on actual hardware with limited resources.
Kai: Well, the package structure itself is pretty well organized; they have four main blocks: Hamiltonian and operator representations, configuration objects, the algorithm classes themselves, and result objects. They represent all quantum operators as weighted sums of Pauli strings internally.
Mira: And when you look at the Hamiltonian class part, it enforces Hermiticity and provides specific methods tailored to that specific Hamiltonian structure. This shows they've thought about how to handle different types of physical systems correctly within the framework.
Lev: I wonder if that internal representation as Pauli strings is efficient enough for large systems, because translating those into actual gates on a quantum computer can be a real bottleneck when you scale up the size of the lattice.
Title and authors: Kai: The simulation workflow they describe is pretty standard: define your Hamiltonian, set your algorithm parameters, run the simulation to get results, and then compare those results against exact diagonalization calculations. This comparison against exact diagonalization is where they show good agreement between the state-vector PITE and shot-based PITE approaches.
Mira: And that comparison itself is interesting because it validates the state-vector method as a reliable reference point for what a full simulation should look like, even if it’s not the noisy shot-based result. They also mention that these resulting states can be used for further studies, like looking at real-time dynamics and spectral functions.
Lev: Spectral functions sound promising because if you can get those, you can probe how the system moves over time after being prepared in a specific state. How they get that dynamic structure factor involves taking a space-time Fourier transform of the time-dependent correlation function.
Kai: Speaking of results, the paper suggests some real improvements for this package. First, they say using this state-vector implementation as a starting point is really good for doing things like "quenches, real-time expectation values, or correlation functions" by combining it with other tools like Qiskit to evolve the prepared state under a Hamiltonian.
Mira: That makes sense because you start with a clean prepared ground state and then use that to probe dynamics, which is a natural next step in the research pipeline. It connects this preparation tool directly into time evolution studies.
Lev: I see that connection, but from my side, I'm thinking about how they can make the simulation faster on larger systems; they suggest combining parallel simulation of the real-time evolution and its Hermitian adjoint to get a speedup for systems with twenty-two sites or more <ref:2605.07559#pg2>. That sounds like some serious optimization work.
Kai: That parallelization idea is key if you want to run this efficiently on bigger systems where the state space gets really big. It’s about leveraging the structure of the evolution itself rather than just running everything sequentially.
Mira: And they also touch on how users can define their Hamiltonians flexibly, either by giving them a terms dictionary or by using a method called add uniform terms to inject translationally invariant fields. This supports a very wide class of generic quantum spin systems, which is what we need for broad applicability.
Title and authors: Lev: Flexibility is good, but when you start adding more complex interaction structures—more terms in that dictionary—the complexity of the operators can explode very quickly, and that's where the computational cost really starts to climb significantly.
Kai: They also mention predefined initial states, like singlet or neel states, which lets users systematically explore different ground-state preparation methods right from the start. This is helpful for benchmarking different initial guesses.
Mira: I agree. It gives experimentalists and theorists a structured way to test how robust these preparation methods are before they dive into optimizing the algorithm parameters themselves.
Lev: So, while having those pre-set states is useful for testing, what about running the simulation on hardware that has noise? The state-vector method avoids statistical uncertainty because it’s in the infinite-shot limit, but that doesn't help when you have actual measurement errors at every step.
Kai: That’s a fair point. But the paper emphasizes that this state-vector formulation is indispensable for parameter exploration because it bypasses those statistical uncertainties entirely, which is what makes it so useful right now for tuning.
Mira: So, to wrap up on the improvements, they are really emphasizing how to build upon this package. They show how you can use the prepared state to do real-time evolution and compute spectral functions, and they point toward optimizing the simulation using parallel methods for larger systems.
Lev: And for me, the most practical thing is that they’ve provided a clear path for comparison against exact diagonalization using a dedicated wrapper, which means I can actually test if this method gives me results that are close to what I would get from a full exact solver on real hardware.
Kai: It sounds like this paper, "svPITE: A Python package for the state-vector-based probabilistic imaginary-time evolution algorithm", really gives us a solid, noise-free tool to systematically explore ground state preparation methods and then feed those states into time evolution studies.
Mira: Exactly. It’s about moving from just running a simulation to building a proper framework where you can test the underlying physics of the method itself.
Lev: For now, I'm looking at how they handle scaling up the computation for larger lattices and how their parallelization strategy actually translates into meaningful speedups when we move toward physical systems.
Kai: Well, that’s it for this look at svPITE. We’ll see what these new tools can do next in our work on quantum dynamics.
The paper's summary: Kai: So we're looking at this paper called "svPITE: A Python package for the state-vector-based probabilistic imaginary-time evolution algorithm". They’ve built a Python package focusing on the state-vector version of this method.
Mira: It’s about ground state preparation using this imaginary time evolution technique, but they make it state vector based so they can study how the algorithm actually works without all that statistical noise.
Lev: That means they're isolating how fast it converges and how accurate their approximations are, separate from the randomness you get when you run a simulation.
Kai: Right, so they aren't just throwing up a simulation; they're building a tool to tune the initial parameters of the imaginary time evolution algorithm systematically.
Mira: The paper points out that this state vector approach corresponds to what we call the infinite-shot limit of the shot based simulation, which means it’s super clean for studying how the method itself behaves.
Lev: That cleanliness is what makes it useful for benchmarking, but I'm always thinking about how much overhead that state vector representation adds when you try to run this on actual hardware with limited resources.
Kai: The package structure itself is pretty organized; they have four main blocks: Hamiltonian and operator representations, configuration objects, the algorithm classes themselves, and result objects.
Mira: And when you look at the Hamiltonian class part, it enforces Hermiticity and provides specific methods tailored to that specific Hamiltonian structure. It shows they've thought about how to handle different types of physical systems correctly within the framework.
Lev: I wonder if that internal representation as Pauli strings is efficient enough for large systems, because translating those into actual gates on a quantum computer can be a real bottleneck when you scale up the size of the lattice.
Kai: The simulation workflow they describe is pretty standard: define your Hamiltonian, set your algorithm parameters, run the simulation to get results, and then compare those results against exact diagonalization calculations.
Mira: And that comparison itself is interesting because it validates the state vector method as a reliable reference point for what a full simulation should look like, even if it’s not the noisy shot based result. They also mention that these resulting states can be used for further studies, like looking at real time dynamics and spectral functions.
The paper's summary: Lev: Spectral functions sound promising because if you can get those, you can probe how the system moves over time after being prepared in a specific state. How they get that dynamic structure factor involves taking a space time Fourier transform of the time dependent correlation function.
Kai: Speaking of results, the paper suggests some real improvements for this package. First, they say using this state vector implementation as a starting point is really good for doing things like quenches or real time expectation values by combining it with other tools like Qiskit to evolve the prepared state under a Hamiltonian.
Mira: That makes sense because you start with a clean prepared ground state and then use that to probe dynamics, which is a natural next step in the research pipeline. It connects this preparation tool directly into time evolution studies.
Lev: I see that connection, but from my side, I'm thinking about how they can make the simulation faster on larger systems; they suggest combining parallel simulation of the real time evolution and its Hermitian adjoint to get a speedup for systems with twenty two sites or more. That sounds like some serious optimization work.
Kai: That parallelization idea is key if you want to run this efficiently on bigger systems where the state space gets really big. It’s about leveraging the structure of the evolution itself rather than just running everything sequentially.
Mira: And they also touch on how users can define their Hamiltonians flexibly, either by giving them a terms dictionary or by using a method called add uniform terms to inject translationally invariant fields. This supports a very wide class of generic quantum spin systems, which is what we need for broad applicability.
Lev: Flexibility is good, but when you start adding more complex interaction structures—more terms in that dictionary—the complexity of the operators can explode very quickly, and that's where the computational cost really starts to climb significantly.
The paper's summary: Kai: They also mention predefined initial states, like singlet or neel states, which lets users systematically explore different ground state preparation methods right from the start. This is helpful for benchmarking different initial guesses.
Mira: I agree. It gives experimentalists and theorists a structured way to test how robust these preparation methods are before they dive into optimizing the algorithm parameters themselves.
Lev: So, while having those pre set states is useful for testing, what about running the simulation on hardware that has noise? The state vector method avoids statistical uncertainty because it’s in the infinite shot limit, but that doesn't help when you have actual measurement errors at every step.
Kai: That’s a fair point. But the paper emphasizes that this state vector formulation is indispensable for parameter exploration because it bypasses those statistical uncertainties entirely, which is what makes it so useful right now for tuning.
Mira: So, to wrap up on the summary, they are really emphasizing how to build upon this package. They show how you can use the prepared state to do real time evolution and compute spectral functions and they point toward optimizing the simulation using parallel methods for larger systems.
Lev: And for me, the most practical thing is that they’ve provided a clear path for comparison against exact diagonalization using a dedicated wrapper, which means I can actually test if this method gives me results that are close to what I would get from a full exact solver on real hardware.
Kai: It sounds like this paper, "svPITE: A Python package for the state-vector based probabilistic imaginary time evolution algorithm", really gives us a solid, noise free tool to systematically explore ground state preparation methods and then feed those states into time evolution studies.
Mira: Exactly. It’s about moving from just running a simulation to building a proper framework where you can test the underlying physics of the method itself.
Lev: For now, I'm looking at how they handle scaling up the computation for larger lattices and how their parallelization strategy actually translates into meaningful speedups when we move toward physical systems.
Kai: Well, that’s it for this look at svPITE. We’ll see what these new tools can do next in our work on quantum dynamics.
The paper's improvements: Tom: So we’re looking at how they plan to improve this svPITE tool after showing what it can do for ground state prep and time evolution studies.
Kai: It seems they see the path forward as taking this state vector setup and connecting it directly to other tools like Qiskit for real time evolution experiments.
Mira: That makes sense because you start with a clean prepared ground state and then use that to probe dynamics, which is a natural next step in the research pipeline. It connects this preparation tool directly into time evolution studies.
Lev: I see that connection, but from my side, I'm thinking about how they can make the simulation faster on larger systems; they suggest combining parallel simulation of the real time evolution and its Hermitian adjoint to get a speedup for systems with twenty two sites or more. That sounds like some serious optimization work.
Kai: That parallelization idea is key if you want to run this efficiently on bigger systems where the state space gets really big. It’s about leveraging the structure of the evolution itself rather than just running everything sequentially.
Mira: And they also touch on how users can define their Hamiltonians flexibly, either by giving them a terms dictionary or by using a method called add uniform terms to inject translationally invariant fields. This supports a very wide class of generic quantum spin systems, which is what we need for broad applicability.
Lev: Flexibility is good, but when you start adding more complex interaction structures—more terms in that dictionary—the complexity of the operators can explode very quickly, and that's where the computational cost really starts to climb significantly.
Kai: They also mention predefined initial states, like singlet or neel states, which lets users systematically explore different ground state preparation methods right from the start. This is helpful for benchmarking different initial guesses.
Mira: I agree. It gives experimentalists and theorists a structured way to test how robust these preparation methods are before they dive into optimizing the algorithm parameters themselves.
Lev: So, while having those pre set states is useful for testing, what about running the simulation on hardware that has noise? The state vector method avoids statistical uncertainty because it’s in the infinite shot limit, but that doesn't help when you have actual measurement errors at every step.
Kai: That’s a fair point. But the paper emphasizes that this state vector formulation is indispensable for parameter exploration because it bypasses those statistical uncertainties entirely, which is what makes it so useful right now for tuning.
Mira: So, to wrap up on the improvements, they are really emphasizing how to build upon this package. They show how you can use the prepared state to do real time evolution and compute spectral functions and they point toward optimizing the simulation using parallel methods for larger systems.
Lev: And for me, the most practical thing is that they’ve provided a clear path for comparison against exact diagonalization using a dedicated wrapper, which means I can actually test if this method gives me results that are close to what I would get from a full exact solver on real hardware.
Kai: It sounds like this paper, "svPITE: A Python package for the state-vector based probabilistic imaginary time evolution algorithm", really gives us a solid, noise free tool to systematically explore ground state preparation methods and then feed those states into time evolution studies.
Mira: Exactly. It’s about moving from just running a simulation to building a proper framework where you can test the underlying physics of the method itself.
Lev: For now, I'm looking at how they handle scaling up the computation for larger lattices and how their parallelization strategy actually translates into meaningful speedups when we move toward physical systems.
Kai: Well, that’s it for this look at svPITE. We’ll see what these new tools can do next in our work on quantum dynamics.
Conclusion: Kai: So to wrap up, this paper on "svPITE: A Python package for the state-vector based probabilistic imaginary time evolution algorithm" is essentially showing us a clean, noise free way to build and tune ground states before running complex time evolution studies.
Mira: It’s about moving away from just running a simulation to building a proper framework where you can test the underlying physics of the method itself. It gives users a solid starting point for figuring out how these preparation methods actually work in practice.
Lev: From my angle, it’s useful because they have that direct comparison against exact diagonalization results using QuSpin, which means I can actually test if this method gives me results that are close to what I would get from a full exact solver on real hardware.
Kai: Right, so the implication is we get a better way to systematically explore the initial conditions of our quantum systems without getting bogged down by statistical noise during that preparation phase.
Mira: It changes things for theorists because now they have this clean reference state they can use to start their real time dynamics or spectral function calculations right away. That's a huge step toward testing more complex physics.
Lev: For hardware, it means we have a tool that can actually tell us if our experimental setup is getting us close to the theoretical ground state without the overhead of running massive shot based simulations for every single parameter change.
Kai: Exactly. It’s about moving from just running a simulation to building a proper framework where you can test the underlying physics of the method itself.
Mira: So, we have a more robust way to get clean initial conditions and feed them into the next stage of research, whether that's looking at time evolution or finding correlation functions.
Lev: I still think we need to see how they handle scaling up the computation for larger lattices and how their parallelization strategy actually translates into meaningful speedups when we move toward physical systems.
Kai: Well, that’s it for this look at svPITE. We’ll see what these new tools can do next in our work on quantum dynamics.
Institute of Software Technology, German Aerospace Center (DLR) · University of Hamburg
quant-ph, cond-mat.str-el
Submitted: 2026-05-08
Updated: 2026-09-15
Comments: 35 pages, 11 figures, final version. Package available at https://gitlab.com/dlr-sc-qc/many-body/svpite
Journal ref: SciPost Phys. Codebases 85 (2026)
DOI: 10.21468/SciPostPhysCodeb.85
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 83/100
The gist: We present a Python package for ground-state preparation based on the probabilistic imaginary-time evolution algorithm, with particular focus on its state-vector-based implementation.
Key concepts
- Probabilistic ITE (PITE)
- PITE is a framework that simulates imaginary-time evolution, which is crucial in finding quantum ground states. It achieves this by using stochastic operations combined with measurements and post-selection to mimic the effect of non-unitary time evolution, keeping the process within the constraints of quantum circuits.
- State-Vector Formulation
- This method represents the system's state precisely as a vector, which is different from statistical simulations. It allows researchers to study intrinsic properties like convergence behavior and accuracy without being affected by random fluctuations inherent in shot-based methods. It corresponds to the ideal, infinite-shot limit.
- Pauli String Operator
- In svPITE, quantum operators are represented as weighted sums of Pauli strings. This standard representation is used internally to build the Hamiltonian class, ensuring that all operators adhere to physical constraints like Hermiticity and providing a structured way to handle complex quantum interactions.
Summary
We present a Python package for ground-state preparation based on the probabilistic imaginary-time evolution algorithm, with particular focus on its state-vector-based implementation. p. 0 de , † satoshi. de
Abstract
We present a Python package for ground-state preparation based on the probabilistic
imaginary-time evolution algorithm, with particular focus on its state-vector-based implementation. A standard shot-based simulation is also supported, and results can be
benchmarked against exact diagonalisation via a dedicated wrapper. The package enables efficient tuning of initial parameters, facilitating systematic exploration and optimisation of the method’s performance.Where the paper says it
Where the paper says it
Overview of the PITE Algorithm
Probabilistic ITE provides one such framework, in which non-unitary evolution e-Hˆ∆τ is realized via stochastic application of unitary operations combined with measurement and post-selection. This approach enables the emulation of imaginary-time dynamics while remaining compatible with the constraints of quantum circuits. p. 2 Probabilistic ITE (PITE) provides one such framework, in which non-unitary evolution
e
−Hˆ∆τ
is realized via stochastic application of unitary operations combined with measurement
and post-selection [7–9]. This approach enables the emulation of imaginary-time dynamics
while remaining compatible with the constraints of quantum circuits. In particular, state-vector implementations allow one to isolate intrinsic algorithmic properties such as convergence behaviour and approximation accuracy, independently of statistical
fluctuations. The present codebase provides a reference implementation of PITE using a state-vector
backend, while also supporting shot-based simulations within the same framework.Where the paper says it
Where the paper says it
State-Vector Formulation
The state-vector formulation allows one to isolate intrinsic algorithmic properties such as convergence behaviour and approximation accuracy, independently of statistical fluctuations. The unnormalised state vector of the system after the (j + 1)th step is given by a specific update scheme involving real-time evolutions. p. 4 Here,
P
(j)
0 = 〈ψnew|ψnew〉 is the conditional probability of success for the ( j + 1)th step given that
the first, second, ···, and jth PITE steps were successful as well. This update scheme is implemented in the package’s state-vector-based PITE module. p. 4 Here,
P
(j)
0 = 〈ψnew|ψnew〉 is the conditional probability of success for the ( j + 1)th step given that
the first, second, ···, and jth PITE steps were successful as well. This update scheme is implemented in the package’s state-vector-based PITE module. This update scheme is implemented in the package’s state-vector-based PITE module. The state-vector-based PITE simulation does not suffer from statistical uncertainties and
corresponds to the infinite-shot limit of the shot-based simulation.Where the paper says it
Where the paper says it
Where the paper says it
Package Structure and Implementation
The svPITE package is organized into four main building blocks: Hamiltonian and operator representations, configuration objects, the algorithm classes, and result objects. All quantum operators in svPITE are represented internally as weighted sums of Pauli strings. p. 4 This
separation ensures a consistent user interface across simulation methods and allows easy extension. 1 Hamiltonian and operator representation
All quantum operators in svPITE are represented internally as weighted sums of Pauli strings,
where each string consists of the Pauli operators ’X’, ’Y’, and ’Z’ acting on a fixed number
of lattice sites. SciPost Physics Codebases Submission
built on top of PauliStringOperator, enforcing Hermiticity and providing Hamiltonianspecific methods. This abstraction ensures that both high-level model classes (e.Where the paper says it
Where the paper says it
Simulation Workflow and Benchmarks
A standard workflow involves defining a Hamiltonian, configuring the algorithm parameters, running the simulation to obtain results, and comparing them with exact diagonalization (ED). The comparison between state-vector PITE and shot-based PITE results shows good agreement between the two approaches. p. 2 The present codebase provides a reference implementation of PITE using a state-vector
backend, while also supporting shot-based simulations within the same framework. It also
enables direct comparison with exact diagonalization (ED) results in the same environment,
where ED calculations are performed using QuSpin [11]. The package enables efficient tuning of initial parameters, facilitating systematic exploration and optimisation of the method’s performance. Starting from the prepared ground state, the
strong interoperability with other packages further enables real-time evolution and the
computation of spectral functions, such as the spin-spin dynamical structure factor. The package enables efficient tuning of initial parameters, facilitating systematic exploration and optimisation of the method’s performance. Starting from the prepared ground state, the
strong interoperability with other packages further enables real-time evolution and the
computation of spectral functions, such as the spin-spin dynamical structure factor.Where the paper says it
Where the paper says it
Where the paper says it
Future Directions
Several directions for future development could further broaden the applicability and performance of the svPITE package. A first important extension concerns the treatment of more general interaction structures. p. 2 This facilitates efficient execution as well as straightforward extension to hardware-oriented
workflows. Compared to existing approaches, the code emphasizes a unified treatment of
state-vector and shot-based PITE, providing a transparent environment for cross-validation
between idealized and sampling-based dynamics. Moreover, since it requires
neither explicit measurements nor ancillary qubits, the algorithm reduces to a sequence of
real-time evolutions. This leads to a substantial improvement in computational efficiency, as
demonstrated in later sections using this package. SciPost Physics Codebases Submission
For standard spin models, this is the recommended and easiest way to start. Alternatively, especially for non-standard models, one can provide a dictionary of coefficient arrays (terms_dict)
to the Hamiltonian constructor, allowing full control over couplings and lattice structure.Where the paper says it
Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
State-vector implementation of PITE can be used as a starting point for further simulations like
quenches, real-time expectation values, or correlation functions
by combining it with Qiskit's native tools to evolve the prepared state under a Hamiltonian. -
The package enables the computation of spectral functions such as the spin-spin dynamical structure factor by preparing an initial ground state and then acting with a local spin operator to prepare an initial state for real-time evolution.
-
The system can be benchmarked against exact diagonalization results in the same environment, where
ED calculations are performed using QuSpin,
allowing for direct comparison of PITE results with exact solutions. -
Users can define custom Hamiltonians flexibly by providing a
terms dict
or usingadd uniform terms
to add translationally invariant fields, supporting a wide class of generic quantum spin systems. -
The package supports the definition of predefined initial states such as 'singlet', 'neel', and 'random' states, allowing for systematic exploration of ground-state preparation methods.
-
The state-vector based PITE simulation can be optimized by combining
parallel simulation of the real-time evolution U RTE and its Hermitian adjoint U RTE†
to achieve a speedup for systems with L >= 22 sites. -
Shot-based simulations are computationally demanding, but
the state-vector formulation of PITE is indispensable for parameter exploration
because it avoids statistical uncertainties and corresponds to the infinite-shot limit.
Abstract
We present a Python package for ground-state preparation based on the probabilistic imaginary-time evolution algorithm, with particular focus on its state-vector-based implementation. A standard shot-based simulation is also supported, and results can be benchmarked against exact diagonalisation via a dedicated wrapper. The package enables efficient tuning of initial parameters, facilitating systematic exploration and optimisation of the method's performance. Starting from the prepared ground state, the strong interoperability with other packages further enables real-time evolution and the computation of spectral functions, such as the spin-spin dynamical structure factor.
Sources
- Quantum computing with Qiskit
- High-precision ground state parameters of the two-dimensional spin-1/2 Heisenberg model on the square lattice
- Qrisp: A Framework for Compilable High-Level Programming of Gate-Based Quantum Computers
- Simulations of Quantum Circuits with Approximate Noise using qsim and Cirq
- PennyLane: Automatic differentiation of hybrid quantum-classical computations
Related papers
- Toward chemically accurate quantum simulations on quantum hardware: A quantum-HPC hybrid approach
- Transversal surface-code game with reconfigurable qubits
- Fulqrum: a generalized framework for quantum subspace diagonalization
- Flux-Activated Resonant Control of a Bosonic Quantum Memory
- Machine learning the effects of many quantum measurements
- Barriers to dequantization of near-term molecular electronic structure methods