PauliLindbladMap

__new__(data, /, num_qubits=None)

O construtor padrão do PauliLindbladMap.

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 PauliLindbladMape, 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 o mapa. 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 o mapa atua.

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 termos do gerador no expoente desse mapa.

As taxas do mapa.

apply_layout(layout, num_qubits=None)

Aplique um layout de transpilador a esse mapa de Pauli Lindblad.

Isso permite o remapeamento de índices de qubit, por exemplo, se o mapa for definido 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 o mapa).
• num_qubits (int | None) – O número de qubits para os quais expandir o mapa. Se não for fornecido, a saída terá a mesma largura que a entrada fornecida TranspileLayoutou a mesma largura da entrada se o endereço layout for fornecido em outro formato.

Retorna

Um novo PauliLindbladMap com o layout fornecido aplicado.

clear()

Limpe todos os termos geradores desse mapa, tornando-o novamente igual ao mapa de identidade.

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_lindblad_map = PauliLindbladMap.from_list([("IXXXYY", 2.0), ("ZZYZII", -1)])
>>> pauli_lindblad_map.clear()
>>> assert pauli_lindblad_map == PauliLindbladMap.identity(pauli_lindblad_map.py_num_qubits())

compose(other)

Compor com outro PauliLindbladMap.

Isso anexa as matrizes internas de self e other e, portanto, resulta em um mapa cujos termos enumerados são os de self seguidos pelos de other.

Parâmetros

other (PauliLindbladMap) – o mapa Pauli Lindblad para compor.

copy()

Obtenha uma cópia desse mapa da Pauli Lindblad.

Exemplos

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IXZXYYZZ", 2.5), ("ZXIXYYZZ", 0.5)])
>>> assert pauli_lindblad_map == pauli_lindblad_map.copy()
>>> assert pauli_lindblad_map is not pauli_lindblad_map.copy()

drop_paulis(indices)

Retire Paulis deste mapa de Pauli Lindblad.

Elimine todos os Pauli nos índices fornecidos, substituindo-os efetivamente por uma identidade.

O mapa resultante pode conter duplicatas, que podem ser removidas usando o método PauliLindbladMap.simplify() método.

Parâmetros

indices (Sequence[int]) – Os índices para os quais a Paulis deve ser descartada.

Retorna

Um novo mapa de Pauli Lindblad em que todos os Pauli nos índices fornecidos foram eliminados.

Exemplos

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

drop_qubits(indices)

Retire os qubits desse mapa de Pauli Lindblad, realizando efetivamente uma operação de rastreamento.

O mapa resultante pode conter duplicatas, que podem ser removidas usando o método PauliLindbladMap.simplify() método.

Parâmetros

indices (Sequence[int]) – Os índices dos qubits a serem rastreados.

Retorna

Um novo mapa de Pauli Lindblad em que todos os Pauli nos índices fornecidos foram rastreados.

Exemplos

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.drop_qubits([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

static from_components(rates, qubit_sparse_pauli_list)

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

Construa um mapa de Pauli Lindblad a partir de uma lista de rótulos e taxas de geradores 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[tuple[str, float]]) – Pares de rótulos e suas taxas associadas na soma do gerador.
• 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 o mapa atua. Se isso for fornecido e iter não estiver vazio, o valor deverá corresponder aos comprimentos do rótulo.

Exemplos

Construa um mapa de Pauli Lindblad a partir de uma lista de rótulos:

>>> PauliLindbladMap.from_list([
...     ("IIIXX", 1.0),
...     ("IIYYI", 1.0),
...     ("IXXII", -0.5),
...     ("ZZIII", -0.25),
... ])
<PauliLindbladMap with 4 terms on 5 qubits:
    (1)L(X_1 X_0) + (1)L(Y_2 Y_1) + (-0.5)L(X_3 X_2) + (-0.25)L(Z_4 Z_3)>

Use num_qubits para eliminar a ambiguidade de entradas potencialmente vazias:

>>> PauliLindbladMap.from_list([], num_qubits=10)
<PauliLindbladMap with 0 terms on 10 qubits: 0.0>

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"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

static from_sparse_list(iter, /, num_qubits)

Construa um mapa de Pauli Lindblad a partir de uma lista de rótulos, os qubits aos quais cada item se aplica e a taxa de todo o termo.

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

Os campos "labels" (rótulos) e "indices" (índices) das triplas 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[str, Sequence[int], float]]) – triplas de rótulos, os qubits aos quais cada termo de qubit único se aplica e a taxa de todo o termo.
• num_qubits (int) – o número de qubits em que o mapa atua.

Exemplos

Construa um mapa simples:

>>> PauliLindbladMap.from_sparse_list(
...     [("ZX", (1, 4), 1.0), ("YY", (0, 3), 2)],
...     num_qubits=5,
... )
<PauliLindbladMap with 2 terms on 5 qubits: (1)L(X_4 Z_1) + (2)L(Y_3 Y_0)>

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

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

static from_terms(obj, /, num_qubits=None)

Construa um PauliLindbladMap a partir de termos individuais.

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

