Improving Hardware Requirements for Fault-Tolerant Quantum Computing by Optimizing Error Budget Distributions

Mathias Soeken; Nils Quetschlich; Robert Wille; Tobias Forster

REVIEW 2 major objections 5 minor 36 references

Improving Hardware Requirements for Fault-Tolerant Quantum Computing by Optimizing Error Budget Distributions

T0 review · 2 major / 5 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper claims that a machine-learning-predicted split of a quantum circuit's error budget lowers estimated fault-tolerant hardware costs for over 75% of circuits, by an average of 15.6%.

desk verdict Useful, reproducible ML approach to error-budget allocation, but the headline savings are inflated by a hybrid selection rule and the lack of a simple-heuristic baseline leaves the marginal value of the model unclear. read the letter →

arxiv 2509.02683 v1 pith:JN3VHFPV submitted 2025-09-02 quant-ph

Tobias Forster , Nils Quetschlich , Mathias Soeken , Robert Wille This is my paper · ORCID

classification quant-ph

keywords fault-tolerantquantumcomputingerrorbudgetdistributionresourceestimationspace-timecostoptimizationmachinelearningcorrectionT-stateproductionlogicalqubits

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that the way a fault-tolerant quantum circuit's total error budget is split among its main parts is a practical lever for reducing hardware requirements. End users normally assume the budget is split evenly, but the paper argues that some circuit parts, such as T-state production, can absorb errors at lower resource cost than others, so the split should be lopsided. To make this concrete, it builds a labeled dataset by randomly sampling many budget splits, estimating each with a resource estimator, and keeping the split with the lowest product of physical qubits and execution time. A machine learning model is then trained to predict such a split directly from a circuit's logical gate counts. On 383 unseen circuits, the predicted splits reduce estimated space-time costs for over 75% of circuits, with an average reduction of 15.6% and a maximum of 77.7% compared with a uniform split.

What carries the argument

The load-bearing object is the error budget distribution, a triple of error probabilities assigned to logical-qubit implementation, T-state production, and rotation-gate approximation, normalized so the three sum to the user's total error budget. The argument is carried by a supervised machine learning model trained on a dataset built by sampling many random triples per circuit, having a resource estimator compute the resulting space-time product, and labeling each circuit with the triple that minimized that product. The model's input features are the circuit's logical gate counts, so the learned mapping, once trained, predicts a resource-efficient distribution for an arbitrary new circuit without further search.

What would settle it

Re-run the resource estimation for the same test circuits with a multiplicative error model, where the total success probability is the product of the three parts' success probabilities, and compare the space-time costs of the predicted distributions against the uniform baseline; if the predicted gains disappear or the budget is violated at the 10% total error level, the additive assumption is doing the work.

Watch

Extended reading notes

Core claim

The central discovery is that the uniform error budget distribution is almost always suboptimal: for a fixed total error budget, shifting allowed error away from implementing logical qubits and toward T-state production and rotation-gate approximation lowers the estimated physical resources needed to execute the circuit fault-tolerantly. The paper states this as a quantitative claim about a resource estimator: using a machine-learning-predicted distribution instead of a uniform one reduced estimated space-time costs for more than 75% of 383 previously unseen circuits, by an average of 15.6% including circuits that did not improve, and by up to 77.7%.

Load-bearing premise

The paper's estimates assume the total error is exactly the sum of the three part budgets; if real failure probabilities combine differently, such as multiplying survival probabilities, the optimized split could silently exceed the user's intended total error.

Editorial extensions

If this is right

If the paper is right, fault-tolerant resource estimates for a given application can be reduced by simply changing how a fixed error budget is allocated, without tightening hardware error rates or changing the error correction code.
The same general pattern of a lower logical error budget and higher T-state and rotation budgets should transfer across circuits and across total budgets, since the effect appeared at 0.1%, 1%, and 10% total error.
Predicted distributions can be produced cheaply once the model is trained, because the input is just logical gate counts, avoiding the need to sample thousands of distributions for each new circuit.
Most circuits, but not all, benefit from the predicted split, so the method supports per-circuit tailoring rather than a single universal distribution rule.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Editorially: because the paper's cost labels come from an estimator that adds the three error budgets linearly, the reported savings are predictions under that additive model; a test that composes failure probabilities multiplicatively could change the optimal split, especially at the 10% total budget level.
Editorially: the same data-accumulation pipeline could be relabeled with a different objective, such as physical qubit count alone or execution time alone, so the method is not tied to the space-time product.
Editorially: a natural next experiment is to check whether distributions trained under one error-correcting code, with its specific T-state cost, still help when the code or magic-state factory changes; the learned mapping would likely need retraining if relative costs shift.
Editorially: an empirical validation on hardware or detailed simulation with a multiplicative error model would separate the genuine budgeting insight from artifacts of the additive estimator.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: the work is a genuine, reproducible application of ML to error budget allocation for FTQC resource estimation, and the authors are transparent about their setup. But the headline reduction is measured against a hybrid that takes the better of the ML prediction and the uniform baseline, so the claim that ML alone beats uniform is not supported as stated. And the comparison lacks a trivial fixed-heuristic baseline, so we don't know how much of the gain is due to learning.

