Pith. sign in

REVIEW 3 major objections 5 minor 1 cited by

AEQUAM: Accelerating Quantum Algorithm Validation through FPGA-Based Emulation

T0 review · 3 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read AEQUAM claims an FPGA toolchain that emulates quantum circuits up to six qubits on a low-cost Cyclone 10LP, scaling better in logic elements than most earlier FPGA emulators while supporting Clifford+T and rotational gates.

desk verdict Real FPGA emulation toolchain with an overreaching scalability claim that its own Section V-C3 contradicts; worth reviewing after re-scoping. read the letter →

arxiv 2506.01029 v1 pith:QUQZGIZH submitted 2025-06-01 quant-ph cs.SYeess.SY

Lorenzo Lagostina , Deborah Volpe , Maurizio Zamboni , Giovanna Turvani This is my paper
classification quant-phcs.SYeess.SY
keywords quantumcircuitemulationFPGAbutterflyselectionsparsegatematricesfixed-pointarithmeticSIMDwindowingalgorithmverification
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

AEQUAM is a toolchain that turns OpenQASM 2.0 circuits into a compact, RISC-style instruction set and then into a custom FPGA hardware emulator, aiming to make quantum-algorithm verification faster and cheaper than software simulation. The paper's central claim is that a sparsity-aware butterfly selection mechanism, which applies each gate only to the pairs of probability amplitudes that actually interact, lets the emulator fit six qubits in full-serial mode and five qubits in full-parallel mode on a small Intel Cyclone 10LP FPGA, with better logic-element scaling than most earlier FPGA emulators. A second claim is that a 20-bit fixed-point representation with nearest rounding keeps emulation error small while sharply cutting area, and that the architecture supports both Clifford+T gates (the standard discrete gate set) and rotational gates, unlike the closest sparse-emulator predecessor. The authors present this as a practical low-cost platform for debugging and teaching quantum algorithms, validated on standard benchmark circuits and against a reference state-vector simulator.

What carries the argument

The load-bearing mechanism is the butterfly-like couple-selection scheme. For an $N$-qubit state vector, applying a single-qubit gate to a target qubit splits the equivalent $2^N \times 2^N$ gate matrix into $2^{N-1}$ identical $2\times2$ kernels, each acting on one pair of probability amplitudes; the positions of those pairs follow an FFT-like butterfly pattern set by the target qubit. For controlled gates, half of the kernels become identity matrices, and those couples are skipped, eliminating redundant work and removing any need to build or store layer matrices. On top of this, the windowing mechanism shrinks the datapath count from $2^{N-1}$ to $2^{N-W-1}$ by processing $W$ windows of amplitude couples serially, so the user can interpolate between full-parallel speed and full-serial area, at the cost of doubling gate-execution time per increment of $W$.

What would settle it

A reader could re-synthesize AEQUAM and the cited emulators on one FPGA family with identical precision and synthesis settings; if AEQUAM no longer uses fewer logic elements at equal qubit counts, the scalability claim is a comparison artifact. A simpler check is to reproduce the reported synthesis numbers: the serial 6-qubit and parallel 5-qubit configurations must fit on the 24,624-LE Cyclone 10LP at the stated 80/109 MHz clocks and with roughly 11.7k and 21.0k LEs.

Watch

Extended reading notes

Core claim

The paper's central claim is that a quantum state vector can be evolved on an FPGA by processing only the interacting amplitude couples selected by a butterfly-style pattern, one gate at a time, instead of materializing layer matrices or multiplying full state vectors. On the authors' chosen device, an Intel Cyclone 10LP with roughly 24.6k logic elements, this yields a 6-qubit emulator in full-serial mode (11,702 LEs) and a 5-qubit emulator in full-parallel mode (20,993 LEs) at 20-bit fixed-point precision with nearest rounding. The authors compare against four published FPGA emulators and report that AEQUAM's logic-element curve is better than all but one, whose better scaling comes at the cost of supporting only X, CNOT, Toffoli, and Hadamard gates; AEQUAM instead covers Clifford+T and rotational gates, so it can run any generic circuit accepted by the compiler. They further claim that the fixed-point precision, chosen through their software models, keeps error small (maximum and average complex distances generally below 0.05 in their benchmarks) while the software model itself runs at least an order of magnitude faster than the reference state-vector simulator.

