MajoranaOperator

Un vettore facoltativo di indici di gruppo per ciascun termine.

Per ulteriori informazioni, consultare il modulo grouping .

adjoint()

Restituisce il coniugato ermitiano (o aggiunto) di questo operatore.

Ciò influisce sui termini e sui coefficienti come segue:

• le azioni di ciascun termine invertono il loro ordine
• i coefficienti sono complessi coniugati

>>> 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 questo operatore è equivalente a un altro operatore.

In questo contesto, per “equivalenza” si intende un’uguaglianza approssimativa entro i limiti della tolleranza assoluta specificata. Per essere più precisi, questo metodo restituisce True, quando tutti i valori assoluti dei coefficienti nella differenza other - self sono inferiori alla soglia specificata 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

Parametri

• altro – l’altro operatore con cui effettuare il confronto.
• atol – la tolleranza assoluta per il confronto. Il valore predefinito è 1e-8.

classmethod from_dict(data)

Crea un nuovo operatore a partire da un dizionario.

>>> 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)

Parametri

dati – un dizionario che associa tuple di termini a coefficienti complessi. Ogni chiave è una tupla di numeri interi che indicizza i modi di Majorana. È possibile utilizzare gamma() per semplificare l'assegnazione degli indici pari e dispari a $\gamma$ e $\gamma'$.

Risultati

Un nuovo operatore.

classmethod from_terms(terms)

Crea un nuovo operatore a partire da un iteratore di termini (vedi anche 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

Parametri

termini – un iteratore di termini generato da iter_terms().

Risultati

Un nuovo operatore.

classmethod from_terms_with_groups(terms)

Crea un nuovo operatore a partire da un iteratore di termini con gruppi (vedi anche 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

Parametri

termini – un iteratore di termini generato da iter_terms_with_groups().

Risultati

Un nuovo operatore.

get_boundaries()

Restituisce un elenco in sola lettura degli indici che indicano i confini tra i termini dell'operatore.

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

Risultati

Un elenco dei limiti previsti dalle condizioni dell'operatore.

get_coeffs()

Restituisce un elenco in sola lettura dei coefficienti dell'operatore.

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

Risultati

Un elenco dei coefficienti dell'operatore.

get_modes()

Restituisce un elenco in sola lettura degli indici delle modalità su cui l'operatore ha agito.

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

Risultati

Un elenco delle modalità di funzionamento dell'operatore.

get_support()

Restituisce l'insieme degli indici di modalità su cui agisce questo operatore.

>>> 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}

Risultati

L'insieme degli indici di modalità su cui agisce questo operatore.

group_weights()

Restituisce la media del modulo assoluto del coefficiente di ciascun gruppo.

La i-esima voce è la somma di abs(coeff) sui termini del gruppo i, divisa per il numero di termini di quel gruppo. Se è groups None, questa funzione restituisce anch’essa None.

Si tratta del peso di campionamento di una formula di prodotto randomizzata (ad esempio qDRIFT ) che estrae gruppi interi anziché singoli termini. Il calcolo in modo nativo è notevolmente più efficiente rispetto alla riduzione di e get_coeffs() groups in NumPy,, poiché questi due accessori copiano ciascuno un valore per ogni termine non raggruppato dall’operatore, solo per poi aggregarlo nuovamente in un unico valore per gruppo, mentre questa operazione restituisce semplicemente i valori num_groups() ridotti.

>>> 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]

Risultati

Il valore medio assoluto del coefficiente di ciascun indice di gruppo.

has_groups()

Indica se questo operatore tiene traccia degli indici di gruppo.

Ciò equivale a (ma è più economico di) verificare op.groups is not None, poiché non copia gli indici dei gruppi dall'operatore per esaminarli.

>>> 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

Risultati

Se groups è impostato su questo operatore.

ichop(atol=1e-08)

Rimuove i termini il cui modulo del coefficiente è inferiore alla soglia specificata.

Questo metodo modifica l'operatore direttamente e restituisce 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 * ()

Parametri

atol – la tolleranza assoluta per il valore di soglia. Il valore predefinito è 1e-8.

is_even()

Restituisce se questo operatore è pari.

>>> 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

Risultati

Se questo operatore è pari.

is_hermitian(atol=1e-08)

Restituisce se questo operatore è ermitiano.

>>> 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

Parametri

atol – Il livello di precisione numerica entro il quale i coefficienti sono considerati uguali. Il valore predefinito è 1e-8.

Risultati

Se questo operatore sia ermitiano.

iter_terms()

Un iteratore sui termini dell'operatore.

>>> 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()

Un iteratore sui termini dell'operatore con il relativo indice di gruppo.

