MajoranaOperator

Um vetor opcional de índices de grupo para cada termo.

Para obter mais informações, consulte o módulo grouping .

adjoint()

Retorna o conjugado hermitiano (ou adjunto) desse operador.

Isso afeta os termos e coeficientes da seguinte forma:

• as ações em cada termo invertem sua ordem
• os coeficientes são conjugados complexos

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): -1.0j, (gamma(0, False), gamma(0, True)): 1.0})
>>> adj = op.adjoint()
>>> print(format(adj))
 -0.000000e0 +1.000000e0j * ()
  1.000000e0 -0.000000e0j * (γ'0 γ0)

equiv(other, atol=1e-08)

Verifica se este operador é equivalente a outro operador.

Equivalência, neste contexto, significa igualdade aproximada dentro da tolerância absoluta especificada. Para ser mais preciso, esse método retorna True, quando todos os valores absolutos dos coeficientes da diferença other - self estão abaixo do limite especificado atol.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 1e-7})
>>> zero = MajoranaOperator.zero()
>>> op.equiv(zero)
False
>>> op.equiv(zero, 1e-6)
True
>>> op.equiv(zero, 1e-9)
False

Parâmetros

• outro – o outro operador com o qual se deve comparar.
• atol – a tolerância absoluta para a comparação. Esse valor é definido por padrão como 1e-8.

classmethod from_dict(data)

Cria um novo operador a partir de um dicionário.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict(
...     {
...         (): 1.0-1.0j,
...         (0, 1): 2.0,
...     }
... )
>>> print(format(op))
  1.000000e0 -1.000000e0j * ()
  2.000000e0 +0.000000e0j * (γ0 γ'0)

Parâmetros

dados – um dicionário que mapeia tuplas de termos para coeficientes complexos. Cada chave é uma tupla de números inteiros que indexam os modos de Majorana. Você pode usar gamma() para simplificar a atribuição de índices pares e ímpares a $\gamma$ e $\gamma'$.

Retorna

Uma nova operadora.

classmethod from_terms(terms)

Cria um novo operador a partir de um iterador de termos (veja também iter_terms()).

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0, (0,): 1.0, (1,): -1.0j})
>>> op.equiv(MajoranaOperator.from_terms(op.iter_terms()))
True

Parâmetros

termos – um iterador de termos, conforme gerado por iter_terms().

Retorna

Uma nova operadora.

classmethod from_terms_with_groups(terms)

Cria um novo operador a partir de um iterador de termos com grupos (veja também iter_terms_with_groups()).

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator([2.0, 1.0, -1.0j], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> reconstructed = MajoranaOperator.from_terms_with_groups(op.iter_terms_with_groups())
>>> op.equiv(reconstructed) and op.groups == reconstructed.groups
True

Parâmetros

termos – um iterador de termos, conforme gerado por iter_terms_with_groups().

Retorna

Uma nova operadora.

get_boundaries()

Retorna uma lista somente para leitura dos índices que indicam os limites entre os termos do operador.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += MajoranaOperator.from_dict({(0, 1): 1.0})
>>> op.get_boundaries()
[0, 0, 2]

Retorna

Uma lista dos limites dos termos do operador.

get_coeffs()

Retorna uma lista somente para leitura dos coeficientes do operador.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += -1j * MajoranaOperator.one()
>>> op.get_coeffs()
[(1+0j), -1j]

Retorna

Uma lista dos coeficientes do operador.

get_modes()

Retorna uma lista somente para leitura dos índices de modo sobre os quais o operador atuou.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += MajoranaOperator.from_dict({(0, 1): 1.0})
>>> op.get_modes()
[0, 1]

Retorna

Uma lista dos modos de operação.

get_support()

Retorna o conjunto de índices de modo sobre os quais este operador atua.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict(
...     {
...         (0, 4): 1,
...         (1, 3, 4, 7): 1,
...     }
... )
>>> assert op.get_support() == {0, 1, 3, 4, 7}

Retorna

O conjunto de índices de modo sobre os quais esse operador atua.

group_weights()

Retorna a magnitude média absoluta do coeficiente de cada grupo.

A i-ésima entrada é a soma de abs(coeff) sobre os termos do grupo i, dividida pelo número de termos desse grupo. Se for groups None, essa função também retorna None.

Este é o peso amostral de uma fórmula de produto aleatória (por exemplo, qDRIFT ) que seleciona grupos inteiros, em vez de termos individuais. Calcular isso de forma nativa é consideravelmente mais econômico do que reduzir e get_coeffs() groups em NumPy,, pois esses dois acessadores copiam, cada um, um valor por termo não agrupado do operador apenas para que ele seja agregado novamente a um valor por grupo, enquanto esta abordagem retorna apenas os valores num_groups() reduzidos.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.group_weights())
None
>>> op.groups = [0, 1, 0, 1]
>>> op.group_weights()
[1.0, 2.0]