Load-bearing premise

The scalability comparison assumes that logic-element counts from different FPGA families, such as Cyclone 10LP LEs, Cyclone V and Arria 10 ALMs, and Stratix LCs, are directly comparable without normalizing for architecture, synthesis settings, or numerical precision.

Editorial extensions

If this is right

  • On the tested Cyclone 10LP part, full-serial emulation supports 6 qubits (11,702 LEs) and full-parallel supports 5 qubits (20,993 LEs), with windowing orders filling the area-time tradeoff between them.
  • The architecture executes Clifford+T and rotational gates, so any OpenQASM 2.0 circuit without measurement-conditioned branches can be emulated, unlike the closest sparse-emulator predecessor that stops at X, CNOT, Toffoli, and Hadamard.
  • Fixed-point 20-bit nearest representation keeps maximum and average complex amplitude errors generally below 0.05 on the tested circuits while using far fewer resources than floating-point datapaths.
  • The software model runs benchmark circuits at least an order of magnitude faster than the reference state-vector simulator, so the butterfly mechanism itself, independent of FPGA synthesis, already accelerates validation.
  • Because area grows exponentially with qubits as the state-vector size $2^N$, the practical ceiling on this FPGA class is around six to eight qubits, and larger qubit counts require external memory or larger devices.

Reading between the lines

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

  • A testable extension the authors leave implicit: sweep the windowing order $W$ at fixed qubit count on a larger FPGA to map the full area-time Pareto curve; the reported serial and parallel endpoints suggest intermediate $W$ values are the practical operating points for real circuits.
  • Because rotation angles are precomputed into a table at compile time, variational circuits with many distinct angles will exhaust the sine-cosine register file before the qubit limit; replacing the table with an on-chip trigonometric unit, which the authors list as future work, would remove that bottleneck.
  • If fixed-point error accumulates with circuit depth, the 20-bit recommendation will eventually fail on very deep circuits; the software models' precision sweep effectively turns bit width into a tunable parameter, so a user can choose the smallest width that keeps the maximum complex distance below a target threshold.
  • The toolchain currently ignores measurement and rejects measurement-conditioned branches, so the emulator certifies ideal state evolution rather than measurement-feedback behavior; the circuit-partitioning scheme sketched for future releases would extend it to those programs.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 5 minor

Summary. The paper introduces AEQUAM, an open-source FPGA-based toolchain for quantum circuit emulation. It compiles OpenQASM 2.0 into RISC-like instructions, provides Cython software models for selecting fixed-point number representations, and generates VHDL for a processor that applies gates to interacting amplitude pairs through a butterfly selection mechanism. The authors synthesize a 20-bit fixed-point configuration on an Intel Cyclone 10LP and report 6-qubit full-serial and 5-qubit full-parallel emulation, with windowed variants trading parallelism for area. They benchmark emulation accuracy against Qiskit using mqt-bench and public circuits, and compare resource usage with prior FPGA emulators.

Significance. If the resource-efficiency and scalability claims are supported, AEQUAM would be a useful low-cost platform for teaching and for validating small quantum circuits, with configurable precision and parallelism and support for both Clifford+T and rotational gates. The public GitHub repository, automated testbench scripts, and the systematic software-model study of numeric precision are concrete strengths that aid reproducibility. However, the headline scalability claim currently rests on a comparison that mixes non-commensurable FPGA resource units and precision choices, so the significance as stated is not yet established.

