> ## Documentation Index
> Fetch the complete documentation index at: https://docs.haiqu.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# State compression

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.

```python theme={null}
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:

```python theme={null}
# 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:

```python theme={null}
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](https://docs.haiqu.ai)

Contact Support [feedback.haiqu.ai](https://feedback.haiqu.ai)

Follow Us on LinkedIn latest news on [LinkedIn](https://www.linkedin.com/company/haiquai/)

Visit Our Website Learn more about Haiqu Inc. on [haiqu.ai](https://haiqu.ai)

Business Inquiries Contact us at [info@haiqu.ai](mailto:info@haiqu.ai)