Optimization complexity and resource minimization of emitter-based photonic graph state generation protocols

Abstract

Photonic graph states are important for measurement- and fusion-based quantum computing, quantum networks, and sensing. They can in principle be generated deterministically by using emitters to create the requisite entanglement. Finding ways to minimize the number of entangling gates between emitters and understanding the overall optimization complexity of such protocols is crucial for practical implementations. Here, we address these issues using graph theory concepts. We develop optimizers that minimize the number of entangling gates, reducing them by up to 75% compared to naive schemes for moderately sized random graphs. While the complexity of optimizing emitter-emitter CNOT counts is likely NP-hard, we are able to develop heuristics based on strong connections between graph transformations and the optimization of stabilizer circuits. These patterns allow us to process large graphs and still achieve a reduction of up to 66% in emitter CNOTs, without relying on subtle metrics such as edge density. We find the optimal emission orderings and circuits to prepare unencoded and encoded repeater graph states of any size, achieving global minimization of emitter and CNOT resources despite the average NP-hardness of both optimization problems. We further study the locally equivalent orbit of graphs. Although enumerating orbits is #P complete for arbitrary graphs, we analytically calculate the size of the orbit of repeater graphs and find a procedure to generate the orbit for any repeater size. Finally, we inspect the entangling gate cost of preparing any graph from a given orbit and show that we can achieve the same optimal CNOT count across the orbit.

Introduction

Graph states are garnering an increasing amount of interest for quantum networks^{1,2,3,4,5,6,7,8,9,10}, error correction^11,12,13, measurement-based or fusion-based quantum computing¹⁴, and enhanced sensing^15,16. They are stabilizer states that can be represented by graphs, providing a graphical method to understand their entanglement structure^{17,18,19,20,21,22} and utility for error correction codes^23,24. Stabilizer and graph states are also crucial for understanding the complexity of quantum circuits and the cost of the Clifford part of universal quantum circuits^25,26.

In all-photonic architectures, photonic graph states can be prepared using fusion gates and multiplexing to increase the success probability of probabilistic fusions¹⁴. An alternative way to prepare photonic graph states is by utilizing quantum emitters such as color centers^27,28,29, quantum dots^30,31,32, or atoms^33,34. In this approach, the emitters mediate the entanglement between the photons, and the preparation is deterministic. There are several proposals for how to create graph states from quantum emitters, with well known examples being cluster states^30,32,35,36 and repeater graph states (RGSs)^1,4,37. For arbitrary graphs, the generation schemes typically assume unrestricted connectivity³⁸ or constrained connectivity, which might require a large number of SWAP gates. A recent algorithm that incorporates connectivity constraints was developed in ref. ³⁹; this algorithm takes an arbitrary photonic graph state as input and outputs the minimal number of emitters needed to produce the state and an explicit state generation circuit. The runtime of the algorithm and the depth of the circuit it produces are both polynomial in the size of the target graph state.

Although there has been a lot of progress in developing algorithms for generating photonic graph states, the question of how to prepare them optimally using minimal resources is still a line of ongoing research. Reference³⁹ showed that the minimal number of emitters depends on the emission ordering. Moreover, for a given target graph, the complexity of finding the photon emission ordering that requires the fewest emitters is generically NP-hard, as it relates to finding the linear rank-width of the graph. Despite this, there exist heuristics that can be used to identify optimal orderings. Even if one fixes the emission ordering, there remain multiple options for what gates to perform at each step of the algorithm of ref. ³⁹, and each choice can lead to a very different state generation circuit. In addition to the number of emitters, another very costly resource is the number of emitter-emitter CNOT gates appearing in the generation circuit. Reference³⁹ did not address the question of how to minimize the number of these CNOTs. On the other hand, several other works have examined the question of how to reduce CNOT gate counts more generally in stabilizer circuits. The Gaussian elimination algorithm of ref. ⁴⁰ corresponds to unrestricted connectivity and requires at most ${\mathcal{O}}({n}^{2})$ CNOT gates. The algorithm developed in ref. ⁴¹ for unrestricted connectivity achieves at most ${\mathcal{O}}({n}^{2}/\log 2(n))$ CNOT gates, using parallel row-elimination matrices. Reference⁴² developed an algorithm for restricted connectivity which achieves at most a ${\mathcal{O}}({n}^{2}/\log 2(\delta ))$ circuit size, where δ is the minimum node degree of the graph. Reference⁴³ further proved bounds on the number of entangling gates with respect to the rank-width of a graph, and provided ${\mathcal{O}}(n)$ CZ-complexity algorithms for special cases of graphs. These works have shown progress in reducing CNOT\ CZ counts, but the complexity of minimizing the number of CNOTs in stabilizer circuits for constrained architectures, as well as the complexity of the photonic graph preparation based on ref. ³⁹, are still open problems. Very recently, ref. ⁴⁴ showed that the number of CNOTs needed to produce an RGS of 2n photons is n − 2. This was done by searching through the space of graphs locally equivalent to the target state (i.e., the local complementation (LC) orbit²⁰) and applying the algorithm of ref. ³⁹ to each to find the graph with the minimal CNOT count.

In this paper, we develop several different optimization algorithms to reduce the emitter CNOTs required to prepare arbitrary photonic graph states. Using these algorithms, we obtain the following results:

• Using our most computationally expensive algorithm, we show a reduction of emitter CNOT gates up to 75% for modest-sized graphs compared to a naive implementation of the algorithm developed in ref. ³⁹. Although there are strong indications that this CNOT minimization problem is NP-hard, we identify and incorporate into our algorithms heuristics that enable them to reduce the CNOT counts up to 66% even for large graph states containing hundreds of photons.

• We find the optimal emission ordering that minimizes the number of required emitters for both unencoded and logically encoded RGSs of any size, although the general problem is NP-hard.

• We find that any LC-equivalent RGS can be generated with n − 2 CNOTs, where 2n is the number of photons in the state, in agreement with ref. ⁴⁴. Unlike in ref. ⁴⁴, we do not need to search through LC-equivalent graphs to find such minimal CNOT circuits. Instead, we can start from any graph in the LC orbit and directly construct a circuit that generates it using only n − 2 CNOTs. Our results imply that there is not an intrinsic correlation between the number of edges in the target graph state and the minimal number of CNOTs needed to produce it, as was suggested in ref. ⁴⁴. This correlation was likely due to specific algorithmic settings used in ref. ³⁹ rather than to fundamental features of the algorithm. We also show that RGSs with logical encodings that protect against photon loss exhibit the same CNOT scaling.

• We find analytical expressions for the size of the LC orbits of complete graphs and of RGSs. This is despite the fact that this counting problem is #P-complete for arbitrary graphs. We further show that if we exclude graphs that differ from others in the orbit by only a relabeling of vertices, then the resulting orbit is linear in the size of the RGS. We show this for RGSs without and with extra leaf qubits.

• RGSs with different photon orderings generally require different numbers of emitters and different numbers of emitter-emitter CNOT gates to produce, as was shown in ref. ³⁹. However, here we find numerical evidence that there may exist a simple correlation between these two resources: Photon orderings that require the same number of emitters also require the same number of CNOTs, even if the graphs with these different orderings are not LC-equivalent. This is a feature that does not apply to generic graphs.

• The fact that LC-equivalent graphs can be generated with the same number of CNOTs follows from the fact that such states are the same up to single-photon gates. However, this does not mean that a given graph state generation algorithm will necessarily find circuits with the same minimal number of CNOTs for two LC-equivalent graphs. We perform an exhaustive search across all graph states of six photons and find that, with our optimized algorithms, LC-equivalent graphs always require the same number of emitter-emitter CNOTs to produce. We conjecture that, unlike the algorithms of refs. ³⁹ and ref. ⁴⁴, our optimized graph state generation algorithms are capable of constructing minimal-CNOT circuits for any target graph state.

The code for our algorithms can be found in ref. ⁴⁵.

Our paper is organized as follows. In Section “Minimizing the number of entangling gates in photonic graph state generation”, we explain the algorithm of ref. ³⁹ in terms of graph modifications, discuss the complexity of the optimization problem, and test the performance of our optimizers for random graphs. In Section “Properties of LC graphs and summary of graph theory tools”, we discuss graph theory concepts related to circle graphs and local complementations. In Section “Size of LC orbit of known families of graphs”, we find analytically the size of LC orbits of well-known graphs. In Section “Optimal resources for unencoded and encoded repeater graphs”, we study the optimal preparation of RGSs. Finally, in Secton “Study of LC orbits”, we focus on minimizing the preparation resources across LC orbits of random graphs.

Results

Minimizing the number of entangling gates in photonic graph state generation

Graph visualization of the algorithm

The photonic graph state generation algorithm introduced in ref. ³⁹ was developed using the stabilizer formalism. Here we develop various optimizers with improvements and additional features compared to this algorithm. A summary of our toolbox is shown in Fig. 1, which we will analyze throughout the paper. First, we briefly review how the algorithm of ref. ³⁹ works and also show how we can visualize the main steps of the algorithm in terms of graph rather than stabilizer operations.

Fig. 1: Overview of optimization of photonic graph state generation.

The input photonic graph is fed into the tableau class simulator, from which we can choose different optimizers to minimize its preparation cost. The outputs of the simulator can be used for visualization of the results (e.g., circuit, or graph state evolution). Extra external functionalities further allow us to characterize the graphs, such as enumerating or generating their LC orbits.

