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

O circuito de dois locais.

O circuito de dois locais é um circuito parametrizado que consiste em camadas de rotação alternadas e camadas de emaranhamento. As camadas de rotação são portas de qubit único aplicadas em todos os qubits. A camada de emaranhamento usa portas de dois qubits para emaranhar os qubits de acordo com uma estratégia definida usando entanglement. As portas de rotação e de emaranhamento podem ser especificadas como string (por exemplo 'ry' ou 'cx'), como tipo de porta (por exemplo RYGate ou CXGate) ou como QuantumCircuit (por exemplo, um circuito de 1 qubit ou um circuito de 2 qubit).

É fornecido um conjunto de estratégias de emaranhamento padrão:

• 'full' O entrelaçamento é quando cada qubit está entrelaçado com todos os outros.
• 'linear' emaranhamento é o qubit $i$ emaranhado com o qubit $i + 1$, para todos os $i \in \{0, 1, ... , n - 2\}$, em que $n$ é o número total de qubits.
• 'reverse_linear' emaranhamento é o qubit $i$ emaranhado com o qubit $i + 1$, para todos os $i \in \{n-2, n-3, ... , 1, 0\}$, em que $n$ é o número total de qubits. Observe que, se for entanglement_blocks = 'cx' , essa opção fornecerá o mesmo unitário que 'full' com menos portas de emaranhamento.
• 'pairwise' o emaranhamento é uma camada em que o qubit $i$ está emaranhado com o qubit $i + 1$, para todos os valores pares de $i$, e depois uma segunda camada em que o qubit $i$ está emaranhado com o qubit $i + 1$, para todos os valores ímpares de $i$.
• 'circular' é o entrelaçamento linear, mas com um entrelaçamento adicional do primeiro e do último qubit antes da parte linear.
• 'sca' (shifted-circular-alternating) é uma versão generalizada e modificada do circuito 14 proposto em Sim et al. Ele consiste em um entrelaçamento circular em que o entrelaçamento "longo" que conecta o primeiro ao último qubit é deslocado em um a cada bloco. Além disso, as funções dos qubits de controle e de destino são trocadas a cada bloco (portanto, alternadas).

O entrelaçamento pode ainda ser especificado usando um mapa de entrelaçamento, que é uma lista de pares de índices, como

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

Se for necessário usar diferentes emaranhados por bloco, forneça uma lista de mapas de emaranhados. Veja os exemplos abaixo sobre como isso pode ser usado.

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

As barreiras podem ser inseridas entre as diferentes camadas para melhor visualização usando o atributo insert_barriers .

Para cada porta parametrizada, um novo parâmetro é gerado usando um ParameterVector. O nome desses parâmetros pode ser escolhido usando o endereço parameter_prefix.

Exemplos

>>> 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 ├
     └───┘ ░      └───┘ ░ └───┘ ░ └───┘ ░ └───┘

Parâmetros

• num_qubits (int | None) – O número de qubits do circuito de dois locais.
• rotation_blocks (str |type |qiskit.circuit.Instruction |QuantumCircuit |list[str |type |qiskit.circuit.Instruction |QuantumCircuit] | None) – Os portões utilizados na camada de rotação. Pode ser especificado através do nome de um portão (por exemplo, 'ry') ou o próprio tipo de porta (por exemplo, RYGate). Se houver apenas uma porta, a mesma porta é aplicada a cada qubit. Se for fornecida uma lista de portas, todas as portas são aplicadas a cada qubit na ordem indicada. Consulte a seção Exemplos para obter mais detalhes.
• entanglement_blocks (str |type |qiskit.circuit.Instruction |QuantumCircuit |list[str |type |qiskit.circuit.Instruction |QuantumCircuit] | None) – Os portões utilizados na camada de entrelaçamento. Pode ser especificado no mesmo formato que rotation_blocks.
• entanglement (str |list[list[int]] | Callable[[int], list[int]]) – Especifica a estrutura de entrelaçamento. Pode ser uma cadeia de caracteres ('full', 'linear', 'reverse_linear', 'circular' ou 'sca'), uma lista de pares de números inteiros especificando os índices de qubits emaranhados entre si ou um chamável que retorna essa lista com o índice da camada de emaranhamento. Padrão para 'full' entanglement. Observe que se entanglement_blocks = 'cx', então o entrelaçamento 'full' fornece a mesma unidade que 'reverse_linear' , mas a última opção tem menos portas de entrelaçamento. Consulte a seção Exemplos para obter mais detalhes.
• reps (int) – Especifica a frequência com que um bloco que consiste em uma camada de rotação e uma camada de emaranhamento é repetido.
• skip_unentangled_qubits (bool) – Se True, os portões de qubit único são aplicados somente a qubits que estão emaranhados com outro qubit. Se False, as portas de um único qubit são aplicadas a cada qubit no ansatz. O padrão é False.
• skip_final_rotation_layer (bool) – Se False, uma camada de rotação é adicionada no final do ansatz. Se for True, nenhuma camada de rotação será adicionada.
• parameter_prefix (str) – As portas parametrizadas exigem a definição de um parâmetro, para o qual usamos instâncias de Parameter. O nome de cada parâmetro será esse prefixo especificado mais seu índice.
• insert_barriers (bool) – Se True, são inseridas barreiras entre cada camada. Se for False, nenhuma barreira será inserida. O padrão é False.
• initial_state (QuantumCircuit | None) – A QuantumCircuit para anexar ao circuito.
• name (str) – O nome a ser usado para o circuito gerado.
• flatten (bool | None) – Defina essa opção como True para gerar um circuito plano em vez de aninhá-lo em várias camadas de objetos de porta. Por padrão, atualmente, o conteúdo do circuito de saída será agrupado em objetos aninhados para uma visualização mais limpa. No entanto, se estiver usando esse circuito para qualquer coisa além de visualização, é altamente recomendável definir esse sinalizador como True para evitar uma grande sobrecarga de desempenho para a vinculação de parâmetros.

Atributos

name

from qiskit import QuantumCircuit

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

my_circuit

Métodos

get_entangler_map