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

arXiv:2407.16801 · Proceedings of the ACM on Programming Languages

Qudit Quantum Programming with Projective Cliffords

Jennifer Paykin, Sam Winnick

Published Jan 8, 2026• 1 citation
arXivHTMLPDF

Abstract

This paper introduces a novel abstraction for programming quantum operations, specifically projective Cliffords , as functions over the qu d it Pauli group. Generalizing the idea behind Pauli tableaux, we introduce a type system and lambda calculus for projective Cliffords called λ P c that captures well-formed Clifford operations via a Curry-Howard correspondence with a particular encoding of the Clifford and Pauli groups. In λ P c , users write functions that encode projective Cliffords P ↦ UPU † , and such functions are compiled to circuits executable on modern quantum computers that transform quantum states | φ ⟩ into U | φ ⟩, up to a global phase. Importantly, the language captures not just qubit operations, but qu d it operations for any dimension d . Throughout the paper we explore what it means to program with projective Cliffords through a number of examples and a case study focusing on stabilizer error correcting codes.

DOI
10.1145/3776646

Related papers

A Review of Galois Qudits

Adam Wills

Galois qudits are $q$-dimensional quantum systems whose choice of Pauli group encodes the arithmetic of some finite field $\mathbb{F}_q$. They differ from the more familiar modular qudit, which are the same quantum system but whose choice of Pauli group are the clock and shift operators, which encode the arithmetic of integer addition and multiplication modulo $q$. Galois qudits are a useful mathematical construct that allow us to leverage the mathematical tools that are native to the larger qudit while only physically building smaller qudits. In particular, a Galois qudit of dimension $q = 2^s$ is exactly the same thing as a collection of $s$ qubits, not only in its Hilbert space, but also in its Pauli group, and Clifford hierarchy. This formalism has found a lot of utility recently in constructing quantum error-correcting codes over qubits with useful properties. In this review, we build on existing literature to collect and formalise facts and proofs about Galois qudits over binary extension fields. We define them and their Clifford hierarchies, describe what it means to measure their Pauli operators, describe their stabiliser tableaux, formally define qudit-to-qubit mappings, and finally describe quantum Reed-Solomon codes.

quant-pharXiv:2605.18981•May 20, 2026•0 citations

Quantum error correcting codes: From stabilizer codes to induced codes

Edward A. Loeb

The first large class of quantum error-correcting codes that was constructed is the class of stabilizer codes. The construction method used for these codes is based on finding abelian subgroups of general Pauli groups. Stabilizer codes are a special case of a more general class of quantum error-correcting codes---Clifford codes. The construction technique for Clifford codes generalizes the stabilizer code construction by introducing abstract error groups. Abstract error groups generalize the Pauli groups so that codes can be constructed for quantum systems with any dimension. Clifford codes are thus constructed by finding normal subgroups of abstract error groups. In this dissertation we show that Clifford codes are a special case of a larger class of codes, which we refer to as induced codes. In addition to this new construction method, we also present some new results pertaining to a subclass of stabilizer codes called degenerate stabilizer codes.

•Jan 1, 2006•0 citations

Stabilizer states and Clifford operations for systems of arbitrary dimensions and modular arithmetic

Erik Hostens, Jeroen Dehaene, Bart De Moor

We describe generalizations of the Pauli group, the Clifford group, and stabilizer states for qudits in a Hilbert space of arbitrary dimension $d$. We examine a link with modular arithmetic, which yields an efficient way of representing the Pauli group and the Clifford group with matrices over ${\mathbb{Z}}_{d}$. We further show how a Clifford operation can be efficiently decomposed into one and two-qudit operations. We also focus in detail on standard basis expansions of stabilizer states.

arXiv:quant-ph/0408190•Physical Review A•Apr 11, 2005•137 citations

Hybrid Clifford Codes via Operator Algebra Quantum Error Correction and Projective Representation Theory

Jonas Eidesen, David W. Kribs, Andrew Nemec