The algorithm starts from a target stabilizer state of entangled photons with a specified photon emission ordering. The algorithm first calculates the number of emitters required to generate the target state by computing the maximum bipartite entanglement entropy for the given emission ordering. This is facilitated by putting the tableau of stabilizers in the row-reduced echelon form (RREF)²¹. Once the minimal number of emitters is obtained, the generation circuit is then constructed step-by-step by working backwards in time. That is, the algorithm starts with the stabilizer tableau of the target photonic graph state and decoupled emitters and successively modifies it through a series of Gaussian eliminations (each time restoring it to RREF) until the tableau is converted into that of a product state for all photons and emitters. This product state is the actual initial state corresponding to decoupled emitters and photons that have not yet been emitted, and the actual generation circuit is obtained by inverting the time-reversed circuit produced by the algorithm. The resulting circuit must obey the constraints that photon-photon gates are forbidden, and that photons are emitted from the quantum emitters according to the specified emission ordering. At intermediate stages of the algorithm, emitters and photons are entangled with one another, but there is no emitter-photon entanglement at the beginning or end of the generation circuit. All the entanglement generated during the algorithm (and hence all the entanglement in the final photonic graph state) originates either from the photon emission process or from emitter-emitter entangling gates.

The time-reversed circuit that the algorithm builds up from the sequence of Gaussian eliminations consists of two main primitives: photon absorption and time-reversed measurement (TRM). The overall goal of the time-reversed circuit is to absorb all of the photons into the emitters in the reverse of the chosen emission ordering. However, it is not always possible to absorb a photon at a given step of the algorithm since the ability to do so depends on the structure of the photon-emitter state at that stage. Photon absorption is the time-reverse of photon emission. Since photon emission creates photon-emitter entanglement, photon absorption removes it, but this can only happen if the photon in question is already entangled with emitters. When a photon absorption is not possible, we instead perform a TRM to prepare the state for the next absorption. TRMs are operations that act on emitters that are not entangled with photons or other emitters. This is because TRMs are time-reversed versions of ordinary projective measurements on emitters, and since the measured emitter is completely decoupled in the post-measurement state, TRMs can only act on decoupled emitters in the time-reversed circuit. TRMs generate photon-emitter entanglement, thus enabling a subsequent photon absorption. In particular, the result of a TRM is to connect the decoupled emitter with the neighborhood of the photon to be subsequently absorbed (see, for example, 2nd step in Fig. 2, and proof in Supplementary Information dmmc1 IA)(To be more precise, the TRM connects the decoupled emitter with the neighborhood of the photon to be absorbed, up to some local complementations. For example, in Fig. 2, if we apply G*8*9*8, where G is the graph of panel 6, then we recover the rule we mentioned about TRMs going from panel 5 to panel 6. Here, ‘*v’ refers to local complementation about v which is defined later on.). The first step of the graph state generation algorithm always involves TRMs, because a photon absorption is not possible when all photons are decoupled from emitters. TRMs can also happen mid-circuit, and they might require emitter-emitter CNOTs beforehand. The emitter CNOTs can disentangle a chosen emitter from the rest, allowing it to then undergo a TRM to create more emitter-photon entanglement and prepare the state for the next photon absorption Table 1.

Fig. 2: Time-reversed evolution of the photon-emitter graph state during the graph state generation algorithm.

The input target state shown in panel 1 contains of 6 entangled photons (black nodes) and 3 decoupled emitter qubits (orange nodes). The algorithm converts the input state into the disentangled state shown in panel 15 through a sequence of time-reversed measurements (TRMs) and photon absorptions (PAs), interspersed with single-qubit gates and emitter-emitter CNOT gates (DE). We omit showing steps that involve single-qubit gates.

Table 1 Height function condition (cond.) that dictates whether the operation (oper.) of time-reversed measurement (TRM) or of photon absorption (PA) is applied, and the stabilizer operations we apply (sub-circuit to perform oper.)

Let us take a closer look at photon absorption. When photon absorption is possible, the tableau has at most two stabilizer rows (due to RREF) in which the first non-identity Pauli starts from the photon to be absorbed. In some cases, photon absorption happens freely, meaning that there is an available emitter we can use, and no emitter-emitter CNOTs are required upfront. In the tableau formalism, this means that a stabilizer of the form ${I}^{\text{photon}(1)}\ldots {I}^{\text{photon}(j-1)}{\sigma }_{j}^{\,\text{photon}\,\,(j)}{\sigma }_{k}^{\,\text{emitter}\,\,(l)}$ exists, such that the Pauli weight on emitter qubits is one. The absorption is performed by transforming both the photon and the emitter Paulis into Z via local gates, and then applying CNOT_em,ph. In other cases, the photonic stabilizer row(s) could have more than one non-identity emitter Pauli, in which case we need to apply emitter-emitter CNOTs first to reduce the Pauli weight on emitters to one, which then enables a single emitter to absorb the photon. (The emitter choice is not unique, as we discuss further later on.) Graphically, free absorption happens in any of the following three scenarios:

• An emitter is a leaf of the photon to be absorbed. See steps 8–9 of Fig. 2.

• The photon to be absorbed is a leaf of the emitter. See steps 10–11 of Fig. 2.

• The emitter is connected to the neighborhood of the photon to be absorbed. See steps 2–3 of Fig. 2.

By “leaf" of a qubit, we mean a neighboring qubit that itself has no other neighbors. Note that steps 8, 10, 12, 14, and 15 of Fig. 2 correspond to emitter CNOTs. The decision of how we apply these CNOTs, meaning which emitter we free up for the next photon absorption, is not unique, and our decision affects the total CNOT count. For example, the generation path of Fig. 2 is not optimal, and in Supplementary Information IB, we show that the graph can be prepared with only 3 emitter CNOTs.

Optimization of CNOT cost and complexity of minimizing CNOTs in stabilizer circuits

Minimizing the number of emitter-emitter entangling gates used to prepare an arbitrary photonic graph state is, in general, a non-trivial task. In principle, there are several choices we can make in the construction of the circuit to minimize this metric, and it is not always clear a-priori which decision path we should follow. When we can absorb a photon using an available emitter (without needing emitter CNOTs), we can follow this path because it does not increase the number of CNOTs. It is important that we maximize the number of free photon absorptions, but it is not always obvious how to do this from the RREF gauge. This is because the RREF gauge on its own does not always ensure that the stabilizers have minimal Pauli weight. For this reason, we might also need to perform “back-substitution" while preserving the RREF gauge, by which we mean that we try multiplying each stabilizer with “shorter" stabilizers further down in the RREF tableau—if a product has lower weight, then we replace the stabilizer with this product. In Supplementary Information IC, we provide Algorithm 2, which performs the back-substitution. That section also includes Algorithm 3, which searches through all possible conditions for free absorption.

When the absorption cannot be performed “freely” (i.e., without needing emitter CNOTs), we can choose to free up any of the available emitters with a non-identity Pauli in the photonic stabilizer row(s). For example, consider the simplest case where we have the stabilizer $I\ldots I{Z}^{{\rm{photon}}(j)}{Z}^{{{\rm{em}}}_{1}}{Z}^{{{\rm{em}}}_{2}}$. (More generally, such a stabilizer can have Pauli’s different than Z’s, and we can transform them with local gates into Z’s.) In this case, we can choose to do ${{\rm{CNOT}}}_{{{\rm{em}}}_{1},{{\rm{em}}}_{2}}$ or ${{\rm{CNOT}}}_{{{\rm{em}}}_{2},{{\rm{em}}}_{1}}$. Because CNOT_ij transforms Z⁽ⁱ⁾Z^(j) into I⁽ⁱ⁾Z^(j), the Pauli of the target qubit is preserved in the stabilizer row, and this qubit can then absorb the photon. Although at the current step we cannot avoid a CNOT gate between the emitters, which emitter we choose to absorb the photon could affect the number of CNOTs required in later stages of the algorithm.

Because the stabilizers that represent the state are not unique, another freedom in the optimization comes from multiplying stabilizer rows. We can explore this freedom when emitter CNOTs are necessary before photon absorption. At every step, there are at most two photonic stabilizer rows that start from the photon that we want to absorb (due to the RREF gauge). Multiplying these rows together changes the Pauli operators of emitters and can also change which emitters remain in the photonic stabilizer row, and thus which are available for absorbing the photon. Consequently, we end up with new local gates that we can perform before deciding how to apply the emitter CNOTs that leave one emitter to absorb the photon. Additionally, at some time step, we could also have a stabilizer (or stabilizers) that has support only on emitter sites. We could multiply such a stabilizer with the photonic stabilizers (of the photon to be absorbed), which once again changes the local gates and emitter CNOTs we apply. The same effect of requiring different local gates comes also from performing back-substitution. Instead of only putting the tableau in the RREF gauge before every photon absorption step (which is done irrespective of whether free absorption is possible), we can go one step further and do the back-substitution. We find that this also affects the total gate count and, in most cases, leads to reduced circuit size.

Finally, we can also perform local complementations (LCs) before making an emitter choice. Complementing locally the graph G about a vertex v, which we denote as G*v, inverts the neighborhood of the node v, N_v = {w ∈ V(G)∣(w, v) ∈ E(G)}, where V(G) is the vertex set and E(G) is the edge set. That is, for every pair of vertices (w, p) ∈ N_v, we either remove an existing edge between them or add one if there wasn’t one already. An LC translates to the following Clifford operation^46,47,48:

$${U}_{v}^{\,\text{LC}\,}=\sqrt{-i{X}_{a}}\prod\limits_{j\in {N}_{v}}\sqrt{i{Z}_{j}} \sim {H}_{a}{P}_{a}{H}_{a}\prod\limits_{j\in {N}_{v}}{P}_{j}^{\dagger },$$

(1)

where H_a (P_a) is a Hadamard (phase) gate acting on qubit a.

Multiple LC rounds form an LC sequence about vertices vw…p such that $G{\prime} =G* vw\ldots p$. We will explain in detail the role of LCs in the optimization of stabilizer circuits in Section “Study of LC orbits”. For now, we stress that if a graph is the local complement of another graph, then the graphs are related by local graph transformations, and the stabilizer states differ up to local Clifford gates. Similar to the new choices over local gates generated by row multiplications of the stabilizers, the extra degree of freedom of inspecting local complements can be incorporated into the optimization of generating photonic graph states.

