Entanglement bounds on the performance of quantum computing architectures

There are many possible architectures of qubit connectivity that designers of future quantum computers will need to choose between. However, the process of evaluating a particular connectivity graph’s performance as a quantum architecture can be difficult. In this paper, we show that a quantity known as the isoperimetric number establishes a lower bound on the time required to create highly entangled states. This metric we propose counts resources based on the use of two-qubit unitary operations, while allowing for arbitrarily fast measurements and classical feedback. We use this metric to evaluate the hierarchical architecture proposed by A. Bapat et al. [Phys. Rev. A 98, 062328 (2018)] and find it to be a promising alternative to the conventional grid architecture. We also show that the lower bound that this metric places on the creation time of highly entangled states can be saturated with a constructive protocol, up to a factor logarithmic in the number of qubits.


I. INTRODUCTION
As the development of quantum computers progresses from the construction of qubits to the construction of intermediate-scale devices, quantum information scientists have increasingly begun to explore various architectures for scalable quantum computing [1][2][3][4]. Researchers have quantified the cost imposed by moving from one architecture to another [5,6] and optimized the placement of qubits on a fixed architecture [7][8][9]. Experimentalists have also begun to test different architectures in laboratory settings [10,11].
In this work, we are interested in developing tools to evaluate the relative performance of different architectures. Here, "architecture" refers to the connectivity graph that defines the allowable elementary operations between qubits. We propose a natural metric based on entanglement measures. When several physical models are represented by a graph G = (V, E), with a set of vertices V corresponding to qubits, and a set of weighted edges E corresponding to two-qubit operations (where the weights denote the maximum rates of operations), a useful metric is given by what we dub the "rainbow time," τ RB (G) = max F ⊂ V , F ⩽ 1 2 V F ∂F , (1) where |∂F| denotes size of the boundary of F, i.e. the total weight of edges connecting F and We show that the rainbow time is a lower bound on the time required to create a highly entangled state on the graph (i.e., states of N qubits with O(N) bipartite entanglement). It is also the reciprocal of a well-studied graph quantity known as the isoperimetric number [12]. We note that this lower bound holds even when measurement and feedback are allowed to speed-up entanglement generation, such as in the case of Greenberger-Horne-Zeilinger states [13]. In contrast to Ref. [14], where architectures are evaluated assuming that only unitary operations are permitted, our results apply to the more general setting that allows nonunitary operations.
As a complementary result, we show that this lower bound is nearly tight-a procedure that distributes Bell pairs using maximum-flow algorithms nearly saturates this bound to produce O(N) entanglement across any bipartition, up to O(logN) overhead. This suggests that beyond providing a bound, the rainbow time would be a useful witness to the speed at which entanglement can actually be generated.

II. PHYSICAL MODEL
In this paper, we evaluate the performance of quantum architectures with a connectivity graph given by G. Each vertex in the graph represents a single data qubit, and an edge exists between two vertices if two-qubit operations can be performed between them. We interpret the edge weight w ij between vertices i and j as representing bandwidth, so that higherweighted edges are capable of performing more two-qubit operations in a single unit of time.
We consider an example physical model where the edge weights represent the rate of distribution of entangled pairs as in Ref. [15]. Each vertex is a small module that contains a data qubit and some ancilla qubits. In each unit of time, Bell pairs are generated between the ancilla qubits on the edges of the graph, which can then be used to perform two-qubit gates on the data qubits [16,17]. The process of moving from this model to an abstracted connectivity graph is illustrated in Fig. 1. We assume that measurements, classical communication, and intra-module unitaries are arbitrarily fast, such that the bottleneck is given by quantum operations between modules. For example, this model can describe a trappedion system which uses photonic interconnects to generate entanglement between modules as in Refs. [18,19]. In this framework, vertex degrees and total graph edge weights represent required ancilla overheads, justifying their use as cost functions in Ref. [14].
While, for simplicity, we will focus in the main text on the above model, our results also apply to other physical models, up to constant-factor overheads. For example, since any twoqubit operation between data qubits can be performed by consuming two Bell pairs [20], the above model is equivalent to a model where edge weights are proportional to rates of two-qubit operations. In Appendix A, we show in more detail how to extend our results to this model, as well as to a model where edge weights represent coupling strengths in a Hamiltonian.

