SparseObservable

__new__(data, /, num_qubits=None)

O construtor padrão do SparseObservable.

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. Isso pode ser outro SparseObservablee, nesse caso, a entrada é copiada, um Pauli ou SparsePauliOp, caso em que from_pauli() ou from_sparse_pauli_op() são chamados conforme apropriado, 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 operador. 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.

Uma lista simples de termos de um único qubit. Isso é mais naturalmente uma lista de listas, mas é armazenada de forma plana por motivos de uso de memória e localidade, com as sublistas denotadas por limites.

Índices que dividem bit_terms e indices em sublistas para cada termo individual na soma. boundaries[0] : boundaries[1] é o intervalo de índices em bit_terms e indices que correspondem ao primeiro termo da soma. Todos os índices de qubit não especificados são implicitamente a identidade. Esse é um item a mais do que coeffsjá que boundaries[0] é sempre um zero explícito (para facilitar o algoritmo).

Os coeficientes de cada termo abstrato na soma. Isso tem tantos elementos quanto termos na soma.

Uma lista simples dos índices de qubit que as entradas correspondentes em bit_terms atuam. Essa lista deve ser sempre classificada por termo, em que um termo é uma sublista, conforme indicado por boundaries.

O número de qubits em que o operador 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 na soma que esse operador está rastreando.

adjoint()

Calcule o adjunto desse observável.

Isso é bem definido no sentido matemático abstrato. Todos os termos do alfabeto de um único qubit são autoadjuntos, portanto, o resultado dessa operação é o mesmo observável, exceto que seus coeficientes são todos conjugados complexos.

Exemplos

>>> left = SparseObservable.from_list([("XY+-", 1j)])
>>> right = SparseObservable.from_list([("XY+-", -1j)])
>>> assert left.adjoint() == right

apply_layout(layout, num_qubits=None)

Aplique um layout de transpilador a isso SparseObservable.

Normalmente, você terá definido seu observável em termos dos qubits virtuais dos circuitos que usará para preparar os estados. Após a transpilação, os qubits virtuais são mapeados para qubits físicos específicos em um dispositivo, que pode ser maior do que o seu circuito. Esse mapeamento também pode mudar no decorrer do circuito. Esse método transforma o observável de entrada em qubits virtuais em um observável que é adequado para ser aplicado imediatamente após o circuito físico totalmente transpilado.

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 observável).
• num_qubits (int | None) – O número de qubits para expandir o observável. 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 SparseObservable com o layout fornecido aplicado.

as_paulis()

Expresse o observável somente em termos de Pauli, escrevendo cada projetor como uma soma de termos de Pauli.

Observe que não há garantia da ordem dos termos de Pauli resultantes. Use SparseObservable.simplify() além disso, para obter uma representação canônica.

Retorna

O mesmo observável, mas expresso apenas em termos de Pauli.

Exemplos

Reescreva um observável em termos de projetores em operadores Pauli:

>>> obs = SparseObservable("+")
>>> obs.as_paulis()
<SparseObservable with 2 terms on 1 qubit: (0.5+0j)() + (0.5+0j)(X_0)>
>>> direct = SparseObservable.from_list([("I", 0.5), ("Z", 0.5)])
>>> assert direct.simplify() == obs.as_paulis().simplify()

Para operadores pequenos, isso pode ser usado com simplify() como uma forma canônica única:

>>> left = SparseObservable.from_list([("+", 0.5), ("-", 0.5)])
>>> right = SparseObservable.from_list([("r", 0.5), ("l", 0.5)])
>>> assert left.as_paulis().simplify() == right.as_paulis().simplify()

clear()

Limpe todos os termos desse operador, tornando-o igual ao operador zero novamente.

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

Exemplos

>>> obs = SparseObservable.from_list([("IX+-rl", 2.0), ("01YZII", -1j)])
>>> obs.clear()
>>> assert obs == SparseObservable.zero(obs.py_num_qubits())

