netket.experimental.operator.FermionOperator2nd

class netket.experimental.operator.FermionOperator2nd(hilbert, terms, weights=None, constant=0.0, dtype=None)

Bases: netket.operator.DiscreteOperator

Inheritance
Inheritance diagram of netket.experimental.operator.FermionOperator2nd
__init__(hilbert, terms, weights=None, constant=0.0, dtype=None)[source]

Constructs a fermion operator given the single terms (set of creation/annihilation operators) in second quantization formalism.

This class can be initialized in the following form: FermionOperator2nd( hilbert, terms, weights ...). The term contains pairs of (idx, dagger), where idx ∈ range(hilbert.size) (it identifies an orbital) and dagger is a True/False flag determining if the operator is a creation or destruction operator. A term of the form \(\\hat{a}_1^\\dagger \\hat{a}_2\) would take the form ((1,1), (2,0)), where (1,1) represents \(\\hat{a}_1^\\dagger\) and (2,0) represents \(\\hat{a}_2\). To split up per spin, use the creation and annihilation operators to build the operator.

Parameters
  • hilbert (required) – hilbert of the resulting FermionOperator2nd object

  • terms (list(str) or list(list(list(int)))) – single term operators (see example below)

  • weights (list(union(float,complex))) – corresponding coefficients of the single term operators

  • constant (float, complex) – constant contribution (corresponding to the identity operator * constant)

  • dtype (Optional[Any]) –

Returns

A FermionOperator2nd object.

Example

Constructs a new FermionOperator2nd operator :math:(0.5-0.5j)*(a_0^\\dagger a_1) + (0.5+0.5j)*(a_2^\\dagger a_1) with the construction scheme. >>> import netket.experimental as nkx >>> terms, weights = (((0,1),(1,0)),((2,1),(1,0))), (0.5-0.5j,0.5+0.5j) >>> hi = nkx.hilbert.SpinOrbitalFermions(3) >>> op = nkx.operator.FermionOperator2nd(hi, terms, weights) >>> op FermionOperator2nd(hilbert=SpinOrbitalFermions(n_orbitals=3), n_operators=2, dtype=complex128) >>> terms = (“0^ 1”, “2^ 1”) >>> op = nkx.operator.FermionOperator2nd(hi, terms, weights) >>> op FermionOperator2nd(hilbert=SpinOrbitalFermions(n_orbitals=3), n_operators=2, dtype=complex128) >>> op.hilbert SpinOrbitalFermions(n_orbitals=3) >>> op.hilbert.size 3

Attributes
H

Returns the Conjugate-Transposed operator

Return type

AbstractOperator

T

Returns the transposed operator

Return type

AbstractOperator

dtype

The dtype of the operator’s matrix elements ⟨σ|Ô|σ’⟩.

Return type

Any

hilbert

The hilbert space associated to this operator.

Return type

AbstractHilbert

is_hermitian

Returns true if this operator is hermitian.

Return type

bool

max_conn_size

The maximum number of non zero ⟨x|O|x’⟩ for every x.

Return type

int

size

The total number number of local degrees of freedom.

Return type

int

Methods
__call__(v)

Call self as a function.

Return type

ndarray

Parameters

v (numpy.ndarray) –

apply(v)
Return type

ndarray

Parameters

v (numpy.ndarray) –

collect()

Returns a guranteed concrete instancce of an operator.

As some operations on operators return lazy wrapperes (such as transpose, hermitian conjugate…), this is used to obtain a guaranteed non-lazy operator.

Return type

AbstractOperator

conj(*, concrete=False)
Return type

AbstractOperator

conjugate(*, concrete=False)[source]

Returns the complex conjugate of this operator.

copy(*, dtype=None)[source]
Parameters

dtype (Optional[Any]) –

static from_openfermion(hilbert, of_fermion_operator=None, *, n_orbitals=None, convert_spin_blocks=False)[source]

Converts an openfermion FermionOperator into a netket FermionOperator2nd.

The hilbert first argument can be dropped, see __init__ for details and default value. Warning: convention of openfermion.hamiltonians is different from ours: instead of strong spin components as subsequent hilbert state outputs (i.e. the 1/2 spin components of spin-orbit i are stored in locations (2*i, 2*i+1)), we concatenate blocks of definite spin (i.e. locations (i, n_orbitals+i)).

