Mitigación de errores de lectura para la primitiva Sampler utilizando M3

Estimación de uso: menos de un minuto en un procesador Heron r2 (NOTA: Esto es sólo una estimación. Su tiempo de ejecución puede variar)

En segundo plano

A diferencia de la primitiva Estimador, la primitiva Muestreador no tiene soporte incorporado para la mitigación de errores. Varios de los métodos utilizados por el Estimador están diseñados específicamente para valores de expectativas y, por lo tanto, no son aplicables a la primitiva Muestreador. Una excepción es la mitigación de errores de lectura, que es un método muy eficaz que también es aplicable a la primitiva Sampler.

El complemento M3 Qiskit implementa un método eficaz para mitigar los errores de lectura. Este tutorial explica cómo utilizar el addon M3 Qiskit para mitigar el error de lectura de la primitiva Sampler.

¿Qué es un error de lectura?

Inmediatamente antes de la medición, el estado de un registro qubit es descrito por una superposición de estados de base computacional o por una matriz de densidad. A continuación, la medición del registro de qubits en un registro de bits clásico se realiza en dos pasos. Primero se realiza la medición cuántica propiamente dicha. Esto significa que el estado del registro de qubits se proyecta sobre un único estado base que se caracteriza por una cadena de $1$ s y $0$ s. El segundo paso consiste en leer la cadena de bits que caracteriza este estado base y escribirla en la memoria del ordenador clásico. A este paso lo llamamos lectura. Resulta que el segundo paso (lectura) incurre en más errores que el primero (proyección sobre los estados base). Esto tiene sentido cuando se recuerda que la lectura requiere detectar un estado cuántico microscópico y amplificarlo al ámbito macroscópico microscópico y amplificarlo al ámbito macroscópico. Un resonador de lectura se acopla a el qubit (transmón), experimentando así un desplazamiento de frecuencia muy pequeño. Un pulso de microondas se hace rebotar en el resonador, que experimenta a su vez pequeños cambios en sus características. A continuación, el pulso reflejado se amplifica y analiza. Se trata de un proceso proceso y está sujeto a multitud de errores.

El punto importante es que, aunque tanto la medición cuántica como la lectura están sujetas a error, esta última incurre en el error dominante, llamado error de lectura error dominante, llamado error de lectura, en el que se centra este tutorial.

Fundamentos teóricos

Si la cadena de bits muestreada (almacenada en la memoria clásica) difiere de la cadena de bits que caracteriza el estado cuántico proyectado, decimos que se ha producido un error de lectura. Se observa que estos errores son aleatorios y no están correlacionados de una muestra a otra. Se ha demostrado que es útil modelar el error de lectura como un canal clásico ruidoso. Es decir, para cada par de cadenas de bits $i$ y $j$, existe una probabilidad fija de que un valor verdadero de $j$ sea se lea incorrectamente como $i$.

Más concretamente, para cada par de cadenas de bits $(i, j)$, existe una probabilidad (condicional) ${M}_{i,j}$ de que se lea $i$, dado que el valor verdadero es $j.$ Es decir

donde $n$ es el número de bits del registro de lectura. Para concretar, suponemos que $i$ es un entero decimal cuya representación binaria es la cadena de bits que etiqueta los estados de la base de cálculo. Llamamos matriz de asignación a la matriz $2^n \times 2^n$ ${M}$. Para un valor verdadero fijo $j$, la suma de la probabilidad sobre todos los resultados ruidosos $i$ debe dar $1$. Es decir

Una matriz sin entradas negativas que satisface (1) se denomina izquierda-estocástica. Una matriz izquierda-estocástica también se denomina columna-estocástica porque cada una de sus columnas suma $1$. Experimentalmente determinamos valores aproximados para cada elemento ${M}_{i,j}$ mediante preparando repetidamente cada estado base $|j \rangle$ y luego calculando las frecuencias de aparición de las cadenas de bits muestreadas.

Si un experimento implica estimar una distribución de probabilidad sobre cadenas de bits de salida mediante muestreo repetido, entonces podemos usar ${M}$ para mitigar el error de lectura a nivel de la distribución. El primer paso consiste en repetir muchas veces un circuito fijo de interés, creando un histograma de cadenas de bits muestreadas. El histograma normalizado es la distribución de probabilidad medida sobre las $2^n$ posibles cadenas de bits, que denotamos por ${\tilde{p}} \in \mathbb{R}^{2^n}$. La probabilidad (estimada) ${{\tilde{p}}}_i$ de la cadena de bits de muestreo $i$ es igual a la suma de todas las cadenas de bits verdaderas $j$, cada una ponderada por la probabilidad de que se confunda con $i$. Esta afirmación en forma de matriz es

