Exploiting Symmetry Reduces the Cost of Training QAOA

A promising approach to the practical application of the Quantum Approximate Optimization Algorithm (QAOA) is finding QAOA parameters classically in simulation and sampling the solutions from QAOA with optimized parameters on a quantum computer. Doing so requires repeated evaluations of QAOA energy in simulation. We propose a novel approach for accelerating the evaluation of QAOA energy by leveraging the symmetry of the problem. We show a connection between classical symmetries of the objective function and the symmetries of the terms of the cost Hamiltonian with respect to the QAOA energy. We show how by considering only the terms that are not connected by symmetry, we can significantly reduce the cost of evaluating the QAOA energy. Our approach is general and applies to any known subgroup of symmetries and is not limited to graph problems. Our results are directly applicable to nonlocal QAOA generalization RQAOA. We outline how available fast graph automorphism solvers can be leveraged for computing the symmetries of the problem in practice. We implement the proposed approach on the MaxCut problem using a state-of-the-art tensor network simulator and a graph automorphism solver on a benchmark of 48 graphs with up to 10,000 nodes. Our approach provides an improvement for $p=1$ on $71.7\%$ of the graphs considered, with a median speedup of $4.06$, on a benchmark where $62.5\%$ of the graphs are known to be hard for automorphism solvers.


Introduction
Recent advances in quantum hardware [1,2] pave the way for demonstrating useful quantum advantage in the coming years. A leading candidate for demonstrating such an advantage is the Quantum Approximate Optimization Algorithm (QAOA) [3], which has been implemented on hardware using up to 23 qubits [4]. An important challenge associated with practical application of QAOA is the need to find good QAOA parameters, known to be a difficult task in practice [5,6]. This difficulty is exacerbated by the high cost of obtaining such parameters variationally on a quantum computer because of the long sampling times on quantum hardware implementations and the large number of samples required for accurate energy evaluation [7,8]. Although a number of machine learning approaches have been proposed [9,10], they only partially address this problem, since training the machine learning models requires large datasets, which are both expensive to obtain from quantum devices and not standardized.
A promising approach to overcoming the challenge of finding good QAOA parameters is finding them purely classically by leveraging the locality of the QAOA algorithm and the recent advances in tensor network methods [11,12] to efficiently (in the number of qubits) evaluate the QAOA energy. In this approach, the value of QAOA energy for a Hamiltonian encoding the target problem with given parameters is evaluated one term at a time; for each term, only the corresponding reverse causal cone is considered [3,13]. Since the size of the reverse causal cone grows only with QAOA circuit depth, but not with the overall size of the problem, this approach allows one to calculate energies for formally infinitely sized problems. Then a classical optimizer can be used to find QAOA parameters by maximizing the QAOA energy. Although the main motivating application for such advances is finding QAOA parameters, fast evaluation of QAOA energy also has important applications to graph analysis [14] and to understanding QAOA potential.
In this paper we introduce a novel method that accelerates the evaluation of QAOA energy by leveraging the symmetries of a problem instance. Classical symmetries of the objective function lead to symmetries of the cost Hamiltonian. We show that these symmetries introduce classes of equivalence on the terms of the cost Hamiltonian with regard to QAOA energy, making it sufficient to evaluate only the energy of one term from each equivalence class. For some problems, such symmetries of the objective function may be known a priori or can be computed by using state-of-the-art graph automorphism solvers, which we demonstrate to be fast compared with the cost of evaluating the energy. We note that our results apply to any subgroup of symmetries of the problem. Moreover, our results are applicable not only to QAOA but also to its nonlocal generalization RQAOA [15][16][17] because of the need to optimize parameters and evaluate the energy of each term to compute correlations.
We implement this approach numerically for the MaxCut problem using the state-of-the-art tensor network simulator QTensor [11,18] and using nauty [19] for computing the automorphism group of the graph. To illustrate the worst-case performance of the proposed methods, we consider graphs known to be hard for the automorphisms solvers we use, and we show that even in this scenario we achieve a median speedup of 1.79 for a single energy evaluation and p = 1. For graphs that are considered easy for graph automorphism solvers, we observe a median speedup of 8.96 and a mean speedup of over 2726. In practice, the benefits of using the proposed approach are expected to be larger, since energy is typically evaluated repeatedly (e.g., while optimizing QAOA parameters), and the cost of doing so grows with p, and the symmetries are computed only once.
While the results in this paper are based on the ideas presented in [20], our results are distinct in the following three ways. First, we focus on the symmetries of the terms of the cost Hamiltonian and the corresponding redundancies in QAOA energy evaluation, rather than the symmetries of the quantum state and the corresponding symmetries in QAOA outcome probabilities. Second, we demonstrate a novel application of the symmetry analysis to accelerating the training of QAOA purely classically. Third, by leveraging the high-performance tensor network simulator QTensor [11,18], we are able to consider instances with up to 10,000 nodes / qubits, whereas [20] considered instances with no more than 22 nodes / qubits. The rest of the paper is organized as follows. We review relevant background in Sec. 2. Our main result connecting the symmetry of the objective function to the classes of equivalence on the terms of the cost Hamiltonian is presented in Sec. 3. The results in that section are general and are not limited to graph problems. In Sec. 4 we outline how available fast graph symmetry solvers can be used to accelerate QAOA energy computation. In Sec. 5 we present the numerical results. In Sec. 6 we summarize our conclusions and briefly discuss future work.

