Skip to content

Fermion

A block in a Hilbert space of spinless fermions.

Sources: fermion.hpp · fermion.cpp

Constructors

Fermion(nsites::Int64)
Fermion(nsites::Int64, number::Int64)
Fermion(nsites::Int64, irrep::Representation)
Fermion(nsites::Int64, number::Int64, irrep::Representation)

Fermion(int64_t nsites);
Fermion(int64_t nsites, int64_t number);
Fermion(int64_t nsites, Representation const &irrep);
Fermion(int64_t nsites, int64_t number, Representation const &irrep);
Name Description Default
nsites number of sites (integer)
number number of fermions (integer)
irrep Irreducible Representation of the symmetry group

If the number argument is omitted, the block contains all fermion numbers from \(0\) to nsites.

Local configurations

Each site of a Fermion block carries a local dimension \(d=2\). In a ProductState, the local configuration of every site is given by an integer with the following meaning:

Integer Configuration Symbol
0 empty ○
1 occupied fermion ●

Operators

The following operator types can be used on a Fermion block. Here \(c^\dagger_i\) and \(c_i\) denote the fermionic creation and annihilation operators on site \(i\), and \(n_i = c^\dagger_i c_i\) is the number operator.

Type Description Formula No. of sites
Cdag creation operator \(c^\dagger_i\) 1
C annihilation operator \(c_i\) 1
N number operator \(n_i = c^\dagger_i c_i\) 1
NN density-density interaction \(n_i n_j\) 2
Hop hopping term \(-(c^\dagger_i c_j + c^\dagger_j c_i)\) 2
HopAsym antisymmetric hopping term \(-(c^\dagger_i c_j - c^\dagger_j c_i)\) 2
TotalN total number of fermions \(\sum_i n_i\) 0
Id identity \(\mathbb{1}\) 0

For a full description of all operator types, see the operator types page. The Jordan-Wigner sign convention used for the fermionic operators is described in the Hilbert spaces section of the user guide.

Iteration

A Fermion block can be iterated over, where at each iteration a ProductState representing the corresponding basis state is returned.

block = Fermion(4, 2)
for pstate in block
    @show to_string(pstate, block), index(block, pstate)
end

auto block = Fermion(4, 2);
for (auto pstate : block) {
  Log("{} {}", to_string(pstate, block), block.index(pstate));
}

Methods

index

Returns the index of a given ProductState in the basis of the Fermion block.

index(block::Fermion, pstate::ProductState)::Int64

int64_t Fermion::index(ProductState const &pstate);

1-indexing

In the C++ version, the index count starts from "0" whereas in Julia the index count starts from "1".

nsites

Returns the number of sites of the block.

nsites(block::Fermion)::Int64

int64_t nsites(Fermion const &block);

size

Returns the size of the block, i.e. its dimension.

size(block::Fermion)::Int64

int64_t size(Fermion const &block);

dim

Returns the dimension of the block, same as "size" for non-distributed blocks.

dim(block::Fermion)::Int64

int64_t dim(Fermion const &block);

isreal

Returns whether the block can be used with real arithmetic. Complex arithmetic is needed when a Representation is genuinely complex.

isreal(block::Fermion)::Bool

bool isreal(Fermion const &block);

Usage Example

A spinless fermion chain with nearest-neighbor hopping and density-density repulsion.

let
    N = 8
    nfermions = 4

    # Spinless fermion chain with hopping and nearest-neighbor repulsion
    block = Fermion(N, nfermions)
    ops = OpSum()
    for i in 1:N
        ops += "t" * Op("Hop", [i, mod1(i + 1, N)])
        ops += "V" * Op("NN", [i, mod1(i + 1, N)])
    end
    ops["t"] = 1.0
    ops["V"] = 2.0

    e0 = eigval0(ops, block)
    @show e0
end

int N = 8;
int nfermions = 4;

// Spinless fermion chain with hopping and nearest-neighbor repulsion
auto block = Fermion(N, nfermions);
auto ops = OpSum();
for (int i = 0; i < N; ++i) {
  ops += "t" * Op("Hop", {i, (i + 1) % N});
  ops += "V" * Op("NN", {i, (i + 1) % N});
}
ops["t"] = 1.0;
ops["V"] = 2.0;

double e0 = eigval0(ops, block);
XDIAG_SHOW(e0);