Reversible Pebbling Game for Quantum Memory Management

TL;DR

This paper introduces a SAT-based tool for automatic quantum memory management that optimizes the trade-off between memory resources and operational complexity, addressing hardware limitations in quantum computing.

Contribution

It models quantum memory management as a reversible pebbling game and develops a novel algorithm to generate efficient clean-up strategies considering hardware constraints.

Findings

Achieved an average 52.77% improvement over existing methods.

Validated the approach on cryptographic programs and near-term quantum devices.

Demonstrated flexibility in exploring resource-operation trade-offs.

Abstract

Quantum memory management is becoming a pressing problem, especially given the recent research effort to develop new and more complex quantum algorithms. The only existing automatic method for quantum states clean-up relies on the availability of many extra resources. In this work, we propose an automatic tool for quantum memory management. We show how this problem exactly matches the reversible pebbling game. Based on that, we develop a SAT-based algorithm that returns a valid clean-up strategy, taking the limitations of the quantum hardware into account. The developed tool empowers the designer with the flexibility required to explore the trade-off between memory resources and number of operations. We present three show-cases to prove the validity of our approach. First, we apply the algorithm to straight-line programs, widely used in cryptographic applications. Second, we perform a comparison with the existing approach, showing an average improvement of 52.77%. Finally, we show the advantage of using the tool when synthesizing a quantum circuit on a constrained near-term quantum device.

Tables

Table 1. TABLE I: Comparison

				Bennett		Pebbling strategy
	pi	po	nodes	P	K	P	K	runtime	%P	$\times$K
b2_m3	8	8	74	66	124	30	186	0.17	54.55	1.5
b3_m4	12	12	59	47	82	20	117	121.37	57.45	1.43
b4_m5	16	16	203	187	358	83	778	55.75	55.61	2.17
b5_m7	20	20	256	236	452	106	888	31.15	55.08	1.96
b6_m7	24	24	310	286	548	130	1132	35.72	54.55	2.07
b8_m7	32	32	422	390	748	187	1884	11.59	52.05	2.52
b10_m7	40	40	535	495	950	264	2938	28.66	46.67	3.09
b12_m7	48	48	646	598	1148	331	4228	56.33	44.65	3.68
b16_m23	64	64	881	817	1570	480	6218	133.45	41.25	3.96
c17	5	2	12	7	12	4	12	0.01	42.86	1
c432	36	7	208	172	337	60	685	23.70	65.12	2.03
c499	41	32	219	178	324	77	610	60.08	56.74	1.88
c880	60	26	334	274	522	82	1280	43.52	70.07	2.45
c1355	41	32	219	178	324	77	594	2.63	56.74	1.83
c1908	33	25	220	187	349	70	875	57.97	62.57	2.51
c2670	157	63	554	397	731	160	1948	47.94	59.7	2.66
c3540	50	22	856	806	1590	416	5434	111.20	48.39	3.42
c5315	178	123	1257	1079	2035	498	7635	118.38	53.85	3.75
c6288	32	32	1011	979	1926	640	10232	101.31	34.63	5.31
c7552	207	108	1151	944	1780	540	7757	124.1	42.8	4.36
Average percentage reduction of pebbles = 52.77
Average multiplicative factor for the number of steps = 2.68

Equations

$$z_1=A(x_2,x_3)z_2=C(z_1,x_3)z_3=B(x_3,x_4)$$

$$z_4=D(z_3,x_3)y_1=E(z_2,z_4)y_2=F(x_1,z_1)$$

$$G_c:|q_1⟩\dots |q_k⟩|q_t⟩\mapsto |q_1⟩\dots |q_k⟩|q_t\oplus c(q_1,\dots ,q_k)⟩$$

$$P_0$$

$$P_1$$

$$P_2$$

$$P_3$$

$$P_4$$

$$P_5$$

$$P_0$$

$$P_1$$

$$P_2$$

$$P_3$$

$$P_4$$

$$P_5$$

$$P_6$$

$$P_7$$

$$\underset{v\in V}{\bigwedge }{\bar{p}}_{v,0}\wedge \underset{v\in O}{\bigwedge }{p}_{v,K}\wedge \underset{v\notin O}{\bigwedge }{\bar{p}}_{v,K}$$