donde ${\vec{p}}$ es la distribución verdadera. En otras palabras, el error de lectura tiene el efecto de multiplicar la distribución ideal sobre las cadenas de bits ${\vec{p}}$ por la matriz de asignación ${M}$ para para producir la distribución observada ${\tilde{p}}$. Hemos medido ${\tilde{p}}$ y ${M}$, pero no tenemos acceso directo a ${\vec{p}}$. En principio, obtendremos obtendremos la verdadera distribución de cadenas de bits para nuestro circuito resolviendo numéricamente la ecuación (2) para ${\vec{p}}$.

Antes de seguir adelante, conviene señalar algunas características importantes de este planteamiento ingenuo.

• En la práctica, la ecuación (2) no se resuelve invirtiendo ${M}$. Las rutinas de álgebra lineal de las bibliotecas de software emplean métodos más estables, precisos y eficientes.
• Al estimar ${M}$, asumimos que sólo se producían errores de lectura. En particular, asumimos que no hubo errores de preparación de estado y de medición cuántica - o al menos que fueron mitigados. En la medida en que se trata de una buena suposición, ${M}$ representa realmente error de lectura. Pero cuando usamos ${M}$ para corregir una distribución medida sobre cadenas de bits, no hacemos tal suposición. De hecho, esperamos que un circuito introduzca ruido, por ejemplo, errores de puerta. La distribución "verdadera sigue incluyendo los efectos de cualquier error que no se haya mitigado de otro modo.

Este método, aunque útil en algunas circunstancias, adolece de algunas limitaciones.

Los recursos de espacio y tiempo necesarios para estimar ${M}$ crecen exponencialmente en $n$ :

• La estimación de ${M}$ y ${\tilde{p}}$ está sujeta a errores estadísticos debidos al muestreo finito. Este ruido puede hacerse tan pequeño como se desee a costa de más disparos (hasta la escala de tiempo de los parámetros de hardware a la deriva que dan lugar a errores sistemáticos en ${M}$ ). Sin embargo, si no se hacen suposiciones sobre las cadenas de bits observadas al realizar la mitigación, el número de disparos necesarios para estimar ${M}$ crece al menos exponencialmente en $n$.
• ${M}$ es una matriz $2^n \times 2^n$. En $n>10$, la cantidad de memoria necesaria para almacenar ${M}$ es mayor que la memoria disponible en un portátil potente.

Otras limitaciones son:

• La distribución recuperada ${\vec{p}}$ puede tener una o más probabilidades negativas (sin dejar de sumar uno). Una solución es minimizar $||{M} {\vec{p}} - {\tilde{p}}||^2$ con la restricción de que cada entrada de ${\vec{p}}$ sea no negativa. Sin embargo, el tiempo de ejecución de este es varios órdenes de magnitud superior al de la resolución directa de la ecuación (2).
• Este procedimiento de mitigación funciona a nivel de una distribución de probabilidad sobre cadenas de bits. En concreto, no puede corregir un error en una cadena de bits cadena de bits observada.

Complemento Qiskit M3 : escalado a cadenas de bits más largas

La resolución de la ecuación (2) mediante rutinas estándar de álgebra lineal numérica está limitada a cadenas de bits de no más de unos 10 bits. M3 puede manejar cadenas de bits mucho más largas. Dos propiedades clave de M3 que lo hacen posible son:

• Las correlaciones en el error de lectura de orden tres y superior entre colecciones de bits se suponen despreciables y se ignoran. En principio, a costa de más disparos, también se podrían estimar correlaciones más altas.
• En lugar de construir ${M}$ explícitamente, utilizamos una matriz efectiva mucho más pequeña que registra probabilidades sólo para las cadenas de bits recogidas al construir ${\tilde{p}}$.

A grandes rasgos, el procedimiento funciona del siguiente modo.

En primer lugar, construimos bloques de construcción a partir de los cuales podemos elaborar una descripción simplificada y eficaz de ${M}$. A continuación, ejecutamos repetidamente el circuito de interés y recopilamos cadenas de bits que utilizamos para construir tanto ${\tilde{p}}$ como, con la ayuda de los bloques de construcción, una descripción efectiva de ${M}$.

Más exactamente,

• Las matrices de asignación de un qubit se estiman para cada qubit. Para ello preparamos repetidamente el registro de qubits en el estado todo-cero $|0 ... 0 \rangle$ y después en el estado todo-uno $|1 ... 1 \rangle$, y registramos la probabilidad de que cada qubit se lea incorrectamente incorrectamente.

