Note

Cette page a été générée à partir de tutorials/noise/7_accreditation.ipynb.

Exécuter en mode interactif dans le ` IBM Quantum lab <https://quantum-computing.ibm.com/jupyter/tutorial/noise/7_accreditation.ipynb>` _.

Protocole d’accréditation

Le protocole d’accréditation (AP) est un protocole conçu pour caractériser la fiabilité des machines quantiques bruitées.

Etant donné un ordinateur quantique bruité mettant en œuvre un circuit quantique « cible », AP (Protocole d’Accréditation) certifie une borne supérieure sur l’amplitude de la variation entre la distribution de probabilité des sorties retournées par le dispositif et la distribution de probabilité idéale. Cette méthode est basée sur Ferracin et al, « Accreditting outputs of noisy intermédiaire-scale quantum devices », https://arxiv.org/abs/1811.09709.

Ce bloc-notes donne un exemple d’utilisation du module ignis.characterization.accréditation. Cet exemple particulier montre comment accréditer les sorties d’un circuit quantique 4-qubit de profondeur 5. Tous les circuits sont exécutés à l’aide du simulateur d’Aer en utilisant un modèle de bruit.

#Import general libraries (needed for functions)
import numpy as np
from numpy import random
import qiskit

#Import Qiskit classes
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error

#Import the accreditation functions.
from qiskit.ignis.verification.accreditation import AccreditationFitter,AccreditationCircuits

Entrée du protocole

AP can accredit the outputs of a target circuit that 1) Takes as input \(n\) qubits in the state \(|{0}>\) 2) Ends with single-qubit measurements in the Pauli-\(Z\) basis 3) Is made of \(m\) “bands”, each band containing a round of single-qubit gates and a round of controlled-\(Z\) gates. The accreditation is made by employing trap circuits, circuits that can be efficiently simulated on a classical computer and that whose outputs are used to witness the correct functionality of the device.

Let’s now draw a target quantum circuit! We start with a simple circuit to generate and measure 4-qubits GHZ states.

# Create a Quantum Register with n_qb qubits.
q_reg = QuantumRegister(4, 'q')
# Create a Classical Register with n_qb bits.
c_reg = ClassicalRegister(4, 's')
# Create a Quantum Circuit acting on the q register
target_circuit = QuantumCircuit(q_reg, c_reg)

target_circuit.h(0)
target_circuit.h(1)
target_circuit.h(2)
target_circuit.h(3)
target_circuit.cz(0,1)
target_circuit.cz(0,2)
target_circuit.h(1)
target_circuit.h(2)
target_circuit.cz(0,3)
target_circuit.cz(1,2)
target_circuit.h(1)
target_circuit.h(2)
target_circuit.h(3)

target_circuit.measure(q_reg, c_reg)

target_circuit.draw(output = 'mpl')

Génération de circuits d’accréditation

La fonction \(accreditation\_circuits\) génère tous les circuits nécessaires à l’AP, cible et pièges. Il ajoute automatiquement les portes de Pauli aléatoires aux circuits (si l’implémentation est bruyante, ces portes Pauli aléatoires réduisent le bruit aux erreurs de Pauli !)

Il renvoie également la liste :math:` postp_list ` des chaînes requises pour le post-traitement des sorties, ainsi que le nombre \(v\_zero\) indiquant le circuit d’exécution de la cible.

Ceci est le circuit cible avec les portes Pauli choisies aléatoirement:

accsys = AccreditationCircuits(target_circuit)

v = 10

circ_list, postp_list, v_zero = accsys.generate_circuits(v)
circ_list[(v_zero)%(v+1)].draw(output = 'mpl')

Voici à quoi ressemble un « trap circuit » :

circ_list[(v_zero+1)%(v+1)].draw(output = 'mpl')

On peut utiliser l’argument optionnel twoqubitgate pour choisir entre l’utilisation de portes cx au lieu de portes cz, on peut aussi changer arbitrairement la carte de couplage, afin de compiler conformément à la topologie de l’appareil désiré (ce qui, dans ce cas, peut conduire à augmenter le nombre de couches).

accsys.target_circuit(target_circuit, two_qubit_gate='cx', coupling_map=[[0,1],[1,2],[2,3]] )

v = 10

circ_list, postp_list, v_zero = accsys.generate_circuits(v)
circ_list[(v_zero)%(v+1)].draw(output = 'mpl')

Simulation de circuits idéaux

Let’s implement AP.

Nous utilisons :math:` accreditation_circuits ` pour générer des circuits cible et des circuits de trap. Ensuite, nous utilisons la fonction :math:` single_protocol_run ` pour implémenter tous ces circuits, en gardant la sortie de la cible uniquement si tous les trap renvoient la sortie correcte.