Background
We briefly review relevant concepts and point the interested reader to further discussions in the literature.

Binary optimization on quantum computers
Consider a function on the Boolean cube, f : {0, 1} n → R, and the corresponding optimization problem max x∈{0,1} n f (x). (1) A Hamiltonian H ∈ C 2 n ×2 n is said to faithfully represent the function f if For clarity of presentation, we consider only functions that can be represented as where Z j is a Pauli Z operator acting on qubit j and coefficientsf (S) are given by the Fourier expansion of f [21]. Many objective functions of practical interest are given as Boolean polynomials, with Hamiltonians of the form (3) following trivially by substituting x ∈ {0, 1} → I−Z 2 . For a detailed discussion, the reader is referred to [21].

Quantum Approximate Optimization Algorithm
The Quantum Approximate Optimization Algorithm [3] is a hybrid quantum-classical algorithm that combines a parameterized quantum evolution with a method for finding good parameters. Applied to the problem (1), QAOA prepares a parameterized quantum state where U P (γ) = e −iγH is the phase operator with H encoding the objective function f according to (2), is the mixing operator with X j denoting the Pauli X acting on qubit j, and |s = |+ ⊗n is a uniform superposition over computational basis states.
The parameters β and γ have to be chosen in such a way that, upon measuring the state | β, γ p , the solution of desired quality to the original problem (1) is retrieved with high probability. QAOA parameters are typically found variationally by using an outer-loop classical optimizer to approximately maximize E p ( β, γ) = β, γ| p H | β, γ p , with the value of E p ( β, γ) (commonly referred to as QAOA energy) evaluated either from sampling a quantum computer or purely classically as described below, although many alternative approaches have been proposed [3,9,10,22].

Classical training of QAOA
Finding QAOA parameters is typically done by using a classical optimizer to approximately maximize the expectation value of the cost Hamiltonian in QAOA state: Doing so requires repeated evaluations of E p ( β, γ). For many classes, this value can be evaluated purely classically with resource requirements growing only with the density of the problem and the number, p, of QAOA steps and not the number, n, of qubits (i.e., variables in the problem) [3]. Here we briefly review the mechanism for doing so; for more details and an in-depth discussion, the reader is referred to [13,22].
Consider a Hamiltonian of the form (3). Then the value E p ( β, γ) can be written as By linearity, each term E p ( β, γ, S) (corresponding to observable j∈S Z j ) can be evaluated independently. To see that each term E p ( β, γ, S) can be evaluated with resource requirements independent of n, note that all factors e −iβpXj with j / ∈ S will commute through j∈S Z j and cancel out, resulting in operator O(S) having support only on |S| qubits; that is, From (3), the phase separating operator is Analogously to the previous step, wheneverS ∩ S = ∅, the factor e −iγf (S) j∈S Zj acting on qubitsS will commute through and cancel out. Therefore the operator after one step of QAOA has support only on the set of qubits Note that the support of the operator after one step of QAOA (|S p=1 | qubits) does not depend on the overall size of the problem, n, explicitly. Rather, it depends only on the density of the problem. Repeating the above steps, at each step the support of the operator (and thus the complexity of evaluating E p ( β, γ, S)) grows by including more interacting qubits that are within the reverse causal cone of j∈S Z j .
For dense instances (e.g., where a term connects any two variables), this approach yields no gains because the reverse causal cone envelops the entire circuit. Specifically, the applicability of the method is limited by the size of the largest reverse causal cone of any term in the Hamiltonian. However, for relatively sparse problems with quadratic terms (|S| = 2, such as MaxCut), this technique has been demonstrated to enable evaluating E p ( β, γ) and finding good QAOA parameters for instances with hundreds to thousands of nodes with p ≤ 4 [11,12].

