Nota

Esta página foi gerada a partir do tutoriais/ruido/7_certificacao.ipynb.

Execute interativamente no IBM Quantum lab.

Protocolo de acreditação

O Protocolo de Acreditação (AP) é um protocolo projetado para caracterizar a confiabilidade de dispositivos quânticos ruidosos.

Dado um dispositivo quântico ruidoso implementando um circuito quântico “alvo“, o AP certifica um limite superior na distância de variação entre a distribuição de probabilidade das saídas devolvidas pelo dispositivo e a distribuição de probabilidade ideal. Esse método é baseado em Ferracin et al, “Accrediting outputs of noisy intermediate-scale quantum devices”, https://arxiv.org/abs/1811.09709.

Este notebook dá um exemplo de como utilizar o módulo ignis.characterization.accreditation. Este exemplo específico mostra como acreditar as saídas de um circuito quântico de 4 qubits com profundidade 5. Todos os circuitos são executados usando o simulador Aer com ruído.

#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

Entrada para o protocolo

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.

Vamos agora desenhar um circuito quântico alvo! Começamos com um circuito simples para gerar e medir o estado GHZ de 4 qubits.

# 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')

Gerando circuitos de acreditação

A função \(accreditation\_circuits\) gera todos os circuitos requeridos pelo AP, alvo e armadilhas. Ele automaticamente anexa portas Pauli aleatórias aos circuitos (se a implementação for ruidosa, essas portas Pauli aleatórias reduzem o ruído a erros de Pauli!)

Ela também retorna a lista \(postp\_list\) de caracteres necessárias para o pós-processamento das saídas, bem como o número \(v\_zero\) indicando o circuito implementando o alvo.

Este é o circuito alvo com portas Pauli escolhidas aleatoriamente:

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

É assim que uma armadilha se parece:

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

Pode-se utilizar o argumento opcional twoqubitgate para alternar e usar portas cx em vez de portas cz e pode alterar arbitrariamente o mapa de acoplamento, a fim de compilar para a topologia do dispositivo desejado (que neste caso pode levar a mais camadas do que o esperado).

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

Simulando os circuitos ideais

Vamos implementar o AP.

Usamos \(accreditation\_circuits\) para gerar circuitos alvo e armadilha. Em seguida, utilizamos a função \(single\_protocol\_run\) para implementar todos esses circuitos, mantendo a saída do alvo apenas se todas as armadilhas retornarem a saída correta.

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!

Na ausência de ruído, todas as armadilhas retornam a saída esperada, portanto, sempre aceitamos a saída do alvo.

Para obter um limite superior da distância de variação nas saídas do circuito alvo, precisamos implementar o AP \(d\) vezes, cada vez com v diferentes circuitos armadilha.

# 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']

A função \(bound\_variation\_distance\) calcula o limite superior da distância de variação (VD) usando

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

onde \(\theta\in[0,1]\) é um número positivo e

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

é a probabilidade máxima de aceitar um estado incorreto para o alvo. A função \(bound\_variation\_distance\) também calcula a confiança no limite como

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

Definindo o modelo de ruído

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

Em seguida, implementamos circuitos com ruído e passamos suas saídas para \(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

Mudar o número de circuitos armadilha por execução do protocolo altera o limite superior da VD, mas não a confiança.

Qual número de circuitos armadilha garantirá o limite superior mínimo para o seu circuito alvo?

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