commutes(other, tol=1e-12)

Verifique se o observável comuta com outro.

Parâmetros

• other (SparseObservable) – O outro observável para verificar a comutação.
• tol (float) – Se os coeficientes no produto de si mesmo e do outro estiverem abaixo da tolerância (em magnitude), os termos são ignorados.

Retorna

True se os termos se compensarem, até a tolerância, False caso contrário.

Aumentos

TypeError – Se não other pudesse ser coagido a SparseObservable.

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

Componha outro SparseObservable sobre este.

Em termos de álgebras de operadores, a composição corresponde à multiplicação à esquerda: c = a.compose(b) corresponde a $C = B A$. Em outras palavras, a.compose(b) retorna um operador que "executa a e, em seguida, executa b no resultado". Em vez disso, o argumento front=True torna essa multiplicação correta.

self e other devem ter o mesmo tamanho, a menos que qargs seja fornecido, caso em que other pode ser menor que self, desde que o número de qubits em other e o comprimento de qargs sejam iguais. qargs nunca pode conter duplicatas ou índices de qubits que não existam em self.

Observe que essa função pode causar uma explosão exponencial do uso de memória do observável, pois o alfabeto de SparseObservable não é fechado sob composição; a composição de dois termos de bit único pode ser uma soma, que multiplica o número total de termos. Esse uso de memória não é _necessariamente_ inerente ao observável resultante, mas encontrar uma refatoração eficiente da soma geralmente é igualmente difícil do ponto de vista computacional. É melhor usar o conhecimento do domínio de seus observáveis para minimizar o número de termos que existem, em vez de tentar simplificá-los após o fato.

Parâmetros

• outro - o observável usado para multiplicar à esquerda self.

• qargs -

  se fornecido, os qubits em self a serem associados aos qubits em other. Em outras palavras: se isso for dado, é semelhante a uma implementação mais eficiente de:

  self.compose(other.apply_layout(qargs, self.num_qubits))

  pois nenhum observável temporário é criado para armazenar a forma de layout aplicado de other.

• front - se True, então multiplicar à direita por other em vez de multiplicar à esquerda (padrão False). O qargs ainda é aplicado ao other. Isso é mais útil quando qargs está definido, ou other pode ser um objeto que deve ser coagido a SparseObservable.

conjugate()

Calcule a conjugação complexa desse observável.

Essa operação é definida em termos das convenções de matriz padrão do Qiskit, em que a forma da matriz é considerada na base computacional $Z$. Os termos do alfabeto relacionados a $X$- e $Z$ não são afetados pela conjugação complexa, mas os termos relacionados a $Y$ modificam seus termos do alfabeto. Exatamente:

• $Y$ conjugue com $-Y$
• $\lvert r\rangle\langle r\rvert$ conjugados para $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ conjugados para $\lvert r\rangle\langle r\rvert$

Além disso, todos os coeficientes são conjugados.

Exemplos

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.conjugate() == SparseObservable([("III", -1j), ("Ylr", -0.5)])

copy()

Obtenha uma cópia desse observável.

Exemplos

>>> obs = SparseObservable.from_list([("IXZ+lr01", 2.5), ("ZXI-rl10", 0.5j)])
>>> assert obs == obs.copy()
>>> assert obs is not obs.copy()

evolve(other, /, qargs=None)

Desenvolva essa observável por meio de um termo de Pauli.

Uma evolução da observável $O$ por um $P$ de Pauli corresponde a $P^\dagger O P$.

Ao contrário de uma implementação literal por meio de duas composições completas, este método realiza a conjugação diretamente no nível de um único qubit, utilizando uma tabela de consulta fixa. Isso evita a materialização de quaisquer termos intermediários SparseObservable e calcula a observável evoluída em uma única passagem pelos termos. self e other deve ter o mesmo número de qubits, a menos que qargs seja especificado; nesse caso, other pode ser menor que self, desde que o número de qubits em other e o comprimento de qargs sejam iguais. qargs especifica quais qubits de self são evoluídos por other.

