Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

Lost for Words: A Quantum Computing Language for Dissipative Systems

Ian Richard C Buckley

Published Jul 24, 2026• 0 citations
Publisher

Abstract

Every major quantum programming language restricts to unitary operations and Hermitian Hamiltonians. This is understandable: unitarity is tractable, elegant, and sufficient for standard gate-model quantum computing. But real quantum systems are open, dissipative, and non-Hermitian. By refusing to engage with loss, the field is in a bind -- unable to express PT-symmetric computation, Lindblad dynamics, exceptional-point algorithms, or even the classical limit of quantum mechanics. We identify the missing primitive: BIND (the Frobenius comultiplication delta: A -> A tensor A), and the missing parameter: beta (the semiring grade interpolating between tropical, quantum, and PT-symmetric regimes). The Raven ISA is the minimal non-unitary extension of the Heunen et al. phase language that adds these two ingredients. It implements five computational advantages unavailable to unitary languages, and subsumes all existing quantum programming languages as the beta = i special case. It is time to find BIND.

DOI
10.5281/zenodo.21500662

Related papers

Raven on Existing Hardware: Simulating PT-Symmetric Quantum Dynamics via Hybrid Classical-Quantum Reweighting

Ian Richard C Buckley

The Raven ISA tier (β∈ℂ, PT-symmetric) is shown to be accessible on any existing quantum computer via a hybrid classical-quantum protocol: standard unitary circuits supply the imaginary-β quantum phases, while classical post-measurement reweighting by Boltzmann factors e^(−σE_k) supplies the real-β dissipation. The composite estimator reconstructs the complex-β partition function Z(σ+it) with no additional qubits, no postselection overhead, and gate cost identical to a standard Meld circuit. Three application classes are demonstrated: RavenRank (dissipation-weighted ranking), PT-symmetric eigensolvers for non-Hermitian matrices, and exceptional-point search with sub-Grover query complexity.

•Jul 22, 2026•0 citations

Embrace the Bath: Why Dissipation Is a Feature, Not a Bug, for Quantum Computing

Ian Richard C Buckley

Quantum computing has been, from its inception, a programme of refrigeration: isolate the system, suppress dissipation, drive the physical temperature toward zero. This programme has achieved remarkable results, and the researchers who built it deserve full credit. But it is incomplete. Real quantum systems are open. Biology runs its most precise quantum computations -- kinetic proofreading, photosynthetic energy transfer, avian magnetoreception -- in warm, wet, dissipative environments, not in dilution refrigerators. Exceptional-point sensors already outperform classical sensors by exploiting, rather than suppressing, gain and loss. We coin the term hot quantum computing for computation that treats dissipation as a resource rather than a defect, and we describe the instruction set architecture -- the Raven ISA, built on the Motive ISA -- that gives it a rigorous programming model. Hot quantum is not noisy quantum: the distinction is between a leaky pipe (still trying to be airtight) and a water wheel (working because of the flow). The field has been jumping out of the bath. It is time to embrace it.

•Jul 24, 2026•0 citations

The Hot Processing Unit (HPU): Architecture and Programming Model for Dissipative Quantum Hardware

Ian Richard C Buckley

We introduce the Hot Processing Unit (HPU), a unified programming model for dissipative quantum hardware. Five physically distinct substrate classes -- PT-symmetric photonic chips (HPU-P), bosonic cat qubits (HPU-B), radical-pair molecular processors (HPU-R), non-Hermitian electrical circuits (HPU-C), and exceptional-point (EP) sensor arrays (HPU-E) -- share a common computational structure: they execute programmes in which gain, loss, and complex inverse temperature beta are first-class operations. We show that the Raven Instruction Set Architecture (ISA) is the natural HPU instruction set, with SNAP-count (the number of tier-promotion events) as the resource metric analogous to T-count in fault-tolerant quantum computing. The GPU unified diverse parallel hardware under CUDA; the HPU unifies diverse dissipative hardware under the Raven ISA. We present the HPU architecture, a five-substrate compiler pipeline, and five benchmark algorithms -- culminating in the observation that EP sensing (SNAP-count = 0) is the first demonstrated HPU algorithm, and that autonomous quantum error correction on cat qubits is the route to Shor's algorithm on HPU hardware.

