Pith. sign in

REVIEW 3 major objections 6 minor 1 cited by

ASDF: A Compiler for Qwerty, a Basis-Oriented Quantum Programming Language

T0 review · 3 major / 6 minor · reviewed 2026-08-10 · deepseek-v4-flash

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

Pith's one-line read ASDF, the first compiler for the basis-oriented Qwerty language, synthesizes quantum circuits whose fault-tolerant qubit and runtime costs match handwritten circuits from circuit-oriented compilers.

desk verdict First real compiler for a basis-oriented quantum language, with a reproducible artifact and credible cost parity; the predication cleanup is the one unproven load-bearing step. read the letter →

arxiv 2501.13262 v1 pith:TCNYBQ7W submitted 2025-01-22 quant-ph cs.PL

Austin J. Adams , Sharjeel Khan , Arjun S. Bhamra , Ryan R. Abusaada , Anthony M. Cabrera , Cameron C. Hoechst , Travis S. Humble , Jeffrey S. Young
show 1 more author
Thomas M. Conte
This is my paper · ORCID
classification quant-phcs.PL
keywords quantumprogramminglanguagebasis-orientedbasistranslationcircuitsynthesisfunctionspecializationadjointfunctionspredicatedfault-tolerantresourceestimation
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 argues that a quantum programming language built on basis translations rather than gates can be compiled into efficient circuits, removing the assumed tax of high-level abstraction. It introduces ASDF, the first compiler for the Qwerty language, and demonstrates on Bernstein-Vazirani, Deutsch-Jozsa, Grover's search, Simon's problem, and period finding that the generated circuits use comparable physical qubits and estimated runtimes on fault-tolerant hardware to handwritten circuits produced by established circuit-oriented compilers. The central objects are basis translations, operations that rewrite a state's amplitudes from one orthonormal basis to another while preserving them, and the compiler's treatment of adjoint and predicated forms of functions. If the claim holds, quantum programmers can reason in bases and reusable reversible functions without sacrificing resource efficiency.

What carries the argument

The load-bearing object is Qwerty IR, a quantum static-single-assignment dialect in a general extensible multi-level compiler-infrastructure framework, whose operations carry basis-translation, preparation, measurement, and function-adjoint or predication structure. It matters because it lets ASDF lower basis translations through a four-part pipeline: standardize, apply vector phases, permute standard-basis vectors, and destandardize. The second load-bearing mechanism is the predication cleanup, in which every renaming-based swap is recognized by a dataflow index analysis and then undone by one uncontrolled swap followed by one predicated swap, so the renaming is reversed exactly in the subspace orthogonal to the predicate.

What would settle it

Compile a reversible Qwerty function that performs a non-trivial qubit permutation through renaming, write it in predicated form, and compare ideal-state-vector simulation of the predicated function against the generated circuit on many random inputs orthogonal to the predicate; any deviation there would refute the predication cleanup.

Watch

Extended reading notes

Core claim

The discovery is that the basis translation, Qwerty's core primitive, is not an obstacle to compilation: any well-typed translation can be factored into a standardization step, a phase-adjustment step on standard-basis vectors, a permutation implemented by reversible-logic synthesis, and a destandardization step, with conditional versions used exactly where the two sides of the translation change primitive basis. Around this synthesis, ASDF builds a compiler with a quantum static-single-assignment IR that represents qubits flowing through basis-translation and measurement operations, so adjoint and predicated calls become structural rewrites rather than special cases. The result, the paper claims, is that a family of well-known algorithms written without any hand-composed gates compiles to circuits whose fault-tolerant resource estimates match those of handwritten circuits from the comparison compilers.

Load-bearing premise

The predication cleanup assumes the intraprocedural dataflow index analysis finds every renaming-based swap in every predicated block; if it misses one, the compiled function will modify states outside the predicate's span.

Editorial extensions

If this is right

  • Fault-tolerant resource estimates show Qwerty programs can target surface-code hardware at qubit and time costs comparable to hand-coded circuits, so the abstraction layer does not add a practical premium.
  • Aggressive inlining removes all callable intrinsics from the generated low-level representation on the five benchmarks, producing straight-line code suitable for restricted hardware profiles.
  • Basis translations with programmer-supplied phase factors synthesize directly to multi-controlled phase gates, making constructs such as diffuser steps one-line basis translations.
  • The span-equivalence type checker verifies basis translations in polynomial time, so exponential-sized bases such as 64-qubit tensor products remain checkable.
  • Adjoint and predicated function specializations are generated transitively through the call graph, so reusable reversible functions can be invoked backwards or under predicates without manual gate-level rewriting.

