herramientas de visualización

animate_shaded_lightcone(circuit, bounds, coupling_map, *, reverse=False)

Anima un cono de luz sombreado.

Esta animación permite visualizar un cono de luz sombreado sobre el mapa de acoplamiento de una QPU, lo que facilita la interpretación de los conos de luz sombreados en circuitos que actúan sobre qubits con una conectividad superior a una línea unidimensional ( 1D ).

Los qubits se colocan integrándolos en coupling_map una red cuadrada, de modo que cada acoplamiento se representa como un paso unitario. Esto funciona tanto para la conectividad «heavy-hex» como para la cuadrada, y no depende de la numeración de los qubits.

Parámetros

• circuit (QuantumCircuit) – el circuito cuyo cono de luz sombreado se va a animar.
• bounds (dict[str, PauliLindbladMap]) – los límites que se deben utilizar para el cono de luz sombreado.
• coupling_map (CouplingMap) – el mapa de conectividad de los qubits sobre el que se proyectan los límites de peso 1 y 2.
• reverse (bool) – si se deben animar las capas del circuito en orden inverso.

Devuelve

La figura plotly .

Subidas

• ValueError : si no coupling_map es posible distribuir el en una cuadrícula.
• ValueError : si el bounds contiene un término que actúa sobre más de 2 qubits, lo cual no tiene cabida en el dibujo.
• ValueError : si la operación no se circuit aplica exactamente a los qubits de la coupling_map.
• ValueError : si ninguna de las casillas del circuito tiene límites.
• ValueError : si la expresión contiene bounds un término de 2 qubits en un par de qubits no acoplados.

Tipo de retorno

Figura

draw_shaded_lightcone(circuit, bounds, noise_model_paulis, *, pauli_filter=None, include_empty_boxes=True, **rendering_kwargs)

Dibuja un cono de luz sombreado.

En primer lugar, los datos facilitados bounds se acumulan y se filtran según pauli_filter. Véase también accumulate_filtered_bounds(). A continuación, los límites resultantes se superponen sobre la imagen proporcionada ( circuit véase overlay_bounds_onto_circuit()) y, posteriormente, se representan (véase render_bounds()).

Este es el punto de entrada de una sola llamada para el proceso de tres pasos; utilízalo a menos que necesites los resultados intermedios.

Los modelos de ruido que se muestran a continuación proceden de generate_noise_model_paulis(), que genera los términos de Pauli de peso 1 y 2 que se aprenden realmente para cada casilla. Los valores de los límites son ficticios, y los errores de tipo $Z$ se consideran tres veces más probables que los de tipo $X$, para que se aprecie el efecto del filtrado.

>>> import numpy as np
>>> from qiskit import QuantumCircuit
>>> from qiskit.circuit import BoxOp
>>> from qiskit.quantum_info import PauliLindbladMap
>>> from samplomatic import InjectNoise
>>> from samplomatic.utils import find_unique_box_instructions
>>> from qiskit_addon_slc.utils import generate_noise_model_paulis
>>> from qiskit_addon_slc.visualization import draw_shaded_lightcone

>>> circuit = QuantumCircuit(3)
>>> for idx, (qubit_0, qubit_1) in enumerate([(0, 1), (1, 2)]):
...     body = QuantumCircuit(3)
...     _ = body.cx(qubit_0, qubit_1)
...     annotation = InjectNoise(ref=f"noise_{idx}", modifier_ref=f"box_{idx}")
...     _ = circuit.append(BoxOp(body, annotations=[annotation]), [0, 1, 2])

>>> noise_model_paulis = generate_noise_model_paulis(
...     find_unique_box_instructions(circuit)
... )
>>> rates = {"X": 0.01, "Y": 0.02, "Z": 0.03}
>>> bounds = {
...     f"box_{idx}": PauliLindbladMap.from_components(
...         np.array(
...             [
...                 sum(rates[pauli] for pauli in label)
...                 for label, _ in noise_model_paulis[f"noise_{idx}"].to_sparse_list()
...             ]
...         )
...         * (idx + 1),
...         noise_model_paulis[f"noise_{idx}"],
...     )
...     for idx in range(2)
... }

>>> figure = draw_shaded_lightcone(circuit, bounds, noise_model_paulis)

El pauli_filter se reenvía a accumulate_filtered_bounds() y también se incluye en el título de la figura. «An» int selecciona un peso de Pauli, sin dejar de mezclar los tipos de Pauli:

>>> figure = draw_shaded_lightcone(
...     circuit, bounds, noise_model_paulis, pauli_filter=1
... )

«A» o str «m» se corresponde Pauli con cada término de ruido reducido a su propio soporte distinto de la identidad. Dado que los gráficos anteriores agrupan todos los tipos de Pauli que comparten un soporte, así es como se puede visualizar un solo tipo; en este caso, ambos difieren por un factor de tres entre las tasas $X$ y $Z$ :

>>> from qiskit_addon_slc.visualization import accumulate_filtered_bounds
>>> for pauli_filter in (None, "X", "Z"):
...     filtered = accumulate_filtered_bounds(
...         circuit, bounds, noise_model_paulis, pauli_filter=pauli_filter
...     )
...     single_qubit = {
...         support[0]: round(float(bound), 3)
...         for support, bound in sorted(filtered["box_0"].items())
...         if len(support) == 1
...     }
...     print(f"{str(pauli_filter):>4}: {single_qubit}")
None: {0: 0.06, 1: 0.06, 2: 0.06}
   X: {0: 0.01, 1: 0.01, 2: 0.01}
   Z: {0: 0.03, 1: 0.03, 2: 0.03}

