Aprenda o modelo de ruído de um gate

Este tutorial demonstra como aprender um modelo de ruído para um gate unitário com um protocolo de aprendizado padrão, acessível pelas funções de protocolo de alto nível prepare_vanilla_program() e process_vanilla_result().

1. Defina o gate

2. Configure a simulação local

3. Prepare o programa quântico

4. Execute o programa quântico

5. Leia os resultados

Executando em hardware real

Os circuitos abaixo são simulados localmente, então este passo a passo não precisa de credenciais do IBM Quantum®. Para executá-lo em um dispositivo real:

• Passo 1: substitua FakeMarrakesh por um Backend real.

• Passo 2: passe esse Backend como o modo do executor e remova as opções do simulador.

1. Defina o gate

O gate é um BoxOp que contém uma camada com twirling de seis gates CZ disjuntos.

from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeMarrakesh
from samplomatic import InjectNoise, Tag, Twirl

backend = FakeMarrakesh()

cz_pairs = [(91, 92), (93, 94), (95, 99), (98, 111), (112, 113), (114, 115)]

circuit = QuantumCircuit(backend.num_qubits)
with circuit.box([Twirl(), Tag("cz_gate"), InjectNoise("cz_gate")]):
    for pair in cz_pairs:
        circuit.cz(*pair)

Executando em hardware real

from qiskit_ibm_runtime import QiskitRuntimeService

backend = QiskitRuntimeService().backend("ibm_marrakesh")

2. Configure a simulação local

Os índices de Pauli dentro de cada mapa são locais à porta, em ordem crescente de qubit físico:

cz_qubits = sorted({qubit for pair in cz_pairs for qubit in pair})
local = {qubit: index for index, qubit in enumerate(cz_qubits)}
local

{91: 0,
 92: 1,
 93: 2,
 94: 3,
 95: 4,
 98: 5,
 99: 6,
 111: 7,
 112: 8,
 113: 9,
 114: 10,
 115: 11}

Defina o ruído com um termo ZZ correlacionado e um termo XX mais fraco em cada par CZ, além de um termo Z de um único qubit em todo lugar; a medição recebe um termo de inversão de bit (bit-flip) por qubit.

from qiskit.quantum_info import PauliLindbladMap

num_qubits = len(cz_qubits)

cz_noise = PauliLindbladMap.from_sparse_list(
    [("ZZ", [local[a], local[b]], 8e-4) for a, b in cz_pairs]
    + [("XX", [local[a], local[b]], 4e-4) for a, b in cz_pairs]
    + [("Z", [index], 3e-4) for index in range(num_qubits)],
    num_qubits=num_qubits,
)

readout_noise = PauliLindbladMap.from_sparse_list(
    [("X", [index], 5e-3) for index in range(num_qubits)], num_qubits=num_qubits
)

Construa uma caixa para a medição aprender.

measurement = QuantumCircuit(backend.num_qubits, num_qubits)
with measurement.box([Twirl(), Tag("readout"), InjectNoise("readout")]):
    for clbit, qubit in enumerate(cz_qubits):
        measurement.measure(qubit, clbit)

Cada entrada de layer_noise_model associa uma dessas caixas ao mapa que será aplicado a ela. Use o método de simulação de estabilizadores e defina seed_simulator para tornar os dados simulados reproduzíveis.

from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Executor

executor = Executor(
    mode=AerSimulator(method="stabilizer"),
    options={
        "simulator": {
            "layer_noise_model": [
                (circuit[0], cz_noise),
                (measurement[0], readout_noise),
            ],
            "seed_simulator": 1234,
        }
    },
)

Executando em hardware real

executor = Executor(mode=backend)

3. Prepare o programa quântico

Use prepare_vanilla_program() para construir o programa quântico que contém os experimentos de aprendizado.

from qiskit_noise_learning.protocols import prepare_vanilla_program

program = prepare_vanilla_program(
    backend,
    [circuit[0], measurement[0]],
    fragment_depths=[2, 16, 64, 128],
    num_randomizations=50,
    shots_per_randomization=20,
)

print(f"Number of template circuits: {len(program.items)}")

Number of template circuits: 5

4. Execute o programa quântico

Envie o programa quântico. Esta etapa é a mesma, esteja o executor apontando para um simulador ou para um dispositivo real.

result = executor.run(program).result()

5. Leia os resultados

Processe o resultado com process_vanilla_result().

from qiskit_noise_learning.protocols import process_vanilla_result

noise_maps, gate_names, fit = process_vanilla_result(result)

Plote os decaimentos de fidelidade por par de qubits: tanto os dados quanto o ajuste exponencial.

fit.plot_qubit_pair_decays(
    pairs=cz_pairs,
    observable_type="means",
    exponential_fit=True,
)