SparsePauliOp

Valor Padrão: 1e-08

Retorna os coeficientes de Pauli.

Retorna uma tupla (input_shape, output_shape).

Retorna o número de qubits se for um operador N-qubit ou None caso contrário.

Retorna o Parameters livre nos coeficientes.

Devolva o PauliList.

Retorna os qargs do operador.

Valor Padrão: 1e-05

Configurações de retorno.

O número de termos Pauli de Pauli no operador.

adjoint()

Retorna o adjunto do Operador.

apply_layout(layout, num_qubits=None)

Aplique um layout de transpilador a isso SparsePauliOp

Parâmetros

• layout (TranspileLayout |list[int] | None) – Um valor TranspileLayout, uma lista de números inteiros ou None. Se tanto layout quanto num_qubits forem nulos, é retornada uma cópia do operador.
• num_qubits (int | None) – O número de qubits para os quais o operador deve ser expandido. Se não for fornecido, se layout for um TranspileLayout o número de qubits do circuito de saída do transpilador será usado por padrão. Se layout for uma lista de números inteiros, a permutação especificada será aplicada sem nenhuma expansão. Se o layout for None (Nenhum), o operador será expandido para o número de qubits fornecido.

Retorna

Um novo SparsePauliOp com o layout fornecido aplicado

Tipo de retorno

SparsePauliOp

argsort(weight=False)

Retorna índices para classificar as linhas da tabela.

Retorna a composição de permutações na ordem de classificação por coeficiente e classificação por Pauli. Ao usar o kwarg de peso, a saída também pode ser classificada pelo número de termos não idênticos no Pauli, em que o conjunto de todos os Pauli's de um determinado peso ainda é ordenado lexicograficamente.

Exemplo

Aqui está um exemplo de como usar o SparsePauliOp argsort.

import numpy as np
from qiskit.quantum_info import SparsePauliOp

# 2-qubit labels
labels = ["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"]
# coeffs
coeffs = [2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j]

# init
spo = SparsePauliOp(labels, coeffs)
print('Initial Ordering')
print(spo)

# Lexicographic Ordering
srt = spo.argsort()
print('Lexicographically sorted')
print(srt)

# Lexicographic Ordering
srt = spo.argsort(weight=False)
print('Lexicographically sorted')
print(srt)

# Weight Ordering
srt = spo.argsort(weight=True)
print('Weight sorted')
print(srt)

Initial Ordering
SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
              coeffs=[2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j])
Lexicographically sorted
[4 7 0 1 2 6 5 3]
Lexicographically sorted
[4 7 0 1 2 6 5 3]
Weight sorted
[4 7 3 0 1 2 6 5]

Parâmetros

• weight (bool) – classificar opcionalmente por peso se for True (Padrão: False).
• sorted (By using the weight kwarg the output can additionally be)
• Pauli. (by the number of non-identity terms in the)

Retorna

os índices para classificar a tabela.

Tipo de retorno

Matriz

assign_parameters(parameters, inplace=False)

Vincule os Parameters livres nos coeficientes aos valores fornecidos.

Parâmetros

• parameters (Mapping[Parameter, complex |ParameterExpression] | Sequence[complex |ParameterExpression]) – Os valores aos quais os parâmetros serão vinculados.
• inplace (bool) – Se False, uma cópia do operador com os parâmetros vinculados será retornada. Se True , o próprio operador é modificado.

Retorna

Uma cópia do operador com parâmetros vinculados, se inplace for False, caso contrário, None.

Tipo de retorno

SparsePauliOp | Nenhum

chop(tol=1e-14)

Defina as partes reais e imaginárias dos coeficientes como 0 se < tol em magnitude.

Por exemplo, o operador que representa 1+1e-17j X + 1e-17 Y com uma tolerância maior que 1e-17 será reduzido para 1 X , enquanto SparsePauliOp.simplify() retornaria 1+1e-17j X.