major comments (3)
  1. [Abstract; Section V-C3; Section VII] The central claim of "better scalability" is contradicted by the paper's own comparison. The abstract says the architecture "demonstrates better scalability than other state-of-the-art emulators," and Section VII claims "outperforming prior FPGA-based solutions in terms of resource efficiency." Yet Section V-C3 explicitly states that "the architecture proposed by [18] is the only one with better scalability than ours." Table 3 shows [18] reaching 9 qubits with 4019 LCs versus AEQUAM's 6 qubits with 11702 LEs (serial) and 5 qubits with 20993 LEs (parallel). The abstract and conclusion claims must either be qualified (e.g., "among emulators supporting rotational gates and without external memories") or the comparison must be revised.
  2. [Table 3; Figure 26; Section V-C3] The resource comparison shown in Table 3 and Figure 26 is not normalized across FPGA families or numerical precisions. Logic utilization is reported as LEs for Cyclone 10LP, ALMs for Cyclone V and Arria 10, and LCs for Stratix; these units are not directly comparable, and the precision ranges from 10-bit fixed point to 64-bit floating point. As a result, the "competitive" and "resource efficiency" statements in Sections V-C3 and VI are unsupported as written. The authors should report a normalized metric (e.g., area per complex amplitude, or area per amplitude-bit) or synthesize at least one earlier design with the same tool, device family, and precision.
  3. [Figure 26; Section V-C3] The scalability comparison uses only logic-element count versus qubit count and does not account for gate-set coverage, execution throughput, or memory architecture. Since [17] uses external memory and [18] supports only a restricted gate set (Pauli X, CNOT, Toffoli, Hadamard), the raw qubit-per-resource plot conflates architectural capability with scalability. A fair comparison should also report throughput (e.g., gates per second) and specify the supported gate set and whether on-chip state storage is used for each data point.
minor comments (5)
  1. [Figure 24] Figures 24(c) and 24(d) are referenced twice in the text, once for variation with Q and once for variation with W; the figure numbering and captions need correction.
  2. [Figure 26] The legend in Figure 26 lists references [14]-[17], while Table 3 compares AEQUAM with [15]-[18]; the reference numbering should be aligned.
  3. [Section III-D1] The sentence "It is also the address of the first state" appears twice in the description of the control unit.
  4. [Section V-A1] The phrase "opta-core" appears to be a typo for "octa-core".
  5. [References] References [13] and [21] are duplicate entries for the same OpenQASM paper; one should be removed or cross-referenced.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: AEQUAM's central results are synthesis measurements and external-benchmark validations, not self-referential derivations.

full rationale

AEQUAM's claims do not reduce to their inputs by construction. The butterfly selection mechanism is imported from [19], which is prior external work by Negovetic et al., and it is explicitly credited ('proposed for the first time in [19]') rather than being presented as a derived first-principles result; adopting an external mechanism is independent support, not circularity. The 20-bit fixed-point precision is selected from the authors' own software accuracy sweeps (Section V-A3, Figure 18), but the subsequent hardware results are new synthesis outcomes and simulation runs; the precision choice is design tuning, not a fitted parameter renamed as a prediction. Functional verification compares the hardware against Qiskit's state-vector simulator and mqt-bench circuits, i.e., external references. The only self-citation ([4], an optimization application paper sharing some authors) appears in a list of application references and carries no weight in the scalability or accuracy argument. The internal tension between the abstract's 'better scalability' and Section V-C3's statement that [18] is the only architecture with better scalability is a correctness and comparison-scoping defect, as is the LE-versus-ALM/LC metric mixing; neither is a circular inference. No circular step can be exhibited, so the appropriate score is 0.

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

The central claim rests on standard quantum simulation mathematics, the correctness of the adopted butterfly mechanism, and the comparability of synthesis metrics across FPGAs. There are no invented physical entities. The 20-bit precision is a fitted hardware parameter, and the benchmark methodology assumes representative circuits from mqt-bench plus public repositories.

free parameters (1)
  • Fixed-point precision (Nbits) = 20-bit
    Selected from a software-model sweep of 8 to 32 bits as the best accuracy-to-area compromise; not derived from first principles. The nearest rounding mode is chosen similarly.
