hqs_quantum_solver.spinless_fermions

hqs_quantum_solver.spinless_fermions#

Operators for spinless fermions.

Functions

annihilation(*[, site, coef])

Annihilation operator for a spinless fermions system.

anomalous_pairing(coef)

The spinless fermion anomalous pairing term.

creation(*[, site, coef])

Creation operator for a spinless fermions system.

hopping(coef)

The spinless fermion hopping term.

interaction(coef)

The spinless fermion interaction term.

number(*[, site, coef])

Term for the number operator.

zero()

Zero operator for a spinless fermion system.

Classes

ExpressionType(value[, names, module, ...])

The type of an expression.

HamiltonianExpression(coef_hopping, ...)

Defines a Hamiltonian of a spinless fermion system.

MatrixEntryGenerator()

Operator(*args, **kwargs)

Operator acting on a space representing spinless fermions.

OperatorFromFunction(fun, dtype, expression_type)

Create an operator expression from an add_triplets function.

OperatorFromTriplets(triplet_list, ...)

Create an operator expression from a list of triplets.

OperatorInfo(*, domain, codomain, dtype)

The properties of an operator excluding the matrix elements.

VectorSpace(*, sites, particle_numbers)

The vector space for spinless fermions.
class Operator(*args, **kwargs)#

Operator acting on a space representing spinless fermions.

Constructor.

Parameters:

  • expression (Expression) – The operator expression.

  • domain (VectorSpace) – The domain of the operator.

  • codomain (VectorSpace) – The codomain of the operator.

  • transpose (bool) – When true, construct the transpose of the operator.

  • dtype (DTypeLike) – Force a specific dtype.

  • operator_type (OperatorFactory | None) – The operator backend.

property H#

Hermitian adjoint.

Returns the Hermitian adjoint of self, aka the Hermitian conjugate or Hermitian transpose. For a complex matrix, the Hermitian adjoint is equal to the conjugate transpose.

Can be abbreviated self.H instead of self.adjoint().

Returns:

A_H – Hermitian adjoint of self.

Return type:

LinearOperator

property T#

Transpose this linear operator.

Returns a LinearOperator that represents the transpose of this one. Can be abbreviated self.T instead of self.transpose().

__init__(expression: Expression, *, domain: VectorSpace, codomain: VectorSpace | None = None, transpose: bool = False, dtype: DTypeLike | None = None, operator_type: OperatorFactory | None = None) → None#

Constructor.

Parameters:

  • expression (Expression) – The operator expression.

  • domain (VectorSpace) – The domain of the operator.

  • codomain (VectorSpace) – The codomain of the operator.

  • transpose (bool) – When true, construct the transpose of the operator.

  • dtype (DTypeLike) – Force a specific dtype.

  • operator_type (OperatorFactory | None) – The operator backend.

adjoint()#

Hermitian adjoint.

Returns the Hermitian adjoint of self, aka the Hermitian conjugate or Hermitian transpose. For a complex matrix, the Hermitian adjoint is equal to the conjugate transpose.

Can be abbreviated self.H instead of self.adjoint().

Returns:

A_H – Hermitian adjoint of self.

Return type:

LinearOperator

property codomain: VectorSpace#

The codomain of the operator.

property domain: VectorSpace#

The domain of the operator.

dot(x: ndarray, out: ndarray | None = None) → ndarray#

Compute the dot product of operator with array; optional out to avoid reallocation.

When represented by NumPy this operation would be A @ x.

Parameters:

  • x (np.ndarray) – The vector/array to dot product with.

  • out (Optional[np.ndarray]) – Optional array to store results and avoid reallocation.

Returns:

The result of the dot product, A @ x.

Return type:

np.ndarray

dot_add(x: ndarray, out: ndarray, z: float | complex = 1.0) → None#

Compute the dot product of operator with array and add it to out array.

When represented by NumPy this operation would be out += z * (A @ x).

Parameters:

  • x (np.ndarray) – The vector/array to dot product with.

  • out (np.ndarray) – The array to which the outcome will be added.

  • z (complex) – scalar prefactor before addition, defaults to unity.

dot_h(x: ndarray, out: ndarray | None = None) → ndarray#

Compute the dot product of operator adjoint with array, allows optional out.

When represented by NumPy this operation would be A.conj().T @ x. Though transpose returns only a view of a matrix, conjugate returns a copy, hence this method.