>>> 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()

Restituisce il rango massimo dei termini presenti in questo operatore.

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

Risultati

Il grado massimo di questo operatore.

normal_ordered(ascending=False, reduce=True)

Restituisce un operatore equivalente con termini ordinati normalmente.

L'ordine normale di un termine operatore è definito in modo tale che tutte le azioni siano ordinate in ordine lessicografico. Il fatto che salgano o scendano dipende dal valore del parametro ascending . In base alla convenzione stabilita da gamma() per collocare $\gamma$ ( $\gamma'$ ) sugli indici pari (dispari), ne risulta il seguente esempio (per l'impostazione predefinita, 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)

Parametri

• ascendente – se gli indici debbano aumentare o diminuire.
• ridurre – se ridurre ogni termine alla sua forma minima eliminando le azioni che, elevate al quadrato, danno come risultato l’identità. Vedi anche l'esempio riportato sopra.

Risultati

Un operatore equivalente ma con ordine normale.

num_groups()

Restituisce il numero di gruppi.

Se è groups None, questa funzione restituisce anch'essa None. In caso contrario, restituirà il numero di gruppi, definito come l'indice del gruppo più grande presente più 1 (che potrà quindi essere utilizzato come indice per il gruppo successivo).

>>> 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

Risultati

L'indice di gruppo più importante è in groups rialzo di 1.

classmethod one()

Crea l'operatore di identità moltiplicativa.

La composizione dell'operatore ottenuto con questo metodo con un altro operatore non ha alcun effetto.

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

relabel_modes(permutation)

Restituisce un nuovo operatore con le modalità rinominate.

>>> 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)

Parametri

permutazione – l'elenco delle permutazioni degli indici. La modalità viene i rinominata in permutation[i], pertanto l'elenco non deve contenere voci duplicate e deve essere sufficientemente lungo da indicizzare ogni modalità su cui agisce l'operatore (la sua lunghezza deve superare l'indice di modalità più elevato dell'operatore).

Risultati

Un nuovo operatore con le modalità rinominate.

Aumenti

ValueError – se permutation contiene voci duplicate o è troppo breve per ridenominare una modalità su cui agisce l'operatore.

simplify(atol=1e-08)

Restituisce un operatore equivalente ma semplificato.

Il processo di semplificazione somma innanzitutto tutti i coefficienti appartenenti a termini uguali e poi mantiene solo quelli il cui coefficiente totale supera la tolleranza specificata (proprio come ichop()).

Quando un operatore è stato manipolato aritmeticamente o costruito in modo tale da non garantire l'unicità dei termini, è opportuno richiamare questo metodo prima di applicare qualsiasi metodo che filtri i coefficienti numericamente piccoli, al fine di evitare la perdita di informazioni. Si veda l'esempio riportato di seguito, che illustra come ichop() sia possibile troncare termini la cui somma porta a un coefficiente totale di grandezza che non dovrebbe essere troncato:

>>> 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)

Parametri

atol – la tolleranza assoluta per il valore di soglia. Il valore predefinito è 1e-8.

Risultati

Un operatore equivalente ma semplificato.

split_out_groups(group_indices=None)

Suddivide questo operatore in un elenco facoltativo di nuovi operatori in base a groups.

Se è groups None, questa funzione restituisce anch'essa None. Altrimenti, se group_indices è None (impostazione predefinita), restituisce una lista contenente un nuovo operatore per ogni indice di gruppo in groups, in ordine di indice. Se group_indices è specificato, vengono generati solo gli indici richiesti, nell’ordine indicato: ciò consente di evitare il costo legato alla creazione di operatori per gruppi che non vengono mai utilizzati, il che risulta particolarmente vantaggioso quando è necessario ricorrere solo a un numero limitato di gruppi rispetto a un totale molto più ampio, ad esempio quando si effettua un sottocampionamento dei gruppi per una formula di prodotto randomizzata. Un indice duplicato in group_indices viene restituito una volta per ogni occorrenza.

>>> 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))]

Parametri

group_indices – gli indici dei gruppi per i quali creare gli operatori, nell'ordine di output desiderato. Se non specificato, vengono creati tutti i gruppi, in ordine di indice.

Risultati

Un vettore facoltativo contenente un nuovo operatore per ciascun indice di gruppo richiesto.

classmethod zero()

Costruisce l'operatore di identità additiva.

L'aggiunta di un operatore costruito con questo metodo a un altro operatore non ha alcun effetto.

>>> 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 questo operatore in un FermionOperator.

Questo implementa il protocollo SupportsFermionOperator delegando a majorana_to_fermion().