III. ENTANGLEMENT CAPACITY
Given a graph G, we wish to bound the total possible increase in a given entanglement measure after n rounds of entanglement distribution over its links. Suppose we fix a bipartition of the graph into two subgraphs supported on vertex subsets F and F . We consider a general entanglement measure, S, which quantifies the bipartite entanglement between F and F . We assume the following axioms: S is zero for product states ρ F ⊗ ρ F , additive between nonentangled regions, S ρ F F ⊗ τ F F = S ρ F F + S τ F F , and nonincreasing under local operations and classical communication. Entanglement measures that obey these axioms include the entanglement cost, the distillable entanglement, and the entanglement of formation [21,22]. All of these measures are identical to the von Neumann entropy for pure states.
By the result of Ref. [21], the entanglement after n rounds is bounded by n times the maximum single-round entanglement. We will therefore bound the entanglement generated in one round, going from ρ to ρ′. To produce ρ′, we begin with ρ and then generate entanglement on the graph edges. This means that w ij ancilla Bell pairs are generated for each edge (i, j) crossing the boundary ∂F. The total number of Bell pairs is therefore |∂F|, the sum over all the weights, Ignoring ancillas purely local to F or F , the resulting state is ρ ⊗ ρ Bell ⊗ | ∂F | . The final state ρ′ is then generated by local operations, assisted by classical communication, on this state. We denote the state that results from an arbitrary round of local operations and classical communications on ρ as LOCC(ρ). Therefore, our axioms for S allow us to write Working in the units of S(ρ Bell ) = 1, we refer to this upper bound on the change in entanglement, ΔS ⩽ |∂F|, as the entanglement capacity of the (F , F ) bipartition in the graph G.

IV. RAINBOW STATES
We now define a highly entangled state whose creation serves as a benchmark for the performance of a quantum computing architecture.
Entanglement makes a useful benchmark for any quantum computer because it can be shown that computations that do not produce entanglement can be efficiently simulated classically [23][24][25]. Further motivation for producing highly entangled states can be found in quantum simulation, where a quantum simulator of general applicability ought to be capable of representing and simulating highly entangled states [26].
To select a particular entangled state for benchmarking, we consider "rainbow states." In 1D contexts, for even N, a rainbow state is one in which qubits i and N − i are maximally entangled [27,28]. The state itself is maximally entangled across a bipartition between the first N/2 qubits and the rest.
We extend this construction to arbitrary graphs. Suppose we consider a set of qubits V and any subset F ⊂ V, with the requirement that |F | ⩽ 1 2 | V |. Denote by F i the ith vertex of F using an arbitrary ordering, and similarly use F i to index vertices in the complement F . We can then define a "rainbow" state as one in which qubit F i and qubit F i form a Bell pair, and any additional qubits in F are left in the state |0〉. This state is illustrated for a particular choice of F and ordering in Fig. 2. Note that this construction is only well-defined if |F | ⩽ 1 2 | V |, as otherwise there will not be enough data qubits in F to form Bell pairs with all the data qubits in F. The arbitrary ordering allows multiple rainbow states to be defined from the same F.