Parameters:

  • x (np.ndarray) – The vector/array to dot product with.

  • out (Optional[np.ndarray]) – Optional array to store results and avoid reallocation.

Returns:

The result of the dot product, A.conj().T @ x.

Return type:

np.ndarray

property dtype: OperatorDType#

The NumPy dtype.

matmat(X)#

Matrix-matrix multiplication.

Performs the operation y=A@X where A is an MxN linear operator and X dense N*K matrix or ndarray.

Parameters:

X ({matrix, ndarray}) – An array with shape (N,K).

Returns:

Y – A matrix or ndarray with shape (M,K) depending on the type of the X argument.

Return type:

{matrix, ndarray}

Notes

This matmat wraps any user-specified matmat routine or overridden _matmat method to ensure that y has the correct type.

matvec(x)#

Matrix-vector multiplication.

Performs the operation y=A@x where A is an MxN linear operator and x is a column vector or 1-d array.

Parameters:

x ({matrix, ndarray}) – An array with shape (N,) or (N,1).

Returns:

y – A matrix or ndarray with shape (M,) or (M,1) depending on the type and shape of the x argument.

Return type:

{matrix, ndarray}

Notes

This matvec wraps the user-specified matvec routine or overridden _matvec method to ensure that y has the correct shape and type.

rdot(x: ndarray) → ndarray#

Compute the dot product of array with operator.

When represented by NumPy this operation would be x @ A.

Parameters:

x (np.ndarray) – The vector/array to dot product with.

Returns:

The result of the dot product, x @ A.

Return type:

np.ndarray

rdot_h(x: ndarray) → ndarray#

Compute the dot product of array with operator adjoint.

When represented by NumPy this operation would be x @ A.conj().T.

Parameters:

x (np.ndarray) – The vector/array to dot product with.

Returns:

The result of the dot product, x @ A.conj().T.

Return type:

np.ndarray

rmatmat(X)#

Adjoint matrix-matrix multiplication.

Performs the operation y = A^H @ x where A is an MxN linear operator and x is a column vector or 1-d array, or 2-d array. The default implementation defers to the adjoint.

Parameters:

X ({matrix, ndarray}) – A matrix or 2D array.

Returns:

Y – A matrix or 2D array depending on the type of the input.

Return type:

{matrix, ndarray}

Notes

This rmatmat wraps the user-specified rmatmat routine.

rmatvec(x)#

Adjoint matrix-vector multiplication.

Performs the operation y = A^H @ x where A is an MxN linear operator and x is a column vector or 1-d array.

Parameters:

x ({matrix, ndarray}) – An array with shape (M,) or (M,1).

Returns:

y – A matrix or ndarray with shape (N,) or (N,1) depending on the type and shape of the x argument.

Return type:

{matrix, ndarray}

Notes

This rmatvec wraps the user-specified rmatvec routine or overridden _rmatvec method to ensure that y has the correct shape and type.

property shape: tuple[int, int]#

Returns the shape tuple of the class.

Returns:

The tuple containing the dimensions of the class.

Return type:

Tuple[int, …]

todense() → ndarray#

Return the operator as a dense matrix.

Returns:

The operator as a dense matrix.

Return type:

np.ndarray

transpose()#

Transpose this linear operator.

Returns a LinearOperator that represents the transpose of this one. Can be abbreviated self.T instead of self.transpose().

class VectorSpace(*, sites: int, particle_numbers: Literal['even', 'odd'] | int | tuple[int, int])#

The vector space for spinless fermions.

sites#

The number of sites.

Type:

int

particle_number_offset#

Together with particle_number_stride, defines the set of allowed particle numbers. The allowed particle numbers are particle_number_offset plus any multiple of particle_number_stride.

Type:

int

particle_number_stride#

Together with particle_number_stride, defines the set of allowed particle numbers. The allowed particle numbers are particle_number_offset plus any multiple of particle_number_stride.

Type:

int

Create VectorSpace.

Parameters:

  • sites (int) – The number of sites.

  • particle_numbers ("even" | "odd" | int | tuple[int, int]) – Set to “even” and “odd” allows for all even and odd particle numbers, respectively. Set to an integer allows only this particular particle number. Set to a tuple, defines particle_number_offset and particle_number_stride.

__init__(*, sites: int, particle_numbers: Literal['even', 'odd'] | int | tuple[int, int]) → None#

Create VectorSpace.

