Pith. sign in

REVIEW 4 major objections 5 minor 25 references

Mera: Memory Reduction and Acceleration for Quantum Circuit Simulation via Redundancy Exploration

T0 review · 4 major / 5 minor · reviewed 2026-08-12 · deepseek-v4-flash

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

Pith's one-line read Compressed gate matrices lift quantum-circuit simulation from 17 to 34 qubits.

desk verdict Compressed gate-matrix formats are internally consistent, but the paper's headline claims rest on a cost model that standard simulators don't use, and the Hadamard method misses the standard fast transform. read the letter →

arxiv 2411.15332 v1 pith:XO7YPMXX submitted 2024-11-22 quant-ph cs.ET

Yuhong Song , Edwin Hsing-Mean Sha , Longshan Xu , Qingfeng Zhuge , Zili Shao This is my paper · ORCID
classification quant-phcs.ET
keywords quantumcircuitsimulationfull-statesparsegatecompressionHadamardmatrixtensorproductstatevectormemoryreductionredundancyexploration
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

This paper tries to establish that full-state quantum circuit simulation on a single workstation can handle far more qubits if the simulator stops storing the dense 2^n × 2^n operation matrix. For the large majority of quantum gates that are sparse, it stores only the non-zero entries in two compressed formats—DAX (value plus flat index) and DAS (value plus row-gap distances)—and defines tensor-product and matrix-vector operations directly on those formats, avoiding recompression. For the dense Hadamard gate it stores an entire $H^{{⊗n}}$ layer as a single magnitude 1/√N and computes signs on demand, which is the basis of its claim to reach 35 qubits for Hadamard-only multiplication and 34 qubits for sparse-gate circuits. The reported payoff is up to 6.9× end-to-end acceleration on a QNN neuron and 4.6× on Grover, compared with a dense-matrix implementation.

What carries the argument

The load-bearing objects are three representations. DAX stores each non-zero complex entry of a gate matrix together with its decimal index; DAS stores each non-zero entry with the count of zeros preceding it in its row and a row-end flag. Both carry tensor-product and matrix-vector routines directly: the result index in a tensor product is the binary concatenation of the two source indices, and gaps in DAS are combined by a three-case distance rule. The third object, RH, encodes $H^{{⊗n}}$ by the single magnitude 1/√N, with each entry's sign recovered by dividing the matrix into quarters whose lower-right block is negated, recursively, at O(n) cost per sign. What makes these structures carry the argument is Theorem 2: the zero ratio of a tensor product is never below the larger zero ratio of its factors, so a sparse circuit's operation matrix stays sparse and the structure stays compressed through a whole simulation step.

What would settle it

Compile the same QNN and Grover circuits into a conventional state-vector simulator that keeps only the 2^n amplitudes and applies gates one at a time, on the same 0.7 TB workstation; if it simulates more than 34 qubits, or if the paper's dense-matrix baseline can be replaced by this standard method at identical memory, the claimed gain is an artifact of the chosen baseline rather than a property of the compressed structures.

Watch

Extended reading notes

Core claim

On its own terms, the paper's central claim is that both sources of redundancy in the operation matrix—duplicated zeros and duplicated absolute values—can be removed from the representation without restoring them during computation. For a gate with zero ratio R, the tensor product with another matrix has zero ratio R(A⊗B)=R(A)+(1−R(A))R(B), which is at least the larger factor (Theorems 1 and 2), so a sparse circuit's operation matrix stays sparse. DAX and DAS encode exactly the non-zero entries and their positions, and the tensor-product and matrix-vector formulas use binary concatenation of indices or gap arithmetic to produce compressed results directly. For Hadamard, every entry of $H^{{⊗n}}$ has absolute value 1/√N, so the RH structure stores one number and computes signs by recursive quarter division; the logarithm-based sign routine needs O(n) sign calls per row. The experiments on a 0.7 TB workstation report that the dense-matrix baseline fits 17 qubits, DAX/DAS fit 34 qubits for sparse-gate circuits, RH fits 35 qubits for Hadamard MVM, and the hybrid RH+DAX implementation accelerates the QNN neuron up to 6.9× and Grover up to 4.6× at the qubit counts where the dense baseline still runs; the abstract's headline figure of 35 corresponds to the Hadamard-only case.

