symmetrize

Symmetrizes an operator with respect to a permutation symmetry group.

Source symmetrize.hpp

JuliaC++

symmetrize(op::Op, group::PermutationGroup)
symmetrize(op::Op, group::PermutationGroup, irrep::Representation)
symmetrize(ops::OpSum, group::PermutationGroup)
symmetrize(ops::OpSum, group::PermutationGroup, irrep::Representation)

OpSum symmetrize(Op const &op, PermutationGroup const &group);
OpSum symmetrize(Op const &op, PermutationGroup const &group, Representation const &irrep);
OpSum symmetrize(OpSum const &ops, PermutationGroup const &group);
OpSum symmetrize(OpSum const &ops, PermutationGroup const &group, Representation const &irrep);

Parameters

Name	Description
ops / op	OpSum or Op defining the operator to be symmetrized
group	PermutationGroup defining the permutation symmetries
irrep	Irreducible Representation of the symmetry group

Symmetrization in this context means the following. In general, we are given an OpSum of the form,

\[ O = \sum_{A\subseteq \mathcal{L}} O_A,\]

where \(O_A\) denotes a local operator acting on sites \(A=\{a_1, \ldots, a_{l_A}\}\) and \(L\) denotes the lattice. A PermutationGroup \(\mathcal{G}\) is defined through its permutations \(\pi_1, \ldots, \pi_M\). The symmetrized operator returned by this function is then

\[ O^\mathcal{G} = \frac{1}{M}\sum_{A\subseteq \mathcal{L}} \sum_{\pi \in \mathcal{G}} O_{\pi(A)},\]

where \(\pi(A) = \{\pi(a_1), \ldots,\pi(a_{l_A})\}\) denotes the permutated set of sites of the local operator \(O_A\). If a Representation called \(\rho\) is given in addition, the following operator is constructed,

\[ O^\mathcal{G, \rho} = \frac{1}{M}\sum_{A\subseteq \mathcal{L}} \sum_{\pi \in \mathcal{G}} \chi_\rho(\pi) O_{\pi(A)},\]

where \(\chi_\rho(\pi)\) denotes the characters of the representation \(\rho\). This routine is useful to evaluate observables in symmetrized blocks.

Usage Example

JuliaC++

let
    N = 4
    nup = 2
    block = Spinhalf(N, nup)
    p1 = Permutation([1, 2, 3, 4])
    p2 = Permutation([2, 3, 4, 1])
    p3 = Permutation([3, 4, 1, 2])
    p4 = Permutation([4, 1, 2, 3])
    group = PermutationGroup([p1, p2, p3, p4])
    rep = Representation([1, 1, 1, 1])
    block_sym = Spinhalf(N, group, rep)

    ops = OpSum()
    for i in 1:N
        ops += Op("HB", 1.0, [i, mod1(i+1, N)])
    end

    e0, psi = eig0(ops, block);
    e0, psi_sym = eig0(ops, block_sym);

    corr = Op("HB", 1.0, [1, 2])
    nn_corr = inner(corr, psi)
    corr_sym = symmetrize(corr, group)
    nn_corr_sym = inner(corr_sym, psi_sym)
    @show nn_corr, nn_corr_sym
end

int N = 4;
int nup = 2;
auto block = Spinhalf(N, nup);
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 rep = Representation({1, 1, 1, 1});
auto block_sym = Spinhalf(N, group, rep);

auto ops = OpSum();
for (int i=0; i<N; ++i) {
  ops += Op("HB", 1.0, {i, (i+1)%N});
}
auto [e0, psi] = eig0(ops, block);
auto [e0s, psi_sym] = eig0(ops, block_sym);

auto corr = Op("HB", 1.0, {0, 1});
auto nn_corr = inner(corr, psi);
auto corr_sym = symmetrize(corr, group);
auto nn_corr_sym = innerC(corr_sym, psi_sym);
XDIAG_SHOW(nn_corr);
XDIAG_SHOW(nn_corr_sym);