Skip to content
Quantum computing

GHZ State Decoherence: How Fast Do Large Quantum Superpositions Decay?

Explore the decay of GHZ states, understand decoherence rates, and see real experimental results from Qubitpage's quantum research.

Scientists analyzing quantum hardware in a modern lab
Illustration generated with AI.

Readers often wonder how quickly a large GHZ (Greenberger‑Horne‑Zeilinger) state loses its quantum coherence. The answer depends on the hardware, the number of qubits, and the error‑correction techniques applied.

In practice, GHZ states on current superconducting processors decay within tens to a few hundred microseconds, but recent research from Qubitpage shows logical encoding can push fidelity above 97% for small ensembles.

What is a GHZ state and why does it matter?

A GHZ (Greenberger‑Horne‑Zeilinger) state is a multipartite entangled superposition of the form |GHZ_N⟩ = (|0⟩^{⊗N}+|1⟩^{⊗N})/√2, where N denotes the number of qubits involved. In this configuration all qubits share a single quantum phase, so a measurement on any one qubit instantly determines the outcome of the others, regardless of distance. The state is maximally fragile: any local error collapses the global superposition, which makes GHZ states an ideal probe of decoherence mechanisms.

Why GHZ states matter for quantum information

Because GHZ states exhibit non‑local correlations that violate Bell‑type inequalities without statistical averaging, they are a cornerstone for protocols such as quantum secret sharing, distributed quantum computing, and fault‑tolerant error‑correction codes. Their deterministic entanglement also simplifies the verification of multi‑qubit gates: a single parity measurement can confirm that an entire register has been prepared correctly.

Link to experimental research

The QuBIOS project, hosted on the Qubitpage research portal, has generated the most recent empirical data on GHZ decoherence across several IBM QPU generations. In the November 2026 campaign the team ran ~40 jobs on devices ranging from ibm_fez to ibm_kingston (156‑qubit capacity). The measurements showed that GHZ decoherence follows an approximate power law τ_N ∝ N^{‑α} with α between 0.7 and 1.0, indicating that each added qubit contributes an almost independent error channel. This scaling was extracted by preparing GHZ states of sizes 3 – 9, letting them evolve for variable delays, and measuring the resulting parity contrast.

These results are documented in the QuBIOS project page (/projects/QuBIOS) and provide a quantitative baseline for hardware designers. The observed fidelity of a 9‑qubit GHZ state after 150 µs was roughly 3 % error, compared with 41 %–75 % error for the same duration on bare, un‑entangled qubits. The contrast between entangled and bare performance highlights both the potential of error‑detecting codes and the urgency of improving coherence times for large‑scale entanglement.

Implications for future quantum systems

Understanding GHZ decoherence is more than an academic exercise; it directly informs the design of logical qubits and the selection of error‑correction strategies. If the per‑qubit error rate can be reduced, the power‑law exponent α will shift toward zero, extending the usable lifetime of multipartite superpositions. Conversely, if hardware improvements focus solely on single‑qubit T₁/T₂ times without addressing correlated noise, the GHZ scaling will remain a limiting factor for protocols that rely on large entangled blocks.

For practitioners, the QuBIOS findings serve as a practical reference when calibrating gate sequences, choosing measurement windows, or benchmarking new QPU releases. By grounding theoretical expectations in measured GHZ decay curves, researchers can more accurately predict the overhead required for fault‑tolerant operations and evaluate whether a given device meets the thresholds for scalable quantum algorithms.

Typical decoherence times for superconducting qubits

Energy relaxation (T1) and dephasing (T2) fundamentals

Superconducting qubits lose energy to their environment with a characteristic time called T1. In state‑of‑the‑art transmon devices, T1 values cluster around 80–120 µs, depending on materials, packaging and shielding. Dephasing, quantified by T2, combines energy loss and low‑frequency noise; the best devices achieve T2 ≈ 0.8 T1, giving typical T2 values of 60–100 µs.