V. RAINBOW TIMES AND ISOPERIMETRIC NUMBER
Using the model for quantum architectures in which each edge weight of a graph G denotes the rate of entanglement generation across that edge, we can calculate the lower bound on the time required to create a rainbow state, according to the entanglement capacity. For any vertex subset F we define this time as t(F ) = F ∂F = number of qubits in F entanglement capacity of (F , F ) .
As we have shown, the entanglement capacity corresponds to the total weight of edges across the boundary, which constrains the amount of entanglement that can be distributed to the subsystem F from its complement F in unit time.
Although there are many choices for a highly entangled physical state associated with the subset F that would be hard to create, here we argue why the above metric t(F) suffices for most considerations. Although there are many different states with O(N) entanglement which could be used to evaluate graphs, the rainbow state is easy to conceptualize and create. Since any bipartite entangled state can be converted either to or from Bell pairs through entanglement concentration or dilution [29], the rainbow state offers insight into the time required to create a general bipartite entangled state. Furthermore, rainbow states arise as ground states of novel models in condensed-matter physics [30], and thus the ability to create them can be important for quantum simulation. The difficulty to create rainbow states is also recognized in Ref. [13]. While there is freedom in defining a physical rainbow state via the pairing of vertices in F with those in F , the precise choice of pairing does not affect the minimum time required to create the state according to the entanglement capacity, t(F). While different rainbow states that share a common subset F may differ in how quickly they can be created, t(F) serves as the common lower bound on the creation time for all of them, and thus we will focus on that metric here.
We will now use t(F) to evaluate the quantum architecture G, the larger graph that contains F as a vertex subset. To do this, we find the maximum t(F) given G. Note that this is not the same as maximizing entanglement entropy, which would simply yield half the graph without any consideration of the graph structure. Instead we ask: Of all the maximally entangled states we can build by bipartitioning V into F and F , which of them is slowest to build according to the entanglement capacity? We call the associated quantity t(F) the rainbow time of the graph G and denote it τ RB (G), as defined in Eq. (1).
The rainbow time has a simple and attractive interpretation, can be directly connected to quantum computing tasks, and is applicable to various physical models of computation. In addition, it can be directly connected to a quantity known as the isoperimetric number h(G) [12], sometimes also known as the Cheeger constant, which is well-studied in graph theory and computer science [31][32][33]. As we have defined it, the rainbow time is simply τ RB (G) = 1/h(G) [34]. Thus, aiming to minimize the rainbow time (so that large entangled states can be easily created) in a quantum architecture is equivalent to maximizing the isoperimetric number. An "isoperimetric set" is a vertex subset F that achieves t(F) = τ RB (G). Often, isoperimetric numbers appear in the context of expander graphs, which are constructed to possess large isoperimetric numbers [35] and are used to prove important results in complexity theory [36][37][38]. Intuitively, a small isoperimetric number (large τ RB ) means that a graph has bottlenecks, and a sizable subset can easily be disconnected by removing relatively few edges. This also implies that an architecture with large τ RB is more prone to becoming disconnected due to the failure of a small number of edges.
Even though computation of the exact rainbow time is NP-hard for general graphs [12], it can be approximated to within an O( logN) factor [39]. There are also efficiently computable bounds on the rainbow time, including ones using the eigenvalues of the graph Laplacian [12]. Furthermore, for many specific graphs, we can evaluate the rainbow time efficiently. In Appendix B, we have done this for the complete, star, and grid graphs, as well as the hierarchical products and hierarchies presented in Ref. [14]. In particular, we compare hierarchies to d-dimensional grids and show that, for some parameters, hierarchies have lower rainbow time and lower total edge weight than grids, making them promising architectures for quantum computing.

