One Additional Qubit is Enough: Encoded Embeddings for Boolean Components in Quantum Circuits

TL;DR

This paper demonstrates that a single additional qubit suffices to embed any non-reversible Boolean function into a reversible quantum circuit using variable-length encoding, significantly reducing qubit overhead.

Contribution

It proves that only one extra qubit is needed for embedding any Boolean function reversibly, and characterizes functions that require no additional qubits, advancing quantum circuit design.

Findings

One extra qubit is always enough for embedding any Boolean function.

Variable-length encoding reduces qubit overhead in quantum oracles.

Some functions do not require additional qubits at all.

Abstract

Research on quantum computing has recently gained significant momentum since first physical devices became available. Many quantum algorithms make use of so-called oracles that implement Boolean functions and are queried with highly superposed input states in order to evaluate the implemented Boolean function for many different input patterns in parallel. To simplify or enable a realization of these oracles in quantum logic in the first place, the Boolean reversible functions to be realized usually need to be broken down into several non-reversible sub-functions. However, since quantum logic is inherently reversible, these sub-functions have to be realized in a reversible fashion by adding further qubits in order to make the output patterns distinguishable (a process that is also known as embedding). This usually results in a significant increase of the qubits required in total. In this work, we show how this overhead can be significantly reduced by utilizing coding. More precisely, we prove that one additional qubit is always enough to embed any non-reversible function into a reversible one by using a variable-length encoding of the output patterns. Moreover, we characterize those functions that do not require an additional qubit at all. The made observations show that coding often allows one to undercut the usually considered minimum of additional qubits in sub-functions of oracles by far.

Tables

Table 1. TABLE I : Truth table of the half adder function

$x_1$	$x_2$	$y_1$	$y_0$
0	0	0	0
0	1	0	1
1	0	0	1
1	1	1	0

Table 2. (a) Before embedding

$x_1$	$x_2$	$y_1$	$y_0$
0	0	0	0
0	1	0	1
1	0	0	1
1	1	1	0

Table 3. (b) After embedding

$a$	$x_1$	$x_2$	$g$	$y_1$	$y_0$
0	0	0	0	0	0
0	0	1	1	0	1
0	1	0	0	0	1
0	1	1	1	1	0
1	0	0	0	1	0
1	0	1	0	1	1
1	1	0	1	0	0
1	1	1	1	1	1

Table 4. TABLE II : Encoding a non-reversible function

$x_3$	$x_2$	$x_1$	$x_3^{\prime }$	$x_2^{\prime }$	$x_1^{\prime }$
0	0	0	1	1	0
0	0	1	0	0	0
0	1	0	1	1	0
0	1	1	1	0	0
1	0	0	0	0	0
1	0	1	1	1	1
1	1	0	1	1	0
1	1	1	1	1	0

Table 5. (a) Orig. function

$x_3$	$x_2$	$x_1$	$x_3^{\prime }$	$x_2^{\prime }$	$x_1^{\prime }$
0	0	0	1	1	0
0	0	1	0	0	0
0	1	0	1	1	0
0	1	1	1	0	0
1	0	0	0	0	0
1	0	1	1	1	1
1	1	0	1	1	0
1	1	1	1	1	0

Table 6. (b) Encoding

$i$	$p_i$	$\mu \left(p_i\right)$	$code\left(p_i\right)$
1	110	4	0 - -
2	000	2	1 0 -
3	100	1	1 1 0
4	111	1	1 1 1

Table 7. (c) Encoded function

$x_3$	$x_2$	$x_1$	$x_3^{\prime }$	$x_2^{\prime }$	$x_1^{\prime }$
0	0	0	0	-	-
0	0	1	1	0	-
0	1	0	0	-	-
0	1	1	1	1	0
1	0	0	1	0	-
1	0	1	1	1	1
1	1	0	0	-	-
1	1	1	0	-	-

Table 8. TABLE III : Number of required qubits

