PhasedQubitSparsePauliList

__new__(data, /, num_qubits=None)

O construtor padrão do PhasedQubitSparsePauliList.

Isso delega a um dos métodos explícitos do construtor de conversão, com base no tipo do argumento data . Se num_qubits for fornecido e o construtor implícito pelo tipo de data não aceitar um número, o número inteiro fornecido deverá corresponder à entrada.

Parâmetros

• data - O tipo de dados da entrada. Pode ser outro PhasedQubitSparsePauliListe, nesse caso, a entrada é copiada, ou pode ser uma lista em um formato válido para from_list() ou from_sparse_list().
• num_qubits (int|None) – Número opcional de qubits para a lista. Para a maioria das entradas de dados, isso pode ser inferido e não precisa ser passado. Isso só é necessário para listas vazias ou para o formato de lista esparsa. Se for fornecido desnecessariamente, deverá corresponder à entrada de dados.

O número de qubits em que os operadores da lista atuam.

Isso não pode ser inferido de nenhuma outra forma ou valor, pois as identidades não são armazenadas explicitamente.

O número de elementos na lista.

apply_layout(layout, num_qubits=None)

Aplique um layout de transpilador a essa lista Pauli esparsa de qubits em fase.

Isso permite o remapeamento de índices de qubit, por exemplo, se a lista for definida em termos de rótulos de qubit virtual.

Parâmetros

• layout (TranspileLayout |list[int] | None) – O layout a ser aplicado. A maioria dos usos dessa função deve passar o campo QuantumCircuit.layout de um circuito que foi transpilado para hardware. Além disso, você pode passar uma lista de novos índices de qubit. Se for fornecido explicitamente como None, nenhum remapeamento será aplicado (mas você ainda poderá usar num_qubits para expandir os qubits na lista).
• num_qubits (int | None) – O número de qubits para expandir os elementos da lista. Se não for fornecido, a saída terá a mesma largura da entrada fornecida TranspileLayoutou a mesma largura da entrada se o endereço layout for fornecido em outro formato.

Retorna

Um novo QubitSparsePauli com o layout fornecido aplicado.

clear()

Limpa todos os elementos da lista, tornando-a igual à lista vazia novamente.

Isso não altera a capacidade das alocações internas; portanto, operações subsequentes de adição ou subtração resultantes da composição podem não exigir uma realocação.

Exemplos

>>> pauli_list = PhasedQubitSparsePauliList.from_list(["IXXXYY", "ZZYZII"])
>>> pauli_list.clear()
>>> assert pauli_list == PhasedQubitSparsePauliList.empty(pauli_list.num_qubits)

copy()

Obtenha uma cópia dessa lista Pauli esparsa de qubits.

Exemplos

>>> phased_qubit_sparse_pauli_list = PhasedQubitSparsePauliList.from_list(["IXZXYYZZ", "ZXIXYYZZ"])
>>> assert phased_qubit_sparse_pauli_list == phased_qubit_sparse_pauli_list.copy()
>>> assert phased_qubit_sparse_pauli_list is not phased_qubit_sparse_pauli_list.copy()

static empty(num_qubits)

Obtém a lista vazia para um determinado número de qubits.

A lista vazia não contém elementos e é o elemento de identidade para unir duas PhasedQubitSparsePauliList instâncias.

Exemplos

Obtenha a lista vazia em 100 qubits:

>>> PhasedQubitSparsePauliList.empty(100)
<PhasedQubitSparsePauliList with 0 elements on 100 qubits: []>

static from_label(label, /)

Constrói uma lista com um único termo a partir de um rótulo de cadeia densa.

O rótulo deve ser uma sequência do alfabeto 'IXYZ'. O rótulo é interpretado de forma análoga a uma cadeia de bits. Em outras palavras, a letra mais à direita está associada ao qubit 0, e assim por diante. Isso é o mesmo que os rótulos de Pauli e SparsePauliOp.

Parâmetros

label (str) – o rótulo denso.

Exemplos

>>> PhasedQubitSparsePauliList.from_label("IIIIXZI")
<PhasedQubitSparsePauliList with 1 element on 7 qubits: [X_2 Z_1]>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert PhasedQubitSparsePauliList.from_label(label) == PhasedQubitSparsePauliList.from_pauli(pauli)

static from_list(iter, /, *, num_qubits=None)

Construa uma lista Pauli esparsa de qubits em fase a partir de uma lista de rótulos densos.

Isso é análogo a SparsePauliOp.from_list(). Nesse formulário denso, você deve fornecer todas as identidades explicitamente em cada rótulo.

O rótulo deve ser uma sequência do alfabeto 'IXYZ'. O rótulo é interpretado de forma análoga a uma cadeia de bits. Em outras palavras, a letra mais à direita está associada ao qubit 0, e assim por diante. Isso é o mesmo que os rótulos de Pauli e SparsePauliOp.

Parâmetros