Se tanto a parte real quanto a imaginária de um coeficiente forem 0 após o truncamento, o Pauli correspondente é removido do operador.

Parâmetros

tol (float) – A tolerância absoluta para verificar se uma parte real ou imaginária deve ser definida como 0.

Retorna

Esse operador com coeficientes cortados.

Tipo de retorno

SparsePauliOp

compose(other, qargs=None, front=False)

Retorna a composição do operador com outro SparsePauliOp.

Parâmetros

• other (SparsePauliOp) – um objeto SparsePauliOp.
• qargs (list or None) – uma lista de posições do subsistema às quais aplicar outras. Se None for aplicado a todos os subsistemas (padrão: None).
• front (bool) – Se True, compor usando o operador multiplicação à direita, em vez de multiplicação à esquerda [, padrão: False].

Retorna

O composto SparsePauliOp.

Tipo de retorno

SparsePauliOp

Aumentos

QiskitError - se outro não puder ser convertido em um operador ou tiver dimensões incompatíveis para os subsistemas especificados.

conjugate()

Retorna o conjugado do SparsePauliOp.

copy()

Faça uma cópia profunda do operador atual.

dot(other, qargs=None)

Retorna o operador multiplicado à direita self * other.

Parâmetros

• other (Operator) – um objeto operador.
• qargs (list or None) – uma lista de posições do subsistema às quais aplicar outras. Se None for aplicado a todos os subsistemas (padrão: None).

Retorna

A matriz correta multiplicou o Operator.

Tipo de retorno

Operador

equiv(other, atol=None)

Verifique se dois operadores SparsePauliOp são equivalentes.

Parâmetros

• other (SparsePauliOp) – um objeto operador.
• atol (float | None) – Tolerância numérica absoluta para verificar a equivalência.

Retorna

Verdadeiro se o operador for equivalente a self.

Tipo de retorno

bool

expand(other)

Retorna o produto tensorial de ordem inversa com outro SparsePauliOp.

Parâmetros

other (SparsePauliOp) – um objeto SparsePauliOp.

Retorna

o produto tensorial $b \otimes a$, onde $a$

é o atual SparsePauliOp, e $b$ é o outro SparsePauliOp.

Tipo de retorno

SparsePauliOp

static from_list(obj, dtype=None, *, num_qubits=None)

Construa a partir de uma lista de cadeias e coeficientes de Pauli.

Por exemplo, o Hamiltoniano de 5 qubits

pode ser construído como

from qiskit.quantum_info import SparsePauliOp

# via tuples and the full Pauli string
op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])

Parâmetros

• obj (Iterable[Tuple[str, complex]]) – A lista de 2 tuplas que especificam os termos de Pauli.
• dtype (type | None) – Tipo de dados dos coeficientes. Se None (padrão), o tipo de dados é inferido automaticamente.
• num_qubits (int) – O número de qubits do operador (Padrão: Nenhum).

Retorna

A representação SparsePauliOp dos termos de Pauli.

Tipo de retorno

SparsePauliOp

Aumentos

• QiskitError - Se uma lista vazia for passada e num_qubits for None.
• QiskitError - Se num_qubits e os objetos na lista de entrada não corresponderem.

static from_operator(obj, atol=None, rtol=None)

Criar a partir de um objeto Operator.

Observe que o custo dessa construção é exponencial em geral, pois o número de termos de Pauli possíveis na decomposição é exponencial no número de qubits.

Internamente, isso usa uma implementação da "decomposição tensorizada de Pauli" apresentada em Hantzko, Binkowski e Gupta (2023).

Parâmetros

• obj (Operator) – um operador N-qubit.
• atol (float) – Opcional. Tolerância absoluta para verificar se os coeficientes são zero (Padrão: 1e-8 ). Como a comparação é com zero, de fato a tolerância usada é a máxima de atol e rtol.
• rtol (float) – Opcional. tolerância relativa para verificar se os coeficientes são zero (Padrão: 1e-5 ). Como a comparação é com zero, de fato a tolerância usada é a máxima de atol e rtol.