Parameters:

  • sites (int) – The number of sites.

  • particle_numbers ("even" | "odd" | int | tuple[int, int]) – Set to “even” and “odd” allows for all even and odd particle numbers, respectively. Set to an integer allows only this particular particle number. Set to a tuple, defines particle_number_offset and particle_number_stride.

all_occupations() → Iterator[list[int]]#

Iterator over all possible occupation configurations.

Returns:

The iterator.

Return type:

Iterator[list[int]]

copy(*, particle_number_change: int) → VectorSpace#

Returns a new vector space with a different value for particles.

Parameters:

particle_number_change (int) – The value to be added to the number of particles. Allowed to be negative.

property dim: int#

The dimension of the vector space.

fock_state(occupation: list[int]) → ndarray#

Returns an element of the occupancy number basis.

Parameters:

occupation (list[int]) – The occupation number per site. Must be 0 or 1.

occupation(fock_state: ndarray, decimal: int = 7) → tuple[int, list[int]]#

Given a fock state, returns the corresponding occupations.

Parameters:

  • fock_state (ndarray) – A vector representing a fock state of the current vector space.

  • decimal (int) – The number of decimals the input vector has to coninside with to a fock state representation.

Returns:

The sign and occupation numbers of the state.

Return type:

tuple[int, list[int]]

annihilation(*, site: int | None = None, coef: ArrayLike | None = None) → Expression#

Annihilation operator for a spinless fermions system.

Either site or coef needs to be specified.

Parameters:

  • site (int) – When specified return a annihilation operator for a specific site.

  • coef (ArrayLike) – When specified return a linear combination of annihilation operators. The coef array contains the coefficients, where the i-th entry corresponds to the annihilation operator at the i-th site.

anomalous_pairing(coef: ArrayLike) → Expression#

The spinless fermion anomalous pairing term.

Parameters:

coef (ArrayLike) –

The “anomalous pairing” matrix \(D\). To define the pairing part, you should define the upper triangular part of the matrix U. Defining this matrix adds

\[\sum_{j,k=0}^{M-1} D_{jk} \, \hat{c}_j \hat{c}_k + D_{jk}^* \, \hat{c}_k^\dagger \hat{c}_j^\dagger\]

to the Hamiltonian.

creation(*, site: int | None = None, coef: ArrayLike | None = None) → Expression#

Creation operator for a spinless fermions system.

Either site or coef needs to be specified.

Parameters:

  • site (int) – When specified return a creation operator for a specific site.

  • coef (ArrayLike) – When specified return a linear combination of creation operators. The coef array contains the coefficients, where the i-th entry corresponds to the creation operator at the i-th site.

hopping(coef: ArrayLike) → Expression#

The spinless fermion hopping term.

Parameters:

coef (ArrayLike) –

The “hopping” matrix \(h_0\). The diagonal elements of \(h_0\) define the vector \(\varepsilon\) from the HQS Lattice Documentation, and the off-diagonal elements the matrix \(t\). In other words, defining the attribute h0 adds

\[\sum_{j,k=0}^{M-1} (h_0)_{jk} \, \hat{c}_j^\dagger \hat{c}_k = \sum_{j\not=k} (h_0)_{jk} \, \hat{c}_j^\dagger \hat{c}_k + \sum_{j=0}^{M-1} (h_0)_{jj} \, \hat{n}_j\]

to the Hamiltonian to be defined.

interaction(coef: ArrayLike) → Expression#

The spinless fermion interaction term.

Parameters:

coef (ArrayLike) –

The “interaction” matrix \(U\). To define the interaction part, you should define the upper triangular part of the matrix U. Defining U, adds

\[\sum_{j,k=0}^{M-1} U_{jk}\, \left(\hat{n}_j - \tfrac12\middle) \middle(\hat{n}_k - \tfrac12\right)\]

to the Hamiltonian to be defined.

Note

The cofficient matrix must be real-valued.

number(*, site: int | None = None, coef: ArrayLike | None = None) → Expression#

Term for the number operator.

The term is defined by

\[\hat{c}_k^\dagger \hat{c}_k\]

if site is given and

\[\sum_j \varepsilon_j \hat{c}_j^\dagger\]

is coef is given.

Parameters:

  • site (int) – Specifies the index k.

  • coef (ArrayLike) – Specifies the coefficients \(\varepsilon_j\).

Returns:

The operator expression.

Return type:

Expression

zero() → Expression[MatrixEntryGenerator]#

Zero operator for a spinless fermion system.

Returns:

The operator expression.

Return type:

Expression