• Las correlaciones de orden tres o superior se consideran despreciables y no se tienen en cuenta.

  En su lugar construimos un número $n$ de $2 \times 2$ matrices de asignación single-qubit y un número $n(n-1)/2$ de matrices de asignación de dos qubits $4 \times 4$ de dos qubits. Estas matrices de asignación de uno y dos qubits se almacenan para su uso posterior uso posterior.

• Tras muestrear repetidamente un circuito para construir ${\tilde{p}}$, construimos una aproximación efectiva a ${M}$ utilizando únicamente cadenas de bits que se muestrean al construir ${\tilde{p}}$. Esta matriz efectiva se construye utilizando las matrices de uno y dos qubits descritas en el punto anterior. La dimensión lineal de esta matriz es como máximo del orden del número de disparos utilizados en la construcción de ${\tilde{p}}$, que es mucho menor que la dimensión $2^n$ de la matriz de asignación completa ${M}$.

Para más detalles técnicos sobre M3, puede consultar Scalable Mitigation of Measurement Errors on Quantum Computers.

Aplicación de M3 a un algoritmo cuántico

Aplicaremos M3 's readout mitigation to the hidden shift problem. El problema del desplazamiento oculto, y otros problemas estrechamente relacionados, como el problema del subgrupo oculto, se concibieron originalmente en un entorno tolerante a fallos (más concretamente, antes de que se demostrara que las QPU tolerantes a fallos eran posibles). Pero también se estudian con los procesadores disponibles. Un ejemplo de aceleración exponencial algorítmica obtenida para una variante del problema de turnos ocultos obtenida en QPUs de 127 qubits IBM® puede encontrarse en este artículo ( arXiv version ).

A continuación, toda la aritmética es booleana. Es decir, para $a, b \in \mathbb{Z}_2 = \{0, 1\}$, suma, $a + b$ es la función lógica XOR. Además, la multiplicación $a \times b$ (o $a b$ ) es la función lógica AND. Para $x, y \in \{0, 1\}^n$, $x + y$ se define mediante la aplicación bit a bit de XOR. El producto punto $\cdot: {\mathbb{Z}_2^n} \rightarrow \mathbb{Z}_2$ se define por $x \cdot y = \sum_i x_i y_i$.

Operador de Hadamard y transformada de Fourier

En la implementación de algoritmos cuánticos, es muy común utilizar el operador de Hadamard como transformada de Fourier. Los estados base computacionales se denominan a veces estados clásicos. Están en una relación de uno a uno con las cadenas de bits clásicas. El operador de Hadamard $n$ -qubit sobre estados clásicos puede verse como una transformada de Fourier sobre el hipercubo booleano:

Consideremos un estado ${|{s}\rangle}$ correspondiente a la cadena de bits fija $s$. Aplicando $H^{\otimes n}$, y utilizando ${\langle {x}|{s}\rangle} = \delta_{x,s}$, vemos que la transformada de Fourier de ${|{s}\rangle}$ puede escribirse como

El Hadamard es su propio inverso, es decir, $H^{\otimes n} H^{\otimes n} = (H H)^{\otimes n} = I^{\otimes n}$. Por lo tanto, la transformada de Fourier inversa es el mismo operador, $H^{\otimes n}$. Explícitamente, tenemos,

El problema del cambio oculto

Consideramos un ejemplo sencillo de un problema de desplazamiento oculto. El problema consiste en identificar un desplazamiento constante en la entrada de una función. La función que consideramos es el producto punto. Es el miembro más sencillo de una gran clase de funciones que admiten una aceleración cuántica para el problema del desplazamiento oculto mediante técnicas similares a las que se presentan a continuación.

Sea $x,y \in {\mathbb{Z}_2^m}$ cadenas de bits de longitud $m$. Definimos ${f}: {\mathbb{Z}_2^m} \times {\mathbb{Z}_2^m} \rightarrow \{-1,1\}$ por

Sea $a,b \in {\mathbb{Z}_2^m}$ cadenas de bits fijas de longitud $m$. Definimos además $g: {\mathbb{Z}_2^m} \times {\mathbb{Z}_2^m} \rightarrow \{-1,1\}$ por

donde $a$ y $b$ son parámetros (ocultos). Se nos dan dos cajas negras, una que implementa $f$, y la otra $g$. Suponemos que sabemos que calculan las funciones definidas anteriormente, excepto que no conocemos ni $a$ ni $b$. El juego consiste en determinar las cadenas de bits ocultas (shifts) $a$ y $b$ haciendo consultas a $f$ y $g$. Está claro que si jugamos el juego de forma clásica necesitamos consultas a $O(2m)$ para determinar $a$ y $b$. Por ejemplo, podemos consultar $g$ con todos los pares de cadenas tales que un elemento del par sea todo ceros, y el otro elemento tenga exactamente un elemento establecido en $1$. En cada consulta, aprendemos un elemento de $a$ o $b$. Sin embargo, veremos que, si las cajas negras se implementan como circuitos cuánticos, podemos determinar $a$ y $b$ con una sola consulta a cada uno de $f$ y $g$.

