QubitSparsePauli

class qiskit.quantum_info.QubitSparsePauli(data, /, num_qubits=None)

Bases: object

Um operador Pauli sem fase armazenado em um formato esparso de qubit.

Representação

Um operador Pauli é um produto tensorial de operadores Pauli de um único qubit da forma $P = \bigotimes_n A^{(n)}_i$ , para $A^{(n)}_i \in \{I, X, Y, Z\}$ . A representação interna de um QubitSparsePauli armazena apenas os operadores de Pauli de um único qubit sem identidade.

Internamente, cada operador Pauli de um único qubit é armazenado com um valor numérico, explicitamente:

Rótulo	Operador	Valor numérico	`Pauli` atributo
`"I"`	$I$ (identidade)	Não armazenado.	Não armazenado.
`"X"`	$X$ (Pauli X)	`0b10` (2)	`X`
`"Y"`	$Y$ (Pauli Y)	`0b11` (3)	`Y`
`"Z"`	$Z$ (Pauli Z)	`0b01` (1)	`Z`

Atributo	Duração	Descrição
`paulis`	$s$	Cada um dos operadores Pauli de um único qubit sem identidade. Elas correspondem à não identidade $A^{(n)}_i$ na lista, em que as entradas são armazenadas em ordem crescente de $i$ primeiro e em ordem crescente de $n$ dentro de cada termo.
`indices`	$s$	O qubit correspondente ( $n$ ) para cada um dos operadores em `paulis`. `QubitSparsePauli` exige que essa lista seja classificada por termos, e os algoritmos podem contar com a manutenção desse invariante.

O parâmetro $s$ é o número total de termos de um único qubit sem identidade.

O item escalar da matriz paulis é armazenado como um byte numérico. Os valores numéricos estão relacionados à representação Pauli simétrica que SparsePauliOp usa, e podem ser acessados com acesso nomeado por uma enumeração:

Pauli

class Pauli

GitHub

Um IntEnum que fornece acesso nomeado aos valores numéricos usados para representar cada um dos termos do alfabeto de um único qubit enumerados em Alphabet of single-qubit Pauli operators used in QubitSparsePauliList.

Essa classe é anexada a QubitSparsePauli. Acesse-o como QubitSparsePauli.Pauli. Se isso for muita digitação e você estiver lidando apenas com QubitSparsePauliList e o nome Pauli não for ambíguo, talvez você queira encurtá-lo como:

>>> ops = QubitSparsePauli.Pauli
>>> assert ops.X is QubitSparsePauli.Pauli.X

Você pode acessar todos os valores da enumeração com acesso a atributos ou com indexação semelhante a um dicionário por string:

>>> assert QubitSparsePauli.Pauli.X is QubitSparsePauli.Pauli["X"]

Os bits que representam cada Pauli de um único qubit são a representação simpática (sem fase) do operador Pauli.

Valores

X

Valor Padrão: 2

O operador Pauli $X$ . Usa o rótulo de letra única "X".

Y

Valor Padrão: 3

O operador Pauli $Y$ . Usa o rótulo de letra única "Y".

Z

Valor Padrão: 1

O operador Pauli $Z$ . Usa o rótulo de letra única "Z".

Cada um dos atributos do tipo matriz se comporta como uma sequência Python. Você pode indexar e fatiar esses dados com a semântica padrão list-como a semântica padrão. O corte de um atributo retorna um Numpy ndarray contendo uma cópia dos dados relevantes com o dtype natural do campo; isso permite que você faça matemática facilmente nos resultados, como operações bit a bit em paulis.

Construção

QubitSparsePauli define vários construtores. O construtor padrão tentará delegar a um dos construtores mais específicos, com base no tipo de entrada. Você sempre pode usar os construtores específicos para ter mais controle sobre a construção.

Método	Resumo
`from_label()`	Converta um rótulo de string denso em um `QubitSparsePauli`.
`from_sparse_label()`	Crie um `QubitSparsePauli` a partir de uma tupla de um rótulo de cadeia esparsa e os qubits aos quais se aplicam.
`from_pauli()`	Elevar um único `Pauli` em um `QubitSparsePauli`.
`from_raw_parts()`	Crie o operador a partir das matrizes de dados brutos.

new

__new__(data, /, num_qubits=None)

O construtor padrão do QubitSparsePauli.

