Run with mitigation - Haiqu Documentation

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.

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.

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)})

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

API Reference