Clifford codes are a natural generalization of quantum stabilizer codes based primarily on representation theory. This class of codes has previously been extended to the setting of quantum subsystem codes. We formulate a two-fold generalization of Clifford codes, for both the hybrid classical and quantum information and projective representation theory settings. This leads to new classes of hybrid subspace and subsystem Clifford codes. We extend the fundamental representation theoretic quantum error correction theorem to include these codes, based on the operator algebra quantum error correction framework. We also discuss several examples throughout the presentation, of both stabilizer and non-stabilizer type.

quant-pharXiv:2606.02531•Jun 2, 2026•0 citations

A Simple Method for Compiling Quantum Stabilizer Circuits

Brendan Reid

Stabilizer circuits play an important role in quantum error correction protocols, and will be vital for ensuring fault tolerance in future quantum hardware. While stabilizer circuits are defined on the Clifford generating set,$\{H, S, CX\}$, not all of these gates are native to quantum hardware. As such they must be compiled into the native gateset, with the key difference across hardware archetypes being the native two-qubit gate. Here we introduce an intuitive and accessible method for Clifford gate compilation. While multiple open source solutions exist for quantum circuit compilation, these operate on arbitrary quantum gates. By restricting ourselves to Clifford gates, the compilation process becomes almost trivial and even large circuits can be compiled manually. The core idea is well known: if two Clifford circuits conjugate Paulis identically, they are equivalent. Compilation is then reduced to ensuring that the instantaneous Pauli conjugation is correct for each qubit at every timestep. This is Tableaux Manipulation, so called as we directly interrogate stabilizer tableaux to ensure correct Pauli conjugation. We provide a brief explanation of the process along with a worked example to build intuition; we finally show some comparisons for compiling large circuits to open source software, and highlight that this method ensures a minimal number of quantum gates are employed.

arXiv:2404.19408•IEEE International Conference on Quantum Computing and Engineering (QCE)•Sep 15, 2024•0 citations

Synthesizing Circuits from Tableaus

anne mara

Quantum computers are only as powerful as the compilers that optimize the circuits they run. As quantum hardware scales, reducing gate counts and circuit depth becomes critical for practical computation. This work implements a core synthesis algorithm in OCaml that maps arbitrary Cliffords to circuits, a fundamental building block in quantum circuit compilation. The Clifford synthesis implementation is designed around how LambdaPC thinks about quantum computation, through Pauli operators. It frames synthesis as a search problem: given a Clifford tableau, find a path to the identity by applying gates. Working factor by factor, it reduces each Pauli pair (P, Q) to a canonical (Z_i, X_i) form using single-qubit Clifford gates and TQE gates, until the full tableau is decomposed into an executable circuit. The main challenge was working within LambdaPC's typed representation, where n-qubit Paulis are encoded as nested pairs. This required helper functions to extract Pauli data from those structures and pattern-matching logic to find minimal gate sequences, laying the groundwork for end-to-end Clifford compilation in LambdaPC.