• iter (list[str]) – Lista de rótulos de strings densas.
• num_qubits (int | None) – Não é necessário especificar isso se você tiver certeza de que iter não é uma sequência vazia, pois isso pode ser inferido a partir dos comprimentos dos rótulos. Se iter puder estar vazio, você deverá especificar esse argumento para não ambiguidade em quantos qubits os operadores atuam. Se isso for fornecido e iter não estiver vazio, o valor deverá corresponder aos comprimentos do rótulo.

Exemplos

Construa uma lista Pauli esparsa de qubits a partir de uma lista de rótulos:

>>> PhasedQubitSparsePauliList.from_list([
...     "IIIXX",
...     "IIYYI",
...     "IXXII",
...     "ZZIII",
... ])
<PhasedQubitSparsePauliList with 4 elements on 5 qubits:
    [X_1 X_0, Y_2 Y_1, X_3 X_2, Z_4 Z_3]>

Use num_qubits para eliminar a ambiguidade de entradas potencialmente vazias:

>>> PhasedQubitSparsePauliList.from_list([], num_qubits=10)
<PhasedQubitSparsePauliList with 0 elements on 10 qubits: []>

Esse método é equivalente a chamadas para from_sparse_list() com o campo explícito qubit-arguments definido como números inteiros decrescentes:

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> from_list = PhasedQubitSparsePauliList.from_list(labels)
>>> from_sparse_list = PhasedQubitSparsePauliList.from_sparse_list([
...     (label, (3, 2, 1, 0))
...     for label in labels
... ])
>>> assert from_list == from_sparse_list

static from_pauli(pauli, /)

Construir um PhasedQubitSparsePauliList a partir de uma única Pauli instância.

A lista de saída terá um único termo. Observe que a fase é eliminada.

Parâmetros

pauli (Pauli) – a única Pauli para converter.

Exemplos

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> PhasedQubitSparsePauliList.from_pauli(pauli)
<PhasedQubitSparsePauliList with 1 element on 5 qubits: [Y_3 X_2 Z_1]>
>>> assert PhasedQubitSparsePauliList.from_label(label) == PhasedQubitSparsePauliList.from_pauli(pauli)

static from_phased_qubit_sparse_paulis(obj, /, num_qubits=None)

Construir um PhasedQubitSparsePauliList a partir de instâncias individuais de PhasedQubitSparsePauli instâncias.

Todos os termos devem ter o mesmo número de qubits. Se fornecido, o argumento num_qubits deve corresponder aos termos.

Parâmetros

• obj (Iterable[PhasedQubitSparsePauli]) – Iterável de termos individuais para criar a lista.
• num_qubits (int | None) – O número de qubits em que os elementos da lista devem atuar. Isso geralmente é inferido a partir da entrada, mas pode ser explicitamente fornecido para lidar com o caso de um iterável vazio.

Retorna

A lista correspondente.

static from_sparse_list(iter, /, num_qubits)

Construa uma lista Pauli esparsa de qubits em fase a partir de uma lista de rótulos e dos qubits aos quais cada item se aplica.

Isso é análogo a SparsePauliOp.from_sparse_list().

Os campos "labels" (rótulos) e "indices" (índices) das tuplas são associados por meio de um zíper. Por exemplo, isso significa que uma chamada para from_list() pode ser convertida para a forma usada por esse método, definindo o campo "indices" de cada tripla como (num_qubits-1, ..., 1, 0).

Parâmetros

• iter (list[tuple[int, str, Sequence[int]]]) – tuplas de expoentes de fase, rótulos e os qubits aos quais cada termo de qubit único se aplica.
• num_qubits (int) – o número de qubits em que os operadores da lista atuam.

Exemplos

Construa uma lista simples:

>>> PhasedQubitSparsePauliList.from_sparse_list(
...     [(0, "ZX", (1, 4)), (1, "YY", (0, 3))],
...     num_qubits=5,
... )
<PhasedQubitSparsePauliList with 2 elements on 5 qubits: [X_4 Z_1, (-i)Y_3 Y_0]>

Esse método pode replicar o comportamento de from_list()se o campo qubit-arguments da tupla for definido como números inteiros decrescentes:

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> from_list = PhasedQubitSparsePauliList.from_list(labels)
>>> from_sparse_list = PhasedQubitSparsePauliList.from_sparse_list([
...     (label, (3, 2, 1, 0))
...     for label in labels
... ])
>>> assert from_list == from_sparse_list

to_pauli_list()

Retorna um PauliList representando a mesma lista de Paulis.

to_sparse_list()

Expresse a lista em termos de um formato de lista esparsa.

Isso pode ser visto como uma contraoperação de PhasedQubitSparsePauliList.from_sparse_list()no entanto, não é garantido que a ordem dos termos seja a mesma depois de uma viagem de ida e volta para uma lista esparsa.

Exemplos

>>> phased_qubit_sparse_list = PhasedQubitSparsePauliList.from_list(["IIXIZ", "IIZIX"])
>>> reconstructed = PhasedQubitSparsePauliList.from_sparse_list(phased_qubit_sparse_list.to_sparse_list(), qubit_sparse_list.num_qubits)