Skip to main content
GHZ State|6 results
Simulation→
Hardware→
Complete

GHZ State Preparation

Testing multi-qubit entanglement scaling with 3-qubit GHZ states

We scale entanglement from two to three qubits using GHZ states and measure how noise worsens with circuit complexity. Adding one qubit drops IBM's fidelity from 99% to 98%, while Tuna-9 shows more significant degradation.

Research Question

How does entanglement fidelity degrade when scaling from 2-qubit Bell states to 3-qubit GHZ states, and what does parity leakage reveal about correlated errors?

Prior Work

The Greenberger-Horne-Zeilinger (GHZ) state |GHZ⟩ = (|000⟩ + |111⟩) / √2 extends Bell-type entanglement to three or more qubits. First proposed in 1989 by Daniel Greenberger, Michael Horne, and Anton Zeilinger, GHZ states are maximally entangled and form the basis for quantum error correction codes, quantum secret sharing, and multi-party quantum communication.

GHZ states are more fragile than Bell states because they require additional entangling gates and involve more qubits exposed to decoherence simultaneously. The key diagnostic is parity: a perfect GHZ state only produces even-parity outcomes (|000⟩ and |111⟩). Any odd-parity states (|001⟩, |010⟩, |011⟩, |100⟩, |101⟩, |110⟩) indicate hardware errors. The ratio of even-to-odd parity outcomes measures how well the device maintains multi-qubit coherence.

On current NISQ hardware, 3-qubit GHZ fidelities typically range from 85-98%, depending on the connectivity and gate error rates of the specific qubit layout chosen by the compiler.

Method

We prepare the 3-qubit GHZ state using a cascade of entangling gates: a Hadamard on qubit 0, then CNOT gates chaining entanglement through qubits 1 and 2.

Circuit: H(q[0]) → CNOT(q[0], q[1]) → CNOT(q[1], q[2]) → Measure all

Protocol:

  • 1024 shots per backend
  • Fidelity = (count_000 + count_111) / total
  • Parity analysis: fraction of even-parity vs odd-parity outcomes
  • Same circuit on emulator, IBM ibm_torino, and QI Tuna-9

Results

Platform Comparison

BackendTypeKey MetricDate
QI Tuna-9 (9q)
Hardware86.0% fidelity2/10/2026
QI Tuna-9 (9q)
Hardware87.9% fidelity2/10/2026
IBM Torino (133q)
Hardware93.8% fidelity2/10/2026
QI Tuna-9 (9q)
Hardware86.6% fidelity2/10/2026
IBM Marrakesh (156q)
Hardware98.1% fidelity2/10/2026
QI Emulator
Emulator100.0% fidelity2/10/2026
QI Tuna-9 (9q)qiskit-transpiler-baseline-ghz5
completed
GHZ State Fidelity86%
Fidelity86.0%vs100.0%(qxelarator (emulator))
|00000⟩
1882 (53.4%)
|11111⟩
1641 (46.6%)

5-qubit GHZ via Qiskit transpiler routing: 86.0% fidelity. Same qubit set as AI ([5,2,4,6,8] vs [2,4,5,6,8]) but valid CNOT chain. AI circuit used invalid pairs (q4-q5, q5-q6 not connected).

View cQASM circuit
version 3.0
qubit[9] q
bit[9] b

// 5-qubit GHZ via Qiskit transpiler routing
// CNOT chain: q5->q2->q4->q6->q8
H q[5]
CNOT q[5], q[2]
CNOT q[2], q[4]
CNOT q[4], q[6]
CNOT q[6], q[8]

b = measure q
View raw JSON
QI Tuna-9 (9q)ghz-tuna9-daemon-001
completed
GHZ State Fidelity88%
Fidelity87.9%vs100.0%(qxelarator (emulator))
Even parity: 55.8%Odd parity: 44.2%
|000⟩
473 (46.2%)
|111⟩
427 (41.7%)
|110⟩
66 (6.4%)
|101⟩
22 (2.1%)
|001⟩
14 (1.4%)
|011⟩
10 (1.0%)
|010⟩
7 (0.7%)
|100⟩
5 (0.5%)