$$\underset{i=1}{\overset{K}{\bigwedge }}\underset{(v,w)\in E}{\bigwedge }((p_{v,i}\oplus p_{v,i+1})\to (p_{w,i}\wedge p_{w,i+1}))$$

$$\underset{i=0}{\overset{K}{\bigwedge }}(\sum _{v\in V}{p}_{v,i}\le P)$$

$$t_1=a+b{t}_2=c+d{t}_3=a-b{t}_4=c-d$$

$$x=t_1+t_{2}y=t_1-t_{2}z=t_3+t_{4}t=t_3-t_4$$

Full text

I Introduction

The prospective of experimenting with a practical quantum computer is closing up thanks to the recent developments in hardware technology [1, 2, 3]. Driven by the revolutionary potential capabilities of quantum computing, research is extremely active both in academic and in industrial environments [4]. The race is on to develop quantum algorithms capable of proving quantum supremacy, which is the ability to solve problems that cannot be solved classically [5, 6, 7, 8].

A large part of the design of quantum algorithms is still performed manually, despite the emergence of several automatic methods for both synthesis [9, 10] and optimization [11, 12, 13] of quantum circuits. Most manual and automatic approaches for quantum circuit synthesis decompose large functionality into smaller parts in order to deal with complexity. Each part requires some resources in terms of qubits and quantum operations. The components can be connected together in order to obtain the desired computation for the overall circuit.

Most of the parts of a large function are used to compute intermediate values, which are stored on qubits. However, the final composed circuit must not emit any of those values. Otherwise, the computed results may entangle with intermediate values and compromise the overall quantum algorithm. Since quantum operations are reversible, intermediate results can be “uncomputed” by performing the same operations that computed them, in reverse order. Fig. 1 illustrates a small example. The composition of the two functions $f$ and $g$ generates an unknown state that can be uncomputed by performing $f$ in reverse order.

There are many possible ways to combine the small parts of a decomposition, each of which resulting in different accumulated costs for number of qubits and number of quantum operations. The requirement that all intermediate results must be uncomputed makes finding a good way to combine parts particularly difficult in quantum computing. Consequently, effective memory management, which guarantees erasure of intermediate results, is crucial in quantum circuit synthesis.

The problem of finding a strategy to compute and uncompute intermediate states for a given fixed number of qubits corresponds to solving the reversible pebbling game. The reversible pebbling game problem has been studied for the first time by Bennett in [14], in the context of exploring space/time trade-off in reversible computation. Input is a Directed Acyclic Graph (DAG), in which each node corresponds to one part of the decomposed computation, and edges define data dependency. Also, nodes can be pebbled, meaning that the computed value is available on some resource, in our case on a qubit. The game consists of placing pebbles on the graph nodes. Initially no node is pebbled. A pebble can be placed on a node if all its children are pebbled, and the same condition is required to remove a pebble from a node. The game is concluded if all the outputs are pebbled and all the other nodes are unpebbled. Solving the problem returns a valid clean-up strategy.

The problem complexity has been studied in [15] where the authors prove that the problem is PSPACE-complete, as the non-reversible pebbling game. An explicit asymptotic expression for the best time-space product is given in [16], while the asymptotic behavior on trees is studied in [17].

We propose a solution to the reversible pebbling game that casts the problem as a satisfiability problem. We show how the method is capable of exploring the trade-off between space (number of qubits) and time (number of operations). In our experimental evaluation, we showcase several examples how our approach can be used to find memory management strategies both for manual and automatic synthesis approaches.

II Preliminaries

II-A Quantum memory management

Our approach abstracts from the actual quantum operations that are being performed, and therefore the interested reader is referred to the literature for a detailed background on quantum computing [18].

The problem of quantum memory management is crucial in quantum circuit design, as all the garbage states need to be carefully cleaned up.

In the remainder of this section, we consider the example of a quantum algorithm that performs the following mapping: $|x_{1}\rangle|x_{2}\rangle|x_{3}\rangle|x_{4}\rangle|0\rangle|0\rangle\mapsto|x_{1}\rangle|x_{2}\rangle|x_{3}\rangle|x_{4}\rangle|y_{1}\rangle|y_{2}\rangle$ where

