Non-stabilizerness and entanglement from cat-state injection

Recently, cat states have been used to heuristically improve the runtime of a classical simulator of quantum circuits based on the diagrammatic ZX-calculus. Here we investigate the use of cat-state injection within the quantum circuit model. We explore a family of cat states, catm∗ , and describe circuit gadgets using them to concurrently inject non-stabilizerness (also known as magic) and entanglement into any quantum circuit. We provide numerical evidence that cat-state injection does not lead to speed-up in classical simulation. On the other hand, we show that our gadgets can be used to widen the scope of compelling applications of cat states. Specifically, we show how to leverage them to achieve savings in the number of injected qubits, and also to induce scrambling dynamics in otherwise non-entangling Clifford circuits in a controlled manner.


I. INTRODUCTION
It is often the case that, in order to precisely capture the physics behind quantum information tasks or quantum computation protocols, one must treat the same phenomena through various lenses.To consider a concrete example, Shor's algorithm might seem simple, but it is only once we understand the physics behind it in terms of computational complexity [1], nonclassical resources [2], and hardware implementation [3,4], among others, that we can properly glimpse the enormous challenges behind implementing this algorithm.This plurality of techniques and their benefits push different communities to be in constant contact and discussion.
A powerful outcome of such a collaborative effort between quantum information scientists, category theory mathematicians, and computer scientists was the development of ZX-calculus, a formal diagrammatic calculus for quantum theory [5][6][7].This diagrammatic treatment is now being applied in various research fields such as quantum error correction [8,9] and classical simulation of quantum computation [10][11][12].Moreover, research into the latter field has also seen extensive progress in the last years [11,[13][14][15][16]].As a striking example of the importance of bridging the research of different communities, in Ref. [11], Kissinger et.al showed how the so-called cat states, introduced as a tool in [16], can be extremely powerful devices for improving the runtime of classical simulation of quantum circuits within the diagrammatic ZX-calculus.
In our work, motivated by this recent application of cat states, we choose these states as our case study to analyze improvements within three different topics of research.To that end, first, we define a family of cat states that we characterize in terms of non-stabilizerness (commonly referred to as magic) and entanglement.These cat states are closely related to a family of magic states investigated in [17] for their relationship to catalysis and their provably optimal synthesis over the ⟨CX, T ⟩ gate set.Next, we describe a family of quantum circuit gadgets that fault-tolerantly inject non-stabilizer and entangling unitaries into quantum circuits, via these resource states.This family of gadgets allows us to highlight interesting applications of cat states.Specifically, we analyze (i) the power of cat-state injection for classical simulation of quantum computation within the quantum circuit model framework; (ii) the possible reductions in the quantum resources needed for certain quantum computations; and (iii) how the injected unitaries introduce complexity to the task of classically simulating quantum dynamics.For the latter application, we use a simple test-bed for hardness of simulation that is the evidence of scrambling of quantum information in hard-to-simulate quantum circuits.
The structure of our work is as follows.In Sec.II, we introduce the basics of gadgets in quantum circuits, present an overview of classical simulation, revisit various aspects of the quantum resources we will study in cat states, and review the essentials of doped quantum circuits and scrambling of information.In Sec.III, we present our results.We explore and characterize a family of cat states, construct gadgets that inject magic and entangling unitaries into any quantum circuit provided we have access to such states, and discuss the three aforementioned applications of these gadgets.Finally, we provide some concluding remarks in Sec.IV.

II. BACKGROUND A. Fault-tolerant quantum computation and circuit gadgets
The thirst for fault-tolerant quantum computing has driven a lot of research into error-correcting codes wherein redundancy is used to reduce or eliminate the arXiv:2305.19988v2[quant-ph] 1 Sep 2023 nefarious effect of noise.More specifically, these errorcorrecting codes work by encoding logical qubits into several physical qubits.After that, the computation is driven by operations, such as gates and measurements, applied to the encoded qubits.The simplest way of acting with a gate G on an encoded qubit q L would be to simply act with that same gate independently on each of the physical qubits of q L .In a given code, gates that admit such an implementation are said to be transversal [18].Unfortunately, it has been shown that no useful error-correcting code admits a universal set of transversal gates [19].
Stabilizer codes are a particular type of errorcorrecting code wherein the encoding and decoding can be accomplished using circuits with Clifford gates only.Moreover, whilst Clifford gates admit transversal implementations, any non-Clifford gate, required to unlock universality [20], will be non-transversal.For this reason, Clifford gates are commonly regarded as free operationsin the sense that they can be implemented easily/cheaply -whereas any non-Clifford gate is hard/expensive to implement.
The magic-state injection model of quantum computation, proposed by Bravyi and Kitaev in 2005 [21], addresses the aforementioned difficulties.In their seminal work, the authors describe a 15-to-1 magic-state distillation protocol wherein a single, low-noise copy of the non-stabilizer resource state |T ⟩ := |0⟩ + e iπ/4 |1⟩ / √ 2 can be extracted from 15 noisier copies of the same state, via the application of only (cheap) Clifford gates.The distilled resource state can then be used to implement the non-Clifford T gate, T := diag 1, e iπ/4 , using only Clifford unitaries and classical feedforward.Thus, in this model, quantum computations are carried out by adaptive Clifford circuits with magic-state qubits obtained via a magic-state distillation protocol.
The adaptive stabilizer circuit constructions used to (fault-tolerantly) implement non-stabilizer gates via the injection of magic resource states are known as gadgets.Besides the paradigmatic example of the T gate discussed above, there are several other well-known gadgets implementing gates such as the Toffoli gate, the controlled-S gate, and gates in higher levels of the Clifford hierarchy [22].In complete generality, the existence of gadgets for elements in the third level of the Clifford hierarchy is guaranteed by the following theorem.
Theorem 1 (Adapted from [22]).Let U be an n-qubit gate in the third level of the Clifford hierarchy.Then, the state |ψ⟩ = U |0⟩ ⊗n can be prepared fault-tolerantly by using only (possibly adaptive) gates and measurements in the second level of the Clifford hierarchy.
In our work, we will analyze a family of magic and entangled states that we obtain from the original cat states defined in [16], and which we call here star cat states.In particular, we describe the corresponding non-stabilizer and entangling unitaries that can be injected into Clifford circuits if we have access to a cat state factory and explicitly describe the gadgets that can be used to perform the injection.We call these cat gadgets.As we will show later, Theorem 1 theoretically guarantees that cat gadgets exist and can be implemented in a fault-tolerant manner.