•Jun 8, 2026•0 citations
This paper introduces a novel abstraction for programming quantum operations, specifically projective Cliffords , as functions over the qu d it Pauli group. Generalizing the idea behind Pauli tableaux, we introduce a type system and lambda calculus for projective Cliffords called λ P c that captures well-formed Clifford operations via a Curry-Howard correspondence with a particular encoding of the Clifford and Pauli groups. In λ P c , users write functions that encode projective Cliffords P ↦ UPU † , and such functions are compiled to circuits executable on modern quantum computers that transform quantum states | φ ⟩ into U | φ ⟩, up to a global phase. Importantly, the language captures not just qubit operations, but qu d it operations for any dimension d . Throughout the paper we explore what it means to program with projective Cliffords through a number of examples and a case study focusing on stabilizer error correcting codes.
Galois qudits are qqq-dimensional quantum systems whose choice of Pauli group encodes the arithmetic of some finite field Fq\mathbb{F}_qFq​. They differ from the more familiar modular qudit, which are the same quantum system but whose choice of Pauli group are the clock and shift operators, which encode the arithmetic of integer addition and multiplication modulo qqq. Galois qudits are a useful mathematical construct that allow us to leverage the mathematical tools that are native to the larger qudit while only physically building smaller qudits. In particular, a Galois qudit of dimension q=2sq = 2^sq=2s is exactly the same thing as a collection of sss qubits, not only in its Hilbert space, but also in its Pauli group, and Clifford hierarchy. This formalism has found a lot of utility recently in constructing quantum error-correcting codes over qubits with useful properties. In this review, we build on existing literature to collect and formalise facts and proofs about Galois qudits over binary extension fields. We define them and their Clifford hierarchies, describe what it means to measure their Pauli operators, describe their stabiliser tableaux, formally define qudit-to-qubit mappings, and finally describe quantum Reed-Solomon codes.
The first large class of quantum error-correcting codes that was constructed is the class of stabilizer codes. The construction method used for these codes is based on finding abelian subgroups of general Pauli groups. Stabilizer codes are a special case of a more general class of quantum error-correcting codes---Clifford codes. The construction technique for Clifford codes generalizes the stabilizer code construction by introducing abstract error groups. Abstract error groups generalize the Pauli groups so that codes can be constructed for quantum systems with any dimension. Clifford codes are thus constructed by finding normal subgroups of abstract error groups. In this dissertation we show that Clifford codes are a special case of a larger class of codes, which we refer to as induced codes. In addition to this new construction method, we also present some new results pertaining to a subclass of stabilizer codes called degenerate stabilizer codes.
We describe generalizations of the Pauli group, the Clifford group, and stabilizer states for qudits in a Hilbert space of arbitrary dimension ddd. We examine a link with modular arithmetic, which yields an efficient way of representing the Pauli group and the Clifford group with matrices over Zd{\mathbb{Z}}_{d}Zd​. We further show how a Clifford operation can be efficiently decomposed into one and two-qudit operations. We also focus in detail on standard basis expansions of stabilizer states.
Clifford codes are a natural generalization of quantum stabilizer codes based primarily on representation theory. This class of codes has previously been extended to the setting of quantum subsystem codes. We formulate a two-fold generalization of Clifford codes, for both the hybrid classical and quantum information and projective representation theory settings. This leads to new classes of hybrid subspace and subsystem Clifford codes. We extend the fundamental representation theoretic quantum error correction theorem to include these codes, based on the operator algebra quantum error correction framework. We also discuss several examples throughout the presentation, of both stabilizer and non-stabilizer type.
Stabilizer circuits play an important role in quantum error correction protocols, and will be vital for ensuring fault tolerance in future quantum hardware. While stabilizer circuits are defined on the Clifford generating set,{H,S,CX}\{H, S, CX\}{H,S,CX}, not all of these gates are native to quantum hardware. As such they must be compiled into the native gateset, with the key difference across hardware archetypes being the native two-qubit gate. Here we introduce an intuitive and accessible method for Clifford gate compilation. While multiple open source solutions exist for quantum circuit compilation, these operate on arbitrary quantum gates. By restricting ourselves to Clifford gates, the compilation process becomes almost trivial and even large circuits can be compiled manually. The core idea is well known: if two Clifford circuits conjugate Paulis identically, they are equivalent. Compilation is then reduced to ensuring that the instantaneous Pauli conjugation is correct for each qubit at every timestep. This is Tableaux Manipulation, so called as we directly interrogate stabilizer tableaux to ensure correct Pauli conjugation. We provide a brief explanation of the process along with a worked example to build intuition; we finally show some comparisons for compiling large circuits to open source software, and highlight that this method ensures a minimal number of quantum gates are employed.
Quantum computers are only as powerful as the compilers that optimize the circuits they run. As quantum hardware scales, reducing gate counts and circuit depth becomes critical for practical computation. This work implements a core synthesis algorithm in OCaml that maps arbitrary Cliffords to circuits, a fundamental building block in quantum circuit compilation. The Clifford synthesis implementation is designed around how LambdaPC thinks about quantum computation, through Pauli operators. It frames synthesis as a search problem: given a Clifford tableau, find a path to the identity by applying gates. Working factor by factor, it reduces each Pauli pair (P, Q) to a canonical (Z_i, X_i) form using single-qubit Clifford gates and TQE gates, until the full tableau is decomposed into an executable circuit. The main challenge was working within LambdaPC's typed representation, where n-qubit Paulis are encoded as nested pairs. This required helper functions to extract Pauli data from those structures and pattern-matching logic to find minimal gate sequences, laying the groundwork for end-to-end Clifford compilation in LambdaPC.