Retorna

a representação SparsePauliOp do operador.

Tipo de retorno

SparsePauliOp

Aumentos

QiskitError - se o operador de entrada não for um operador N-qubit.

static from_sparse_list(obj, num_qubits, do_checks=True, dtype=None)

Construa a partir de uma lista de cadeias de Pauli locais e coeficientes.

Cada elemento da lista é uma tripla de uma cadeia de Pauli local, índices onde aplicá-la e um coeficiente.

Por exemplo, o Hamiltoniano de 5 qubits

pode ser construído como

from qiskit.quantum_info import SparsePauliOp

# via triples and local Paulis with indices
op = SparsePauliOp.from_sparse_list([("ZX", [1, 4], 1), ("YY", [0, 3], 2)], num_qubits=5)

# equals the following construction from "dense" Paulis
op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])

Parâmetros

• obj (Iterable[tuple[str, list[int], complex]]) – A lista de 3 tuplas especificando a Paulis.
• num_qubits (int) – O número de qubits do operador.
• do_checks (bool) – Se deve ser realizada uma verificação de validade nos índices de entrada.
• dtype (type | None) – Tipo de dados dos coeficientes. Se None (padrão), o tipo de dados é inferido automaticamente.

Retorna

A representação SparsePauliOp dos termos de Pauli.

Tipo de retorno

SparsePauliOp

Aumentos

• QiskitError - Se o número de qubits for incompatível com os índices dos termos de Pauli.
• QiskitError - Se o qubit designado já estiver atribuído.

static from_sparse_observable(obs)

Inicializar a partir de um SparseObservable.

Parâmetros

obs (SparseObservable) – O SparseObservable para converter.

Retorna

A SparsePauliOp versão do observável.

Tipo de retorno

SparsePauliOp

group_commuting(qubit_wise=False)

Particionar um SparsePauliOp em conjuntos de cadeias Pauli comutáveis.

Parâmetros

qubit_wise (bool) –

se a regra de comutação é aplicada a todo o operador ou em uma base por qubit. Por exemplo:

>>> from qiskit.quantum_info import SparsePauliOp
>>> op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])
>>> op.group_commuting()
[SparsePauliOp(["IZ", "ZZ"], coeffs=[0.+2.j, 0.+1j]),
 SparsePauliOp(["XX", "YY"], coeffs=[2.+0.j, 1.+0.j])]
>>> op.group_commuting(qubit_wise=True)
[SparsePauliOp(['XX'], coeffs=[2.+0.j]),
 SparsePauliOp(['YY'], coeffs=[1.+0.j]),
 SparsePauliOp(['IZ', 'ZZ'], coeffs=[0.+2.j, 0.+1.j])]

Retorna

Lista de SparsePauliOp onde cada SparsePauliOp contém

operadores Pauli comutantes.

Tipo de retorno

lista [ SparsePauliOp ]

input_dims(qargs=None)

Retorna uma tupla de dimensão de entrada para os subsistemas especificados.

is_unitary(atol=None, rtol=None)

Retorna True se o operador for uma matriz unitária.

Esse método verifica se o operador composto com seu adjunto é igual à identidade, até a tolerância fornecida. A tolerância é usada ao simplificar o operador composto e verificar se o resultado é a identidade.

Parâmetros

• atol (float) – Opcional. Tolerância absoluta para verificar se os coeficientes são zero (Padrão: 1e-8 ).
• rtol (float) – Opcional. Tolerância relativa para verificar se os coeficientes são zero (Padrão: 1e-5 ).

Retorna

Verdadeiro se o operador for unitário, Falso caso contrário.

Tipo de retorno

bool

label_iter()

Retorna um iterador de representação de rótulos.

Esse é um iterador preguiçoso que converte cada termo no site SparsePauliOp em uma tupla (rótulo, coeff). Para converter a tabela inteira em rótulos, use o método to_labels() .