Nenhuma simplificação é feita como parte da criação do mapa.

Parâmetros

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

Retorna

O mapa correspondente.

gamma()

Calcule o endereço $\gamma$ para o mapa.

generators()

Obtenha os geradores do mapa.

Este é um alias para get_qubit_sparse_pauli_list_copy(), oferecendo um nome mais prático que se alinha às convenções de nomenclatura utilizadas no Aer e no Runtime para classes semelhantes.

Retorna

Uma cópia dos termos do gerador do mapa.

Tipo de retorno

QubitSparsePauliList

get_qubit_sparse_pauli_list_copy()

Obtenha uma cópia da lista pauli esparsa de qubits do mapa.

static identity(num_qubits)

Obtém o mapa de identidade no número de qubits fornecido.

O mapa de identidade não contém termos geradores e é o elemento de identidade para a composição de duas instâncias PauliLindbladMap qualquer coisa composta com o mapa de identidade é igual a ele mesmo.

Exemplos

Obtenha o mapa de identidade em 100 qubits:

>>> PauliLindbladMap.identity(100)
<PauliLindbladMap with 0 terms on 100 qubits: 0.0>

inverse()

Retorna um novo PauliLindbladMap que é o inverso matemático de self.

keep_paulis(indices)

Mantenha todos os Pauli nos índices fornecidos e elimine todos os outros.

Isso é equivalente a usar PauliLindbladMap.drop_paulis() no conjunto complementar de índices.

Parâmetros

indices (Sequence[int]) – Os índices para os quais o Paulis deve ser mantido.

Retorna

Um novo mapa de Pauli Lindblad em que todos os Pauli nos índices fornecidos foram mantidos e todos os outros Paulis foram descartados.

Exemplos

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

keep_qubits(indices)

Mantenha cada qubit nos índices fornecidos e rastreie todos os outros qubits.

Isso é equivalente a usar PauliLindbladMap.drop_qubits() no conjunto complementar de índices.

Parâmetros

indices (Sequence[int]) – Os índices para os quais os qubits devem ser mantidos.

Retorna

Um novo mapa de Pauli Lindblad em que cada qubit nos índices fornecidos foi mantido e todos os outros qubits foram rastreados.