What's actually new: to my knowledge, no prior resource estimation work trains a model to choose the split of the error budget among logical, T states, and rotations. The dataset construction (1000 random splits per circuit, pick the lowest space-time product) is reasonable, and training a random forest on logical counts is straightforward. The evaluation uses a properly held-out test set, and the code is on GitHub. The histograms and guidelines are a nice byproduct, even if they're just descriptive summaries of the training data.

Where it's soft:

1. The selection issue is real and material. Section V-A explicitly says the cost of the ML prediction and the uniform distribution are compared and the lower one is chosen for every circuit. That means the plotted differences are all non-negative by construction and the 15.6% average is the gain of an oracle that can discard bad ML guesses. The abstract and Section V-C repeatedly call this 'the ML model's predictions' compared to uniform. To make the claim clean, they need to report the ML-only win rate and the distribution of losses when ML is worse. My guess is the gains would shrink, maybe substantially.

2. No baseline against a fixed rule extracted from their own guidelines, e.g., allocate roughly 0.1/0.5/0.4 to logical/T/rotations. Such a heuristic might capture most of the improvement, which would shrink the value of the trained model.

3. Generalization is only within MQT Bench, with a random circuit split. A leave-one-family-out or a second benchmark would tell us whether the model actually transfers to unseen circuit structures. The paper's claim about 'arbitrary circuits' is too strong.

4. The additive error model: if the three budgets are per-part error probabilities, their sum is a conservative upper bound on the total failure probability via the union bound, so the 10% case is safe; the paper should just say this. Minor.

Bottom line: the contribution is a useful engineering step, and the paper deserves a serious referee. With the ML-only numbers, a heuristic baseline, and a scope statement, it could be a solid venue-level paper. For now it's a conditional accept that needs those numbers.

Referee Report

2 major / 5 minor

Summary. The paper addresses the problem of allocating a user-specified total error budget among three parts of a fault-tolerant quantum circuit—logical qubit implementation, T-state production, and rotation-gate approximation—in order to reduce estimated physical resource costs (space-time product). The authors sample 1000 random error-budget distributions per circuit for 1530 circuits from MQT Bench, use Microsoft's Azure Quantum Resource Estimator to label each circuit with the best sampled distribution, and train a random forest to predict a good distribution from logical gate counts. They evaluate on a held-out test set of 383 circuits across total error budgets of 0.1%, 1%, and 10%, reporting that the estimated space-time cost is reduced for over 75% of circuits with an average reduction of 15.6% and a maximum reduction of 77.7% compared to a uniform distribution. They also extract general guidelines on how to distribute the budget and make the implementation available on GitHub.

Significance. If the reported evaluation were correctly attributed, the paper would make a useful practical contribution to fault-tolerant quantum resource estimation: it shows that the error-budget distribution is a meaningful degree of freedom and provides an automated way to exploit it, backed by a reasonably large dataset, a held-out test split, three total-budget settings, and public code. The guidelines and the dataset are also potentially reusable by other researchers. However, the central quantitative claim is currently not supported as stated because the evaluation protocol selects the cheaper of the ML prediction and the uniform baseline for every test circuit; therefore the reported reductions describe a hybrid strategy, not the ML model alone. This is a fixable issue, but it affects the headline result and needs to be addressed before the paper can be accepted.

major comments (2)