En el contexto de la complejidad algorítmica, una caja negra se denomina oráculo. Además de ser opaco, un oráculo tiene la propiedad de que consume la entrada y produce la salida instantáneamente, sin añadir nada al presupuesto de complejidad del algoritmo en el que está integrado. De hecho, en el caso que nos ocupa, los oráculos que implementan $f$ y $g$ son eficientes.

Circuitos cuánticos para $f$ y $g$

Necesitamos los siguientes ingredientes para implementar $f$ y $g$ como circuitos cuánticos.

Para estados clásicos de un solo qubit ${|{x_1}\rangle}, {|{y_1}\rangle}$, con $x_1,y_1 \in \mathbb{Z}_2$, la puerta controlada- $Z$ ${CZ}$ puede escribirse como

Operaremos con $m$ puertas CZ, una en $(x_1, y_1)$, y otra en $(x_2, y_2)$, y así sucesivamente, a través de $(x_m, y_m)$. Llamamos a este operador ${CZ}_{x,y}$.

$U_f = {CZ}_{x,y}$ es una versión cuántica de ${f} = {f}(x,y)$ :

También necesitamos implementar un desplazamiento de cadena de bits. Denotamos el operador en el registro $x$ $X^{a_1}\cdots X^{a_m}$ por $X_a$ e igualmente en el registro $y$ $X_b = X^{b_1}\cdots X^{b_m}$. Estos operadores aplican $X$ siempre que un bit sea $1$, y la identidad $I$ siempre que sea $0$. Entonces tenemos

La segunda caja negra $g$ se implementa mediante el unitario $U_g$, dado por

Para verlo, aplicamos los operadores de derecha a izquierda al estado ${|{x}\rangle}{|{y}\rangle}$. Primero

A continuación,

Por último,

que es, en efecto, la versión cuántica de $f(x+a, y+b)$.

El algoritmo de cambio oculto

Ahora unimos las piezas para resolver el problema del turno oculto. Comenzamos aplicando Hadamards a los registros inicializados al estado todo-cero.

A continuación, consultamos el oráculo $g$ para llegar a

En la última línea, omitimos el factor de fase global constante $(-1)^{a \cdot b}$, y denotamos la igualdad hasta una fase por $\approx$. A continuación, aplicando el oráculo $f$ introducimos otro factor de $(-1)^{x \cdot y}$, anulando el ya presente. Entonces tenemos:

El último paso es aplicar la transformada inversa de Fourier, $H^{\otimes 2m} = H^{\otimes m} \otimes H^{\otimes m}$, dando como resultado

El circuito está terminado. En ausencia de ruido, el muestreo de los registros cuánticos devolverá devolverá las cadenas de bits $b, a$ con la probabilidad $1$.

El producto interior booleano es un ejemplo de las llamadas funciones dobladas. No definiremos aquí las funciones curvas sino que nos limitaremos a señalar que "son máximamente resistentes contra ataques que buscan explotar una dependencia de las salidas en algún subespacio lineal de las entradas" Esta cita es del artículo Quantum algorithms for highly non-linear Boolean functions, que da algoritmos eficientes de desplazamiento oculto para varias clases de funciones curvas. El algoritmo de este tutorial aparece en la sección 3.1 del artículo.

En el caso más general, el circuito para encontrar un desplazamiento oculto $s \in \mathbb{Z}^n$ es

En el caso general, $f$ y $g$ son funciones de una sola variable. Nuestro ejemplo del producto interior tiene esta forma si dejamos que $f(x, y) \to f(z)$, siendo $z$ igual a la concatenación de $x$ y $y$, y $s$ igual a la concatenación de $a$ y $b$. El caso general requiere exactamente dos oráculos: Un oráculo para $g$ y otro para $\tilde{f}$, donde este último es una función conocida como el dual de la función doblada $f$. La función producto interior tiene la propiedad autodual $\tilde{f}=f$.

En nuestro circuito para el desplazamiento oculto sobre el producto interior omitimos la capa intermedia de Hadamards que aparece en el circuito para el caso general. Aunque en el caso general esta capa es necesaria, ahorramos un poco de profundidad al omitirla, a expensas de un poco de postprocesamiento, ya que la salida es ${|{b}\rangle}{|{a}\rangle}$ en lugar de la deseada ${|{a}\rangle}{|{b}\rangle}$.

