Optimal Synthesis of Multi-Controlled Qudit Gates

At present, quantum computing has entered the era of noisy medium-scale quantum (NISQ) systems, where there are inherent limitations on size, depth, and the number of qubits of quantum circuits that can be supported by physical experimental hardware, so the degree of optimization of quantum circuits directly affects the scope of application of quantum computers [1]. Designing quantum circuits as small as possible, as shallow as possible, and using as few qubits as possible for various computational problems is one of the most important research directions in the field of quantum computing [2, 3, 4, 5, 6, 7, 8, 9].

While typical quantum circuits are expressed in terms of qubits (two-level quantum systems), many of the underlying physical systems, e.g. the quantum processors based on photonic systems [10, 11], ion traps [12, 13], and superconducting devices [14, 15], have much higher natural dimensions, where the proposed type of qubit is actually a restricted subspace of the higher-dimensional systems. By utilizing the other wasted dimensions accessible, mainly because of the increment of the device’s information density, we can reduce the resource requirements of quantum circuits [16, 17], even exponentially [4]! So, to extend the frontier of what quantum computers can compute, in particular for those whose underlying physical system (e.g., those based on ion traps [18]) suffers from poor scalability (i.e., supports only a small number of qubits), it is a promising way to utilize the higher dimensions and work with qudits instead of qubits to implement quantum circuits.

Compared with qubit circuits, there is much less research on the optimization of qudit circuits, and the qudit synthesis of many basic primitives remains to be optimized. The class of multi-controlled qudit gates is an important such primitive, which is widely used in many quantum algorithms, including unitary synthesis [5, 19, 20], Grover’s search algorithm [21], arithmetic operators synthesis [22, 23], and implementation of classical reversible functions [24]. There is a standard synthesis of multi-controlled $d$-level qudit gates by using $O(k)$ two-qudit gates, whose two-qudit gate count is optimal, but using as many as $\lceil(k-2)/(d-2)\rceil$ clean ancilla [5, 23]. Here, $k$ is the number of controls. The synthesis in [25] is ancilla-free but uses an exponential number of two-qudit gates. Di and Wei [20] claimed an ancilla-free synthesis by using $O(k^{3})$ two-qudit gates, which significantly improves the synthesis in [25]. Recently, Yeh and van de Wetering [24] studied how to synthesize multi-controlled qutrit ($3$-level qudit) gates in a fault-tolerant manner, and obtained an ancilla-free synthesis of any multi-controlled Clifford+T unitary on qutrits by using $O(k^{3.585})$ Clifford+T gates.

In this paper, we propose a one-clean-ancilla synthesis of any $k$-controlled qudit gate by using just $O(k)$ two-qudit gates, which achieves optimality both on size and number of ancilla up to just one ancilla. The core of our synthesis is an $O(k)$-size synthesis of a special $k$-controlled qudit gate, namely the $k$-controlled Toffoli gate using no ancilla when $d$ is odd or just one borrowed ancilla when $d$ is even. In addition, our synthesis of the $k$-controlled Toffoli gate directly leads to an improvement from $O(k^{3.585})$ to $O(k)$ in the Clifford+T gate count of [24]’s synthesis mentioned above. As applications, our synthesis can be used to improve various quantum algorithms, e.g., synthesis of arithmetic operators [22, 23] and $d$-ary Grover’s algorithm [21]. In particular, it has the following significant implications.

Here, by substituting our improved synthesis of multi-controlled qudit gates, we can significantly reduce the number of clean ancilla from $\lceil(n-2)/(d-2)\rceil$ to just $1$, while keeping the two-qudit gate count still optimal (see Section IV-A).

Here, for any $d\geq 3$, by substituting our improved synthesis of multiple-controlled Toffoli gate, we obtain an $O(d^{n}n)$-size implementation of any $n$-variable $d$-ary classical reversible function, where the size is optimal up to a logarithmic factor, and using no ancilla when $d$ is odd and just one borrowed ancilla when $d$ is even (see Section IV-B). In particular, when $d=3$, our implementation remains fault-tolerant, which answers an open question proposed in [24].