MaxCut
For a graph G = (V, E), the goal of the MaxCut problem is to partition the set of nodes V into two parts such that the number of edges spanning multiple parts is maximized. MaxCut on general graphs is APX-complete [23]. The Max-Cut objective is encoded by the Hamiltonian

Objective function symmetries and QAOA
For an objective function f on n bits, a symmetry is a permutation of the n-bit strings, a ∈ S 2 n : x → a(x), that leaves the objective function unchanged; that is, f (x) = f (a(x)), ∀x ∈ {0, 1} n . In this paper we focus on a subgroup of permutations that are variable index permutations (i.e., permutations of n elements), and we denote this subgroup S n . On qubits, the symmetry a ∈ S n can be faithfully represented by a unitary acting as A |x = |a(x) , ∀x ∈ {0, 1} n . Note that if an objective function has symmetry a ∈ S n , the Hamiltonian faithfully representing it as specified by (2) satisfies A † HA = H, where A is given by (5). Additionally, for any A ∈ S 2 n , the QAOA initial state |s satisfies A |s = |s , and, for any A ∈ S n , the mixing Hamiltonian B = n j=1 X j satisfies A † BA = B. For a detailed discussion of classical symmetries and their relation to QAOA, the reader is referred to [20].

Graph symmetries
A symmetry of a graph G = (V, E) is a transformation that leaves the graph unchanged. In this paper we consider only (vertex) automorphisms, defined as permutations of nodes, For any label-independent objective function f defined on G, an automorphism σ of G is a symmetry of f . Random three-regular and Erdos-Renyi model graphs have been shown to almost surely have no nontrivial automorphisms [24,25]. At the same time, many graphs of interest for the study of QAOA are highly structured, with the size of a group of automorphisms as large as n! [14].

Fast solvers for graph symmetries
In practice, heuristics are used for computing the group of automorphisms of a graph. A number of software implementations exist, including nauty [26,27] (used in this paper), Traces [19,28], saucy [29], Bliss [30], and conauto [31]. These packages are capable of solving most graphs with up to tens of thousands of nodes in less than a second [19] and thus are sufficient for tackling problems that can realistically be expected to be relevant to noisy intermediate-scale quantum devices. Any automorphism solver could be used; in Sec. 5 we illustrate the performance obtained on adversarial and more favorable instances by using the solver nauty.
A 2015 breakthrough by Babai [32,33] for the graph isomorphism problem leads to a quasi-polynomial algorithm for computing the group of automorphisms of a graph; no efficient algorithm is known in general. For an overview of complexity-theoretic aspects of obtaining the group of symmetries of a graph, the reader is referred to [20,Sec. 3.3].
3 Using symmetry to reduce the number of observables to evaluate In this section we show how classical symmetries of the objective function reduce the cost of evaluating QAOA energy.
The central observation is that variable index permutation symmetries of the objective function induce symmetries of the subsets S of qubit indices in (3) corresponding to observables (products of Pauli Z operators) in the cost Hamiltonian. Since these symmetries impose classes of equivalence on the terms of the Hamiltonian and since such symmetries are preserved by the QAOA ansatz, the QAOA energy can be computed by evaluating only the value of one observable from each equivalence class. We now formalize this observation. Consider a permutation of variable (qubit) indices a ∈ S n . This permutation induces an action on the subsets of qubit indices {j 1 , . . . , j k } ⊂ [n] by the rule a({j 1 , . . . , j k }) = {a(j 1 ), . . . , a(j k )}. We have the following result.
is a phase separating operator with the Hamiltonian H of the form (3) faithfully representing f . Consider two observables j∈S1 Z j and j∈S2 Z j connected by a in the sense that a(S 1 ) = S 2 .
Then, the expectation value of the two observables in the QAOA state is equal; that is, for all choices of the number of QAOA steps p and parameters β, γ.
Proof. Let A ∈ S 2 n be a unitary faithfully representing a as defined by (5). If the observables j∈S1 Z j and j∈S2 Z j are connected by a, then A † j∈S1 Z j A = j∈S2 Z j . Operator A faithfully represents a symmetry of the objective function f and therefore [A, H] = 0, which implies [A, U P (γ)] = 0, ∀γ. Moreover, A represents a permutation of qubits a ∈ S n and therefore [A, B] = 0, which implies [A, U B (β)] = 0, ∀β. Combining these two observations gives where the last equality is from the QAOA initial state being invariant under any permutation of computational basis states: P |s = |s , ∀P ∈ S 2 n . This completes the proof.
The algorithm for computing the QAOA energy is as follows. Suppose we hold a group of classical symmetries of the objective function (in Sec. 4 we show how such groups can be heuristically obtained for many relevant problem classes). Begin by computing classes of equivalence {S m } M m=1 on subsets of qubit (variable) indices corresponding to the terms of the Hamiltonian. If we denote an (arbitrarily chosen) representative of the equivalence class by s m ∈S m , the total energy can be computed by evaluating M terms as follows: Note that although in this paper we focus on the case where the value β, γ| p j∈sm Z j | β, γ p is computed classically, the proposed method is applicable irrespective of how the value of the observable is evaluated.
Remark. Although Theorem 1 is formulated for QAOA and for observables that are products of the Pauli Z, it can be easily generalized by noting that the relevant conditions are (i) invariance of the ansatz under symmetry (i.e., A |ψ(θ) = |ψ(θ) ) and (ii) observables satisfying the relation A † j∈S1 P j A = j∈S2 P j , where P j ∈ {X j , Y j , Z j } is a single-qubit Pauli acting on qubit j.
An interesting future direction is exploring the applications of such generalizations to reducing the resource requirements of the variational quantum eigensolver [34].

