symmetrize

Symmetrizes an operator with respect to a PermutationGroup or a Representation.

Sources
symmetrize.hpp
symmetrize.cpp
symmetrize.jl

---

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.

---

Definition

C++Julia

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

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

---

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

---

Usage Example

C++Julia

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(group);
auto block_sym = Spinhalf(N, rep);

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

auto corr = Op("SdotS", {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);

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(group)
    block_sym = Spinhalf(N, rep)

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

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

    corr = Op("SdotS", [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