qiskit.circuit.library.n_local

qiskit.circuit.library.n_local(num_qubits, rotation_blocks, entanglement_blocks, entanglement='full', reps=3, insert_barriers=False, parameter_prefix='θ', overwrite_block_parameters=True, skip_final_rotation_layer=False, skip_unentangled_qubits=False, name='nlocal')

Construir un circuito variacional n-local.

La estructura del circuito n-local son capas alternas de rotación y entrelazamiento. En ambas capas, los bloques de circuitos parametrizados actúan sobre el circuito de forma definida. En la capa de rotación, los bloques se aplican apilados unos sobre otros, mientras que en la capa de enredo según la estrategia entanglement . Los bloques del circuito pueden tener tamaños arbitrarios (menor igual al número de qubits del circuito). Cada capa se repite reps veces, y por defecto se añade una capa final de rotación.

Por ejemplo, un bloque de rotación en 2 qubits y un bloque de entrelazamiento en 4 qubits utilizando "linear" entanglement produce el siguiente circuito.

┌──────┐ ░ ┌──────┐                      ░ ┌──────┐
┤0     ├─░─┤0     ├──────────────── ... ─░─┤0     ├
│  Rot │ ░ │      │┌──────┐              ░ │  Rot │
┤1     ├─░─┤1     ├┤0     ├──────── ... ─░─┤1     ├
├──────┤ ░ │  Ent ││      │┌──────┐      ░ ├──────┤
┤0     ├─░─┤2     ├┤1     ├┤0     ├ ... ─░─┤0     ├
│  Rot │ ░ │      ││  Ent ││      │      ░ │  Rot │
┤1     ├─░─┤3     ├┤2     ├┤1     ├ ... ─░─┤1     ├
├──────┤ ░ └──────┘│      ││  Ent │      ░ ├──────┤
┤0     ├─░─────────┤3     ├┤2     ├ ... ─░─┤0     ├
│  Rot │ ░         └──────┘│      │      ░ │  Rot │
┤1     ├─░─────────────────┤3     ├ ... ─░─┤1     ├
└──────┘ ░                 └──────┘      ░ └──────┘

|                                 |
+---------------------------------+
       repeated reps times

Enredo:

El entrelazamiento describe las conexiones de las puertas en la capa de entrelazamiento. Para una puerta de dos qubits, por ejemplo, el enredo contiene pares de qubits sobre los que debe actuar la puerta, por ejemplo [[ctrl0, target0], [ctrl1, target1], ...]. Se proporciona un conjunto de estrategias de enredo predeterminadas que pueden seleccionarse por nombre:

• "full" El entrelazamiento se produce cuando cada qubit está entrelazado con todos los demás.

• ---

  "linear" El entrelazamiento es el qubit $i$ entrelazado con el qubit $i + 1$,

  para todo $i \in \{0, 1, ... , n - 2\}$, donde $n$ es el número total de qubits.

• ---

  "reverse_linear" El entrelazamiento es el qubit $i$ entrelazado con el qubit $i + 1$,

  para todo $i \in \{n-2, n-3, ... , 1, 0\}$, donde $n$ es el número total de qubits. Observe que si entanglement_blocks=="cx" entonces esta opción proporciona el mismo unitario que "full" con menos puertas de enredo.

• ---

  "pairwise" El entrelazamiento es una capa en la que el qubit $i$ está entrelazado con el qubit

  $i + 1$, para todos los valores pares de $i$, y luego una segunda capa en la que el qubit $i$ está enredado con el qubit $i + 1$, para todos los valores impares de $i$.

• ---

  "circular" El entrelazamiento es un entrelazamiento lineal, pero con un entrelazamiento adicional del

  primer y último qubit antes de la parte lineal.

• ---

  "sca" El entrelazamiento (circular alternativo desplazado) es una versión generalizada y modificada

  del circuito propuesto 14 en Sim et al.. Consiste en un entrelazamiento circular en el que el entrelazamiento "largo" que conecta el primer qubit con el último se desplaza uno en cada bloque. Además, el papel de los qubits de control y de destino se intercambian en cada bloque (por tanto, se alternan).

Si una capa de enredos contiene múltiples bloques, entonces el enredo debe darse como lista de enredos para cada bloque. Por ejemplo:

entanglement_blocks = ["rxx", "ryy"]
entanglement = ["full", "linear"]  # full for rxx and linear for ryy

o:

structure_rxx = [[0, 1], [2, 3]]
structure_ryy = [[0, 2]]
entanglement = [structure_rxx, structure_ryy]

Por último, el entrelazamiento puede variar en cada repetición del circuito. Para ello, podemos pasar un callable que toma como entrada el índice de la capa y devuelve el enredo de la capa en el formato anterior. Consulte los ejemplos siguientes para ver un ejemplo concreto.

Ejemplos:

Las puertas de rotación y de entrelazamiento pueden especificarse mediante cadenas simples, si están formadas por un único bloque por capa:

from qiskit.circuit.library import n_local

circuit = n_local(3, "ry", "cx", "linear", reps=2, insert_barriers=True)
circuit.draw("mpl")

Se pueden establecer múltiples puertas por capa pasando una lista. Aquí, por ejemplo, utilizamos rotaciones Pauli-Y y Pauli-Z en la capa de rotación:

circuit = n_local(3, ["ry", "rz"], "cz", "full", reps=1, insert_barriers=True)
circuit.draw("mpl")

Para omitir las capas de rotación o de enredo, el bloque puede establecerse en una lista vacía:

circuit = n_local(4, [], "cry", reps=2)
circuit.draw("mpl")

El enredo puede establecerse explícitamente mediante el argumento entanglement :

entangler_map = [[0, 1], [2, 0]]
circuit = n_local(3, "x", "crx", entangler_map, reps=2)
circuit.draw("mpl")

Podemos definir diferentes estructuras de entrelazamiento por capa, especificando una función que tome como entrada el índice de la capa actual y devuelva la estructura de entrelazamiento. Por ejemplo, en el siguiente ejemplo se utilizan diferentes entrelazamientos para las capas impares y pares:

def entanglement(layer_index):
    if layer_index % 2 == 0:
        return [[0, 1], [0, 2]]
    return [[1, 2]]

circuit = n_local(3, "x", "cx", entanglement, reps=3, insert_barriers=True)
circuit.draw("mpl")

Parámetros

• num_qubits (int) – El número de qubits del circuito.
• rotation_blocks (str |Gate |Iterable[str |Gate]) – Los bloques utilizados en las capas de rotación. Si se pasan varios, se aplicarán uno tras otro (como nuevas subcapas).
• entanglement_blocks (str |Gate |Iterable[str |Gate]) – Los bloques utilizados en las capas de entrelazamiento. Si se pasan varios, se aplicarán uno tras otro.
• entanglement (str |Iterable[Iterable[int]] | Iterable[str |Iterable[Iterable[int]]] | Callable[[int], str |Iterable[Iterable[int]] | Iterable[str |Iterable[Iterable[int]]]]) – Los índices que especifican sobre qué qubits actúan los bloques de entrada. Esto se especifica mediante una cadena que describe una estrategia de entrelazamiento (véase la información adicional) o una lista de conexiones de qubits. Si se pasa una lista de bloques de entrelazamiento, se puede especificar un entrelazamiento diferente para cada bloque pasando una lista de entrelazamientos. Para especificar un entrelazamiento variable para cada repetición, pase una función que tome como entrada la capa y devuelva el entrelazamiento para esa capa. El valor predeterminado es "full", lo que significa una estructura de entrelazamiento total.
• reps (int) – Especifica la frecuencia con la que se repiten los bloques de rotación y los bloques de enredo.
• insert_barriers (bool) – Si True, se insertan barreras entre cada capa. Si False, no se inserta ninguna barrera.
• parameter_prefix (str) – El prefijo utilizado si se generan parámetros por defecto.
• overwrite_block_parameters (bool) – Si los parámetros de los bloques añadidos deben sobrescribirse. Si False, los parámetros de los bloques no se modifican.
• skip_final_rotation_layer (bool) – Si se añade una capa de rotación final al circuito.
• skip_unentangled_qubits (bool) – Si True, las puertas de rotación sólo actúan sobre los qubits que están enredados. Si False, las puertas de rotación actúan sobre todos los qubits.
• name (str | None) – El nombre del circuito.

Devuelve

Un circuito n-local.

Tipo de retorno

QuantumCircuit