tJ

A block in a \(t-J\) type Hilbert space, i.e. fermions with \(\uparrow, \downarrow\) spin excluding doubly occupied sites.

Sources: tj.hpp · tj.cpp

Constructors

JuliaC++

tJ(nsites::Int64, nup::Int64, ndn::Int64)
tJ(nsites::Int64, nup::Int64, ndn::Int64, irrep::Representation)

tJ(int64_t nsites, int64_t nup, int64_t ndn);
tJ(int64_t nsites, int64_t nup, int64_t ndn, Representation const &irrep);

Name	Description	Default
nsites	number of sites (integer)
nup	number of "up" electrons (integer)
ndn	number of "dn" electrons (integer)
irrep	Irreducible Representation of the symmetry group

Local configurations

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

Integer	Configuration	Symbol
`0`	empty	○
`1`	up-spin electron	↑
`2`	down-spin electron	↓

The Jordan-Wigner sign convention used for the fermionic operators is described in the Hilbert spaces section of the user guide.

Operators

The following operator types can be used on a tJ block. Here \(c^\dagger_{i\sigma}\), \(c_{i\sigma}\) are the electron creation and annihilation operators, \(n_{i\sigma} = c^\dagger_{i\sigma}c_{i\sigma}\), \(n_i = n_{i\uparrow} + n_{i\downarrow}\), and \(\mathbf{S}_i\) is the spin operator with \(S^z_i = \tfrac12(n_{i\uparrow} - n_{i\downarrow})\), \(S^+_i = c^\dagger_{i\uparrow}c_{i\downarrow}\).

Type	Description	Formula	No. of sites
`Cdagup`	creation operator (\(\uparrow\))	\(c^\dagger_{i\uparrow}\)	1
`Cup`	annihilation operator (\(\uparrow\))	\(c_{i\uparrow}\)	1
`Cdagdn`	creation operator (\(\downarrow\))	\(c^\dagger_{i\downarrow}\)	1
`Cdn`	annihilation operator (\(\downarrow\))	\(c_{i\downarrow}\)	1
`Hop`	hopping (\(\uparrow\) and \(\downarrow\))	\(-\sum_\sigma (c^\dagger_{i\sigma}c_{j\sigma} + \mathrm{h.c.})\)	2
`Hopup`	hopping (\(\uparrow\))	\(-(c^\dagger_{i\uparrow}c_{j\uparrow} + \mathrm{h.c.})\)	2
`Hopdn`	hopping (\(\downarrow\))	\(-(c^\dagger_{i\downarrow}c_{j\downarrow} + \mathrm{h.c.})\)	2
`HopAsym`, `HopupAsym`, `HopdnAsym`	antisymmetric hopping variants	\(-(c^\dagger_{i\sigma}c_{j\sigma} - \mathrm{h.c.})\)	2
`Nup`	number operator (\(\uparrow\))	\(n_{i\uparrow}\)	1
`Ndn`	number operator (\(\downarrow\))	\(n_{i\downarrow}\)	1
`Ntot`	number operator	\(n_i = n_{i\uparrow} + n_{i\downarrow}\)	1
`NtotNtot`	density-density interaction	\(n_i n_j\)	2
`NupNup`, `NupNdn`, `NdnNup`, `NdnNdn`	spin-resolved density-density	\(n_{i\sigma} n_{j\sigma'}\)	2
`SdotS`	Heisenberg interaction	\(\mathbf{S}_i \cdot \mathbf{S}_j\)	2
`SzSz`	Ising interaction	\(S^z_i S^z_j\)	2
`Exchange`	spin exchange interaction	\(\frac{1}{2}(S^+_i S^-_j + S^-_i S^+_j)\)	2
`ExchangeAsym`	antisymmetric exchange	\(\frac{1}{2}(S^+_i S^-_j - S^-_i S^+_j)\)	2
`tJSdotS`	\(t\)-\(J\) Heisenberg interaction	\(\mathbf{S}_i \cdot \mathbf{S}_j - \frac{n_i n_j}{4}\)	2
`tJSzSz`	\(t\)-\(J\) Ising interaction	\(S^z_i S^z_j - \frac{n_i n_j}{4}\)	2
`Sz`	local magnetic moment (\(z\))	\(S^z_i\)	1
`Sx`, `Sy`	local magnetic moment (\(x\), \(y\))	\(S^x_i\), \(S^y_i\)	1
`S+`, `S-`	spin raising / lowering	\(S^+_i\), \(S^-_i\)	1
`TotalN`	total electron number	\(\sum_i n_i\)	0
`TotalNup`, `TotalNdn`	total spin-resolved number	\(\sum_i n_{i\uparrow}\), \(\sum_i n_{i\downarrow}\)	0
`TotalSz`	total magnetization	\(\sum_i S^z_i\)	0
`Id`	identity	\(\mathbb{1}\)	0

For a full description of all operator types, see the operator types page.

Iteration

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

JuliaC++

block = tJ(4, 2, 1)
for pstate in block
    @show pstate, index(block, pstate) 
end

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

Methods

index

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

JuliaC++

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

int64_t tJ::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.

JuliaC++

nsites(block::tJ)::Int64

int64_t nsites(tJ const &block);

size

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

JuliaC++

size(block::tJ)::Int64

int64_t size(tJ const &block) const;

dim

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

JuliaC++

dim(block::tJ)::Int64

int64_t dim(tJ const &block) const;

isreal

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

JuliaC++

isreal(block::tJ)::Int64

bool isreal(tJ const &block);

Usage Example

JuliaC++

N = 4
nup = 2
ndn = 1

# without permutation symmetries
block = tJ(N, nup, ndn)
@show block

# with permutation symmetries
p = Permutation([2, 3, 4, 1])
group = PermutationGroup([p^0, p^1, p^2, p^3])
rep = Representation(group, [1.0, -1.0, 1.0, -1.0])
block_sym = tJ(N, nup, ndn, rep)
@show block_sym

@show nsites(block_sym)
@show size(block_sym)

# Iteration
for pstate in block_sym
    @show pstate, index(block_sym, pstate)
end

int N = 4;
int nup = 2;
int ndn = 1;

// without permutation symmetries
auto block = tJ(N, nup, ndn);
XDIAG_SHOW(block);

// with permutation symmetries
auto p1 = Permutation({0, 1, 2, 3});
auto p2 = Permutation({1, 2, 3, 0});
auto p3 = Permutation({2, 3, 0, 1});
auto p4 = Permutation({3, 0, 1, 2});
auto group = PermutationGroup({p1, p2, p3, p4});
auto irrep = Representation(group, arma::vec{1, -1, 1, -1});
auto block_sym = tJ(N, nup, ndn, irrep);
XDIAG_SHOW(block_sym);
XDIAG_SHOW(block_sym.nsites());
XDIAG_SHOW(block_sym.size());

// Iteration
for (auto pstate : block_sym) {
  Log("{} {}", to_string(pstate), block_sym.index(pstate));
}