Overall, we need to inspect several degrees of freedom to ensure optimal preparation of any generic graph, and the number of choices we can make grows quickly with the number of emitters and graph size. This indicates that the problem of minimizing the number of CNOTs to generate arbitrary photonic graph states utilizing the algorithm of ref. ³⁹ is, on average, a hard problem. There exist related works in the literature that all involve mapping the problem of the optimization of CNOT circuits (known as linear reversible circuits) to NP-complete (for the decision variant), or NP-hard (for the optimization variant) problems. We summarize the conclusions of these other works here:

• In ref. ⁴⁹, the authors mention that optimizing the size or depth of an n-qubit CNOT circuit, using m ancillas and with topological constraints on the connectivity, is NP-hard. They prove that it is also NP-hard to optimize a corresponding sub-circuit.

• Reference⁵⁰ discusses the minimum fill-in problem. To obtain circuits of minimum size, we need to minimize the steps in the Gaussian elimination where zero entries might become non-zero. The question of whether it is possible to do the Gaussian elimination with at most k fill-ins is NP-complete as was proven in ref. ⁵¹.

• In ref. ⁵², the problem of synthesizing linear reversible circuits is translated into the syndrome decoding problem, which is known to be an NP-hard optimization problem. The authors develop heuristics to minimize the CNOTs for restricted or unrestricted architecture connectivity.

• In ref. ⁴², the authors use Steiner trees to optimize the size of the Clifford circuit. The decision variant of the minimum Steiner tree is NP-complete, and its optimization variant is NP-hard. Thus, the authors construct 2-approximations to Steiner trees to achieve ${\mathcal{O}}({n}^{2}/\log (\delta ))$ circuit size, where δ is the minimum degree of the graph⁵³.

Since from the perspective of our optimization problem, we also find that minimizing the number of CNOTs requires that we inspect exponentially many decisions, it is unlikely that a polynomial time algorithm can be developed for the general case. However, later on, we will show how to use different optimization methods to obtain nearly optimal CNOT counts and show under which cases we can make more optimal choices for the construction of the circuit, without exploring the entire search space (Table 1 and Table 2).

Table 2 Notations of graph families and the family each one represents

Description of Brute-force algorithm

We now describe our Brute-force algorithm, which we use to address many degrees of freedom, while targeting choices that matter the most. It is a tree decision algorithm that inspects multiple paths we can follow on the most crucial optimization step, the step that requires emitter CNOTs before absorption. When absorption of photon j is possible but we first need to apply emitter CNOTs, the algorithm explores the following paths:

• It picks any of the available emitters of the two photonic stabilizer rows to absorb the photon.

• It multiplies the photonic rows (if two of them exist) and then picks, again, any of the available emitters to absorb the photon.

• It multiplies stabilizers that have support on emitters (if such stabilizers exist) on photonic rows and then inspects emitter choices again.

• It performs LCs, based on the cutoff of LC rounds and nodes we choose to complement about, and for each such realization tests, again, photonic absorption utilizing any of the available emitters.

All the above choices are explored for the current photon absorption level, and each tableau is fed to the next algorithmic steps of time-reversed measurements and absorptions. In those next levels, new tableaux are generated and processed next. Once all tableaux are processed (we have a product state of all qubits), the circuit with minimal CNOT counts across all realizations is selected as optimal. The algorithm has also a pruning option of how many realizations to keep per level. This option allows us to prune the search since the choices we explore increase quickly with increasing graph size or emitter resources.

In Fig. 3, we compare the performance of the Naive approach against the Brute-force method for random graphs of n_p = 7 and n_p = 8 photons. The Naive approach does not perform back-substitution and does not exhaust all checks for free photon absorption (PA). For the absorption step, it first attempts to perform free PA. It finds the photonic stabilizer row(s) which starts with a non-trivial Pauli on the photon to be absorbed, and tests if there is only one emitter site with a non-trivial Pauli in these rows. If this is true, the emitter is used for absorption. If this is not true and there are two photonic rows, it multiplies them together and tests again if there is only one emitter site in the new photonic row that we obtain. If this is true, the emitter is used for free PA. Otherwise, we search for stabilizers with support only on emitter sites. If such a stabilizer exists, we test if free PA is possible after multiplying the stabilizer with support on emitters with the photonic stabilizer row. If there are two photonic stabilizer rows, we multiply first on the first photonic stabilizer row, and test for free PA, and repeat the same for the second photonic row. If there are multiple stabilizers with support on emitters, we multiply one of them at a time at a given photonic row, and re-check the free PA, till we have looped over all emitter stabilizers and photonic stabilizers. If this condition also fails, then we return with a flag that free PA was not successful, and resort to a PA that requires that we first perform emitter-emitter CNOTs. Of the two photonic rows that could exist, we pick the one with minimal Pauli weight on emitter sites, and we free-up the first emitter we encounter in this row via emitter-emitter CNOTs. Thus, the Naive approach picks an emitter randomly in this final decision step. In Figs. 3a, b, we search over all degrees of freedom we mentioned for the Brute-force method, and enable one round of LCs. We note a substantial reduction in emitter CNOTs, with a maximum of up to 75%. For several graphs, we see a reduction of 50–67% in emitter CNOT counts, and the average reduction across the 2000 graphs of order n_p = 7 is ~22%. In Figs. 3c, d, we repeat the same calculation, but for graphs of n_p = 8 photons. For these random graphs, we again enable the final optimization step of LC operations before the photon absorption, but we prune some of the choices (i.e., potential tableaux that we will explore per step). Although we prune away choices, we still note that the reduction in emitter CNOTs can reach up to ~67%.

Fig. 3: Comparison of CNOT cost between the naive and brute-force algorithms.

a Emitter CNOT counts obtained from the Naive (black), and Brute-force optimizer (yellow), for 2000 random graphs of order n_p = 7. b Percentage reduction of CNOT counts for each graph of (a). c Same as in (a), for 500 random graphs of n_p = 8. d Percentage reduction in emitter CNOT counts for the graphs of (c).

Description of Heuristics #1 optimizer

Although our Brute-force algorithm obtains close to optimal CNOT counts for small-sized graphs, it is inefficient to inspect all degrees of freedom we mentioned for large graphs. Even if we were to prune choices, we would end up chopping our search space severely and in a blind way. However, in several cases, we observed that the Brute-force optimizer uncovers a particular pattern associated with the optimal decision. Here, we will explain and use this pattern to develop efficient heuristic methods that improve substantially the CNOT counts.

As we mentioned previously, back-substitution on the RREF tableau tends to lead to shorter circuits and fewer CNOTs. Thus, in our heuristics method we incorporate the option to perform back-substitution right before every photon absorption, and we also enable the option to exhaust all possibilities for free photon absorption. Additionally, as the size of the graph and emitter resources increase, we end up with a large number of entangled emitters at the final step where we disentangle only emitter qubits. If we perform back-substitution again in this last step, we find that in several cases we reduce the CNOT counts, because back-substitution tends to reduce the weight of the stabilizers. All these extra improvements do not increase substantially the runtime (see Supplementary Information ID).

An important decision step is which emitter to “free up” for absorption via local gates and CNOTs. The emitter with a non-trivial Pauli on the photonic stabilizer row can then absorb the photon. In several cases, the Brute-force optimizer selects local gates and an emitter for absorption, such that the application of emitter CNOTs increases the number of disconnected subgraphs. In other words, if we track the graph evolution, we find that the graph splits into smaller ones, and subsets of emitters belong to different subgraphs. This means that certain emitters will never interact again before future absorptions, and they will consume photons of disjoined subgraphs.

We illustrate this feature in Fig. 4, which depicts the evolution of a 7-node graph prepared by three emitters, labeled as 8–10. We display the updated graph after each CNOT gate (corresponding to time-reversed measurement, photon absorption, or an emitter-emitter gate); we do not explicitly show the local gates that are also applied between graph updates. All decisions are identical between the Naive and Brute-force methods until the step of freeing up an emitter to absorb photon 2 (step 10 in the figure). The Brute-force method picks emitter 10, which creates two disconnected subgraphs, and ensures that emitter 10 never interacts again with emitters 8 and 9. Consequently, in the end, we need to disentangle only emitters 8 and 9, whereas in the Naive method, we need to disentangle all of them.

Fig. 4: Graph state evolution paths followed by the naive and brute-force algorithms.

Evolution of a 7-node graph prepared with the Naive, (a) or Brute-force method, (b). The top-left panel is the input graph and the bottom-right panel the final state. All steps are identical between the two methods till the decision of which emitter absorbs photon 2 (step 10). The Naive (Brute-force) method picks emitter 9 (10), and leads to 3 (2) emitter CNOTs in total. TRM is time-reversed measurement, DE disentanglement, and PA photon absorption.

This intuitive pattern also arises in the so-called nested dissection technique of Gaussian elimination on sparse matrices⁵⁴. In this context, a non-zero entry of a sparse matrix represents an edge between graph nodes (note that this graph is not the same as a graph state, rather it is an artificial graph that represents the matrix). In nested dissection techniques, one tries to identify separators, i.e., nodes whose removal will create subgraphs, so that then Gaussian elimination can be performed on each piece separately.

