Reduce unnecessary manual definitions in TJOperators (#18)

* Use `S_plus, u_num, d_num` to express all one-body spin operators
* Fix typo in tjoperators test
* Fix docstring of `x_min_x_plus`
* Improve test on `singlet`

Author: Yue-Zhengyuan

src/tjoperators.jl

@@ -239,62 +239,83 @@ end
 const nʰ = h_num
 
 @doc """
-    S_x(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
-    Sˣ(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
+    S_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
+    S⁺(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
 
-Return the one-body spin-1/2 x-operator on the electrons.
-""" S_x
-function S_x(P::Type{<:Sector}=Trivial, S::Type{<:Sector}=Trivial;
-             slave_fermion::Bool=false)
-    return S_x(ComplexF64, P, S; slave_fermion)
+Return the spin-plus operator (only defined for `Trivial` spin symmetry).
+""" S_plus
+function S_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false)
+    return S_plus(ComplexF64, P, S; slave_fermion)
 end
-function S_x(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial};
-             slave_fermion::Bool=false)
+function S_plus(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial};
+                slave_fermion::Bool=false)
     t = single_site_operator(elt, Trivial, Trivial; slave_fermion)
     I = sectortype(t)
     b = slave_fermion ? 0 : 1
-    t[(I(b), dual(I(b)))][1, 2] = 0.5
-    t[(I(b), dual(I(b)))][2, 1] = 0.5
+    t[(I(b), dual(I(b)))][1, 2] = 1.0
     return t
 end
-function S_x(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial};
-             slave_fermion::Bool=false)
+function S_plus(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial};
+                slave_fermion::Bool=false)
     t = single_site_operator(elt, U1Irrep, Trivial; slave_fermion)
     I = sectortype(t)
     b = slave_fermion ? 0 : 1
-    t[(I(b, 1), dual(I(b, 1)))][1, 2] = 0.5
-    t[(I(b, 1), dual(I(b, 1)))][2, 1] = 0.5
+    t[(I(b, 1), dual(I(b, 1)))][1, 2] = 1.0
     return t
 end
+const S⁺ = S_plus
+
+@doc """
+    S_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
+    S⁻(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
+
+Return the spin-minus operator (only defined for `Trivial` spin symmetry).
+""" S_min
+function S_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false)
+    return S_min(ComplexF64, P, S; slave_fermion)
+end
+function S_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector},
+               spin_symmetry::Type{<:Sector};
+               slave_fermion::Bool=false)
+    return copy(adjoint(S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion)))
+end
+const S⁻ = S_min
+
+@doc """
+    S_x(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
+    Sˣ(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
+
+Return the one-body spin-1/2 x-operator on the electrons (only defined for `Trivial` spin symmetry).
+""" S_x
+function S_x(P::Type{<:Sector}=Trivial, S::Type{<:Sector}=Trivial;
+             slave_fermion::Bool=false)
+    return S_x(ComplexF64, P, S; slave_fermion)
+end
+function S_x(elt::Type{<:Number}, particle_symmetry::Type{<:Sector},
+             spin_symmetry::Type{<:Sector};
+             slave_fermion::Bool=false)
+    return (S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion)
+            +
+            S_min(elt, particle_symmetry, spin_symmetry; slave_fermion)) / 2
+end
 const Sˣ = S_x
 
 @doc """
     S_y(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
     Sʸ(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
 
-Return the one-body spin-1/2 x-operator on the electrons (only defined for `Trivial` symmetry). 
+Return the one-body spin-1/2 y-operator on the electrons (only defined for `Trivial` spin symmetry). 
 """ S_y
 function S_y(P::Type{<:Sector}=Trivial, S::Type{<:Sector}=Trivial;
              slave_fermion::Bool=false)
     return S_y(ComplexF64, P, S; slave_fermion)
 end
-function S_y(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial};
-             slave_fermion::Bool=false)
-    t = single_site_operator(elt, Trivial, Trivial; slave_fermion)
-    I = sectortype(t)
-    b = slave_fermion ? 0 : 1
-    t[(I(b), dual(I(b)))][1, 2] = -0.5im
-    t[(I(b), dual(I(b)))][2, 1] = 0.5im
-    return t
-end
-function S_y(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial};
+function S_y(elt::Type{<:Number}, particle_symmetry::Type{<:Sector},
+             spin_symmetry::Type{<:Sector};
              slave_fermion::Bool=false)
-    t = single_site_operator(elt, U1Irrep, Trivial; slave_fermion)
-    I = sectortype(t)
-    b = slave_fermion ? 0 : 1
-    t[(I(b, 1), dual(I(b, 1)))][1, 2] = -0.5im
-    t[(I(b, 1), dual(I(b, 1)))][2, 1] = 0.5im
-    return t
+    return (S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion)
+            -
+            S_min(elt, particle_symmetry, spin_symmetry; slave_fermion)) / (2im)
 end
 const Sʸ = S_y
 
@@ -308,78 +329,14 @@ function S_z(P::Type{<:Sector}=Trivial, S::Type{<:Sector}=Trivial;
              slave_fermion::Bool=false)
     return S_z(ComplexF64, P, S; slave_fermion)
 end
-function S_z(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial};
-             slave_fermion::Bool=false)
-    t = single_site_operator(elt, Trivial, Trivial; slave_fermion)
-    I = sectortype(t)
-    b = slave_fermion ? 0 : 1
-    t[(I(b), dual(I(b)))][1, 1] = 0.5
-    t[(I(b), dual(I(b)))][2, 2] = -0.5
-    return t
-end
-function S_z(elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep};
-             slave_fermion::Bool=false)
-    t = single_site_operator(elt, Trivial, U1Irrep; slave_fermion)
-    I = sectortype(t)
-    b = slave_fermion ? 0 : 1
-    t[(I(b, 1 // 2), dual(I(b, 1 // 2)))] .= 0.5
-    t[(I(b, -1 // 2), dual(I(b, -1 // 2)))] .= -0.5
-    return t
-end
-function S_z(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial};
+function S_z(elt::Type{<:Number}, particle_symmetry::Type{<:Sector},
+             spin_symmetry::Type{<:Sector};
              slave_fermion::Bool=false)
-    t = single_site_operator(elt, U1Irrep, Trivial; slave_fermion)
-    I = sectortype(t)
-    b = slave_fermion ? 0 : 1
-    t[(I(b, 1), dual(I(b, 1)))][1, 1] = 0.5
-    t[(I(b, 1), dual(I(b, 1)))][2, 2] = -0.5
-    return t
-end
-function S_z(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep};
-             slave_fermion::Bool=false)
-    t = single_site_operator(elt, U1Irrep, U1Irrep; slave_fermion)
-    I = sectortype(t)
-    b = slave_fermion ? 0 : 1
-    t[(I(b, 1, 1 // 2), dual(I(b, 1, 1 // 2)))] .= 0.5
-    t[(I(b, 1, -1 // 2), dual(I(b, 1, -1 // 2)))] .= -0.5
-    return t
+    return (u_num(elt, particle_symmetry, spin_symmetry; slave_fermion) -
+            d_num(elt, particle_symmetry, spin_symmetry; slave_fermion)) / 2
 end
 const Sᶻ = S_z
 
-@doc """
-    S_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
-    S⁺(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
-
-Return the spin-plus operator.
-""" S_plus
-function S_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false)
-    return S_plus(ComplexF64, P, S; slave_fermion)
-end
-function S_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector},
-                spin_symmetry::Type{<:Sector};
-                slave_fermion::Bool=false)
-    return S_x(elt::Type{<:Number}, particle_symmetry, spin_symmetry; slave_fermion) +
-           1im * S_y(elt, particle_symmetry, spin_symmetry; slave_fermion)
-end
-const S⁺ = S_plus
-
-@doc """
-    S_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
-    S⁻(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false)
-
-Return the spin-minus operator.
-""" S_min
-function S_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false)
-    return S_min(ComplexF64, P, S; slave_fermion)
-end
-function S_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector},
-               spin_symmetry::Type{<:Sector};
-               slave_fermion::Bool=false)
-    return S_x(elt, particle_symmetry, spin_symmetry; slave_fermion) -
-           1im * S_y(elt, particle_symmetry, spin_symmetry; slave_fermion)
-end
-const S⁻ = S_min
-
 # Two site operators
 # ------------------
 function two_site_operator(elt::Type{<:Number}, particle_symmetry::Type{<:Sector},
@@ -503,9 +460,7 @@ const d⁺d⁻ = d_plus_d_min
     u_min_u_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false)
     u⁻u⁺(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false)
 
-Return the Hermitian conjugate of `u_plus_u_min`, i.e.
-``(e†_{1,↑}, e_{2,↑})† = -e_{1,↑}, e†_{2,↑}`` (note the extra minus sign). 
-It annihilates a spin-up electron at the first site and creates a spin-up electron at the second.
+Return the two-body operator ``e_{1,↑}, e†_{2,↑}`` that annihilates a spin-up electron at the first site and creates a spin-up electron at the second.
 The only nonzero matrix element corresponds to `|0↑⟩ <-- |↑0⟩`.
 """ u_min_u_plus
 function u_min_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false)
@@ -522,9 +477,7 @@ const u⁻u⁺ = u_min_u_plus
     d_min_d_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false)
     d⁻d⁺(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false)
 
-Return the Hermitian conjugate of `d_plus_d_min`, i.e.
-``(e†_{1,↓}, e_{2,↓})† = -e_{1,↓}, e†_{2,↓}`` (note the extra minus sign). 
-It annihilates a spin-down electron at the first site and creates a spin-down electron at the second.
+Return the two-body operator ``e_{1,↓}, e†_{2,↓}`` that annihilates a spin-down electron at the first site and creates a spin-down electron at the second.
 The only nonzero matrix element corresponds to `|0↓⟩ <-- |↓0⟩`.
 """ d_min_d_plus
 function d_min_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false)
@@ -798,7 +751,6 @@ end
 function S_exchange(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep};
                     slave_fermion::Bool=false)
     t = two_site_operator(elt, Trivial, SU2Irrep; slave_fermion)
-
     for (s, f) in fusiontrees(t)
         l3 = f.uncoupled[1][2].j
         l4 = f.uncoupled[2][2].j
@@ -810,7 +762,6 @@ end
 function S_exchange(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep};
                     slave_fermion::Bool=false)
     t = two_site_operator(elt, U1Irrep, SU2Irrep; slave_fermion)
-
     for (s, f) in fusiontrees(t)
         l3 = f.uncoupled[1][3].j
         l4 = f.uncoupled[2][3].j

test/tjoperators.jl

@@ -83,12 +83,16 @@ end
                                                      slave_fermion)
                 end
 
-                # test spin operator
+                # test singlet operator
                 if particle_symmetry == Trivial && spin_symmetry !== SU2Irrep
-                    @test singlet_min(particle_symmetry, spin_symmetry; slave_fermion) ≈
-                          (u_min_d_min(particle_symmetry, spin_symmetry; slave_fermion) -
-                           d_min_u_min(particle_symmetry, spin_symmetry; slave_fermion)) /
-                          sqrt(2)
+                    sing = singlet_min(particle_symmetry, spin_symmetry;
+                                       slave_fermion)
+                    ud = u_min_d_min(particle_symmetry, spin_symmetry;
+                                     slave_fermion)
+                    du = d_min_u_min(particle_symmetry, spin_symmetry; slave_fermion)
+                    @test permute(ud, ((2, 1), (4, 3))) ≈ -du
+                    @test permute(sing, ((2, 1), (4, 3))) ≈ sing
+                    @test sing ≈ (ud - du) / sqrt(2)
                 else
                     @test_throws ArgumentError singlet_min(particle_symmetry, spin_symmetry;
                                                            slave_fermion)
@@ -103,6 +107,7 @@ end
                       e_plus_e_min(particle_symmetry, spin_symmetry; slave_fermion) -
                       e_min_e_plus(particle_symmetry, spin_symmetry; slave_fermion)
 
+                # test spin operator
                 if spin_symmetry == Trivial
                     ε = zeros(ComplexF64, 3, 3, 3)
                     for i in 1:3