B. Classical simulation of quantum computation
In parallel to the research into fault tolerance, the field of classical simulation of quantum circuits has also seen significant research over the past two decades.This is because improving classical simulators allows us to effectively probe the threshold between classical and quantum computation, i.e., to establish which quantum circuits effectively bring forth quantum computational advantage.Moreover, classical simulation aids in the development of hardware and software (e.g.error-correcting codes) and gives insights into new, quantum-inspired classical algorithms.
Since non-stabilizer operations upgrade Clifford circuits into universal quantum computation, the amount of magic in a quantum circuit -usually quantified via magic measures or magic monotones (cf.Sec.II C) -provides a way of quantifying the hardness of classical simulation.A thorough description of the connection between different magic monotones and the cost of classical simulation is provided in [23].Here, we refrain from going into such extensive technical details and instead focus only on the results of immediate relevance to our work.
Recent work in stabilizer-rank simulators has given rise to classical simulation algorithms that scale polynomially with the number n of qubits in the quantum circuit, but exponentially with the number t of non-Clifford gates.As explained above, a unitary circuit with t non-Clifford gates can be transformed into an adaptive Clifford circuit with a given input magic state, |Ψ R ⟩.For instance, in the case where all non-Clifford gates are T := diag(1, e iπ/4 ) gates, the input resource state is simply the tensor product of t copies of the single-qubit magic state ⊗t .Such a state can be decomposed as: where c i are complex coefficients and the sum extends over r t-qubit stabilizer states |ϕ i ⟩ .
Having decomposed the input resource state into a linear combination of stabilizer states, it is possible to efficiently compute the output state of each of the r adaptive Clifford circuits [13].Weighting each of these states by the proper coefficient allows us to reconstruct the output state of the computation and compute the expectation value ⟨O⟩ of any observable O of interest.
The runtime of these stabilizer-rank simulators scales with O r 2 [13] such that their inefficiency is actually hidden in r, which scales exponentially with the number of non-Clifford gates in the quantum circuit.Therefore, finding decompositions of the form of Eq. ( 1) with minimal r has a direct impact on the simulation cost.The stabilizer rank, χ (|Ψ R ⟩), of a given non-stabilizer state |Ψ R ⟩, is a magic monotone defined as the minimum value of r.Therefore, the best runtime of stabilizer-rank simulators is given by O χ (|Ψ R ⟩) 2 , for a quantum circuit with input state |Ψ R ⟩.
Observing that a single copy of the state |T ⟩ has stabilizer rank χ (|T ⟩) = 2, and because the stabilizer rank is submultiplicative, i.e., χ , one arrives at the conclusion that the runtime of these algorithms is (at most) O (2 t ) .Fortunately, it is possible to do better.In particular, Qassim et al. [16] show that χ |T ⟩ ⊗6 = 6, so that using such decomposition yields a scaling O 6 t/6 = O (2 αt ) , with α = log 2 (6)/6 ≈ 0.4308.In fact, the best currently known value for this coefficient is α = 0.3963 obtained asymptotically in Ref. [16] and via a partial decomposition provided in Ref. [11].

Cat states and improved classical simulation costs
To obtain the best upper bound for the cost of classical simulation known to date when using a stabilizer-rank approach, Ref. [16] resorted to a family of magic states called cat states and defined as where T ⊥ denotes the state orthogonal to |T ⟩.Besides being non-stabilizer states, it is clear that these cat states are also entangled.Qassim et al. [16] noted that these states are low-rank magic states such that: Using this result, they searched for decompositions of |cat m ⟩ (rather than |T ⟩ ⊗m ) with larger m than is feasible for tensor products of |T ⟩ .Finding the decompositions of these cat states then allowed them to set better upper bounds for χ |T ⟩ ⊗m .
Building upon these observations, Ref. [11] proposed a heuristic approach for improving the runtime of classical simulation using ZX-calculus.(For a brief description of the ZX-calculus framework see Appendix A. We recommend Ref. [6] for a more in-depth discussion.)Essentially, their proposal works as follows: (a) Take the quantum circuit that we want to simulate; (b) Transform it, using ZX simplification rules, into a graph-like ZX-diagram (see Appendix A or Ref. [6]); (c) Simplify the diagram as much as possible; (d) Search the diagram for cat-state-like sub-diagrams and use the low-rank stabilizer decompositions of such states to break the large diagram into a (small) number of other diagrams; (e) Return to step (c) and carry out this procedure iteratively until all diagrams have been reduced to constants that can be used to compute the desired expectation value.
By searching first for structures that can be associated with cat states, the procedure ensures that the multiplicity of diagrams increases more slowly than it would if we were to consider the best decomposition of |T ⟩ ⊗m states.Because this procedure is heuristic, the promised asymptotic scaling is still the same, i.e.O 2 0.3963t , however, in practice, the whole simulation is much faster, and quantum circuits that were previously out of reach for other classical simulators are simulable using this technique [11,12].
Here, we point out that this procedure enables fast classical simulation at the cost of moving away from the circuit model, which is a natural and familiar representation of quantum computations.Because of that, we lose some insight into which features of the original circuit are allowing the simulation speed-up.

C. Resource theory of magic
As explained in the previous section, magic is often used to quantify the cost of classical simulation of quantum dynamics, introducing an exponential overhead.We can treat magic formally as a resource using the resource theory of magic.In a quantum resource theory [24], one describes sets of free states and free quantum channels and attempts to quantify the amount of a given resource using the so-called monotones, i.e., quantities that can only monotonically decrease upon application of free operations.
The resource theory of magic considers states that can be prepared by Clifford circuits as free objects, and any Clifford operation as a free channel.In such a way, one can define various monotones, i.e., functions of the form M : F → [0, 1] such that M (C(ρ)) ≤ M (ρ) for C some Clifford unitary.A first example is that of the stabilizer rank χ, defined in the previous subsection.Another one is the robustness of magic (RoM), denoted as R. Letting S n := {|ϕ i ⟩} i be the set of n-qubit pure stabilizer states, we have that [25] R(ρ) := min In Ref. [25], the authors make a comprehensive study of how this monotone can be used in many different ways, including (i) characterizing the cost of classical simulation using a quasi-probability approach, (ii) bounding the Their results are summarized in Table I.We use |Φ max ⟩ to denote the maximally robust state of 2 qubits which has R (|Φ max ⟩) = √ 5 (cf.[25] for details on the state), while |CS⟩ is the maximally robust 2-qubit state with all equal weights.
The Hoggar state is the 3-qubit state with maximum robustness [25].Independently of the ensuing discussion and work, it is worth noting that while this observation makes this state special in a sense, to the best of our knowledge, a simple gadget that fault-tolerantly injects the corresponding unitary U Hog. (generating this state from the state |0⟩ ⊗3 ) into a quantum circuit is unknown.This may stem from the fact that U Hog. is not in the third level of the Clifford hierarchy, so that Theorem 1 does not apply.