simulator = qiskit.Aer.get_backend('qasm_simulator')

test_1 = AccreditationFitter()

# Create target and trap circuits with random Pauli gates
accsys = AccreditationCircuits(target_circuit)
circuit_list, postp_list, v_zero = accsys.generate_circuits(v)


job = execute(circuit_list,
              simulator,
              shots=1)
result = job.result()
# Post-process the outputs and see if the protocol accepts
test_1.single_protocol_run(result, postp_list, v_zero)

print("Outputs of the target: ",test_1.outputs," , AP",test_1.flag,"these outputs!")

Outputs of the target:  ['0100']  , AP accepted these outputs!

En l’absence de bruit, tous les trap renvoient la sortie attendue, donc nous acceptons toujours la sortie de la cible.

Pour obtenir une borne supérieure sur l’amplitude de la variation sur les sorties du circuit cible, nous devons implémenter l’AP \(d\) fois, chaque fois avec v circuits de trap différents.

# Number of runs
d = 20

test_2 = AccreditationFitter()

for run in range(d):

    # Create target and trap circuits with random Pauli gates
    circuit_list, postp_list, v_zero = accsys.generate_circuits(v)


    # Implement all these circuits

    job = execute(circuit_list,
                  simulator,
                  shots=1)
    result = job.result()

    # Post-process the outputs and see if the protocol accepts
    test_2.single_protocol_run(result, postp_list, v_zero)
    print("Protocol run number",run+1,", outputs of the target",test_2.flag)

print('\nAfter',test_2.num_runs,'runs, AP has accepted',test_2.N_acc,'outputs!')

print('\nList of accepted outputs:\n', test_2.outputs)

Protocol run number 1 , outputs of the target accepted
Protocol run number 2 , outputs of the target accepted
Protocol run number 3 , outputs of the target accepted
Protocol run number 4 , outputs of the target accepted
Protocol run number 5 , outputs of the target accepted
Protocol run number 6 , outputs of the target accepted
Protocol run number 7 , outputs of the target accepted
Protocol run number 8 , outputs of the target accepted
Protocol run number 9 , outputs of the target accepted
Protocol run number 10 , outputs of the target accepted
Protocol run number 11 , outputs of the target accepted
Protocol run number 12 , outputs of the target accepted
Protocol run number 13 , outputs of the target accepted
Protocol run number 14 , outputs of the target accepted
Protocol run number 15 , outputs of the target accepted
Protocol run number 16 , outputs of the target accepted
Protocol run number 17 , outputs of the target accepted
Protocol run number 18 , outputs of the target accepted
Protocol run number 19 , outputs of the target accepted
Protocol run number 20 , outputs of the target accepted

After 20 runs, AP has accepted 20 outputs!

List of accepted outputs:
 ['0100', '0010', '1011', '1001', '0110', '1111', '1101', '0000', '1101', '0000', '0110', '1011', '0110', '1101', '0000', '0110', '1101', '0010', '1001', '1101', '0000']