Retorna

objeto iterador de rótulos para o site SparsePauliOp.

Tipo de retorno

LabelIterator

matrix_iter(sparse=False)

Retorna um iterador de representação de matriz.

Esse é um iterador preguiçoso que converte cada termo no site SparsePauliOp em uma matriz à medida que é usado. Para converter em uma única matriz, use o método to_matrix() método.

Parâmetros

sparse (bool) – opcionalmente, retorna matrizes CSR esparsas se True; caso contrário, retorna matrizes em forma de matriz Numpy (Padrão: False)

Retorna

objeto iterador de matriz para PauliList.

Tipo de retorno

MatrixIterator

noncommutation_graph(qubit_wise)

Crie o gráfico de não comutação deste SparsePauliOp.

Isso transforma o problema de agrupamento do operador de medição em um problema de coloração de gráfico. O gráfico construído contém um nó para cada Pauli. Os nós serão conectados para quaisquer dois termos de Pauli que não _not_ comutam.

Parâmetros

qubit_wise (bool) – se a regra de comutação é aplicada a todo o operador ou em uma base por qubit.

Retorna

o gráfico de não comutação com nós para cada Pauli e bordas

indicando uma relação de não comutação. Cada nó conterá o índice do termo de Pauli ao qual corresponde em seus dados. As bordas do gráfico não contêm dados.

Tipo de retorno

rustworkx.PyGraph

output_dims(qargs=None)

Retorna uma tupla de dimensão de saída para os subsistemas especificados.

power(n)

Retorna a composição de um operador consigo mesmo n vezes.

Parâmetros

n (int) – o número de vezes para compor com o self ( n>0 ).

Retorna

o operador composto n vezes.

Tipo de retorno

Clifford

Aumentos

QiskitError - se as dimensões de entrada e saída do operador não forem iguais ou se a potência não for um número inteiro positivo.

reshape(input_dims=None, output_dims=None, num_qubits=None)

Retorna uma cópia superficial com dimensões reformuladas do subsistema de entrada e saída.

Parâmetros

• input_dims (None or tuple) – novas dimensões de entrada do subsistema. Se for None (Nenhum), as dimensões de entrada originais serão preservadas [Padrão: Nenhum].
• output_dims (None or tuple) – novas dimensões de saída do subsistema. Se for None (Nenhum), os dims de saída originais serão preservados [Padrão: Nenhum].
• num_qubits (None or int) – remodelar para um operador N-qubit [Padrão: Nenhum].

Retorna

retorna self com dimensões de entrada e saída remodeladas.

Tipo de retorno

BaseOperator

Aumentos

QiskitError - se o tamanho combinado de todas as dimensões de entrada do subsistema ou de saída do subsistema não for constante.

simplify(atol=None, rtol=None)

Simplifique o site PauliList combinando duplicatas e removendo zeros.

Parâmetros

• atol (float) – Opcional. Tolerância absoluta para verificar se os coeficientes são zero (Padrão: 1e-8 ).
• rtol (float) – Opcional. tolerância relativa para verificar se os coeficientes são zero (Padrão: 1e-5 ).

Retorna

o operador SparsePauliOp simplificado.

Tipo de retorno

SparsePauliOp

sort(weight=False)

Classifique as linhas da tabela.

Depois de classificar os coeficientes usando o argsort do numpy, classifique por Pauli. A classificação de Pauli tem precedência. Se Pauli for o mesmo, ele será classificado por coeficiente. Ao usar o kwarg de peso, a saída também pode ser classificada pelo número de termos não idênticos no Pauli, em que o conjunto de todos os Pauli's de um determinado peso ainda é ordenado lexicograficamente.

Exemplo

Aqui está um exemplo de como usar o SparsePauliOp sort.

import numpy as np
from qiskit.quantum_info import SparsePauliOp