Load-bearing premise

All claims rest on the premise that full-state simulation must build a 2^n × 2^n operation matrix and multiply it into the state vector; if a simulator applies each gate to the 2^n-element state vector directly, the 17-to-34 qubit comparison does not transfer because the dense-matrix baseline itself is not a fair comparator.

Editorial extensions

If this is right

  • At a fixed memory of 0.7 TB, the test workstation's maximum operation-matrix size grows from 17 to 34 qubits for circuits of sparse gates, and Hadamard-only MVM runs at 35 qubits.
  • Because compression is structural rather than applied after the fact, the paper's reported MTP speedups (up to 1800.3×) and MVM speedups (up to 141.2×) come without a separate compression or decompression phase.
  • The RH representation means a layer of n Hadamard gates costs one stored value plus on-demand sign computation, so the memory cost of building superposition is no longer exponential in n.
  • Combining RH for Hadamard layers with DAX for sparse layers gives up to 6.9× end-to-end acceleration for the QNN neuron and up to 4.6× for Grover's algorithm against the dense-matrix implementation.
  • The QNN case is itself limited to 12 qubits in the paper because the dense RY gates in the encoding stage cannot be compressed by these structures.

Reading between the lines

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

  • The paper's 34-qubit figure is measured against a simulator that materializes the full operation matrix, which is not the design of standard state-vector simulators; a conventional gate-by-gate simulator keeping only the 2^n-element state vector would be a different baseline, and the paper does not compare against it.
  • If the same zero-skipping idea were applied directly to gate-by-gate state-vector updates, the memory saving would apply to the gate matrices only, not to the state vector, so total memory would scale with 2^n plus the compressed gate size; a testable extension is to port DAX/DAS into such a simulator and measure whether a 34-qubit advantage survives.
  • The RH sign pattern is essentially the Walsh–Hadamard transform structure, so the quarter-based, block-based, and logarithm-based tricks might extend to any Kronecker power of a 2×2 constant-magnitude matrix, giving a family of regularity-oriented compressed simulations for transforms such as the quantum Fourier transform.
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

4 major / 5 minor

Summary. The paper proposes two compressed data structures, DAX and DAS, for sparse quantum gate matrices, and a regularity-based structure, RH, for dense Hadamard gates, together with corresponding tensor-product (MTP) and matrix-vector multiplication (MVM) routines. The authors report that the compressed structures raise the maximum simulable qubit count from 17 to 34 or 35 on a 0.7 TB workstation and achieve up to 6.9× speedup on a QNN case study and 4.6× on Grover's algorithm. The mathematical derivations (Theorems 1-3, Algorithm 1) are self-contained and internally consistent, but the empirical evaluation compares against a 'Matrix' baseline that materializes the full 2^n × 2^n operation matrix at each time step, which is not how standard full-state simulators operate.

Significance. If the empirical claims were valid, the work would provide a practical way to extend full-state quantum circuit simulation on a single workstation by exploiting gate-matrix sparsity and Hadamard regularity. The paper also contributes parameter-free compressed representations and an explicit algorithm for the Hadamard transform without referencing the standard fast Walsh-Hadamard transform. However, the significance is substantially weakened because the baseline used in all experiments is a strawman: standard full-state simulators apply gates directly to the 2^n-element state vector with O(2^n) memory and O(2^n) time per gate, so the reported 'increase from 17 to 35 qubits' and the large speedups are artifacts of materializing the global matrix rather than genuine improvements over established simulation techniques.