[TABLE]

with $A,B,C,D,E,F$ being some generic 2-input Boolean operations and $z_{1},z_{2},z_{3},z_{4}$ the intermediate results. Such computation can be represented using the DAG in Fig. 2, in which each node represents an operation. An edge is drawn from a node $v$ to a node $w$, if $w$ requires the value of $v$ (see Fig. 2).

In order to build the quantum circuit to perform our computation we exploit the direct correspondence between each node in the graph and a reversible single-target gate.

Definition 1** (Single-target gate)**

A single-target gate $G_{c}$ is a reversible gate characterized by a control function $c$, by a set of control qubits $q_{1},\dots,q_{k}$ and by a target qubit $q_{t}$. The gate inverts the value of the target line if $c(q_{1},\dots,q_{k})$ evaluates to true, i.e.,

[TABLE]

Different reversible circuits resulting from this translation is shown in Fig. 3. When two identical gates are performed twice on the same target, the value on the line is uncomputed, and goes back to its original state. Qubits initialized to $|0\rangle$, called ancillae, are used to store the intermediate results and must be restored after the computation. Once the results $y_{1}$ and $y_{2}$ have been computed, all the intermediate values $z_{1},z_{2},z_{3},z_{4}$ must be cleaned up.

A simple solution is the one proposed in Fig. 3(a), which is referred to as the Bennett [14] strategy. It consists of computing all the operations in a bottom-up order, and then uncomputing the intermediate results in a top-down fashion, so that all the nodes have their inputs available. This strategy always leads to the minimum number of gates, and to the maximum number of qubits. The order in which the DAG is converted into a reversible circuit can have a significant effect on how the memory is managed. In the example strategy in Fig. 3(b) it is shown how, only by changing the order of the operations, it is possible to save one qubit, without increasing the duration of the computation. Finally, by allowing an increase in the number of gates, we can further reduce the number of ancillae to 4. In this case some functions are computed several times, see Fig. 3(c).

In Fig. 3 ancillae are colored red during the time they are storing an intermediate result. The first two strategies store values for a long time during which they are not needed, whereas the last strategy makes a good usage of fewer memory. Those three graphs are useful to visualize the trade-off between hardware resources (i.e., qubits) and time (i.e., operations). We cannot state that the last method performs better than the first one, as that would depend from the actual hardware constraints. What we achieve in this work is to empower the designer with the ability to choose whether exchange memory for time and vice versa.

II-B Reversible pebbling game

The problem of finding the best uncomputing strategy is equivalent to the reversible pebbling game problem. In the remainder we use independently pebbling and uncomputing strategy.

Definition 2** (Reversible pebbling configuration)**

A reversible pebbling configuration of a DAG $G=(V,E)$ is the set $P\subseteq V$ of all the pebbled vertices.

Definition 3** (Reversible pebbling strategy)**

A reversible pebbling strategy of a DAG $G$ is a sequence of reversible pebbling configurations $P=(P_{1},...,P_{m})$ such that $P_{1}=\{\}$ and $P_{m}=O$, where $O$ is the set of all sinks of $G$. For each $1<i\leq m$, we have $P_{i}=P_{i-1}\cup\{v\}$ or $P_{i}=P_{i-1}/\{v\}$ and $P_{i}\neq P_{i-1}$. All in-neighbors of $v$ are in $P_{i-1}$.

In Fig. 4 we show two possible pebbling strategies for the DAG in the example. Each row of the grids represents a node and each column, from left to right, corresponds to a single step. A black square means that the corresponding node is pebbled. In accordance to the rules of the game, the initial configuration is empty and the last only contains output vertices. In these examples we only allow one move per step. The first strategy is the one reported by Bennett [14], in which we naively compute all the nodes and then uncompute intermediate results. This pebbling requires a number of pebbles equal to the number of nodes, 6 in the example, and only 10 steps, that is minimum. The complete sequence of pebbling configurations for the first example is:

[TABLE]

The second approach is a strategy that only uses 4 pebbles. To reduce the number of pebbles, it computes twice the nodes $a$ and $b$, increasing the number of steps to 14. The complete sequence of pebbling configurations for the second example is:

[TABLE]

II-C SAT solver

Given a Boolean function $f(x_{1},...,x_{n})$, the Boolean satisfiability problem (or SAT problem) consists of determining an assignment $V$ to the variables $x_{1},...,x_{n}$ such that $f$ is satisfied (evaluates to true). If such an assignment exists we call it a satisfying assignment, otherwise the problem is unsatisfiable. SAT solvers are software programs in which $f$ is specified as conjunctive normal form (CNF) consisting of a conjunction of clauses where each clause is a disjunction of literals. We define a literal as instance of a variable or its complement. SAT can be summarized as follows: given a list of clauses, determine if there exists a variable assignment that satisfies all of them.

III SAT-encoding

In this work we aim at finding a good pebbling strategy while constraining the maximum number of pebbles per step.

Problem 1

Given a DAG and a number of pebbles, find a valid pebbling strategy using the minimum number of steps.

As we use a SAT solver [19] to extract our solution, we have to decompose this problem into many SAT problems.

Problem 2

Given a DAG and $K$ pebbles, does a valid pebbling strategy with $K$ steps exist?

The solver can either find a solution and return a pebbling strategy, or state that no solution exists. In this case we increase the number of steps to $K+1$ until a satisfying solution is found.

Following the definition of a reversible pebbling game given in Section II-B, we first declare our set of variables, and then we impose satisfiability constraints.

III-A Variables

The input DAG $G=(V,E)$ has some nodes which compute an output value and we refer to them as a set $O\subseteq V$. Note that the primary inputs are not nodes in the DAG. We also define $C(v)=\{w\mid w\rightarrow v\}$ as all children of a node $v$.

Example 1

The DAG in Fig. 2 has six nodes $\{A,B,C,D,E,F\}$ and two outputs $O=\{E,F\}$. Note that, e.g., $C(A)=\emptyset$, since the primary inputs are not part of the DAG.

Problem 2 is encoded in terms of the pebble state variables $p_{v,i}$. For $v\in V$ and $0\leq i\leq K$, those are Boolean variables that evaluate to true if the node $v$ is pebbled at time $i$. Note that the SAT formula encodes $K+1$ pebble configurations with $K$ steps describing the transition from one configuration to the other.

III-B Clauses

The following set of clauses describes the reversible pebbling problem.

• •

Initial and final clauses: at time [math] all the nodes are unpebbled and at time $K$ all the outputs need to be pebbled and all the intermediate results unpebbled

[TABLE]

• •

Move clauses: if a node is pebbled or unpebbled at time $i+1$, then all its children are pebbled at time $i$ and time $i+1$

[TABLE]

• •

Cardinality clauses: at each step, at most $P$ pebbles are used

[TABLE]

IV Applications and Results

In this section we illustrate the validity of our proposed approach by show-casing several examples in which large computations are expressed in terms of a sequence of smaller ones. In order to optimally exploit qubit resources, a high-quality quantum memory management is required that can be addressed using our SAT-based reversible pebble game solver. Our algorithm uses at its core the open source SAT solver Z3 [19].

IV-A Show-case: Straight-line programs

We apply our method to the synthesis of straight-line programs used in cryptographic applications. Those programs are combinations of modular arithmetic operations as addition, subtraction, multiplication, and squaring. We assume that for each operation a quantum implementation exists, and will have a given cost in terms of quantum gates and ancillae. We can estimate the cost of an algorithm implementation in terms of number of different operations, according to the resources available. We choose a straight-line program that implements the addition between two points of an Edward curve in projective coordinates from [20]. We pebble the resulting DAG using different number of pebbles. Fig. 5 visualizes the pebbling strategies obtained with 24, 20, 16, 12, and 10 pebbles. In each case, we obtain a different number of operations, as reported in Fig. 5. For example the first implementation performs a total of 74 operations: 28 additions, 20 subtractions, 15 squaring and 11 multiplication. We can see how the tool manages to fit the desired computation into limited number of qubits, by increasing the number of required steps. As a consequence, the last implementation has an higher cost in terms of operations: 110 in total. The overall cost of the algorithm on different hardware can be evaluated having some estimates of the real cost of each operation. On the top of each grid, we show the dynamic change in the memory employed during the computation. A flat dynamic suggests that a constant number of qubits is used through the whole computation. A solution with a lower peak requires less qubits.