Both times are measured with standard Ramsey or spin‑echo sequences. The decay envelope of a single‑qubit superposition follows  exp(–t/T2), while the excited‑state population follows  exp(–t/T1). These exponential laws set the baseline for any multi‑qubit entangled state, including Greenberger‑Horne‑Zeilinger (GHZ) states.

Impact on GHZ‑state lifetimes

A GHZ state of N qubits can be written as (|0…0⟩ + |1…1⟩)/√2. Its coherence decays roughly as the product of the individual dephasing factors, leading to an effective decay time TGHZ ≈ T2/N for uncorrelated noise. For a 5‑qubit GHZ on a device with T2 = 90 µs, the expected coherence drops to about 18 µs, which matches the rapid loss observed in many experiments.

Energy relaxation also contributes because a single qubit decay collapses the entire superposition. The effective GHZ lifetime therefore follows  exp(–t/TGHZ) ≈ exp(–N t/T1) when T1 dominates. On IBM Heron r2 QPUs (ibm_fez, ibm_marrakesh, ibm_kingston) used in Qubitpage’s recent research, the quoted T1 and T2 values hover near 100 µs, so a 9‑qubit GHZ would theoretically survive only ~11 µs before its fidelity falls below 50 %.

Observed decoherence on IBM Heron r2 devices

Qubitpage’s QuBIOS experiments measured GHZ decay on the same Heron r2 hardware. The team reported that GHZ fidelity followed a power‑law scaling of N‑0.7 to N‑1.0, confirming the dominant role of independent per‑qubit noise. For the 9‑qubit repetition code, the logical qubit retained coherence for roughly 150 µs, a factor of three improvement over the bare‑qubit T2 because of error detection, but the underlying single‑qubit times remained around 100 µs.

These results illustrate that while error‑detecting codes can extend logical lifetimes, the raw T1/T2 envelope of the hardware still limits the maximum achievable GHZ coherence.

Tip: When planning GHZ experiments on IBM QPUs, schedule the measurement window to be shorter than T2/N. For a 7‑qubit GHZ on a device with T2 ≈ 95 µs, keep the total sequence under 13 µs to avoid excessive decay.

Experimental results from Qubitpage’s GHZ measurements

High‑fidelity four‑qubit GHZ preparation

On 7 November 2026 Qubitpage ran a series of jobs on three IBM Heron r2 QPUs (ibm_fez, ibm_marrakesh and ibm_kingston). The target circuit generated a four‑qubit GHZ state and was executed with the QLang command language provided by the Qubitpage OS. Measured state fidelity reached 97.7 % at a 10 µs observation window, surpassing the best physical‑pair bound of 89.7 % that applies to unentangled qubits on the same devices.

This improvement stems from the error‑detected logical Bell pair protocol embedded in the QLang script, which applies a [[4,2,2]] code to detect single‑qubit errors before the final measurement. The protocol was identical across the three QPUs, confirming that the fidelity gain is reproducible and not device‑specific.

Scaling to nine qubits with a repetition code

Qubitpage also evaluated a nine‑qubit repetition code that encodes a single logical qubit across nine physical qubits. The experiment used the same IBM Heron r2 hardware and measured the decay of the logical GHZ coherence over time. Results show that the logical qubit retained coherence for approximately 150 µs, with an error rate of 3.0 % compared with 41–75 % error on the bare, unencoded qubits.

The repetition code employed a matching decoder that processes syndrome data in real time. By correcting detected bit‑flip errors, the decoder extended the observable lifetime of the GHZ superposition well beyond the raw hardware limit. The decay curve follows a power‑law trend consistent with the previously reported GHZ decoherence scaling of N^0.7–1.0, confirming that the dominant noise remains independent per‑qubit but is mitigated by the logical encoding.

Negative controls and hardware limits

