Transpiling Quantum Assembly Language Circuits to a Qudit Form

Abstract

In this paper, we introduce the workflow for converting qubit circuits represented by Open Quantum Assembly format (OpenQASM, also known as QASM) into the qudit form for execution on qudit hardware and provide a method for translating qudit experiment results back into qubit results. We present the comparison of several qudit transpilation regimes, which differ in decomposition of multicontrolled gates: qubit as ordinary qubit transpilation and execution, qutrit with $d=3$ levels and single qubit in qudit, and ququart with $d=4$ levels and 2 qubits per ququart. We provide several examples of transpiling circuits for trapped ion qudit processors, which demonstrate potential advantages of qudits.

1. Introduction

A digital model of quantum computing relies on performing quantum logical operations under qubits, which are quantum analogs of classical bits allowing superposition states [1,2,3]. It is expected that quantum processors of sufficiently high performance may be superior to classical counterparts in various computational problems [3,4], such as prime factorization [5], optimization [6], and simulating complex (quantum) systems [7,8]. Key building blocks for realizing quantum processors based on various physical platforms, such as superconducting circuits [9,10], semiconductor quantum dots [11,12,13,14], photonic systems [15,16], neutral atoms [17,18,19,20], and trapped ions [21,22,23] have been demonstrated. Although quantum advantage has been shown in several experiments with noisy intermediate-scale quantum (NISQ) devices [9,10,15], finding the path towards large-scale quantum computing remains an open question.

A promising approach to scaling ion-based quantum processors is to use additional levels for encoding quantum information, which is at the heart of the concept of qudit-based quantum processors. Qudit-based quantum information processing has been widely studied both theoretically and experimentally during the last decades [24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63]. Experimental results include demonstrations of qudit processors based on trapped ions [64,65,66,67], superconducting circuits [68,69], and quantum light [61]. Specifically, in the case of trapped ions, high-fidelity control over multilevel systems has been shown [64,65,66,67,70]. Qudits can be used both for storing multiple qubits and for using higher levels as ancillas in the case of the decomposition of multiqubit gates. However, as soon as the majority of algorithms are formulated in the qubit form, in order to use qudits, one needs a procedure for transforming qubit circuits in the qudit form to achieve an advantage in terms of the resulting fidelity.

In this work, we focus on the problem of efficient transforming quantum circuits that are expressed via Quantum Assembly (QASM) format to the qudit form. We focus our attention on this format since QASM is the widely used representation of qubit circuits, and many quantum frameworks can handle QASM code according to the desired algorithm. Frameworks qiskit [71] and cirq [72] are commonly used to implement qubit algorithms and run them on quantum hardware, with the ability to optimize qubit circuits and perform topology-aware multiqubit transpilation. Processing of qudit circuits is also the topic of several research, such as the simulation platform for hybrid quantum systems QuDiet [73], which introduces a special QASM format for qudit execution, or the numerical qudit optimization framework bqskit [74]. The distinguishing feature of our transpilation approach is to take qubit QASM circuit, store qubit into qudits, execute circuit on qudit device, and provide qubit results back to a user. From this perspective, our technique provides a seamless qubit circuit interface to the user and utilizes the benefits of qudits with different dimensionality.

To maximize the potential of qudits to execute qubit circuits, we introduce several key concepts that cannot be reached using earlier developed quantum circuit frameworks. Firstly, in our paper, we introduce the idea of a customizable transpiling process with target device description using runtime. While other frameworks often operate with native gates as unitary matrices to perform numerical optimization [74], our transpiler omits a unitary representation of native gates and relies on analytical decompositions and composition rules in terms of native gates and mathematical expressions. These rules can be defined for any quantum device to use in our transpiler seamlessly. Moreover, we propose to use for these rules the similar QASM description format (analytical formulas in the form of syntactic rules). These facts simplify the process of operating with the transpiler and greatly reduce the computing complexity of transpiling and optimizing qubit circuits.

The second idea is the process of unmapping samples obtained via the qudit quantum computer. Using the qubit-to-qudit mapping from transpiler, one can convert these results back to qubit form. This process provides the opportunity to use qudit quantum hardware or a simulator to run any qubit circuit in QASM form and obtain the circuit’s statistics corresponding to qubits defined in the QASM file.

The third is the idea of efficient multiqubit gate decomposition in terms of qudit gates. Using qudit-based transpilation techniques, we expect to benefit in quantum circuit fidelity due to reducing the number of noisy two-qudit operations. We present a comparison of several qudit execution regimes, whose main difference is in the decomposition of multicontrolled gates: qubit as ordinary qubit transpilation and execution, qutrit with $d=3$ levels and single qubit in qudit, and ququart with $d=4$ levels and 2 qubits per ququart.

The paper is organized as follows. In Section 2, we briefly revise the specification of the QASM format. In Section 3, we discuss basic gates for qudit circuit construction. In Section 4, we consider the trapped ion qudit quantum processor as a concrete example of a hardware platform for the transpilation process and provide a description of JSON format for the record of the qudit circuit. In Section 5, we present a developed general transpilation workflow and a concrete realization of transpilation methods for input QASM circuits, which allows one to obtain implementable on a hardware qudit circuit for ion qudits with $d=3$ and $d=4$ levels. In Section 6, we benchmark a transpiler developed on widely used quantum algorithms and compare its different regimes with a qubit qiskit transpiler and between each other. Finally, we conclude this paper in Section 7.

2. Quantum Circuits in the QASM Format

The QASM format [75] is a widely used format for writing qubit quantum circuits in gate-based model in a text form. QASM format could be generated using one of the quantum computing frameworks (e.g., qiskit [71]), from user-defined logic or could be written manually. It is allowed due to the syntactical and semantic simplicity of the QASM representation, which consists of gates, measures, and barrier operations along with their conditional variants. This set of operations is sufficient for quantum program execution on real hardware or on a simulator.

QASM was designed to formalize quantum computations and fully describe quantum circuits. A QASM file is composed of a series of instructions, each of which represents a specific operation that is to be executed on the hardware (see Appendix A).