major comments (4)
  1. [Abstract, Section IV-B, Figure 5] The central claim that the compressed structures 'increase the number of qubits from 17 to 35' is an artifact of the baseline. With 0.7 TB of memory, a standard state-vector simulator stores the 2^n amplitudes and applies each gate directly; for n = 35, the state-vector requires about 550 GB (2^35 × 16 bytes), which already fits in 0.7 TB without any compression. The 'Matrix' baseline that materializes the full 2^n × 2^n operation matrix is not representative of practical full-state simulation, so the memory improvement is not a real advance in simulable qubit count.
  2. [Section IV-B, Figures 6 and 7] The 1800.3× MTP and 141.2× MVM speedups are measured against the 'Matrix' method, which constructs and multiplies the dense global matrix. In standard full-state simulation, a single-qubit gate is applied to the state-vector in O(2^n) time by updating amplitude pairs; the DAX/DAS MVM over nonzeros of the global matrix also takes O(2^n) time for a single-qubit gate, so the reported speedups reflect avoiding the strawman's huge global-matrix operations, not an asymptotic improvement over conventional simulators.
  3. [Section III-B2, Property 2, Algorithm 1] The RH-MVM algorithm is stated to have complexity O(n · 2^{2n−2}), which is drastically worse than the standard fast Walsh-Hadamard transform, which applies H^⊗n to a state-vector in O(n · 2^n) time. The paper never cites or benchmarks against the fast Walsh-Hadamard transform, yet claims 'execution acceleration' for Hadamard-based circuits. This omission is load-bearing because the proposed method is asymptotically slower than a well-known classical algorithm, and the reported 2.3× speedup over 'Matrix' is again relative to the strawman baseline.
  4. [Section IV-D, Table III and IV] The maximum-qubit improvements are not demonstrated for end-to-end algorithm simulation. For the QNN neuron, the authors acknowledge that the maximum qubit remains 12 because the dense RY gates in stage 1 are the bottleneck; for Grover, the memory figures for 'RH-DAX' at 34 qubits are for the gate matrices (H^⊗n, oracle, Z0) and do not include end-to-end runtimes at those sizes. Thus the abstract's 'increase the number of qubits from 17 to 35' refers only to isolated gate blocks or matrix-storage capacity, not to the simulation of complete algorithms.
minor comments (5)
  1. [Abstract and Conclusion] The abstract states the qubit increase is 'from 17 to 35', while Section IV-B and the conclusion report 34 qubits for DAX/DAS and 35 qubits for RH. This inconsistency should be reconciled.
  2. [Section IV-C title] The title reads 'Evaluation for RH structures' but the text spells the gate as 'Hardamard' in several places; the correct spelling is 'Hadamard'.
  3. [Section IV-B] The text refers to 'Paul-X' in the list of implemented gates; this should be 'Pauli-X'.
  4. [Table III] The row labeled '1.0× 1638.4× 1638.4×' under memory usage is unclear: it lists speedups under the heading 'Memory Usage' columns, which is confusing because the columns are 'stage1 stage2 stage3' and the entries are memory sizes, not speedups. Please clarify the table structure.
  5. [Section II-B, Related Work] The paper should cite and compare against standard high-performance quantum circuit simulators (e.g., Qiskit, Qulacs, qHiPSTER) in the evaluation, since the proposed methods are intended for full-state simulation.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the core tensor-product sparsity identities and the H^⊗n sign recurrences are self-contained derivations, although the evaluation uses a strawman full-matrix baseline.

full rationale

