> ## 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.

# Run with mitigation

haiqu.run(use\_mitigation=True)

This notebook demonstrates how to use mitigation when executing your quantum circuits with `haiqu.run(use_mitigation=True)`.

Haiqu SDK can automatically apply lightweight error mitigation to both sampling and expectation value estimation tasks For an adder circuit starting at around 17.3% success probability, mitigation can boost the success probability significantly up to 85% (4.9x)

Having a bug or an issue?

Submit feedback

haiqu.run(use\_mitigation=True)

What does it do? This parameter enables quantum error mitigation when executing quantum circuits on supported devices, helping to improve the accuracy of results. How do I use it? You just need to set use\_mitigation=True when calling haiqu.run(). The mitigation process will be applied automatically if supported by the backend. What are the options? Currently there are not additional options available for error mitigation. Customizable EM pipeline options will be added in future releases. Which option do you recommend? Start with testing out error mitigation on small scale sampling tasks. Then move to mitigating expectation values of observables and more complex circuits as you gain confidence.

Initialize the example

Import the necessary libraries, initialize the Haiqu SDK, and create a quantum circuit to demonstrate error mitigation. In this example we return to using quantum adder circuit. 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("Run Job 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)
```

Execute the quantum circuit with error mitigation enabled

To run on a particular quantum device, we need to specify our credentials in the `options` parameter of the `haiqu.run()` function. We will use `fake_torino` as a device for demonstration purposes, but you can replace it with the real `ibm_torino` (or any other device) from the list obtained from using `haiqu.list_devices()` or `haiqu.list_simulators()`, as long as you have access to it.

```python theme={null}
device = haiqu.get_device("fake_torino")
options = {}

# Uncomment the following lines to run on the actual IBM Quantum device
# device = haiqu.get_device("ibm_torino")  

# options = {
#     "ibm_quantum_token": "YOUR_IBM_QUANTUM_API_KEY",  # Replace with your IBM Quantum API key
#     "ibm_quantum_instance": "YOUR_IBM_QUANTUM_INSTANCE_ID",  # Replace with your IBM Quantum instance ID if needed
# }



# Initialize scenarios
scenarios = [
    {"device": haiqu.get_device("aer_simulator"), "options": {}, "use_mitigation": False, "description": "Ideal Result"},
    {"device": device, "options": options, "use_mitigation": False, "description": f"{device.id} w/o mitigation"},
    {"device": device, "options": options, "use_mitigation": True, "description": f"{device.id} with mitigation"},
]

# Execute the quantum circuit with and without error mitigation
results = []
for scenario in scenarios:
    job = haiqu.run(
        adder,
        device=scenario["device"],
        options=scenario["options"],
        shots=8192,
        use_mitigation=scenario["use_mitigation"],
    )
    result = job.result()
    results.append({"description": scenario["description"], "probability": result[0].get(m_plus_k_binary, 0)})
```

```python theme={null}
def build_summary(results):
    """Build summary table data from experiment results."""
    baseline = results[1]["probability"]
    return {
        "Configuration": [r["description"] for r in results],
        "Success Probability": [f'{r["probability"]:.1%}' for r in results],
        "Improvement": [""] + ["Noisy Baseline"] + [f'{(results[2]["probability"]/baseline):.1f}x'],
    }

print(pd.DataFrame(build_summary(results)))
```

💡 Good to Know: It is also possible to use error mitigation for expectation value estimation tasks, as described in 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)