>>> figure = draw_shaded_lightcone(
...     circuit, bounds, noise_model_paulis, pauli_filter="Z"
... )

Dado que la coincidencia utiliza el soporte reducido, se selecciona un término de « weight-2 » en lugar "XX" de una etiqueta de ancho completo como "XXI":

>>> figure = draw_shaded_lightcone(
...     circuit, bounds, noise_model_paulis, pauli_filter="XX"
... )

Parámetros

• circuit (QuantumCircuit) – el circuito cuyo cono de luz sombreado hay que dibujar.
• bounds (dict[str, PauliLindbladMap]) – los límites que se deben utilizar para el cono de luz sombreado.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – los términos de error de Pauli de los modelos de ruido del circuito.
• pauli_filter (Pauli |str |int | None) – el tipo de Pauli opcional mediante el cual se filtraron los límites.
• include_empty_boxes (bool) – si se deben incluir o no las casillas vacías.
• rendering_kwargs : cualquier argumento de palabra clave adicional se reenvía a QuantumCircuit.draw().

Devuelve

La figura mpl .

Tipo de retorno

Figura

accumulate_filtered_bounds(circuit, bounds, noise_model_paulis, pauli_filter=None)

Acumula los valores de enlace filtrados según un tipo de Pauli especificado.

Los valores de los límites se suman por cada soporte distinto de la identidad, por lo que, sin un filtro, los límites de todos los términos de ruido que comparten un mismo soporte se acumulan en un único valor.

Se compara un Pauli filtro o str con cada término de ruido reducido a su propio soporte distinto de la identidad, y no con su etiqueta de ancho total. De este modo, selecciona "X" todos los términos de un solo qubit $X$, independientemente del qubit sobre el que actúen; "XX" selecciona los términos de weight-2 $XX$, y una etiqueta de ancho completo como no "IXI" coincide con nada.

Parámetros

• circuit (QuantumCircuit) – el circuito cuyos límites hay que acumular.
• bounds (dict[str, PauliLindbladMap]) – los límites cuyos valores se van a acumular.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – los términos de ruido de Pauli para cada modelo de ruido.
• pauli_filter (Pauli |str |int | None) – : el tipo de Pauli opcional por el que se va a filtrar. Se comporta de la siguiente manera: - None: acumula todos los límites de los términos de ruido con el mismo soporte. - int: solo acumula los límites de los términos de ruido con el peso de Pauli especificado. - str: selecciona los términos de ruido cuyo soporte distinto de la identidad sea igual a este peso de Pauli. - Pauli: selecciona los términos de ruido cuyo soporte distinto de la identidad sea igual a este peso de Pauli.

Devuelve

Un diccionario anidado. La llave más exterior es la InjectNoise.modifier_ref (igual que la original bounds). El siguiente elemento clave es el soporte del valor límite acumulado y filtrado (es decir, una tupla de números enteros). Esto se corresponde con el valor real del límite como un número de tipo «float».

Tipo de retorno

dict [ str, dict [ tuple [ int, …], float ]]

overlay_bounds_onto_circuit(pauli_bounds, circuit, *, include_empty_boxes=True)

Superpone los límites sobre el circuito.

Esto genera un nuevo « “QuantumCircuit” » con puertas «falsas» que reproducen aquellas instrucciones BoxOp del original circuit que tenían una anotación InjectNoise . Esas casillas se sustituyen por representaciones gráficas de los límites calculados para los errores de Pauli de su respectivo soporte (véase también accumulate_filtered_bounds()).

El circuito devuelto está destinado únicamente a la representación; sus instrucciones son marcadores de posición que contienen valores asociados, en lugar de puertas lógicas ejecutables.

La entrada de metadatos "max_bound" establece el límite superior de la escala de colores utilizada por render_bounds(). Parte del máximo teórico de $2.0$ y solo aumenta, por lo que se mantiene en $2.0$ siempre que cada límite calculado sea más estricto que ese.

Parámetros

• pauli_bounds (dict[str, dict[tuple[int, ...], float]]) – los límites acumulados y filtrados.
• circuit (QuantumCircuit) – el circuito sobre el que superponer los límites.
• include_empty_boxes (bool) – si se deben incluir o no las casillas vacías.

Devuelve

Un circuito cuántico «falso» con instrucciones «Gate» que muestran los valores límite calculados. El circuito cuántico devuelto contiene QuantumCircuit.metadata el valor límite máximo en «max_bound».

Tipo de retorno

QuantumCircuit

render_bounds(bounds_circuit, *, pauli_filter=None, **kwargs)

Muestra un circuito cuántico con límites superpuestos y el estilo correspondiente.

Cada recuadro superpuesto se colorea según su valor de límite en una escala viridis que va de $0$ hasta la entrada de metadatos "max_bound" de bounds_circuit (véase overlay_bounds_onto_circuit()), y se añade una barra de colores a la derecha del circuito.

Al proporcionar el mismo valor que pauli_filter se utilizó para accumulate_filtered_bounds() registrarlo en el título de la figura, lo cual conviene hacer siempre que se represente un conjunto filtrado de límites.

Parámetros

• bounds_circuit (QuantumCircuit) – el circuito cuántico con límites superpuestos. Véase también overlay_bounds_onto_circuit().
• pauli_filter (Pauli |str |int | None) – el tipo de Pauli opcional mediante el cual se filtraron los límites. Esto se indicará en el título de la figura generada.
• kwargs : cualquier argumento de palabra clave adicional se reenvía a QuantumCircuit.draw().

Devuelve

La figura mpl .

Tipo de retorno

Figura