Parameters
  • hilbert (AbstractHilbert) – (optional) hilbert of the resulting FermionOperator2nd object

  • of_fermion_operator (openfermion.ops.FermionOperator) – openfermion.ops.FermionOperator object

  • n_orbitals (Optional[int]) – (optional) total number of orbitals in the system, default None means inferring it from the FermionOperator2nd. Argument is ignored when hilbert is given.

  • convert_spin_blocks (bool) – whether or not we need to convert the FermionOperator to our convention. Only works if hilbert is provided and if it has spin != 0

Returns

A FermionOperator2nd object.

get_conn(x)

Finds the connected elements of the Operator. Starting from a given quantum number x, it finds all other quantum numbers x’ such that the matrix element \(O(x,x')\) is different from zero. In general there will be several different connected states x’ satisfying this condition, and they are denoted here \(x'(k)\), for \(k=0,1...N_{\mathrm{connected}}\). :type x: ndarray :param x: An array of shape (hilbert.size) containing the quantum numbers x. :type x: array

Returns

The connected states x’ of shape (N_connected,hilbert.size) array: An array containing the matrix elements \(O(x,x')\) associated to each x’.

Return type

matrix

Raises

ValueError – If the given quantum number is not compatible with the hilbert space.

Parameters

x (numpy.ndarray) –

get_conn_flattened(x, sections, pad=False)[source]

Finds the connected elements of the Operator. Starting from a given quantum number x, it finds all other quantum numbers x’ such that the matrix element \(O(x,x')\) is different from zero. In general there will be several different connected states x’ satisfying this condition, and they are denoted here \(x'(k)\), for \(k=0,1...N_{\mathrm{connected}}\). This is a batched version, where x is a matrix of shape (batch_size,hilbert.size). :param x: A matrix of shape (batch_size,hilbert.size) containing

the batch of quantum numbers x.

Parameters

sections (array) – An array of size (batch_size) useful to unflatten the output of this function. See numpy.split for the meaning of sections.

Returns

The connected states x’, flattened together in a single matrix. array: An array containing the matrix elements \(O(x,x')\) associated to each x’.

Return type

matrix

get_conn_padded(x)

Finds the connected elements of the Operator. Starting from a batch of quantum numbers x={x_1, … x_n} of size B x M where B size of the batch and M size of the hilbert space, finds all states y_i^1, …, y_i^K connected to every x_i. Returns a matrix of size B x Kmax x M where Kmax is the maximum number of connections for every y_i. :type x: ndarray :param x: A N-tensor of shape (…,hilbert.size) containing

the batch/batches of quantum numbers x.

Returns

The connected states x’, in a N+1-tensor. mels: A N-tensor containing the matrix elements \(O(x,x')\)

associated to each x’ for every batch.

Return type

x_primes

Parameters

x (numpy.ndarray) –

n_conn(x, out=None)

Return the number of states connected to x.

Parameters
  • x (matrix) – A matrix of shape (batch_size,hilbert.size) containing the batch of quantum numbers x.

  • out (array) – If None an output array is allocated.

Returns

The number of connected states x’ for each x[i].

Return type

array

operator_string()[source]

Return a readable string describing all the operator terms

to_dense()

Returns the dense matrix representation of the operator. Note that, in general, the size of the matrix is exponential in the number of quantum numbers, and this operation should thus only be performed for low-dimensional Hilbert spaces or sufficiently sparse operators.

This method requires an indexable Hilbert space.

Return type

ndarray

Returns

The dense matrix representation of the operator as a Numpy array.

to_linear_operator()
to_qobj()

Convert the operator to a qutip’s Qobj. :rtype: qutip.Qobj :returns: A qutip.Qobj object.

Return type

qutip.Qobj

to_sparse()

Returns the sparse matrix representation of the operator. Note that, in general, the size of the matrix is exponential in the number of quantum numbers, and this operation should thus only be performed for low-dimensional Hilbert spaces or sufficiently sparse operators.

This method requires an indexable Hilbert space.

Return type

csr_matrix

Returns

The sparse matrix representation of the operator.

transpose(*, concrete=False)

Returns the transpose of this operator.

Parameters

concrete – if True returns a concrete operator and not a lazy wrapper

Return type

AbstractOperator

Returns

if concrete is not True, self or a lazy wrapper; the transposed operator otherwise