The search for an increase in the number of disconnected subgraphs can be used as a heuristic inspection on top of the Naive circuit generator. Our first level of heuristics explores if we can achieve this pattern during the generation. The increase in the number of disconnected subgraphs is accomplished by ensuring that the application of local gates followed by a single CNOT gate either removes an emitter from the remaining graph or breaks the graph into separate subgraphs that each have more than one node (e.g., as in Fig. 4). We first prioritize removing single emitters whenever this is possible. We find that we can deterministically choose local gates and the emitter to be removed from the graph at a particular time-step by performing back-substitution. Back-substitution is important, because it reveals whether or not stabilizers of weight 2 with support only on emitters exist. If such stabilizers exist, we use a look-up table related to what local operations we apply on the qubits before the emitter CNOT (see transformation rules in Supplementary Information IE).

Once no more weight-2 stabilizers with support on emitter sites exist, we then resort to a more extensive search for potentially creating disconnected components. We select the photonic stabilizer row of the photon to be absorbed (if two exist, we pick the one with minimal weight on emitter sites), and identify the emitters with non-identity Paulis. We take any emitter pair {i, j} and apply one of 36 possible combinations of local gates from the set {I, H, P, HP, PH, HPH} on each emitter. After that, we apply CNOT_ij or CNOT_ji and check whether a combination of these gates leads to a greater number of disconnected components. Note that PHP gives the same tableau transformation as HPH (up to different phase updates, since HPHPHP = e^iπ/4I), so we ignore the former.

The above heuristic method is implemented only before an absorption and only when no emitter is freely available. We terminate the search once we find a choice that increases the number of disconnected components, and then we re-attempt the free photon absorption. If the free absorption is still not possible, we transform all ${\tilde{n}}_{e}$ non-identity Paulis acting on emitters to Z via local gates, for the photonic row we are inspecting. We then scan through these ${\tilde{n}}_{e}$ emitters, which are all potential absorption sites, and for each we apply a series of ${\tilde{n}}_{e}-1$ CNOT gates, all with the chosen emitter as the target, so that the Paulis on the remaining ${\tilde{n}}_{e}-1$ emitters are transformed to identities (as needed for photon absorption). The emitter that yields a graph with the fewest edges following these CNOTs is chosen as the photon absorption site. We find that this procedure typically leads to a greater CNOT reduction compared to selecting an emitter randomly.

Let us also examine the cost in runtime for searching for an increase in disconnected components. In the worst-case scenario and for a particular time step, the complexity of the search scales as follows:

• For a fixed emitter pair, we apply any of the 36 combinations of local gates from the set {I, P, H, HP, PH, HPH} before the CNOT.

• We inspect any emitter pair that appears in the photonic stabilizer row at a given time step: $36\times {\tilde{n}}_{e}({\tilde{n}}_{e}-1)/2$. ${\tilde{n}}_{e}$ is the number of available emitters for photon absorption for the current photon (emitter sites with non-identity Paulis). We inspect only the photonic stabilizer row with minimal weight on emitter sites. Due to the RREF gauge, there can be at most two stabilizer rows we can use.

• We can also exchange the role of control/target qubits, which increases the number of choices by a factor of 2, giving rise to $2\times 36\times {\tilde{n}}_{e}({\tilde{n}}_{e}-1)/2$.

• We need to extract the adjacency from the tableau to count the number of connected components for each of the above choices: ${n}^{3}\times 2\times 36\times {\tilde{n}}_{e}({\tilde{n}}_{e}-1)/2$. The factor of n³ arises from Gaussian elimination.

Note that the above list does not include the final step of scanning through the potential absorption sites and applying CNOTs to find the site for which the updated graph has the fewest edges, because this step makes a sub-leading contribution to the runtime cost. [This is because we only need to apply ${\tilde{n}}_{e}-1$ emitter CNOTs ${\tilde{n}}_{e}$ times to free up any of the available emitters.] Also, we resort to this final step only if none of the above patterns succeed in increasing the number of disconnected components and we still fail to absorb the photon. By inspecting several graphs, we find that from the set of local gates {I, H, P, HP, PH, HPH}, we can discard HP and HPH because these are not usually selected by the optimizer. Thus, we reduce the search of local gates to 4 per emitter and 16 combinations per emitter pair. Further, the above worst-case scaling is for only one step of the algorithm, and so the complexity of the algorithm increases for every step in which it is not immediately clear which emitter to use for the next photon absorption. However, this algorithm is much more efficient than the Brute-force one because it does not open recursive search levels. Further analysis of this algorithm, which we refer to as the Heuristics #1 optimizer, is given in Supplementary Information IF. We should also comment that it is not always guaranteed that the choice revealed by the increase in disconnected subgraphs is globally optimal. This is because the minimum fill-in problem is NP-complete, meaning we do not know if the Gaussian elimination ordering we follow (which is also subject to constraints on which vertices can be removed) will be the most optimal one. Nevertheless, as we will show shortly, the patterns we describe lead to substantial reductions in emitter CNOTs compared to the Naive optimizer.

This summarizes the subroutines of our Heuristics #1 optimizer. In Fig. 5a, we compare the average number of emitter CNOTs obtained by the two methods for 500 random graphs of size n_p = 6 up to n_p = 50. We explore three variants of the Heuristics #1 method, which have to do with whether or not we allow back-substitution globally, and whether or not we exhaust all checks for free photon absorption. From these three methods, we keep the one that gives the lowest CNOT counts. For n_p + n_e≥ 30, we truncate the emitters we inspect as possible photon absorption sites to up to 1/3 of the available emitters in a given photonic stabilizer row. For n_p + n_e < 30, we explore all emitter pairs and local gate combinations. The black curve in Fig. 5a shows the average number of emitter CNOTs the Naive method utilizes, and the orange curve shows the number of emitter CNOTs used by the Heuristics #1 method. The dashed line shows the bound ${n}_{p}^{2}/\log 2({n}_{p})$. Reference⁴¹ developed a Gaussian elimination algorithm for unrestricted connectivity which achieves at most ${\mathcal{O}}({n}^{2}/\log 2(n))$ CNOT gates. Here we show instead the bound ${n}_{p}^{2}/\log 2({n}_{p})$, since the emitter resources per n_p are not fixed, and depend on the input graphs. In Fig. 5b, we further show the average and maximum reduction in emitter CNOTs for each value of n_p. We note that the maximum reduction across n_p is ≥35–40%. The average reduction across all n_p is ~30%. Figure 5c shows a slice of the data of Fig. 5a for n_p = 30. The black (orange) bars are the emitter CNOTs obtained by the Naive (Heuristics #1) method. For illustration purposes, we sort the data in increasing number of CNOTs required by the Naive method. We see that the percentage reduction in CNOT counts for the graphs with n_p = 30 we sampled over can reach up to ~40%.

Fig. 5: Comparison of CNOT cost between the naive and Heuristics #1 algorithms.

a Average number of emitter CNOTs needed to prepare photonic graphs from n_p = 6 till n_p = 50, using the Naive (black), or Heuristics #1 optimizer (orange). We sample 500 random graphs per n_p. The dashed line indicates the bound ${n}_{p}^{2}/\log 2({n}_{p})$. The green line shows the average number of emitters. b Mean and maximum reduction of emitter CNOTs per n_p. c Number of emitter CNOTs required by the Naive or Heuristics #1 method for 500 random graphs of n_p = 30 photons.

Description of Heuristics #2 optimizer

The Heuristics #1 optimizer sets a new upper bound on emitter CNOTs compared to the Naive scheme. To reduce the emitter CNOT counts further, we can add more optimization levels. We developed another algorithm, Heuristics #2 (see Supplementary Information IF), which follows most of the steps of Heuristics #1 discussed above, but differs from it in the last step. Instead of picking the emitter that leads to the fewest edges in the graph (right before the photon absorption), Heuristics #2 looks further ahead and examines CNOT counts that would be accrued in subsequent iterations of the algorithm if any of the ${\tilde{n}}_{e}$ available emitters were to be chosen to absorb the next photon. To “free up” one of them, we apply ${\tilde{n}}_{e}-1$ CNOTs between it and each of the remaining available emitters as before. Heuristics #2 continues to examine potential future steps until all qubits are disentangled or until a cutoff on the number of future steps to be examined is reached. The algorithm explores these potential next steps by repeatedly calling the same subroutine, so that options are explored recursively following all steps of the Heuristics #1 optimizer, and the additional steps of Heuristics #2. The algorithm keeps track of the number of emitter CNOTs for each potential future trajectory, and after it has explored all the possible paths made available to it, it returns to the present iteration of the algorithm and chooses as the next absorption site the emitter that it projects will lead to the fewest CNOTs overall. Note that this is not an exhaustive search since, although we open recursions, we pick emitters greedily. Moreover, we monitor the CNOT counts constantly, making informed choices about which emitter to choose at each level.

The Heuristics #2 optimizer can also be controlled by setting a cutoff on the number of emitters we consider as potential absorption sites, and we can choose when to perform a recursive search or, when to proceed with only the steps of Heuristics #1. Because we interleave recursions with Heuristics #1, we save up computational time, since for certain graphs the Heuristics #1 patterns will be identified and the optimizer will exit before searching exhaustively through the decision space. Additionally as mentioned above, we can set a “future cutoff”, i.e., monitor the CNOT counts up to a future reference point, and then return to make a decision for a previous emitter choice. This optimizer is more efficient than the Brute-force one, and it allows us to push the computation to larger-sized graphs by pruning choices in a controlled way.