VI. CREATING RAINBOW STATES
So far we have shown that rainbow time τ RB serves as a lower bound for generating maximum entanglement across any bipartition of the system. We now examine whether this bound can be saturated, in the sense that one can create a rainbow state across any bipartition in time O τ RB . We will show that for a general graph, there is an explicit protocol that prepares a rainbow state in time no more than τ RB ln | F | for any bipartition where F is the smaller subset, indicating that the bound τ RB is tight up to a logarithmic factor.
We begin the proof by mapping the problem of creating rainbow state to the MaxFlow problem in computer science [40]. Here, we restrict our attention to quantum architectures on graph G = (V, E), where the edge weights are integers that represent the number of Bell pairs that can be generated across the edge per unit time. Suppose we are given arbitrary vertex subsets F and K, where |F| = |K| ⩽ |V\/2, and K ⊂ F . To create a Bell state between a given pair of nodes in a single time step, we can specify a path connecting them on the graph G, generate Bell pairs on each edge along that path, and then perform entanglement connection on each internal node to convert the string of Bell pairs into one long-distance Bell pair. We can create many distant Bell pairs in this way during a single time step by specifying many paths. However, the set of paths must not use any edge more often than the weight of that edge allows for, since by definition the weight of an edge limits the number of Bell pairs the edge can generate in a unit time step. Thus, we can interpret the weight of each edge as its capacity, and the collection of paths as a flow of entanglement from F to K, as illustrated in Fig. 3. Suppose we now attach a fictitious source node s to each node in F, and a fictitious sink node t to every node in K. Then the problem of maximizing the number of Bell pairs simultaneously generated between F and K is the same as the problem of maximizing the flow from the source s to the sink t. The latter problem is known as MaxFlow, visualized in Fig. 3, and an explicit protocol to give the maximum possible amount of flow can be found efficiently via, e.g., the Ford-Fulkerson algorithm [41]. Note that if all the edge weights are integers, a flow of maximum value exists in which the flow carried by each edge is also an integer [42].
To demonstrate that a flow approach yields an efficient creation of a rainbow state, we invoke the MaxFlow-MinCut theorem, which says that the maximum flow has the same value as the minimum cut [40]. Here, a "cut" means a bipartition of the graph separating s and t, and its value is the total weight of all edges that cross the bipartition. By finding a lower bound on the value of all possible cuts in a graph, we show that a flow larger than or equal to this bound must exist.
Suppose that we now consider any cut of the graph into some arbitrary pair of subsets {s} ∪ S and {t} ∪ T. The boundary of this cut will consist of edges from s → T, S → t, and S → T. Its magnitude can be written as Cut(S, T ) = T ∩ F + S ∩ K + ∂S . (5) since s and t are connected only to nodes in F and K, respectively, and the edges in S → T are just the boundary of S in the original graph. To evaluate |∂S| = |∂T|, we will assume that |S | ⩽ 1 2 | V |, meaning we can apply the isoperimetric condition |S | ⩽ | ∂S | τ RB . (If this is not the case, then a near-identical argument can be made applying this condition to T.) To account for cases where τ RB < 1, we will write this as |∂S| ⩾ m|S| where m = min (1,1/τ RB ).
We then note that ∂S ⩾ m S ⩾ m( S ∩ F + S ∩ K ) ⩾ m( F − T ∩ F + S ∩ K ) . (6) By inserting this lower bound for |∂S| into Eq. (5), we obtain Since we know m ⩽ 1, we obtain the final bound on the cut magnitude, If m = 1 (i.e., τ RB ⩽ 1), then it follows that the value of the smallest cut is greater than |F|, meaning that a flow exists of magnitude at least |F|, which creates the rainbow state in a single round. If m < 1 (i.e., τ RB > 1), then we find that a flow exists of magnitude |F|/τ RB [43]. Once |F|/τ RB nodes are entangled, they can be disconnected from s and t, and the process repeated on a new set of nodes F 1 ⊂ F. Therefore, after n rounds of computation, the remaining set of nodes waiting for entanglement F n is produced by removing 1/τ RB of the nodes in set F n−1 , with F 0 = F, allowing us to compute the maximum size of F n inductively: Once |F n | < 1, the process is complete, as there are no fractional nodes. It follows that ⌈τ RB ln |F|⌉ rounds suffice to complete the entangling process.

VII. OUTLOOK
In this work, we have presented a new metric for evaluating proposed architectures for quantum computers. While we have proven that any vertex subset F can have a rainbow state prepared in ⌈τ RB ln |F|⌉ time, test simulations on many example small graphs suggest that flow-based algorithms can create rainbow states in ⌈τ RB ⌉ time. It is thus possible that the logarithmic factor can be removed and that the rainbow time lower bound is fully tight and saturable. In addition, although our argument suggests that for any bipartition of the system, there exists a rainbow state that can be created in ⌈τ RB ln |F|⌉ time, other rainbow states (where the connections between node pairs are permuted) may take longer. It would be interesting to upper bound the creation time of arbitrary rainbow states using tools from classical network theory such as routing time [44,45].
Finally, another open question is how the entanglement capacity, used here in terms of the rainbow time, can be applied to the analysis of quantum algorithms. While the rainbow time is not enough to provide an upper bound on the time-complexity of running a quantum algorithm on a given quantum architecture, it can provide a lower bound when the amount of entanglement required in the algorithm is known. References [46,47] explore the question of how entanglement grows during Shor's algorithm and in adiabatic quantum computing. These complement other results showing that low-entanglement systems can be simulated efficiently on a classical computer [23,48]. Rainbow time can also be used to benchmark algorithms for compilation and gate decomposition of quantum circuits, by comparing their realized circuit depth to this theoretical minimum required time.