Reading between the lines

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

  • Editorial inference: if the resource parity holds beyond the five benchmarks, basis-oriented languages could let domain experts delegate circuit design entirely to the compiler, much as high-level synthesis did for classical hardware.
  • Editorial inference: the uncontrolled-swap-then-controlled-swap cleanup is a general way to make SSA-style renaming safe under predicates and could be extracted as a reusable pass for any quantum IR with renaming-based swaps.
  • Editorial inference: the factoring-based span-equivalence checker is a candidate algorithmic primitive for type systems of other basis-oriented quantum languages, since it avoids enumerating exponentially many basis vectors.
  • Editorial inference: a direct stress test of the predication cleanup, using random reversible functions composed with non-trivial predicates and ideal simulation of orthogonal input states, would harden the empirical case beyond the paper's benchmarks.
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 / 6 minor

Summary. The paper presents ASDF, an MLIR-based compiler for Qwerty, a basis-oriented quantum programming language. The compiler type-checks and lowers Qwerty programs to OpenQASM 3 or QIR by synthesizing circuits from basis translations, automatically generating adjoint and predicated function specializations, and applying gate-level optimizations. The empirical evaluation compares the fault-tolerant resource estimates of ASDF-generated circuits with handwritten circuits in Qiskit, Quipper, and Q# across five benchmarks (Bernstein-Vazirani, Deutsch-Jozsa, Grover, Simon, and period finding), reporting comparable costs. A publicly available Docker artifact reproduces the experiments.

Significance. If the correctness gaps identified below are closed, this is a significant systems contribution: ASDF is, to the authors' knowledge, the first compiler for the basis-oriented paradigm, and it demonstrates that a high-level basis-oriented language can be compiled to circuits with fault-tolerant resource costs competitive with handwritten circuit-oriented code. The paper's strengths include a reproducible Docker artifact (DOI provided), open-source code, a polynomial-time span-equivalence checker with a complexity proof, and a multi-compiler empirical comparison over standard algorithms. The main weaknesses are the absence of a correctness proof for the predication-cleanup mechanism and the lack of any benchmark exercising predicated functions, leaving a load-bearing part of the claimed 'full generally' specialization support unvalidated.

major comments (3)
  1. [§5.3, Fig. 5] The predication cleanup is not proven correct. The text describes an intraprocedural index analysis and a swap-unswap sequence, but gives no invariant or theorem showing that (a) the index map is a bijection that captures every renaming-based swap in the basic block, and (b) the emitted pair of one uncontrolled SWAP followed by one controlled SWAP realizes the intended predicate projector (the function on the predicate subspace and the identity on the orthogonal subspace). A missed swap or an incorrect index mapping would silently corrupt the orthogonal subspace while leaving resource counts unchanged. The evaluation in §8.3 does not include any benchmark that uses `b & f`, so this code path is not empirically validated by the reported experiments. Please add a formal invariant and correctness proof for the cleanup, or provide a systematic test harness that runs a variety of predicated Qwerty functions on a simulator and checks equivalence against the expected unitary.
  2. [§4.1, Appendix B] The span-equivalence check is given only a complexity proof. Theorem B.6 establishes the O(k^2 log k) runtime, but no theorem states that Algorithm B1 accepts exactly those basis translations for which the two bases have equal span. The text says correctness 'can be proved inductively' but the proof is not supplied. Because this check guards every basis translation, a false positive would allow invalid translations to be synthesized and a false negative would reject valid programs. Please provide the correctness theorem and its proof (or a detailed invariant and induction argument) for Algorithm B1.
  3. [§6.2, Appendix D] The function-specialization analysis lacks a correctness proof. Algorithm D5 is claimed to terminate because cyclic call graphs cannot be constructed in Qwerty, but this fact is not proven, and no theorem asserts that the computed set of specializations contains exactly the specializations required by the program. A missing specialization would cause a compilation or linking failure rather than a wrong circuit, but the paper's claim that ASDF handles adjoints and predication 'in full generality' (Section 5) needs a supporting argument or an alternative empirical demonstration that all predicating and adjointing patterns in the test suite are correctly specialized.
minor comments (6)
  1. [§5.3, Fig. 5] The red label 'UNSWAP' in the figure is a fragment and is potentially confusing; the caption correctly says the red gates are SWAP gates, so the label should be clarified or removed.
  2. [Throughout] The capitalization of the compiler name is inconsistent: 'ASDF' appears in the title and abstract while the body uses 'Asdf'. Please pick one form and use it consistently.
  3. [§5.3] The phrase 'assigning fresh indices to each non-stationary argument to the basic block' is unclear; the figure shows indices on non-stationary value edges, not on arguments. Please clarify what indices are assigned to what.
  4. [Appendix E, Algorithm E6] The algorithm does not explain the distinct roles of 'smallstd' and 'bigstd' inside the loop; a sentence or two of intuition would substantially improve readability.
  5. [§8.3] The Deutsch-Jozsa results are said to be 'virtually identical' to Bernstein-Vazirani and therefore omitted from the figures; please state this explicitly in the figure captions or provide the omitted data in an appendix so the reader does not wonder about the missing benchmark.
  6. [References] Reference [2] cites only the arXiv preprint of the Qwerty paper; if a published version exists, please cite it as well.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: ASDF's resource claims are checked against independent compilers and an external estimator; the only same-group reference (Qwerty [2]) defines the language being compiled rather than supplying the result.