IV-B Show-case: Comparison with Bennett strategy

The second show-case has the purpose of quantifying the ability of the program to map a design in a limited number of qubits. We consider an operator called $H$ (different from the Hadamard gate) that is used internally to the algorithm that computes the doubling of two points referred before [20]. This operator is a composition of modular additions ($+$) and modular subtraction ($-$); it has $a,b,c,d$ as inputs and four outputs $x,y,z,t$, where:

[TABLE]

Experiments reported in Table I show a comparison between the Bennett pebbling method and our solution. The different designs correspond to the $H$ operator with different bitwidths and modulus. We also show the results for the well known ISCAS benchmark. The graph representation for the function has been extracted from an XOR-majority graph using the open source tool mockturtle [21]. A method to use XOR-majority graphs into quantum circuits using a naive quantum memory management strategy was presented in [22]. The number of pebbles corresponds to the minimum one for which the solver could find a solution within 2 minutes. Even with this short timeout, the algorithm finds a solution for a significantly reduced number of pebbles. The average percentage reduction is $52.77\%$. As the pebbles are reduced, the number of steps increase with respect to the Bennett method. In average, the number of steps for the constrained design is $2.68\times$ the one of the naive strategy. With the increase of the size of the DAG, we see a fewer pebble reduction. The reason is in the timeout chosen, as the solver requires more time to deal with large designs: the number of variables of the SAT problem is proportional to $n^{2}$ where $n$ is the number of nodes of the DAG. Also increasing the number of nodes, more steps seems to be required. This is also dependent on the timeout. In fact the algorithm is capable of finding many solutions with different number of pebbles but same number of steps. Nevertheless more constrained solutions require more time to be resolved.

IV-C Show-case: Adapting to hardware constraints

In the last example, we consider programming a quantum system composed of 16 qubits, as for example the ibmqx5 quantum computer from IBM [23]. We want to map an oracle for the 9-input AND function as part of a more complex algorithm, e.g., Grover’s algorithm [24]. The function can be represented using the DAG in Fig. 6(a).

Our first attempt is to use the Bennett strategy for qubits clean-up. This method leads to the circuit shown in Fig. 6(b). This 17-qubits design cannot be mapped on the chosen 16-bits hardware. A second possibility is to apply the well known decomposition method proposed by Barenco in [25] to the 9-controls Toffoli gates, as in Fig. 6(d). In this case only one extra ancilla is required (11 qubits in total). The drawback of this solution is that there is an explosion in the number of gates: from 15 to 48. It is known how, increasing the number of gates can negatively affect the noise in the final result [26]. Our tool provides with enough flexibility to find a more balanced solution. Setting the number of pebbles to exactly 16 we indeed obtain a valid pebbling strategy that maps the desired functionality into the available number of qubits. The result is a circuit with only 23 gates shown in Fig. 6(c).

V Conclusion

We developed a SAT-based algorithm for quantum memory management. We show how the clean-up problem corresponds to the reversible pebbling game problem. Consequently, our algorithm solves instances of the reversible pebbling game to explore the trade-off between memory and number of operations. Finding an efficient pebbling strategy is crucial in quantum algorithm development, where often small manually optimized circuits are cascaded together. Our tool can enable computations in constrained systems, when this would not be possible using the strategies in the literature. We show three different show-cases to demonstrate the efficiency of our method. In general, it can be used in cryptographic applications to synthesize straight-line programs, but also in any hierarchical synthesis automatic method. It can be used to estimate the cost of performing an algorithm on a given hardware in terms of number of operations. Our experiments show that we are capable of finding solutions with an average reduction in number of ancillae required of 52.77% with a timeout of 2 minutes. Finally we give a simple example of how the tool could be used by a designer to map a required computation into an available constrained hardware.

Acknowledgments

This research was supported by H2020-ERC-2014-ADG 669354 CyberCare and the Swiss National Science Foundation (200021-169084 MAJesty and and 200021-146600).