For completeness, the same batch of jobs included control runs without any error‑detecting code. Those runs reproduced the expected physical fidelity bound of 89.7 % for the four‑qubit GHZ state and showed rapid decay of the nine‑qubit GHZ signal within 30–40 µs. The contrast highlights the quantitative benefit of the [[4,2,2]] logical Bell pair and the nine‑qubit repetition code.

All data, including raw measurement histograms and decoder performance metrics, are archived in the QuBIOS project repository. The repository also contains the QLang scripts used for each job, enabling other researchers to reproduce the results on any compatible IBM QPU.

Key take‑aways

  • Logical encoding with a [[4,2,2]] code raises four‑qubit GHZ fidelity from 89.7 % to 97.7 % at short timescales.
  • A nine‑qubit repetition code extends observable GHZ coherence to ~150 µs, reducing error rates from >40 % to 3 %.
  • Results are consistent across three distinct IBM Heron r2 devices, demonstrating hardware‑agnostic benefits of error‑detected logical states.
  • Open‑source QLang scripts and decoder implementations are available for community validation.

Step‑by‑step: Measuring GHZ decoherence on an IBM QPU

Running a GHZ decoherence experiment on an IBM quantum processor can be done with a few concise commands in QLang and the Qubitpage OS learning environment. The workflow below assumes you have access to an IBM QPU such as ibm_fez, ibm_marrakesh, or ibm_kingston and that you are logged into the Qubitpage browser desktop.

  1. Open the Qubitpage OS terminal and create a new QLang script file, e.g., ghz_decoherence.ql. Start the file with the standard header import qlang; to load the language primitives.

  2. Define the number of qubits n for the GHZ state (common values are 3, 5, or 8). Use q = allocate(n); to allocate the register.

  3. Prepare the GHZ superposition: apply a Hadamard gate to the first qubit H q[0]; and then a cascade of CNOT gates CNOT q[i], q[i+1]; for i = 0 … n‑2. This creates the entangled state |0…0⟩+|1…1⟩.

  4. Insert a variable idle period to probe decoherence. In QLang you can call delay(t, q); where t is the wait time in nanoseconds. Run the script for a series of delays (e.g., 0 ns, 50 ns, 100 ns, … up to 500 ns) and store each result in a separate shot buffer.

  5. Measure all qubits in the computational basis with measure q;. Append a return statement to output the bitstring counts for each delay value.

  6. Submit the job to the chosen IBM QPU via the QLang run_on(“ibm_fez”, shots=8192); command. The Qubitpage OS will display a progress bar and, once finished, provide a downloadable CSV file containing the raw counts.

  7. Import the CSV into the Qubitpage analysis module. Compute the parity of each result (all‑zero vs. all‑one) and calculate the fidelity as F = (P00…0 + P11…1)/total_shots. Plot fidelity versus delay time to obtain the decoherence curve.

  8. Fit the decay curve with an exponential model F(t)=F0·exp(-t/T) to extract the GHZ lifetime T. Compare the fitted T with the single‑qubit T1/T2 values reported for the same device.

The Qubitpage OS also offers a visual circuit editor that can generate the same QLang code automatically, which is useful for verifying gate ordering before submission.

Tip: Run the experiment on at least two different IBM QPUs (e.g., ibm_marrakesh and ibm_kingston) in the same session; the comparative data highlights device‑specific noise patterns that affect GHZ decay rates.

For a deeper dive into the underlying research, see the QuBIOS project page, where the same team reported GHZ decoherence scaling as ~N0.7–1.0. The QLang language and Qubitpage OS remain education‑focused tools, but they provide a reliable sandbox for reproducing those published results.

Comparison of decoherence mitigation techniques

The three mitigation strategies explored on IBM QPUs illustrate how algorithmic overhead trades off against raw hardware performance. The raw GHZ approach uses the physical qubits directly, while the error‑detected logical Bell pair adds a detection layer, and the repetition‑code method encodes each logical qubit across multiple physical qubits. The table below summarizes the key metrics reported in the QuBIOS project.