La fonction :math:` bound_variation_distance’calcule la limite supérieure de la distance de variation (VD) à l’aide de

\[VD\leq \frac{\varepsilon}{N_{\textrm{acc}}/d-\theta}\textrm{ ,}\]

où \(\theta\in [ 0,1 ]\) est un nombre positif et

\[\varepsilon= \frac{1.7}{v+1}\]

est la probabilité maximale d’accepter un état incorrect pour la cible. La fonction :math:` bound_variation_distance` calcule également la confiance dans la liaison en tant que

\[1-2\textrm{exp}\big(-2\theta d^2\big)\]

theta = 5/100

test_2.bound_variation_distance(theta)

print("AP accepted",test_2.N_acc,"out of",test_2.num_runs,"times.")
print("With confidence",test_2.confidence,"AP certifies that VD is upper-bounded by",test_2.bound)

AP accepted 20 out of 20 times.
With confidence 1.0 AP certifies that VD is upper-bounded by 0.16267942583732053

Définition du modèle de bruit

We define a noise model for the simulator. We add depolarizing error probabilities to the controlled-\(Z\) and single-qubit gates.

noise_model = NoiseModel()

p1q = 0.003
noise_model.add_all_qubit_quantum_error(depolarizing_error(p1q, 1), 'u1')
noise_model.add_all_qubit_quantum_error(depolarizing_error(p1q, 1), 'u2')
noise_model.add_all_qubit_quantum_error(depolarizing_error(p1q, 1), 'u3')
p2q = 0.03
noise_model.add_all_qubit_quantum_error(depolarizing_error(p2q, 2), 'cx')

basis_gates = ['u1','u2','u3','cx']

Nous mettons ensuite en place des circuits bruités et transmettons leurs résultats à :math:` single_protocol_run `.

test_3 = AccreditationFitter()

for run in range(d):

    # Create target and trap circuits with random Pauli gates
    circuit_list, postp_list, v_zero = accsys.generate_circuits(v)
    job = execute(circuit_list,
                  simulator,
                  noise_model=noise_model,
                  basis_gates=basis_gates,
                  shots=1,
                  backend_options={'max_parallel_experiments': 0})
    result = job.result()
    # Post-process the outputs and see if the protocol accepts
    test_3.single_protocol_run(result, postp_list, v_zero)
    print("Protocol run number",run+1,", outputs of the target",test_3.flag)

print("\nAP accepted",test_3.N_acc,"out of",test_3.num_runs,"times.")
print('\nList of accepted outputs:\n', test_3.outputs)

theta = 5/100

test_3.bound_variation_distance(theta)
print("\nWith confidence",test_3.confidence,"AP certifies that VD is upper-bounded by",test_3.bound)

Protocol run number 1 , outputs of the target rejected
Protocol run number 2 , outputs of the target rejected
Protocol run number 3 , outputs of the target rejected
Protocol run number 4 , outputs of the target rejected
Protocol run number 5 , outputs of the target rejected
Protocol run number 6 , outputs of the target rejected
Protocol run number 7 , outputs of the target accepted
Protocol run number 8 , outputs of the target rejected
Protocol run number 9 , outputs of the target accepted
Protocol run number 10 , outputs of the target rejected
Protocol run number 11 , outputs of the target rejected
Protocol run number 12 , outputs of the target rejected
Protocol run number 13 , outputs of the target accepted
Protocol run number 14 , outputs of the target rejected
Protocol run number 15 , outputs of the target rejected
Protocol run number 16 , outputs of the target rejected
Protocol run number 17 , outputs of the target rejected
Protocol run number 18 , outputs of the target accepted
Protocol run number 19 , outputs of the target rejected
Protocol run number 20 , outputs of the target rejected

AP accepted 4 out of 20 times.

List of accepted outputs:
 ['0100', '0010', '1011', '1001', '0110', '1111', '1101', '0000', '1101', '0000', '0110', '1011', '0110', '1101', '0000', '0110', '1101', '0010', '1001', '1101', '0000', '0100', '0110', '1111', '0100']

With confidence 1.0 AP certifies that VD is upper-bounded by 1

Changer le nombre de circuits d’alerte par protocole d’exécution change la limite supérieure de la VD, mais pas la confiance.

Quel est le nombre de circuits de trap qui assureront la limite supérieure minimale pour votre circuit cible?

min_traps = 4
max_traps = 10


for num_trap_circs in range(min_traps,max_traps):

    test_4 = AccreditationFitter()
    for run in range(d):

        # Create target and trap circuits with random Pauli gates
        circuit_list, postp_list, v_zero = accsys.generate_circuits(num_trap_circs)

        job = execute(circuit_list,
                      simulator,
                      noise_model=noise_model,
                      basis_gates=basis_gates,
                      shots=1,
                      backend_options={'max_parallel_experiments': 0})
        result = job.result()

        # Post-process the outputs and see if the protocol accepts
        test_4.single_protocol_run(result, postp_list, v_zero)

    print("\nWith", num_trap_circs,
          "traps, AP accepted", test_4.N_acc,
          "out of", test_4.num_runs, "times.")
    test_4.bound_variation_distance(theta)
    print("With confidence", test_4.confidence,
          "AP with", num_trap_circs,
          "traps certifies that VD is upper-bounded by", test_4.bound)

With 4 traps, AP accepted 16 out of 20 times.
With confidence 1.0 AP with 4 traps certifies that VD is upper-bounded by 0.45333333333333337

With 5 traps, AP accepted 7 out of 20 times.
With confidence 1.0 AP with 5 traps certifies that VD is upper-bounded by 0.9444444444444444

With 6 traps, AP accepted 11 out of 20 times.
With confidence 1.0 AP with 6 traps certifies that VD is upper-bounded by 0.48571428571428577

With 7 traps, AP accepted 9 out of 20 times.
With confidence 1.0 AP with 7 traps certifies that VD is upper-bounded by 0.53125

With 8 traps, AP accepted 7 out of 20 times.
With confidence 1.0 AP with 8 traps certifies that VD is upper-bounded by 0.6296296296296298

With 9 traps, AP accepted 11 out of 20 times.
With confidence 1.0 AP with 9 traps certifies that VD is upper-bounded by 0.33999999999999986