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

Construa um circuito variacional n-local.

A estrutura do circuito n-local é composta por camadas alternadas de rotação e emaranhamento. Em ambas as camadas, os blocos de circuito parametrizados atuam no circuito de uma maneira definida. Na camada de rotação, os blocos são aplicados empilhados uns sobre os outros, enquanto na camada de emaranhamento, de acordo com a estratégia entanglement . Os blocos do circuito podem ter tamanhos arbitrários (menor igual ao número de qubits no circuito). Cada camada é repetida reps vezes e, por padrão, uma camada de rotação final é anexada.

Por exemplo, um bloco de rotação em 2 qubits e um bloco de emaranhamento em 4 qubits usando o emaranhamento "linear" produz o seguinte 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

Emaranhamento:

O entrelaçamento descreve as conexões das portas na camada de entrelaçamento. Para uma porta de dois qubits, por exemplo, o emaranhamento contém pares de qubits nos quais a porta deve atuar, por exemplo, [[ctrl0, target0], [ctrl1, target1], ...]. Um conjunto de estratégias de emaranhamento padrão é fornecido e pode ser selecionado por nome:

• "full" O entrelaçamento é quando cada qubit está entrelaçado com todos os outros.

• ---

  "linear" o entrelaçamento é o qubit $i$ entrelaçado 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" o entrelaçamento é o qubit $i$ entrelaçado 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 entrelaçamento é uma camada em que o qubit $i$ está entrelaçado com o qubit

  $i + 1$ para todos os valores pares de $i$, e, em seguida, uma segunda camada em que o qubit $i$ é emaranhado com o qubit $i + 1$, para todos os valores ímpares de $i$.

• ---

  "circular" o entrelaçamento é um entrelaçamento linear, mas com um entrelaçamento adicional do

  primeiro e último qubit antes da parte linear.

• ---

  "sca" O entrelaçamento (circular alternado deslocado) é uma versão generalizada e modificada

  do circuito proposto 14 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).

Se uma camada de entrelaçamento contiver vários blocos, o entrelaçamento deverá ser fornecido como uma lista de entrelaçamentos para cada bloco. Por exemplo:

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]

Por fim, o entrelaçamento pode variar em cada repetição do circuito. Para isso, oferecemos suporte à passagem de um chamável que recebe como entrada o índice da camada e retorna o entrelaçamento para a camada no formato acima. Veja os exemplos abaixo para um exemplo concreto.

Exemplos:

As portas de rotação e emaranhamento podem ser especificadas por meio de cadeias simples, se forem compostas de um único bloco por camada:

from qiskit.circuit.library import n_local

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

Vários portões por camada podem ser definidos passando uma lista. Aqui, por exemplo, usamos as rotações Pauli-Y e Pauli-Z na camada de rotação:

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

Para omitir camadas de rotação ou emaranhamento, o bloco pode ser definido como uma lista vazia:

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

O entrelaçamento pode ser definido explicitamente por meio do argumento entanglement :

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

Podemos definir diferentes entrelaçamentos por camada, especificando uma função que receba como entrada o índice da camada atual e retorne a estrutura de entrelaçamento. Por exemplo, o código a seguir utiliza diferentes entrelaçamentos para camadas ímpares e 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) – O número de qubits do circuito.
• rotation_blocks (str |Gate |Iterable[str |Gate]) – Os blocos utilizados nas camadas de rotação. Se vários forem passados, eles serão aplicados um após o outro (como novas subcamadas).
• entanglement_blocks (str |Gate |Iterable[str |Gate]) – Os blocos utilizados nas camadas de entrelaçamento. Se forem passados vários, eles serão aplicados um após o outro.
• entanglement (str |Iterable[Iterable[int]] | Iterable[str |Iterable[Iterable[int]]] | Callable[[int], str |Iterable[Iterable[int]] | Iterable[str |Iterable[Iterable[int]]]]) – Os índices que especificam em quais qubits os blocos de entrada atuam. Isso é especificado por uma string que descreve uma estratégia de entrelaçamento (consulte as informações adicionais) ou uma lista de conexões de qubits. Se uma lista de blocos de entrelaçamento for passada, diferentes entrelaçamentos para cada bloco podem ser especificados passando uma lista de entrelaçamentos. Para especificar o entrelaçamento variável para cada repetição, passe uma função que receba como entrada a camada e retorne o entrelaçamento para essa camada. O padrão é "full", o que significa uma estrutura de entrelaçamento total.
• reps (int) – Especifica a frequência com que os blocos de rotação e os blocos de entrelaçamento são repetidos.
• insert_barriers (bool) – Se True, são inseridas barreiras entre cada camada. Se for False, nenhuma barreira será inserida.
• parameter_prefix (str) – O prefixo usado se forem gerados parâmetros padrão.
• overwrite_block_parameters (bool) – Se os parâmetros nos blocos adicionados devem ser substituídos. Se False, os parâmetros nos blocos não serão alterados.
• skip_final_rotation_layer (bool) – Se uma camada de rotação final é adicionada ao circuito.
• skip_unentangled_qubits (bool) – Se True, as portas de rotação atuam somente nos qubits que estão emaranhados. Se False, as portas de rotação atuam em todos os qubits.
• name (str | None) – O nome do circuito.

Retorna

Um circuito n-local.

Tipo de retorno

QuantumCircuit