Benchmark			Embedding
name	$n$	$m$	Bennett [23]	Min. [13, 14]	Encoded
\csvreader[ late after line=
, late after last line=
\Coded

Equations

$$\big{(}w(a_{2}),w(b_{2})\leq w(a_{1})\big{)}\lor\big{(}w(a_{2}),w(b_{2})\geq w(b_{1})\big{)}.\quad\quad\quad$$

$$w(c)-w(a)-w(b)$$

$$=2^k-2^{k-l}$$

$$<2^k,$$

Full text

I Introduction

Quantum algorithms running on quantum computers allow for significant (exponential in the best case) speed-ups compared to their classical counterparts by exploiting quantum-mechanical phenomena like superposition, entanglement, and phase shifts [1]. Recently, devices that have been made publicly available—together with the commitment of companies like IBM, Google, Microsoft, and Rigetti—brought new momentum into a domain that has been considered as a “dream of the future” for a long time [2, 3, 4]. Even though these first devices are limited in qubit fidelity and their number of qubits (i.e., they are classified as NISQ devices [5]), they provide a first step towards building a fault-tolerant quantum computer that is capable of conducting hard and useful tasks in non-exponential time.

Many proposed quantum algorithms contain large Boolean parts (also called oracles) that are queried with a highly superposed input to gain quantum speed-up. Examples are the modular exponentiation in Shor’s algorithm for integer factorization [6] or a Boolean description of the database that is queried in Grover’s Algorithm [7]. In order to use these Boolean components on a quantum computer, they have to be described as quantum circuits (i.e., a sequence of quantum operations that are applied to the qubits)—an inherently reversible description means. Since it is very complex to determine a sequence of quantum operations (also denoted quantum gates) that realize the desired functionality (a process termed synthesis [8, 9]), the Boolean function to be realized is usually decomposed into several (not necessarily reversible) sub-functions [10, 11, 12]. Hence, even though the overall functionality of the oracle is inherently reversible, its sub-components may not be.

In order to realize non-reversible functions in quantum logic, further qubits (often called ancillary, ancillae, or working qubits) have to be added in order to make the output patterns distinguishable and, hence, obtain a reversible function (a process called embedding [13, 14]). Moreover, such additional qubits are often used to store intermediate results and have to be restored to their initial state (by de-computing intermediate results) before “leaving” the oracle. All this obviously increases the number of qubits needed to realize the oracle. In fact, even if the embedding process guarantees a minimum of ancillary/ancillae/working qubits, their number is frequently quite substantial—a severe drawback since qubits are a highly limited resource.

In order to overcome the issue outlined above, we propose to utilize coded embeddings where each occurring output pattern is encoded with another (smaller) unique pattern. This way, we utilize recently proposed embedding and synthesis schemes such as one-pass synthesis of reversible logic [15] as well as synthesis exploiting coding techniques [16, 17] for the realization of quantum oracles. Encoding outputs allows us to significantly reduce the number of qubits even below what is usually considered to be the minimum. Although this changes the intended functionality, using encoded values is still acceptable for the realization of oracles since subsequent sub-components just have to be slightly adjusted to handle the code, or need to be equipped with a small decoder beforehand (which often is easier to realize than the original functionality).

Moreover, in this work we show for the first time that utilizing all that potential indeed allows for the realization of Boolean non-reversible sub-components with at most one additional qubit only. In addition to that, we exactly identify the cases where even this additional qubit is not necessary. By this, we can provably show that, using coding, one additional qubit is enough, i.e., that the proposed scheme often allows one to undercut the usually considered minimum of additional qubits in oracles by far. This is additionally confirmed by experimental evaluations. Note that while we only cover the two-valued case here—since this is the de facto standard in quantum computation and a large set of benchmarks is available for evaluation—we expect that our (theoretical) results can be extended to the multiple-valued case with a radix $r>2$ in a straightforward fashion (e.g., using the generalization as proposed in [18]).

The remainder of this work is structured as follows. In Section II, we briefly introduce the basics of quantum circuits as well as how non-reversible functions can be realized by them. Section III provides a technique for encoding the function to be realized. Here, we also formally prove that using a variable-length code indeed allows for realizations with at most one additional qubit. Section IV compares the number of required qubits in coded embeddings to those embeddings (without encoding) that have been considered to be the minimum thus far. Section V concludes the paper.

II Background

In this section, we briefly recap the basics of quantum circuits, as well as how to realize Boolean components occurring in them.

II-A Quantum Circuits

Quantum computations are conducted by applying operations to qubits—entities that cannot only be in one of its two basis states (denoted $\left|0\right\rangle$ and $\left|1\right\rangle$), but also in an (almost) arbitrary superposition of both. Typical operations acting on a single qubits are negating the state of a qubit (NOT operation, denoted by $X$ or $\oplus$), setting a qubit into superposition (Hadamard operation, denoted by $H$), or conducting a phase shift by $i$ (denoted by $S$). Moreover, these operations may be controlled by other qubits. Then, the operation is only conducted if all controlling qubits are in basis state $\left|1\right\rangle$. All these computations may be represented by means of circuit diagrams, where each qubit is represented by a horizontal line and quantum gates (i.e., operations that are applied to the qubits) on these lines determine (from left to right) in which order the respective operations are applied to the qubits.

Example 1**.**

The quantum circuit shown in Fig. 1(a) is composed of two qubits and two gates. First, a Hadamard operation is applied to qubit $q_{0}$, setting $q_{0}$ into a superposition. Afterwards, a controlled NOT (CNOT) operation is conducted, where $q_{0}$ serves as control qubit and $q_{1}$ is the target qubit. Here, the value of $q_{1}$ is inverted if $q_{0}$ is in the basis state $\left|1\right\rangle$.

Reversible circuits are a subset of quantum circuits that can be modeled in the classical domain. Hence, these circuits are used when designing Boolean components for quantum circuits and are usually composed of multiple-controlled Toffoli gates. These gates are composed of a (possibly empty) set of control qubits and a so-called target qubit. The value of the target qubit is inverted if, and only if, all control qubits are in basis state $\left|1\right\rangle$. Hence, the CNOT gate discussed above is a multiple-controlled Toffoli gate with a single control.

Example 2**.**

Consider the reversible circuit shown in Fig. 1(b) that is composed of three qubits and four gates. The target qubit of a Toffoli gate is again denoted by $\oplus$, whereas control qubits are denoted by $\bullet$. Additionally, we have labeled the intermediate values of the qubits throughout the circuit when applying $\left|q_{0}q_{1}q_{2}\right\rangle=\left|000\right\rangle$ as input. Since a reversible circuit can be modeled in the classical domain (no quantum effects are exploited), we use [math] and $1$ to indicate the basis states (rather than $\left|0\right\rangle$ and $\left|1\right\rangle$). The first gate has not control qubits and, thus, inverts the value of $q_{0}$ from 0 to 1. The second gate is controlled by $q_{0}$. Since the value of $q_{0}$ is 1, the value of $q_{1}$ is inverted from 0 to 1. The second gate does not affect the state of the qubits, since the control qubit $q_{2}$ is set to 0. Eventually, the last gate inverts the state of $q_{2}$ from 0 to 1.

II-B Boolean Components in Quantum Circuits

Typically, quantum circuits contain large Boolean components (also called oracles) which can be realized by reversible circuits. Decompositions of the gates occurring in reversible circuits into elementary quantum operations (e.g., into the well-known Clifford+T library [19]) can be determined using approaches such as [20].

Since Boolean components occurring in quantum circuits commonly describe very complex functionality, they are usually split into several non-reversible parts (e.g., the modular exponentiation in Shor’s algorithms can be build up from several adders)—either manually [10, 11, 12] or by automated synthesis tools (using methods as reviewed, e.g., in [8, 9]). But since quantum computations are inherently reversible, it has to be ensured that these sub-components are realized in a reversible fashion, i.e., as a function realizing a unique mapping from the inputs to the outputs and vice versa.

Example 3**.**

Consider the truth table of a half adder shown in Table I(a) and assume that this functionality shall be realized as a sub-function of an oracle. Since the output pattern 01 occurs twice, the function is not reversible—the input cannot be determined uniquely having the output only.

To ensure a unique input-output mapping, the non-reversible function to be realized is embedded into a reversible one that typically has a much larger number of variables.111Note that each variable of the function is realized by means of a qubit in the quantum circuit. This embedding process can either be conducted explicitly [13, 14] (required when using synthesis approaches such as [21, 22]) or implicitly (using synthesis schemes following one-pass synthesis as employed in [15, 16]). However, conducting the embedding often yields circuits where the number of additional variables and, hence, qubits is significant. Since qubits are a limited resource (especially in NISQ devices [5]) their number shall be kept as small as possible. But even following the state of the art reviewed above, still a rather substantial number of qubits results. In fact, the minimal number of qubits required for embedding thus far is defined as follows:

Definition 1**.**

Consider a Boolean function $f\colon\mathbb{B}^{n}\rightarrow\mathbb{B}^{m}$ with output patterns $p_{1},p_{2},\ldots,p_{k}\in\mathbb{B}^{m}$ ordered by the number of corresponding input patterns (in the following denoted as $\mu(p_{i})=|\{x\in\mathbb{B}^{n}\mid f(x)=p_{i}\}|$). Since the embedding process has to make all output patterns distinguishable, at least $\lceil\log_{2}\mu(p_{1})\rceil$ additional so-called garbage outputs are required (where $p_{1}$ is the most frequently occurring output pattern). Moreover, since the number of inputs and outputs has to be equal to realize a reversible function as quantum circuit, a total of $\min(n,m+\lceil\log_{2}\mu(p_{1})\rceil)$ qubits are required to embed a function $f\colon\mathbb{B}^{n}\rightarrow\mathbb{B}^{m}$. If this implies to add further inputs, the desired output is obtained when setting all ancillary inputs to a specific value (usually 0).

Example 3** (continued).**

Since the most frequently occurring output pattern $p_{1}=01$ occurs twice, $\lceil\log_{2}2\rceil=1$ garbage output is required to make this output pattern distinguishable. To align the number of inputs with the number of outputs, one ancillary input is required. Table I(b) shows one possible embedding of the half adder function. The desired function can be obtained at the primary outputs by setting the ancillary input $a$ to 0 (highlighted in bold). All garbage variables as well as the primary outputs when $a\neq 0$ can be chosen arbitrarily as long as a reversible function results.

The ancillary qubits of all sub-functions of an oracle have to be de-computed to their initial state to allow for a correct execution within the oracle and enable a later reuse.

III One Ancillary Qubit is Enough

The authors of [16, 17] have shown that it is possible to undercut the theoretical lower bound on the number of required qubits (discussed in Section II-B) by using coding techniques, i.e., by using a 1-to-1 mapping of the output patterns to others. In this section, we first review the main idea of this approach and then formally prove that, using a variable-length encoding, at most one ancillary qubit is enough to realize any desired non-reversible function—and, by this, any sub-component of an oracle. Afterwards, in Section IV, it is experimentally confirmed that this indeed allows one to significantly reduce the number of overall required qubits (even below the minimum considered thus far) in many cases.

III-A Utilizing Coding

As shown in [16, 17], the number of additionally required output patterns can be significantly reduced by exploiting coding techniques. The general idea for using coding is motivated by the fact that usually not all output patterns occur equally many times and, thus, do not require the same number of garbage outputs. Hence, a variable-length encoding can be utilized, where frequently occurring output patterns are represented by a short code word (together with a large number of garbage outputs) and rarely occurring output patterns are represented by a longer code word (together with a smaller number of garbage outputs).

Example 4**.**

Consider the Boolean function with $n=3$ inputs and $m=3$ outputs shown in Table II(a). Using an embedding scheme as discussed in Section II-B yields a reversible function with five variables (thus, requiring five qubits). However, using the code as shown in Table II(b) allows one to reduce the number of required qubits to three. For example, the most frequently occurring output pattern $p_{1}=110$ (which requires $\lceil\log_{2}4\rceil=2$ garbage outputs) is encoded as $code(p_{1})=0$, while the output pattern $p_{3}=100$ is encoded by $code(p_{3})=110$. The number of variables/qubits required for each output pattern is then determined by the sum of the code length and the number of required garbage outputs—resulting in the encoded function shown in Table II(c) (dashes indicate garbage variables).

To generate a code as shown above, a Pseudo-Huffman encoding is employed. To this end, one starts with terminal nodes—one for each output pattern with $\mu(p_{i})>0$ (no code has to be assigned to output patterns that do not occur)—and attaches a weight representing the number of required garbage outputs (i.e., $\lceil\log_{2}\mu(p_{i})\rceil$). The Pseudo-Huffman tree is then generated by repeatedly combining the two nodes $a$ and $b$ with the smallest attached weights $w(a)$ and $w(b)$ to a new node $c$ with attached weight $w(c)=\max(w(a),w(b))+1$ until a single node results. The weight of such a node $w(c)$ then gives the number of outputs required to represent all combined output patterns uniquely, i.e., one additional variable is required (aside from $\max(w(a),w(b))$) to distinguish between $a$ and $b$. Hence, the weight of the root node determines the number of overall required outputs in the encoded function. Building the Pseudo-Huffman tree inherently gives such a variable-length encoding of the output patterns by, e.g., assigning 0 (1) to the left (right) successor of each node. Concatenation of the values attached to the path from the root node to a terminal representing an output pattern $p_{i}$ determines $code(p_{i})$.

Example 5**.**

Figure 2 shows the Pseudo-Huffman tree for the function shown in Table II(a). Since there exist four output patterns with $\mu(p_{i})>0$, we start with four terminal nodes (labeled $v_{1}$, $v_{2}$, $v_{3}$, and $v_{4}$, respectively) and attach the number of required garbage outputs as weights (drawn as numbers inside the nodes). First, we combine the nodes $v_{3}$ and $v_{4}$ to a new node $v_{5}$ with weight $w(v_{5})=\max(0,0)+1=1$. Next, we combine the nodes $v_{2}$ and $v_{5}$ to a new node $v_{6}$ with weight $w(v_{6})=\max(1,1)+1=2$. Eventually, the nodes $v_{1}$ and $v_{6}$ are combined to a node $v_{7}$ with weight $w(v_{7})=\max(2,2)+1=3$—the single root node of the tree. The code for the individual output patterns is then determined by the path from the root node to the respective terminal. For example, output pattern $p_{2}=000$ is encoded by $code(p_{2})=10$ since the path traverses the right edge of node $v_{7}$ and the left edge of node $v_{6}$. Overall, the code shown in Table II(b) results.

III-B Proving an Upper Bound of $n+1$ Qubits

In this section, we prove that encoding the output patterns of an $n$-input function as shown above results in a coded function requiring at most $n+1$ variables. Moreover, we show precisely in which cases this additional qubit is required and in which not. To this end, we first formally define the Pseudo-Huffman tree utilized to determine the encoding.

Definition 2** (Pseudo-Huffman Tree).**

Let $G=(V,E)$ be a connected, arborescence (a directed rooted tree) composed of a set of nodes $V=\{v_{1},v_{2},\ldots,v_{|V|}\}$ and a set of edges $E\subset V\times V$, and let $w\colon V\to\mathbb{N}_{0}$ be a labeling of the graph nodes in terms of non-negative weights. Moreover, let $T=\{t\in V\mid\forall v\in V\colon(t,v)\notin E\}\subseteq V$ denote the set of all terminal nodes. Then, $PH=(G,w)$ is called a Pseudo-Huffman tree, if, and only if,

each internal node $v\in V\setminus T$ has exactly two children $a,b\in V$ and $w(v)=\max(w(a),w(b))+1$ and 2. 2.

for any two different internal nodes $v_{1},v_{2}\in V\setminus T$ with children $a_{1},b_{1}$ and $a_{2},b_{2}$, respectively, it holds that $w(a_{1})\leq w(b_{1})$ implies

[TABLE]

In other words, the tree can be formed from the terminal nodes by successively combining nodes with the lowest available weights as described in Section III-A.

The following theorem yields a condition on the terminal nodes of a Pseudo-Huffman tree that is sufficient to restrict the weight of the tree’s root node.

Theorem 1**.**

Let $PH=((V,E),w)$ be a Pseudo-Huffman tree. If there exists an assignment $s_{v}$ for each terminal node $v\in T=\{t\in V\mid\forall v\in V\colon(t,v)\notin E\}$ such that $2^{w(v)}\geq s_{v}>2^{w(v)-1}$ (where $w(v)$ denotes the weight of node $v$) and $\sum_{v\in T}s_{v}=2^{n}$, then the weight $w(v_{r})$ of the root node $v_{r}$ of the tree is either $n$ or $n+1$.

Proof.

Replace all weights using the rule $w\mapsto 2^{w}$. Then the rule for computing the weight of a new node changes from $\max(w(a),w(b))+1$ to $2\cdot\max(w(a),w(b))$. Accordingly, all weights in the tree will be a power of 2.

We perform the proof by arguing about the weights of the nodes when constructing a Pseudo-Huffman tree. To this end, consider the set of all nodes $V^{i}_{r}$ of the tree-under-construction that are the root nodes of the already connected components after step $i$ of the algorithm. Let $w^{i}_{total}=\sum_{v\in V_{r}^{i}}w(v)$ denote the sum of the weights over all these nodes.

At each step $i$ of the algorithm, two nodes $a,b\in V^{i}_{r}$ with minimal weight are chosen and joined to a new node $c$ such that $V^{i+1}_{r}=\{c\}\cup V^{i}_{r}\setminus\{a,b\}$. There are two cases:

both nodes $a$ and $b$ have the same weight $2^{k}$. Then, they are replaced by a node with weight $2^{k+1}$ such that $w_{total}^{i+1}=w_{total}^{i}$ (see Fig. 3(a)), i.e., the sum of the weights over the root nodes remains constant. 2. 2.

one node—assume without loss of generality $a$—has weight $w(a)=2^{k}$ and the other node ($b$) has weight $w(b)=2^{k-l}$ for some $k\geq l>0$. Then, they are replaced by a node $c$ with weight $w(c)=2^{k+1}$ (see Fig.  3(b)).

Since we always take the nodes with minimal weight, there might not be any other node $d\in V^{i}_{r}$ with $w(d)<2^{k}$ as this node would have a higher priority to be joined with $b$. Thus, all nodes in $V^{i}_{r}$ aside from $b$ have a weight that—by construction—is a power of 2 that is greater than or equal to $2^{k}$. Consequently, after joining $a$ and $b$, $w^{i}_{total}$ is increased to a number $w^{i+1}_{total}$ that is divisible by $2^{k}$. More precisely, it is increased by

[TABLE]

such that $w^{i+1}_{total}$ is the smallest number that is greater than $w^{i}_{total}$ and divisible by $2^{k}$.

Clearly, this case happens at most once for each $k>0$, since afterwards there is no more node in $V^{i+1}_{r}$ with a weight less than $2^{k}$ and all nodes that will be added to $V^{j}_{r}$ (for $j>i$) have higher weights.

By the assumption of Theorem 1, we initially have $2^{n}=\sum_{v\in T}s_{v}\leq w^{0}_{total}$ and $w^{0}_{total}<2^{n+1}$. Thus, we will at some point denoted $final$ reach the case that all nodes in $V^{final}_{r}$ have a weight greater than or equal to $2^{n}$ such that $w^{final}_{total}$ is divisible by $2^{n}$. Since $2^{n+1}$ is divisible by all potencies $2^{k}$ for $k=0,\ldots,n$, $w^{final}_{total}$ will never exceed $2^{n+1}$, as we are always increasing $w^{i}_{total}$ to the smallest larger number divisible by $2^{k}$ for a $k\in\{1,\ldots,n\}$. Consequently, we have at least one and at most two nodes in $V^{final}_{r}$ with a weight of $2^{n}$. Thus, the root node of the resulting tree either is the single node with weight $2^{n}$ or the single node with weight $2^{n+1}$ constructed from the two nodes with weight $2^{n}$. Hence, the root node of the original Pseudo-Huffman tree has weight $n$ or $n+1$ as desired. ∎

Now let us interpret this result in the setting of coded Boolean functions. Consider a Boolean function $f:\mathbb{B}^{n}\rightarrow\mathbb{B}^{m}$ to be encoded. We can construct a Pseudo-Huffman tree with $|T|=|\{p_{i}\in\mathbb{B}^{m}\mid\mu(p_{i})>0\}|$ terminal nodes (which is always possible), where each terminal node $v\in T$ uniquely corresponds to one output pattern $p_{i}$ and has assigned $s_{v}=\mu(p_{i})$ (thus, having a weight $w(v)=\lceil\log_{2}\mu(p_{i})\rceil$). As this assignment clearly satisfies the conditions of Theorem 1, the height of this tree is either $n$ or $n+1$. Hence, there exists a coding (which is inherently given by the constructed tree) that requires at most one additional qubit when realizing $f$ in quantum logic.

Moreover, we can precisely determine in which cases this additional qubit is required. In fact, the additional qubit is required whenever there exists an output pattern $p_{i}$ where $\mu(p_{i})>0$ is not a power of two.

Corollary 1**.**

The root node of a Pseudo-Huffman tree satisfying the same assumptions as in Theorem 1 has weight $n$ if, and only if, $\sum_{v\in T}2^{w(v)}=2^{n}$.

Proof.

Given that $\sum_{v\in T}2^{w(v)}=2^{n}$ we may apply Theorem 1 by using the assignment $s_{v}=2^{w(v)}$ for all $v\in T$. Following the argumentation in the proof of Theorem 1, the root node of the Pseudo-Huffman tree has weight $n$ if $w^{i}_{total}$ does not exceed $2^{n}$ at any time, i.e., if the second case (which increases $w^{i}_{total}$) does not occur at all. This is clearly the case if $w^{0}_{total}=2^{n}$ in the beginning. Conversely, if $\sum_{v\in T}2^{w(v)}\neq 2^{n}$, we have $w^{0}_{total}>2^{n}$ in the beginning, such that $w^{final}_{total}=2^{n+1}$ in the end. ∎

IV Comparison to Embeddings without Coding

In this section, we compare the idea of coded embeddings to previous approaches and discuss their effect on the design of quantum oracles.

IV-A Evaluation

We compare the idea of coded embeddings to approaches that do not consider coding when realizing a Boolean function $f\colon\mathbb{B}^{n}\rightarrow\mathbb{B}^{m}$ in quantum logic. More precisely, we compare to exact methods utilizing $\max(n,m+\lceil\log_{2}\mu(p_{1})\rceil)$ qubits [13, 14] as well as to heuristic ones that always utilize a Bennett embedding with $n+m$ qubits [23, 24] (e.g., generated when using an ESoP based synthesis approach [25]). To this end, we have implemented the proposed idea in C++ and utilized the QMDD package [26] as well as the BDD package CUDD [27] to gain a compact representation of the considered functions—allowing us to determine the number of required qubits in negligible runtime. As benchmarks we use the functions from RevLib [28], as well as from the ISCAS [29] and IWLS [30] benchmark suites.222Note that we only consider non-reversible functions from these benchmarks suits since reversible ones do not require embedding.

Table III summarizes the obtained results. The first three columns of the benchmark as well as the number of inputs $n$ and the number of outputs $m$. In the next three columns we list the number of required qubits when using Bennett embedding (i.e., $m+n$), when using a minimal encoding without considering coding (i.e., $\max(n,m+\lceil\log_{2}\mu(p_{1})\rceil)$), and when using coded embeddings as described in this work (i.e., $n$ or $n+1$), respectively.

As can be seen in Table III, the number or required qubits can significantly be reduced when considering coded embeddings—especially in cases where $m>n$. Consider for example benchmarks cps_140 and e64_149, where the number of required qubits can be reduced by 107 and 65, respectively, using coding techniques. Overall, a possible reduction of 36.4% can be observed on average.

IV-B Discussion

Concerning the design of quantum oracles, coded embeddings as proposed above can be exploited in two different ways:

• •

On the one hand, one can apply the coding technique locally on each and every sub-component and use decoders (after each sub-component) to translate the encoded results to the original ones which are then used as inputs of the subsequent components. This essentially reduces the complexity of synthesis for the individual sub-components (since a smaller number of qubits needs to be considered). While this offers a significant improvement of synthesis run-time (as also observed in [16]), the total number of additional qubits does not change (due to the decoders).

• •

On the other hand, one can apply the coding technique globally such that the encoded outputs of one sub-component are directly used as input for subsequent components and a single decoder at the end translates the final results to the desired ones. This approach significantly reduces the number of extra qubits required during the computation of the oracle’s sub-components such that the total number of extra qubits is likely to stay close to the theoretical minimum given by the oracle’s overall functionality (which is zero). On the downside, a re-design of the sub-components might be required in order to work with encoded values.

V Conclusions

In this work, we have proven that one additional qubit is enough to determine a coded embedding of any non-reversible function for quantum circuits. By this, one can significantly reduce the overall number of qubits required for realizing Boolean oracles, since their functionality is usually split into several non-reversible parts. Our experimental evaluation shows that the number of required qubits can indeed be reduced by 36.4% on average, when comparing to embeddings that do not utilize encoding and that have been considered as the minimum thus far. Possible applications on the design of oracles for quantum circuits are discussed.

Acknowledgements

This work has partially been supported by the European Union through the COST Action IC1405.