GHZ State
Create multi-qubit entanglement at scale - the Greenberger-Horne-Zeilinger state.
Overview
The GHZ (Greenberger–Horne–Zeilinger) state is a maximally entangled state of N qubits:
|GHZₙ⟩ = (1/√2)(|00...0⟩ + |11...1⟩)
This example demonstrates:
- Scaling entanglement to many qubits
- Circuit depth optimization
- Benchmarking quantum backends
The Circuit (5 qubits)
┌───┐ ┌─┐
q_0: ┤ H ├──■─────────────────┤M├────────────
└───┘┌─┴─┐ └╥┘┌─┐
q_1: ─────┤ X ├──■─────────────╫─┤M├─────────
└───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├──■────────╫──╫─┤M├──────
└───┘┌─┴─┐ ║ ║ └╥┘┌─┐
q_3: ───────────────┤ X ├──■───╫──╫──╫─┤M├───
└───┘┌─┴─┐ ║ ║ ║ └╥┘┌─┐
q_4: ────────────────────┤ X ├─╫──╫──╫──╫─┤M├
└───┘ ║ ║ ║ ║ └╥┘
c: 5/══════════════════════════╩══╩══╩══╩══╩═
0 1 2 3 4
Code
"""
GHZ State - Multi-Qubit Entanglement
====================================
Creates GHZ states with configurable number of qubits.
Demonstrates scaling, optimization, and quality metrics.
"""
from softqcos_sdk import QCOSClient
import time
def create_ghz_circuit(n_qubits: int) -> str:
"""Generate OpenQASM for N-qubit GHZ state."""
lines = [
'OPENQASM 2.0;',
'include "qelib1.inc";',
f'qreg q[{n_qubits}];',
f'creg c[{n_qubits}];',
'',
'// Create GHZ state',
'h q[0]; // Superposition on first qubit',
]
# Chain of CNOT gates
for i in range(n_qubits - 1):
lines.append(f'cx q[{i}], q[{i+1}]; // Entangle qubit {i} with {i+1}')
lines.append('')
lines.append('// Measure all qubits')
lines.append('measure q -> c;')
return '\n'.join(lines)
def analyze_ghz_results(counts: dict, n_qubits: int) -> dict:
"""Analyze GHZ state quality metrics."""
all_zeros = "0" * n_qubits
all_ones = "1" * n_qubits
total_shots = sum(counts.values())
count_zeros = counts.get(all_zeros, 0)
count_ones = counts.get(all_ones, 0)
# Calculate metrics
valid_counts = count_zeros + count_ones
error_counts = total_shots - valid_counts
metrics = {
"n_qubits": n_qubits,
"total_shots": total_shots,
"valid_states": valid_counts,
"error_states": error_counts,
"count_all_zeros": count_zeros,
"count_all_ones": count_ones,
"fidelity": valid_counts / total_shots,
"balance": min(count_zeros, count_ones) / max(count_zeros, count_ones) if min(count_zeros, count_ones) > 0 else 0,
"error_rate": error_counts / total_shots,
}
return metrics
def run_ghz_experiment(n_qubits: int, shots: int = 2048):
"""Run a complete GHZ state experiment."""
client = QCOSClient()
print(f"\n🔗 GHZ-{n_qubits} State Experiment")
print("=" * 60)
# Generate circuit
circuit = create_ghz_circuit(n_qubits)
print(f"\n📝 Circuit Properties:")
print(f" Qubits: {n_qubits}")
print(f" Depth: {n_qubits}") # H + (n-1) CNOTs + measure
print(f" Gates: 1 H + {n_qubits - 1} CNOTs")
# Execute
print(f"\n⏳ Executing with {shots} shots...")
start_time = time.time()
result = client.execute(qasm=circuit, shots=shots)
execution_time = time.time() - start_time
print(f" Completed in {execution_time:.2f}s")
# Analyze
metrics = analyze_ghz_results(result.counts, n_qubits)
# Display results
print(f"\n📊 Results:")
print("-" * 40)
all_zeros = "0" * n_qubits
all_ones = "1" * n_qubits
for state, count in sorted(result.counts.items(), key=lambda x: -x[1]):
percentage = (count / shots) * 100
bar = "█" * int(percentage / 2)
if state == all_zeros:
label = f"|{'0'*n_qubits}⟩ ✓"
elif state == all_ones:
label = f"|{'1'*n_qubits}⟩ ✓"
else:
label = f"|{state}⟩ ✗"
if percentage > 0.5: # Only show significant states
print(f" {label}: {count:5d} ({percentage:5.1f}%) {bar}")
# Quality report
print(f"\n📈 Quality Metrics:")
print(f" Fidelity: {metrics['fidelity']:.1%}")
print(f" State balance: {metrics['balance']:.1%}")
print(f" Error rate: {metrics['error_rate']:.1%}")
if metrics['fidelity'] > 0.95:
print("\n🎉 Excellent GHZ state quality!")
elif metrics['fidelity'] > 0.85:
print("\n✅ Good GHZ state quality")
elif metrics['fidelity'] > 0.70:
print("\n⚠️ Moderate quality - consider optimization")
else:
print("\n❌ Poor quality - optimization recommended")
return result, metrics
def benchmark_ghz_scaling():
"""Benchmark GHZ state creation across different sizes."""
print("\n" + "=" * 70)
print("📊 GHZ State Scaling Benchmark")
print("=" * 70)
client = QCOSClient()
results = []
for n in [2, 3, 4, 5, 6, 8, 10]:
circuit = create_ghz_circuit(n)
start = time.time()
result = client.execute(qasm=circuit, shots=1024)
elapsed = time.time() - start
metrics = analyze_ghz_results(result.counts, n)
metrics['execution_time'] = elapsed
results.append(metrics)
print(f" GHZ-{n:2d}: Fidelity={metrics['fidelity']:.1%}, Time={elapsed:.2f}s")
print("\n📉 Summary Table:")
print("-" * 60)
print(f"{'Qubits':<8} {'Fidelity':<12} {'Error Rate':<12} {'Time (s)':<10}")
print("-" * 60)
for m in results:
print(f"{m['n_qubits']:<8} {m['fidelity']:<12.1%} {m['error_rate']:<12.1%} {m['execution_time']:<10.2f}")
return results
def main():
# Single experiment
result, metrics = run_ghz_experiment(n_qubits=5, shots=2048)
# Uncomment for scaling benchmark:
# benchmark_ghz_scaling()
return result
if __name__ == "__main__":
main()
Expected Output
🔗 GHZ-5 State Experiment
============================================================
📝 Circuit Properties:
Qubits: 5
Depth: 5
Gates: 1 H + 4 CNOTs
⏳ Executing with 2048 shots...
Completed in 0.45s
📊 Results:
----------------------------------------
|00000⟩ ✓: 1034 ( 50.5%) █████████████████████████
|11111⟩ ✓: 1014 ( 49.5%) ████████████████████████
📈 Quality Metrics:
Fidelity: 100.0%
State balance: 98.1%
Error rate: 0.0%
🎉 Excellent GHZ state quality!
Optimized GHZ Circuit
The standard GHZ circuit has linear depth O(n). For better hardware performance, use logarithmic-depth optimization:
"""Logarithmic-depth GHZ state preparation."""
from softqcos_sdk import QCOSClient
import math
def create_ghz_log_depth(n_qubits: int) -> str:
"""Create GHZ state with O(log n) depth using parallel CNOTs."""
lines = [
'OPENQASM 2.0;',
'include "qelib1.inc";',
f'qreg q[{n_qubits}];',
f'creg c[{n_qubits}];',
'',
'// Log-depth GHZ preparation',
'h q[0];',
]
# Parallel CNOT cascade
step = 1
while step < n_qubits:
lines.append(f'// Layer {int(math.log2(step)) + 1}')
for i in range(0, n_qubits - step, step * 2):
if i + step < n_qubits:
lines.append(f'cx q[{i}], q[{i + step}];')
step *= 2
lines.append('measure q -> c;')
return '\n'.join(lines)
# Compare depths
standard_ghz = create_ghz_circuit(8)
optimized_ghz = create_ghz_log_depth(8)
print(f"Standard GHZ-8 depth: 8 (linear)")
print(f"Optimized GHZ-8 depth: 3 (logarithmic)")
# Execute both and compare
client = QCOSClient()
standard_result = client.execute(qasm=standard_ghz, shots=1024)
optimized_result = client.execute(qasm=optimized_ghz, shots=1024)
print(f"\nStandard: {standard_result.counts}")
print(f"Optimized: {optimized_result.counts}")
Running on Real Quantum Hardware
"""Execute GHZ state on Azure Quantum."""
from softqcos_sdk import QCOSClient
client = QCOSClient()
# Create circuit
circuit = create_ghz_circuit(5)
# Estimate cost first
estimate = client.azure_quantum.estimate_cost(
circuit=circuit,
target="ionq.aria",
shots=100 # Fewer shots for QPU
)
print(f"Estimated cost: €{estimate.cost_eur:.2f}")
print(f"Estimated time: {estimate.time_seconds}s")
# Execute on real hardware
if estimate.cost_eur < 10.0: # Budget check
result = client.azure_quantum.execute(
circuit=circuit,
target="ionq.aria",
shots=100
)
metrics = analyze_ghz_results(result.counts, 5)
print(f"\n🔬 Real QPU Results:")
print(f" Fidelity: {metrics['fidelity']:.1%}")
print(f" This is expected to be lower than simulator due to noise")
Use Cases
Quantum Error Correction Benchmarking
GHZ states are used to benchmark error rates in quantum hardware:
def benchmark_hardware_errors(backend: str, n_qubits: int):
"""Use GHZ state to estimate hardware error rate."""
client = QCOSClient()
circuit = create_ghz_circuit(n_qubits)
result = client.execute(qasm=circuit, backend=backend, shots=4096)
metrics = analyze_ghz_results(result.counts, n_qubits)
# Error per gate estimate
n_cnots = n_qubits - 1
error_per_gate = 1 - (metrics['fidelity'] ** (1 / n_cnots))
print(f"Backend: {backend}")
print(f"Total fidelity: {metrics['fidelity']:.1%}")
print(f"Estimated error per CNOT: {error_per_gate:.2%}")
return error_per_gate
Quantum Networking
GHZ states are foundational for quantum networks and distributed quantum computing:
# Multi-party entanglement for quantum secret sharing
ghz_3 = create_ghz_circuit(3) # Three parties: Alice, Bob, Charlie
Next Steps
- Quantum Teleportation - Use entanglement for quantum communication
- VQE Chemistry - Apply quantum computing to real problems
- Azure Quantum - Run on real quantum hardware