# 2-qubit labels
labels = ["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"]
# coeffs
coeffs = [2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j]

# init
spo = SparsePauliOp(labels, coeffs)
print('Initial Ordering')
print(spo)

# Lexicographic Ordering
srt = spo.sort()
print('Lexicographically sorted')
print(srt)

# Lexicographic Ordering
srt = spo.sort(weight=False)
print('Lexicographically sorted')
print(srt)

# Weight Ordering
srt = spo.sort(weight=True)
print('Weight sorted')
print(srt)

Initial Ordering
SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
              coeffs=[2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j])
Lexicographically sorted
SparsePauliOp(['II', 'XI', 'XX', 'XX', 'XX', 'XY', 'XZ', 'YI'],
              coeffs=[4.+0.j, 7.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j, 3.+0.j])
Lexicographically sorted
SparsePauliOp(['II', 'XI', 'XX', 'XX', 'XX', 'XY', 'XZ', 'YI'],
              coeffs=[4.+0.j, 7.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j, 3.+0.j])
Weight sorted
SparsePauliOp(['II', 'XI', 'YI', 'XX', 'XX', 'XX', 'XY', 'XZ'],
              coeffs=[4.+0.j, 7.+0.j, 3.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j])

Parâmetros

• weight (bool) – classificar opcionalmente por peso se for True (Padrão: False).
• sorted (By using the weight kwarg the output can additionally be)
• Pauli. (by the number of non-identity terms in the)

Retorna

uma cópia ordenada da tabela original.

Tipo de retorno

SparsePauliOp

static sum(ops)

Soma de SparsePauliOps.

Essa é uma versão especializada da função sum integrada para SparsePauliOp com menor sobrecarga.

Parâmetros

ops (list[SparsePauliOp]) – uma lista de SparsePauliOps.

Retorna

o SparsePauliOp que representa a soma da lista de entrada.

Tipo de retorno

SparsePauliOp

Aumentos

• QiskitError - se a lista de entrada estiver vazia.
• QiskitError - se a lista de entrada incluir um objeto que não seja SparsePauliOp.
• QiskitError - se os números de qubits dos objetos na lista de entrada não corresponderem.

tensor(other)

Retorna o produto tensorial com outro SparsePauliOp.

Parâmetros

other (SparsePauliOp) – um objeto SparsePauliOp.

Retorna

o produto tensorial $a \otimes b$, onde $a$

é o atual SparsePauliOp, e $b$ é o outro SparsePauliOp.

Tipo de retorno

SparsePauliOp

to_list(array=False)

Converta em uma lista de rótulos e coeficientes da cadeia de Pauli.

Para operadores com muitos termos, a conversão usando o array=True kwarg será mais eficiente, pois aloca antecipadamente a memória para a matriz completa de rótulos do Numpy.

Parâmetros

array (bool) – retorna uma matriz Numpy se for True; caso contrário, retorna uma lista (Padrão: False).

Retorna

Lista de pares (rótulo, coeff) para linhas do site PauliList.

Tipo de retorno

lista ou matriz

to_matrix(sparse=False, force_serial=False)

Converter em uma matriz densa ou esparsa.

Parâmetros

• sparse (bool) – se True retornar uma matriz CSR esparsa; caso contrário, retornar uma matriz Numpy densa (o padrão).
• force_serial (bool) – se True, use uma implementação sem threads, independentemente do estado das variáveis de ambiente de controle de threading do Qiskit. Por padrão, isso usará o paralelismo com threads nas CPUs disponíveis.

Retorna

Uma matriz densa se sparse=False. csr_matrix: Uma matriz esparsa no formato CSR se sparse=True.

Tipo de retorno

Matriz

to_operator()

Converter em um objeto Operator de matriz

Tipo de retorno

Operador

to_sparse_list()

Converta para um formato de lista Pauli esparsa com elementos (pauli, qubits, coeficiente).

transpose()

Retorna a transposição do SparsePauliOp.