full rationale

The paper's central claim is that circuits synthesized from Qwerty basis translations and function specializations have fault-tolerant costs comparable to hand-written circuit-oriented programs. Nothing in the derivation fits a parameter to the target metric or renames a fitted quantity as a prediction. Section 8.3 feeds assembly from all four language stacks into the Azure Quantum Resource Estimator after Qiskit -O3; the baseline implementations come from the Qiskit textbook, Quipper literature, and a Q# textbook, while the Qwerty programs derive from the same group's earlier language paper [2]. That self-reference is provenance for the language being compiled, not a load-bearing premise for the cost comparison, which is established externally. The span-equivalence checker (Section 4.1, Appendix B) is a constructive algorithm with lemmas (B.1-B.3) reducing to tensor-product facts; the basis-translation synthesizer (Section 6.3) decomposes translations into standardization, vector phases, and permutation using Tweedledum's external reversible synthesis. The predication cleanup (Section 5.3) is an informal correctness argument rather than a theorem, and the evaluation does not exercise predicated functions, but this is a soundness gap, not circularity: the swap-unswap construction is defined to implement the predicate semantics, not derived from the benchmarks or from a self-citation. No fitted input is called a prediction, no uniqueness theorem from the authors is imported, and no known result is merely renamed.

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

The central claim rests on standard linear algebra, the Qwerty language semantics, external synthesis libraries, and several unproved compiler transformations, most notably predication cleanup. There are no fitted numerical parameters. The largest unexamined risk is not overfitting but compiler-correctness corner cases, which would affect the meaning of the resource comparison.

assumptions (5)
  • domain assumption Basis translations with equal span are unitary and preserve amplitudes.
    Section 2.2 states this as the core semantics of Qwerty, inherited from the prior Qwerty paper [2]. The entire lowering pipeline depends on this.
  • standard math The factoring lemmas in Appendix B correctly decide when a basis literal can be decomposed as a tensor product.
    Algorithms B1-B4 use Lemmas B.1-B.3 to check span equivalence in polynomial time. The proofs are sketches and not machine-checked, so an error here would break type checking of basis translations.
  • domain assumption The swap-unswap cleanup for predicated basic blocks restores correctness in the subspace orthogonal to the predicate.
    Section 5.3 describes the procedure with a single example and an informal dataflow index argument. No theorem or comprehensive test suite is presented.
  • domain assumption The Tweedledum and mockturtle libraries synthesize correct reversible circuits for permutations and classical functions.
    Sections 6.3 and 6.4 delegate permutation synthesis to Tweedledum's transformation-based algorithm and classical synthesis to mockturtle; the paper assumes these external tools are correct.
  • standard math Standard gate decompositions (H, S, QFT, Selinger multi-controlled-iX) implement the intended basis changes and fault-tolerant cost model.
    Sections 6.3 and 6.5 use these decompositions; the Azure Quantum Resource Estimator's default model is accepted as the cost metric.

how reviews work

0 comments
Cite this review

Pith. "Pith review of ASDF: A Compiler for Qwerty, a Basis-Oriented Quantum Programming Language." pith.science (2026). https://pith.science/paper/TCNYBQ7W

@misc{pith2026250113262,
  author       = {Pith},
  title        = {Pith review of: ASDF: A Compiler for Qwerty, a Basis-Oriented Quantum Programming Language},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TCNYBQ7W}},
  note         = {Machine review of arXiv:2501.13262}
}
read the original abstract

Qwerty is a high-level quantum programming language built on bases and functions rather than circuits. This new paradigm introduces new challenges in compilation, namely synthesizing circuits from basis translations and automatically specializing adjoint or predicated forms of functions. This paper presents ASDF, an open-source compiler for Qwerty that answers these challenges in compiling basis-oriented languages. Enabled with a novel high-level quantum IR implemented in the MLIR framework, our compiler produces OpenQASM 3 or QIR for either simulation or execution on hardware. Our compiler is evaluated by comparing the fault-tolerant resource requirements of generated circuits with other compilers, finding that ASDF produces circuits with comparable cost to prior circuit-oriented compilers.

Figures

Figures reproduced from arXiv: 2501.13262 by the authors.