•Jul 24, 2026•0 citations

Computational complexity and simulability of non-Hermitian quantum dynamics

Brian Barch, Daniel A. Lidar

Non-Hermitian (NH) quantum systems demonstrate striking differences from their Hermitian counterparts, leading to claims of NH advantage in areas ranging from metrology to entanglement generation. We show that in the context of quantum computation, any such NH advantage is unlikely to be scalable as an efficient computational resource: If coherent nonunitary evolution with renormalization could be realized with only polynomial overhead, then the resulting model could implement postselection, implying implausibly strong complexity-theoretic power under standard assumptions. We define NHBQP ( U ) as the computational power of polynomial-size quantum circuits that, in addition to a standard universal unitary gate set, may apply a fixed gate U on O ( 1 ) qubits that is not proportional to a unitary, with the state renormalized after each use of U . We prove that this model is powerful enough to decide every language in PostBQP (equivalently PP ). Moreover, in the standard uniform circuit-family model, this characterization is tight: For any fixed such nonunitary gate U , NHBQP ( U ) = PostBQP = PP . PostBQP is believed intractable, so this suggests that any scalable NH computational advantage must come with a compensating cost limiting its efficiency. Additionally, we study simulation complexity of restricted classes of nonunitary systems by purifying them to postselected unitary evolution in a form preserving system locality. Using this framework, we show that unitary gates with postselection can simulate not only evolution under NH Hamiltonians but arbitrary quantum trajectories. Any NH model whose purification lies in a strongly simulable unitary family (e.g., Clifford, matchgate, or low-bond-dimension tensor-network circuits) remains efficiently classically simulable, provided the relevant postselected events occur with probability Ω ( 2 − poly ( n ) ) . Thus, adding non-Hermiticity to a universal unitary system makes it infeasibly computationally powerful, while adding it to a strongly simulable system adds no computational power in this setting.

arXiv:2506.03435•Physical Review Research•Jun 24, 2026•6 citations

Unitary Expressions: A Necessary Abstraction for Extensible Quantum Programming Languages and Systems

Ed Younis

Quantum gates are the fundamental instructions of digital quantum computers. Current programming languages, systems, and software development toolkits identify these operational gates by their titles, which requires a shared understanding of their meanings. However, in the continuously developing software ecosystem surrounding quantum computing -- spanning high-level programming systems to low-level control stacks -- this identification process is often error-prone, challenging to debug, maintenance-heavy, and resistant to change. In this paper, we propose replacing this nominal gate representation with a functional one. We introduce the OpenQudit system for describing, parsing, optimizing, analyzing, and utilizing programs comprising gates described as symbolic unitary expressions. As part of this effort, we design the Qudit Gate Language (QGL), a unitary-specific expression language, and implement a differentiating just-in-time compiler in OpenQudit towards embedding this language in quantum programming languages and systems. Additionally, we have precisely designed and implemented the Qudit Virtual Machine (QVM) to evaluate quantum programs and their gradients efficiently. This evaluation is performed millions of times during the compilation of quantum programs. Our QVM can compute gradients approximately ten times faster than current leading numerical quantum compilation frameworks in the most common use cases. Altogether, the OpenQudit system is envisioned to (1) support many-level or qudit-based quantum systems, (2) enable the safe composition of program transformation tools, (3) accelerate circuit optimizers and transpilers, (4) enable compiler extensibility, and (5) provide a productive, simple-to-use interface to quantum practitioners.

arXiv:2501.09667•Jan 16, 2025•1 citation

The Origami ISA as a Graded Frobenius Extension

Ian Richard C Buckley

Heunen, Lemonnier, McNally, and Rice (POPL 2026) introduce the phase language: two primitives, Ph(theta) and 'if let p then s', that together are universal for unitary quantum computation. Their language is elegant and expressive, yet by design it restricts to unitary operations, to a fixed real-phase semiring, and to a single computational tier. We show that the phase language is the grade-beta=i special case of the Origami instruction-set architecture (ISA), a beta-graded Frobenius monad defined over the beta-semiring. Three main results are proved. Theorem 1 (restricted embedding): the phase-only and empty-pattern fragment of the phase language embeds faithfully into the H^1-tier subcategory of Origami_{beta=i} generated by ORBIT, TWIST, and FLIP. Theorem 2 (strict extension): the Raven ISA (complex beta) is strictly more expressive than the phase language; any computation using a non-unitary TWIST serves as witness. Theorem 3 (Frobenius monad): the quadruple {ORBIT, FLIP, BIND, MERGE} forms a Frobenius monad in the PROP semantics, satisfying the Frobenius condition and giving a categorical foundation for the full ISA. The graded structure enables a three-tier computational hierarchy: tropical (beta -> infinity), quantum (beta = i), and PT-symmetric (beta in C), with the phase language occupying exactly the middle tier.