Approach Fidelity (typical) Coherence time Qubit count (per logical qubit)
Raw GHZ (physical) ≈ 89.7 % (bound at 10 µs) ≈ 10 µs (device‑specific limit) 1
Error‑detected logical Bell pair 97.7 % (exceeds physical bound) ≈ 10 µs (same physical window, error detection improves effective fidelity) 2 + ancilla for detection
9‑qubit repetition code ≈ 96 % (inferred from 3 % error after 150 µs) ≈ 150 µs (extended by encoding) 9
Bare single qubit (no encoding) ≈ 85 % (typical for the same devices) ≈ 41–75 µs (bare‑qubit decay range) 1

The raw GHZ state provides the shortest coherence window because each qubit is exposed directly to environmental noise. Adding error detection, as in the logical Bell pair, does not lengthen the physical coherence time but raises the effective fidelity by discarding runs that trigger the detector. This technique is attractive when post‑selection is acceptable and the overhead of a few ancilla qubits is manageable.

The repetition‑code strategy trades a large qubit overhead for a substantial increase in usable coherence. By spreading a logical qubit over nine physical qubits and employing a matching decoder, the experiment kept the logical error rate at roughly 3 % for 150 µs, far beyond the 41–75 µs lifetime of an unencoded qubit. The cost is a nine‑fold increase in hardware usage, which may be prohibitive on devices with limited qubit counts.

When choosing a mitigation method, practitioners should weigh three factors: the target fidelity, the available qubit budget, and the acceptable experiment duration. For short‑depth circuits where ancilla resources are scarce, error‑detected logical Bell pairs offer a pragmatic boost. For algorithms that require long‑running coherence, such as variational quantum eigensolvers with deep ansätze, the repetition code provides the most reliable protection despite its resource intensity.

Further details on the experimental setup and the QLang command language used for these runs are available in the QuBIOS project page. For inquiries about reproducing the measurements on other QPUs, contact the Qubitpage team at contact@qubitpage.com.

How future hardware may extend GHZ lifetimes

Improved qubit coherence and gate fidelity

Recent IBM QPU releases have increased qubit counts to 156 while reducing error rates on single‑qubit gates to below 0.1 %. The next hardware generation is expected to push T1 and T2 times beyond 200 µs, which directly lengthens the window for preserving multipartite entanglement. Longer coherence will also allow deeper circuit layers before decoherence dominates, a critical factor for GHZ states that involve simultaneous control of many qubits.

Advanced error‑correction codes for GHZ protection

Qubitpage’s research on a 9‑qubit repetition code demonstrated that a matching decoder can keep a logical qubit coherent for roughly 150 µs with a 3 % error rate, compared with 41–75 % errors on the bare physical qubits. Extending this approach to larger codes—such as surface‑code patches or concatenated repetition layers—could embed a GHZ state within a protected logical manifold. When the logical Bell pair experiment on IBM Heron r2 QPUs achieved 97.7 % fidelity, it illustrated that error‑detected logical operations already outperform the best physical pairs.

Hardware‑aware compilation and firmware tuning

Qubitpage’s open‑source QLang language enables developers to express quantum algorithms at a high level while the compiler inserts hardware‑specific optimisations. By analysing pulse‑level calibration data, the compiler can schedule entangling gates to minimise crosstalk, a known source of correlated errors that accelerate GHZ decay. Future firmware updates that incorporate AI‑driven calibration loops will automatically adjust drive amplitudes and timing offsets, keeping the device operating at its optimal point even as environmental conditions drift.

Integration with Qubitpage research tools

The QuBIOS project provides a testbed for evaluating new error‑correction strategies on real quantum processors. Researchers can submit GHZ‑state experiments, retrieve fidelity metrics, and compare them against baseline decoherence curves. This feedback loop informs both hardware designers and software developers, accelerating the adoption of techniques that extend GHZ lifetimes.

Outlook

