pith. sign in

arxiv: 2510.16149 · v2 · submitted 2025-10-17 · 🪐 quant-ph

Efficient Quantum State Preparation with Bucket Brigade QRAM

Alessandro Berti , Francesco Ghisoni This is my paper

Pith reviewed 2026-05-18 05:56 UTC · model grok-4.3

classification 🪐 quant-ph
keywords quantum state preparationbucket brigade QRAMsegment treeQRAMdata encodingquantum algorithmsmatrix encodingquantum memory
0
0 comments X

The pith

Embedding a segment tree in bucket brigade QRAM encodes an M by N matrix into a quantum state using logarithmic qubits and time.

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

The paper develops a framework that combines the bucket brigade QRAM hardware model with the classical segment tree data structure to prepare quantum states from classical data. It introduces a memory layout that embeds the segment tree inside BBQRAM cells while preserving hierarchy and enabling logarithmic-time retrieval through specialized access primitives. This yields an encoding of matrix A in R^{M x N} into a register of Theta(log2(MN)) qubits in O(log2 squared(MN)) time, using constant working qubits under fixed precision and O(MN) memory cells. A reader would care because data loading overhead often blocks quantum advantage in machine learning, finance, and chemistry, and this approach aims to make it negligible.

Core claim

The authors demonstrate that their method encodes a matrix A in R^{M x N} in a quantum register of Theta(log2(MN)) qubits in O(log2 squared(MN)) time, requiring a constant number of working qubits under fixed precision and O(MN) memory cells within the BBQRAM architecture, by embedding a segment tree within the BBQRAM memory cells that preserves the tree hierarchy and supports data retrieval in logarithmic time via specialized access primitives.

What carries the argument

A segment-tree embedding inside BBQRAM memory cells that preserves hierarchy and supports logarithmic-time data retrieval via specialized access primitives.

If this is right

  • Quantum algorithms can treat data loading as negligible overhead.
  • The method provides a foundation for hardware-aware classical-to-quantum encoding algorithms.
  • State preparation for matrices now requires only Theta(log(MN)) qubits plus O(MN) memory cells and constant ancillas.
  • Applications in machine learning, finance, and chemistry gain a concrete route to efficient data encoding.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The layout could be adapted to other QRAM variants or data structures for similar gains.
  • Overall complexity of quantum linear systems solvers might drop when data access is no longer the dominant cost.
  • Small-scale numerical checks on the segment-tree primitives would directly test the logarithmic scaling before hardware implementation.
  • The approach highlights the value of co-designing quantum algorithms with specific QRAM memory organizations.

Load-bearing premise

A memory layout exists that embeds a segment tree within BBQRAM memory cells while preserving the segment tree's hierarchy and supporting data retrieval in logarithmic time via specialized access primitives.

What would settle it

An explicit construction or simulation showing that the specialized access primitives cannot retrieve data in logarithmic time without extra qubits scaling with MN or without exceeding constant working qubits would falsify the claimed efficiency.

Figures

Figures reproduced from arXiv: 2510.16149 by Alessandro Berti, Francesco Ghisoni.

