Searcharxiv⌕ Search

arXiv subjects

Mathys Rennela

Publications and source records attributed to Mathys Rennela.

12 recordsLinked to original sources
arXiv2026

Design rules for fault-tolerant multi-gate teleportation

Multi-gate teleportation (MGT) packages $n$ remote gates into a single ebit via a 1-ebit fan-out quantum circuit, saving $n{-}1$ entangled pairs relative to sequential gate teleportation. The cost is a correlated failure mode: a single network fault propagates through the fan-out tree, injecting a weight-$n$ Pauli error on the target register (weight $n{+}1$ including the control). We establish a design rule for fault-tolerant packet sizes in rotated surface codes of odd distance~$d$: a rigorous decoder-independent floor $\lfloor d/2 \rfloor$, extended to $\lceil d/2 \rceil$ by a local weight argument confirmed by simulation when the decoder is correlation-aware. Simulation with PyMatching shows the standard MWPM decoder built from the packet circuit's detector error model (DEM) naturally corrects the correlated error: at $n=\lfloor d/2\rfloor$ the packet matches or surpasses the per-link sequential LER for moderate-to-high $\gamma$, with the crossover $\gamma^\star$ decreasing as $d$ grows (from $\gamma^\star{\approx}17$ at $d{=}5$ to $\gamma^\star{<}1$ at $d{=}9$, extrapolated), whilst reducing the entanglement cost from $n$ ebits to~$1$. Packetisation wins when the network is the bottleneck ($\gamma \gg 1$); at $\gamma \approx 1$ the packet is marginally worse ($\leq1.13\times$ at $d\in\{5,7\}$, reversing by $d{=}9$) as the $n{-}1$ extra local fan-out gates offset the network savings. No custom decoding algorithm is required: the standard MWPM decoder, built from the packet circuit's DEM, already encodes the correlation.

quant-ph↗
arXiv2026

Quasilinear Equivalence Checking for Detector Error Models

A Detector Error Model (DEM) is a structured representation of error mechanisms in quantum circuits, which has gained popularity in quantum compilation pipelines for its ability to capture fault-tolerance at a circuit level. It lists error mechanisms as instructions targeting detectors and observables, specifying for each physical fault channel the probability that the fault fires, the detectors it triggers, and the observables it flips. In this paper, we develop an equational theory for DEMs, with its associated categorical semantics. We present a sound, terminating, confluent rewriting system for DEM terms, formulating it as a symmetric monoidal theory (a PROP) over the Giry monad. We prove that every DEM term has a unique normal form, which can be computed efficiently in quasilinear time $O(k|E|\log|E|)$, where $|E|$ is the number of instructions and $k$ bounds the size of a target set. This provides a complete set of invariants (via Tanner graphs) for structural DEM equivalence. We provide the first static decision procedure for DEM equivalence, with rigorous correctness guarantees. It is complete (decides full decoder-equivalence exactly) for non-adaptive quantum error correction (QEC) pipelines, and scales to a sound and applicable decision procedure for partially-adaptive circuits (lattice surgery, distributed QEC, ...) without suffering exponential overhead. We discuss its application to the verification and optimisation of quantum compilers.

quant-ph↗
arXiv2025

Efficient Gate Reordering for Distributed Quantum Compiling in Data Centers

Just as classical computing relies on distributed systems, the quantum computing era requires new kinds of infrastructure and software tools. Quantum networks will become the backbone of hybrid, quantum-augmented data centers, in which quantum algorithms are distributed over a local network of quantum processing units (QPUs) interconnected via shared entanglement. In this context, it is crucial to develop methods and software that minimize the number of inter-QPU communications. Here we describe key features of the quantum compiler araQne, which is designed to minimize distribution cost, measured by the number of entangled pairs required to distribute a monolithic quantum circuit using gate teleportation protocols. We establish the crucial role played by circuit reordering strategies, which strongly reduce the distribution cost compared to a baseline approach.

quant-ph↗
arXiv2024

Low bit-flip rate probabilistic error cancellation

Noise remains one of the most significant challenges in the development of reliable and scalable quantum processors. While quantum error correction and mitigation techniques offer potential solutions, they are often limited by the substantial overhead required. To address this, tailored approaches that exploit specific hardware characteristics have emerged. In quantum computing architectures utilizing cat-qubits, the inherent exponential suppression of bit-flip errors can significantly reduce the qubit count needed for effective error correction. In this work, we explore how the unique noise bias of cat-qubits can be harnessed to enhance error mitigation efficiency. Specifically, we demonstrate that the sampling cost associated with probabilistic error cancellation (PEC) methods can be exponentially reduced with the depth of the circuit when gates act on cat-qubits and preserve the noise bias. Similar results also hold for Clifford circuits and Pauli channels. Our error mitigation scheme is benchmarked across various quantum machine learning circuits, showcasing its practical advantages for near-term applications on cat-qubit architectures.

quant-ph↗
arXiv2021