D. Resource theory of entanglement
In contrast to the relatively recent resource theory of magic discussed above, the resource theory of entanglement has its roots in the early development of quantum information, with many important contributions over a long period [26][27][28][29][30].This resource theory can be analyzed from two main perspectives: a dynamical one, where we consider the entanglement properties of quantum channels and unitary gates [31][32][33], or a statical one, where the entanglement present in bipartite or, more broadly, multipartite quantum states is the focus of examination [24,27,34].
In the static formalism, the resource theory considers the free states to be all separable states, and the free operations to be either (i) resource non-generating, in which case they are termed separability-preserving or non-entangling operations [35], (ii) local operations with classical communication (LOCC) [36], or (iii) local operations with shared randomness (LOSR) [37].Ref. [38] prescribed minimal requirements for entanglement monotones.The theory for such monotones is extremely rich, and still under development, especially for the case of multipartite entanglement.
We will be interested in multipartite entanglement quantification.This kind of entanglement becomes intrinsically complicated to quantify in a consistent manner due to the exponentially increasing number of nonequivalent entanglement classes under LOCC.It is common that, for studying multipartite entanglement, one often wants ways to distinguish between degrees of entanglement, such as bipartite versus tripartite entanglement, etc.In the case of the present work, we are solely interested in showing that we have some degree of entanglement in a state and that this resource is injected into a circuit, generating entangling unitaries.For that, we will use the quantifier of multipartite entanglement introduced by Meyer and Wallach [39,40] that is simple to calculate and interpret.Denoting D(H) as the set of all quantum states acting over space H, this monotone has the nice feature of being easy to compute for a given where ρ k describes the state of a subsystem, given by ρ k = Tr \H k (|ψ⟩⟨ψ|), that is, the partial trace of |ψ⟩ with respect to all subsystems but H k .