Requisitos

Antes de empezar este tutorial, asegúrate de que tienes instalado lo siguiente:

• Qiskit SDK v2.1 o posterior, con soporte de visualización
• Qiskit Runtime v0.41 o posterior (pip install qiskit-ibm-runtime)
• M3 Qiskit addon v3.0 (pip install mthree)

Configuración

from collections.abc import Iterator, Sequence
from random import Random
from qiskit.circuit import (
    CircuitInstruction,
    QuantumCircuit,
    QuantumRegister,
    Qubit,
)
from qiskit.circuit.library import CZGate, HGate, XGate
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService
import timeit
import matplotlib.pyplot as plt
from qiskit_ibm_runtime import SamplerV2 as Sampler
import mthree

Paso 1: Asignar entradas clásicas a un problema cuántico

En primer lugar, escribimos las funciones para implementar el problema del desplazamiento oculto como QuantumCircuit.

def apply_hadamards(qubits: Sequence[Qubit]) -> Iterator[CircuitInstruction]:
    """Apply a Hadamard gate to every qubit."""
    for q in qubits:
        yield CircuitInstruction(HGate(), [q], [])


def apply_shift(
    qubits: Sequence[Qubit], shift: int
) -> Iterator[CircuitInstruction]:
    """Apply X gates where the bits of the shift are equal to 1."""
    for i, q in zip(range(shift.bit_length()), qubits):
        if shift >> i & 1:
            yield CircuitInstruction(XGate(), [q], [])


def oracle_f(qubits: Sequence[Qubit]) -> Iterator[CircuitInstruction]:
    """Apply the f oracle."""
    for i in range(0, len(qubits) - 1, 2):
        yield CircuitInstruction(CZGate(), [qubits[i], qubits[i + 1]])


def oracle_g(
    qubits: Sequence[Qubit], shift: int
) -> Iterator[CircuitInstruction]:
    """Apply the g oracle."""
    yield from apply_shift(qubits, shift)
    yield from oracle_f(qubits)
    yield from apply_shift(qubits, shift)


def determine_hidden_shift(
    qubits: Sequence[Qubit], shift: int
) -> Iterator[CircuitInstruction]:
    """Determine the hidden shift."""
    yield from apply_hadamards(qubits)
    yield from oracle_g(qubits, shift)
    # We omit this layer in exchange for post processing
    # yield from apply_hadamards(qubits)
    yield from oracle_f(qubits)
    yield from apply_hadamards(qubits)


def run_hidden_shift_circuit(n_qubits, rng):
    hidden_shift = rng.getrandbits(n_qubits)

    qubits = QuantumRegister(n_qubits, name="q")
    circuit = QuantumCircuit.from_instructions(
        determine_hidden_shift(qubits, hidden_shift), qubits=qubits
    )
    circuit.measure_all()
    # Format the hidden shift as a string.
    hidden_shift_string = format(hidden_shift, f"0{n_qubits}b")
    return (circuit, hidden_shift, hidden_shift_string)


def display_circuit(circuit):
    return circuit.remove_final_measurements(inplace=False).draw(
        "mpl", idle_wires=False, scale=0.5, fold=-1
    )

Empezaremos con un pequeño ejemplo:

n_qubits = 6
random_seed = 12345
rng = Random(random_seed)
circuit, hidden_shift, hidden_shift_string = run_hidden_shift_circuit(
    n_qubits, rng
)

print(f"Hidden shift string {hidden_shift_string}")

display_circuit(circuit)

Output:

Hidden shift string 011010

Paso 2: Optimizar los circuitos para la ejecución del hardware cuántico

job_tags = [
    f"shift {hidden_shift_string}",
    f"n_qubits {n_qubits}",
    f"seed = {random_seed}",
]
job_tags

Output:

['shift 011010', 'n_qubits 6', 'seed = 12345']

# Uncomment this to run the circuits on a quantum computer on IBMCloud.
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=100
)

# from qiskit_ibm_runtime.fake_provider import FakeMelbourneV2
# backend = FakeMelbourneV2()
# backend.refresh(service)

print(f"Using backend {backend.name}")


def get_isa_circuit(circuit, backend):
    pass_manager = generate_preset_pass_manager(
        optimization_level=3, backend=backend, seed_transpiler=1234
    )
    isa_circuit = pass_manager.run(circuit)
    return isa_circuit


isa_circuit = get_isa_circuit(circuit, backend)
display_circuit(isa_circuit)

Output:

Using backend ibm_kingston

