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

Construire un circuit variationnel n-local.

La structure du circuit n-local est constituée d'une alternance de couches de rotation et d'enchevêtrement. Dans les deux couches, des blocs de circuits paramétrés agissent sur le circuit d'une manière définie. Dans la couche de rotation, les blocs sont empilés les uns sur les autres, tandis que dans la couche d'enchevêtrement, ils sont appliqués selon la stratégie entanglement . Les blocs du circuit peuvent avoir des tailles arbitraires (la plus petite étant égale au nombre de qubits dans le circuit). Chaque couche est répétée reps fois et, par défaut, une couche de rotation finale est ajoutée.

Par exemple, un bloc de rotation sur 2 qubits et un bloc d'intrication sur 4 qubits utilisant l'intrication "linear" donnent le circuit suivant.

┌──────┐ ░ ┌──────┐                      ░ ┌──────┐
┤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

L'enchevêtrement :

L'enchevêtrement décrit les connexions des portes dans la couche d'enchevêtrement. Pour une porte à deux qubits par exemple, l'intrication contient des paires de qubits sur lesquelles la porte doit agir, par exemple [[ctrl0, target0], [ctrl1, target1], ...]. Un ensemble de stratégies d'enchevêtrement par défaut est fourni et peut être sélectionné par nom :

• "full" L'intrication, c'est lorsque chaque qubit est intriqué avec tous les autres.

• ---

  "linear" l'intrication est l' $i$ entre le qubit et le qubit $i + 1$,

  pour tous les $i \in \{0, 1, ... , n - 2\}$, où $n$ est le nombre total de qubits.

• ---

  "reverse_linear" l'intrication est l' $i$ entre le qubit et le qubit $i + 1$,

  pour tous les $i \in \{n-2, n-3, ... , 1, 0\}$, où $n$ est le nombre total de qubits. Notez que si entanglement_blocks=="cx" , cette option permet d'obtenir la même unité que "full" avec moins de portes d'enchevêtrement.

• ---

  "pairwise" L'intrication est une couche où l' $i$ e de qubit est intriquée avec celle de qubit

  $i + 1$ pour toutes les valeurs paires de $i$, puis une deuxième couche où le qubit $i$ est intriqué avec le qubit $i + 1$, pour toutes les valeurs impaires de $i$.

• ---

  "circular" L'intrication est une intrication linéaire, mais avec une intrication supplémentaire du

  premier et dernier qubit avant la partie linéaire.

• ---

  "sca" L'intrication (décalée-circulaire-alternée) est une version généralisée et modifiée

  du circuit proposé 14 dans Sim et al. Il s'agit d'un enchevêtrement circulaire où l'enchevêtrement "long" reliant le premier au dernier qubit est décalé d'une unité à chaque bloc. En outre, les rôles des qubits de contrôle et des qubits cibles sont échangés à chaque bloc (donc en alternance).

Si une couche d'intrication contient plusieurs blocs, l'intrication doit être donnée sous la forme d'une liste d'intrications pour chaque bloc. Par exemple :

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

ou :

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

Enfin, l'intrication peut varier à chaque répétition du circuit. Pour ce faire, nous proposons de passer un appel qui prend en entrée l'index de la couche et renvoie l'enchevêtrement pour la couche dans le format ci-dessus. Voir les exemples ci-dessous pour un exemple concret.

Exemples :

Les portes de rotation et d'intrication peuvent être spécifiées par des chaînes simples, si elles sont constituées d'un seul bloc par couche :

from qiskit.circuit.library import n_local

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

Il est possible de définir plusieurs portes par couche en passant une liste. Ici, par exemple, nous utilisons les rotations Pauli-Y et Pauli-Z dans la couche de rotation :

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

Pour omettre les couches de rotation ou d'enchevêtrement, le bloc peut être défini comme une liste vide :

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

L'enchevêtrement peut être défini explicitement via l'argument entanglement :

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

Nous pouvons définir différents enchevêtrements par couche, en spécifiant une fonction qui prend en entrée l'index de la couche actuelle et renvoie la structure d'enchevêtrement. Par exemple, l'exemple suivant utilise des enchevêtrements différents pour les couches impaires et paires :

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

Paramètres

• num_qubits (int) – Le nombre de qubits du circuit.
• rotation_blocks (str |Gate |Iterable[str |Gate]) – Les blocs utilisés dans les couches de rotation. Si plusieurs sont passés, ils seront appliqués les uns après les autres (comme de nouvelles sous-couches).
• entanglement_blocks (str |Gate |Iterable[str |Gate]) – Les blocs utilisés dans les couches d'entrelacement. Si plusieurs sont passés, ils seront appliqués les uns après les autres.
• entanglement (str |Iterable[Iterable[int]] | Iterable[str |Iterable[Iterable[int]]] | Callable[[int], str |Iterable[Iterable[int]] | Iterable[str |Iterable[Iterable[int]]]]) – Les indices spécifiant sur quels qubits agissent les blocs d'entrée. Ceci est spécifié par une chaîne décrivant une stratégie d'intrication (voir les informations supplémentaires) ou une liste de connexions de qubits. Si une liste de blocs d'intrication est transmise, il est possible de spécifier une intrication différente pour chaque bloc en transmettant une liste d'intrications. Pour spécifier un enchevêtrement variable pour chaque répétition, transmettez une fonction appelable qui prend comme entrée la couche et renvoie l'enchevêtrement pour cette couche. La valeur par défaut est "full", ce qui signifie une structure d'intrication « tout-à-tout ».
• reps (int) – Spécifie la fréquence de répétition des blocs de rotation et des blocs d'enchevêtrement.
• insert_barriers (bool) – Si True, des barrières sont insérées entre chaque couche. Si False, aucune barrière n'est insérée.
• parameter_prefix (str) – Le préfixe utilisé si des paramètres par défaut sont générés.
• overwrite_block_parameters (bool) – Si les paramètres des blocs ajoutés doivent être remplacés. Si False, les paramètres des blocs ne sont pas modifiés.
• skip_final_rotation_layer (bool) – Si une couche de rotation finale est ajoutée au circuit.
• skip_unentangled_qubits (bool) – Si True, les portes de rotation n'agissent que sur les qubits intriqués. Si False, les portes de rotation agissent sur tous les qubits.
• name (str | None) – Le nom du circuit.

Retours

Un circuit n-local.

Type de retour

QuantumCircuit