Accelerating QAOA training by using fast graph automorphism solvers
To apply the findings of Sec. 3 in practice, one needs a way of obtaining the group of symmetries of the classical objective function. We now outline how heuristic graph automorphism solvers can be used for this purpose, both for problems defined on unweighted graphs and in more general cases.
The first class of problems we consider are problems defined on unweighted graphs. Graph problems are of particular interest to the study and near-term applications of QAOA and have been studied extensively in recent years. Problems considered include MaxCut [15,35,36], Maximumk-Cut [17], Maximum Independent Set [37,38], Community Detection [5,39,40], Graph Vertex k-Coloring [41], Maximum k-Colorable Subgraph [42], Graph Partitioning [8], and many more [43][44][45]. The combination of hardness and sparsity make graph problems especially appealing as an early application of QAOA, as evidenced by the fact that a number of recent experimental demonstrations apply QAOA to graph problems [4,46]. For problems defined explicitly on unweighted graphs, the group of automorphisms of the graph is a subgroup of the group of symmetries of the problem.
A second class of problems are problems with objective functions of the form An important problem class of this form is the Sherrington-Kirkpatrick spin model. In this case, classical symmetries of the objective function can be found by considering a graph G = (V, E) with each edge in E assigned a color in such a way that two edges (i, j) and (u, v) have the same color if and only if J i,j = J u,v . Although standard tools such as nauty and Traces cannot handle graphs with colored edges directly, the problem can be converted to an equivalent one where the colors are assigned to vertices instead of edges [47]. In many cases, the coefficients J i,j have discrete support, such as J i,j ∈ {−1, 1}, and thus the problem can have nontrivial amounts of symmetry. On the other hand, if coefficients come from a continuous distribution, such as a normal distribution truncated to some interval, the problem is expected to have no classical symmetries.  . The horizontal axis is the graphs in the benchmark set of [28], sorted in order of increasing speedup. For some graphs (indicated with a missing marker for p = 2 or p = 3), the energy could not be computed given the chosen resource constraints. For p = 1, the improvement is observed for 89% of the graphs with a small search tree and 61% of the graphs with a large search tree. For the detailed results, see Tables 1 and 2.
In this work we do not consider problems with higher-order terms. The symmetries of such problems can be found using graph automorphism solvers by considering an appropriately constructed bipartite graph. Because of the overhead of doing so and the lack of readily apparent applications, we do not examine problems with terms beyond quadratic.