[V-A, V-C, and Abstract] The evaluation protocol in Section V-A states 'the error budget distribution with the lowest estimated space-time cost was chosen from the machine learning model's predictions and a uniform distribution.' This means that every reported improvement is computed as (uniform - min(uniform, ML))/uniform, which is never negative and which discards the ML prediction whenever it is worse than uniform. The histograms in Figure 4 therefore contain no negative-difference bars for the predicted distributions, and the reported 'over 75%' and '15.6% average reduction' describe a hybrid strategy rather than 'machine-learning-predicted error budget distributions instead of a uniform distribution' as claimed in the abstract. Please report the distribution of (cost(uniform) - cost(ML-only))/cost(uniform) for every test circuit, including negative values, and give the mean, median, and fraction of improving circuits for the ML-only predictions. The abstract and Section V-C should be revised to describe the evaluation honestly, or the evaluation should be changed to compare ML-only predictions against the uniform baseline without per-circuit selection.
[V-B and V-C] The paper does not compare the ML predictions against a simple fixed non-uniform heuristic. The guidelines derived in Section V-B (small logical budget, larger T-state and rotation budgets) can be instantiated as a constant distribution, such as the mean optimized distribution over the training set, and applied to all test circuits. Without this baseline, the observed gains may be attributable simply to shifting away from a uniform split rather than to per-circuit tailoring by the ML model. Please add a fixed-heuristic baseline and report paired comparisons (ML-only versus fixed-heuristic, and fixed-heuristic versus uniform) so that the value added by machine learning per circuit is quantified.

minor comments (5)

[II-C] The additive error-budget model ('The sum of these individual error budgets refers to the total error budget') is stated without justification. If the three budgets are per-part error probabilities, the sum is a conservative upper bound on the total failure probability by the union bound, so the 10% budget case does not silently exceed the user's budget; please state this interpretation explicitly so that the model is not misread as an exact equality.
[V-A] Please report the random-forest hyperparameters (number of trees, maximum depth, minimum samples per leaf, etc.) and the random seed used for the train/test split, since these are needed to reproduce the exact numbers.
[Figure 4] The blue and yellow histograms are drawn in the same panel and overlap substantially; transparent bars or separate panels would make the comparison readable.
[V-B] The claim that the rotations error budget 'behave[s] similarly to the T states budget' because rotation approximation includes T-state usage is plausible but not demonstrated; a scatter plot or correlation coefficient between the two budgets across circuits would support this guideline.
[V-C] The phrase 'including samples without improvement' is ambiguous given the min-selection protocol; clarify that these are circuits for which the uniform baseline was selected because the ML prediction was worse, not circuits where the ML-only prediction happened to match uniform.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: held-out supervised evaluation against an external resource estimator.

full rationale

The paper's derivation chain is a standard supervised-learning pipeline. Random error-budget distributions are sampled and evaluated with Microsoft's Azure Quantum Resource Estimator (an external tool), the lowest-cost distribution per circuit is stored as a label, a Random Forest is trained on 75% of the accumulated dataset, and the evaluation is performed on the held-out 25% test set. Because the test set is never used for training or label fitting, the reported reductions are genuine out-of-sample results. The 'guidelines' in Section V-B are descriptive statistics of the accumulated dataset, not outputs of the prediction model, so they cannot be circular. Self-citations to MQT Bench and other MQT tools are used for benchmarks and implementation, not to justify the central claim, and the resource-estimation model itself is imported from external published work. The only notable concern is that Section V-A states that 'the error budget distribution with the lowest estimated space-time cost was chosen from the machine learning model's predictions and a uniform distribution,' meaning the headline numbers describe a hybrid min-selection policy rather than the ML model alone. This is an evaluation-reporting issue about what exactly is being measured, not a circularity in the derivation: the selected quantity is not definitionally equal to the training target nor fitted to the test outcomes. Therefore, no circular step is present.

Assumptions & free parameters 3 free parameters · 3 assumptions · 0 invented entities

The central claim depends on the Azure Quantum Resource Estimator's additive error-budget model, the representativeness of MQT Bench circuits, and the choice of space-time cost as the objective. No new physical entities are introduced. Free parameters include the random forest hyperparameters (not disclosed) and the number of random samples per circuit (1000).

free parameters (3)

Random forest hyperparameters
Not reported in the paper; the model's predictions and hence the reported reductions depend on these training choices.
Number of random budget samples per circuit = 1000
Design choice in the data accumulation step (Section IV-B); the 'best' distribution used as a label is the best among these 1000 random samples, so the label quality depends on this number.
Train/test split ratio = 75/25
Random split of the accumulated dataset (Section V-A); the computed reduction on the test set depends on this split.