3-qubit GHZ fidelity: 87.9%. Even parity: 55.8%, Odd parity: 44.2%.

View cQASM circuit
version 3.0
qubit[3] q
bit[3] b

H q[1]
CNOT q[1], q[0]
CNOT q[0], q[2]
b = measure q
View raw JSON
IBM Torino (133q)ghz-003-ibm-torino
completed
GHZ State Fidelity94%
Fidelity93.8%vs100.0%(qxelarator (emulator))
|000⟩
1962 (47.9%)
|111⟩
1879 (45.9%)
|010⟩
72 (1.8%)
|011⟩
67 (1.6%)
|110⟩
39 (1.0%)
|001⟩
36 (0.9%)
|101⟩
22 (0.5%)
|100⟩
19 (0.5%)

3-qubit GHZ on ibm_torino via MCP: 93.8% fidelity. Lower than ibm_marrakesh (98.1%), suggesting qubit-pair-dependent CNOT error rates. Still well above Tuna-9 (85.4%).

View raw JSON
QI Tuna-9 (9q)ghz-003-tuna9
completed
GHZ State Fidelity87%
Fidelity86.6%vs100.0%(qxelarator (emulator))
Even parity: 55.6%Odd parity: 44.4%
|000⟩
1983 (48.4%)
|111⟩
1564 (38.2%)
|110⟩
310 (7.6%)
|101⟩
64 (1.6%)
|010⟩
61 (1.5%)
|100⟩
41 (1.0%)
|001⟩
39 (1.0%)
|011⟩
34 (0.8%)

3-qubit GHZ fidelity: 86.6% on Tuna-9. Significant noise with 13.4% leakage into non-GHZ states. Asymmetry between |000⟩ (48.4%) and |111⟩ (38.2%) suggests qubit-dependent error rates.

View cQASM circuit
version 3.0
qubit[3] q
bit[3] b

H q[0]
CNOT q[0], q[1]
CNOT q[0], q[2]
b = measure q
View raw JSON
IBM Marrakesh (156q)ghz-003-ibm
completed
GHZ State Fidelity98%
Fidelity98.1%vs100.0%(qxelarator (emulator))
|000⟩
2098 (51.2%)
|111⟩
1922 (46.9%)
|110⟩
36 (0.9%)
|101⟩
14 (0.3%)
|011⟩
13 (0.3%)
|001⟩
10 (0.2%)
|100⟩
2 (0.0%)
|010⟩
1 (0.0%)
View raw JSON
QI Emulatorghz-003
completed
GHZ State Fidelity100%
Fidelity100.0%vs86.0%(tuna-9)
Even parity: 50.1%Odd parity: 49.9%
|000⟩
513 (50.1%)
|111⟩
511 (49.9%)

3-qubit GHZ fidelity: 100.0%. Even parity: 50.1%, Odd parity: 49.9%.

This ran on a noiseless emulator. Hardware results will show real noise effects.

View cQASM circuit
version 3.0
qubit[3] q
bit[3] b

H q[0]
CNOT q[0], q[1]
CNOT q[1], q[2]
b = measure q
View raw JSON

Discussion

The scaling from Bell (2-qubit) to GHZ (3-qubit) reveals how noise compounds with circuit depth and qubit count.

Emulator (100% fidelity): Perfect as expected -- only |000⟩ and |111⟩ appear in exactly equal proportions.

IBM ibm_torino (98.14% fidelity): Only a small degradation from the Bell state's 99.05%. IBM's processor handles the additional CNOT gate well, suggesting the qubit connectivity chosen by the transpiler minimizes SWAP overhead. The ~2% error is distributed across multiple odd-parity states, consistent with independent depolarizing noise on each gate.

QI Tuna-9: Shows more significant parity leakage (~15% into wrong-parity states on some runs). This is expected for a 9-qubit device where the additional CNOT gate accumulates more error. The parity distribution provides useful diagnostic information about correlated vs. independent errors.

The fidelity drop from Bell to GHZ is a proxy for how algorithms with deeper circuits will perform. If each additional entangling layer costs ~1-2% fidelity, this bounds the useful circuit depth for variational algorithms on these devices.

Sources & References