Atualmente, esse método suporta a evolução apenas por meio de um operador de termo único, o que significa que other deve ser um operador de Pauli representado por Pauli.

Parâmetros

• outro – o operador de Pauli, usado para conjugar self.
• qargs – se fornecido, os qubits em self a serem evoluídos por other. O comprimento deve corresponder ao número de qubits em other.

Retorna

Uma nova forma evoluiu SparseObservable com as conjugações aplicadas.

Aumentos

• TypeError – se não other for do tipo Pauli.
• ValueError – se self e other tiverem números diferentes de qubits (e não qargs for especificado).
• ValueError – se qargs o comprimento não corresponder other ao número de qubits.
• ValueError – se qargs contiver duplicatas ou índices fora do intervalo.
• ValueError – se other contiver mais de um termo.

expand(other, /)

Produto tensor de ordem inversa.

Isso é equivalente a other.tensor(self), exceto pelo fato de que other será primeiro convertido para SparseObservable se ainda não for um (chamando o construtor padrão).

Parâmetros

outro - o observável a ser colocado no lado esquerdo do produto tensorial.

Exemplos

Isso é equivalente a tensor() com a ordem dos argumentos invertida:

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == right.expand(left)

static from_label(label, /)

Construa um observável de termo único a partir de um rótulo de cadeia densa.

O operador resultante terá um coeficiente de 1. O rótulo deve ser uma sequência do alfabeto 'IXYZ+-rl01'. 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

>>> SparseObservable.from_label("IIII+ZI")
<SparseObservable with 1 term on 7 qubits: (1+0j)(+_2 Z_1)>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

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

Construa um observável a partir de uma lista de rótulos e coeficientes densos.

Isso é análogo ao SparsePauliOp.from_list()exceto que ele usa o alfabeto estendido de SparseObservable. 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+-rl01'. 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, complex]]) – Pares de rótulos e seus coeficientes associados a serem somados. Os rótulos são interpretados da mesma forma que em from_label().
• 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 o iter puder estar vazio, você deverá especificar esse argumento para não ambiguidade de quantos qubits o observável representa. Se isso for fornecido e iter não estiver vazio, o valor deverá corresponder aos comprimentos do rótulo.

Exemplos

Construa um observável a partir de uma lista de rótulos do mesmo tamanho:

>>> SparseObservable.from_list([
...     ("III++", 1.0),
...     ("II--I", 1.0j),
...     ("I++II", -0.5),
...     ("--III", -0.25j),
... ])
<SparseObservable with 4 terms on 5 qubits:
    (1+0j)(+_1 +_0) + (0+1j)(-_2 -_1) + (-0.5+0j)(+_3 +_2) + (-0-0.25j)(-_4 -_3)>

Use num_qubits para eliminar a ambiguidade de entradas potencialmente vazias:

>>> SparseObservable.from_list([], num_qubits=10)
<SparseObservable 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 = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_pauli(pauli, /)

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

O observável de saída terá um único termo, com um coeficiente unitário dependente da fase.

Parâmetros

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

Exemplos

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> SparseObservable.from_pauli(pauli)
<SparseObservable with 1 term on 5 qubits: (1+0j)(Y_3 X_2 Z_1)>
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

static from_raw_parts(num_qubits, coeffs, bit_terms, indices, boundaries, check=True)

Construa um SparseObservable 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 no observável.

• coeffs - coeficientes complexos de cada termo do observável. Esse deve ser um array Numpy com dtype complex128.

• bit_terms - lista achatada dos termos de um único qubit que inclui todos os termos completos. Esse deve ser um array Numpy com dtype uint8 (que é compatível com BitTerm).

• índices - lista ordenada por termos achatados dos qubits aos quais cada termo de qubit único corresponde. Esse deve ser um array Numpy com dtype uint32.

• limites - os índices que dividem bit_terms e indices em termos. Esse deve ser um array Numpy com dtype uintp.