QASM format does not specify what type of quantum system it uses: qubit or qudit. Although all qubit operations can be expressed using QASM, certain qudit operations may not be expressible due to the lack of a suitable description for the level structure and operations associated with qudits. So, in our experiments, we use the QASM format for qubit quantum circuits, which describe the quantum logic of a program, and as input to the transpiler, which converts QASM circuit into qudit form for further execution on qudit hardware. We also provide JSON format specification for qudit circuit description in Section 4.

3. Qudit Circuits

By analogy with qubit-based quantum computing, one can implement quantum circuits with d-level quantum systems, qudits. On the existing qudit-based hardware, single-qudit operation ${\mathsf{U}}_d^{ij}$, which acts on a d-level qudit, is usually implemented as a unitary $2\times 2$ matrix acting on a linear span of i-th and j-th levels (see an example for a trapped ion platform [64,65] and for a superconducting platform [69]). Single-qudit operation ${\mathsf{U}}_d^{ij}$ can be defined with the use of a qudit extension of Pauli matrices ${\sigma }_x^{ij}$, ${\sigma }_y^{ij}$ and ${\sigma }_z^{ij}$, acting on i-th and j-th levels, that are the analogs to the qubit Pauli matrices extended with zeroes:

$$\begin{array}{c}\begin{array}{cc}\hfill {\sigma }_x^{ij}& =|j⟩⟨i|+|i⟩⟨j|,\hfill \\ \hfill {\sigma }_y^{ij}& =\mathrm{i}|j⟩⟨i|-\mathrm{i}|i⟩⟨j|,\hfill \\ \hfill {\sigma }_z^{ij}& =|i⟩⟨i|-|j⟩⟨j|,\hfill \end{array}\end{array}$$

(1)

where $i,j\in \{0,\dots ,d-1\}$; d is the number of levels in the qudit; and $\mathrm{i}$ stands for an imaginary unit. These matrices satisfy the following relations:

$$\begin{array}{c}{\left.{\sigma }_a^{ij}{\sigma }_b^{ij}\right|}_{a,b\in \{x,y,z\}}=\left\{\begin{array}{cc}{\epsilon }^{ij}\hfill & \mathrm{if}a=b,\hfill \\ -{\sigma }_b^{ij}{\sigma }_a^{ij}\hfill & \mathrm{otherwise},\hfill \end{array}\right.\end{array}$$

(2)

where ${\epsilon }^{ij}=|i⟩⟨i|+|j⟩⟨j|$ is the identity matrix acting on i-th and j-th levels.

Single-qudit native operations for a trapped ion and a superconducting platform are defined as a rotation with two angle parameters $\theta$ and $\varphi$. Parameter $\theta$ specifies the angle of rotation that is determined by pulse length in a qudit system. Parameter $\varphi$ specifies the axis of rotation in the $XY$ plane within the Bloch sphere. Using a qudit extension of Pauli matrices, we can obtain a matrix representation for a single-qudit operation ${\mathsf{R}}^{ij}$:

$$\begin{array}{c}{\mathsf{R}}^{ij}(\theta ,\varphi )=exp\left(-\mathrm{i}\theta {\sigma }_{\varphi }^{ij}\right),\end{array}$$

(3)

where

$${\sigma }_{\varphi }^{ij}=cos\left(\varphi \right){\sigma }_x^{ij}+sin\left(\varphi \right){\sigma }_y^{ij},$$

(4)

and the following symmetry relations are fulfilled:

$$\begin{array}{cc}\hfill {\mathsf{R}}^{ij}{(\theta ,\varphi )}^{†}& ={\mathsf{R}}^{ij}(-\theta ,\varphi ),\hfill \end{array}$$

(5)

$$\begin{array}{cc}\hfill {\mathsf{R}}^{ji}(\theta ,\varphi )& ={\mathsf{R}}^{ij}(\theta ,-\varphi ),\hfill \end{array}$$

(6)

$$\begin{array}{cc}\hfill {\mathsf{R}}^{ij}(-\theta ,\varphi )& ={\mathsf{R}}^{ij}(\theta ,\varphi \pm \pi ),\hfill \end{array}$$

(7)

$$\begin{array}{cc}\hfill {\mathsf{R}}^{ij}(\theta +2\pi n,\varphi )& ={\mathsf{R}}^{ij}(\theta ,\varphi ),\hfill \end{array}$$

(8)

$$\begin{array}{cc}\hfill {\mathsf{R}}^{ij}(\theta ,\varphi +2\pi m)& ={\mathsf{R}}^{ij}(\theta ,\varphi ),\hfill \end{array}$$

(9)

where the arbitrary integers are n and m.

We note that we define ${\mathsf{R}}^{ij}$ gate without ${\displaystyle \frac{1}{2}}$ factor to preserve $2\pi$ periodicity for all parameters. However, typical definitions of single-qubit gate ${\mathsf{R}}_{\mathsf{qb}}$ and single-qudit gate ${\mathsf{R}}_{\mathsf{qd}}^{ij}$ depend on the ${\displaystyle \frac{\theta }{2}}$ parameter:

$$\begin{array}{c}{\mathsf{R}}_{\mathsf{qb}}(\theta ,\varphi )=exp\left(-\mathrm{i}{\displaystyle \frac{\theta }{2}}{\sigma }_x\right),\end{array}$$

(10)

$$\begin{array}{c}{\mathsf{R}}_{\mathsf{qd}}^{ij}(\theta ,\varphi )=exp\left(-\mathrm{i}{\displaystyle \frac{\theta }{2}}{\sigma }_{\varphi }^{ij}\right).\end{array}$$

(11)

While the qubit operation satisfies the relation ${\mathsf{R}}_{\mathsf{qb}}(\theta +2\pi ,\varphi )=-{\mathsf{R}}_{\mathsf{qb}}(\theta ,\varphi )$ and, therefore, two operations become equivalent up to global phase factor $-1$, the qudit ${\mathsf{R}}_{\mathsf{qd}}^{ij}$ operation does not hold this equivalence:

$${\mathsf{R}}_{\mathsf{qd}}^{ij}(\theta +2\pi ,\varphi )={\mathsf{E}}^{ij}-{\epsilon }^{ij}cos\left({\displaystyle \frac{\theta }{2}}\right)+\mathrm{i}{\sigma }_{\varphi }^{ij}sin\left({\displaystyle \frac{\theta }{2}}\right),$$

(12)

$${\mathsf{R}}_{\mathsf{qd}}^{ij}(\theta +2\pi ,\varphi )+{\mathsf{R}}_{\mathsf{qd}}^{ij}(\theta ,\varphi )=2{\mathsf{E}}^{ij},$$

(13)

where

$${\mathsf{E}}^{ij}=\sum _{k\ne i,j}|k⟩⟨k|=\mathsf{Id}-{\epsilon }^{ij}$$

(14)

and $\mathsf{Id}$ is an identity matrix.

Along with ${\mathsf{R}}^{ij}$ operation, qudit devices provide the possibility to apply a phase operation ${\mathsf{Ph}}^i$ and Z rotation ${\mathsf{RZ}}^{ij}$, which can be often implemented virtually (see [67] for the trapped ions and [69] for the superconducting platform), and hence, does not contribute to generating errors:

$$\begin{array}{c}{\mathsf{Ph}}^i\left(\theta \right)=exp\left(\mathrm{i}\theta {\epsilon }^i\right)={\mathsf{E}}^i+e^{\mathrm{i}\theta }{\epsilon }^i,\end{array}$$

(15)

$$\begin{array}{c}{\mathsf{RZ}}^{ij}\left(\theta \right)=exp\left(-\mathrm{i}\theta {\sigma }_z^{ij}\right)={\mathsf{E}}^{ij}+e^{-\mathrm{i}\theta }{\epsilon }^i+e^{\mathrm{i}\theta }{\epsilon }^j.\end{array}$$

(16)

Another crucial type of operation for quantum computations is entangling a two-qudit gate. The specific form of two-qudit operations varies depending on the physical platform considered. In theoretical papers, two-qudit ${\mathsf{CZ}}^{i|j}$ and ${\mathsf{C}\mathsf{X}}^{i|jk}$ gates are commonly considered:

$${\mathsf{CZ}}^{i|j}:\left\{\begin{array}{cccc}\hfill & |i,j⟩& \mapsto -|i,j⟩,\hfill & \\ \hfill & |x,y⟩& \mapsto |x,y⟩\hfill & \mathrm{i}\mathrm{f} x\ne i\mathrm{or}y\ne j,\end{array}\right.$$

(17)

$${\mathsf{CX}}^{i|jk}:\left\{\begin{array}{cccc}\hfill & |i,j⟩& \mapsto |i,k⟩,\hfill & \\ \hfill & |i,k⟩& \mapsto |i,j⟩,\hfill & \\ \hfill & |x,y⟩& \mapsto |x,y⟩\hfill & \mathrm{i}\mathrm{f} x\ne i\mathrm{or}y\ne j,k.\end{array}\right.$$

(18)

However, trapped ion qudit-based quantum computers operate with a Mølmer–Sørensen gate [76] ${\mathsf{XX}}^{ij|kl}$:

$${\mathsf{XX}}^{ij|kl}\left(\theta \right)=exp\left(-\mathrm{i}\theta {\sigma }_x^{ij}\otimes {\sigma }_x^{kl}\right),$$

(19)

where the pairs of levels $i,j$ and $k,l$ refer to the first and second qubits, respectively. Within superconducting processors, an iSWAP gate of the following form can be typically implemented:

$${\mathsf{iSWAP}}^{ij|kl}\left(\theta \right):\left\{\begin{array}{c}|i,k⟩\mapsto e^{l\theta }|j,l⟩,\hfill \\ |j,l⟩\mapsto e^{l\theta }|i,k⟩,\hfill \end{array}\right..$$

(20)

Notably, a real quantum device implies selection rules, which determine allowed level pairs for single-qudit and two-qudit gates. We define a ${\mathsf{SWAP}}^{ij}$ operation between levels i and j as ${\mathsf{R}}^{ij}({\displaystyle \frac{\pi }{2}},{\displaystyle \frac{\pi }{2}})$ to solve the issue. Effectively, it swaps the population between i-th and j-th levels, allowing us to decompose any ${\mathsf{R}}^{ij}$ into the sequence of allowed swaps and transitions. For any i, j and s, the following identity holds:

$${\mathsf{G}}_n^i={\mathsf{SWAP}}_n^{is}\circ {\mathsf{G}}_n^s\circ {\mathsf{SWAP}}_n^{si},$$

(21)

where ${\mathsf{G}}_n^j$ is the pattern for operation that involves the i-th level in n-th qudit in register, e.g., ${\mathsf{R}}_n^{i·}$, ${\mathsf{XX}}_{n·}^{i···}$, ${\mathsf{XX}}_{·n}^{··i·}$, etc., and ∘ denotes the operations’ composition, where operations are applied in a left-to-right order. Also, for this decomposition to be valid, the operation pattern ${\mathsf{G}}_n^j$ cannot involve an s-th level. For example, for $\mathsf{XX}$ gate, the level swap is performed as follows:

$${\mathsf{XX}}_{n|m}^{ij|kl}\left(\theta \right)=\left({\mathsf{SWAP}}_n^{is}\otimes {\mathsf{Id}}_m\right)\circ {\mathsf{XX}}_{n|m}^{sj|kl}\left(\theta \right)\circ \left({\mathsf{SWAP}}_n^{si}\otimes {\mathsf{Id}}_m\right).$$

(22)

4. Trapped Ion Qudit Quantum Computer

As a concrete example of a qudit device for the transpilation process, we consider the trapped ion qudit-based processor developed in Refs. [65,67]. The authors implemented qudit-trapped ion computations (in this work, we consider at most $d=4$) using the ${\mathsf{R}}_{\mathrm{ion}}^{0i}$, ${\mathsf{Ph}}_{\mathrm{ion}}^i$ and ${\mathsf{XX}}_{\mathrm{ion}}^{01|01}$ native gate set. These gates are equivalent to the defined ones in the previous section with parameter modifications:

$$\begin{array}{cc}\hfill {\mathsf{Ph}}_{\mathrm{ion}}^i\left(\theta \right)& ={\mathsf{Ph}}^i\left(\theta \right),\hfill \\ \hfill {\mathsf{R}}_{\mathrm{ion}}^{0i}(\theta ,\varphi )& ={\mathsf{R}}^{0i}(\frac{\theta }{2},\varphi ),\hfill \\ \hfill {\mathsf{XX}}_{\mathrm{ion}}^{01|01}\left(\theta \right)& ={\mathsf{XX}}^{01|01}\left(\theta \right).\hfill \end{array}$$

(23)

Considering the allowed level transitions for ${}^{171}\mathrm{Yb}^{+}$ ion qudits and Equation (21), it is possible to decompose any sequence of qudit operations ${\mathsf{Ph}}^i$, ${\mathsf{R}}^{ij}$ and ${\mathsf{XX}}^{ij|kl}$ into the sequence of ion native gates ${\mathsf{Ph}}_{\mathrm{ion}}^i$, ${\mathsf{R}}_{\mathrm{ion}}^{0i}$ and ${\mathsf{XX}}_{\mathrm{ion}}^{01|01}$ [63].

Operations ${\mathsf{Ph}}_{\mathrm{ion}}^i$, ${\mathsf{R}}_{\mathrm{ion}}^{0i}$ and ${\mathsf{XX}}_{\mathrm{ion}}^{01|01}$ on allowed levels are stored in an ion quantum computer description format (see Appendix B).

5. Qasm-to-Qudit Form Transpilation

In our model, qudit circuits can only be constructed with the native gate set for a given quantum device. Native gates are the operations physically allowed on the device, and, usually, a set of native gates contains single-particle and two-particle operations. On the other hand, QASM is a more general quantum circuit description format. It can represent not only a sequence of physical gates but rather quantum logic for this circuit with, for example, $\mathsf{U}(\theta ,\varphi ,\lambda )$ and controlled $\mathsf{CX}$ or multiqubit Toffoli operations. Hence, in some cases, even qubit circuits in QASM format could not be executed on the device as is.

The transpiler aims to bridge the gap between high-level software and hardware representations of a circuit and to facilitate the process of translating QASM code into a qudit circuit. We divide the transpilation process into three steps, as depicted in Figure 1: qubit transpilation, qubit–qudit transpilation (or qudit transpilation, which is performed according to qubit-to-qudit mapping), and qudit circuit optimization. At the end of transpilation, an optimized qudit circuit can be stored in a format suitable for execution on the target device.

Figure 1. General scheme of transpilation process and changing the format of the circuits (arrows with caption) during transpilation.

In the first step, the ‘pure’ qubit transpilation takes place. It parses QASM code into an abstract syntax tree, which is used as a circuit representation within the transpiler, and converts a sequence of logical quantum gates into a native gate set using decompositions of the most used gates (e.g., $\mathsf{U}(\theta ,\varphi ,\lambda )$, $\mathsf{CX}$, $\mathsf{MCX}$, etc.). This process is divided into two phases: preprocessor and optimizer. Each phase could be tuned according to the chosen target device.

At the first phase, the preprocessor performs parsing and checking the semantics of the QASM file. Any encountered error in source code is supplemented with a descriptive error message and the line number and position to refer to it in source code. Next, it expands all QASM gates into the native gate set for the device using the provided qelib1.inc file, which consists of many applied gate declarations according to OpenQASM 2.0 standard. After the preprocessor phase, the user obtains a sequence of native qubit gates. Here, the optimizer could be enabled to reduce the number of operations and produce an equivalent gate sequence.

At the second phase, the optimizer undergoes the subsequences of gates from the source circuit and tries to match them with a predefined set of symmetry relations and gate contraction rules, which can be defined in a separate matcher file matcher.script. The matcher file represents the set of rules in the form of mathematical expressions that can be derived from target device operations’ relations. Due to such a form, this file can be written by developers and scientists for a given device without using a matrix representation of the native gate.

Along with the native gate set, the file with gate declarations qelib1.inc and rule set matcher.script represent the runtime for the given target device. We describe the content of qelib1.inc and matcher.script more precisely in Appendix C. For now, the transpiler supports one of the following runtimes and corresponding native gate sets:

• Quantum emulator:
  $\mathsf{U},\mathsf{CX}$.
• Trapped ion quantum computer:
  $\mathsf{RZ},\mathsf{R},\mathsf{XX}$.
• Trapped ion intermediate representation:
  $\mathsf{RZ},\mathsf{R},\mathsf{CZ},\mathsf{MCZ}$.

where n, m and other lower indices denote qubits (or qudits) where the operation acts on. Quantum emulator and trapped ion quantum computer runtimes are suitable for the case of qubit execution. Trapped ion intermediate representation is the special runtime, which should not resemble any quantum hardware or quantum simulator. However, this runtime produces a qubit circuit with an extended gate set and passes it into the following step. This extended circuit represents an intermediate format that allows the transpiler to choose a qudit decomposition for $\mathsf{RZ}$, $\mathsf{R}$ and $\mathsf{CZ}$ for a given type of qudit.

Another point of introducing this runtime is that it contains decompositions for multiqubit gates (e.g., Fredkin $\mathsf{CSWAP}$ or multicontrolled Toffoli $\mathsf{MCX}$) in terms of $\mathsf{MCZ}$ gates. For many qudit parameters, this gate has special form in the qudit circuit that will arise during the second step of transpilation. The resulting qudit circuit will only contain ${\mathsf{XX}}^{ij|kl}$ gates as two-qudit operations. Additionally, the qudit optimization step could be enabled to reduce the length of the qudit sequence of gates. Qudit optimization rules are described in the third step of the transpiler.

In the second step, the transpiler uses a qubit circuit transpiled with a trapped ion intermediate representation runtime from the first step to produce a qudit circuit. Along with the number of parameter of levels in qudit d, it uses a parameter b that defines how many qubits from the original circuit can be embedded in each qudit from the generated qudit circuit. Qudit, containing at least $2^b$ levels, is able to represent qubit register with b qubits by placing register states on $2^b$ qubit levels. If the number of levels is $d>2^b$, then the remaining levels are considered as ancillary. An example of qudit structure is presented in Figure 2. Qubits ($d=2$) or qutrits ($d=3$) can only store a single qubit, whereas ququarts ($d=4$) can store one or two qubits.

Figure 2. Qudit levels to qubit state mapping for $b=1$ and $b=2$. For any qudit levels d and qubits in qudit b, all qudit levels are divided into $2^b$qubit levels and $d-2^b$ ancillary levels. Each qubit level digit is converted into qubit state using its binary representation, whereas ancillary levels are used for specific decompositions.

To store all qubits from the QASM circuit into qudits, the transpiler produces a qubit–qudit mapping. The result is two sets of indices $Q_n$ and $I_n$ for any qubit index $n\in \{0,1,\dots ,N-1\}$, where N is the size of the register in the original circuit: $Q_n$ stands for qudit index in the qudit register and $I_n\in \{0,1,\dots ,b-1\}$ stands for a qubit index within a single qudit. The current implementation of the transpiler assigns indices in a straightforward manner, as shown in Figure 3: $Q_n:=\lfloor n/b\rfloor$ and $I_n:=\left(n\mathrm{mod}b\right)$. Although the straightforward mapping is sufficient for qubit and qutrit transpilation, it may produce a less efficient ququart circuit. In this case, users can specify custom mapping based on their circuit. The aspect of proper mapping will be discussed in Section 6. Also, it is intended to develop an algorithm that uses heuristics to generate proper mapping that minimizes the number of two-qudit gates in the resulting circuit [77].

Figure 3. Example for a straightforward mapping for $b=2$. White blocks represent the initial qubits from the QASM circuit. Qubits are uniquely assigned with $Q_n$ and $I_n$ indices. The straightforward mapping assigns $Q=0$ to the first pair of qubits, $Q=1$ to the second pair, and so on. Within a single pair, qubits are distinguished by index I.

These indices are used to convert the qubit circuit into qudit operations. Single-qubit gates for the case $b=1$ (implies $\forall n:I_n=0$) are mapped as

$$\begin{array}{c}{\mathsf{R}}_n(\theta ,\varphi )\to {\mathsf{R}}_{Q_n}^{01}(\theta ,\varphi ),\end{array}$$

(24)

$$\begin{array}{c}{\mathsf{RZ}}_n\left(\theta \right)\to {\mathsf{Ph}}_{Q_n}^1\left(\theta \right).\end{array}$$

(25)

For $b>1$, the transpiler decomposes $\mathsf{R}$ and $\mathsf{RZ}$, considering the position of the qubit within a single qudit ($I_n$ index). This decomposition consists of $2^{b-1}$ qudit gates ${\mathsf{R}}^{ij}$ and ${\mathsf{Ph}}^k$, respectively. Levels i, j and k are obtained explicitly from the $I_n$ index of a qubit. For example, for $b=2$,

$$\begin{array}{c}{\mathsf{R}}_n(\theta ,\varphi )\to \left\{\begin{array}{cc}{\mathsf{R}}_{Q_n}^{01}(\theta ,\varphi )\circ {\mathsf{R}}_{Q_n}^{23}(\theta ,\varphi )\hfill & \mathrm{if}{I}_n=0,\hfill \\ {\mathsf{R}}_{Q_n}^{02}(\theta ,\varphi )\circ {\mathsf{R}}_{Q_n}^{13}(\theta ,\varphi )\hfill & \mathrm{if}{I}_n=1,\hfill \end{array}\right.\end{array}$$

(26)

$$\begin{array}{c}{\mathsf{RZ}}_n\left(\theta \right)\to \left\{\begin{array}{cc}{\mathsf{Ph}}_{Q_n}^1\left(\theta \right)\circ {\mathsf{Ph}}_{Q_n}^3\left(\theta \right)\hfill & \mathrm{if}{I}_n=0,\hfill \\ {\mathsf{Ph}}_{Q_n}^2\left(\theta \right)\circ {\mathsf{Ph}}_{Q_n}^3\left(\theta \right)\hfill & \mathrm{if}{I}_n=1.\hfill \end{array}\right.\end{array}$$

(27)

Notably, decompositions of multiqubit gates can benefit for some qudit parameters d and b. For this case, we used a special trapped ion intermediate representation runtime in the first stage on qudit transpilation. With this runtime, we obtained an optimized circuit that contains multiqubit $\mathsf{MCZ}$ gates, and in the second stage, we utilized these gates to produce the efficient decomposition using different values for transpilation parameters d and b. In our paper, we focus on several cases of qudit transpilation.

The first case is that of qutrits ($d=3$) or ququarts ($d=4$) with $b=1$, having a special $\mathsf{MCZ}$ gate decomposition [62], which efficiently uses higher levels and produces a sequence of $2N-3\in O\left(N\right)$${\mathsf{XX}}^{01|01}$ operations, whereas a straightforward qubit algorithm [78] will require $O\left(2^N\right)$$\mathsf{CX}$/$\mathsf{CZ}$ operations or $O\left(N\right)$ operations with $O\left(N\right)$ ancillary qubits (here, N is the number of qubits involved).

The second case is that of qudits with $b>1$ and $d=2^b$. In this case, all levels are occupied by qubits, thus no ancillary levels can be used. $\mathsf{MCZ}$ gates can be represented in terms of $\mathsf{CZ}$ gates using standard qubit decomposition. However, some of the operations will end up acting on two qubits in a single qudit, and hence, will be decomposed into ${\mathsf{Ph}}^m$ gate instead of ${\mathsf{XX}}^{ij|kl}$ for qubits in different qudits [79]. Considering the matrix representation of $\mathsf{CZ}$, the following definition for a two-qudit gate is obtained:

$$\begin{array}{c}{\mathsf{CZ}}_{nm}\to \left\{\begin{array}{cc}{\mathsf{Ph}}_{Q_n}^3\left(\pi \right)\hfill & \mathrm{if}{Q}_n=Q_m\hfill \\ {\mathsf{XX}}_{Q_n{Q}_m}^{i3|j3}\left(\pi \right)\hfill & \mathrm{if}{Q}_n\ne Q_m\hfill \end{array}\right.\end{array}$$

(28)

where $i=2^{I_n}$ and $j=2^{I_m}$.

Due to the permutation symmetry of $\mathsf{MCZ}$ gate, we can virtually swap qubits to obtain an efficient circuit. There is no issue in the case of qubit transpilation; however, for many qudit cases, it can minimize the amount of qudit $\mathsf{XX}$ gates in template decomposition. The analysis of qubit permutations in $\mathsf{MCZ}$ for qudits will be considered in future works.

The third step of transpilation consists of optimizing the qudit circuit according to the allowed level transitions and the production of the qudit circuit descriptor for execution, as described in Section 4. The circuit after the second step consists of qudit operations ${\mathsf{Ph}}^i$, ${\mathsf{R}}^{ij}$ and ${\mathsf{XX}}^{ij|kl}$, while the trapped ion computer accepts operations with specific transition levels only. The transpiler uses level swap operations ${\mathsf{SWAP}}^{ij}$ from Equation (21) whenever possible and keeps only the operations allowed by a selection rule:

$$\begin{array}{c}{\mathsf{G}}_n^i\to {\mathsf{SWAP}}_n^{is}\circ {\mathsf{G}}_n^s\circ {\mathsf{SWAP}}_n^{si},\end{array}$$

(29)

$$\begin{array}{c}{\mathsf{G}}_n^i\in \{{\mathsf{R}}_n^{i·(·i)},{\mathsf{XX}}_{n·}^{i·|··(·i|··)},{\mathsf{XX}}_{·|n}^{··|i·(··|·i)}\},\end{array}$$

(30)

where ${\mathsf{G}}_n^i$ is a pattern for operation acting at the i-th level in the n-th qudit. Using this rule, the transpiler is able to convert any ${\mathsf{R}}^{ij}$ or ${\mathsf{XX}}^{ij|kl}$ operation into the sequence of allowed transitions for a given adjacency graph between levels in a given qudit device.

Along with the conversion of the allowed operations, the transpiler optimizes the resulting qudit circuit. Although most initial gates from QASM are already optimized during qubit transpilation, the circuit has the potential for optimization after applying level swaps and $\mathsf{MCZ}$ gate decompositions. This optimization step differs from qubit optimization due to more specific matching rules. They include combinations of rotations and removing operations that are non-affecting on measurement results ${\mathsf{Ph}}^i\left(\theta \right)$:

$$\begin{array}{cc}\hfill {\mathsf{Ph}}^i\left({\theta }_1\right)\circ {\mathsf{Ph}}^i\left({\theta }_2\right)& \to {\mathsf{Ph}}^i\left({\theta }_1+{\theta }_2\right)\hfill \end{array}$$

(31)

$$\begin{array}{cc}\hfill {\mathsf{Ph}}^i\left(2n\pi \right)& \to \mathsf{Id}\hfill \end{array}$$

(32)

$$\begin{array}{cc}\hfill {\mathsf{R}}^{ij}\left({\theta }_1,\varphi \right)\circ {\mathsf{R}}^{ij}\left({\theta }_2,\varphi \right)& \to {\mathsf{R}}^{ij}\left({\theta }_1+{\theta }_2,\varphi \right)\hfill \end{array}$$

(33)

$$\begin{array}{cc}\hfill {\mathsf{R}}^{ji}(\theta ,\varphi )& \to {\mathsf{R}}^{ij}(\theta ,-\varphi )\hfill \end{array}$$

(34)

$$\begin{array}{cc}\hfill {\mathsf{R}}^{ij}(2n\pi ,\varphi )& \to \mathsf{Id}\hfill \end{array}$$

(35)

$$\begin{array}{cc}\hfill {\mathsf{XX}}^{ij\mid kl}\left({\theta }_1\right)\circ {\mathsf{XX}}^{ij\mid kl}\left({\theta }_2\right)& \to {\mathsf{XX}}^{ij\mid kl}\left({\theta }_1+{\theta }_2\right)\hfill \end{array}$$

(36)

$$\begin{array}{cc}\hfill {\mathsf{XX}}^{ij\mid kl}\left(2n\pi \right)& \to \mathsf{Id}\hfill \end{array}$$

(37)

Rules are designed to preserve the unitary matrix of the circuit, to reduce the amount of ${\mathsf{R}}^{ij}$ and ${\mathsf{XX}}^{ij|kl}$ operations and to try to move ${\mathsf{Ph}}^i$ to the end of the circuit. The last is used to remove trailing phases since they are not affecting measuring in computational Z-basis. Yet this step doesn’t preserve unitary matrix of the circuit and is considered optional.

At the end, the transpiler is able to produce a qudit circuit in the format presented in Section 3. Since this format supports several circuits in a single JSON file, all input QASM files are placed into a single output file.

Notably, qudit circuits and qudit computers operate with qudits and dits (classical numbers $0,1,\cdots ,d-1$), rather than qubits and bits. This fact leads to the problem of unmapping qudit experiment samples into qubit results. Given qudit computer execution output is an array of qudit states and samples counts, we only have to convert qudit states into qubit states using the mapping.

Qudit state is represented either as an array of numbers (e.g., [0, 1, 2, 1, 2]), or as a string (e.g., “01212”). Firstly, since each qudit consists of b qubits, dits $0,1,\cdots ,2^b-1$ are the only values that should be observed in an experiment. Although other dits with values $\ge 2^b$ are still can be sampled, they are considered as an error and can be excluded from qubit samples (strict mode) as shown in Figure 4. The other way to handle higher dits is to interpret them as the highest allowed level $2^b-1$ (non-strict mode). Secondly, dits can be converted into binary representation (0 → “000”, 1 → “001”, etc.), where each bit corresponds to one of the qubit from the original circuit. The index of the qubit can be obtained by inverting qubit-to-quqit mapping, using indices $Q_n$ and $I_n$. For each dit at position Q from the sampling and for each bit within dit I, we find a qubit index n such that $Q=Q_n$ and $I=I_n$. In strict mode, if there is no qubit n we assert that I-th bit in Q-th dit is 0, which is possible if there are empty places for qubits in the mapping. Otherwise, in non-strict mode, we just ignore bits not in the mapping and set them to 0. This is equivalent to a partial trace of qudit state over the valid qubit states. Transpiler steps with qubit-to-qudit mapping, along with qudit samples post-processing (unmapping), represent the main part of the workflow qubit circuit execution on qudit-based hardware (Figure 5). In total, any hardware-agnostic QASM circuit serves as an input to this workflow, with the possibility of using custom qubit-to-quqit mapping. After the workflow execution, we obtain qubit results that can be matched with our input circuit. This approach was introduced in [77] and developed in this paper.

Figure 4. Two possible ways to convert qudit state back to qubit state. The first is strict mode which considers levels $\ge 2^b$ as an error and excludes them from resulting samples. The second is non-strict mode, which converts these levels to the highest allowed level.

Figure 5. Qudit transpilation, quantum execution and sample unmapping form the workflow for qubit circuit execution on qudit-based hardware.

6. Comparison of Transpilation Approaches

To benchmark developed transpiler techniques, in Table 1, we provide a comparison of output circuits for different commonly used cases and different transpiler options that include optimization, qudit level count d, and qubits per qudit parameter b. The With optimization column implies all optimization techniques from Section 5, whereas Without optimization column only decomposes the QASM circuit into $\mathsf{I}\mathsf{q}\mathsf{c}\mathsf{C}\mathsf{i}\mathsf{r}\mathsf{c}\mathsf{u}\mathsf{i}\mathsf{t}.$ Moreover, we used the Qiskit [71] quantum computing framework using $\mathsf{q}\mathsf{i}\mathsf{s}\mathsf{k}\mathsf{i}\mathsf{t}.\mathsf{q}\mathsf{a}\mathsf{s}\mathsf{m}2.\mathsf{l}\mathsf{o}\mathsf{a}\mathsf{d}$ and $\mathsf{q}\mathsf{i}\mathsf{s}\mathsf{k}\mathsf{i}\mathsf{t}.\mathsf{t}\mathsf{r}\mathsf{a}\mathsf{n}\mathsf{s}\mathsf{p}\mathsf{i}\mathsf{l}\mathsf{e}$ functions that convert the QASM circuit to a native gate set for a given target and perform optimizations. In our case, this was for the trapped ion quantum computer with native gates $\mathsf{RZ}$, $\mathsf{R}$ and $\mathsf{XX}$. However, to our knowledge, the Qiskit framework is not able to produce qudit circuits. So, it can only be compared with the developed transpiler with parameters $d=2$ and $b=1$, which is equivalent to the qubit transpilation.

Table 1. Comparison of transpilation for different regimes. We produce the circuits for each case and permute qubits manually in order to obtain a minimum $\mathsf{XX}$ count in the ququart regime. This permutation does not affect the gate count in qiskit, qubit and qutrit regimes.

Name	Regime	Without Optimization			With Optimization
		$\mathsf{RZ}$ Count	$\mathsf{R}$ Count	$\mathsf{XX}$ Count	$\mathsf{RZ}$ Count	$\mathsf{R}$ Count	$\mathsf{XX}$ Count
Bernstein–Vazirani identify ${101}_2$ string	qiskit	-	-	-	0	24	2
	qubit	16	22	2	6	13	2
	qutrit	16	22	2	6	13	2
	ququart	25	72	1	5	42	1
Bernstein–Vazirani identify ${10101}_2$ string	qiskit	-	-	-	0	36	3
	qubit	24	32	3	8	19	3
	qutrit	24	32	3	9	19	3
	ququart	37	106	2	7	58	2
Grover find ${000}_2$ string	qiskit	-	-	-	4	35	7
	qubit	22	48	6	7	13	6
	qutrit	14	42	4	9	18	4
	ququart	25	172	4	7	82	4
Grover find ${0000}_2$ string	qiskit	-	-	-	30	128	40
	qubit	93	223	36	37	47	36
	qutrit	29	135	16	18	73	16
	ququart	130	704	20	31	353	20
SWAP test 1 qubit states	qiskit	-	-	-	3	24	7
	qubit	22	42	7	8	11	7
	qutrit	14	36	5	4	15	5
	ququart	22	132	4	1	59	4
SWAP test 2 qubits states	qiskit	-	-	-	6	47	14
	qubit	44	82	14	15	19	14
	qutrit	28	70	10	7	28	10
	ququart	44	256	8	1	114	8

We choose the following list of circuits for a comparison of different transpilation regimes:

• Bernstein–Vazirani algorithm:

  –

  The identification of ${101}_2$ binary string on 3 qubits and 1 ancillary qubit;

  –

  The identification of ${10101}_2$ binary string on 5 qubits and 1 ancillary qubit.

• Grover algorithm:

  –

  Finding ${000}_2$ binary string on 3 qubits and 1 ancillary qubit;

  –

  Finding ${0000}_2$ binary string on 4 qubits and 1 ancillary qubit.

• Swap test:

  –

  Orthogonal qubit states on 3 qubits;

  –

  Orthogonal 2-qubits states on 5 qubits.

These input qubit circuits have a representation in QASM format, which is the same for every regime:

• qiskit: $\mathsf{q}\mathsf{i}\mathsf{s}\mathsf{k}\mathsf{i}\mathsf{t}.\mathsf{q}\mathsf{a}\mathsf{s}\mathsf{m}2.\mathsf{l}\mathsf{o}\mathsf{a}\mathsf{d}$, $\mathsf{q}\mathsf{i}\mathsf{s}\mathsf{k}\mathsf{i}\mathsf{t}.\mathsf{t}\mathsf{r}\mathsf{a}\mathsf{n}\mathsf{s}\mathsf{p}\mathsf{i}\mathsf{l}\mathsf{e}$ with trapped-ion basic gates;
• qubit: level count $d=2$, qubits per qudit $b=1$;
• qutrit: level count $d=3$, qubits per qudit $b=1$;
• ququart: level count $d=4$, qubits per qudit $b=2$.

We note that the qiskit regime is only shown as optimized since $\mathsf{q}\mathsf{i}\mathsf{s}\mathsf{k}\mathsf{i}\mathsf{t}.\mathsf{t}\mathsf{r}\mathsf{a}\mathsf{n}\mathsf{s}\mathsf{p}\mathsf{i}\mathsf{l}\mathsf{e}$ always optimizes the input circuit.

Firstly, the effect of circuit optimization can be clearly observed. For every circuit from the list, an optimization pass reduces the number of $\mathsf{R}$ gates at least by 41%. Furthermore, some cases have a reduction of up to 79% in gate amount in the case of Grover’s algorithm for qubit regime. Notably, the whole circuit can be optimized if the optimizer decides that it is equivalent to the $\mathsf{Id}$ operation. In these experiments, we did not use barriers in the circuits.

Secondly, our transpiler shows better output (in terms of the amount of $\mathsf{R}$ gates) than the $\mathsf{q}\mathsf{i}\mathsf{s}\mathsf{k}\mathsf{i}\mathsf{t}.\mathsf{t}\mathsf{r}\mathsf{a}\mathsf{n}\mathsf{s}\mathsf{p}\mathsf{i}\mathsf{l}\mathsf{e}$ function. However, this result is obtained by the increased number of $\mathsf{RZ}$ gates in an output circuit. However, regarding the fact that $\mathsf{RZ}$ gates are implemented virtually on qudit quantum computer, our optimization results can be considered more effective.

Thirdly, qutrit and ququart regimes can also optimize the amount of $\mathsf{XX}$ gates. This result has more impact since two-qudit gates are more subjected to errors than single-qudit gates. This effect takes place in circuits with a large number of qubits. However, the single-qudit gate amount for these regimes is much greater than the qubit amount. This is due to our optimization workflow that only optimizes gates on the same levels, but the circuit can contain gates on all pairs of levels. One can consider a simplistic approach to choosing a preferable regime for running a circuit. Given estimates of single-qubit and two-qubit gate errors ($e_{1\mathrm{b}}$ and $e_{2\mathrm{b}}$), as well as single-qudit and two-qudit gate errors ($e_{1\mathrm{d}}$ and $e_{2\mathrm{d}}$), the resulting errors in a qubit-based and qudit-based circuit can be approximately upper-bounded as

$$\begin{array}{cc}\hfill E_{\mathrm{b}}& =e_{1\mathrm{b}}{N}_{1\mathrm{b}}+e_{2\mathrm{b}}{N}_{2\mathrm{b}},\hfill \\ \hfill E_{\mathrm{d}}& =e_{1\mathrm{d}}{N}_{1\mathrm{d}}+e_{2\mathrm{d}}{N}_{2\mathrm{d}},\hfill \end{array}$$

(38)

where $N_{1\mathrm{b}\left(\mathrm{d}\right)}$ and $N_{2\mathrm{b}\left(\mathrm{d}\right)}$ are the numbers of single-qubit (qudit) and two-qubit (qudit) gates correspondingly. Comparing $E_{\mathrm{b}}$ and $E_{\mathrm{b}}$ can help one to choose the best way to run the circuit on the available hardware. We note that $N_{1\mathrm{b}\left(\mathrm{d}\right)}$ can be calculated without including virtual phase gates. We also note that, due to the mentioned fact that the optimization workflow optimizes gates at the same level, but a circuit may contain gates between all pairs of levels, the idea of whole qudit optimization arises. This can decompose any sequence of operations or a general single-qudit unitary matrix into the most optimal sequence in terms of the number of $\mathsf{R}$ gate amount, as was conducted in [80].

It is worth noting that the performance of the ququart regime is significantly influenced by the qubit-to-qudit mapping. Specifically, the way in which qubits are distributed among qudits has a significant impact on the resulting number of entangling gates. Within a straightforward mapping, for example, three qubits that are affected by the Fredkin $\mathsf{CSWAP}$ gate in the Swap test (2 qubit states) algorithm are placed in separate ququarts, resulting in 16 $\mathsf{XX}$ gates in the qudit circuit. However, with a more carefully designed mapping, it is possible to store two of these qubits in a single ququart, reducing the number of $\mathsf{XX}$ gates to 8. This example demonstrates that different mappings can lead to better or worse results than the qubit regime. Therefore, finding an optimal mapping for a particular circuit is crucial when running a qubit circuit on a qudit platform.

7. Conclusions

In this paper, we provided the general workflow for converting qubit QASM circuits into qudit circuits and compared transpilation for different regimes. With different values for parameters d (dimension of qudit) and b (qubit count in a single qudit), the transpiler uses different decomposition approaches and produces a qudit circuit, which can be executed on a quantum computer with qudit dimension $\ge d$. Parameters d and b should be chosen reasonably for a given problem. The first example is that circuits with a high arity of $\mathsf{MCX}$/$\mathsf{MCZ}$ gates benefit from the qutrit regime since it decomposes a multiqubit gate into $2N-3$ two-qudit operations, whereas qubit decomposition has at least $O\left(N\right)$ two-qudit gates. The second example is circuits with distinct pairs of qubits with a high weight of interconnection (amount of two-qubit gates) within a pair and low interconnection between pairs. Using the ququart regime and an appropriate qubit-to-qudit mapping can greatly reduce the amount of two-qudit gates compared to the qubit regime, although optimal mapping could be performed automatically (locally for each $\mathsf{MCZ}$ and globally for a whole circuit). Since naive mapping optimization via finding the best qubit permutation requires $O\left(N!\right)$, we leave the nearly optimal mapping finding feature to future versions of the transpiler.

We also consider qudit circuit optimization that reduces qudit gate amount in the resulting circuit. For different regimes, the reducing factor is in the range of 40% to 80%. Optimization routine accounts allowed transitions for $\mathsf{R}$ and $\mathsf{XX}$ gates for a given target qudit system. However, current optimization can be further improved to produce the most optimal output. This is the main focus for future work.