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.

identity()

The identity operator.

interaction(coef)

The spinless fermion interaction term.

lattice_terms(lattice)

Returns the terms corresonding to a Lattice Builder configuration or instance.

number(*[, site, coef])

Term for the number operator.

zero()

Zero operator for a spinless fermion system.

Classes

Operator

Operator acting on a space representing spinless fermions.

VectorSpace

The vector space for spinless fermions.
class Operator#

Operator acting on a space representing spinless fermions.

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: SparseMatrixFactory | 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.

static __new__(cls, *args, **kwargs)#
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#

The vector space for spinless fermions.

The space is spanned by vectors of the form

\[\prod_{j=0}^{M-1} (c_j^\dagger)^{n_j} \ket{0} \quad\text{where}\quad n_j \in \{ 0, 1 \},\]

and \(c_j^\dagger\) is the creation operator for site \(j\).

The vector space contains all vectors from the set above where the total particle number is equal to

\[\left( \texttt{particle_number_offset} + k \cdot \texttt{particle_number_stride} \right)\]

for \(k \in \mathbb{Z}\).

sites#

The number of sites.

Type:

int

particle_number_offset#

The offset of the restriction of the total particle number.

Type:

int

particle_number_stride#

The stride of the restriction of the total particle number.

Type:

int

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

    Restricts the states of the system.

    "even"

    Restricts to states having an even number of particles.

    "odd"

    Restricts to states having an odd number of particle.

    int

    Restricts to states that have the the given number of particles.

    tuple[int, int]

    Given the tuple (offset, stride) restricts to states that have a particle number equal to offset plus an integer multiple of 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.

identity() → Expression[MatrixEntryGenerator]#

The identity operator.

Returns:

Term describing the identity operator.

Return type:

Expression

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.

lattice_terms(lattice: dict[str, Any] | lb.models.LatticeBuilderInputSpinless | lb.Builder) → Expression#

Returns the terms corresonding to a Lattice Builder configuration or instance.

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 \hat{c}_j\]

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