The paper's load-bearing derivations are self-contained. Theorem 1 is a counting identity for zero entries under tensor products, R(A⊗B)=R(A)+(1−R(A))R(B), and Theorems 2-3 and Properties 1-2 follow algebraically from that definition; the DAX/DAS structures are sparse encodings whose memory savings are direct counts of stored nonzeros rather than fitted predictions. The RH structure is derived from the tensor-product sign pattern of H^⊗n, and Algorithm 1 implements that sign recurrence; no parameter is fitted and no uniqueness theorem is imported from prior work by these authors. The paper candidly self-limits its headline QNN claim in Section IV-D: 'the maximum number of qubits for this method is still 12. Because the dense RY gates in stage 1 become the bottleneck for qubits increasing.' The main weakness is benchmark validity, not circularity: all qubit-count and speedup numbers are measured against the paper's own 'Matrix' baseline that materializes the full 2^n×2^n operation matrix, which standard state-vector simulators do not form; that is a strawman-evaluation and correctness concern. No load-bearing self-citations appear, and no claimed prediction reduces by construction to its inputs.

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

No fitted parameters; block size b is selected by minimizing a derived complexity expression. Invented entities are data structures, not physical entities. The central derivations are self-contained mathematical identities, but they rest on domain assumptions about how full-state simulation should be organized and what workloads are representative.

assumptions (3)
  • ad hoc to paper The full 2^n x 2^n operation-matrix must be materialized in memory for each snapshot of a circuit.
    Invoked in Section I when claiming memory is the bottleneck ('an n-qubit quantum circuit produces an operation-matrix ... with the size of 2^n x 2^n') and used to set the 17-qubit baseline in experiments. Standard state-vector simulators avoid this.
  • domain assumption Benchmark circuits consisting of m identical gates are representative of quantum circuit simulation workloads.
    Section IV-B evaluates MTP/MVM on six gates with m identical copies; real circuits interleave diverse gates, and the QNN experiment itself shows a dense RY gate bottleneck that prevents qubit scaling.
  • ad hoc to paper The memory for a gate matrix can be counted without counting the state-vector when reporting maximum qubits.
    Section IV-C reports that RH 'can accommodate any qubits' because the matrix stores one value, but an n-qubit state-vector still takes 2^{n+4} bytes; at n=35 that is 512GB and no room remains for the compressed matrix or computation.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Mera: Memory Reduction and Acceleration for Quantum Circuit Simulation via Redundancy Exploration." pith.science (2026). https://pith.science/paper/XO7YPMXX

@misc{pith2026241115332,
  author       = {Pith},
  title        = {Pith review of: Mera: Memory Reduction and Acceleration for Quantum Circuit Simulation via Redundancy Exploration},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XO7YPMXX}},
  note         = {Machine review of arXiv:2411.15332}
}
read the original abstract

With the development of quantum computing, quantum processor demonstrates the potential supremacy in specific applications, such as Grovers database search and popular quantum neural networks (QNNs). For better calibrating the quantum algorithms and machines, quantum circuit simulation on classical computers becomes crucial. However, as the number of quantum bits (qubits) increases, the memory requirement grows exponentially. In order to reduce memory usage and accelerate simulation, we propose a multi-level optimization, namely Mera, by exploring memory and computation redundancy. First, for a large number of sparse quantum gates, we propose two compressed structures for low-level full-state simulation. The corresponding gate operations are designed for practical implementations, which are relieved from the longtime compression and decompression. Second, for the dense Hadamard gate, which is definitely used to construct the superposition, we design a customized structure for significant memory saving as a regularity-oriented simulation. Meanwhile, an ondemand amplitude updating process is optimized for execution acceleration. Experiments show that our compressed structures increase the number of qubits from 17 to 35, and achieve up to 6.9 times acceleration for QNN.

Figures

Figures reproduced from arXiv: 2411.15332 by the authors.