To test the performance of the Heuristics #2 optimizer, we consider the same 500 random graphs that we used in Fig. 5 and inspect if the new optimization levels reduce the CNOT counts further. (Again, we test three variants of Heuristics #2 which have to do with whether we perform back-substitution globally and whether we exhaust the conditions for free photon absorption. From the three methods, we select the one that gives fewer CNOTs.) We set a future cutoff of 2 photon absorptions and constrain the available emitters we inspect as potential absorbers to at most 5. We also allow recursions to enter the new optimization steps of Heuristics #2 if no more than half of the graph has been consumed yet. We set this last condition so that we explore choices early on in the backwards generation. For n_p > 20, we further turn off the optimization part that involves a search over local gates and emitter pairs for disconnected components, because this is a more computationally intensive step, and because we already inspect emitter choices recursively. In Fig. 6a, we show the mean number of emitter CNOTs obtained by the two Heuristic methods and compare them against the Naive optimizer. Based on Fig. 6b, the Heuristics #2 optimizer gives an extra boost to the mean and maximum reduction of up to ~6% compared to Heuristics #1. It is noteworthy that despite the small cutoff on emitters we inspect per photon absorption, and the small future cutoff, we still obtain further reductions in emitter CNOTs. (Recall that the Heuristics #1 method inspects all available emitters up to n_p + n_e < 30.) In Fig. 6c, we show the number of emitter CNOTs obtained by the three methods for graphs of size n_p = 18. Compared to the Naive scheme, the Heuristics #2 method requires even ~50% fewer emitter CNOTs, and the reduction is more pronounced for graphs that scored a higher CNOT count in the Naive method.

Fig. 6: Comparison of CNOT cost between the naive and the Heuristics algorithms.

a Average number of emitter CNOTs obtained by the Naive (black), Heuristics #1 (orange), and Heuristics #2 (cyan) method as a function of n_p. We sample over the same 500 random graphs per n_p from Fig. 5. b Reduction of emitter CNOTs obtained by the two heuristics methods. With solid (dashed) lines we show the mean and max reductions obtained by the Heuristics #2 (Heuristics #1) method. c Emitter CNOTs obtained by the three optimizers for the graphs with n_p = 18.

Computational runtime

Let us briefly discuss the computational time of the different schemes we introduced. All our results were simulated with MATLAB 2021a on an 8-core Apple M1 Chip with 8 GB of RAM. In Fig. 7, we show the average runtime for extracting the CNOT counts for graphs of up to n_p = 24, and for 200 samples per n_p. The fastest method is the Naive approach (black line), which involves no substantial optimization. In particular, we obtain the generation circuit of a 100-node photonic graph state within 0.3–0.4 s on average (see Supplementary Information ID).

Fig. 7: Average runtime of Naive (black), Heuristics #1 (orange), and Heuristics #2 (cyan) optimizers for finding the generation circuit of a photonic graph of size n_p ∈ [6, 24].

We sample 200 graphs per n_p. The error bars mark the minimum and maximum computational time for each n_p.

The overhead of the Heuristics #1 method (orange line) leads to an increase in the runtime, which is still well below 1 s up to n_p = 24. The Heuristics #2 method (cyan line) is more computationally intensive but can still run fast, depending on the options we set. Here, we set a cutoff on emitters to be inspected for a given photonic absorption of up to 3, and a future cutoff of 2 photon absorptions. We also enable the optimizer to recursively call itself if we have not yet consumed more than half of the total number of photons. This method also runs approximately within the range of a few seconds for up to n_p = 24. The solid lines for the Heuristic methods correspond to no back-substitution and do not exhaust all tests for free photon absorption. The dashed lines include these extra steps. We see that, on average, including these refinements globally does not affect the runtime substantially, and this is owed to how fast the optimizer will detect a heuristic pattern and make a decision to exit before further inspection steps. Also, note that the runtime of the Heuristics #2 optimizer approximately saturates for particular ranges of n_p. This is not a coincidence, and is owed to the cutoffs we set. This is another advantage of our optimizers, because based on the optimization levels we include and the cutoffs we set, we can have very good control on the runtime. In other words, our algorithms can be made fixed-parameter tractable with respect to the number of emitters (which typically increases with increasing graph size) since the choices that arise are mainly owned to the increase in emitter resources. Additionally, we have optimized the runtime of several subroutines so that we achieve fast processing of the graphs. For example, in Supplementary Information IC we provide Algorithm 4 to perform the phase update of the rowsum faster than in ref. ⁴⁰. Throughout the search for disconnected subgraphs, we avoid performing the phase updates of stabilizers, because those are unnecessary (we only care about extracting the adjacency matrix after the gates). Once we find the successful pattern (if it exists), we then perform the phase updates to keep the entire procedure consistent. Finally, let us comment that our optimizers achieve a similar performance irrespective of how dense the graph is (see further Supplementary Information IG). It is very important to keep our optimization unbiased, and not rely on subtle metrics such as graph density, since as we will see later on, two locally equivalent graphs can differ in their edge density, but incur exactly the same entangling gate cost in their preparation.

Properties of LC graphs and summary of graph theory tools

In this section, we will inspect in detail the role of local gates in the circuit optimization. As we already mentioned, LCs on a graph translate into local Clifford gates on the respective stabilizer state. To proceed with our discussion, we will first mention useful graph theory concepts from the literature and use them to understand the structure and properties of particular LC families.

Local complementation and LC equivalence

Local complementations were initially introduced by Kotzig^55,56 and further studied later on by Bouchet^57,58,59, and Van den Nest^60,61. The LC about vertex v has the effect of inverting the edges in the neighborhood of v, denoted as N_v [see Fig. 8a]. The local operation ${U}_{v}^{\,\text{LC}\,}$ of Eq. (1) provides a one-to-one correspondence between stabilizer and graph states as long as the tableau is already in canonical form (i.e., the ${{\mathcal{S}}}_{Z}$ part is the adjacency, and the ${{\mathcal{S}}}_{X}$ part is the identity). In other words, we can write more accurately:

$$| G* v\left.\right\rangle ={U}_{v}^{\,\text{LC}\,}| G\left.\right\rangle .$$

(2)

If one performs all possible LCs on a given graph, this creates a family of graphs often termed the LC orbit. In Supplementary Information IC, we provide Algorithm 11 that creates the LC orbit of a given graph by either discarding or not the isomorphs (i.e., graphs that look the same but have different node labeling). Bouchet developed an algorithm for testing if two graphs are equivalent under any series of LCs⁵⁸. This equivalence can be tested in polynomial time by solving a linear system of equations; the complexity of this algorithm is ${\mathcal{O}}(| V(G){| }^{4})$ due to the need to perform Gaussian elimination to find a basis for the solution space.

Fig. 8: Circle graphs and local complementations.

a LC operation about v and resulting graph. b Circle graph representation of K₃. c Circle graph representation of RGS of three core nodes. d Circle graph obstructions of ref. ⁵⁹. e Probability to find a circle graph as a function of its size. We sample 5000 graphs per n.

Circle and split-free graphs

Several properties of LC graphs have been formulated from the perspective of a particular family of graphs called circle graphs. Table 2 Formally, they are defined as graphs whose nodes are represented as the chords of a circle, and whose edge set is represented as intersections of chords. Two chords intersect if there is an edge between the nodes they represent in E(G). A circle graph is also described via an alternance (or double occurrence) word, such that if (v, w) ∈ E(G), then the pattern v…w…v…w, or w…v…w…v exists in the word. For example, the path graph P₂ is represented by the word m(P₂) = v₁v₂v₁v₂. We also show the circle graph representation of the complete graph K₃ in Fig. 8b. The alternance word is formed by reading the labels on the circle clockwise. An LC about a vertex v reverses the subword between the two occurrences of v. In other words, if m(G) = AvBvC, then $m(G* v)=Av\bar{B}vC$, where $\bar{B}$ is a subword that contains the nodes of B in reverse order.

Circle graphs have been studied from both a graph theory and quantum information theory perspective^62,63,64,65. Among others^{66,67,68,69,70}, Bouchet introduced an algorithm to recognize circle graphs in polynomial time⁵⁷. For completeness, we describe this algorithm in Supplementary Information IH. Here, we give a brief overview of how the algorithm works. To understand the circle graph recognition algorithm of Bouchet, we need to first review some graph theory concepts, namely splits, and split-free graphs.

Let us begin with the definition of a split. A split in a graph is a partition of the nodes into two sets V₁, V₂ with ∣V₁∣, ∣V₂∣ ≥ 2, such that A ⊆ V₁ and B ⊆ V₂ together form a complete bipartite graph [see also Supplementary Information IH]. A split-free graph is also known as prime (note that primality can have a different definition, but we use it here to refer to graphs that have no splits). For a prime graph of order n ≥ 6 there exists a node v such that at least one out of the following graphs (known as vertex minors) is always prime⁵⁸:

$$G\backslash v,G* v\backslash v,G* vwv\backslash v,\,\,w\in {N}_{v}.$$

(3)

In other words, a prime graph necessarily contains a vertex minor which is also a prime graph^71,72. In the quantum information community, the above three graphs are known as the graphs obtained after a Z-, or Y-, or X-measurement of v. The operation corresponding to an X-measurement is not unique, which is consistent with the fact that one can choose any w ∈ N_v¹⁷. The implication of the prime reduction is that there exists a closure condition, such that the vertex minors of split-free graphs remain split-free. Splits are also invariant under LCs. These important features form the basis of recognizing circle graphs⁵⁷, or enumerating their LC orbit⁵⁸.

The circle graph recognition algorithm first tests if the graph is prime. If it is not prime, the graph is partitioned into prime components and the alternance word is built for each piece. The construction of the word uses the reduction principle of Eq. (3). In the end, the total word is formed by piecing together the smaller words. If, at any step, the alternances cannot be satisfied, then some of the reduced prime graphs is not a circle graph, and hence the input graph is also not a circle graph⁷². Bouchet also proved that non-circle graphs have as a vertex minor a graph which is isomorphic to at least one graph that belongs in a finite set of graphs⁵⁹. The members in this family of vertex minors are often referred to as obstructions. For circle graphs, these vertex minors are called circle graph obstructions⁵⁹, shown in Fig. 8d.