Figure 1
Figure 1. Bernstein–Vazirani expressed in Qwerty [2] Every basis in Qwerty is grounded in four primitive bases: std (the 𝑍 eigenbasis), pm (the 𝑋 eigenbasis), ij (the 𝑌 eigen￾basis), and fourier[N] (the N-qubit Fourier basis [34, §5.1]). Each primitive basis can be used in a Qwerty basis expression: the tensor product of two bases is written 𝑏1 + 𝑏2, and the 𝑁-fold tensor product is written 𝑏[𝑁]. Basis expressions may also co… view at source ↗
Figure 2
Figure 2. Compilation flow for our Qwerty compiler. Solid arrows are our work. infers N from the length of the captured secret bitstring on lines 5-6 in [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. An example of how Asdf type checks a Qwerty basis translation. AST optimizations simplify the IR produced, making the output amenable to subsequent IR-level optimizations. Addi￾tionally, optimizations require less engineering when done at the AST level — inside the compiler implementation, most of these optimizations are ∼5 lines of code at the AST level versus ∼50 lines at the MLIR level. 5 Qwerty IR After Asdf per… view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: An example of adjointing a basic block Another major difference between the AST and IR is that b1 >> b2 in Qwerty is a function value, whereas qbtrans in Qwerty IR is merely an op. Program semantics are pre￾served by wrapping the qbtrans in a lambda. The process for lo…
Figure 6
Figure 6. Figure 6: A summary of the structure of the circuit synthe￾sized by Asdf for a basis translation (read left to right) intractable because there are an enormous number of pos￾sible predicated specializations given different predicates. To avoid this, we run interprocedural datafl…
Figure 7
Figure 7. Figure 7: An example of basis translation circuit synthesis by Asdf involving both conditional and unconditional stan￾dardization translation 𝑏in >> 𝑏out begins by collecting two lists of pairs (prim, dim), where prim is a primitive basis and dim is the number of qubits, one lis…
Figure 8
Figure 8. Figure 8: An example of basis translation circuit synthesis involving an vector phase if the upper qubit is e.g. |+⟩ ∉ span(|−⟩). (In general, the erro￾neous circuit would behave as {'p','m'} + ij >> {'p', 'm'} + pm instead of the goal translation shown in [PITH_FULL_IMAGE:figu…
Figure 10
Figure 10. Figure 10: A relaxed peephole optimization performed on QCircuit-dialect IR 6.5 QCircuit IR Optimizations Before generating the output circuit from QCircuit IR, we run optimizations to remove redundancies left behind by ear￾lier systematic lowering. For instance, in [PITH_FULL_…
Figure 11
Figure 11. Figure 11: Runtime of benchmarks for each compiler for different oracle input sizes (lower is better) 16 32 64 128 Input size (bits) 0 25 50 75 100 125 150 Physical Kiloqubits Asdf (Our Work) Qiskit Quipper Q# (a) Bernstein–Vazirani 16 32 64 128 Input size (bits) 0 200 400 600 8…
Figure 12
Figure 12. Figure 12: Physical qubits used by each benchmark by each compiler for different oracle input sizes (lower is better) oracles are expressed as classical logic in both Quipper and Qwerty, but as gates in Qiskit and Q#. The Q# code is largely taken from Wojcieszyn [60]; the Qiskit…

Discussion (0). Continue with ORCID 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. MLIR for Quantum Beyond Gate Cancellation: Quantum Circuit Mapping Reimagined

    quant-ph 2026-07 accept novelty 6.0 of 10

    An MLIR-native A* qubit-routing pass outperforms QMAP and TKET on SWAP count and runtime and integrates into an open MLIR quantum compiler.

Reference graph

Works this paper leans on

68 extracted references · 33 canonical work pages · cited by 1 Pith paper

  1. [1]

    Ali Javadi Abhari, Arvin Faruque, Mohammad Javad Dousti, Lukas Svec, Oana Catu, Amlan Chakrabati, Chen-Fu Chiang, Seth Vander- wilt, John Black, Fred Chong, Margaret Martonosi, Martin Suchara, Ken Brown, Massoud Pedram, and Todd Brun. 2012. Scaffold: Quan- tum Programming Language. Technical Report. Princeton University Department of Computer Science. 43 pages

    work page 2012

  2. [2]

    Adams, Sharjeel Khan, Jeffrey S

    Austin J. Adams, Sharjeel Khan, Jeffrey S. Young, and Thomas M. Conte

    work page

  3. [3]

    QIR Alliance. 2022. The QIR Alliance. https://www.qir-alliance.org/ alliance/

    work page 2022

  4. [4]

    Sheldon Axler. 2023. Linear Algebra Done Right (fourth edition ed.). Springer International Publishing

    work page 2023

  5. [5]

    Charles H. Bennett. 1989. Time/Space Trade-Offs for Reversible Computation. SIAM J. Comput. 18, 4 (Aug. 1989), 766–776. https: //doi.org/10.1137/0218053

    doi:10.1137/0218053 1989

  6. [6]

    Ethan Bernstein and Umesh Vazirani. 1993. Quantum complexity theory. In Proceedings of the twenty-fifth annual ACM symposium on Theory of Computing (STOC ’93) . Association for Computing Machin- ery, New York, NY, USA, 11–20.https://doi.org/10.1145/167088.167097

    arXiv 1993

  7. [7]

    Xiaoning Bian. 2020. quipper-qasm: Flatten Quipper ASCII format circuit into a list of gates. https://github.com/onestruggler/quipper- qasm/

    work page 2020

  8. [8]

    Sonia Lopez Bravo. 2024. QIR Target Profile Types - Azure Quan- tum. Microsoft. https://learn.microsoft.com/en-us/azure/quantum/ quantum-computing-target-profiles

    work page 2024

Show all 68 references
  1. [9]

    Bishop, Steven Heidel, Colm A

    Andrew Cross, Ali Javadi-Abhari, Thomas Alexander, Niel De Beau- drap, Lev S. Bishop, Steven Heidel, Colm A. Ryan, Prasahnt Sivarajah, John Smolin, Jay M. Gambetta, and Blake R. Johnson. 2022. Open- QASM 3: A Broader and Deeper Quantum Assembly Language. ACM Transactions on Qu...

    2022 doi

  2. [10]

    Cross, Lev S

    Andrew W. Cross, Lev S. Bishop, John A. Smolin, and Jay M. Gambetta

  3. [11]

    David Deutsch and Richard Jozsa. 1997. Rapid solution of problems by quantum computation. Proceedings of the Royal Society of London. Series A: Mathematical and Physical Sciences 439, 1907 (Jan. 1997), 553–558. https://doi.org/10.1098/rspa.1992.0167

    1997

  4. [12]

    S. D. Fallek, C. D. Herold, B. J. McMahon, K. M. Maller, K. R. Brown, and J. M. Amini. 2016. Transport implementation of the Bernstein–Vazirani algorithm with ion qubits. New Journal of Physics 18, 8 (Aug. 2016), 083030. https://doi.org/10.1088/1367-2630/18/8/083030

    2016 doi

  5. [13]

    Python Software Foundation. 2023. ast – Abstract Syntax Trees. https: //docs.python.org/3/library/ast.html

    2023

  6. [14]

    Fowler, Matteo Mariantoni, John M

    Austin G. Fowler, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland. 2012. Surface codes: Towards practical large-scale quantum computation. Physical Review A 86, 3 (Sept. 2012), 032324. https: //doi.org/10.1103/PhysRevA.86.032324

    2012 doi

  7. [15]

    Green, Peter LeFanu Lumsdaine, Neil J

    Alexander S. Green, Peter LeFanu Lumsdaine, Neil J. Ross, Peter Selinger, and Benoît Valiron. 2013. An Introduction to Quantum Pro- gramming in Quipper. In Reversible Computation, Gerhard W. Dueck and D. Michael Miller (Eds.). Springer, Berlin, Heidelberg, 110–124. https://doi...

    2013 doi

  8. [16]

    Green, Peter LeFanu Lumsdaine, Neil J

    Alexander S. Green, Peter LeFanu Lumsdaine, Neil J. Ross, Peter Selinger, and Benoît Valiron. 2013. Quipper: a scalable quantum pro- gramming language. In Proceedings of the 34th ACM SIGPLAN Confer- ence on Programming Language Design and Implementation (PLDI ’13) . Associatio...

    2013

  9. [17]

    Lov K. Grover. 1996. A fast quantum mechanical algorithm for database search. In Proceedings of the twenty-eighth annual ACM symposium on Theory of Computing (STOC ’96) . Association for Computing Machin- ery, New York, NY, USA, 212–219. https://doi.org/10.1145/237814. 237866

    1996 doi

  10. [18]

    Lov K. Grover. 1997. Quantum Mechanics Helps in Searching for a Needle in a Haystack. Physical Review Letters 79, 2 (July 1997), 325–328. https://doi.org/10.1103/PhysRevLett.79.325

    1997 doi

  11. [19]

    Healy, Reza Jokar, Soolu Thomas, Vincent R

    Michael B. Healy, Reza Jokar, Soolu Thomas, Vincent R. Pascuzzi, Kit Barton, Thomas A. Alexander, Roy Elkabetz, Brian C. Donovan, Hiroshi Horii, and Marius Hillenbrand. 2024. Design and architecture of the IBM Quantum Engine Compiler. https://doi.org/10.48550/arXiv. 2408.06469

    2024 doi arXiv

  12. [20]

    Bettina Heim. 2022. QIR: Callables. https://github.com/qir-alliance/ qir-spec/blob/8b75546ad25a5bb243edf6fab80bd356856a7b24/ specification/v0.1/2_Callables.md

    2022

  13. [21]

    Bettina Heim. 2022. QIR Specification. https://github.com/qir- alliance/qir-spec

    2022

  14. [22]

    David Ittah, Ali Asadi, Erick Ochoa Lopez, Sergei Mironov, Samuel Banning, Romain Moyard, Mai Jacob Peng, and Josh Izaac. 2024. Cat- alyst: a Python JIT compiler for auto-differentiable hybrid quantum programs. Journal of Open Source Software 9, 99 (July 2024), 6720. https://d...

    2024 doi

  15. [23]

    David Ittah, Thomas Häner, Vadym Kliuchnikov, and Torsten Hoefler

  16. [24]

    Chong, and Margaret Martonosi

    Ali JavadiAbhari, Shruti Patil, Daniel Kudrow, Jeff Heckey, Alexey Lvov, Frederic T. Chong, and Margaret Martonosi. 2014. ScaffCC: a framework for compilation and analysis of quantum computing programs. In Proceedings of the 11th ACM Conference on Computing Frontiers (CF ’14)....

    2014

  17. [25]

    Chris Lattner and Vikram Adve. 2004. LLVM: A Compilation Frame- work for Lifelong Program Analysis & Transformation. In Proceedings of the international symposium on Code generation and optimization: feedback-directed and runtime optimization (CGO ’04) . IEEE Computer Society, USA, 75

    2004

  18. [26]

    Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasi- lache, and Oleksandr Zinenko. 2021. MLIR: Scaling Compiler In- frastructure for Domain Specific Computation. In 2021 IEEE/ACM International Sy...

    2021

  19. [27]

    Ji Liu, Luciano Bello, and Huiyang Zhou. 2021. Relaxed Peephole Optimization: A Novel Compiler Optimization for Quantum Circuits. In 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO) . 301–314. https://doi.org/10.1109/CGO51591. 2021.9370310

    2021

  20. [28]

    Thomas Lubinski, Cassandra Granade, Amos Anderson, Alan Geller, Martin Roetteler, Andrei Petrenko, and Bettina Heim. 2022. Advanc- ing hybrid quantum–classical computation with real-time execution. Frontiers in Physics 10 (2022), 940293. https://www.frontiersin.org/ articles/1...

    2022

  21. [30]

    McCaskey, Dmitry I

    Alexander J. McCaskey, Dmitry I. Lyakh, Eugene F. Dumitrescu, Sarah S. Powers, and Travis S. Humble. 2020. XACC: a system-level software infrastructure for heterogeneous quantum–classical com- puting. Quantum Science and Technology 5, 2 (Feb. 2020), 024002. https://doi.org/10....

    2020 doi

  22. [31]

    Giulia Meuli, Mathias Soeken, Earl Campbell, Martin Roetteler, and Giovanni de Micheli. 2019. The Role of Multiplicative Complex- ity in Compiling Low T-count Oracle Circuits. In 2019 IEEE/ACM International Conference on Computer-Aided Design (ICCAD) . 1–8. https://doi.org/10....

    2019

  23. [32]

    Microsoft. 2024. Azure Quantum Development Kit. https://github.com/ microsoft/qsharp

    2024

  24. [33]

    Michael Miller, Dmitri Maslov, and Gerhard W

    D. Michael Miller, Dmitri Maslov, and Gerhard W. Dueck. 2003. A transformation based algorithm for reversible logic synthesis. In Pro- ceedings of the 40th annual Design Automation Conference (DAC ’03) . Association for Computing Machinery, New York, NY, USA, 318–323. https://...

    2003

  25. [34]

    Nielsen and Isaac L

    Michael A. Nielsen and Isaac L. Chuang. 2010. Quantum Computation and Quantum Information: 10th Anniversary Edition (1st edition ed.). Cambridge University Press, Cambridge ; New York

    2010

  26. [35]

    Jennifer Paykin, Robert Rand, and Steve Zdancewic. 2017. QWIRE: a core language for quantum circuits. ACM SIGPLAN Notices 52, 1 (Jan. 2017), 846–858. https://doi.org/10.1145/3093333.3009894

    2017

  27. [36]

    Anurudh Peduri, Siddharth Bhat, and Tobias Grosser. 2022. QSSA: an SSA-based IR for Quantum computing. In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction (CC 2022). Association for Computing Machinery, New York, NY, USA, 2–14. https://doi....

    2022

  28. [37]

    Young, and Thomas M

    Will Powell, Jason Riedy, Jeffrey S. Young, and Thomas M. Conte

  29. [38]

    Qiskit contributors. 2023. Qiskit: An Open-source Framework for Quantum Computing. https://doi.org/10.5281/zenodo.2573505

    2023 doi

  30. [39]

    River Riddle and Matthias Springer. 2021. Writing DataFlow Analyses in MLIR. https://mlir.llvm.org/docs/Tutorials/DataFlowAnalysis/

    2021

  31. [40]

    Bruno Schmitt and Giovanni De Micheli. 2022. tweedledum: A Com- piler Companion for Quantum Computing. In2022 Design, Automation & Test in Europe Conference & Exhibition (DATE) . IEEE, Antwerp, Bel- gium, 7–12. https://doi.org/10.23919/DATE54114.2022.9774510

    2022

  32. [41]

    Bruno Schmitt, Ali Javadi-Abhari, and Giovanni De Micheli. 2021. Compilation flow for classically defined quantum operations. In 2021 Design, Automation & Test in Europe Conference & Exhibition (DATE) . 964–967. https://doi.org/10.23919/DATE51398.2021.9474163

    2021

  33. [42]

    Peter Selinger. 2013. Quantum circuits of T-depth one. Physical Review A 87, 4 (April 2013), 042302. https://doi.org/10.1103/PhysRevA. 87.042302

    2013 doi

  34. [43]

    Peter Selinger and Benoit Valiron. 2006. A lambda calculus for quan- tum computation with classical control. Mathematical Structures in Computer Science 16, 3 (June 2006), 527–552. https://doi.org/10.1017/ S0960129506005238

    2006

  35. [44]

    Shende, S.S

    V.V. Shende, S.S. Bullock, and I.L. Markov. 2006. Synthesis of quantum- logic circuits. IEEE Transactions on Computer-Aided Design of In- tegrated Circuits and Systems 25, 6 (June 2006), 1000–1010. https: //doi.org/10.1109/TCAD.2005.855930

    2006

  36. [45]

    Safat Siddiqui, Mohammed Jahirul Islam, and Omar Shehab. 2014. Five Quantum Algorithms Using Quipper. https://doi.org/10.48550/arXiv. 1406.4481

    2014 doi arXiv

  37. [46]

    D.R. Simon. 1994. On the power of quantum computation. In Pro- ceedings 35th Annual Symposium on Foundations of Computer Science . 116–123. https://doi.org/10.1109/SFCS.1994.365701

    1994

  38. [47]

    Daniel R. Simon. 1997. On the Power of Quantum Computation. SIAM J. Comput. 26, 5 (Oct. 1997), 1474–1483. https://doi.org/10.1137/ S0097539796298637

    1997

  39. [48]

    Kartik Singhal, Kesha Hietala, Sarah Marshall, and Robert Rand. 2022. Q# as a Quantum Algorithmic Language. http://arxiv.org/abs/2206. 03532

    2022

  40. [49]

    Smith, Michael J

    Robert S. Smith, Michael J. Curtis, and William J. Zeng. 2017. A Practical Quantum Instruction Set Architecture . Technical Report arXiv:1608.03355. arXiv. http://arxiv.org/abs/1608.03355

    2017 arXiv

  41. [50]

    Dueck, and D

    Mathias Soeken, Gerhard W. Dueck, and D. Michael Miller. 2016. A Fast Symbolic Transformation Based Algorithm for Reversible Logic Synthesis. In Reversible Computation, Simon Devitt and Ivan Lanese (Eds.). Springer International Publishing, Cham, 307–321. https://doi. org/10.1...

    2016 doi

  42. [51]

    Mathias Soeken and Mariia Mykhailova. 2022. Automatic oracle generation in microsoft’s quantum development kit using QIR and LLVM passes. In Proceedings of the 59th ACM/IEEE Design Automa- tion Conference (San Francisco, California) (DAC ’22). Association for Computing Machine...

    2022

  43. [52]

    Mathias Soeken, Heinz Riener, Winston Haaswijk, Eleonora Testa, Bruno Schmitt, Giulia Meuli, Fereshte Mozafari, Siang-Yun Lee, Alessandro Tempia Calvino, Dewmini Sudara Marakkalage, and Gio- vanni De Micheli. 2022. The EPFL Logic Synthesis Libraries. http: //arxiv.org/abs/1805.05121

    2022 arXiv

  44. [53]

    Krysta Svore, Alan Geller, Matthias Troyer, John Azariah, Christo- pher Granade, Bettina Heim, Vadym Kliuchnikov, Mariia Mykhailova, Andres Paz, and Martin Roetteler. 2018. Q#: Enabling Scalable Quan- tum Computing and Development with a High-level DSL. In Pro- ceedings of the...

    2018

  45. [54]

    Eduardo González Sánchez and Bradben. 2024. Q# Specialization declarations. https://learn.microsoft.com/en-us/azure/quantum/user- guide/language/programstructure/specializationdeclarations

    2024

  46. [55]

    The CUDA-Q development team. 2024. CUDA-Q. https://github.com/ NVIDIA/cuda-quantum

    2024

  47. [56]

    Philippe Tillet, H. T. Kung, and David Cox. 2019. Triton: an inter- mediate language and compiler for tiled neural network computa- tions. In Proceedings of the 3rd ACM SIGPLAN International Work- shop on Machine Learning and Programming Languages (MAPL 2019) . Association for...

    2019

  48. [57]

    Wim van Dam, Mariia Mykhailova, and Mathias Soeken. 2023. Us- ing Azure Quantum Resource Estimator for Assessing Performance of Fault Tolerant Quantum Computation. In Proceedings of the SC ’23 Workshops of The International Conference on High Performance Computing, Network, St...

    2023

  49. [58]

    Stefan Wernli and Ian Davis. 2024. QIR Runner. https://github.com/qir- alliance/qir-runner

    2024

  50. [59]

    Stefan Wernli and Bettina Heim. 2022. QIR Specification. https://github.com/qir-alliance/qir-spec/blob/11db5f743d637f/ specification/under_development/profiles/Base_Profile.md

    2022

  51. [60]

    Filip Wojcieszyn. 2022. Introduction to Quantum Computing with Q# and QDK. Springer International Publishing, Cham. https://doi.org/ 10.1007/978-3-030-99379-5

    2022 doi

  52. [61]

    Cabrera, and Travis S

    Elaine Wong, Vicente Leyton Ortega, Daniel Claudino, Seth Johnson, Sharmin Afrose, Meenambika Gowrishankar, Anthony M. Cabrera, and Travis S. Humble. 2024. A Cross-Platform Execution Engine for the Quantum Intermediate Representation. https://doi.org/10.48550/ arXiv.2404.14299...

    2024 doi

  53. [62]

    Wootton, Francis Harkins, Nicholas T

    James R. Wootton, Francis Harkins, Nicholas T. Bronn, Almudena Car- rera Vazquez, Anna Phan, and Abraham T. Asfaw. 2021. Teaching quantum computing with an interactive textbook. In 2021 IEEE Inter- national Conference on Quantum Computing and Engineering (QCE) . 385–391. https...

    2021

  54. [63]

    Young, Jason Riedy, Thomas M

    Jeffrey S. Young, Jason Riedy, Thomas M. Conte, Vivek Sarkar, Prasanth Chatarasi, and Sriseshan Srikanth. 2019. Experimental Insights from the Rogues Gallery. In 2019 IEEE International Conference on Rebooting Computing (ICRC). 1–8. https://doi.org/10.1109/ICRC.2019.8914707

    2019

  55. [64]

    Charles Yuan, Christopher McNally, and Michael Carbin. 2022. Twist: sound reasoning for purity and entanglement in Quantum programs. Proceedings of the ACM on Programming Languages 6, POPL (Jan. 2022), 30:1–30:32. https://doi.org/10.1145/3498691

    2022 doi

  56. [65]

    Conte, Richard Vuduc, and Vivek Sarkar

    Tong Zhou, Jun Shirako, Anirudh Jain, Sriseshan Srikanth, Thomas M. Conte, Richard Vuduc, and Vivek Sarkar. 2020. Intrepydd: performance, productivity, and portability for data science application kernels. In Proceedings of the 2020 ACM SIGPLAN International Symposium on New I...

    2020

  57. [2017]

    Technical Report

    Open Quantum Assembly Language . Technical Report. arXiv. http://arxiv.org/abs/1707.03429

    arXiv

  58. [2019]

    In Practice and Experience in Advanced Research Computing 2019: Rise of the Machines (learning) (PEARC ’19)

    Wrangling Rogues: A Case Study on Managing Experimental Post-Moore Architectures. In Practice and Experience in Advanced Research Computing 2019: Rise of the Machines (learning) (PEARC ’19) . Association for Computing Machinery, New York, NY, USA, 1–8.https: //doi.org/10.1145/...

    2019

  59. [2022]

    ACM Transactions on Quantum Com- puting 3, 3 (July 2022), 14:1–14:32

    QIRO: A Static Single Assignment-based Quantum Program Representation for Optimization. ACM Transactions on Quantum Com- puting 3, 3 (July 2022), 14:1–14:32. https://doi.org/10.1145/3491247

    2022 doi

  60. [2024]

    http://arxiv.org/abs/2404.12603

    Qwerty: A Basis-Oriented Quantum Programming Language. http://arxiv.org/abs/2404.12603

    arXiv

Pith tools

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