The rest of this paper is organized as follows. Section II presents preliminaries. In Section III, we show how to synthesize multiple-controlled qudit gates. In Section IV, we apply our synthesis to improve the unitary synthesis and the implementation of classical reversible functions. We conclude this paper in Section V.

For a positive integer $d$, let $[\underline{d}]$ denote the set $\{0,1,\cdots,d-1\}$. We will use boldface type characters, e.g., $\bm{x}$, for vectors. For a vector $\bm{x}=(x_{1},\cdots,x_{n})$ and $1\leq i<j\leq n$, let $\bm{x}_{i:j}$ denote the subvector $(x_{i},x_{i+1},\dots,x_{j})$.

A qubit is a two-level quantum-mechanical system, or mathematically associated with a two-dimensional Hilbert space. Similarly, a $d$-level qudit is associated with a $d$-dimensional Hilbert space where $d\geq 3$ is an integer. Let $\ket{0},\ket{1},\cdots,\ket{d-1}$ denote the computational basis of a $d$-level qudit. Any state on a $d$-level qudit can be written as $\ket{\phi}=\sum_{i=0}^{d-1}\alpha_{i}\ket{i}$ where each $\alpha_{i}$ is a complex number and $\sum_{i=0}^{d-1}|\alpha_{i}|^{2}=1$, or mathematically is a unit vector in the Hilbert space. Throughout the paper, we treat $d$ as a constant, and a $\poly(d)$ factor may be hidden in the big $O$ notation.

Quantum states can be acted on by quantum gates, which are mathematically unitary operators on the Hilbert space. We introduce some quantum gates acting on qudits that we will meet.

Let $\mathcal{G}$ denote the gate set $\{\ket{0}\text{-}X_{01}\}\cup\{X_{ij}:i\neq j\}$, and call gates from $\mathcal{G}$ $\mathcal{G}$-gates. An easy observation is that both $\ket{\ell}$-$X_{+y}$ and $\ket{\ell}$-$X_{ij}$ can be synthesized by using $O(d)$ $\mathcal{G}$-gates.

For a gate $U$, $U^{\dagger}$ is the inverse of $U$, or mathematically the adjoint of $U$. In particular, $U^{\dagger}=U$ for each $U\in\mathcal{G}$, $X_{+y}^{\dagger}=X_{+(d-y)}$, and $(U_{n}U_{n-1}\cdots U_{1})^{\dagger}=U_{1}^{\dagger}\cdots U_{n-1}^{\dagger}U_{n}^{\dagger}$. Recall that $UU^{\dagger}=U^{\dagger}U=I$. Here, $I$ is the identity operator.

Ancilla qudits are extra qudits not involved in the logical operation that is performed. According to the initial state and final state, ancilla qudits can be classified into four types:

• •

  A Burnable Ancilla is an ancilla whose initial state is $\ket{0}$ and final state can be arbitrary.

• •

  A Clean Ancilla is an ancilla whose initial state and final state are both $\ket{0}$.

• •

  A Garbage Ancilla is an ancilla whose initial state and the final state can be both arbitrary.

• •

  A Borrowed Ancilla is an ancilla whose initial state can be arbitrary and final state is the same as the initial state.

In this section, we show how to synthesize the $\ket{0^{k}}$-$U$ gate by using $O(k)$ two-qudit gates and one clean ancilla. The core is a synthesis of the $k$-Toffoli gate by using $O(k)$ $\mathcal{G}$-gates and at most one borrowed ancilla (see Theorem III.2 and III.6), which directly leads to the desired synthesis of $\ket{0^{k}}$-$U$ as shown in Fig. 1(b).

In the rest of this section, we focus on the synthesis of the $k$-Toffoli gate on $d$-level qudits. When $d$ is even, the synthesis is essentially the same to that for qubits [27]. When $d$ is odd, the synthesis turns out to be totally different, which is the main technical part of this paper.