A unique property of circle graphs is that one can count the size of their orbit, i.e., the number of graphs, which together with G, are LC equivalent⁵⁸. Reference⁶² showed that this counting task maps to the enumeration of Euler Tours in 4-regular multigraphs, which is known to be a #P-complete problem. While a single Euler Tour can be found in poly-time (via a depth-first search), counting all of them is hard. Although the problem is, on average, #P-complete, it is possible to count the LC-orbit size efficiently for certain circle graphs. Bouchet⁵⁸ showed how to count analytically the orbit of the cycle, C_n, the path, P_n, and the 5-wheel, W₅, graph. Here, we will show how to count the orbit of complete and repeater graphs, which also belong in the family of circle graphs.

Circle graph statistics

It is interesting to study how many graphs of order n are circle graphs. For n ≤ 5, all graphs are circle graphs as the first obstruction is of order n = 6. For n = 6, all graphs are circle graphs besides those belonging to a single LC class. Although circle graphs are recognized in poly-time, it is hard to find the exact number of them for a large order n due to the exponential increase in the number of connected graphs. However, we can still sample random graphs and count how many of them are circle graphs. We generate 5000 random graphs per n, for n ∈ [7, 12], and apply Bouchet’s recognition algorithm. For every n, we count the occurrence of circle graphs, and to get the probability, we divide by the number of samples. The results are plotted in Fig. 8e. The probability of encountering a circle graph drops quickly with n. An informal reasoning as to why this is expected, is because, for n ≥ 7, the probability to encounter an obstruction becomes large. For n = 12, the probability that we find a circle graph is vanishingly small. (A proof why almost every graph is not a circle graph is as follows. Consider a labeled chord diagram, where the task is to find the number of ways we can choose to connect 2n points via chords. For the first point there are 2n − 1 options, for the next unused point 2n − 3 options, and so on. This combination yields the product of the first n odd numbers which is given by (2n)!/(2ⁿn!). Because the mapping from chord diagrams to graphs is surjective (but not injective because every non-crossing set of lines gives rise to the empty graph) the quantity (2n)!/(2ⁿn!) gives an upper bound on the number of circle graphs.)

Since most graphs are non-circle graphs, it is interesting how to formulate the problem of counting the size of their orbit and what is the complexity of this problem. To the best of our knowledge, the complexity of counting the size of, or generating the LC orbit for non-circle graphs is an open problem.

In the next section, we will study particular families of circle graphs, such as the complete, star graph, and repeater graph. These are examples of graphs that remain circle graphs irrespective of their size n, and we can find the scaling of their LC orbit analytically.

Size of LC orbit of known families of graphs

Summary of the LC orbit counting algorithm

The LC orbit counting algorithm for circle graphs was developed by Bouchet in ref. ⁵⁸ and counts the number of local complements of a graph G (including G). The size of the LC orbit includes isomorphs and has been proven to be equal to the ratio:

$$l(G):= \frac{e(G)}{k(G)},$$

(4)

where e(G) can be found by the recursive relation:

$$e(G)=\left\{\begin{array}{ll}2e(G\backslash {v}),\,{\text{if}}\,{v}\,{\text{is}}\,{\text{isolated}}\,\quad \\ e(G\backslash v)+e(G* {v}\backslash {v})+e(G* vwv\backslash {v}),\,{\text{else}}\,.\quad \end{array}\right.$$

(5)

A node is isolated if it has no incident edges. The index e(G) is recursively calculated based on this reduction formula [see relation with Eq. (3)], and it corresponds to the number of Euler Tours in 4-regular multigraphs. For ∣V∣ = 1, the index e(G) is initialized with e(G) = 2⁵⁸. Although it is not obvious a priori, the ordering of how we choose to remove nodes v does not impact the final result. The index k(G) relates to the dimension of the bineighborhood space (see also ref. ⁶²). Because the meaning of this index and how to calculate it is more involved, we provide the details in Supplementary Information IH. In our following results, we will report the value of k(G) for certain graph families and refer the reader to our proofs in Supplementary Information IH.

Complete and star graphs

Let us begin with the well-known families of complete, K_n, and star, S_n, graphs. To prove that a complete graph is a circle graph, it suffices to find a valid alternance word. It is easy to verify that the word for K_n is m(K_n) = v₁v₂…v_nv₁v₂…v_n. For example, it contains the alternance v₁v₂…v₁v₂ up to v₁…v_nv₁…v_n, and similarly, all other expected alternances exist in this word [see also Fig. 8a]. The star graph, obtained by complementing about any node of K_n, is also a circle graph. This is because circle graphs are closed under the LC operation. The LC operation on the word reverses the subword between the two occurrences of the node. If we perform the LC operation about node v₁ then we will find the word m(K_n*v₁) = m(S_n) = v₁v_nv_n−1…v₂v₁…v_n.

Now let us prove analytically the scaling of the LC orbit of K_n and S_n. In Supplementary Information IH, we show that k(K_n) = k(S_n) = 2ⁿ⁻¹. The next step is to find e(K_n) = e(S_n). We know that S_n is LC-equivalent to K_n, and it will be easier to analyze the former, as it has n − 1 leaves. Then, we can use the fact that if G and $G{\prime}$ are LC-equivalent, it holds that $e(G)=e(G{\prime} )$. If we pick a vertex v as any of the leaves of S_n [see Fig. 9a] we find based on the decomposition:

$$e({S}_{n})=2e({S}_{n}-1)+{2}^{n-1}.$$

(6)

By decomposition we mean that given G, we create the graphs G\v, G*v\v, and G*vwv\v. The last term arises due to the n − 1 isolated nodes [see Eq. (5)]. Letting T(n) = e(S_n), we have the recursion:

$$T(n)=2T(n-1)+{2}^{n-1},$$

(7)

and solving this we get [see Supplementary Information IH]:

$$T(n)=e({S}_{n})={2}^{n-1}(n+1).$$

(8)

Therefore, we see that the size of the LC orbit of the complete graph (and star graph) scales linearly:

$$l({K}_{n})=\frac{e({K}_{n})}{k({K}_{n})}=\frac{{2}^{n-1}(n+1)}{{2}^{n-1}}=n+1.$$

(9)

Fig. 9: Decompositions for counting LC orbits.

a Star graph, S_n, and its decomposition. b Repeater graph, ${K}_{n}^{n}$, and its decomposition.

Repeater graphs

To prove that the RGS is a circle graph, it suffices to construct an alternance word. Let the core nodes be labeled as v₁, …, v_n and the outer leaves as w₁, …, w_n, where we traverse clockwise first the core nodes and then the leaves. The subword of the core nodes can be constructed as v₁…v_nv₁…v_n. For each leaf w_j of core node v_j, we place one w_j before and one after the second occurrence of v_j to form $m({K}_{n}^{n})={v}_{1}\ldots {v}_{n}{w}_{1}{v}_{1}{w}_{1}\ldots {w}_{n}{v}_{n}{w}_{n}$ [see also Fig. 8c]. This word represents any RGS isomorph if we replace v_j and w_j with the actual labels 1, …, 2n.

To find the size of the LC orbit of an RGS, we use our above results for complete graphs. We denote the repeater graph of 2n nodes by ${K}_{n}^{n}$, which can be thought of as a complete graph of n core nodes to which we attach one leaf node per core node. The superscript indicates the number of leaf nodes, so that ${K}_{n}^{0}={K}_{n}$. In Fig. 9b, we show the first decomposition of ${K}_{n}^{n}$ if we remove one of its leaves. The operation *vwv is an edge pivot, which, in this case, simply exchanges the position of v and w; the removal of v leaves w isolated. Thus, if we were to continue the decomposition of this last graph shown in Fig. 9b, we would then remove w, and we would multiply $e({K}_{n-1}^{n-1})$ by 2 [see Eq. (5)]. In Supplementary Information IH, we show that $e({K}_{n}^{n})$ is given by:

$$e({K}_{n}^{x})={2}^{x}\mathop{\sum }\limits_{k=0}^{x}\left(\begin{array}{c}x\\ k\end{array}\right)e({K}_{n-k}^{0}),n-1\ge x\ge 1,n\ge 3.$$

(10)

Based on our analysis of K_n, we know that $e({K}_{n-k}^{0})={2}^{n-k-1}(n-k+1)$. Thus, solving the above sum for x = n − 1, and solving a recursion (see Supplementary Information IH), we get:

$$e({K}_{n}^{n})={6}^{n-1}(3+2n)+{2}^{n-1}.$$

(11)

At this point, we can also verify previous results. For $e({K}_{2}^{2})=e({P}_{4})$, the above expressions gives 44, and for $e({K}_{1}^{1})=e({P}_{2})=6$, which are the correct results for path graphs [see ref. ⁵⁸ for e(P_n)]. We further tested the expression numerically by recursively evaluating Eq. (5) and found that the two results agree (see Supplementary Information II).

In Supplementary Information IH we further prove that $k({K}_{n}^{n})={2}^{n}$, giving rise to the following scaling of the LC orbit:

$$l({K}_{n}^{n})=\frac{1+{3}^{n-1}(3+2n)}{2}.$$

(12)

We see that the LC orbit of the RGS scales exponentially, in contrast to the linear scaling of K_n. The reason for this exponential scaling is because the 4-regular multigraphs of the RGS are highly symmetric and lead to an exponential number of Euler Tours (see Supplementary Information II).

Although the scaling is exponential, if we generate the orbits of small-sized RGSs, we will notice that they contain a large number of isomorphs. If we can generate the non-isomorphic LC orbit, then it would be easier to analyze the graphs within the orbit and find their preparation cost. One pattern of consecutive LCs that we found can generate the unique non-isomorphic graphs of RGSs is:

$$\begin{array}{l}\{{{\emptyset}}\}\cup \{{v}_{1}\}\cup \{{v}_{2}\}\cup \{{v}_{n+1}\}\cup \{{v}_{3}\}\cup \{{v}_{4}\}\cup \{{v}_{n+3}\}\cup \ldots \\ \cup \{{v}_{n-2}\}\cup \{{v}_{n-1}\}\cup \{{v}_{2n}\},\end{array}$$

(13)

where v₁, …, v_n are core nodes, and v_n+1, …, v_2n are leaf nodes, and we terminate at a core node for odd n ≥ 3 or at a leaf node for even n ≥ 4, without repeating indices. To give an example, let us consider the ${K}_{3}^{3}$ graph, with (v₁, v₂, v₃) = (1, 2, 3), and (v₄, v₅, v₆) = (4, 5, 6). The LC operations we apply based on the above formula are:

• ${K}_{3}^{3}* {{\emptyset}}$

• ${K}_{3}^{3}* 1$

• ${K}_{3}^{3}* 1* 2$

• ${K}_{3}^{3}* 1* 2* 4$

• ${K}_{3}^{3}* 1* 2* 4* 3$.

Following this pattern, we generate an orbit of linear size. We provide Algorithm 5 in Supplementary Information IC, which prepares the non-isomorphic orbit for any RGS size. We also verified with brute-force generation of the entire orbit (that includes isomorphs) and then removal of the isomorphic graphs that we obtain the same graphs as in the case of using the above pattern. By numerical inspection (We tested repeater graphs up to n = 40. We point out that this is a conjecture, since we only have numerical verification and no analytical proof.), we find that the size of the non-isomorphic LC orbit of ${K}_{n}^{n}$ scales as:

$${l}^{{\rm{non}}\text{-}{\rm{iso}}}({K}_{n}^{n})=\frac{(3(2n+1)-{(-1)}^{n+1})}{4},$$

(14)

which is the sequence of numbers non-divisible by 3, known as A001651 (https://oeis.org/A001651). In our case, we shift this sequence because we start from n = 3. More surprisingly, the size of the RGS orbit when we exclude isomorphs is independent of the number of leaves per core qubit, and a very similar pattern can be used to generate the orbit of an RGS with multiple leaves per core node. In Supplementary Information IC, we also provide Algorithm 6, which generates the LC orbit of an RGS with multiple leaves. Of course, if we were to perform the enumeration of the orbit that includes the isomorphs, we would find an even bigger scaling than in Eq. (12), because we would have to do more reductions compared to the RGS with a single leaf per core qubit. It is interesting that this structure of adding more leaves per core qubit does not at all affect the pattern we can use to generate the non-isomorphic orbit, and generalizations of this feature could be used as a guide to create more easily the non-isomorphic orbits of graphs with multiple leaves.

Optimal resources for unencoded and encoded repeater graphs

In this section, we focus on the preparation of repeater states and study the relation between emitter and CNOT resources. We begin by finding the number of emitters needed to prepare an unencoded RGS of n core qubits. In Fig. 10a, we show a histogram of emitter resources, for any emission ordering, and up to ${K}_{5}^{5}$. The upper bound of emitters we need to prepare an RGS equals n. This is expected because, in the worst-case scenario, we prepare K_n on n_e = n emitters, and then we perform two rounds of emissions before finally measuring the emitters. The first emission round creates the core photons, and the second one creates the leaf photons. For this case of maximal number of emitters used, we obtain easily the optimal number of emitter CNOTs. To create a complete graph on n_e = n emitters, we need a minimum of n_e − 1 emitter CNOTs. The emission rounds can be performed without intermediate emitter CNOTs (see generation circuit in Supplementary Information IJ). If we view this generation circuit backwards, all emitter CNOTs are performed in the final disentanglement step, which requires at least ${\tilde{n}}_{e}-1$ emitter CNOTs, where ${\tilde{n}}_{e}$ is the number of emitters that are still entangled with each other right after all photons have been absorbed. In Supplementary Information IC, we provide Algorithm 7 which performs the last disentanglement step.

Fig. 10: Emitter and CNOT resources for preparing unencoded repeater graphs.

a Histogram of emitter resources for preparing ${K}_{3}^{3}$ (blue), ${K}_{4}^{4}$ (pink) and ${K}_{5}^{5}$ (yellow). The probability is calculated across all isomorphs. b Emitter and CNOT counts versus emission ordering for ${K}_{3}^{3}$. c Same as in b, for ${K}_{4}^{4}$. The CNOT counts were obtained via the Heuristic #1 optimizer.

In Figs. 10b, c, we plot the emitter versus CNOT counts across any isomorph of ${K}_{3}^{3}$ and ${K}_{4}^{4}$. For illustration purposes, we sort the data in terms of increasing emitter resources. We obtain the CNOT counts using Heuristics #1 optimizer, for which we set the following options: (i) we do not enable global back-substitution, and (ii) we enable the extra test for free photon absorption. We find that for both ${K}_{3}^{3}$ and ${K}_{4}^{4}$ the optimal number of CNOTs is fixed across isomorphs that require the same number of emitters. This is non-trivial, because among the isomorphs that require the same number of emitters we find non-LC equivalent graphs, but they yield the same number of CNOTs. It is also remarkable that our least expensive optimizer can minimize globally the CNOT cost of RGSs for any emission ordering.

Of particular interest is the optimal scaling of emitter CNOTs for the ordering that requires only two emitters, irrespective of the size of the RGS. Reference³⁹ refers to the optimal ordering as the natural emission ordering. In Supplementary Information IC, we provide Algorithm 8, which generates an alternative optimal emission ordering by exchanging the labeling of two nodes, and again requires two emitters. Figure 11 shows the emitter CNOTs if we use the ordering of Algorithm 8, for RGSs of size n ∈ [3, 200]. We note that the optimal number of emitter CNOTs scales linearly with the number of core qubits and is given by n − 2. (We arrive at the same result if we use instead the natural emission ordering.) This linear scaling has also been mentioned in ref. ⁴⁴, with the difference that there the authors claim that particular graph structures in the LC orbit of the RGS achieve this optimal scaling. The authors perform a search over labelings and LC orbits to identify the optimal graph. They propose two different structures from the LC orbit of the optimally labeled RGS, depending on whether the number of core qubits is even or odd. Based on their optimization, they can analyze RGSs of up to 55 photons in total, where for an RGS of 55 photons, their random search algorithm takes 100 s, and an informed method based on edge minimization takes about 1 s. In our case, we do not even need to search the labeling of the repeater graphs or their LC orbits because we know the optimal emission ordering. Notably, we can find the optimal emitter CNOT counts for RGSs of up to 400 photons within ~50 s in total (with parallel processing), using our least expensive optimizer, Heuristics #1. In Fig. 11c, we plot the emitter CNOTs as a function of core and leaf nodes of an RGS, where each core node has more than one leaf. In Supplementary Information IC, we provide Algorithm 9 which generates the optimal emission ordering for any RGS size with multiple leaves. We see that the number of leaves does not affect the CNOT counts. Using our Heuristics #1 optimizer, we find the same n − 2 scaling, within 127 s of processing all 532 repeater graphs with n ∈ [3, 30] and number of leaves within [2, 20]. In Supplementary Information IK, we provide the circuits to generate an RGS of any number of leaves and core nodes.

Fig. 11: Optimal CNOT counts for preparing repeater graph states.

a Optimal number of emitter CNOTs for each size of ${K}_{n}^{n}$, given the optimal emission ordering. The orange line is obtained from Heuristics #1. The dashed line is y = n − 2. T ≈ 50 s is the total computational time to process all RGSs up to n = 200. b Repeater graph of 100 core qubits. c Emitter CNOTs as a function core qubits and leaves per core qubit of the RGS. d Repeater graph with 30 core qubits and 20 leaves per core qubit. e Number of emitter CNOTs for encoded RGS with branching parameter b₀ = 2 and b₁ = 4 (b₁ is the number of leaves per core qubit). f Encoded RGS with n = 6, b₀ = 2, and b₁ = 4. All nodes correspond to photons. The purple nodes indicate the nodes for the b₀ = 2 branching parameter. T is the total computational time.

Although we showed how to prepare repeater graphs optimally, in order for these states to be useful for quantum communications they need to be encoded. One possible encoding is to replace each core qubit by a tree¹. As an example, we consider a tree with branching parameters b₀ = 2 and b₁ = l. The b₁ nodes are the leaves of the RGS. The task of finding the optimal ordering is once again straightforward for encoded RGSs. In Supplementary Information IC, we provide Algorithm 10, which generates the adjacency matrix with emission ordering that requires two emitters, for any encoded RGS with an even number n ≥ 4 of core qubits, to each of which we attach b₁ = l leaves. Each pair of core qubits corresponds to the b₀ = 2 nodes, and they connect with the top node of a tree. We display an example for n = 6, l = 4 in Fig. 11f. We further show the optimal CNOT counts in Fig. 11e, which we obtain using Heuristics #2 algorithm (we set a future cutoff of 2 steps, and do not enable further recursions). We find that similar to the unencoded case, the encoded RGS can be prepared with n − 2 emitter CNOTs, irrespective of the number of leaf qubits per core qubit.

Study of LC orbits

We now turn our attention to the study of LC orbits of various graphs. We will show how to achieve the same optimal CNOT cost across the orbit using our optimizers.

LC orbits of RGSs

Let us begin with the LC orbits of RGSs. We assume the optimal emission ordering of Algorithm 8, which requires two emitters to prepare an RGS of any size. We also make use of Algorithm 5 to generate only the non-isomorphic RGS orbit (see Supplementary Information II for examples of the LC orbit). Although we focus only on the non-isomorphs, our following results hold for the entire LC orbit.

In Fig. 12, we show the optimal number of emitter CNOTs for preparing any graph LC equivalent to an RGS consisting of 50 or 100 core qubits. To find the optimal number of emitter CNOTs, we use the Heuristics #1 algorithm. We see that the cost in emitter CNOTs is the same across the entire non-isomorphic LC orbit and equal to n − 2. This feature is consistent with the fact that LC graphs have the same entanglement structure (only the connectivity varies), so an algorithm should be capable of finding the same entangling cost.

Fig. 12: Minimizing the number of emitter CNOTs across the LC orbits of repeater graph states.

Number of emitter CNOTs for the LC orbit of ${K}_{50}^{50}$ (a), and ${K}_{100}^{100}$ (b), using the Heuristics #1 optimizer and the optimal emission ordering. T is the total computational time to extract the number of emitter CNOTs (using parallel processing).

LC orbits of random graphs

We now focus on the optimal preparation of LC orbits of random graphs. For generic graphs, there is no efficient algorithm for generating the LC orbit. We provide the generic Algorithm 11 of preparing the LC orbit of any graph in Supplementary Information IC, which has the option to keep or discard isomorphic graphs. In the following analysis, we choose to keep the isomorphs. Since the task of generating the LC orbit becomes difficult as the size of the graph increases, we focus on examples of graphs with n_p≤ 9.

In Fig. 13, we display our results for a random graph of 7 photons (a), 9 photons (b), and 8 photons (c). The top panels display one graph representative of the respective orbits. The second panel in (a) shows the number of emitter CNOTs across the entire orbit, if we use the Heuristics #1 or Heuristics #2 methods. For the Heuristics #2 method, we set an emitter cutoff of up to 4, and a future cutoff of up to 4 steps. The third panel in (a) shows the emitter CNOTs we obtained if we do not allow any LCs and if we also prune the total cases we inspect per recursion level. In the bottom panel, we focus on the graphs for which we did not reach the minimum of 4 CNOTs without any LCs for any of the optimizers, and this time we apply the Brute-force method and allow one round of LCs and no pruning of the realizations. We see that we are now able to reach the minimum CNOT count of 4 even for these outliers. Thus, utilizing all our algorithms, we can find the minimum emitter CNOTs across all LC graphs. In Fig. 13b we repeat the same calculation for the LC orbit of a graph consisting of n_p = 9 photons, which is prepared by 4 emitters. In this case, we see that the Heuristics #2 method can find the minimum number of emitter CNOTs across the entire orbit. A similar result is shown for another example in Fig. 13c, which shows that Heuristics #2 is again able to find the minimum emitter CNOT count across the entire LC orbit of a graph of n_p = 8 photons. Thus, we see that with low computational resources, we can verify that any graph in the orbit of a given graph is prepared with the same entanglement cost.

Fig. 13: Minimizing the emitter CNOTs across LC orbits of random graphs.

a Top: Graph representative of LC orbit consisting of n_p = 7 photons. Middle: Emitter CNOTs across the orbit obtained by the Heuristics #1 (red), Heuristics #2 (cyan), or Brute-force method, w/o allowing LC rounds, (yellow). Bottom: Number of emitter CNOTs obtained by the Brute-force method if we allow 1 LC round, for the graphs for which we did not achieve the minimum CNOT count w/o the LC round for any of the optimizers. b Top: Graph representative of LC orbit of n_p = 9 photons. Middle: Emitter CNOTs across the orbit obtained by the Heuristisc #1 (red), Heuristics #2 (cyan) methods. Bottom: Emitter CNOTs across the orbit obtained by the Brute-force method w/o allowing LCs. c Same as in (b), but for an n_p = 8 random graph that requires only n_e = 3 emitters to produce.

Order 6 orbits and conjecture for all LC graphs

Here we study the optimal preparation of graphs of n_p = 6 photons. To do that, we start by generating all possible adjacency matrices, which amounts to 26,704 connected graphs, including isomorphs. (Note that if we discard isomorphs, we end up with 112 non-isomorphic connected graphs, consistent with ref. ²⁰.) We then implement Bouchet’s LC recognition algorithm⁵⁸ to find all the non-LC equivalent graphs that give rise to 312 LC families. Some of these 312 representatives could be isomorphic to each other (but not LC-equivalent), but we do not discard them. The reason why we include isomorphs is because different node labelings lead to different emitter requirements. Once we have a representative for each LC family, we generate the non-isomorphic LC graphs of the representative using Algorithm 11. Note that discarding isomorphs at this step keeps our family-sorting method consistent because the family representative and the collection of graphs LC equivalent to it all require the same number of emitters to be prepared. Thus, we can safely discard isomorphs from within an LC orbit, although we should keep in mind that the circuits to prepare two isomorphic LC graphs will be different.

To find the optimal CNOT cost for every graph within an LC family, we utilize the different optimizers we developed. We test if the Naive, Heuristics, or Brute-force methods achieve the optimal number of emitter CNOTs. If any of those methods does not minimize the emitter CNOT cost across the entire orbit, we add new layers of optimization. This means that we can follow a different optimizer or change the optimization levels it includes. For instance, in the Brute-force optimizer, we can choose to prune or not realizations, and to allow one or more LC rounds. Once we find that the optimizer resolves the ambiguity and gives rise to the same lower bound on emitter CNOTs within the LC family, we terminate the search.

In Fig. 14, we display the number of emitter CNOTs as a function of the LC graph index, starting from family #209 and up to family #312. The results for the remaining families and the graph representatives of each orbit are in Supplementary Information IL. The different colors correspond to the optimizer that gave the minimum number of CNOT counts. The black bars correspond to the Naive method, the orange (cyan) bars to the Heuristics #1 (#2) method, and the yellow bars to the Brute-force method.

Fig. 14: Optimal emitter CNOTs for a subset of the LC families of order 6 graphs.

Each panel shows the corresponding LC family index out of 312 families and the number of emitter CNOTs across the non-isomorphic LC graphs of the family. The colors show the optimizer that was used. Black: Naive, red: Heuristics #1, cyan: Heuristics #2, yellow: Brute-force.

The optimization for all LC families of order 6 shows that it is possible to achieve globally optimal CNOT counts for any graph within the same LC orbit. Based on our results, we see that no graph from within the same orbit is prepared with fewer CNOT requirements. Since it holds that LC equivalent graphs have the same entanglement structure but different connectivity, it is intuitive that the entangling gate cost will be the same. We conjecture that this holds for any LC family of arbitrary-sized graphs. Although this may seem obvious, we need to clarify the optimization procedure we follow and what it entails. In contrast to ref. ⁴⁴, we do not enable LCs upfront in the backward generation. In other words, we optimize every single graph from within an LC orbit, given its tableau representation as an input. In ref. ⁴⁴, the authors sample the LC orbit of a graph, and then they provide each LC graph as an input in the algorithm of ref. ³⁹, which does not explore all degrees of freedom in the optimization procedure. Consequently, they conclude that some graphs in the orbit can require fewer entangling gates to generate compared to others. This graph is then prepared optimally, and one can apply local gates at the final step of the Clifford circuit to prepare any graph LC equivalent to that, with the same number of entangling gates. Our optimization procedure reveals an even more surprising result. Even though we do not allow LC operations in the final step of the Clifford circuit, we can still resolve the freedom in the remaining part of the Clifford circuit and achieve the same optimal CNOT counts across an entire LC orbit.

Discussion

The efficient generation of photonic graph states is important for future quantum networks and quantum communication applications. We developed algorithms that minimize the number of CNOTs required to prepare these entangled states, revealing a reduction of up to 75% in emitter CNOTs. Our Heuristics algorithms make a strong connection between the graph representation and stabilizer circuits and exploit graph modifications in the construction of the graph that relate to the optimal optimization paths. We also study repeater graph states and find the size of their LC orbit analytically, although this is a #P complete problem for arbitrary graphs. We further find an efficient way to generate the LC orbit of repeater graph states irrespective of their size or photonic emission ordering and show that by discarding isomorphic graphs, the size of the LC orbit scales linearly with the size of the state. We find the optimal photonic emission ordering for unencoded and encoded repeater graph states that gives rise to minimal numbers of emitters and minimal numbers of emitter CNOTs. We also address the problem of preparing LC graphs and show how to minimize the CNOT cost across the entire LC orbit by resolving the freedom over local gates at intermediate steps of the Clifford circuit.

Our work addresses the problem of synethesizing Clifford circuits for emitter-based photonic graph state generation with minimal resources. We show how decisions during the generation impact the total number of emitter CNOTs, and under which cases we can follow nearly optimal optimization paths, especially related to photonic absorption decisions. An aspect we have not explored thoroughly is how to minimize globally the number of emitter CNOTs in the final disentanglement step (i.e., after all photons have been absorbed). If no restriction on the emitters’ connectivity is imposed, then one could explore various elimination orderings or identify node separators such that the disentanglement is achieved with fewer steps. This can bring further reduction in the emitter CNOT counts. A different direction would be to implement the parallel elimination algorithm of ref. ⁴¹, which is developed for unrestricted connectivity, and in our case, would achieve a worst-case scaling of ${\mathcal{O}}({(n{\prime} )}^{2}/{\log }_{2}(n{\prime} ))$ final emitter CNOTs ($n{\prime}$ is the number of emitters that are still entangled at the last algorithmic step, where $n{\prime} \le {n}_{e}$). Another direction would be to sample from the LC orbit of the graph on the $n{\prime}$ emitters and identify the one with the minimal number of edges, such that an unrestricted elimination with fewer CNOTs is followed subsequently. Lastly, one could initially perform the emitter disentanglement we follow in this work and then apply circuit identities to potentially reduce the number of emitter CNOTs^73,74,75,76.

Our algorithms can also serve as a guide for inspecting the preparation cost of resource states in the context of photonic quantum computing (QC) and comparing that to the preparation cost of an all-photonic approach. This could open up the path to understanding the complexity of preparing arbitrary resource states and inspecting the viability of emitter-based architectures for photonic QC.