Isso delega a um dos métodos de construtor de conversão explícitos, 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 QubitSparsePaulie, nesse caso, a entrada é copiada, ou pode ser um formato válido para from_label() ou from_sparse_label().
num_qubits (int|None) – Número opcional de qubits para o operador. Para a maioria das entradas de dados, isso pode ser inferido e não precisa ser passado. Isso só é necessário para o formato de rótulo esparso. Se for fornecido desnecessariamente, deverá corresponder à entrada de dados.

Atributos

indices

Visualização somente de leitura dos índices de cada termo de qubit único sem identidade.

Os índices sempre estarão em ordem ordenada.

num_qubits

O número de qubits em que o termo é definido.

paulis

Visualização somente de leitura dos termos individuais de um único qubit.

Os únicos valores válidos na matriz são aqueles com um Pauli.

Métodos

commutes

commutes(other)

Verifique se self` comuta com outro qubit sparse pauli.

Parâmetros

other (QubitSparsePauli) – o qubit esparso Pauli para verificar a comutação com.

compose

compose(other)

Composição sem fase com outra QubitSparsePauli.

Parâmetros

other (QubitSparsePauli) – o qubit esparso Pauli para compor.

copy

copy()

Obtenha uma cópia deste termo.

from_label

static from_label(label, /)

Constrói a partir de um rótulo de string denso.

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

>>> QubitSparsePauli.from_label("IIIIXZI")
<QubitSparsePauli on 7 qubits: X_2 Z_1>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert QubitSparsePauli.from_label(label) == QubitSparsePauli.from_pauli(pauli)

from_pauli

static from_pauli(pauli, /)

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

Observe que a fase do Pauli foi eliminada.

Parâmetros

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

Exemplos

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> QubitSparsePauli.from_pauli(pauli)
<QubitSparsePauli on 5 qubits: Y_3 X_2 Z_1>
>>> assert QubitSparsePauli.from_label(label) == QubitSparsePauli.from_pauli(pauli)

from_raw_parts

static from_raw_parts(num_qubits, paulis, indices)

Construa um QubitSparsePauli a partir de matrizes Numpy brutas que correspondem à representação de dados necessária descrita na documentação em nível de classe.

Os dados de cada matriz são copiados em alocações de espaço Rust novas e crescentes.

Parâmetros

num_qubits - número de qubits em que o operador atua.
paulis - lista dos termos de um único qubit. Esse deve ser um array Numpy com dtype uint8 (que é compatível com Pauli).
índices - lista ordenada dos qubits aos quais cada termo de qubit único corresponde. Esse deve ser um array Numpy com dtype uint32.

Exemplos

Construa um operador $Z$ que atue no qubit 50 de 100 qubits.

>>> num_qubits = 100
>>> terms = np.array([QubitSparsePauli.Pauli.Z], dtype=np.uint8)
>>> indices = np.array([50], dtype=np.uint32)
>>> QubitSparsePauli.from_raw_parts(num_qubits, terms, indices)
<QubitSparsePauli on 100 qubits: Z_50>

from_sparse_label

static from_sparse_label(sparse_label, num_qubits)

Construa um qubit esparso Pauli a partir de um rótulo esparso, fornecido como uma tupla de uma cadeia de Paulis e os índices dos qubits correspondentes.

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

Parâmetros

sparse_label (tuple[str, Sequence[int]]) – e os qubits aos quais cada termo de qubit único se aplica.
num_qubits (int) – o número de qubits em que o operador atua.

Exemplos

Construa um Pauli simples:

>>> QubitSparsePauli.from_sparse_label(
...     ("ZX", (1, 4)),
...     num_qubits=5,
... )
<QubitSparsePauli on 5 qubits: X_4 Z_1>

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

>>> label = "XYXZ"
>>> from_label = QubitSparsePauli.from_label(label)
>>> from_sparse_label = QubitSparsePauli.from_sparse_label(
...     (label, (3, 2, 1, 0)),
...     num_qubits=4
... )
>>> assert from_label == from_sparse_label

identity

static identity(num_qubits)

Obtenha o operador de identidade para um determinado número de qubits.

Exemplos

Obtenha a identidade em 100 qubits:

>>> QubitSparsePauli.identity(100)
<QubitSparsePauli on 100 qubits: >

to_pauli

to_pauli()

Retorna um Pauli representando o mesmo Pauli sem fase.

to_qubit_sparse_pauli_list

to_qubit_sparse_pauli_list()

Converta esse Pauli em um único elemento QubitSparsePauliList.

Esta página foi útil?

Relate um bug, erro de digitação ou solicite conteúdo no GitHub.