assumptions (3)

domain assumption The total error budget equals the sum of the logical, T states, and rotations error budgets.
Inherited from the Azure Quantum Resource Estimator (Section II-C). If actual errors combine non-additively, the optimized distributions could exceed the user's true tolerated error.
domain assumption MQT Bench circuits are representative of the space of arbitrary quantum circuits.
The model is trained and tested only on MQT Bench (Section V-A); the abstract's claim of 'arbitrary circuits' rests on this.
domain assumption The space-time product is an appropriate cost metric for comparing error budget distributions.
Used to select the best distribution in Section IV-B; other metrics (e.g., qubit count alone) would lead to different labels.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Improving Hardware Requirements for Fault-Tolerant Quantum Computing by Optimizing Error Budget Distributions." pith.science (2026). https://pith.science/paper/JN3VHFPV

@misc{pith2026250902683,
  author       = {Pith},
  title        = {Pith review of: Improving Hardware Requirements for Fault-Tolerant Quantum Computing by Optimizing Error Budget Distributions},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JN3VHFPV}},
  note         = {Machine review of arXiv:2509.02683}
}

read the original abstract

Despite significant progress in quantum computing in recent years, executing quantum circuits for practical problems remains challenging due to error-prone quantum hardware. Hence, quantum error correction becomes essential but induces significant overheads in qubits and execution time, often by orders of magnitude. Obviously, these overheads must be reduced. Since many quantum applications can tolerate some noise, end users can provide a maximum tolerated error, the error budget, to be considered during compilation and execution. This error budget, or, more precisely, its distribution, can be a key factor in achieving the overhead reduction. Conceptually, an error-corrected quantum circuit can be divided into different parts that each have a specific purpose. Errors can happen in any of these parts and their errors sum up to the mentioned error budget, but how to distribute it among them actually constitutes a degree of freedom. This work is based on the idea that some of the circuit parts can compensate for errors more efficiently than others. Consequently, these parts should contribute more to satisfy the total error budget than the parts where it is more costly. However, this poses the challenge of finding optimal distributions. We address this challenge not only by providing general guidelines on distributing the error budget, but also a method that automatically determines resource-efficient distributions for arbitrary circuits by training a machine learning model on an accumulated dataset. The approach is evaluated by analyzing the machine learning model's predictions on so far unseen data, reducing the estimated space-time costs for more than 75% of the considered quantum circuits, with an average reduction of 15.6%, including cases without improvement, and a maximum reduction of 77.7%.

Figures

Figures reproduced from arXiv: 2509.02683 by the authors.

**Figure 2.** Proposed method. budgets and compensating for this by reducing the T states error budget (indicated by the red, blue, and green bars, respectively). Compared to the uniform distribution, the required physical qubits and execution time decrease by ∼ 12% and ∼ 7%, respectively. As shown, it is possible to find distributions that still meet the overall error budget but, in an attempt to reduce the estimated costs, uti… view at source ↗

**Figure 3.** Frequencies of the three error budgets in the test set for a total budget of 1 %. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗

Figures from the paper (1 more)

