TwoLocal

class qiskit.circuit.library.TwoLocal(num_qubits=None, rotation_blocks=None, entanglement_blocks=None, entanglement='full', reps=3, skip_unentangled_qubits=False, skip_final_rotation_layer=False, parameter_prefix='θ', insert_barriers=False, initial_state=None, name='TwoLocal', flatten=None)

Bases : NLocal

Le circuit bi-local.

Le circuit bi-local est un circuit paramétré constitué d'une alternance de couches de rotation et de couches d'enchevêtrement. Les couches de rotation sont des portes à qubit unique appliquées à tous les qubits. La couche d'enchevêtrement utilise des portes à deux qubits pour enchevêtrer les qubits selon une stratégie définie à l'aide de entanglement. Les portes de rotation et d'enchevêtrement peuvent être spécifiées sous forme de chaîne (par ex. 'ry' ou 'cx'), en tant que type de porte (par ex. RYGate ou CXGate) ou comme QuantumCircuit (par exemple, un circuit à 1 qubit ou à 2 qubits).

Un ensemble de stratégies d'enchevêtrement par défaut est fourni :

• 'full' L'intrication, c'est lorsque chaque qubit est intriqué avec tous les autres.
• 'linear' est le qubit $i$ intriqué avec le qubit $i + 1$, pour tous les $i \in \{0, 1, ... , n - 2\}$, où $n$ est le nombre total de qubits.
• 'reverse_linear' est le qubit $i$ intriqué avec 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'enchevêtrement est une couche où le qubit $i$ est enchevêtré avec le qubit $i + 1$, pour toutes les valeurs paires de $i$, et ensuite une deuxième couche où le qubit $i$ est enchevêtré avec le qubit $i + 1$, pour toutes les valeurs impaires de $i$.
• 'circular' est un enchevêtrement linéaire, mais avec un enchevêtrement supplémentaire du premier et du dernier qubit avant la partie linéaire.
• 'sca' (shifted-circular-alternating) entanglement 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).

L'enchevêtrement peut également être spécifié à l'aide d'une carte d'enchevêtrement, qui est une liste de paires d'index, telles que

>>> entangler_map = [(0, 1), (1, 2), (2, 0)]

Si des enchevêtrements différents par bloc doivent être utilisés, fournir une liste des cartes d'enchevêtrement. Voir les exemples ci-dessous pour savoir comment l'utiliser.

>>> entanglement = [entangler_map_layer_1, entangler_map_layer_2, ... ]

Des barrières peuvent être insérées entre les différentes couches pour une meilleure visualisation à l'aide de l'attribut insert_barriers .

Pour chaque porte paramétrée, un nouveau paramètre est généré à l'aide de ParameterVector. Le nom de ces paramètres peut être choisi à l'aide de parameter_prefix.

Exemples

>>> two = TwoLocal(3, 'ry', 'cx', 'linear', reps=2, insert_barriers=True)
>>> print(two.decompose())  # decompose the layers into standard gates
     ┌──────────┐ ░            ░ ┌──────────┐ ░            ░ ┌──────────┐
q_0: ┤ Ry(θ[0]) ├─░───■────────░─┤ Ry(θ[3]) ├─░───■────────░─┤ Ry(θ[6]) ├
     ├──────────┤ ░ ┌─┴─┐      ░ ├──────────┤ ░ ┌─┴─┐      ░ ├──────────┤
q_1: ┤ Ry(θ[1]) ├─░─┤ X ├──■───░─┤ Ry(θ[4]) ├─░─┤ X ├──■───░─┤ Ry(θ[7]) ├
     ├──────────┤ ░ └───┘┌─┴─┐ ░ ├──────────┤ ░ └───┘┌─┴─┐ ░ ├──────────┤
q_2: ┤ Ry(θ[2]) ├─░──────┤ X ├─░─┤ Ry(θ[5]) ├─░──────┤ X ├─░─┤ Ry(θ[8]) ├
     └──────────┘ ░      └───┘ ░ └──────────┘ ░      └───┘ ░ └──────────┘

>>> two = TwoLocal(3, ['ry','rz'], 'cz', 'full', reps=1, insert_barriers=True, flatten=True)
>>> qc = QuantumCircuit(3)
>>> qc &= two
>>> print(qc.draw())
     ┌──────────┐┌──────────┐ ░           ░ ┌──────────┐ ┌──────────┐
q_0: ┤ Ry(θ[0]) ├┤ Rz(θ[3]) ├─░──■──■─────░─┤ Ry(θ[6]) ├─┤ Rz(θ[9]) ├
     ├──────────┤├──────────┤ ░  │  │     ░ ├──────────┤┌┴──────────┤
q_1: ┤ Ry(θ[1]) ├┤ Rz(θ[4]) ├─░──■──┼──■──░─┤ Ry(θ[7]) ├┤ Rz(θ[10]) ├
     ├──────────┤├──────────┤ ░     │  │  ░ ├──────────┤├───────────┤
q_2: ┤ Ry(θ[2]) ├┤ Rz(θ[5]) ├─░─────■──■──░─┤ Ry(θ[8]) ├┤ Rz(θ[11]) ├
     └──────────┘└──────────┘ ░           ░ └──────────┘└───────────┘

>>> entangler_map = [[0, 1], [1, 2], [2, 0]]  # circular entanglement for 3 qubits
>>> two = TwoLocal(3, 'x', 'crx', entangler_map, reps=1, flatten=True)
>>> print(two)  # note: no barriers inserted this time!
        ┌───┐                             ┌──────────┐┌───┐