•Jul 24, 2026•0 citations
Every major quantum programming language restricts to unitary operations and Hermitian Hamiltonians. This is understandable: unitarity is tractable, elegant, and sufficient for standard gate-model quantum computing. But real quantum systems are open, dissipative, and non-Hermitian. By refusing to engage with loss, the field is in a bind -- unable to express PT-symmetric computation, Lindblad dynamics, exceptional-point algorithms, or even the classical limit of quantum mechanics. We identify the missing primitive: BIND (the Frobenius comultiplication delta: A -> A tensor A), and the missing parameter: beta (the semiring grade interpolating between tropical, quantum, and PT-symmetric regimes). The Raven ISA is the minimal non-unitary extension of the Heunen et al. phase language that adds these two ingredients. It implements five computational advantages unavailable to unitary languages, and subsumes all existing quantum programming languages as the beta = i special case. It is time to find BIND.
The Raven ISA tier (β∈ℂ, PT-symmetric) is shown to be accessible on any existing quantum computer via a hybrid classical-quantum protocol: standard unitary circuits supply the imaginary-β quantum phases, while classical post-measurement reweighting by Boltzmann factors e^(−σE_k) supplies the real-β dissipation. The composite estimator reconstructs the complex-β partition function Z(σ+it) with no additional qubits, no postselection overhead, and gate cost identical to a standard Meld circuit. Three application classes are demonstrated: RavenRank (dissipation-weighted ranking), PT-symmetric eigensolvers for non-Hermitian matrices, and exceptional-point search with sub-Grover query complexity.
Quantum computing has been, from its inception, a programme of refrigeration: isolate the system, suppress dissipation, drive the physical temperature toward zero. This programme has achieved remarkable results, and the researchers who built it deserve full credit. But it is incomplete. Real quantum systems are open. Biology runs its most precise quantum computations -- kinetic proofreading, photosynthetic energy transfer, avian magnetoreception -- in warm, wet, dissipative environments, not in dilution refrigerators. Exceptional-point sensors already outperform classical sensors by exploiting, rather than suppressing, gain and loss. We coin the term hot quantum computing for computation that treats dissipation as a resource rather than a defect, and we describe the instruction set architecture -- the Raven ISA, built on the Motive ISA -- that gives it a rigorous programming model. Hot quantum is not noisy quantum: the distinction is between a leaky pipe (still trying to be airtight) and a water wheel (working because of the flow). The field has been jumping out of the bath. It is time to embrace it.
We introduce the Hot Processing Unit (HPU), a unified programming model for dissipative quantum hardware. Five physically distinct substrate classes -- PT-symmetric photonic chips (HPU-P), bosonic cat qubits (HPU-B), radical-pair molecular processors (HPU-R), non-Hermitian electrical circuits (HPU-C), and exceptional-point (EP) sensor arrays (HPU-E) -- share a common computational structure: they execute programmes in which gain, loss, and complex inverse temperature beta are first-class operations. We show that the Raven Instruction Set Architecture (ISA) is the natural HPU instruction set, with SNAP-count (the number of tier-promotion events) as the resource metric analogous to T-count in fault-tolerant quantum computing. The GPU unified diverse parallel hardware under CUDA; the HPU unifies diverse dissipative hardware under the Raven ISA. We present the HPU architecture, a five-substrate compiler pipeline, and five benchmark algorithms -- culminating in the observation that EP sensing (SNAP-count = 0) is the first demonstrated HPU algorithm, and that autonomous quantum error correction on cat qubits is the route to Shor's algorithm on HPU hardware.
Non-Hermitian (NH) quantum systems demonstrate striking differences from their Hermitian counterparts, leading to claims of NH advantage in areas ranging from metrology to entanglement generation. We show that in the context of quantum computation, any such NH advantage is unlikely to be scalable as an efficient computational resource: If coherent nonunitary evolution with renormalization could be realized with only polynomial overhead, then the resulting model could implement postselection, implying implausibly strong complexity-theoretic power under standard assumptions. We define NHBQP ( U ) as the computational power of polynomial-size quantum circuits that, in addition to a standard universal unitary gate set, may apply a fixed gate U on O ( 1 ) qubits that is not proportional to a unitary, with the state renormalized after each use of U . We prove that this model is powerful enough to decide every language in PostBQP (equivalently PP ). Moreover, in the standard uniform circuit-family model, this characterization is tight: For any fixed such nonunitary gate U , NHBQP ( U ) = PostBQP = PP . PostBQP is believed intractable, so this suggests that any scalable NH computational advantage must come with a compensating cost limiting its efficiency. Additionally, we study simulation complexity of restricted classes of nonunitary systems by purifying them to postselected unitary evolution in a form preserving system locality. Using this framework, we show that unitary gates with postselection can simulate not only evolution under NH Hamiltonians but arbitrary quantum trajectories. Any NH model whose purification lies in a strongly simulable unitary family (e.g., Clifford, matchgate, or low-bond-dimension tensor-network circuits) remains efficiently classically simulable, provided the relevant postselected events occur with probability Ω ( 2 − poly ( n ) ) . Thus, adding non-Hermiticity to a universal unitary system makes it infeasibly computationally powerful, while adding it to a strongly simulable system adds no computational power in this setting.
Quantum gates are the fundamental instructions of digital quantum computers. Current programming languages, systems, and software development toolkits identify these operational gates by their titles, which requires a shared understanding of their meanings. However, in the continuously developing software ecosystem surrounding quantum computing -- spanning high-level programming systems to low-level control stacks -- this identification process is often error-prone, challenging to debug, maintenance-heavy, and resistant to change. In this paper, we propose replacing this nominal gate representation with a functional one. We introduce the OpenQudit system for describing, parsing, optimizing, analyzing, and utilizing programs comprising gates described as symbolic unitary expressions. As part of this effort, we design the Qudit Gate Language (QGL), a unitary-specific expression language, and implement a differentiating just-in-time compiler in OpenQudit towards embedding this language in quantum programming languages and systems. Additionally, we have precisely designed and implemented the Qudit Virtual Machine (QVM) to evaluate quantum programs and their gradients efficiently. This evaluation is performed millions of times during the compilation of quantum programs. Our QVM can compute gradients approximately ten times faster than current leading numerical quantum compilation frameworks in the most common use cases. Altogether, the OpenQudit system is envisioned to (1) support many-level or qudit-based quantum systems, (2) enable the safe composition of program transformation tools, (3) accelerate circuit optimizers and transpilers, (4) enable compiler extensibility, and (5) provide a productive, simple-to-use interface to quantum practitioners.
Heunen, Lemonnier, McNally, and Rice (POPL 2026) introduce the phase language: two primitives, Ph(theta) and 'if let p then s', that together are universal for unitary quantum computation. Their language is elegant and expressive, yet by design it restricts to unitary operations, to a fixed real-phase semiring, and to a single computational tier. We show that the phase language is the grade-beta=i special case of the Origami instruction-set architecture (ISA), a beta-graded Frobenius monad defined over the beta-semiring. Three main results are proved. Theorem 1 (restricted embedding): the phase-only and empty-pattern fragment of the phase language embeds faithfully into the H^1-tier subcategory of Origami_{beta=i} generated by ORBIT, TWIST, and FLIP. Theorem 2 (strict extension): the Raven ISA (complex beta) is strictly more expressive than the phase language; any computation using a non-unitary TWIST serves as witness. Theorem 3 (Frobenius monad): the quadruple {ORBIT, FLIP, BIND, MERGE} forms a Frobenius monad in the PROP semantics, satisfying the Frobenius condition and giving a categorical foundation for the full ISA. The graded structure enables a three-tier computational hierarchy: tropical (beta -> infinity), quantum (beta = i), and PT-symmetric (beta in C), with the phase language occupying exactly the middle tier.