Figure 1
Figure 1. Two compressed structures: (a) DAX and (b) DAS. Utilize [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 3
Figure 3. The process of sign computation in matrix [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 4
Figure 4. Three sign computation methods of H⊗n . (a) quarter-based method; (b) block-based method; (c) logarithm-based method. Here, the number of qubit n = 5. the state-vector is conducted to obtain an amplitude of the next state-vector. For this non-optimized method, it requires O(22n) times sign computation. In order to optimize the sign computation of H⊗n, we further propose three methods. Method 1: quarter-based method.… view at source ↗
Figures from the paper (3 more)
Figure 6
Figure 6. Figure 6: The execution time comparison for MTP computation of [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: The execution time comparison for MVM computation of [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 8
Figure 8. Figure 8: Execution time comparison of MVM computation for dense [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

25 extracted references · 17 canonical work pages

  1. [1]

    Characterizing quantum supremacy in near-term devices,

    S. Boixo, S. V . Isakov, V . N. Smelyanskiy, R. Babbush, N. Ding, Z. Jiang, M. J. Bremner, J. M. Martinis, and H. Neven, “Characterizing quantum supremacy in near-term devices,”Nature Physics, vol. 14, no. 6, pp. 595–600, 2018

    2018

  2. [2]

    Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer,

    P. W. Shor, “Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer,”SIAM review, vol. 41, no. 2, pp. 303–332, 1999

    1999

  3. [3]

    A fast quantum mechanical algorithm for database search,

    L. K. Grover, “A fast quantum mechanical algorithm for database search,” in Proceedings of the twenty-eighth annual ACM symposium on Theory of computing , pp. 212–219, 1996

    work page 1996

  4. [4]

    A co-design framework of neural networks and quantum circuits towards quantum advantage,

    W. Jiang, J. Xiong, and Y . Shi, “A co-design framework of neural networks and quantum circuits towards quantum advantage,” Nature communications, vol. 12, no. 1, pp. 1–13, 2021

    work page 2021

  5. [5]

    Quantum neural network compression,

    Z. Hu, P. Dong, Z. Wang, Y . Lin, Y . Wang, and W. Jiang, “Quantum neural network compression,” in Proceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design , pp. 1–9, 2022

    work page 2022

  6. [6]

    List of qc simulators

    “List of qc simulators.” https://www.quantiki.org/wiki/list-qc-simulators, 2022

    work page 2022

  7. [7]

    Massively paral- lel quantum computer simulator,

    K. De Raedt, K. Michielsen, H. De Raedt, B. Trieu, G. Arnold, M. Richter, T. Lippert, H. Watanabe, and N. Ito, “Massively paral- lel quantum computer simulator,” Computer Physics Communications , vol. 176, no. 2, pp. 121–136, 2007

    work page 2007

  8. [8]

    5 petabyte simulation of a 45-qubit quantum circuit,

    T. H ¨aner and D. S. Steiger, “5 petabyte simulation of a 45-qubit quantum circuit,” in Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis , pp. 1– 10, 2017

    work page 2017

Show all 25 references
  1. [9]

    Quantum supremacy circuit simulation on sunway taihulight,

    R. Li, B. Wu, M. Ying, X. Sun, and G. Yang, “Quantum supremacy circuit simulation on sunway taihulight,” IEEE Transactions on Parallel and Distributed Systems , vol. 31, no. 4, pp. 805–816, 2019

    2019

  2. [10]

    Top500 list

    S. Erich, D. Jack, S. Horst, M. Martin, and H. Meuer, “Top500 list.” https://www.top500.org/lists/top500/2021/11/, 2021

    2021

  3. [11]

    qhipster: The quantum high performance software testing environment,

    M. Smelyanskiy, N. P. Sawaya, and A. Aspuru-Guzik, “qhipster: The quantum high performance software testing environment,”arXiv preprint arXiv:1601.07195, 2016

    2016 arXiv

  4. [12]

    Qx: A high-performance quantum computer simulation platform,

    N. Khammassi, I. Ashraf, X. Fu, C. G. Almudever, and K. Bertels, “Qx: A high-performance quantum computer simulation platform,” in Design, Automation & Test in Europe Conference & Exhibition (DATE), 2017 , pp. 464–469, IEEE, 2017

    2017

  5. [13]

    Quantum complexity theory,

    E. Bernstein and U. Vazirani, “Quantum complexity theory,” SIAM Journal on computing , vol. 26, no. 5, pp. 1411–1473, 1997

    1997

  6. [14]

    Simulation of low-depth quantum circuits as complex undirected graphical models,

    S. Boixo, S. V . Isakov, V . N. Smelyanskiy, and H. Neven, “Simulation of low-depth quantum circuits as complex undirected graphical models,” arXiv preprint arXiv:1712.05384 , 2017

    2017 arXiv

  7. [15]

    Breaking the 49-qubit barrier in the simulation of quantum circuits,

    E. Pednault, J. A. Gunnels, G. Nannicini, L. Horesh, T. Magerlein, E. Solomonik, and R. Wisnieff, “Breaking the 49-qubit barrier in the simulation of quantum circuits,” arXiv preprint arXiv:1710.05867 , vol. 15, 2017

    2017 arXiv

  8. [16]

    Validating quantum-classical programming models with tensor network simulations,

    A. McCaskey, E. Dumitrescu, M. Chen, D. Lyakh, and T. Humble, “Validating quantum-classical programming models with tensor network simulations,” PloS one , vol. 13, no. 12, p. e0206704, 2018

    2018

  9. [17]

    Classi- cal simulation of intermediate-size quantum circuits,

    J. Chen, F. Zhang, C. Huang, M. Newman, and Y . Shi, “Classi- cal simulation of intermediate-size quantum circuits,” arXiv preprint arXiv:1805.01450, 2018

    2018 arXiv

  10. [18]

    64-qubit quantum circuit simulation,

    Z.-Y . Chen, Q. Zhou, C. Xue, X. Yang, G.-C. Guo, and G.-P. Guo, “64-qubit quantum circuit simulation,” Science Bulletin, vol. 63, no. 15, pp. 964–971, 2018

    2018

  11. [19]

    Superconducting quantum circuits at the surface code threshold for fault tolerance,

    R. Barends, J. Kelly, A. Megrant, A. Veitia, D. Sank, E. Jeffrey, T. C. White, J. Mutus, A. G. Fowler, B. Campbell, et al. , “Superconducting quantum circuits at the surface code threshold for fault tolerance,” Nature, vol. 508, no. 7497, pp. 500–503, 2014

    2014

  12. [20]

    Statistical assertions for validating patterns and finding bugs in quantum programs,

    Y . Huang and M. Martonosi, “Statistical assertions for validating patterns and finding bugs in quantum programs,” in Proceedings of the 46th International Symposium on Computer Architecture , pp. 541–553, 2019

    2019

  13. [21]

    Full-state quantum circuit simulation by using data compression,

    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 , pp. 1–24, 2019

    2019

  14. [22]

    A method for the construction of minimum-redundancy codes,

    D. A. Huffman, “A method for the construction of minimum-redundancy codes,” Proceedings of the IRE , vol. 40, no. 9, pp. 1098–1101, 1952

    1952

  15. [23]

    Arithmetic coding for data compression,

    I. H. Witten, R. M. Neal, and J. G. Cleary, “Arithmetic coding for data compression,” Communications of the ACM , vol. 30, no. 6, pp. 520–540, 1987

    1987

  16. [24]

    Error-controlled lossy compression optimized for high compression ratios of scientific datasets,

    X. Liang, S. Di, D. Tao, S. Li, S. Li, H. Guo, Z. Chen, and F. Cappello, “Error-controlled lossy compression optimized for high compression ratios of scientific datasets,” in 2018 IEEE International Conference on Big Data (Big Data) , pp. 438–447, IEEE, 2018

    2018

  17. [25]

    Exploration of lossy compression for application-level checkpoint/restart,

    N. Sasaki, K. Sato, T. Endo, and S. Matsuoka, “Exploration of lossy compression for application-level checkpoint/restart,” in 2015 IEEE International Parallel and Distributed Processing Symposium , pp. 914– 922, IEEE, 2015

    2015

Pith tools

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