q_0: |0>┤ X ├─────■───────────────────────┤ Rx(θ[2]) ├┤ X ├
        ├───┤┌────┴─────┐            ┌───┐└─────┬────┘└───┘
q_1: |0>┤ X ├┤ Rx(θ[0]) ├─────■──────┤ X ├──────┼──────────
        ├───┤└──────────┘┌────┴─────┐└───┘      │     ┌───┐
q_2: |0>┤ X ├────────────┤ Rx(θ[1]) ├───────────■─────┤ X ├
        └───┘            └──────────┘                 └───┘

>>> entangler_map = [[0, 3], [0, 2]]  # entangle the first and last two-way
>>> two = TwoLocal(4, [], 'cry', entangler_map, reps=1, flatten=True)
>>> circuit = two.compose(two)
>>> print(circuit.draw())  # note, that the parameters are the same!
q_0: ─────■───────────■───────────■───────────■──────
          │           │           │           │
q_1: ─────┼───────────┼───────────┼───────────┼──────
          │      ┌────┴─────┐     │      ┌────┴─────┐
q_2: ─────┼──────┤ Ry(θ[1]) ├─────┼──────┤ Ry(θ[1]) ├
     ┌────┴─────┐└──────────┘┌────┴─────┐└──────────┘
q_3: ┤ Ry(θ[0]) ├────────────┤ Ry(θ[0]) ├────────────
     └──────────┘            └──────────┘

>>> layer_1 = [(0, 1), (0, 2)]
>>> layer_2 = [(1, 2)]
>>> two = TwoLocal(3, 'x', 'cx', [layer_1, layer_2], reps=2, insert_barriers=True,
... flatten=True)
>>> print(two)
     ┌───┐ ░            ░ ┌───┐ ░       ░ ┌───┐
q_0: ┤ X ├─░───■────■───░─┤ X ├─░───────░─┤ X ├
     ├───┤ ░ ┌─┴─┐  │   ░ ├───┤ ░       ░ ├───┤
q_1: ┤ X ├─░─┤ X ├──┼───░─┤ X ├─░───■───░─┤ X ├
     ├───┤ ░ └───┘┌─┴─┐ ░ ├───┤ ░ ┌─┴─┐ ░ ├───┤
q_2: ┤ X ├─░──────┤ X ├─░─┤ X ├─░─┤ X ├─░─┤ X ├
     └───┘ ░      └───┘ ░ └───┘ ░ └───┘ ░ └───┘

Paramètres

• num_qubits (int | None) – Le nombre de qubits du circuit bi-local.
• rotation_blocks (str |type |qiskit.circuit.Instruction |QuantumCircuit |list[str |type |qiskit.circuit.Instruction |QuantumCircuit] | None) – Les portes utilisées dans la couche de rotation. Peut être spécifié via le nom d'une porte (par exemple 'ry') ou le type de porte lui-même (par exemple RYGate). Si une seule porte est disponible, la même porte est appliquée à chaque qubit. Si une liste de portes est fournie, toutes ces portes sont appliquées à chaque qubit dans l'ordre indiqué. Pour plus de détails, consultez la section « Exemples ».
• entanglement_blocks (str |type |qiskit.circuit.Instruction |QuantumCircuit |list[str |type |qiskit.circuit.Instruction |QuantumCircuit] | None) – Les portes utilisées dans la couche d'intrication. Peut être spécifié dans le même format que rotation_blocks.
• entanglement (str |list[list[int]] | Callable[[int], list[int]]) – Spécifie la structure de l'enchevêtrement. Il peut s'agir d'une chaîne ('full', 'linear', 'reverse_linear', 'circular' ou 'sca'), d'une liste de paires d'entiers spécifiant les indices des qubits intriqués l'un avec l'autre, ou d'un appel renvoyant une telle liste avec l'indice de la couche d'intrication. La valeur par défaut est 'full' . Il convient de noter que si entanglement_blocks = 'cx', l'enchevêtrement de 'full' fournit la même unité que 'reverse_linear' , mais cette dernière option comporte moins de portes d'enchevêtrement. Voir la section Exemples pour plus de détails.
• reps (int) – Spécifie la fréquence de répétition d'un bloc composé d'une couche de rotation et d'une couche d'enchevêtrement.
• skip_unentangled_qubits (bool) – Si True, les portes à qubit unique ne sont appliquées qu'aux qubits qui sont intriqués avec un autre qubit. Si False, les portes à qubit unique sont appliquées à chaque qubit dans l'ansatz. La valeur par défaut est False.
• skip_final_rotation_layer (bool) – Si False, une couche de rotation est ajoutée à la fin de l'ansatz. Si True, aucune couche de rotation n'est ajoutée.
• parameter_prefix (str) – Les portes paramétrées nécessitent la définition d'un paramètre, pour lequel nous utilisons des instances de Parameter. Le nom de chaque paramètre sera le préfixe spécifié plus son index.
• 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. La valeur par défaut est False.
• initial_state (QuantumCircuit | None) – Un QuantumCircuit objet à ajouter au début du circuit.
• name (str) – Le nom à attribuer au circuit généré.
• flatten (bool | None) – Réglez ce paramètre sur True pour obtenir un circuit plat au lieu de l'imbriquer dans plusieurs couches d'objets de porte. Par défaut, le contenu du circuit de sortie sera enveloppé dans des objets imbriqués pour une visualisation plus propre. Cependant, si vous utilisez ce circuit pour autre chose que la visualisation, il est fortement recommandé de mettre ce drapeau à True afin d'éviter une surcharge de performance importante pour la liaison des paramètres.

Attributs

name

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2, name="my_circuit")
print(qc.name)

my_circuit

Méthodes

get_entangler_map