Retorna

A magnitude média absoluta do coeficiente de cada índice do grupo.

has_groups()

Retorna se este operador rastreia índices de grupo.

Isso equivale a (mas é mais barato do que) verificar op.groups is not None, pois não copia os índices dos grupos do operador para inspecioná-los.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.has_groups()
False
>>> op.groups = [0, 1, 0, 1]
>>> op.has_groups()
True

Retorna

Se groups está definido para esse operador.

ichop(atol=1e-08)

Remove termos cuja magnitude do coeficiente seja inferior ao limite especificado.

Esse método modifica o operador no próprio local e retorna None.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 1e-4, (0,): 1e-6, (1,): 1e-10})
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (γ0)
 1.000000e-10 +0.000000e0j * (γ'0)
>>> op.ichop()
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (γ0)
>>> op.ichop(1e-5)
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()

Parâmetros

atol – a tolerância absoluta para o limite de corte. Esse valor é definido por padrão como 1e-8.

is_even()

Retorna se este operador é par.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(0, 1): 1})
>>> op.is_even()
True
>>> op = MajoranaOperator.from_dict({(0,): 1})
>>> op.is_even()
False

Retorna

Se esse operador é par.

is_hermitian(atol=1e-08)

Retorna se este operador é hermitiano.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({
...     (0, 1, 2, 3): 1.00001j,
...     (3, 2, 1, 0): -1j,
... })
>>> op.is_hermitian()
False
>>> op.is_hermitian(1e-4)
True

Parâmetros

atol – A precisão numérica até a qual os coeficientes são considerados iguais. Esse valor é definido por padrão como 1e-8.

Retorna

Se esse operador é hermitiano.

iter_terms()

Um iterador sobre os termos do operador.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0, (0,): 1.0, (1,): -1.0j})
>>> list(sorted(op.iter_terms()))
[([], (2+0j)), ([0], (1+0j)), ([1], (-0-1j))]

iter_terms_with_groups()

Um iterador sobre os termos do operador, acompanhado de seus respectivos índices de grupo.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator([2.0, 1.0, -1.0j], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> list(op.iter_terms_with_groups())
[([], (2+0j), 0), ([0], (1+0j), 1), ([1], (-0-1j), 1)]

max_rank()

Retorna o grau máximo dos termos neste operador.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(0, 1, 2, 3): 1})
>>> op.max_rank()
4

Retorna

A potência máxima desse operador.

normal_ordered(ascending=False, reduce=True)

Retorna um operador equivalente com termos ordenados normalmente.

A ordem normal de um termo de operador é definida de forma que todas as ações sejam ordenadas lexicalmente. O fato de subirem ou descerem depende do valor do parâmetro ascending . De acordo com a convenção estabelecida por gamma() para colocar $\gamma$ ( $\gamma'$ ) em índices pares (ímpares), isso resulta no seguinte exemplo (para o padrão, ascending=False): [\gamma(1, True), \gamma(1, False), \gamma(0, True), \gamma(0, False)] = [3, 2, 1, 0].

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(gamma(0, False), gamma(0, True), gamma(0, False)): 1})
>>> print(format(op.normal_ordered(reduce=False)))
 -1.000000e0 +0.000000e0j * (γ'0 γ0 γ0)
>>> print(format(op.normal_ordered(reduce=True)))
 -1.000000e0 +0.000000e0j * (γ'0)

Parâmetros

• ascendente – se os índices devem subir ou descer.
• reduzir – se se deve reduzir cada termo à sua forma mínima, eliminando as ações que, ao quadrado, resultam na identidade. Veja também o exemplo acima.

Retorna

Um operador equivalente, porém de ordem normal.

num_groups()

Retorna o número de grupos.

Se for groups None, essa função também retorna None. Caso contrário, ela retornará o número de grupos, que é definido como o maior índice de grupo encontrado mais 1 (o que, portanto, pode ser usado como o índice do próximo grupo).

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.groups = [0, 1, 0, 1]
>>> op.num_groups()
2

Retorna

O maior índice do grupo está em alta groups de 1.

classmethod one()

Constrói o operador de identidade multiplicativa.

A composição do operador construído por esse método com outro operador não produz nenhum efeito.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0})
>>> one = MajoranaOperator.one()
>>> op & one == op
True