MODELS
In this Appendix, we will derive the entanglement capacity for several different physical models that can correspond to a graph. Consider a graph, G, and select a subset of the vertices, F. We then want to show that the maximum amount of entanglement that can be created between F and F in unit time is proportional to the size of the boundary, |∂F|. We will allow arbitrary constant factors, and discuss how this bound arises in two different physical situations. As in the main text, we consider entanglement measures S on two regions so long as S obeys the following rules:

2.
Zero for states which are a product of states on each region, S ρ F ⊗ ρ F = 0.

3.
Nonincreasing after any operation which is local to each region, even if we permit classical communication.
In the main text, we showed how to apply these axioms to the analysis of a case in which computation was performed by the production and consumption of Bell pairs. Here we also look at a gate model of computation and a case in which the graph describes the limits on a time-dependent interaction Hamiltonian.

Unitaries
In this model, each graph edge of weight w ij represents the capability to perform w ij unitaries between qubits i and j in a time step. These unitaries are freely chosen by the experimenter. For two qubits, the ability to apply multiple unitaries is no different from the ability to apply an arbitrary unitary. However, we are considering cases where the qubits are part of a larger system, meaning we may wish to perform unitaries in sequence on different pairs to perform a more complicated computation.
We note that every two-qubit unitary can be performed using two Bell pairs as a shared resource and applying local operations. This can be easily seen in the following process:

1.
Alice and Bob start with a data qubit each and two Bell pairs shared between them. They wish to implement an arbitrary two-qubit unitary using only local operations and classical control.

2.
Alice uses one Bell pair and classical communication to teleport her qubit to Bob.

3.
Bob uses his local operations to perform the desired two-qubit gate.
Therefore, the state ρ′ can be obtained from the state ρ by using local operations and classical communication (LOCC) and consuming up to 2|∂F| Bell pairs in the process. Since LOCC cannot increase S, it follows that This suggests that the ability to perform arbitrary unitaries is up to twice as powerful as the ability to distribute arbitrary Bell pairs, which makes sense, as an arbitrary two-qubit gate cannot necessarily be performed with one Bell pair (for instance, SWAP requires two) [20]. Two Bell pairs, however, suffice to implement any arbitrary two-qubit unitary. In any case, this still yields an entanglement capacity ΔS = O( | ∂F | ) bound as desired.

Hamiltonians
We will now consider a case in which the graph describes a Hamiltonian, possibly timedependent. The graph will restrict the strength of these Hamiltonians. If we assume that G = (V, E), then the Hamiltonian can be written as a sum over the two-qubit operations: We then impose the condition ∀t: ℎ ij (t) ⩽ w ij , where w ij is the i-j edge weight. We can then apply the "small incremental entangling" (SIE) theorem [49]. In particular, we apply the special case used in Ref. [50] to bound the total amount of entanglement generated by this Hamiltonian. If H is a sum of pairwise Hamiltonians h ij acting on qubits, then the time-rate of entanglement generation on a set F of sites is Here, S F is the von Neumann entropy of the reduced density matrix on the region F. This can be derived from Eq. (3) of Ref. [50], and specifying two-body terms and qubit sites, but the result could be extended to qudits or general k-body interactions. The sum over Hamiltonian norms, in the graph context, corresponds to a sum over graph edges. Since every Hamiltonian strength is limited by the corresponding edge weight, ∑ ℎ ij ⩽ ∑ w ij = | ∂F |.
Therefore, we can specifically say that for this case, ΔS F = O( | ∂F | ). Many other entanglement measures, such as entanglement of formation or entanglement cost, can be related to the von Neumann entropy [22]. In particular, many entanglement measures on mixed states can be defined as a weighted sum over pure state components; since none of the pure states can increase dramatically in entanglement under this process, the entanglement measure on the mixed state is similarly limited.