assumptions (3)
  • standard math Quantum state evolution follows the layer-by-layer matrix-vector product (Eqs. 5 and 6).
    Standard textbook quantum mechanics; the emulator implements this product selectively via the butterfly mechanism.
  • domain assumption The butterfly couple-selection pattern from [19] correctly identifies all interacting amplitude pairs for each gate type, target qubit, and control mask.
    Adopted from prior work without re-derivation; if the pattern is wrong, the hardware computes the wrong state.
  • domain assumption OpenQASM 2.0 circuits are assumed ideal and noiseless, and unsupported constructs (measure, if) are ignored or rejected.
    The tool targets functional verification of ideal circuits, not noisy-device simulation.

how reviews work

0 comments
Cite this review

Pith. "Pith review of AEQUAM: Accelerating Quantum Algorithm Validation through FPGA-Based Emulation." pith.science (2026). https://pith.science/paper/QUQZGIZH

@misc{pith2026250601029,
  author       = {Pith},
  title        = {Pith review of: AEQUAM: Accelerating Quantum Algorithm Validation through FPGA-Based Emulation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QUQZGIZH}},
  note         = {Machine review of arXiv:2506.01029}
}
read the original abstract

This work presents AEQUAM (Area Efficient QUAntum eMulation), a toolchain that enables faster and more accessible quantum circuit verification. It consists of a compiler that translates OpenQASM 2.0 into RISC-like instructions, Cython software models for selecting number representations and simulating circuits, and a VHDL generator that produces RTL descriptions for FPGA-based hardware emulators. The architecture leverages a SIMD approach to parallelize computation and reduces complexity by exploiting the sparsity of quantum gate matrices. The VHDL generator allows customization of the number of emulated qubits and parallelization levels to meet user requirements. Synthesized on an Altera Cyclone 10LP FPGA with a 20-bit fixed-point representation and nearest-type approximation, the architecture demonstrates better scalability than other state-of-the-art emulators. Specifically, the emulator has been validated by exploiting the well consolidated benchmark of mqt bench framework.

Figures

Figures reproduced from arXiv: 2506.01029 by the authors.

