# Generating whole-processor entanglement on 27- and 65-qubit quantum systems

Two recently published research papers detail the generation of a 27-qubit genuine multipartite entangled state and, separately, the generation of a 65-qubit bipartite entangled state. These results with IBM Quantum processors demonstrate one of the largest entangled states yet created. These large states will be important assets for running quantum computations.

Two recently published research papers detail the generation of a 27-qubit genuine multipartite entangled state and, separately, the generation of a 65-qubit bipartite entangled state. These results with IBM Quantum processors demonstrate one of the largest entangled states yet created. These large states will be important assets for running quantum computations.

Perhaps the most well-known entangled state is the Bell state—represented as (|00⟩ + |11⟩)/√2 whose existence famously ruled out local hidden variable theories of quantum mechanics. Put in a simpler way, if you take two qubits which share this state and separate them over some distance, they will exhibit non-local correlations—measure one, the global wave function will collapse, and the other will be in the same state as the one first measured, regardless of the distance between them. But what happens when you extend this state to include a larger numbers of qubits?

These extended entangled states exhibit what is called multipartite entanglement, and they can come in many different forms in a quantum system. Take, for example, bipartite entanglement of a quantum state, where all partitions of the state into two subsystems of qubits (leaving none out) result in the partitions being entangled with one another. Even stronger than bipartite entanglement is genuine multipartite entanglement, where among the noisy states on a processor, each qubit is entangled with all other qubits. Such entangled states over many qubits are an essential resource at the heart of many quantum algorithms which we hope may exhibit an advantage over the typical classical algorithms that are used in our traditional computers.

One of the reasons why quantum computers are so difficult to make compared to conventional computers is the extreme sensitivity that qubits have to noise. Noise introduces a variety of restrictions that make it difficult to scale up the number of qubits. Each additional qubit introduces complexity and additional noise, which reduces the quality of interactions among the other qubits. Therefore, creating systems with large numbers of qubits doesn’t necessarily improve the capability of quantum computation—in fact, more qubits could deteriorate it. Surrounding this, there are many limiting factors in quantum hardware that affect the quality of computation: gates might not rotate in the way we think they do, qubits may interact with each other in undesirable ways, and, with the most potential for damage, decoherence could irrecoverably erase some of our quantum information. As quantum technology improves, it is important to measure the progress in improving these kinds of errors.

Quantum hardware is complicated, and it is difficult to gauge the ability of a quantum processing system based on calculations of piecemeal error sources alone. Researchers have developed a variety of benchmarks to encapsulate the progress for the whole quantum computing system. The ability to prepare large, highly entangled states is an important benchmark, because it demonstrates the overall ability of the processor to perform quantum computations—especially so when the demonstration includes all of the qubits in the processor.

In our work at the University of Melbourne’s IBM Quantum Hub, we generated a state over all qubits of IBM’s 27-qubit IBM Quantum Montreal system and verified that it was genuinely multipartite entangled, then we generated a state over all qubits of IBM’s 65-qubit IBM Quantum Manhattan system and verified that the state was bipartite entangled.

There are many different classes of states that qualify as possessing genuine multipartite entanglement, but the simplest example is probably exactly how one would think to extend the Bell state. We define these so-called Greenberger-Horne-Zeilinger (GHZ) on *n* qubits as (|0⟩^{n} + |1⟩^{n})/√2 and if we can show that the state generated in a quantum processor is close enough to this ideal GHZ state, then it turns out that the generated state must be genuinely In the first experiment, the University of Melbourne team used the IBM Quantum Montreal processor to generate and verify a 27-qubit genuinely multipartite entangled state—this is a state where there is always a state among the noisy mixture of states on a processor, where each qubit is entangled with every other qubit.multipartite entangled.

In a recent paper^{1} in the *Journal of Physics Communications*, we pushed the IBM Quantum Montreal processor to create a 27-qubit GHZ state—that’s (|000000000000000000000000000⟩ + |111111111111111111111111111⟩)/√2 (with some noise). The size of the GHZ states that researchers have produced has gotten larger over time, and has accelerated. Here’s a graph showing some of the significant results for genuine multipartite entanglement for three or more qubits across A historical plot, similar to the graph below by Max Planck Institute for the Science of Light’s Mario Krenn can be found, here.different platforms in recent years:

This is quite a difficult state to prepare, especially during the current era of noisy quantum processors. We’ll discuss a little bit about how we set this up, how we needed to be careful about the preparation of the state, and how we employed some error mitigation techniques to reveal exactly what was going on in the hardware.