Paso 3: Ejecutar circuitos utilizando Qiskit primitives

# submit job for solving the hidden shift problem using the Sampler primitive
NUM_SHOTS = 50_000


def run_sampler(backend, isa_circuit, num_shots):
    sampler = Sampler(mode=backend)
    sampler.options.environment.job_tags
    pubs = [(isa_circuit, None, NUM_SHOTS)]
    job = sampler.run(pubs)
    return job


def setup_mthree_mitigation(isa_circuit, backend):
    # retrieve the final qubit mapping so mthree knows which qubits to calibrate
    qubit_mapping = mthree.utils.final_measurement_mapping(isa_circuit)

    # submit jobs for readout error calibration
    mit = mthree.M3Mitigation(backend)
    mit.cals_from_system(qubit_mapping, rep_delay=None)

    return mit, qubit_mapping

job = run_sampler(backend, isa_circuit, NUM_SHOTS)
mit, qubit_mapping = setup_mthree_mitigation(isa_circuit, backend)

Paso 4: Procesamiento posterior y devolución de los resultados en formato clásico

En la discusión teórica anterior, determinamos que para la entrada $ab$, esperamos la salida $ba$. Una complicación adicional es que, para tener un circuito más simple (pre-transpilado), insertamos las puertas CZ necesarias entre los pares de qubits vecinos pares de qubits vecinos. Esto equivale a intercalar las cadenas de bits $a$ y $b$ como $a1 b1 a2 b2 \ldots$. La cadena de salida $ba$ se intercalará de forma similar: $b1 a1 b2 a2 \ldots$. La función unscramble a continuación transforma la cadena de salida de $b1 a1 b2 a2 \ldots$ en $a1 b1 a2 b2 \ldots$ para que las cadenas de entrada y salida puedan compararse directamente.

# retrieve bitstring counts
def get_bitstring_counts(job):
    result = job.result()
    pub_result = result[0]
    counts = pub_result.data.meas.get_counts()
    return counts, pub_result

counts, pub_result = get_bitstring_counts(job)

La distancia de Hamming entre dos cadenas de bits es el número de índices en los que difieren los bits.

def hamming_distance(s1, s2):
    weight = 0
    for c1, c2 in zip(s1, s2):
        (c1, c2) = (int(c1), int(c2))
        if (c1 == 1 and c2 == 1) or (c1 == 0 and c2 == 0):
            weight += 1

    return weight

# Replace string of form a1b1a2b2... with b1a1b2a1...
# That is, reverse order of successive pairs of bits.
def unscramble(bitstring):
    ps = [bitstring[i : i + 2][::-1] for i in range(0, len(bitstring), 2)]
    return "".join(ps)


def find_hidden_shift_bitstring(counts, hidden_shift_string):
    # convert counts to probabilities
    probs = {
        unscramble(bitstring): count / NUM_SHOTS
        for bitstring, count in counts.items()
    }

    # Retrieve the most probable bitstring.
    most_probable = max(probs, key=lambda x: probs[x])

    print(f"Expected hidden shift string: {hidden_shift_string}")
    if most_probable == hidden_shift_string:
        print("Most probable bitstring matches hidden shift 😊.")
    else:
        print("Most probable bitstring didn't match hidden shift ☹️.")
    print("Top 10 bitstrings and their probabilities:")
    display(
        {
            k: (v, hamming_distance(hidden_shift_string, k))
            for k, v in sorted(
                probs.items(), key=lambda x: x[1], reverse=True
            )[:10]
        }
    )

    return probs, most_probable

probs, most_probable = find_hidden_shift_bitstring(
    counts, hidden_shift_string
)

Output:

Expected hidden shift string: 011010
Most probable bitstring matches hidden shift 😊.
Top 10 bitstrings and their probabilities:

{'011010': (0.9743, 6),
 '001010': (0.00812, 5),
 '010010': (0.0063, 5),
 '011000': (0.00554, 5),
 '011011': (0.00492, 5),
 '011110': (0.00044, 5),
 '001000': (0.00012, 4),
 '010000': (8e-05, 4),
 '001011': (6e-05, 4),
 '000010': (6e-05, 4)}

Registremos la probabilidad de la cadena de bits más probable antes de aplicar la mitigación de errores de lectura con M3.

max_probability_before_M3 = probs[most_probable]
max_probability_before_M3

Output:

0.9743

Ahora aplicamos la corrección de lectura aprendida por M3 a los recuentos. La función apply_corrections devuelve una distribución cuasi-probabilística. Esta es una lista de float objetos que suman un $1$ e. Sin embargo, algunos valores pueden ser negativos.