Figure 1
Figure 1. Figure 1: The circuit on the left implements a cascade of controlled [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: A circuit multiplexer implementing Í𝑁 −1 𝑖=0 |𝑖⟩ ⟨𝑖|𝑈𝑖 that prepares 𝑁 values in the form |𝑥𝑖⟩ 𝑡 . 3 Background In this section, we describe the main components we require for efficient quantum state preparation. Section 3.1 reviews the concept of QRAM, focusing on the Bucket Brigade architecture, and its role in enabling data retrieval in superposition. Section 3.2 introduces the Segment Tree data structu… view at source ↗
Figure 3
Figure 3. Figure 3: Bucket Brigade QRAM architecture (BBQRAM). Internal nodes act as switches that route address qubits, while leaf nodes [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: QRAM routing algorithm for the address register [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Bus register traversal in BBQRAM. After establishing the access path for the address register [PITH_FULL_IMAGE:figures/full_fig_p009_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Segment tree of squared norms 𝑇 for a matrix 𝐴 ∈ R 2×4 . The segment tree has depth log2 (4 · 2) = 3 and contains 15 nodes. Each leaf stores the squared norm |𝑎𝑧 | 2 =𝑇3,𝑧 of a value of 𝐴 along with its sign s(𝑎𝑧 ). Definition 2 (Segment Tree of Squared Norms). Let 𝐴 ∈ R 𝑀×𝑁 be a matrix, where 𝑀 , 𝑁 are powers of two, and adopt a row-major order indexing of the values of 𝐴 such that 𝑎𝑧 = 𝑎𝑖,𝑗 with 𝑧 = 𝑖 · … view at source ↗
Figure 7
Figure 7. Figure 7: Illustration of the memory layout of a segment tree in a BBQRAM. The top figure shows the segment tree [PITH_FULL_IMAGE:figures/full_fig_p012_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Two representative access paths allowed by the retrieval primitives of Corollary [PITH_FULL_IMAGE:figures/full_fig_p013_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Two representative access paths defined by the retrieval primitives of Corollary [PITH_FULL_IMAGE:figures/full_fig_p014_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Tree of SWAP gates quantum circuit that performs a left circular shift on the working register [PITH_FULL_IMAGE:figures/full_fig_p021_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: Figure 11a depicts the segment tree 𝑇 obtained from matrix 𝐴 ∈ R 2×4 of the numerical example accoding to Definition 2. Figure 11b illustrates how 𝑇 maps into the memory cells of a BBQRAM architecture according to Proposition 3. where 𝑀 and 𝑁 denote the number of rows and columns of 𝐴, respectively; 𝐾 is the total number of entries in 𝐴, indexed in row-major order; and 𝑚, 𝑛, and 𝑘 represent the number of … view at source ↗
Figure 12
Figure 12. Figure 12: Address register |0 0 1⟩a traces a single path that accesses the memory cell |𝐿1 ⟩ containing the sibling pair |24.89⟩ |7.59⟩ at height ℎ = 1 in 𝑇 . |0⟩ |1⟩ |•⟩ |•⟩ |𝛾1⟩ |•⟩ |•⟩ |0⟩ |32.48⟩ |𝑏⟩ |𝐿0⟩ |0⟩ |24.89⟩ |7.59⟩ |𝐿1⟩ |1⟩ |14.45⟩ |10.44⟩ |𝐿2⟩ |0⟩ |1.09⟩ |6.50⟩ |𝐿3⟩ |0⟩ |4.84⟩ |9.61⟩ |𝐿4⟩ |0⟩ |9.00⟩ |1.44⟩ |𝐿5⟩ |0⟩ |0.09⟩ |1.00⟩ |𝐿6⟩ |1⟩ |0.25⟩ |6.25⟩ |𝐿7⟩ [PITH_FULL_IMAGE:figures/full_fig_p023_12.png] view at source ↗
Figure 13
Figure 13. Figure 13: Address register |0 1𝛾1 ⟩a, where |𝛾1 ⟩ = √ 24.89|0⟩a + √ 7.59|1⟩a, accesses in superposition the memory cells |𝐿2 ⟩ and |𝐿3 ⟩ containing the two sibling pairs |14.45⟩ |10.44⟩ and |1.09⟩ |6.50⟩, respectively, that reside at height ℎ = 2 in 𝑇 . and we uncompute |24.89⟩l |7.59⟩r : |0⟩s |0⟩l |0⟩r √︂ 24.89 32.48 |0⟩v + √︂ 7.59 32.48 |1⟩v ! |001⟩a = 1 √ 32.48 |0⟩s |0⟩l |0⟩r √ 24.89|0⟩v + √ 7.59|1⟩v  |001⟩a. … view at source ↗
Figure 14
Figure 14. Figure 14: The figure illustrates the superposition of two distinct access paths when querying the memory cells with the address register [PITH_FULL_IMAGE:figures/full_fig_p024_14.png] view at source ↗
Figure 15
Figure 15. Figure 15: The figure illustrates the superposition of four distinct access paths when querying the memory cells for retrieving sign qubits [PITH_FULL_IMAGE:figures/full_fig_p025_15.png] view at source ↗
read the original abstract

The preparation of data in quantum states is a critical component in the design of quantum algorithms. The cost of this step can significantly limit the realization of quantum advantage in domains such as machine learning, finance, and chemistry. One of the main approaches to achieve efficient state preparation is through the use of Quantum Random Access Memory (QRAM), a theoretical device for coherent data access with several proposed hardware implementations. In this work, we present a framework that integrates the hardware model of the Bucket Brigade QRAM (BBQRAM) with the classical data structure of the Segment Tree to achieve efficient state preparation. We introduce a memory layout that embeds a segment tree within BBQRAM memory cells by preserving the segment tree's hierarchy and supporting data retrieval in logarithmic time via specialized access primitives. We demonstrate that our method encodes a matrix $A \in \mathbb{R}^{M \times N}$ in a quantum register of $\Theta(\log_2(MN))$ qubits in $\mathcal{O}(\log_2^2(MN))$ time, {requiring a constant number of working qubits (under fixed precision) and $\mathcal{O}(MN)$ memory cells within the BBQRAM architecture.} We further illustrate the method through a numerical example. This framework provides theoretical support for quantum algorithms that assume negligible data loading overhead and establishes a foundation for designing classical-to-quantum encoding algorithms that are aware of the underlying hardware QRAM architecture.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The manuscript proposes integrating the Bucket Brigade QRAM (BBQRAM) hardware model with the classical segment tree data structure to enable efficient quantum state preparation. It introduces a memory layout that embeds a segment tree within BBQRAM cells while preserving hierarchy, and claims that this encodes a matrix A ∈ R^{M×N} into a quantum register of Θ(log₂(MN)) qubits in O(log₂²(MN)) time using a constant number of working qubits (under fixed precision) and O(MN) memory cells, with specialized access primitives supporting logarithmic retrieval. A numerical example is provided to illustrate the approach.

Significance. If the central claims hold, the work would supply a hardware-aware encoding scheme that makes data-loading overhead negligible for quantum algorithms in machine learning, finance, and chemistry, thereby strengthening the practical viability of algorithms that assume efficient QRAM access. The explicit use of segment trees to exploit BBQRAM's binary-tree routing is a concrete step toward architecture-aware quantum data structures.

major comments (2)
  1. [Abstract (memory-layout paragraph) and the section describing the proposed embedding] The O(log₂²(MN)) runtime bound and the assertion of constant working qubits rest on the existence of a memory layout that embeds the segment tree hierarchy into BBQRAM cells without introducing extra routing depth or auxiliary-qubit overhead per access. The manuscript states that the layout “preserves the segment tree’s hierarchy” and supports “data retrieval in logarithmic time via specialized access primitives,” but supplies neither an explicit node-to-cell mapping nor a gate-count or query-complexity analysis of those primitives. If the primitives are realized by repeated BBQRAM queries whose depth scales with tree height, the total cost would exceed the claimed bound.
  2. [Abstract and Complexity Analysis section] No derivation, proof sketch, or explicit resource accounting is given for the transition from the segment-tree layout to the final O(log₂²(MN)) gate or query complexity. The abstract simply asserts the result after describing the layout; without this missing step the central complexity claim cannot be verified from the supplied material.
minor comments (2)
  1. [Numerical Example] The numerical example would benefit from an explicit table or diagram showing the address-qubit routing and the sequence of specialized primitives for a small matrix, to make the logarithmic retrieval concrete.
  2. [Resource-count paragraph] Notation for the working-qubit count under “fixed precision” should be clarified; it is stated as constant but the dependence on bit precision or matrix dimension is not quantified.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the careful review and constructive comments on our manuscript. We address each major comment below, clarifying the existing content and indicating where revisions will strengthen the presentation.

read point-by-point responses

  1. Referee: [Abstract (memory-layout paragraph) and the section describing the proposed embedding] The O(log₂²(MN)) runtime bound and the assertion of constant working qubits rest on the existence of a memory layout that embeds the segment tree hierarchy into BBQRAM cells without introducing extra routing depth or auxiliary-qubit overhead per access. The manuscript states that the layout “preserves the segment tree’s hierarchy” and supports “data retrieval in logarithmic time via specialized access primitives,” but supplies neither an explicit node-to-cell mapping nor a gate-count or query-complexity analysis of those primitives. If the primitives are realized by repeated BBQRAM queries whose depth scales with tree height, the total cost would exceed the claimed bound.

    Authors: We acknowledge that the manuscript currently presents the memory layout at a conceptual level without an explicit node-to-cell mapping or a full gate-count breakdown of the access primitives. In the revised manuscript we will add a new subsection that defines the precise mapping of segment-tree nodes onto BBQRAM cells, showing that parent-child relationships are realized by adjacent cells in the bucket-brigade routing tree. This mapping ensures that each specialized primitive is implemented by a single O(log(MN))-depth BBQRAM traversal rather than repeated independent queries. We will also supply an explicit resource count demonstrating that the constant-ancilla claim holds under fixed-precision arithmetic and that no additional routing depth is incurred beyond the logarithmic factor already accounted for in the O(log²(MN)) bound. revision: yes

  2. Referee: [Abstract and Complexity Analysis section] No derivation, proof sketch, or explicit resource accounting is given for the transition from the segment-tree layout to the final O(log₂²(MN)) gate or query complexity. The abstract simply asserts the result after describing the layout; without this missing step the central complexity claim cannot be verified from the supplied material.

    Authors: We agree that a self-contained derivation is required for independent verification. The revised Complexity Analysis section will contain a step-by-step accounting: (1) the segment-tree embedding permits each matrix-element retrieval to be performed with O(log(MN)) BBQRAM queries of depth O(log(MN)); (2) state preparation iterates over O(log(MN)) such retrievals while maintaining a constant number of working qubits; (3) the overall gate complexity is therefore O(log²(MN)). A short proof sketch will be included that bounds the ancilla overhead and confirms the claimed scaling under the fixed-precision model stated in the abstract. revision: yes

Circularity Check

0 steps flagged

No circularity in derivation chain

full rationale

The paper proposes a new memory layout embedding a segment tree into BBQRAM cells while preserving hierarchy, then states that the O(log²(MN)) encoding time and Θ(log₂(MN)) qubit count follow from this layout plus specialized logarithmic retrieval primitives. No equations, fitted parameters, or self-citations are exhibited that reduce the runtime bound to an input by construction. The central claim is presented as a direct consequence of the introduced framework and is therefore self-contained.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 0 invented entities

The construction rests on one main domain assumption about embedding segment trees into BBQRAM cells; no free parameters or new physical entities are introduced.

axioms (1)
  • domain assumption Segment tree hierarchy can be preserved inside BBQRAM memory cells while supporting logarithmic-time retrieval via specialized access primitives.
    This embedding is required for the claimed O(log²(MN)) runtime and constant ancilla count; it is stated as part of the memory layout in the abstract.

pith-pipeline@v0.9.0 · 5777 in / 1209 out tokens · 43745 ms · 2026-05-18T05:56:01.423282+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

What do these tags mean?
matches
The paper's claim is directly supported by a theorem in the formal canon.
supports
The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends
The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses
The paper appears to rely on the theorem as machinery.
contradicts
The paper's claim conflicts with a theorem or certificate in the canon.
unclear
Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. Efficient Complex-Valued State Preparation on Bucket Brigade QRAM

    quant-ph 2026-04 unverdicted novelty 4.0

    Precomputes rotation angles classically and adds a magnitude-then-phase procedure to enable complex-valued state preparation on BBQRAM at unchanged O(log²(MN)) query cost with no reversible arithmetic on the QPU.

Reference graph

Works this paper leans on

35 extracted references · 35 canonical work pages · cited by 1 Pith paper · 1 internal anchor

  1. [1]

    Jonathan Allcock, Jinge Bao, João F Doriguello, Alessandro Luongo, and Miklos Santha. 2023. Constant-depth circuits for Uniformly Controlled Gates and Boolean functions with application to quantum memory circuits.arXiv preprint arXiv:2308.08539(2023)

    work page arXiv 2023

  2. [2]

    Srinivasan Arunachalam, Vlad Gheorghiu, Tomas Jochym-O’Connor, Michele Mosca, and Priyaa Varshinee Srinivasan. 2015. On the robustness of bucket brigade quantum RAM.New Journal of Physics17, 12 (2015), 123010

    work page 2015

  3. [3]

    Babbush, C

    Ryan Babbush, Craig Gidney, Dominic W. Berry, Nathan Wiebe, Jarrod McClean, Alexandru Paler, Austin Fowler, and Hartmut Neven. 2018. Encoding Electronic Spectra in Quantum Circuits with Linear T Complexity.Physical Review X8, 4 (Oct. 2018). https://doi.org/10.1103/physrevx.8.041015 Preprint Efficient Quantum State Preparation with Bucket Brigade QRAM 29

    work page doi:10.1103/physrevx.8.041015 2018

  4. [4]

    Charles H Bennett. 1989. Time/space trade-offs for reversible computation.SIAM J. Comput.18, 4 (1989), 766–776

    work page 1989

  5. [5]

    Anna Bernasconi, Alessandro Berti, Gianna Maria del Corso, and Alessandro Poggiali. 2024. Quantum Subroutine for Efficient Matrix Multiplication. IEEE Access12 (2024), 116274–116284. https://doi.org/10.1109/ACCESS.2024.3446176

    work page doi:10.1109/access.2024.3446176 2024

  6. [6]

    Anna Bernasconi, Alessandro Berti, Gianna M Del Corso, Riccardo Guidotti, and Alessandro Poggiali. 2024. Quantum subroutine for variance estimation: algorithmic design and applications.Quantum Machine Intelligence6, 2 (2024), 78

    work page 2024

  7. [7]

    Berry, Craig Gidney, Mario Motta, Jarrod R

    Dominic W. Berry, Craig Gidney, Mario Motta, Jarrod R. McClean, and Ryan Babbush. 2019. Qubitization of Arbitrary Basis Quantum Chemistry Leveraging Sparsity and Low Rank Factorization.Quantum3 (Dec. 2019), 208. https://doi.org/10.22331/q-2019-12-02-208

    work page doi:10.22331/q-2019-12-02-208 2019

  8. [8]

    Alessandro Berti, Anna Bernasconi, Gianna M Del Corso, and Riccardo Guidotti. 2024. The role of encodings and distance metrics for the quantum nearest neighbor.Quantum Machine Intelligence6, 2 (2024), 62

    work page 2024

  9. [9]

    Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, and Seth Lloyd. 2017. Quantum machine learning.Nature549, 7671 (2017), 195–202

    work page 2017

  10. [10]

    Yanlin Chen and Ronald de Wolf. 2023. Quantum Algorithms and Lower Bounds for Linear Regression with Norm Constraints. In50th International Colloquium on Automata, Languages, and Programming (ICALP 2023) (Leibniz International Proceedings in Informatics (LIPIcs), Vol. 261), Kousha Etessami, Uriel Feige, and Gabriele Puppis (Eds.). Schloss Dagstuhl – Leibn...

    work page doi:10.4230/lipics.icalp.2023.38 2023

  11. [11]

    2008.Computational geometry: algorithms and applications

    Mark De Berg, Otfried Cheong, Marc Van Kreveld, and Mark Overmars. 2008.Computational geometry: algorithms and applications. Springer

    work page 2008

  12. [12]

    Olivia Di Matteo, Vlad Gheorghiu, and Michele Mosca. 2020. Fault-tolerant resource estimation of quantum random-access memories.IEEE Transactions on Quantum Engineering1 (2020), 1–13

    work page 2020

  13. [13]

    On the practicality of quantum sieving algorithms for the shortest vector problem

    Joao F. Doriguello, George Giapitzakis, Alessandro Luongo, and Aditya Morolia. 2025. On the practicality of quantum sieving algorithms for the shortest vector problem. arXiv:2410.13759 [quant-ph] https://arxiv.org/abs/2410.13759

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  14. [14]

    Doriguello, Alessandro Luongo, Jinge Bao, Patrick Rebentrost, and Miklos Santha

    João F. Doriguello, Alessandro Luongo, Jinge Bao, Patrick Rebentrost, and Miklos Santha. 2022. Quantum Algorithm for Stochastic Optimal Stopping Problems with Applications in Finance. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. https://doi.org/10.4230/LIPICS.TQC.2022.2

    work page doi:10.4230/lipics.tqc.2022.2 2022

  15. [15]

    Initial state preparation for quantum chemistry on quantum computers

    Stepan Fomichev, Kasra Hejazi, Modjtaba Shokrian Zini, Matthew Kiser, Joana Fraxanet Morales, Pablo Antonio Moreno Casares, Alain Delgado, Joonsuk Huh, Arne-Christian Voigt, Jonathan E. Mueller, and Juan Miguel Arrazola. 2024. Initial state preparation for quantum chemistry on quantum computers. arXiv:2310.18410 [quant-ph] https://arxiv.org/abs/2310.18410

    work page arXiv 2024

  16. [16]

    Vittorio Giovannetti, Seth Lloyd, and Lorenzo Maccone. 2008. Architectures for a quantum random access memory.Physical Review A78, 5 (2008)

    work page 2008

  17. [17]

    Vittorio Giovannetti, Seth Lloyd, and Lorenzo Maccone. 2008. Quantum random access memory.Physical review letters100, 16 (2008), 160501

    work page 2008

  18. [18]

    2021.Practicality of quantum random access memory

    Connor T Hann. 2021.Practicality of quantum random access memory. Ph. D. Dissertation. Yale University

    work page 2021

  19. [19]

    Connor T Hann, Gideon Lee, SM Girvin, and Liang Jiang. 2021. Resilience of quantum random access memory to generic noise.Prx Quantum(2021)

    work page 2021

  20. [20]

    Samuel Jaques and Arthur G Rattew. 2023. Qram: A survey and critique.arXiv preprint arXiv:2305.10310(2023)

    work page arXiv 2023

  21. [21]

    Iordanis Kerenidis and Anupam Prakash. 2017. Quantum Recommendation Systems. In8th Innovations in Theoretical Computer Science Conference (ITCS 2017) (Leibniz International Proceedings in Informatics (LIPIcs), Vol. 67), Christos H. Papadimitriou (Ed.). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl, Germany, 49:1–49:21. https://doi.org/10.423...

    work page doi:10.4230/lipics.itcs.2017.49 2017

  22. [22]

    Seth Lloyd, Masoud Mohseni, and Patrick Rebentrost. 2014. Quantum principal component analysis.Nature Physics10, 9 (July 2014), 631–633. https://doi.org/10.1038/nphys3029

    work page doi:10.1038/nphys3029 2014

  23. [23]

    Guang Hao Low, Vadym Kliuchnikov, and Luke Schaeffer. 2024. Trading T gates for dirty qubits in state preparation and unitary synthesis.Quantum 8 (June 2024), 1375. https://doi.org/10.22331/q-2024-06-17-1375

    work page doi:10.22331/q-2024-06-17-1375 2024

  24. [24]

    Alessandro Luongo, Armando Bellante, et al. 2021. The quantumalgorithms. org project. InIEEE, International Conference on Quantum Computing and Engineering, QCE 2021, Workshop: Developing Effective Methodologies to Teach Quantum Information Science to Early-Stage Learners

    work page 2021

  25. [25]

    2010.Quantum computation and quantum information

    Michael A Nielsen and Isaac L Chuang. 2010.Quantum computation and quantum information. Cambridge university press

    work page 2010

  26. [26]

    Alexandru Paler, Oumarou Oumarou, and Robert Basmadjian. 2020. Parallelizing the queries in a bucket-brigade quantum random access memory. Phys. Rev. A102 (Sep 2020), 032608. Issue 3. https://doi.org/10.1103/PhysRevA.102.032608

    work page doi:10.1103/physreva.102.032608 2020

  27. [27]

    Daniel K Park, Francesco Petruccione, and June-Koo Kevin Rhee. 2019. Circuit-based quantum random access memory for classical data.Scientific reports9, 1 (2019), 3949

    work page 2019

  28. [28]

    Koustubh Phalak, Avimita Chatterjee, and Swaroop Ghosh. 2023. Quantum random access memory for dummies.Sensors23, 17 (2023), 7462

    work page 2023

  29. [29]

    2014.Quantum algorithms for linear algebra and machine learning

    Anupam Prakash. 2014.Quantum algorithms for linear algebra and machine learning. University of California, Berkeley

    work page 2014

  30. [30]

    Patrick Rebentrost, Alessandro Luongo, Samuel Bosch, and Seth Lloyd. 2022. Quantum computational finance: martingale asset pricing for incomplete markets. arXiv:2209.08867 [quant-ph] https://arxiv.org/abs/2209.08867

    work page arXiv 2022

  31. [31]

    Patrick Rebentrost, Masoud Mohseni, and Seth Lloyd. 2014. Quantum Support Vector Machine for Big Data Classification.Physical Review Letters 113, 13 (Sept. 2014). https://doi.org/10.1103/physrevlett.113.130503

    work page doi:10.1103/physrevlett.113.130503 2014

  32. [32]

    Maria Schuld and Francesco Petruccione. 2018. Supervised learning with quantum computers.Quantum science and technology17 (2018)

    work page 2018

  33. [33]

    Nathan Wiebe, Daniel Braun, and Seth Lloyd. 2012. Quantum Algorithm for Data Fitting.Physical Review Letters109, 5 (Aug. 2012). https: //doi.org/10.1103/physrevlett.109.050505

    work page doi:10.1103/physrevlett.109.050505 2012

  34. [34]

    Wootters and W.H

    W.K. Wootters and W.H. Zurek. 1982. A single quantum cannot be cloned.Nature299, 5886 (1982), 802–803

    work page 1982

  35. [35]

    Shifan Xu, Connor T Hann, Ben Foxman, Steven M Girvin, and Yongshan Ding. 2023. Systems architecture for quantum random access memory. In Proceedings of the 56th Annual IEEE/ACM International Symposium on Microarchitecture. 526–538. Preprint

    work page 2023