We start by initializing the qubits so they're all in the ground state—that's the |00...0⟩ state—and then apply the Hadamard gate to the first qubit to get the superposition (|00...0⟩|0⟩ + |00...0⟩|1⟩)/√2 (using the Qiskit qubit ordering convention). Then, we apply a The controlled-NOT gate, also known as the controlled-x (CX) gate, acts on a pair of qubits, with one acting as “control” and the other as “target.” It performs a NOT on the target whenever the control is in state. If the control qubit is in a superposition, this gate creates entanglement.CNOT gate with the control on the first qubit and target on the second qubit to entangle them, forming an entangled set of two qubits, which is actually the Bell state (|00...0⟩|00⟩ + |00...0⟩|11⟩)/√2.

We can keep applying CNOTs to grow the number of qubits in the entangled set by controlling the gate using a qubit in the set and targeting a qubit not yet in the set. This can be applied in sequence until we produce the final GHZ state (|00...0⟩ + |11...1⟩)/√2.

For example, if all CNOTs are controlled on the first qubit, then the GHZ preparation circuit looks like:

However, by using a smarter selection of controlled qubits for the CNOTs, the circuit could also look like:

This version only has a CNOT depth of three, while the first has a CNOT depth of six. This is important, because decoherence of the quantum state can introduce a large amount of error into the computation, and a longer time spent applying successive CNOTs can lead to more decoherence. So, this method of performing the CNOTs in parallel is crucial for preparing the GHZ state within the processor as fast as possible, which in turn reduces the amount of decoherence that creeps into the system. Based on the IBM Quantum Montreal hardware layout, we carefully prepare the GHZ state in a way that minimizes the total CNOT depth of the circuit.

For this processor, we apply the initial Hadamard gate to q13 and CNOTs grow the entangled set of qubits by following the arrows (where the tail is the control qubit and the head is the target).

Once you construct the circuit in Qiskit, there’s no guarantee that the state you create will meet the criteria for actually possessing genuine multipartite entanglement—more on that later in the blog. But we didn’t only generate genuine multipartite entanglement on a 27-qubit processor.

On top of generating a 27-qubit genuine multipartite entangled state, we also created a 65-qubit In the second experiment, the University of Melbourne team used the IBM Quantum Manhattan processor to generate a 65-qubit bipartite entangled state—this is a state where, no matter how you separate the qubits into two groups, one group is always entangled with the other.bipartite entangled state. Verifying bipartite entanglement is equivalent to showing that all two partitions of qubits in the state are entangled with one another. One way to do this is to test for entanglement between every connected pair of qubits within the qubit layout of the processor. If every pair is entangled, then there’s no way to separate the qubits into two partitions such that there’s no entanglement between them—so the state would have to be bipartite entangled. For this, we use a quantum state called the graph state, which is convenient for measuring pair-wise entanglement.

In another recent paper,^{2} published in *Advanced Quantum Technologies*, we were curious whether IBM Quantum’s largest available processor, the 65-qubit IBM Quantum Manhattan system, could be fully bipartite entangled. We successfully generated a 65-qubit graph state over all of the system’s qubits.

Graph states are defined using a graph with nodes and edges (that is, lines connecting nodes). Nodes represent qubits and edges represent pairs of qubits with two-qubit entangling gates applied, in this case, controlled-phase gates.

Mathematically, we write these graphs as |𝐺_{𝑁}⟩=∏_{(α,β)∈E)}𝐶𝑍^{$\underset{β}{α}$}|+⟩^{(⊗𝑁)}, where 𝑁 is the number of qubits, 𝐸 is the set of edges, α and β are nodes corresponding to qubits, 𝐶𝑍^{$\underset{j}{𝑖}$} is a controlled-phase gate between qubits 𝑖 and j, and |+⟩^{(⊗𝑁)} is the plus state over all 𝑁 qubits which is prepared by applying a Hadamard to each qubit in the ground state |00…0⟩.

Similar to preparing the GHZ state efficiently, we also want to prepare the graph state efficiently by minimizing the controlled-phase gate depth of the state preparation circuit. One way to do this is to imagine a smaller five-qubit unit-cell within the heavy-hexagon architecture of the IBM Quantum Manhattan processor.

An efficient preparation circuit for preparing a graph state over this unit-cell is:

Which has a controlled-phase gate depth of three. By preparing these unit-cell graph states in parallel and stitching them together according to the qubit layout with more controlled-phase gates, we can still prepare the whole N-qubit graph state with a controlled-phase gate depth of three.

Trying to figure out what state you’ve created is a curse of quantum mechanics; many of the quantum mechanical topics that make quantum computing such an exciting prospect are also what make it so complex and difficult to work with. Measurement collapses your wave function and causes the processor or forget its quantum state, so how can you ever know that you’re really generating the right one?

Our workaround is to generate the state many different times, make many different measurements, and then collect statistics on it. The measurement collapses the wave function, but it also tells you a little bit about the state. Then, you ask your processor to replicate exactly what it just did so that you can learn a little bit more.

The typical protocol for this process is known as Quantum tomography is an experimental procedure to reconstruct a description of part of quantum system from the measurement outcomes of a specific set of experiments. See the types of tomography you can implement in Qiskit.quantum state tomography, where you glean all pieces of information to completely describe the prepared state. The experimental and computational requirements of this reconstruction approach grow exponentially with the number of qubits.

However in some cases, you might not actually care about the complete description of the state you’re creating. You may only care about certain properties that are related to what you are trying to detect. So instead, we use specialized techniques that depend on the type of entanglement and the structure of the state we are measuring to help make entanglement detection for large numbers of qubits possible with fewer measurements.

Errors are in just about every component of current-generation noisy quantum processors. Probably the largest single source of error, however, is in the measurement of the state itself, which can be very problematic. When you make your measurement, and the processor outputs a |0⟩, the real state may have actually collapsed to a |1⟩, and vice versa.

How can you ever be sure of anything then?

Well, you can always learn what’s going wrong. This aspect of measurement error is different from other sources of noise. Firstly, in that measurement doesn’t affect any part of the creation of the state—you can still create high-fidelity states that only look noisy once you make a measurement. Maybe your processor is really good at creating entangled states (the metric we care about), but because your ability to read it out is poor, they end up looking very bad.

Secondly, this noise is predominantly classical. This means that it tends to only depend on the final measured population probability distributions, rather than relating to the phase of the state, for example. Therefore, there are techniques that can be used to learn the measurement noise, and then invert it in post-processing such that you can find out what state was actually on your quantum computer. Neat, right?

This is called quantum readout error mitigation (QREM) and is likely to help the performance of many near-term quantum algorithms. One implementation of this can be accessed in the Qiskit, under Measurement Error Mitigation.

For such large states, we had to perform this inversion in a very particular way in order to save on computational resources. Otherwise the probability distributions get pretty large (2^{27} possibilities)!

We took careful steps to ensure that inverting this noise channel didn’t inflate any part of our results on the processor. This is an important point as relatively new techniques are implemented on near-term systems, we need to make sure they’re not doing anything untoward—or misrepresenting what’s actually happening physically.

In some cases, you might not actually care about the complete description of the state you’re creating. You may only care about certain properties such as how close the state is to some other interesting, known state. And, maybe, that interesting state is actually quite simple in structure. This was our case for detecting genuine multipartite entanglement. When creating a GHZ state, you only really care about two things: the population, or the probability of obtaining either of the two all-zero or all-one states, and the coherence, which describes the amount of quantum superposition that the all-zero and all-one states are in. Once you measure these two properties for your lab state, that’s actually all you need to know to understand how well your processor performed.

A metric of choice in quantum information is called the Uhlmann fidelity. Roughly speaking, this measure expresses the probability that one state will pass a test to identify as another ideal state; a fidelity of 1 means the two states are exactly the same, and a fidelity of zero means that the two states are exactly orthogonal, and could never accidentally pass for one another. When you talk about the “fidelity” of a lab state, it usually means how well you managed to recreate a target ideal state.

Measuring the presence of genuine multipartite entanglement in generic states is a notoriously difficult problem in quantum computing. This becomes especially true when you introduce noise into the mix, and traditional checks break down.

Fortunately, however, there are some simple tests known as witnesses which can confirm the entanglement in special cases. One such example of this is certifying the generation of a GHZ state: if you create a quantum state with a GHZ fidelity greater than 0.5, then this means your state is genuinely multipartite entangled.

Plus, though fidelity may generally be complicated to measure, it takes on a simple formula for GHZ states:

F = (P + C)/2, where P is the population, and C is the coherence.