Application to RQAOA
In this subsection, we briefly describe how the proposed approach can be applied to accelerating the recursive quantum approximate optimization algorithm (RQAOA). RQAOA has been proposed in [15,16] and aims to overcome the limitations of QAOA that arise from its locality. We begin by outlining the algorithm and then show how our findings can be used to improve its performance in practice. For detailed discussion of RQAOA the reader is referred to [15][16][17]; pseudocode for RQAOA is given in [16,Appendix C.3].
Consider an objective of the form 6 and the corre- where Z j is the Pauli Z on qubit j. RQAOA begins by finding parameters that maximize the standard QAOA energy β, γ| p H n | β, γ p . Then for every term in the Hamiltonian the value E p ( β, γ, (i, j)) = β * , γ * | p Z i Z j | β * , γ * p is computed, where β * , γ * are the optimized parameters.
Then, the term such that E p ( β, γ, (i, j)) has the largest magnitude is chosen and variable z j is eliminated by imposing constraint z j = sgn(E p ( β, γ, (i, j))z i . The process is repeated until the number of variables becomes small enough for the resulting optimization problem to be solved by a classical algorithm or brute force.
Our findings can be applied to RQAOA in two ways. First, at each step the repeated evaluations of QAOA energy needed for finding QAOA parameters can be accelerated by leveraging symmetries as outline above. Second, out of all terms E p ( β, γ, (i, j)), (i, j) ∈ E only those that are not connected by symmetry need to be independently evaluated.

Numerical Experiments
We implement the proposed approach on the MaxCut problem using the state-of-the-art tensor network simulator QTensor [11,18] for evaluating QAOA energies and the nauty [19] solver for computing the group of automorphisms of a graph. We do not leverage any properties of the Max-Cut problem except the fact that it is defined on unweighted graphs, and we expect similar results if our approach is applied to other graph problems. We release the complete dataset and the source code at [48].
To illustrate the potential as well as the limitations of the proposed approach, we consider the set of graphs used for benchmarking graph automorphism solvers in [28]. The set contains graphs with up to 10,000 nodes and up to 120,050 edges. Following [28], we consider two groups of graphs: graphs with large search trees (Table 1, typically hard for graph automorphism solvers) and graphs with small search trees ( Table 2, typically easy). We execute nauty in sparse mode via the dreadnaut interface and allow it 72 hours to complete. We note that the observed running times of nauty are slower than those reported in [28] and can be further improved by careful tuning, which we purposefully avoided.
To evaluate QAOA energies, we run QTensor either on each term of the problem Hamiltonian (t s ) or only on one term from each class of equivalence computed from the symmetries of the problem (t acc ). We limit the total running time to 30 hours and 62 GB of RAM, and we exclude the graphs for which the energy cannot be computed within these constraints even for p = 1 (typically, the computation of QAOA energy is memory bound). Thus we are left with 30 graphs with large search trees and 18 graphs with small search trees.
In Fig. 1 we present the speedup achieved by leveraging the symmetries. For the graphs with large search trees (i.e., graphs that are typically hard for automorphism solvers) for p = 1 we observe an improvement in 17 out of 28 graphs (61%), with an overall median speedup of 1.79. For the graphs with small search trees (typically easy for automor- Small search trees Figure 2: Violin plot of speedup obtained by leveraging the symmetries of the graph for the graphs with large search trees (a) and small search trees (b) for p = 1, 2. We exclude graphs for which energy calculation for p = 2 could not be completed. The lack of speedup on some instances is due to the cost of computing the group of automorphisms outweighing the savings in QAOA energy computation from leveraging the computed symmetries. We observe that the speedup is higher for p = 2 than it is for p = 1 for all graphs in our dataset with the exception of one graph (cfi-20) with a small search tree. For this graph the times to compute the group of automorphism and the energy were low, resulting in small variations in running times and leading to a slight decrease in the speedup (see corresponding row of Table 2 for detailed information).
phism solvers) for p = 1 we observe an improvement in 16 out of 18 graphs (89%), with a median speedup of 8.96. For p > 1 the observed speedup is larger because the fixed cost of computing the group of automorphisms is amortized by the increasing cost of computing the QAOA energy. In this sense, the results for p = 1 and graphs with large search trees provide a "worst-case scenario" for the proposed methods; choosing different graphs and higher depths is expected to lead to higher speedups. This effect is illustrated in Fig. 2. We do not list statistics such as median speedup for p > 1 since for many graphs the energy could not be computed given the limit of 62 GB of RAM. The complete results are presented in Tables 1 and 2. For p = 2 (and graphs ag2-49, pg2-32, pp-27-1) and for p = 1 (and graph had-232), the standard approach did not complete within 20 hours. For these instance the running time t s for the standard approach is estimated from actual running time t actual ≈ 20h and the number of processed Hamiltonian terms N t by assuming that the average cost of processed, randomly selected terms is equal to the average cost of processing all Hamiltonian terms. This gives an estimate of the running time t s = t actual |E| Nt . Note that the running times and the speedup we report are for computing the QAOA energy once. In practice, the symmetries would be computed once and be used to evaluate the QAOA energy repeatedly (e.g., in the process of optimizing QAOA parameters). Accounting for such repeated evaluation would dramatically improve the speedup: in the case of the graph with the smallest speedup (largest slowdown), mz-aug2-22, amortizing the cost of computing the automorphisms over 5,000 energy evaluations results in a speedup of 1.37, rather than the reported slowdown of ≈ 1061 observed if the energy is evaluated only once.

Discussion
In this paper we presented an approach for accelerating the computation of the QAOA energy by leveraging fast graph symmetry solvers. We observed a median speedup of 1.81 in the worst-case scenario of graphs specifically selected for being hard for automorphism solvers and p = 1. Speedups are expected to be orders of magnitude larger in realistic settings where the QAOA energy is evaluated repeatedly, a situation that arises, for example, when seeking optimal QAOA parameters. When a slowdown-corresponding to situations where the automorphism calculation required more time than was saved by exploiting any found symmetry-was observed, the effect was generally far less extreme than the benefit encountered in other cases. In practice, we envisage that the automorphism solvers would be run with some small time limit (e.g., 10 minutes), with the QAOA energy computed the standard way if the solver did not successfully finish within this limit.
An important consideration for applicability of the proposed approach is the expected amount of symmetry in the problem, which is often known a priori. If the problem considered is defined on a random three-regular or Erdos-Renyi model graph, then it is expected to have no symmetry [24,25], and the step of computing symmetries can be omitted. At the same time, if the problem is defined on a structured graph, a significant amount of symmetry may be expected, and the proposed approach should be applied. As illustrated here, applying such an approach has little downside relative to the speedups it typically produces.
A sufficiently large symmetry group may make the problem classically trivial, which is the case for the complete graph K n . On the other hand, in most cases taking advantage of symmetry to solve the problem is highly nontrivial, and symmetry may in fact make the problem harder to solve in practice. For example, in integer programming, symmetry is known to make problems extremely difficult for branchand-bound solvers. There have been efforts to use information about the symmetry group to reduce the size of the search tree in branch-and-bound methods [49,50]. However, these typically address only a subset of symmetries present in the problem and still lead to nontrivial running times for classical solvers even on moderately sized instances.
An important future direction is focusing on local, rather than global, symmetries, as well as symmetries that are approximate, rather than exact. A step in that direction has been made in [20]. Fully exploiting the locality of QAOA and its interplay with local symmetries in the problem is expected to lead to significant further gains.

Acknowledgments
We thank Danylo Lykov for help with QTensor and Stuart Hadfield for the feedback on the manuscript. We are grateful to anonymous referees whose suggestions improved the presentation. This work was supported in part by the  Table 1: Benchmark graphs with large search trees and thus hard for graph automorphism solvers. N orb is the number of classes of equivalence on terms of the cost Hamiltonian, which is equal to the number of edge orbits of the graph. The smaller the value of N orb , the more symmetric the graph is. For N orb = 1, the expected speedup is O(|E|), since we only need to evaluate one term instead of |E|. t aut is the time (in seconds) to compute the edge orbits of the graph using nauty. t s is the time (in seconds) to compute the QAOA energy using the standard approach. t acc is the time (in seconds) to compute the QAOA energy by leveraging the information about edge orbits. S = ts taut+tacc is the speedup (larger is better; S < 1 corresponds to slowdown). "nan" denotes cases where the energy computation could not be completed under chosen resource limits. Note that the speedup increases with p because computing the group of symmetries of a graph is a fixed cost, which is offset by the increased cost of evaluating the QAOA energy. For two graphs, mz-aug2-30 and mz-aug2-50, it was not possible to compute the group of automorphisms within the chosen time limit (72 hours), even though they are small enough for the QAOA energy to be easily computable.