HIERARCHIES
In this Appendix, we calculate the rainbow times for the hierarchical products and hierarchies of Ref. [14]. A hierarchical product is a graph product denoted G ⨅ H in which | G| copies of H are connected at their root (first) vertices by the graph G. By iterating this process, we can create a hierarchy, in which higher-level graphs connect lower-level identical subhierarchies. We also extend this concept to that of a weighted hierarchy, in which the edges on level i have weight α i . We write a k-level hierarchy with a vector of weights α as G Π α k , where G is the base graph. Finally, if α i = α i−1 , so that edge weight scales geometrically with the level of the hierarchy, then we simply write G Π α k . Some examples are shown in fig. 4.
To calculate the rainbow time for a hierarchical product, we make use of the result from Ref. [12] that there must exist an isoperimetric set [a vertex set F such that τ(F) = τ RB (F)] that is connected and whose complement F is connected. Therefore, we will look at all possible subgraphs of H 1 ⨅ H 2 where both F and F are connected. From these, we will search for the one with the largest τ(F). Since some isoperimetric set is guaranteed to exist in this set of subgraphs, this maximization over τ(F) in this set will also give us τ RB (H 1 ⨅ H 2 ). We will begin by specifying three cases, illustrated in fig. 5. These cases cover all possible subsets with the right connectedness properties and therefore allow us to find the maximizing set for the graph and τ RB (H 1 ⨅ H 2 ).
One such set would cover part of one copy of H 2 . However, note that if the root vertex of H 2 were included in F, then we would have to include all the descendants of H 2 , since otherwise F would not be connected. Therefore, this class will only include subsets of H 2 which do not include the root vertex. In this case, we must maximize over all possible subsets of H 2 to find the maximum τ(F). This may seem like it would yield τ RB (H 2 ); however, in this instance we can pick subsets of H 2 which make up a majority of H 2 , which is not allowed for τ RB . We define the unrestricted rainbow time as Here, G \ G 1 refers to G with its first vertex removed. Therefore, any set from this class will offer a candidate rainbow time of at most τ(F) = u RB (H 2 ).
The second class of candidate sets would cross one or more copies of H 2 . Since F must be connected, the path between these copies must be included in F, which means the root vertices of each H 2 that connect to each other via H 1 must also be in F. Then, as shown above, the entire copy of H 2 must be included. As a result, this case is equivalent to choosing copies of H 2 and either entirely including them in F or entirely excluding them. This problem reduces to dividing up H 1 , and then calculating as if each vertex had an effective volume of |H 1 |. Therefore, we can find the maximum τ(F) of these sets by simply finding τ RB (H 1 ) and scaling it by |H 2 |.
The final class of sets F which meets the connectedness criteria would be an F which includes all of H 1 and then all but one copy of H 2 completely, with perhaps some of the remaining H 2 also included. However, this F would necessarily be larger than half of the total graph H 1 ⊓ H 2 , and therefore we can discard it as a candidate set for determining the rainbow time. We combine the first two options and conclude that τ RB H 1 ΠH 2 = max u RB H 2 , H 2 τ RB H 1 . (B2) We now seek to apply this to hierarchies G Π α k . Just as before, if a vertex is included in F, then we must also include in F all its descendants in the hierarchy; otherwise, the complement F will not be connected. Therefore, all bipartitions can be reduced to choosing a particular level of the hierarchy to cut-on that level, either a vertex will be included or not included, and this must apply to all of its descendants as well. Every bipartition can then be mapped to a bipartition of G, but one where every vertex is scaled by |G| i−1 due to the size of each subhierarchy [note that the large number of vertices not in F do not contribute to τ(F)].
In addition, τ(F) must also be modified by the edge weight, which we define to be α i on level i.
There is one important difference between the top (kth) level and all others, which arises from the constraint that |F | ⩽ 1 2 G Π α k . A cut on the top level must not include more than half of the highest-level copy of G, while all lower levels can use any cut at all as long as it does not include the root vertex. Whatever level we cut, the cut depends only on the base graph G, with each node standing for |G| i−1 total nodes below it. Therefore, we can write the overall τ RB as a maximization over these options: For specificity, we will evaluate the case where G = K n , the complete graph, and α i = α i−1 , which was proposed in Ref. [14] as an architecture. Here, the maximization over lower levels [the second term in Eq. (B3)] can be reduced to either to the first level or the k − 1 level, since we simply have to pick the largest element in a geometric sequence defined by n/ α. We can write the resulting maximization as a choice between three options, τ RB (K n Π α k ) = max 1, n α k − 1 2 n , n α k − 2 . (B4) Whereas one might have expected two options to arise (cut at the top or at the bottom), we actually have three. For α > n, the edges grow in capacity too quickly for the increased volume to make a higher-level cut worthwhile, so the optimal cut is at the bottom, yielding a constant scaling with n. Two other options appear at n > α, where cutting higher up the hierarchy allows for greater volume of qubits in F without too much penalty caused by changing edge weights. The reason there are two strategies is that it may be possible to cut a larger portion of a lower hierarchy and exploit the split between τ RB and u RB . [For K n , in particular, the cut that includes all but the root vertex satisfies u RB (K n ).] To place these results in context, we compare the rainbow time of K n Π α k to the total rainbow time of other graphs. To do this, we write the rainbow time in terms of the total number of qubits in a graph, N, and concern ourself with the overall scaling. For the purpose of comparison, we consider hierarchies where the number of levels scale logarithmically as k = log n N, while α, n are constant parameters independent of N. In this language, τ RB (K n Π α k ) = Θ N max 0, 1 − log n α . We compare this to the rainbow time of some other graphs in Table I. References [12,32] give the isoperimetric number for K N , S N (the star graph of N nodes) and grids (which are Cartesian products of paths). Satisfying sets for these graphs are: for K N and S N , an arbitrary half of the nodes; for grids, a hypercube placed in one corner that takes up half the total volume.
One goal would be to identify a set of parameters where a hierarchy outperforms a ddimensional grid architecture. We are most concerned with comparing to the d-dimensional grid because the other candidates we present, K N and S N , both have very large degree, making them impractical for scalable architectures, although both have been used for small quantum devices [10]. We find that the rainbow time of the hierarchy with base graph K n and scaling constant α will be better (smaller) than that of the grid if α > n (d−1)/d . If it also holds that n > α, then the hierarchy will accomplish this with a total edge weight scaling identically as the grid. It is possible to achieve a smaller prefactor in this scaling under a suitable choice of n, α; for example, when d = 2, the choice of n = 3,4 and α = n 1−1/d gives lower total edge weight for the hierarchy than the grid. We conclude that a hierarchy K n Π α k with α ∈ [n 1−1/d , n) has both lower rainbow time and lower total edge weight than a ddimensional grid of qubits.