Figure 1
Figure 1. FIGURE 1 [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. FIGURE 2: Quantum computing fundamentals. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. FIGURE 3: Q-sphere representation of a quantum state for a [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (22 more)
Figure 4
Figure 4. Figure 4: FIGURE 4: The butterfly-like mechanism for selecting interacting couples of probability amplitudes for each potential target [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: FIGURE 5: The butterfly-like mechanism for selecting in [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: FIGURE 6: RISC-like instruction format [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: FIGURE 7: Gates’ equivalences [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]
Figure 8
Figure 8. Figure 8: FIGURE 8: Compiler structure [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]
Figure 9
Figure 9. Figure 9: FIGURE 9: Architecture of the full parallel quantum emulator processor. [PITH_FULL_IMAGE:figures/full_fig_p011_9.png]
Figure 10
Figure 10. Figure 10: FIGURE 10: Top view emulator [PITH_FULL_IMAGE:figures/full_fig_p012_10.png]
Figure 11
Figure 11. Figure 11: FIGURE 11: Quantum emulator processor datapath. [PITH_FULL_IMAGE:figures/full_fig_p012_11.png]
Figure 12
Figure 12. Figure 12: FIGURE 12: AEQUAM windowing architecture. [PITH_FULL_IMAGE:figures/full_fig_p013_12.png]
Figure 13
Figure 13. Figure 13: FIGURE 13: The VirtLab board presented in [24]. [PITH_FULL_IMAGE:figures/full_fig_p013_13.png]
Figure 14
Figure 14. Figure 14: FIGURE 14: Double handshake protocol [PITH_FULL_IMAGE:figures/full_fig_p014_14.png]
Figure 15
Figure 15. Figure 15: FIGURE 15: Figures of merit to estimate the emulation quality as a function of the number of gates involved in the circuit ( [PITH_FULL_IMAGE:figures/full_fig_p015_15.png]
Figure 16
Figure 16. Figure 16: FIGURE 16: Figures of merit to estimate the emulation quality as a function of the number of gates involved in the circuit ( [PITH_FULL_IMAGE:figures/full_fig_p016_16.png]
Figure 17
Figure 17. Figure 17: FIGURE 17: Comparison of the emulation time required with the proposed approach implemented in software, state vector [PITH_FULL_IMAGE:figures/full_fig_p017_17.png]
Figure 18
Figure 18. Figure 18: FIGURE 18: Kullback Leibler Divergence (KLD) as a func [PITH_FULL_IMAGE:figures/full_fig_p017_18.png]
Figure 19
Figure 19. Figure 19: FIGURE 19: Waves of the simulation of a three-qubit bell state circuit emulation. In particular, the emulator initialization is [PITH_FULL_IMAGE:figures/full_fig_p018_19.png]
Figure 20
Figure 20. Figure 20: FIGURE 20: Waves of the simulation of a three-qubit bell state circuit emulation. In particular, the gate-by-gate circuit execution [PITH_FULL_IMAGE:figures/full_fig_p018_20.png]
Figure 21
Figure 21. Figure 21: FIGURE 21: Waves of the simulation of a three-qubit bell state circuit emulation. In particular, the final state vector acquisition [PITH_FULL_IMAGE:figures/full_fig_p019_21.png]
Figure 22
Figure 22. Figure 22: FIGURE 22: Probability distributions of two benchmark circuits. [PITH_FULL_IMAGE:figures/full_fig_p019_22.png]
Figure 23
Figure 23. Figure 23: FIGURE 23: Figures of merit — Helinger Fidelity (HF), Kullback Leibler Divergence (KLD), Maximum Complex Distance [PITH_FULL_IMAGE:figures/full_fig_p020_23.png]
Figure 24
Figure 24. Figure 24: FIGURE 24: Synthesis results obtained [PITH_FULL_IMAGE:figures/full_fig_p021_24.png]
Figure 25
Figure 25. Figure 25: FIGURE 25: Maximum operating frequency as a function [PITH_FULL_IMAGE:figures/full_fig_p022_25.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

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

  1. Classical Hardware Acceleration of Quantum Autoencoders for Real-Time Anomaly Detection in Collider Experiments

    cs.LG 2026-07 conditional novelty 6.0 of 10

    Quantum and hybrid quantum-classical autoencoders for LHC trigger anomaly detection are quantized and synthesized onto a single FPGA SLR with claimed sub-microsecond-to-few-microsecond latency at stated parity with cl...

Reference graph

Works this paper leans on

29 extracted references · 20 canonical work pages · cited by 1 Pith paper

  1. [19]

    Negovetic, M

    G. Negovetic, M. Perkowski, M. Lukac, and A. Buller, ‘‘Evolving quantum circuits and an fpga-based quantum computing emulator,’’ 2002. https: //pdxscholar.library.pdx.edu/ece_fac/191/

    work page 2002

  2. [18]

    Conceição and R

    C. Conceição and R. Reis, ‘‘Efficient emulation of quantum circuits on classical hardware,’’ in 2015 IEEE 6th Latin American Symposium on Circuits & Systems (LASCAS) , pp. 1–4, IEEE, 2015. https://doi.org/10. 1109/LASCAS.2015.7250404

    work page arXiv 2015

  3. [17]

    Mahmud, B

    N. Mahmud, B. Haase-Divine, A. Kuhnke, A. Rai, A. MacGillivray, and E. El-Araby, ‘‘Efficient computation techniques and hardware architectures for unitary transformations in support of quantum algorithm emulation,’’ Journal of Signal Processing Systems, vol. 92, pp. 1017–1037, 2020. https: //doi.org/10.1007/s11265-020-01569-4

    work page doi:10.1007/s11265-020-01569-4 2020

  4. [1]

    Zahedinejad and A

    E. Zahedinejad and A. Zaribafiyan, ‘‘Combinatorial optimization on gate model quantum computers: A survey,’’ 2017. https://doi.org/10.48550/ arXiv.1708.05294

    arXiv doi:10.48550/arxiv.1708.05294 2017

  5. [2]

    An introduction to variational quantum algorithms for combinatorial optimization problems

    C. Grange, M. Poss, and E. Bourreau, ‘‘An introduction to variational quantum algorithms on gate-based quantum computing for combinatorial optimization problems,’’ 2022. https://doi.org/10.48550/arxiv.2212.11734

    work page Pith review arXiv doi:10.48550/arxiv.2212.11734 2022

  6. [3]

    Liu and G

    Y . Liu and G. J. Koehler, ‘‘Using modifications to grover’s search algo- rithm for quantum global optimization,’’ European Journal of Operational Research, vol. 207, no. 2, pp. 620–632, 2010. https://doi.org/10.1016/j. ejor.2010.05.039

    doi:10.1016/j 2010

  7. [4]

    Giuffrida, D

    L. Giuffrida, D. V olpe, G. A. Cirillo, M. Zamboni, and G. Turvani, ‘‘En- gineering grover adaptive search: Exploring the degrees of freedom for efficient qubo solving,’’ IEEE Journal on Emerging and Selected Topics in Circuits and Systems, vol. 12, no. 3, pp. 614–623, 2022. https://doi.org/ 10.1109/JETCAS.2022.3202566

    work page arXiv 2022

  8. [5]

    Biamonte, P

    J. Biamonte, P . Wittek, N. Pancotti, P . Rebentrost, N. Wiebe, and S. Lloyd, ‘‘Quantum machine learning,’’ Nature, vol. 549, no. 7671, pp. 195–202,

    work page

Show all 29 references
  1. [6]

    Mishra, M

    N. Mishra, M. Kapil, H. Rakesh, A. Anand, N. Mishra, et al., ‘‘Quantum machine learning: A review and current status,’’ in Data Management, Analytics and Innovation , (Singapore), pp. 101–145, Springer Singapore,

  2. [7]

    Y . Cao, J. Romero, J. P . Olson, M. Degroote, P . D. Johnson, M. Kieferová, I. D. Kivlichan, T. Menke, B. Peropadre, N. P . D. Sawaya, S. Sim, L. V eis, and A. Aspuru-Guzik, ‘‘Quantum chemistry in the age of quantum com- puting,’’ Aug 2019. https://doi.org/10.1021/acs.chemrev.8b00803

    2019 doi

  3. [8]

    Pirnay, V

    N. Pirnay, V . Ulitzsch, F. Wilde, J. Eisert, and J.-P . Seifert, ‘‘A super- polynomial quantum advantage for combinatorial optimization problems,’’ arXiv preprint arXiv:2212.08678 , 2022. https://doi.org/10.48550/arXiv. 2212.08678. VOLUME 11, 2023 23 L. Lagostina et al.: AEQU...

    2022 doi arXiv

  4. [9]

    Ristè, M

    D. Ristè, M. P . Da Silva, C. A. Ryan, A. W. Cross, A. D. Córcoles, J. A. Smolin, J. M. Gambetta, J. M. Chow, and B. R. Johnson, ‘‘Demonstration of quantum advantage in machine learning,’’ npj Quantum Information , vol. 3, no. 1, p. 16, 2017. https://doi.org/10.1038/s41534-017-0017-3

    2017 doi

  5. [10]

    Y uan, ‘‘A quantum-computing advantage for chemistry,’’ Science, vol

    X. Y uan, ‘‘A quantum-computing advantage for chemistry,’’ Science, vol. 369, no. 6507, pp. 1054–1055, 2020. https://doi.org/10.1126/science. abd3880

    2020 doi

  6. [11]

    Li and Y

    H. Li and Y . Pang, ‘‘Fpga-accelerated quantum computing emulation and quantum key distillation,’’ IEEE Micro, vol. 41, no. 4, pp. 49–57, 2021

    2021

  7. [12]

    X.-C. Wu, S. Di, E. M. Dasgupta, F. Cappello, H. Finkel, Y . Alexeev, and F. T. Chong, ‘‘Full-state quantum circuit simulation by using data compression,’’ in Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis , p. 1–24...

    2019

  8. [14]

    M. A. Nielsen and I. L. Chuang, Quantum computation and quantum information. Cambridge ; New Y ork: Cambridge University Press, 10th anniversary ed ed., 2010

    2010

  9. [15]

    Pilch and J

    J. Pilch and J. Długopolski, ‘‘An fpga-based real quantum computer emu- lator,’’Journal of Computational Electronics , vol. 18, pp. 329–342, 2019. https://doi.org/10.1007/s10825-018-1287-5

    2019 doi

  10. [16]

    Mahmud and E

    N. Mahmud and E. El-Araby, ‘‘A scalable high-precision and high- throughput architecture for emulation of quantum algorithms,’’ in 2018 31st IEEE International System-on-Chip Conference (SOCC) , pp. 206– 212, IEEE, 2018. https://doi.org/10.1109/SOCC.2018.8618545

    2018

  11. [20]

    H. J. Nussbaumer and H. J. Nussbaumer, The fast F ourier transform . Springer, 1982. https://doi.org/10.1007/978-3-642-81897-4_4

    1982 doi

  12. [21]

    A. W. Cross, L. S. Bishop, J. A. Smolin, and J. M. Gambetta, ‘‘Open quantum assembly language,’’ 2017. https://doi.org/10.48550/ARXIV . 1707.03429

    2017 doi arXiv

  13. [22]

    Bakiri, C

    M. Bakiri, C. Guyeux, J.-F. Couchot, and A. K. Oudjida, ‘‘Survey on hardware implementation of random number generators on fpga: Theory and experimental analyses,’’ Computer Science Review , vol. 27, pp. 135– 153, 2018. https://doi.org/10.1016/j.cosrev.2018.01.002

    2018 doi

  14. [23]

    Koren, Computer arithmetic algorithms

    I. Koren, Computer arithmetic algorithms. CRC Press, 2018

    2018

  15. [24]

    Ruo Roch and M

    M. Ruo Roch and M. Martina, ‘‘Virtlab: A low-cost platform for electronics lab experiments,’’ Sensors, vol. 22, no. 13, 2022. https://doi.org/10.3390/ s22134840

    2022

  16. [25]

    Quetschlich, L

    N. Quetschlich, L. Burgholzer, and R. Wille, ‘‘Mqt bench: Benchmarking software and design automation tools for quantum computing,’’ Quantum, vol. 7, p. 1062, 2023. https://doi.org/10.22331/q-2023-07-20-1062

    2023 doi

  17. [26]

    ‘‘Intel Xeon Gold 6134 processor - product specification.’’ [Online] https://ark.intel.com/content/www/us/en/ark/products/120493/ intel-xeon-gold-6134-processor-24-75m-cache-3-20-ghz.html, accessed 25-October-2021

    2021

  18. [27]

    ‘‘qiskit.quantum_info.hellinger_fidelity — Qiskit 0.36.2 documentation.’’ https://tinyurl.com/mr27xdmc

  19. [28]

    Kullback and R

    S. Kullback and R. A. Leibler, ‘‘On Information and Sufficiency,’’ The Annals of Mathematical Statistics , vol. 22, pp. 79–86, Mar. 1951. https: //doi.org/10.1214/aoms/1177729694. LORENZO LAGOSTINA received the electronics and communications engineering from the Politec- nico ...

    1951

  20. [2017]

    https://doi.org/10.1038/nature23474

    doi

  21. [2021]

    https://doi.org/10.1007/978-981-15-5619-7_8

    doi

Pith tools

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