relabel_modes(permutation)

Retorna um novo operador com os modos renomeados.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({
...     (0, 1): 1,
...     (0, 1, 2, 3): 1,
... })
>>> permutation = [5, 6, 4, 3]
>>> relabeled = op.relabel_modes(permutation)
>>> print(format(relabeled))
  1.000000e0 +0.000000e0j * (γ'2 γ3)
  1.000000e0 +0.000000e0j * (γ'2 γ3 γ2 γ'1)

Parâmetros

permutação – a lista de permutações de índices. O modo é i renomeado para permutation[i], portanto, a lista não deve conter entradas duplicadas e deve ter comprimento suficiente para indexar todos os modos sobre os quais o operador atua (seu comprimento deve ser maior que o maior índice de modo do operador).

Retorna

Um novo operador com seus modos renomeados.

Aumentos

ValueError – se contiver permutation entradas duplicadas ou for curto demais para renomear algum modo sobre o qual o operador atua.

simplify(atol=1e-08)

Retorna um operador equivalente, porém simplificado.

O processo de simplificação soma, primeiro, todos os coeficientes que pertencem a termos iguais e, em seguida, retém apenas aqueles cujo coeficiente total exceda a tolerância especificada (exatamente como ichop()).

Quando um operador tiver sido manipulado aritmeticamente ou construído de forma que não garanta a unicidade dos termos, esse método deve ser chamado antes da aplicação de qualquer método que filtre coeficientes numericamente pequenos, a fim de evitar a perda de informação. Veja o exemplo abaixo, que mostra como ichop() pode truncar termos cuja soma resulta em um coeficiente de magnitude total que não deveria ser truncado:

>>> from qiskit_fermions.operators import MajoranaOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = MajoranaOperator(coeffs, [], boundaries)
>>> canon = op.simplify(1e-4)
>>> assert canon.equiv(op.one(), 1e-6)
>>> op.ichop(1e-4)
>>> assert op.equiv(op.zero(), 1e-6)

Parâmetros

atol – a tolerância absoluta para o limite de corte. Esse valor é definido por padrão como 1e-8.

Retorna

Um operador equivalente, porém simplificado.

split_out_groups(group_indices=None)

Divide esse operador em uma lista opcional de novos operadores com base em groups.

Se for groups None, essa função também retorna None. Caso contrário, se for group_indices None (valor padrão), ela retorna uma lista contendo um novo operador para cada índice de grupo em groups, na ordem dos índices. Se group_indices for fornecido, apenas os índices solicitados são construídos, na ordem indicada: isso evita o custo de construir operadores para grupos que nunca serão utilizados, o que é especialmente benéfico quando é necessário apenas um pequeno número de grupos dentre um total muito maior, por exemplo, ao realizar uma subamostragem de grupos para uma fórmula de produto aleatória. Um índice duplicado em group_indices é retornado uma vez por ocorrência.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.split_out_groups())
None
>>> op.groups = [0, 1, 0, 1]
>>> groups = op.split_out_groups()
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([0, 1], (1+0j)), ([1, 0], (-1+0j))]
[([2, 3], (2+0j)), ([3, 2], (-2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([2, 3], (2+0j)), ([3, 2], (-2+0j))]

Parâmetros

group_indices – os índices de grupo para os quais serão criados os operadores, na ordem de saída desejada. Quando omitido, todos os grupos são criados, em ordem de índice.

Retorna

Um vetor opcional contendo um novo operador para cada índice de grupo solicitado.

classmethod zero()

Constrói o operador de identidade aditiva.

Adicionar o operador criado por esse método a outro não produz nenhum efeito.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0})
>>> zero = MajoranaOperator.zero()
>>> op + zero == op
True

static _anti_commutator_(op_a, op_b)

static _commutator_(op_a, op_b)

static _double_commutator_(op_a, op_b, op_c, sign)

_fermion_operator_()

Converte esse operador em um FermionOperator.

Isso implementa o protocolo SupportsFermionOperator por meio da delegação a majorana_to_fermion().