def perform_mitigation(mit, counts, qubit_mapping):
    # mitigate readout error
    quasis = mit.apply_correction(counts, qubit_mapping)

    # print results
    most_probable_after_m3 = unscramble(max(quasis, key=lambda x: quasis[x]))

    is_hidden_shift_identified = most_probable_after_m3 == hidden_shift_string
    if is_hidden_shift_identified:
        print("Most probable bitstring matches hidden shift 😊.")
    else:
        print("Most probable bitstring didn't match hidden shift ☹️.")
    print("Top 10 bitstrings and their quasi-probabilities:")
    topten = {
        unscramble(k): f"{v:.2e}"
        for k, v in sorted(quasis.items(), key=lambda x: x[1], reverse=True)[
            :10
        ]
    }
    max_probability_after_M3 = float(topten[most_probable_after_m3])
    display(topten)

    return max_probability_after_M3, is_hidden_shift_identified

print(f"Expected hidden shift string: {hidden_shift_string}")
max_probability_after_M3, is_hidden_shift_identified = perform_mitigation(
    mit, counts, qubit_mapping
)

Output:

Expected hidden shift string: 011010
Most probable bitstring matches hidden shift 😊.
Top 10 bitstrings and their quasi-probabilities:

{'011010': '1.01e+00',
 '001010': '8.75e-04',
 '001000': '7.38e-05',
 '010000': '4.51e-05',
 '111000': '2.18e-05',
 '001011': '1.74e-05',
 '000010': '6.42e-06',
 '011001': '-7.18e-06',
 '011000': '-4.53e-04',
 '010010': '-1.28e-03'}

Compare la identificación de la cadena de cambio oculta antes y después de aplicar una correccion M3

def compare_before_and_after_M3(
    max_probability_before_M3,
    max_probability_after_M3,
    is_hidden_shift_identified,
):
    is_probability_improved = (
        max_probability_after_M3 > max_probability_before_M3
    )
    print(f"Most probable probability before M3: {max_probability_before_M3}")
    print(f"Most probable probability after M3: {max_probability_after_M3}")
    if is_hidden_shift_identified and is_probability_improved:
        print("Readout error mitigation effective! 😊")
    else:
        print("Readout error mitigation not effective. ☹️")

compare_before_and_after_M3(
    max_probability_before_M3,
    max_probability_after_M3,
    is_hidden_shift_identified,
)

Output:

Most probable probability before M3: 0.9743
Most probable probability after M3: 1.01
Readout error mitigation effective! 😊

Representa gráficamente cómo varía el tiempo de CPU requerido por M3 en función del número de disparos

# Collect samples for numbers of shots varying from 5000 to 25000.
shots_range = range(5000, NUM_SHOTS + 1, 2500)
times = []
for shots in shots_range:
    print(f"Applying M3 correction to {shots} shots...")
    t0 = timeit.default_timer()
    _ = mit.apply_correction(
        pub_result.data.meas.slice_shots(range(shots)).get_counts(),
        qubit_mapping,
    )
    t1 = timeit.default_timer()
    print(f"\tDone in {t1 - t0} seconds.")
    times.append(t1 - t0)

fig, ax = plt.subplots()
ax.plot(shots_range, times, "o--")
ax.set_xlabel("Shots")
ax.set_ylabel("Time (s)")
ax.set_title("Time to apply M3 correction")

Output:

Applying M3 correction to 5000 shots...
	Done in 0.003321983851492405 seconds.
Applying M3 correction to 7500 shots...
	Done in 0.004425413906574249 seconds.
Applying M3 correction to 10000 shots...
	Done in 0.006366567220538855 seconds.
Applying M3 correction to 12500 shots...
	Done in 0.0071477219462394714 seconds.
Applying M3 correction to 15000 shots...
	Done in 0.00860048783943057 seconds.
Applying M3 correction to 17500 shots...
	Done in 0.010026784148067236 seconds.
Applying M3 correction to 20000 shots...
	Done in 0.011459112167358398 seconds.
Applying M3 correction to 22500 shots...
	Done in 0.012727141845971346 seconds.
Applying M3 correction to 25000 shots...
	Done in 0.01406092382967472 seconds.
Applying M3 correction to 27500 shots...
	Done in 0.01546052098274231 seconds.
Applying M3 correction to 30000 shots...
	Done in 0.016769016161561012 seconds.
Applying M3 correction to 32500 shots...
	Done in 0.019537431187927723 seconds.
Applying M3 correction to 35000 shots...
	Done in 0.019739801064133644 seconds.
Applying M3 correction to 37500 shots...
	Done in 0.021093040239065886 seconds.
