Skip to content

Boson

A block in a Hilbert space of bosons with a fixed local dimension \(d\), i.e. each site can be occupied by \(0, 1, \ldots, d-1\) particles.

Since a \(d\)-level local degree of freedom equally describes a spin \(S = (d-1)/2\), the same block also represents general spin-\(S\) systems. For this reason Boson is also available under the alias Spin, and both the bosonic ladder operators and the spin-\(S\) operators are defined on it (see Operators below).

Sources: boson.hpp ยท boson.cpp

Constructors

Boson(nsites::Int64, d::Int64)
Boson(nsites::Int64, d::Int64, number::Int64)
Boson(nsites::Int64, d::Int64, irrep::Representation)
Boson(nsites::Int64, d::Int64, number::Int64, irrep::Representation)

Boson(int64_t nsites, int64_t d);
Boson(int64_t nsites, int64_t d, int64_t number);
Boson(int64_t nsites, int64_t d, Representation const &irrep);
Boson(int64_t nsites, int64_t d, int64_t number, Representation const &irrep);
Name Description Default
nsites number of sites (integer)
d local dimension, i.e. number of local states \(0,\ldots,d-1\) (\(2 \le d \le 256\))
number total number of bosons (integer)
irrep Irreducible Representation of the symmetry group

If the number argument is omitted, the block contains all boson numbers. The spin-\(S\) degree of freedom corresponds to a local dimension \(d = 2S + 1\); the Spin alias can be used interchangeably with Boson.

Local configurations

Each site of a Boson block carries a local dimension \(d\). In a ProductState, the local configuration of a site is simply the occupation number, i.e. an integer in \(0, 1, \ldots, d-1\). In the spin-\(S\) interpretation, an occupation \(n\) corresponds to the magnetic quantum number \(m = n - S\) with \(S = (d-1)/2\).

Operators

Two families of operators are defined on a Boson block. The bosonic ladder operators act on the occupation numbers, with \(a_i |n\rangle = \sqrt{n}\,|n-1\rangle\), \(a^\dagger_i |n\rangle = \sqrt{n+1}\,|n+1\rangle\) (truncated at \(n = d-1\)), and \(n_i = a^\dagger_i a_i\).

Type Description Formula No. of sites
Adag bosonic creation operator \(a^\dagger_i\) 1
A bosonic annihilation operator \(a_i\) 1
N number operator \(n_i = a^\dagger_i a_i\) 1
Hop hopping term \(-(a^\dagger_i a_j + a^\dagger_j a_i)\) 2
HopAsym antisymmetric hopping term \(-(a^\dagger_i a_j - a^\dagger_j a_i)\) 2
HubbardU on-site interaction \(\frac{1}{2}\sum_i n_i (n_i - 1)\) 0
TotalN total number of bosons \(\sum_i n_i\) 0

The spin-\(S\) operators (with \(S = (d-1)/2\)) act on the same local states. Here \(\mathbf{S}_i = (S^x_i, S^y_i, S^z_i)\) and \(S^\pm_i = S^x_i \pm i S^y_i\).

Type Description Formula No. of sites
Sz local magnetic moment (\(z\)) \(S^z_i\) 1
Sx local magnetic moment (\(x\)) \(S^x_i\) 1
Sy local magnetic moment (\(y\)) \(S^y_i\) 1
S+ spin raising operator \(S^+_i\) 1
S- spin lowering operator \(S^-_i\) 1
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
ScalarChirality scalar chirality \(\mathbf{S}_i \cdot (\mathbf{S}_j \times \mathbf{S}_k)\) 3
Matrix generic operator via a matrix user-defined matrix on the \(d^n\)-dimensional local space of \(n\) sites any
Id identity \(\mathbb{1}\) 0

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

Iteration

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

block = Boson(4, 3, 2)   # 4 sites, local dimension 3, 2 bosons
for pstate in block
    @show to_string(pstate, block), index(block, pstate)
end

auto block = Boson(4, 3, 2);   // 4 sites, local dimension 3, 2 bosons
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 Boson block.

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

int64_t Boson::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::Boson)::Int64

int64_t nsites(Boson const &block);

d

Returns the local dimension of the block.

d(block::Boson)::Int64

int64_t d(Boson const &block);

size

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

size(block::Boson)::Int64

int64_t size(Boson const &block);

dim

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

dim(block::Boson)::Int64

int64_t dim(Boson 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::Boson)::Bool

bool isreal(Boson const &block);

Usage Example

A Bose-Hubbard chain with nearest-neighbor hopping and on-site interaction.

let
    N = 6
    d = 4         # local dimension: up to d-1 = 3 bosons per site
    nbosons = 6

    # Bose-Hubbard chain: hopping + on-site interaction
    block = Boson(N, d, nbosons)
    ops = OpSum()
    for i in 1:N
        ops += "t" * Op("Hop", [i, mod1(i + 1, N)])
    end
    ops += "U" * Op("HubbardU")
    ops["t"] = 1.0
    ops["U"] = 4.0

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

int N = 6;
int d = 4;         // local dimension: up to d-1 = 3 bosons per site
int nbosons = 6;

// Bose-Hubbard chain: hopping + on-site interaction
auto block = Boson(N, d, nbosons);
auto ops = OpSum();
for (int i = 0; i < N; ++i) {
  ops += "t" * Op("Hop", {i, (i + 1) % N});
}
ops += "U" * Op("HubbardU");
ops["t"] = 1.0;
ops["U"] = 4.0;

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