• verificação -

  se True (o padrão), validar se os dados satisfazem todas as garantias de coerência. Se False, nenhuma verificação é feita.

  Aviso

  Se check=False, os bit_terms devem ser absolutamente todos valores válidos de SparseObservable.BitTerm. Se não forem, poderá ocorrer um comportamento indefinido no espaço Rust, invalidando totalmente a execução do programa.

Exemplos

Construa uma soma de $Z$ em cada qubit individual:

>>> num_qubits = 100
>>> terms = np.full((num_qubits,), SparseObservable.BitTerm.Z, dtype=np.uint8)
>>> indices = np.arange(num_qubits, dtype=np.uint32)
>>> coeffs = np.ones((num_qubits,), dtype=complex)
>>> boundaries = np.arange(num_qubits + 1, dtype=np.uintp)
>>> SparseObservable.from_raw_parts(num_qubits, coeffs, terms, indices, boundaries)
<SparseObservable with 100 terms on 100 qubits: (1+0j)(Z_0) + ... + (1+0j)(Z_99)>

static from_sparse_list(iter, /, num_qubits)

Construa um observável a partir de uma lista de rótulos, os qubits aos quais cada item se aplica e o coeficiente de todo o termo.

Isso é análogo ao SparsePauliOp.from_sparse_list()exceto que ele usa o alfabeto estendido de SparseObservable.

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], complex]]) – triplas de rótulos, os qubits aos quais cada termo de qubit único se aplica e o coeficiente de todo o termo.
• num_qubits (int) – o número de qubits no operador.

Exemplos

Construa um operador simples:

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

Construa o observável de identidade (embora, na verdade, basta usar identity()):