Applying M3 correction to 40000 shots...
	Done in 0.022840639110654593 seconds.
Applying M3 correction to 42500 shots...
	Done in 0.023974396288394928 seconds.
Applying M3 correction to 45000 shots...
	Done in 0.026412792038172483 seconds.
Applying M3 correction to 47500 shots...
	Done in 0.026364430785179138 seconds.
Applying M3 correction to 50000 shots...
	Done in 0.02820305060595274 seconds.

Text(0.5, 1.0, 'Time to apply M3 correction')

Interpretación de la trama

El gráfico anterior muestra que el tiempo necesario para aplicar la corrección M3 aumenta linealmente con el número de disparos.

Escalado hacia arriba

n_qubits = 80
rng = Random(12345)
circuit, hidden_shift, hidden_shift_string = run_hidden_shift_circuit(
    n_qubits, rng
)

print(f"Hidden shift string {hidden_shift_string}")

Output:

Hidden shift string 00000010100110101011101110010001010000110011101001101010101001111001100110000111

isa_circuit = get_isa_circuit(circuit, backend)

job = run_sampler(backend, isa_circuit, NUM_SHOTS)
mit, qubit_mapping = setup_mthree_mitigation(isa_circuit, backend)

counts, pub_result = get_bitstring_counts(job)

probs, most_probable = find_hidden_shift_bitstring(
    counts, hidden_shift_string
)

Output:

Expected hidden shift string: 00000010100110101011101110010001010000110011101001101010101001111001100110000111
Most probable bitstring matches hidden shift 😊.
Top 10 bitstrings and their probabilities:

{'00000010100110101011101110010001010000110011101001101010101001111001100110000111': (0.50402,
  80),
 '00000010100110101011101110010001010000110011100001101010101001111001100110000111': (0.0396,
  79),
 '00000010100110101011101110010001010000110011101001101010101001111001100100000111': (0.0323,
  79),
 '00000010100110101011101110010001010000110011101001101010101001101001100110000111': (0.01936,
  79),
 '00000010100110101011101110010011010000110011101001101010101001111001100110000111': (0.01432,
  79),
 '00000010100110101011101110010001010000110011101001101010101001011001100110000111': (0.0101,
  79),
 '00000010100110101011101110010001010000110011101001101010101001110001100110000111': (0.00924,
  79),
 '00000010100110101011101110010001010000010011101001101010101001111001100110000111': (0.00908,
  79),
 '00000010100110101011100110010001010000110011101001101010101001111001100110000111': (0.00888,
  79),
 '00000010100110101011101110010001010000110011101001100010101001111001100110000111': (0.0082,
  79)}

Vemos que se ha encontrado la cadena de desplazamiento oculta correcta. Además, las nueve cadenas de bits más probables son erróneas sólo en una posición.

Anota la probabilidad más probable:

max_probability_before_M3 = probs[most_probable]
max_probability_before_M3

Output:

0.50402

print(f"Expected hidden shift string: {hidden_shift_string}")
max_probability_after_M3, is_hidden_shift_identified = perform_mitigation(
    mit, counts, qubit_mapping
)

Output:

Expected hidden shift string: 00000010100110101011101110010001010000110011101001101010101001111001100110000111
Most probable bitstring matches hidden shift 😊.
Top 10 bitstrings and their quasi-probabilities:

{'00000010100110101011101110010001010000110011101001101010101001111001100110000111': '9.85e-01',
 '00000010100110101011101110010001010000110011100001101010101001111001100110000111': '6.84e-03',
 '00000010100110101011100110010001010000110011101001101010101001111001100110000111': '3.87e-03',
 '00000010100110101011101110010011010000110011101001101010101001111001100110000111': '3.42e-03',
 '00000010100110101011101110010001010000110011101001101010101001111001100100000111': '3.30e-03',
 '00000010100110101011101110010001010000110011101001101010101001110001100110000111': '3.28e-03',
 '00000010100010101011101110010001010000110011101001101010101001111001100110000111': '2.62e-03',
 '00000010100110101011101110010001010000110011101001101010101001101001100110000111': '2.43e-03',
 '00000010100110101011101110010000010000110011101001101010101001111001100110000111': '1.73e-03',
 '00000010100110101011101110010001010000110011101001101010101001111001000110000111': '1.63e-03'}

compare_before_and_after_M3(
    max_probability_before_M3,
    max_probability_after_M3,
    is_hidden_shift_identified,
)

Output:

Most probable probability before M3: 0.54348
Most probable probability after M3: 0.99
Readout error mitigation effective! 😊

Los resultados muestran que el error de lectura fue la fuente dominante de error y que la mitigación M3 fue eficaz.