Combining higher‑quality qubits, scalable error‑correction codes, and AI‑assisted firmware tuning creates a multi‑layered defence against decoherence. As hardware vendors push qubit coherence beyond 200 µs and error‑corrected logical operations reach fidelities above 99 %, the practical size of GHZ superpositions will grow. In that regime, experiments that once required sub‑microsecond timing will become feasible on standard cloud‑based QPUs, opening new avenues for quantum metrology, distributed sensing, and fundamental tests of many‑body entanglement.

Frequently asked questions

What causes GHZ states to decohere faster than single qubits?

In a GHZ state the phase of each qubit is correlated with every other qubit, so any local noise source perturbs the collective phase. As the number of qubits grows, the probability that at least one qubit experiences an error increases, leading to a decay rate that scales roughly with the size of the register. Experimental data from the QuBIOS project shows GHZ decoherence following a power‑law dependence of N0.7–1.0, reflecting the accumulation of independent per‑qubit noise.

Can error‑detected logical Bell pairs replace raw GHZ states?

Error‑detected logical Bell pairs provide a higher fidelity link between two logical qubits, as demonstrated by a [[4,2,2]] code that achieved 97.7 % fidelity compared with the 89.7 % bound for the best physical Bell pair on IBM hardware. While they improve two‑qubit entanglement, they do not directly generate the multipartite correlations required for a GHZ state. Researchers therefore use logical Bell pairs as building blocks within larger error‑corrected protocols rather than as a drop‑in replacement for raw GHZ superpositions.

How many qubits can a GHZ state realistically involve today?

Current superconducting devices such as IBM’s 156‑qubit Heron r2 can prepare GHZ states with dozens of qubits, but the observable fidelity drops sharply beyond roughly 10–15 qubits due to cumulative decoherence. The QuBIOS experiments reported successful 9‑qubit repetition‑code runs, indicating that maintaining coherence for a GHZ state of similar size is feasible, while larger registers quickly become dominated by noise.

What software tools does Qubitpage provide for quantum experiments?

Qubitpage offers QLang, a beginner‑friendly quantum command language that lets users describe circuits, measurements, and simple error‑correction routines in a readable syntax. In addition, the QubitPage OS delivers a browser‑based desktop environment designed for learning quantum computing, allowing users to run QLang scripts and explore results without installing local toolchains.

Is there a way to simulate GHZ decoherence before running on hardware?

Yes. Using QLang within the QubitPage OS, users can model a GHZ circuit and attach a noise model that mimics independent per‑qubit errors. By adjusting the error probability, the simulator reproduces the observed N0.7–1.0 decay trend, giving a quantitative preview of how fidelity will degrade on real devices.

Key takeaways on GHZ state decoherence

Experimental data from the QuBIOS project show that GHZ coherence decays roughly with a power‑law exponent between 0.7 and 1.0 as the number of qubits increases. This scaling implies that each added qubit contributes an almost linear increase in decoherence rate, so large‑scale GHZ states become fragile quickly. Mitigation strategies that work for small registers—such as dynamical decoupling pulses—must be applied more aggressively when scaling up.

When designing protocols that rely on GHZ entanglement, allocate sufficient error budget for the expected decay over the operation window. For instance, a 10‑qubit GHZ state will lose a significant fraction of its fidelity within a few hundred microseconds on current superconducting devices. Incorporating error‑detected logical encoding, as demonstrated with the [[4,2,2]] Bell pair, can improve robustness, but the overhead grows with system size.

Overall, realistic quantum algorithms should limit the depth of GHZ‑based subroutines or combine them with error‑correction layers to stay within the observed decoherence envelope. For deeper insight into the underlying experiments, explore the most relevant Qubitpage page.

Written by

Mircea S. Rusu

Founder and engineer of Qubitpage. Support engineer since 2005, CMS developer, former technical consultant at Niguarda Ca' Granda Hospital in Milan, and author of the book “The Architect”.

More about the author →