Then, the population measurement is easy enough: create the state, measure it, and calculate the proportion of results in either of these states. The coherence is a little trickier. One way, which is the method we use, is called multiple quantum coherences (MQC). It applies little phase rotations of Φ to the prepared state, in order to create (|00...0⟩ + e^{{i Φ}} |11...1⟩)/√2, and then applies the reverse of the GHZ preparation circuit followed by a measurement. The proportions of the results measured in the |00...0⟩ state can be plotted as a sinusoidal curve. The amplitude of this sine curve is then straightforwardly related to the coherence. If there were no coherence, the phase rotation would do nothing, and so the sine curve would be completely flat. Here are a few of the coherence curves we obtained for different-sized GHZ states. The states in superposition are talking to each other!

We measured the fidelity for the GHZ states of sizes 19 to 27 qubits and obtained the following results.

Where QREM indicates that quantum readout error mitigation was applied. For the 27-qubit state, we record a fidelity of 0.546±0.017. Since it’s above the 0.5 threshold with a confidence level of 98.6% error, it means that the state was genuinely multipartite entangled!

If we can use the graph state preparation circuit to create a graph state that corresponds to the full qubit layout of the IBM Quantum Manhattan processor, then showing that each of the connected pairs of qubits in the graph state are entangled means that the whole graph state is bipartite entangled.

Luckily, the graph state has a nice property that makes it relatively straightforward to calculate pair-wise entanglement. The quantum state tomography technique is performed on each pair of connected qubits and their neighbours. Which means that for each pair, we are left with a state of up to five qubits (two in the pair and up to three neighbours). Then after applying some mathematical manipulations to the state, we can calculate something called the negativity between the pair of qubits.

The negativity indicates the amount of entanglement detected between the pair. A value of 0 means that no entanglement was found, and a value of 1 means that the pair was found to be maximally entangled. So by doing this for each connected pair, we can find out which pairs are entangled.

Here’s an image displaying the negativity values between each pair of connected qubits for the 65-qubit graph state that we prepared.

We can see that whether QREM was used or not, all pairs had non-zero negativity and thus the full graph state was bipartite entangled!

So that’s it, that’s the genuinely multipartite entangled 27-qubit GHZ state and the bipartite entangled 65-qubit graph state! We generated them on the IBM Quantum Montreal and IBM Quantum Manhattan systems, respectively. For the GHZ state we used an optimized preparation circuit, corrected its classical measurement noise, and certified it using the multiple quantum coherences phase detection technique. For the graph state we similarly optimized the preparation circuit, corrected its classical measurement noise, and verified bipartite entanglement by using quantum state tomography on connected pairs of qubits and their neighbors.

We’re living in an exciting time, with rapid developments in quantum technology continuing to accelerate. You can expect to see much larger and higher fidelity states not too far on the horizon, just look at IBM’s technology roadmap for an idea of where this might lead.

## Notes

- Note 1: In the first experiment, the University of Melbourne team used the IBM Quantum Montreal processor to generate and verify a 27-qubit genuinely multipartite entangled state—this is a state where there is always a state among the noisy mixture of states on a processor, where each qubit is entangled with every other qubit. ↩︎
- Note 2: A historical plot, similar to the graph below by Max Planck Institute for the Science of Light’s Mario Krenn can be found, here. ↩︎
- Note 3: The controlled-NOT gate, also known as the controlled-x (CX) gate, acts on a pair of qubits, with one acting as “control” and the other as “target.” It performs a NOT on the target whenever the control is in state. If the control qubit is in a superposition, this gate creates entanglement. ↩︎
- Note 4: In the second experiment, the University of Melbourne team used the IBM Quantum Manhattan processor to generate a 65-qubit bipartite entangled state—this is a state where, no matter how you separate the qubits into two groups, one group is always entangled with the other. ↩︎
- Note 5: Quantum tomography is an experimental procedure to reconstruct a description of part of quantum system from the measurement outcomes of a specific set of experiments. See the types of tomography you can implement in Qiskit. ↩︎

## References

- Mooney, G.J., White, G.A.L., Hill, C.D. and Hollenberg, L.C.L. Generation and verification of 27-qubit Greenberger-Horne-Zeilinger states in a superconducting quantum computer.
*J. Phys. Commun*. 5 095004. (2021).↩ - Mooney, G.J., White, G.A.L., Hill, C.D. and Hollenberg, L.C.L. Whole-Device Entanglement in a 65-Qubit Superconducting Quantum Computer.
*Adv. Quantum Technol*. 2100061. (2021).↩