Exemplos

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_qubits([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

parity_sample(num_samples, seed=None, scale=None, local_scale=None)

Amostra de sinal e pares de operadores Pauli do mapa.

Cada sinal é representado por um booleano, com True representando -1e False representando +1.

Dada a representação de quase-probabilidade fornecida na documentação em nível de classe, cada amostra é extraída por meio do seguinte processo:

• Inicialize o sinal booleano e uma instância QubitSparsePauli para o operador de identidade.
• Iterar por cada Pauli no mapa. Usando a pseudoprobabilidade associada a cada operador, escolha aleatoriamente entre aplicar ou não o operador.
• Se o operador for aplicado, atualize o :class`QubitSparsePauli` multiplicando-o pelo Pauli. Se a taxa associada ao Pauli for negativa, inverta o sinal booleano.

Os resultados são retornados como uma matriz 1d de booleanos, e o qubit esparso Paulis amostrado correspondente na forma de um QubitSparsePauliList.

Os argumentos scale e local_scale podem ser usados para alterar as taxas subjacentes utilizadas no processo de amostragem sem modificar a instância atual ou exigir a criação de uma nova. O scale argumento dimensiona todas as taxas por um flutuante fixo e local_scale dimensiona as taxas termo a termo.

Parâmetros

• num_samples (int) – Número de amostras a serem extraídas.
• seed (int) – Semente aleatória.
• scale (float) – Escala a aplicar a todas as taxas.
• local_scale (list[float]) – Escala local a aplicar em cada semestre.

Retorna

A matriz booleana de sinais e a lista de paulis esparsos de qubit.

Tipo de retorno

sinais, qubit_sparse_pauli_list

pauli_fidelity(qubit_sparse_pauli)

Calcule a fidelidade Pauli desse mapa para um qubit Pauli esparso.

Para um Pauli $Q$, a fidelidade com relação ao mapa de Pauli Lindblad $\Lambda$ é o número real $f(Q)$ para o qual $\Lambda(Q) = f(Q) Q$. I.e. cada Pauli é um vetor próprio do mapa linear $\Lambda$, e a fidelidade é o valor próprio correspondente. Para um mapa Pauli Lindblad com conjunto gerador $K$ e função de taxa $\lambda : K \rightarrow \mathbb{R}$, a fidelidade pauli é matematicamente

em que $\langle P, Q\rangle_{sp}$ é $0$ se $P$ e $Q$ forem comuns, e $1$ se forem incomuns.

Args: qubit_sparse_pauli ( QubitSparsePauli ): o qubit sparse Pauli para calcular o Pauli

fidelidade de.

probabilities()

Calcule as probabilidades $p_P$ para o mapa. Estas podem ser interpretadas como as probabilidades de cada gerador não ser aplicado e são definidas como independentes do sinal de cada taxa de Lindblad.

sample(num_samples, seed=None)

Para PauliLindbladMap casos com taxas puramente não negativas, amostre os operadores de Pauli a partir do mapa. Se o mapa tiver taxas negativas, use PauliLindbladMap.parity_sample().

Dada a representação de quase-probabilidade fornecida na documentação em nível de classe, cada amostra é extraída por meio do seguinte processo:

• Inicialize uma instância de :class`~.QubitSparsePauli` com o operador de identidade.
• Iterar por cada Pauli no mapa. Usando a pseudoprobabilidade associada a cada operador, escolha aleatoriamente entre aplicar ou não o operador.
• Se o operador for aplicado, atualize o :class`QubitSparsePauli` multiplicando-o pelo Pauli.

Os Paulis esparsos de qubit amostrados são retornados na forma de um QubitSparsePauliList.

Parâmetros

• num_samples (int) – Número de amostras a serem extraídas.
• seed (int) – Semente aleatória. Padroniza para None.

Retorna

A lista de qubit sparse paulis.

Tipo de retorno

qubit_sparse_pauli_list

Aumentos

ValueError - Se alguma das taxas no mapa for negativa.

scale_rates(scale_factor)

Retorna um novo PauliLindbladMap com taxas dimensionadas pelo fator scale_factor.

Parâmetros

scale_factor (float) – o coeficiente de escala.

signed_sample(num_samples, seed=None)

Exemplos de pares de sinais e operadores de Pauli do mapa. Observe que a convenção de sinal booleano neste método não é padrão. O método preferido para esse tipo de amostragem é PauliLindbladMap.parity_sample(), que também é mais rico em recursos.

Cada sinal é representado por um booleano, com True representando +1, e False representando -1.

Dada a representação de quase-probabilidade fornecida na documentação em nível de classe, cada amostra é extraída por meio do seguinte processo:

• Inicialize o sinal booleano e uma instância QubitSparsePauli para o operador de identidade.
• Iterar por cada Pauli no mapa. Usando a pseudoprobabilidade associada a cada operador, escolha aleatoriamente entre aplicar ou não o operador.
• Se o operador for aplicado, atualize o :class`QubitSparsePauli` multiplicando-o pelo Pauli. Se a taxa associada ao Pauli for negativa, inverta o sinal booleano.

Os resultados são retornados como uma matriz 1d de booleanos, e o qubit esparso Paulis amostrado correspondente na forma de um QubitSparsePauliList.

Parâmetros

• num_samples (int) – Número de amostras a serem extraídas.
• seed (int) – Semente aleatória.

Retorna

A matriz booleana de sinais e a lista de paulis esparsos de qubit.

Tipo de retorno

sinais, qubit_sparse_pauli_list

simplify(tol=1e-08)

Some todos os termos semelhantes no gerador, removendo-os se a taxa resultante tiver um valor absoluto dentro da tolerância de zero. Isso também elimina termos cujo operador de Pauli é proporcional à identidade, já que o gerador correspondente é, na verdade, o mapa nulo.

Como efeito colateral, isso classifica os geradores em uma ordem canônica fixa.

Parâmetros

tol (float) – depois de somar termos semelhantes, todas as taxas cujo valor absoluto for menor do que a tolerância absoluta fornecida serão suprimidas da saída.

Exemplos

Usando simplify() para comparar dois operadores que representam o mesmo mapa, mas que seriam comparados de forma desigual devido aos testes estruturais por padrão:

>>> base = PauliLindbladMap.from_sparse_list([
...     ("XZ", (2, 1), 1e-10),  # value too small
...     ("XX", (3, 1), 2),
...     ("XX", (3, 1), 2),      # can be combined with the above
...     ("ZZ", (3, 1), 0.5),    # out of order compared to `expected`
... ], num_qubits=5)
>>> expected = PauliLindbladMap.from_list([("IZIZI", 0.5), ("IXIXI", 4)])
>>> assert base != expected  # non-canonical comparison
>>> assert base.simplify() == expected.simplify()

Observe que, no exemplo acima, os coeficientes são escolhidos de forma que todos os cálculos de ponto flutuante sejam exatos e não haja problemas intermediários de arredondamento ou associatividade. Se não for possível garantir que esse seja o caso, a forma mais segura é:

>>> left = PauliLindbladMap.from_list([("XYZ", 1.0/3.0)] * 3)   # sums to 1.0
>>> right = PauliLindbladMap.from_list([("XYZ", 1.0/7.0)] * 7)  # doesn't sum to 1.0
>>> assert left.simplify() != right.simplify()
>>> assert left.compose(right.inverse()).simplify() == PauliLindbladMap.identity(left.num_qubits)

to_sparse_list()

Expresse o mapa em termos de um formato de lista esparsa.

Isso pode ser visto como uma contraoperação de PauliLindbladMap.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

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IIXIZ", 2), ("IIZIX", 3)])
>>> reconstructed = PauliLindbladMap.from_sparse_list(pauli_lindblad_map.to_sparse_list(), pauli_lindblad_map.num_qubits)