E. Doping random quantum circuits with magical resources
Distinct quantum computing implementations have different limitations on the set of gates that can be natively applied.For instance, computers based on dualrail encoding using linear-optical components easily implement any single-qubit unitary, while entangling operations are fairly costly due to the probabilistic nature of Bell measurements [41][42][43].Other physical platforms have non-Clifford operations as the decisive factor in increasing the simulation overhead.
Universal random quantum circuits have properties that are provably hard to simulate classically; specifically, they are known to be chaotic and one cannot avoid an overhead that is exponential in the Tcount [13,23,25,44] (recall Sec.II B).The complexity gap between the efficient classical simulation of Clifford unitary circuits, and that of generic unitaries suggests it may be instructive to study the controlled introduction of non-Clifford gates into structured circuits.To that end, a framework known as doped random circuits proved to be useful in gradually obtaining unitary designs via magic doping [45,46], and in capturing the role of magic in quantum chaos [44,[47][48][49][50][51] and many-body entanglement spectrum statistics [52,53].
So far, the literature on doped circuits has focused mainly on one model of hardness of computation based on magic.Here we consider a more general approach to doped quantum circuits, as captured by Fig. 1.We consider doping a circuit with resourceful dynamics inbetween blocks of free gates.The procedure of applying (randomly in a circuit) resourceful gates in-between free circuits may involve multiple slices of the construction depicted in Fig. 1.
This more general view of doped circuits allows us to consider paradigms other than the injection of magic since, broadly speaking, other gates might be considered resourceful in different settings.An interesting example is classical simulation using a Feynman-path approach [54], in which only gates that do not preserve the computational basis incur in an exponential overhead to the cost of simulation.In linear optical quantum computation, separable (qudit) gates are considered free, and we may dope the system with resourceful entangling gates, such as the cnot gate.
The most studied doped random circuits are constituted by single-qubit non-Clifford gates (e.g.T gates or T † gates) evolved adjointly by Clifford unitaries [44].In our work, we will consider the generic case of doping nonstabilizer and entangling unitaries into non-entangling Clifford circuits.This is natural for the analysis of cat states that, besides being magical, are also multipartite entangled (cf.Sec.II B).Generic blocks of free circuits, e.g.Clifford circuits or separable qubit operations, receive controlled doses of resourceful gates, e.g.magic gates in Clifford+T architectures, entangling gates in photonics, or Hadamard gates in the Feynmanpath approach to classical simulation of quantum computation.
We shall see that both non-stabilizerness and entanglement contribute to the simulation complexity when we inject cat states into non-entangling Clifford circuits.Moreover, it provides a natural set of resource states for studying chaotic dynamics, for which both magic and en-tanglement are necessary.Resource theories based on the complexity associated with quantum information scrambling were recently introduced [55,56].Here we will be interested in estimating numerically how many, and what type, of cat states need to be injected into a nonentangling Clifford circuit to achieve quantum information scrambling, a topic we review next.

Scrambling and quantum chaos
As already mentioned, one direct application of doped Clifford circuits involves understanding the role of magic in quantum chaos generated by random circuits.Quantum chaos is a surprising property that some dynamical quantum systems exhibit, and it is assumed to be deeply connected with many of the most intriguing problems in physics, such as the information loss paradox [57,58].
Scrambling of quantum information and quantum chaos are viewed as two related but different phenomena [59].A well-established witness of scrambling of information, known as the out-of-time-order correlator (OTOC) F (τ ) is defined as where V, W (0) are two local operators such that [V, W (0)] = 0, ρ is the initial state of the system, and W (τ ) = U † (τ )W (0)U (τ ) corresponds to the dynamical evolution of W (0) in the Heisenberg picture, with U denoting the unitary implementing the scrambling dynamics.This quantity can be estimated in various ways [60,61], and since it is in general complex-valued, we normally treat its real R[F (t)] and imaginary parts I[F (t)] separately.Heuristically, one witnesses scrambling typical from non-integrable dynamics when [60,62]: (a) there is an exponential decay of the real part of the OTOC.
(b) there is no recovery of the real part of the OTOC.
Exponential decay (a) indicates that initially localized information is being spread to many degrees of freedom through entanglement generation.Lack of recovery (b) is a typical heuristics characterizing the lack of integrability of the dynamics [60,62], or also the presence of non-Clifford resources [63].Recurrence times for nonintegrable dynamics are exponentially large as compared to the integrable case [64,65].We will see this exact behavior -expected to be hard to simulate classically [66] in our numerical studies, when investigating the effect of cat state injection into random quantum circuits for the generation of scrambling dynamics, as captured by the OTOC in Eq. ( 6).This allows for a study of the concurrent roles of non-stabilizerness and entanglement in the complexity of classical simulation.In Fig. 2 we illustrate these ideas by numerically simulating scrambling dynamics in ideal random quantum circuits.We choose a 10-qubit system evolved Out-of-time-order correlator Figure 2. Scrambling arising from ideal universal random quantum circuits.For a quantum circuit on n = 10 qubits, we numerically simulate the OTOC, F (τ ), for V = 1 ⊗(n−1) ⊗ X and W (0 1) .The unitary Uτ is generated by random and dense blocks UB i , 0 ≤ i ≤ 100 of gates of 10 layers each.We take each block to represent a time step τ and consider the total unitary to be the concatenation of all the blocks, e.g.{H, S, CX, T }, applied uniformly at random.Controllednot gates are applied between any pair of qubits, regardless of the distance between them.We plot 10 instances showing that, for each case, the behavior of the OTOC is generic, and highlight the last instance as a probe of that behavior.We show many instances, instead of using an averaging method, since it was recently argued [67] that averaging over instances might lead to misleading conclusions regarding emergent thermalization/scrambling in many-body dynamics.
It is important to note that the kind of (ideal) dynamics presented in Fig. 2(c) is believed to be both hard to learn and simulate classically, for any choice of classical simulation paradigm [44,49,66].We shall see later how cat states can be injected into non-entangling, random Clifford circuits, moving the behavior of the dynamics from Fig. 2(a) towards (c), by simultaneously injecting non-stabilizerness and entanglement resources, and hence introducing universality into the random circuit.

III. RESULTS
As explained in the previous section, the original cat states defined in Eq. ( 2) have been exploited in two main contexts.In Ref. [16], they were used as a convenient tool for finding lower-rank decompositions of |T ⟩ ⊗n leading to the improvements on the upper bounds of the cost of classical simulation of quantum computation with magic states |T ⟩ ⊗n .On the other hand, Ref. [11] explores the decompositions of cat states directly in order to achieve a heuristic improvement of their (strong) classical simulator using ZX-calculus.
Motivated and inspired by these works, here we aim to explore resource states that are both magic and entan-gled, expanding their realm of applicability beyond the classical simulation of quantum circuits.To that end, we start by defining and characterizing an infinite family of cat states, |cat * m ⟩.Then, we construct an explicit magic state injection gadget, which we dub cat gadget, that uses these star cat states to inject a family of mqubit unitaries V m .
One reason for exploring this family of star cat states (rather than using the original one) is the recognition that |cat * m ⟩ has the same RoM as |cat m+1 ⟩ whilst having one less qubit.As a consequence, these two states hold the potential of injecting unitaries with the same number of T gates.This will be discussed further in due time.
We exploit three main applications for our cat gadget.First, in a more direct connection with the prior works [16] and [11], we investigate if the classical simulation of quantum circuits can be sped up by the search for patterns V m , in analogy to the ZX simulator reviewed in Sec.II B. Then, we capitalize on the properties of |cat * m ⟩ states by (i) analyzing how the distillation of these states has the potential for resource reduction in actual quantum computations; and (ii) showing how the injection of (only) these states into otherwise non-entangling Clifford circuits leads to the appearance of scrambling, which, as we discussed, is associated with quantum computational advantage.

A. The family of star cat states
In Sec.II B, we presented the definition of the original cat states as given by Eq. ( 2).Moreover, we explained that these states are such that χ (|T ⊗m ⟩) ≤ 2χ (|cat m ⟩) , which enabled finding better upper bounds for the cost of (strong) classical simulation [16] and led also to a heuristic runtime improvement of the classical ZX simulator [11].
Let us now introduce the family of star cat states which we will denote |cat * m ⟩.Assuming access to a factory of the original cat states given by Eq. ( 2), we obtain the star cat states |cat * m ⟩ by measuring one qubit of the original cat state in the Pauli-Y basis, and post-selecting on outcome +1: Dropping the measured qubit, we are left with the state |cat * m ⟩ which has one less qubit than the original cat state.
It is fairly easy to check that |CS⟩ ≡ |cat * 2 ⟩ , which is to say that |CS⟩ can be obtained from |cat 3 ⟩ simply by measuring one of its qubits in the appropriate basis.This observation will be relevant in Sec.III B when we construct the cat gadgets.
In the description above we obtained the star cat state by postselecting on a +1 outcome of the Y measurement.It is easy to check that a −1 outcome also results in the desired star cat state, if we apply a Z ⊗m correction on the unmeasured qubits: Before proceeding, a small note on terminology is in order.From now on, we use the term "original cat states" to refer to the states specified in Eq. ( 2), and either "star cat states" or simply "cat states" to refer to the family defined via Eq.(7).
Whilst recognizing that the family of star cat states can be obtained from the original one simply via a stabilizer measurement will be useful in the ensuing discussion, explicit expressions of |cat * m ⟩ can also be provided so that: Alternatively, we can recognize that the equation above leads to the following form for these non-stabilizer and entangled resource states: where the sum is taken over all the m-bits binary bit strings, |s| denotes the string's Hamming weight, and ⌊a⌋ denotes the floor function which yields the last integer smaller or equal to a.
In Ref. [17], |W n ⟩ states -which are Clifford-equivalent to our |cat * n ⟩ -are mentioned in the context of resource state conversion with and without catalysis (see Figure 3 therein).Thus, the unitaries injected by our star cat states, depicted below in Fig. 3, closely resemble the unitaries depicted in Fig. 4 of [17].To more easily verify that Eq. ( 9) holds, the values of the RoM of tensor products of |T ⟩, calculated in [25], are also presented.

Non-stabilizerness
Since all we have done was to apply a stabilizer operation, concretely, a Pauli measurement, it is clear that χ (|cat * m ⟩) ≤ χ (|cat m+1 ⟩) .Eq. ( 3) gives us an upper bound on the stabilizer rank of the original cat states: χ (|cat m ⟩) ≤ χ (|T ⊗m ⟩) .Therefore, we immediately note that We are also interested in characterizing the robustness of magic of this family of states.There is a result in [25] that states that if the n-qubit unitary used to obtain a certain resource state, |Ψ R ⟩, from the state |+⟩ ⊗n cannot be synthesized with t (or fewer) T gates then For the case of cat states, this translates into the following bounds for the RoM: which orders these states by the RoM in the same way as Eq. ( 8) orders them by the stabilizer rank.
In Table II, we present the values of the RoM of both the original and the star cat states which we computed by solving the optimization problem set in Eq. ( 4).For comparison, the RoM of tensor products of the |T ⟩ state is also presented (as calculated in [25]).We call attention to two facts regarding these results: first, for all the values of m presented, R (|cat which means that the family of unitaries, V m : V m |+⟩ ⊗m = |cat * m ⟩ cannot be synthesized with fewer than (m + 1) T gates.In fact, Lemma A.7. of [17] informs us that these unitaries are precisely synthesized with (m + 1) T gates, a fact which holds for any m.It is reasonable to believe that the first observation will also be valid for any m.
In Sec.III B, we will discuss in a bit more detail the shape of the family of unitaries V m defined in the previous paragraph, and show how they can be injected into a given random circuit as long as we have access to a factory of |cat * m ⟩ states.It may seem curious that the measurement of one qubit of |cat m ⟩ in the Pauli-Y basis preserves the RoM of the states.In the following, we analyze the consequences of performing alternative Pauli measurements, illustrating that magic may or may not be preserved under different measurements.For instance, we could measure one qubit of |cat m ⟩ in the eigenbasis of X which, assuming the outcome +1, leads to the family of states given by Alternatively, performing a Z measurement with outcome +1 yields Interestingly, while the former family shares the same RoM as that of the family of star cat states, |cat * m ⟩, it is not hard to understand (even without solving the optimization problem) that the latter has a lower RoM.To do so, one can easily show that the states of the family |φ * m ⟩ can be generated from the state |+⟩ ⊗m via unitaries that can be synthesized using only m T gates.Moreover, it is easy to verify that, for the values of m in Table II ; which we conjecture holds for every m.

Entanglement
Even though multipartite entanglement is known to be hard to quantify, in the particular case of the original cat states, |cat m ⟩, it is easy to see that all the entanglement is provided by the underlying (balanced) GHZ structure, associated with the maximum values for most multipartite entanglement monotones.This is so because cat states are equivalent to GHZ states up to local unitary operations.Hence, using the monotone introduced in Sec.II D, Eq. ( 5), we know that E(|cat m ⟩) = E(|GHZ m )⟩ = 1 for all m.
A more technically subtle matter pertains to the entanglement of the cat states |cat * m ⟩.In creating these states by measuring one of the qubits of the original cat states, it may appear that we are destroying entanglement entirely.Nevertheless, that is actually not the case.We can see this in two different ways.First, directly from the fact that we can use these states to inject entangling unitaries (cf.Sec.III B).Secondly, by using the multipartite entanglement monotone E to quantify the entanglement present in these states.Using this monotone we can show a simple result.
We prove this simple fact in Appendix C. Since the monotone is faithful, the fact that E(|cat * m ⟩) = 1/2 for all m implies that star cat states are entangled states with less entanglement than the GHZ state (as quantified by E).It also means that |cat * m ⟩ are not within the same local unitarily equivalence class of the (balanced) GHZ states, since E is invariant in such classes.A simple way of understanding why this is so is to write |cat * m ⟩ in terms of the {|T ⟩ , T ⊥ } basis so that: This equation highlights that the states |cat * m ⟩ are unbalanced-weight GHZ-type states, that is, they consist of a version of the original cat states where the coefficients of the orthogonal states |T ⟩ and T ⊥ have different norm.This leads to less than maximal entanglement, as suitably witnessed by E.
In the following, we will use the fact that the states |cat * m ⟩ are non-stabilizer and entangled to faulttolerantly inject interesting m-qubit unitaries.Through this procedure, we measure the states (hence destroying the entanglement) but use adaptivity to inject the resource into quantum circuits, in the form of entangling unitaries.

B. Constructing a cat-gadget family
As previously explained, we denote by V m the family of unitaries that generates the family of star cat states from the state |+⟩ ⊗m .These unitaries can be defined recursively with the aid of another family of unitaries W m : For a visualization of the structure of these unitaries, see Fig. 3 (cf.Fig. 4 of [17]); it is not hard to show that they belong to the third level of the Clifford hierarchy as they conjugate each Z i onto itself and each X i onto a Clifford unitary.Hence, Theorem 1 guarantees that the star cat states can be created fault-tolerantly using only gates and measurements from the Clifford group.This highlights the existence of an alternative (and perhaps more convenient) preparation procedure for these states other than the one proposed in Eq. (7).Assuming access to a factory of such magic resource states, we can (fault-tolerantly) implement any unitary V m via a cat gadget which consumes the magic resource state |cat * m ⟩ but otherwise uses only Clifford operations and classical feedforward.To do so, we replace every V m in the quantum circuit by a sequence of cnot gates controlled in each of the data qubits V m acted on and targetting each of the qubits of the resource state |cat * m ⟩ ; the auxiliary qubits are then measured in the computational basis.If all measurement outcomes, σ i , yield 0, this immediately   4. Gadget that can be used to implement the unitary V3.The data qubits are entangled with the auxiliary qubits in the magic resource state |cat * 3 ⟩ using cnot gates controlled by the former and targeting the latter; this is then followed by computational basis measurements of the auxiliary qubits.After the appropriate Clifford corrections have been implemented (cf.Eq. ( 11)), the unitary transformation V3, from the family of unitaries Vm : Vm |+⟩ ⊗m = |cat * m ⟩ , has been applied to the computational qubits.
implements the desired unitary transformation V m on the computational qubits.Otherwise, some Clifford corrections are needed which take the form: where we used σ ⊕ = m i=1 σ i for brevity, with ⊕ representing addition modulo 2.
For a clearer visualization, Fig. 4 shows an example of the gadget that injects V 3 .See Appendix B for an example that illustrates how such gadgets can be found rather easily using the ZX-calculus framework.That framework can be used as formal proof that the gadget works for any V m .Interestingly, alternative (yet somewhat similar) gadgets can be found that use the original cat states to inject these same unitaries.
It is important to guarantee that the number of gates associated with the Clifford corrections scales efficiently (i.e.polynomially) with the number of qubits.It is clear that that is indeed the case; the structure of the CZ gates in the gadget corresponds to that needed to create a fully-connected graph, which has a total number of gates quadratic in m: N CZ = m(m − 1)/2 .This observation will be relevant below when discussing quantum resource reduction.

Different structures
The structure of the unitaries V m , as depicted in Fig. 3, is not unique.In fact, these unitaries can be implemented in a quantum circuit in many different ways.For instance, it is not hard to show that any of the T gates appearing in the final layer after W m can be moved to stand before it.Additionally, because W 2 acts symmetrically on any pair of qubits, it can be flipped within the cascade of cnot gates a number of times given by (m − 1).
Another important observation is that the unitaries with T inside the cascade of cnot gates (rather than T † ) can also be implemented by injecting cat states with only minor changes to the Clifford corrections.The T gate acting on the qubit which holds only the control for two cnot gates can also be pushed to be in between those two gates.This (large) flexibility in the representation of these unitaries looks promising as it increases the chances that such structures can be found inside a given quantum circuit.In particular, it can be shown that the number of possible structures that can be injected by the cat gadget is (at least): We note that N m is lower bounded by Ω (4 m m) and this exponential behavior to the number of structures gives us some hope that finding them inside quantum circuits is not as unlikely as one could think a priori.Unfortunately, as we shall discuss in more depth in Sec.III C, this expectation did not materialize in the context of the quantum circuits studied herein.

Classical simulation assisted by template matching
The fact that the original cat states are low rank (cf.Eq. ( 3)) led to the large improvement of the ZX simulator in Ref. [11].As previously explained, because an m-qubit cat state can be decomposed into a smaller number of stabilizer states than |T ⟩ ⊗m , identifying "cat-like" structures in a given (graph-like) ZX-diagram allows us to decompose those structures into a smaller number of terms than we would have if we were trying to identify (and decompose) tensor products of |T ⟩.
Naturally, in principle, the same will be true within the quantum circuit framework.Specifically, given a (general) unitary quantum circuit U with t T gates, if we can identify any of the structures discussed in Sec.III B, then we may transform U into an adaptive Clifford circuit whose resource state, |Ψ R ⟩, (potentially) involves copies of both |T ⟩ and |cat * m ⟩ states.To test this idea, we used the pattern-matching algorithm described in [68] and implemented in Penny-Lane [69,70] to find the desired "cat-like" structures within the quantum circuits.We run the code on the benchmark circuits listed in Table III and also on the same family of exponentiated Pauli circuits as used in [11] with the goal of finding V 2 (-equivalent) structures.
The results show that the improvements to classical simulation obtained by carrying out this procedure are Table III.Tested benchmark circuits.We searched for the patterns corresponding to the unitary V2 in several of the benchmark circuits analyzed in Ref. [10] and obtained from the optimization techniques proposed therein.The counts of V2 detected by the pattern matching algorithm from Ref. [68] are presented in the last column.Rows presented in bold highlight the benchmark circuits for which such patterns were detected, otherwise, no such patterns were identified.
either small or non-existent.In particular, we see that the pattern-matching algorithm detects structures that could be injected by |cat * 2 ⟩ only for four of the benchmark circuits.In the case of the exponentiated Pauli circuits, no such structures were found at all.This highlights the power of ZX-calculus.In that framework, it is easy to associate several phase gadgets with corresponding lowrank original cat states due to the reduction of the input circuit to a graph-like diagram via simplification rules.Contrarily, the comparative rigidity of quantum circuits does not allow the identification of comparable counts of structures associated with cat states.
To conclude this part, we should spare a comment on the cost of the pattern-matching algorithm proposed in [68] and used here.This is given by where n C (n P ) and g C (g P ) are, respectively, the number of qubits and gates in the circuit (pattern).It is clear that while the algorithm is polynomial in the properties of the circuit, it is exponential in the properties of the pattern, n P and g P .This limits our search capacity to structures of small (constant) size; otherwise, in trying to reduce the cost of classical simulation, we run into the risk of carrying out a search task that is more costly than the simulation itself.This search limitation is also not present in ZX-calculus, where the identification of phase gadgets is efficient [11].
As an example, we can consider the specific case of V 2 for which n P = 2 and g P = 5 so that: Note that 5 9 = 1 953 125 , which is a significantly large constant factor, and that the polynomial degree on the number of gates in the circuit is also quite large.

Resource reduction in quantum computation
Instead of focusing on classical simulation, we can consider the task of reducing the quantum resources needed for a certain quantum computation.In this case, doing pattern matching before running the quantum computer may allow us to identify unitary structures that can be injected via cat states |cat * m ⟩ .For each structure we detect in this way, we need one less (auxiliary) qubit to run the computation.For instance, consider the case of the benchmark circuit adder 8 .This circuit has 24 qubits and 173 T gates.As explained in Sec.II A, fault-tolerance computations are performed such that each T gate is injected using the T gadget as long as we have access to a factory of magic states |T ⟩ .This would require 173 auxiliary qubits in the state |T ⟩ ⊗173 .Alternatively, because 16 V 2 -like structures are detected within the circuit, we could use only 157 auxiliary qubits in the state: ⊗16 , so long as we have access to |cat * 2 ⟩ factories.1Note that the same resource reduction would not be achieved if the distilled family of states were the original |cat m ⟩ state.This highlights the usefulness of protocols that "compile" magic from higher-dimensional states to lower-dimensional ones (without any loss of that resource).
Besides the number of qubits, other features of quantum circuits, such as the depth or the number of twoqubit gates, are also deserving of attention when it comes to the optimization of quantum resources.Reducing the depth is relevant since it lowers the demands on the coherence time of the qubits, whilst minimizing the number of two-qubit gates is important because these gates tend to have lower fidelity than the single-qubit ones.
Let us now analyze the CNOT gate count of our injection procedure.We note that the unitaries V m require exactly N cnot = 2(m − 1) cnot gates, and cannot be implemented with fewer cnots [71].Comparatively, the gadget that injects this unitary using the state |cat * m ⟩ requires, on average, N ′ cnot = m(m + 3)/4.This comes from taking into account the m cnot gates used to connect the computational qubits to the auxiliary qubits in the state |cat * m ⟩ (see Fig. 4) plus the average number of CZ gates in the Clifford corrections which is given by m(m − 1)/4.It is not hard to see that N ′ cnot > N cnot ∀m ≥ 2. This means that the fault-tolerant implementation provided by the gadget actually requires more cnot gates than the direct implementation of the unitary itself.
This conclusion is different for applications where the non-local Clifford corrections in the dashed box of Fig. 4 might be irrelevant and, thus, dispensed with.Foregoing the application of these non-local corrections corresponds to applying either V m if the measurement outcomes are such that m i=1 σ i = 0, or the unitary with T inside the cnot cascade (rather than T † ) if m i=1 σ i = 1 .In applications where this difference is irrelevant, such as, for instance, the study of scrambling in random quantum circuits discussed next, we can apply the gadget without the non-local correction leading to an implementation requiring only N ′ cnot = m cnot gates, which is favorable over the number of such gates needed to directly implement V m .
The latter setting is likely to be the exception rather than the rule since most interesting applications involve deterministic (rather than random) procedures, in which case the implementation of the proper Clifford corrections is vital.Therefore, we note that while this approach might reduce the number of qubits needed for a given quantum computation, we are likely incurring an increase in the number of controlled-not gates needed.

Scrambling and quantum chaos of cat-doped random circuits
We may use the family of star cat states to faulttolerantly inject sub-circuit structures that induce scrambling of quantum information into a given circuit.In particular, it is interesting to see this kind of dynamic phenomenon emerge in circuits that lack both magic and entanglement, as both properties are injected with states from this family.
In Fig. 5 we show that scrambling of quantum information is induced by injection of cat-state unitaries V m with 2 ≤ m ≤ 10 into random quantum circuits.We allow the injection of V m with randomly chosen m.Assuming a circuit platform that has free access to Clifford gates drawn from the gate set {H, S}, we inject unitaries V m at random time-steps τ , acting on at most 10 qubits.
The plot in Fig. 5(a) shows the behavior of the real part of the OTOC for 16 injections happening at random times up to step τ = 40.The specifics of the unitary dy- 5. Emergence of scrambling from cat-state injection.As before, we simulate the OTOC given by Eq. ( 6) considering the same evolution choices made in Fig. 2 other than the evolution of the unitary U .Here we have blocks of random non-entangling Clifford unitaries from the set {H, S}.At some time steps τ , characterized by blocks of a fixed number of unitaries, we inject in random positions over the 10-qubit circuit the cat-state unitary structures Vm.On the left (Fig. 5(a)) we perform 16 injections and on the right (Fig. 5(b)) 36.The injection times are chosen arbitrarily and do not affect the results qualitatively.We inject unitaries Vm via states {|cat * m ⟩} 10 m=2 uniformly at random, hence not necessarily V10 but possibly unitaries having less magic and entanglement.Even though the circuits Vm have a specific structure, they induce scrambling of quantum information in a controlled way, as the number of injected cat states increases.
namics are exactly the same as in Fig. 2, the only difference being the unitary blocks U and the injection of V m unitaries.We see that after we stop injecting cat-states into the separable circuit the OTOC stabilizes.The plot of Fig. 5(b) corresponds to 36 injections of cat-states and we see that after all injections have happened, up to timestep τ = 90 in this case, we have the generic feature of scrambling dynamics that was also present in universal Clifford+T circuits (cf.Fig. 2(c)).In particular, we note that cat injection allows for a controlled introduction of scrambling into these separable random circuits.
For a small number of injections and these kinds of circuits, it is possible for the OTOC to stabilize in nonzero values, as can be seen by the highlighted OTOC dynamics in Fig. 5(a).This implies that, afterward, the OTOC should not decrease towards zero -the intuition is that there is no more magic or entanglement to allow for that behavior -and any such decrease would need to arise from decoherence acting on the system's evolution.The problem of distinguishing between decoherence and scrambling is of great interest within the community [72][73][74].The kind of slow and controlled scrambling induced by cat states may be useful in the characterization of the different quantum resources at play, in particular, to distinguish decoherence dynamics from the stable evolution of the OTOC after a finite number of injections.
Known theoretically obtained results have shown that T -doped Clifford circuits require O(n 2 ) non-Clifford gates, where n is the number of qubits, to induce chaotic dynamics that is both hard to simulate and learn [44].In our numerical simulations, this means that O(n) catinjections -for which O(n 2 ) T gates and O(n) CX gates are injected -should suffice for achieving a dynamics having an exponential decay without recovery of the OTOC [49].
If we consider random unitaries built from a universal gate set such as {H, CX, T }, the OTOC ceases to signal scrambling of information when any gate from the universal gate set is removed.Much is discussed in the literature regarding the necessary number of T gates or CX gates to introduce this kind of chaotic evolution, but recent results in classical simulation of quantum systems [75] point towards revisiting the idea of classical simulability using sums over Feynman paths, where H gates lead to an exponential overhead in classical simulation.
Finally, it is useful to point out that although the real part of the OTOC may suffer exponential decay in Clifford dynamics, the imaginary part of the OTOC does not change.As a matter of fact, neither Clifford, nor incoherent or separable dynamics are able to change the imaginary part of the OTOC.The latter is a normally underappreciated quantity, but, in this case, I[F (τ )] ̸ = 0 signals the presence of all elements in the gate set {H, CX, T } in generic quantum circuits.
It is interesting to point out that the imaginary part of the OTOC is not a representative witness of universality in general.For instance, the gate set {H, Toffoli} is universal for quantum computation but it also has the property that I[F (τ )] = 0.Even still, the imaginarity of the OTOC may find fruitful applications elsewhere; for instance, it serves as a witness of basis-independent coherence [61], and it has recently been applied as a tool in quantum machine learning [76].

IV. DISCUSSION
In this work, we assessed the usefulness of cat states within the circuit model of quantum computation.To that end and assuming access to a factory of such nonstabilizer and entangled resource states, we constructed a family of gadgets that fault-tolerantly inject interesting unitaries into quantum circuits.Then, we explored these gadgets in the context of three main applications.
First, we considered the task of (strong) classical simulation of quantum circuits.Specifically, inspired by similar work in the context of the ZX-calculus framework, we explored the idea of searching for specific (non-Clifford) cat-state-like unitaries within benchmark circuits and exponentiated Pauli circuits.The idea is to use the identification of such structures to improve the cost of classical simulation, as they can be implemented via the injection of low-rank resource states.Interestingly, our results show that while cat-state-like structures may appear commonly in ZX-calculus after simplifications have taken place, this does not happen in general circuits due to their (more) rigid structure.This suggests that the success of strong simulation using cat states within the ZX-calculus paradigm arises from simplifications made possible by the diagrammatic representations.
Secondly, we noticed that the application of these gadgets can also be exploited in the context of resource minimization in actual quantum computation.We explained how the detection of cat-like structures within quantum circuits can lead to a reduction in the number of qubits needed to perform the corresponding (faulttolerant) computation in actual quantum hardware.This is a clear advantage over the ZX-calculus framework, wherein the simplifications (whilst leading to faster classical simulation) come at the cost of departing from the quantum circuit model.We also think that the unitary structures injected by our gadgets may find applications in several protocols.For instance, structures akin to these appear in the context of quantum parameter estimation.
It is also interesting to remark that whilst the gadget used to inject the non-stabilizer and entangling unitaries V m does not use any magic gates, it does require the use of two-qubit entangling gates.This observation highlights a crucial difference between the two resources.Moreover, in Sec.III C, we discussed that our gadget requires a larger number of controlled-not gates to inject V m than the one needed to implement V m directly.This is in contrast with what happens, for instance, with the gadget that injects the Toffoli gate which requires 4.5 and 6 cnot gates, respectively on average and in the worst case.On the other hand, the optimal decomposition for the Toffoli gate uses 6 cnots [77] which means that the gadget is advantageous in terms of the count of two-qubit entangling gates.This leads to two questions: first, whether the cat gadget is improvable in terms of the number of cnots needed, and second, which are the entangling unitaries that might be injected with an advantage in the number of cnots.
Finally, we moved towards understanding how the evident nonclassical resources of cat states can be used to induce scrambling of quantum information into otherwise non-entangling circuits.We showed that these states can be used to generate scrambling of information in a slow and controlled way.We have seen numerically that injection of a sufficient number of cat states can induce dynamics that should be hard to simulate classically.In particular, this might have applications in the quantification of different nonclassical resources in quantum information scrambling.

=
Another important rule is the copy rule, that we refer to as (π).This rule will be particularly relevant for us whenever we want to study Clifford corrections and propagate the results of past outcomes through the diagram.Single-system spiders with angles that are multiples of π can be copied through generic-label spiders of the opposite color.There are some identities that are useful as they simplify elements into the identity gate, that in the ZX-calculus is simply represented as a single wire.

= = = 2π
The last identity we consider is the phase-gadget identity [10,71] which teaches us how to represent a ZX-calculus phase gadget into a diagram resembling a quantum circuit.It works for an arbitrary number of qubits, n, but for simplicity we make a finite representation.
The ZX-calculus phase-gadget identity greatly simplifies the proof that our cat gadget works since we can view the injection of |cat * m ⟩ in the ZX-calculus as the injection of a specific phase-gadget into the circuit; the remaining complication is to find out what are the Clifford corrections to be performed and the complete list of equivalent unitaries that can be injected.
Using these tools, Refs.[10,11] studied strong simulation as discussed in the main text.In particular, as it is now clear, one can write any quantum circuit into a ZX-calculus form.Once we perform the simplifications, the final diagram can be put in what is called a graph-like ZX-diagram, that is, a diagram with only green spiders and Hadamard edges (i.e., edges that have a Hadamard gate on them).Thus, graph-like ZX-diagrams are node-weighted graphs2 with node weights representing non-Clifford spiders.

Figure 1 .
Figure 1.Doping resources into quantum circuits.Generic blocks of free circuits, e.g.Clifford circuits or separable qubit operations, receive controlled doses of resourceful gates, e.g.magic gates in Clifford+T architectures, entangling gates in photonics, or Hadamard gates in the Feynmanpath approach to classical simulation of quantum computation.
Figure2.Scrambling arising from ideal universal random quantum circuits.For a quantum circuit on n = 10 qubits, we numerically simulate the OTOC, F (τ ), for V = 1 ⊗(n−1) ⊗ X and W (0) = Z ⊗ 1 ⊗(n−1) .The unitary Uτ is generated by random and dense blocks UB i , 0 ≤ i ≤ 100 of gates of 10 layers each.We take each block to represent a time step τ and consider the total unitary to be the concatenation of all the blocks, e.g., at time τ = 2 we have U2 = UB 2 • UB 1 and at time τ = 3 we generate a new block unitary UB 3 so that U3 = UB 3 • UB 2 • UB 1 , and so on up to τ = 100.We choose gates from the sets (a) non-entangling Clifford, i.e. {H, S}, (b) Clifford := {H, S, CX}, and finally (c) Clifford+T := {H, S, CX, T }, all acting on an initial state ρ = |0⟩⟨0|.We present 10 instances of this evolution and highlight the last of these.In sub-figure (c), the exponential decrease of the real part of the OTOC, together with the lack of revival, are signatures of non-integrable dynamics.

Figure 3 .
Figure 3. Construction of the family of unitaries Vm.In (a) we present the decomposition of Vm into the entangling unitary Wm followed by T ⊗m ; next, in (b), we show how Wm can be constructed recursively from W2, which is shown explicitly in (c).

Figure
Figure 4. Gadget that can be used to implement the unitary V3.The data qubits are entangled with the auxiliary qubits in the magic resource state |cat * 3 ⟩ using cnot gates controlled by the former and targeting the latter; this is then followed by computational basis measurements of the auxiliary qubits.After the appropriate Clifford corrections have been implemented (cf.Eq. (11)), the unitary transformation V3, from the family of unitaries Vm : Vm |+⟩ ⊗m = |cat * m ⟩ , has been applied to the computational qubits.

Table II .
Robustness of magic of the star and original cat states.