**Figure 4.** Figure 4: Improvements in the estimated space-time costs by the proposed approach. [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

36 extracted references · 27 canonical work pages

[1]

Quantum computation and quantum information

M. A. Nielsen and I. L. Chuang, “Quantum computation and quantum information.” Cambridge university press, 2010

2010
[2]

Drug design on quantum comput- ers,

R. Santagati et al., “Drug design on quantum comput- ers,” Nature Physics, 2024

work page 2024
[3]

Quantum computing for health- care: A review,

R. Ur Rasool et al. , “Quantum computing for health- care: A review,” Future Internet, 2023

work page 2023
[4]

Emerging quantum comput- ing algorithms for quantum chemistry,

M. Motta and J. E. Rice, “Emerging quantum comput- ing algorithms for quantum chemistry,” Wiley Interdis- ciplinary Reviews: Computational Molecular Science , 2022

work page 2022
[5]

Quantum chemistry in the age of quantum computing,

Y . Cao et al. , “Quantum chemistry in the age of quantum computing,” Chemical reviews, 2019

work page 2019
[6]

Quantum computing for finance,

D. Herman et al. , “Quantum computing for finance,” Nature Reviews Physics , 2023

work page 2023
[7]

Quantum comput- ing for finance: Overview and prospects,

R. Or ´us, S. Mugel, and E. Lizaso, “Quantum comput- ing for finance: Overview and prospects,” Reviews in Physics, 2019

work page 2019
[8]

Towards equivalence checking of classical circuits using quantum computing,

N. Quetschlich et al. , “Towards equivalence checking of classical circuits using quantum computing,” in Int’l Conf. on Quantum Computing and Engineering , 2024

2024

Show all 36 references

[9]

Stabilizer codes and quantum error correction

D. Gottesman, “Stabilizer codes and quantum error correction.” California Institute of Technology, 1997

1997
[10]

Quantum computations: Algorithms and error correction,

A. Y . Kitaev, “Quantum computations: Algorithms and error correction,” Russian Mathematical Surveys, 1997

1997
[11]

Efficient fault-tolerant quantum comput- ing,

A. M. Steane, “Efficient fault-tolerant quantum comput- ing,” Nature, 1999

1999
[12]

Automated synthesis of fault-tolerant state preparation circuits for quantum error-correction codes,

T. Peham et al., “Automated synthesis of fault-tolerant state preparation circuits for quantum error-correction codes,” PRX Quantum, 2 2025

2025
[13]

Software tools for decoding quantum low-density parity-check codes,

L. Berent, L. Burgholzer, and R. Wille, “Software tools for decoding quantum low-density parity-check codes,” in Asia and South Pacific Design Automation Conf. , 2023

2023
[14]

Error-correction coding for digital communications

G. C. Clark Jr and J. B. Cain, “Error-correction coding for digital communications.” Springer Science & Busi- ness Media, 2013

2013
[15]

A single quantum cannot be cloned,

W. K. Wootters and W. H. Zurek, “A single quantum cannot be cloned,” Nature, 1982

1982
[16]

Surface codes: Towards practical large-scale quantum computation,

A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, “Surface codes: Towards practical large-scale quantum computation,” Physical Review A—Atomic, Molecular, and Optical Physics , 2012

2012
[17]

A game of surface codes: Large-scale quantum computing with lattice surgery,

D. Litinski, “A game of surface codes: Large-scale quantum computing with lattice surgery,” Quantum, 2019

2019
[18]

Realization of an error-correcting sur- face code with superconducting qubits,

Y . Zhao et al. , “Realization of an error-correcting sur- face code with superconducting qubits,”Phys. Rev. Lett., 3 2022

2022
[19]

Fault- tolerant quantum computing with color codes,

A. J. Landahl, J. T. Anderson, and P. R. Rice, “Fault- tolerant quantum computing with color codes,” 2011. arXiv: 1108.5738 [quant-ph]

2011 arXiv
[20]

Two-dimensional color-code quantum computation,

A. G. Fowler, “Two-dimensional color-code quantum computation,” Phys. Rev. A, 4 2011

2011
[21]

Fault-tolerant quantum error correc- tion for steane’s seven-qubit color code with few or no extra qubits,

B. W. Reichardt, “Fault-tolerant quantum error correc- tion for steane’s seven-qubit color code with few or no extra qubits,” Quantum Science and Technology , 2020

2020
[22]

Decoding quantum color codes with MaxSAT,

L. Berent et al. , “Decoding quantum color codes with MaxSAT,” Quantum, 2024

2024
[23]

Restrictions on transversal encoded quantum gate sets,

B. Eastin and E. Knill, “Restrictions on transversal encoded quantum gate sets,” Phys. Rev. Lett., 11 2009

2009
[24]

Utilizing resource estimation for the development of quantum computing applications,

N. Quetschlich, M. Soeken, P. Murali, and R. Wille, “Utilizing resource estimation for the development of quantum computing applications,” in Int’l Conf. on Quantum Computing and Engineering , 2024

2024
[25]

Using azure quantum resource estimator for assessing per- formance of fault tolerant quantum computation,

W. van Dam, M. Mykhailova, and M. Soeken, “Using azure quantum resource estimator for assessing per- formance of fault tolerant quantum computation,” in Workshops of The International Conference on High Performance Computing, Network, Storage, and Analy- sis, 2023

2023
[26]

Assessing requirements to scale to practical quantum advantage,

M. E. Beverland et al., “Assessing requirements to scale to practical quantum advantage,” 2022. arXiv: 2211 . 07629

2022
[27]

Expressing and analyzing quan- tum algorithms with qualtran,

M. P. Harrigan et al., “Expressing and analyzing quan- tum algorithms with qualtran,” 2024. arXiv: 2409 . 04643

2024
[28]

rroodll, jbelarge, elenewski, and zmorrell, Isi-usc- edu/pyliqtr: Release 1.1.1 , version v1.1.1, 2024

2024
[29]

Survey on quantum circuit compilation for noisy intermediate- scale quantum computers: Artificial intelligence to heuristics,

J. Kusyk, S. M. Saeed, and M. U. Uyar, “Survey on quantum circuit compilation for noisy intermediate- scale quantum computers: Artificial intelligence to heuristics,” IEEE Transactions on Quantum Engineer- ing, 2021

2021
[30]

MQT Predictor: Automatic Device Selection with Device- Specific Circuit Compilation for Quantum Comput- ing,

N. Quetschlich, L. Burgholzer, and R. Wille, “MQT Predictor: Automatic Device Selection with Device- Specific Circuit Compilation for Quantum Comput- ing,” ACM Transactions on Quantum Computing, 2025. arXiv: 2310.06889

2025 arXiv
[31]

MQT QMAP: Efficient quantum circuit mapping,

R. Wille and L. Burgholzer, “MQT QMAP: Efficient quantum circuit mapping,” in Proceedings of the 2023 International Symposium on Physical Design , 2023

2023
[32]

Realization of a scalable shor algo- rithm,

T. Monz et al. , “Realization of a scalable shor algo- rithm,” Science, 2016

2016
[33]

Noise-robust ground state energy estimates from deep quantum circuits,

H. J. Vallury et al. , “Noise-robust ground state energy estimates from deep quantum circuits,” Quantum, 2023

2023
[34]

The MQT Handbook: A Summary of Design Automation Tools and Software for Quantum Computing,

R. Wille et al., “The MQT Handbook: A Summary of Design Automation Tools and Software for Quantum Computing,” in Int’l Conf. on Quantum Software, 2024. arXiv: 2405.17543, A live version of this document is available at https://mqt.readthedocs.io

2024 arXiv
[35]

MQT Bench: Benchmarking Software and Design Automation Tools for Quantum Computing,

N. Quetschlich, L. Burgholzer, and R. Wille, “MQT Bench: Benchmarking Software and Design Automation Tools for Quantum Computing,” Quantum, 2023, MQT Bench is available at https : / / www. cda . cit . tum . de / mqtbench/. arXiv: 2204.13719 [quant-ph]

2023 arXiv
[36]

Scikit-learn: Machine learning in Python,

F. Pedregosa et al. , “Scikit-learn: Machine learning in Python,” Journal of Machine Learning Research , 2011

2011

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.

[1] [1]

Quantum computation and quantum information

M. A. Nielsen and I. L. Chuang, “Quantum computation and quantum information.” Cambridge university press, 2010

2010

[2] [2]

Drug design on quantum comput- ers,

R. Santagati et al., “Drug design on quantum comput- ers,” Nature Physics, 2024

work page 2024

[3] [3]

Quantum computing for health- care: A review,

R. Ur Rasool et al. , “Quantum computing for health- care: A review,” Future Internet, 2023

work page 2023

[4] [4]

Emerging quantum comput- ing algorithms for quantum chemistry,

M. Motta and J. E. Rice, “Emerging quantum comput- ing algorithms for quantum chemistry,” Wiley Interdis- ciplinary Reviews: Computational Molecular Science , 2022

work page 2022

[5] [5]

Quantum chemistry in the age of quantum computing,

Y . Cao et al. , “Quantum chemistry in the age of quantum computing,” Chemical reviews, 2019

work page 2019

[6] [6]

Quantum computing for finance,

D. Herman et al. , “Quantum computing for finance,” Nature Reviews Physics , 2023

work page 2023

[7] [7]

Quantum comput- ing for finance: Overview and prospects,

R. Or ´us, S. Mugel, and E. Lizaso, “Quantum comput- ing for finance: Overview and prospects,” Reviews in Physics, 2019

work page 2019

[8] [8]

Towards equivalence checking of classical circuits using quantum computing,

N. Quetschlich et al. , “Towards equivalence checking of classical circuits using quantum computing,” in Int’l Conf. on Quantum Computing and Engineering , 2024

2024