FIG. 1.
Illustration of how a model with ancilla mediator qubits can be abstracted into one in which only data qubits and edge weights are tracked. In panel (a), each module (blue dashed circle) contains one data qubit (red) and several ancilla mediator qubits (green) that form Bell pairs with other modules. In panel (b), the module as a whole is represented by blue circles, while the ancilla mediator qubits are now represented by edge weights. Only the states of the data qubits are tracked.

FIG. 2.
An illustration of how a rainbow state is defined on an arbitrary subgraph F. Here, gray lines represent the connectivity graph of allowed two-qubit interactions, while doubled black lines represent maximally entangled qubit pairs. Qubits without a doubled line are assumed to be in state |0〉.

FIG. 3.
An illustration of the fictitious nodes added to the isoperimetric set, F, and a set of equal size K (encircled by purple dashed line), to create a flow network. The new fictitious nodes, s and t, appear as green triangles connected to every node in F and K, respectively; the original nodes and edges are pink (in F) and blue (in F ) circles. The edges have weight one.  Examples of a hierarchical product (left) and a weighted hierarchy (right).   Important statistics for graphs. Here, only the asymptotic scaling with N is written. In addition to the rainbow time τ RB for each graph, we also include the total weight of all edges w, and the maximum graph degree Δ.
Rainbow times for graphs other than hierarchies can be found in terms of isoperimetric number in Refs. [12,32].