>>> SparseObservable.from_sparse_list([("", (), 1.0)], num_qubits=100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

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 = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_sparse_pauli_op(op, /)

Construir um SparseObservable a partir de uma SparsePauliOp instância.

Essa será uma tradução direta da versão SparsePauliOpem particular, não há soma imediata de termos semelhantes, nem qualquer tentativa de refatorar as somas de termos de Pauli em operadores de projeção equivalentes.

Parâmetros

op (SparsePauliOp) – o operador a ser convertido.

Exemplos

>>> spo = SparsePauliOp.from_list([("III", 1.0), ("IIZ", 0.5), ("IZI", 0.5)])
>>> SparseObservable.from_sparse_pauli_op(spo)
<SparseObservable with 3 terms on 3 qubits: (1+0j)() + (0.5+0j)(Z_0) + (0.5+0j)(Z_1)>

static from_terms(obj, /, num_qubits=None)

Construa um SparseObservable 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 observável.

Parâmetros

• obj (Iterable[Term]) – Iterável de termos individuais para construir o observável.
• num_qubits (int | None) – O número de qubits em que o observável 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 observável correspondente.

static identity(num_qubits)

Obtém o operador de identidade sobre o número determinado de qubits.

Exemplos

Obtenha o operador de identidade para 100 qubits:

>>> SparseObservable.identity(100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

pauli_bases()

Obter um PauliList que representa a base de medição necessária para cada termo (em ordem) nesse observável.

Por exemplo, o projetor 0l+ retornará um Pauli ZXY. O resultado Pauli resultante é denso, no sentido de que as identidades explícitas são armazenadas. Uma identidade na saída de Pauli não requer uma medida concreta.

Isso retornará uma entrada na lista de Pauli para cada termo na soma.

Retorna

a lista de operadores Pauli que representa as bases de medição necessárias.

Tipo de retorno

PauliList

simplify(tol=1e-08)

Some todos os termos semelhantes nesse operador, removendo-os se o coeficiente complexo resultante tiver um valor absoluto dentro da tolerância de zero.

Como efeito colateral, isso classifica o operador em ordem canônica.

Parâmetros

tol (float) – depois de somar termos semelhantes, todos os coeficientes cujo valor absoluto for menor do que a tolerância absoluta fornecida serão suprimidos da saída.

Exemplos

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

>>> base = SparseObservable.from_sparse_list([
...     ("XZ", (2, 1), 1e-10),  # value too small
...     ("+-", (3, 1), 2j),
...     ("+-", (3, 1), 2j),     # can be combined with the above
...     ("01", (3, 1), 0.5),    # out of order compared to `expected`
... ], num_qubits=5)
>>> expected = SparseObservable.from_list([("I0I1I", 0.5), ("I+I-I", 4j)])
>>> 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 = SparseObservable.from_list([("XYZ", 1.0/3.0)] * 3)   # sums to 1.0
>>> right = SparseObservable.from_list([("XYZ", 1.0/7.0)] * 7)  # doesn't sum to 1.0
>>> assert left.simplify() != right.simplify()
>>> assert (left - right).simplify() == SparseObservable.zero(left.num_qubits)

tensor(other, /)

Produto tensorial de dois observáveis.

A ordenação de bits é definida de forma que os índices de qubit do argumento permaneçam os mesmos e os índices de self sejam deslocados pelo número de qubits em other. Essa é a mesma convenção usada pelo restante dos operadores do Qiskit quantum_info operadores.

Essa função é usada para o operador infixo ^ . Se estiver usando esse operador, esteja ciente de que as regras de precedência de operador do Python podem fazer com que a ordem de avaliação seja diferente da sua expectativa. Em particular, o operador + se vincula mais firmemente do que ^, assim como * se vincula mais firmemente do que +. Use parênteses para corrigir a ordem de avaliação, se necessário.

O argumento será convertido para SparseObservable usando seu construtor padrão, se ainda não estiver no formato correto.

Parâmetros

outro - o observável a ser colocado no lado direito do produto tensorial.

Exemplos

A ordem dos bits é tal que o produto tensorial de dois observáveis feitos a partir de um único rótulo "se parece" com um observável feito pela concatenação das duas cadeias:

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == SparseObservable.from_label("XYZ+-IIrl")

Você também pode usar o operador infixo ^ para produtos tensoriais, que converterá de forma semelhante o lado direito da operação se ele ainda não for um SparseObservable:

>>> assert SparseObservable("rl") ^ Pauli("XYZ") == SparseObservable("rlXYZ")

to_sparse_list()

Expresse o observável em termos de um formato de lista esparsa.

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

>>> obs = SparseObservable.from_list([("IIXIZ", 2j), ("IIZIX", 2j)])
>>> reconstructed = SparseObservable.from_sparse_list(obs.to_sparse_list(), obs.num_qubits)

transpose()

Calcule a transposição da matriz desse observável.

Essa operação é definida em termos das convenções de matriz padrão do Qiskit, em que a forma da matriz é considerada na base computacional $Z$. Os termos do alfabeto relacionados a $X$- e $Z$ não são afetados pela transposição, mas os termos relacionados a $Y$ modificam seus termos do alfabeto. Exatamente:

• $Y$ transpõe para $-Y$
• $\lvert r\rangle\langle r\rvert$ transpõe para $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ transpõe para $\lvert r\rangle\langle r\rvert$

Exemplos

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.transpose() == SparseObservable([("III", 1j), ("Ylr", -0.5)])

static zero(num_qubits)

Obtém o operador zero sobre o número dado de qubits.

O operador zero é o operador cujo valor de expectativa é zero para todos os estados quânticos. Ele não tem termos. É o elemento de identidade para a adição de duas instâncias SparseObservable qualquer coisa adicionada ao operador zero é igual a ele mesmo.

Se você quiser que o projetor fique no estado de todos os zeros, use:

>>> num_qubits = 10
>>> all_zeros = SparseObservable.from_label("0" * num_qubits)

Exemplos

Obtenha o operador zero para 100 qubits:

>>> SparseObservable.zero(100)
<SparseObservable with 0 terms on 100 qubits: 0.0>