Join Inverse Rig Categories for Reversible Functional Programming, and Beyond

Reversible computing is a computational paradigm in which computations are deterministic in both the forward and backward direction, so that programs have well-defined forward and backward semantics. We investigate the formal semantics of the reversible functional programming language Rfun. For this purpose, we introduce join inverse rig categories, the natural marriage of join inverse categories and rig categories, which we show can be used to model the language Rfun, under reasonable assumptions. These categories turn out to be a particularly natural fit for reversible computing as a whole, as they encompass models for other reversible programming languages, notably Theseus and reversible flowcharts. This suggests that join inverse rig categories really are the categorical models of reversible computing.

cs.LO↗
arXiv2020

Hybrid divide-and-conquer approach for tree search algorithms

One of the challenges of quantum computers in the near- and mid- term is the limited number of qubits we can use for computations. Finding methods that achieve useful quantum improvements under size limitations is thus a key question in the field. In this vein, it was recently shown that a hybrid classical-quantum method can help provide polynomial speed-ups to classical divide-and-conquer algorithms, even when only given access to a quantum computer much smaller than the problem itself. In this work, we study the hybrid divide-and-conquer method in the context of tree search algorithms, and extend it by including quantum backtracking, which allows better results than previous Grover-based methods. Further, we provide general criteria for polynomial speed-ups in the tree search context, and provide a number of examples where polynomial speed ups, using arbitrarily smaller quantum computers, can be obtained. We provide conditions for speedups for the well known algorithm of DPLL, and we prove threshold-free speed-ups for the PPSZ algorithm (the core of the fastest exact Boolean satisfiability solver) for well-behaved classes of formulas. We also provide a simple example where speed-ups can be obtained in an algorithm-independent fashion, under certain well-studied complexity-theoretical assumptions. Finally, we briefly discuss the fundamental limitations of hybrid methods in providing speed-ups for larger problems.

quant-ph↗
arXiv2019

Quantum Programming with Inductive Datatypes: Causality and Affine Type Theory

Inductive datatypes in programming languages allow users to define useful data structures such as natural numbers, lists, trees, and others. In this paper we show how inductive datatypes may be added to the quantum programming language QPL. We construct a sound categorical model for the language and by doing so we provide the first detailed semantic treatment of user-defined inductive datatypes in quantum programming. We also show our denotational interpretation is invariant with respect to big-step reduction, thereby establishing another novel result for quantum programming. Compared to classical programming, this property is considerably more difficult to prove and we demonstrate its usefulness by showing how it immediately implies computational adequacy at all types. To further cement our results, our semantics is entirely based on a physically natural model of von Neumann algebras, which are mathematical structures used by physicists to study quantum mechanics.

cs.LO↗
arXiv2017

Classical Control, Quantum Circuits and Linear Logic in Enriched Category Theory

We describe categorical models of a circuit-based (quantum) functional programming language. We show that enriched categories play a crucial role. Following earlier work on QWire by Paykin et al., we consider both a simple first-order linear language for circuits, and a more powerful host language, such that the circuit language is embedded inside the host language. Our categorical semantics for the host language is standard, and involves cartesian closed categories and monads. We interpret the circuit language not in an ordinary category, but in a category that is enriched in the host category. We show that this structure is also related to linear/non-linear models. As an extended example, we recall an earlier result that the category of W*-algebras is dcpo-enriched, and we use this model to extend the circuit language with some recursive types.

cs.LO↗
arXiv2016

Convexity and Order in Probabilistic Call-by-Name FPC

Kegelspitzen are mathematical structures coined by Keimel and Plotkin, in order to encompass the structure of a convex set and the structure of a dcpo. In this paper, we ask ourselves what are Kegelspitzen the model of. We adopt a categorical viewpoint and show that Kegelspitzen model stochastic matrices onto a category of domains. Consequently, Kegelspitzen form a denotational model of pPCF, an abstract functional programming language for probabilistic computing. We conclude the present work with a discussion of the interpretation of (probabilistic) recursive types, which are types for entities which might contain other entities of the same type, such as lists and trees.

cs.LO↗
arXiv2014

Privacy in Quantum Communication Complexity

In two-party quantum communication complexity, Alice and Bob receive some classical inputs and wish to compute some function that depends on both these inputs, while minimizing the communication. This model has found numerous applications in many areas of computer science. One question that has received a lot of attention recently is whether it is possible to perform such protocols in a private way. We show that defining privacy for quantum protocols is not so straightforward and it depends on whether we assume that the registers where Alice and Bob receive their classical inputs are in fact classical registers (and hence unentangled with the rest of the protocol) or quantum registers (and hence can be entangled with the rest of the protocol or the environment). We provide new quantum protocols for the Inner Product function and for Private Information Retrieval, and show that the privacy assuming classical input registers can be exponentially smaller than the privacy assuming quantum input registers. We also argue that the right notion of privacy of a communication protocol is the one assuming classical input registers, since otherwise the players can deviate considerably from the protocol.

quant-ph↗