Skip to main content
haiqu.state_compression() Use haiqu.state_compression() to compress quantum circuits and improve performance on noisy quantum hardware. For a 10-qubit adder circuit, state compression increases the likelihood of measuring the correct result from 7.7% to 88.8% (11.5x improvement). Combining state compression with noise mitigation delivers 99.7% success (13.0x improvement). Having a bug or an issue? Submit feedback haiqu.state_compression() What does it do? State compression shortens quantum circuits, improving performance on noisy quantum hardware. How do I use it? Pass a quantum circuit to haiqu.state_compression() to create a compression job, then retrieve results with job.result(). What are the options? Optional parameters include compression_level, fine_tuning, noise_profile, and approximation_level for advanced configuration. Which option do you recommend? Start with the default settings for most use cases. For parameter-specific exploration, see dedicated notebooks for compression_level and fine_tuning. Initialize the benchmark Import the necessary libraries, initialize the Haiqu SDK, and create an adder circuit to demonstrate state compression. The adder circuit adds two integers m and k. 
import qiskit
import numpy as np
import pandas as pd
from qiskit.circuit.library import QFT
from haiqu.sdk import haiqu

haiqu.login()
haiqu.init("State Compression Tutorial")

def build_adder_circuit(num_qubits, m, k):
    """
    Builds a quantum circuit that adds integer k to m using the QFT.
    
    Parameters:
    - num_qubits (int): Number of qubits.
    - m (int): Initial value.
    - k (int): Value to add.
    
    Returns:
    - QuantumCircuit implementing |m⟩ -> |m + k⟩ with measurement.
    - Binary strings for m and m+k (for verification).
    """
    m_binary = f"{m:0{num_qubits}b}"
    m_plus_k_binary = f"{m + k:0{num_qubits}b}"
    adder = qiskit.QuantumCircuit(num_qubits)
    for i in range(num_qubits):
        if m_binary[i] == "1":
            adder.x(num_qubits - 1 - i)
    adder.compose(QFT(num_qubits), inplace=True)
    for i in range(num_qubits):
        adder.rz(k * np.pi / 2 ** i, num_qubits - i - 1)
    adder.compose(QFT(num_qubits).inverse(), inplace=True)
    adder.measure_all()
    return adder, m_binary, m_plus_k_binary

adder, m_binary, m_plus_k_binary = build_adder_circuit(num_qubits=10, m=343, k=19)
haiqu.draw(adder)
Run benchmark scenarios Run experiments comparing original circuit, compressed circuit, and compressed circuit with mitigation on a noisy device: 
# Initialize scenarios.
scenarios = [
    {"compression": False, "mitigation": False, "description": "Original Circuit"},
    {"compression": True,  "mitigation": False, "description": "With Compression"},
    {"compression": True,  "mitigation": True,  "description": "With Compression + Mitigation"}
]
# Loop over scenarios and initialize results.
results = []
for scenario in scenarios:

    # Get circuit.
    circuit = adder

    # Apply state compression to circuit if requested.
    if scenario["compression"]:
        job_h = haiqu.state_compression(circuit=circuit)
        circuit, quality = job_h.result()
    
    # Run circuit on noisy device with optional mitigation.
    res = haiqu.run(circuit, shots=1000, device_id="fake_montreal", use_mitigation=scenario["mitigation"]).result()[0]
    prob = res.get(m_plus_k_binary, 0)
    
    # Store results for summary table.
    results.append({"probability": prob, "description": scenario["description"]})
State compression significantly improves circuit performance on noisy devices. Summary of results: 
def build_summary(results):
    """Build summary table data from experiment results."""
    baseline = results[0]["probability"]
    return {
        'Configuration': [r["description"] for r in results],
        'Success Probability': [f'{r["probability"]:.1%}' for r in results],
        'Improvement': ['Baseline'] + [f'{(r["probability"]/baseline):.1f}x' for r in results[1:]],
        'Business Impact': [
            'Low success rate on noisy hardware',
            'Significant improvement enables practical quantum algorithms',
            'Near-perfect results make production deployment viable',
        ]
    }

pd.DataFrame(build_summary(results))
💡 Good to Know: Compression techniques can be combined with noise mitigation techniques. Get in Touch Documentation portal docs.haiqu.ai Contact Support feedback.haiqu.ai Follow Us on LinkedIn latest news on LinkedIn Visit Our Website Learn more about Haiqu Inc. on haiqu.ai Business Inquiries Contact us at info@haiqu.ai