From 8dd2491cec0aab9bcf93c2db8a2000458155181a Mon Sep 17 00:00:00 2001 From: Lukas Devos Date: Tue, 5 Aug 2025 09:35:33 -0400 Subject: [PATCH 1/4] runic formatter --- docs/make.jl | 38 ++- src/bosonoperators.jl | 4 +- src/fermionoperators.jl | 14 +- src/hubbardoperators.jl | 196 ++++++++---- src/spinoperators.jl | 48 +-- src/tjoperators.jl | 664 +++++++++++++++++++++++++-------------- test/bosonoperators.jl | 16 +- test/hubbardoperators.jl | 66 ++-- test/spinoperators.jl | 40 +-- test/testsetup.jl | 16 +- test/tjoperators.jl | 274 ++++++++++------ 11 files changed, 860 insertions(+), 516 deletions(-) diff --git a/docs/make.jl b/docs/make.jl index 6f8a5b7..b83133d 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -1,21 +1,29 @@ using TensorKitTensors using Documenter -DocMeta.setdocmeta!(TensorKitTensors, :DocTestSetup, :(using TensorKitTensors); - recursive=true) +DocMeta.setdocmeta!( + TensorKitTensors, :DocTestSetup, :(using TensorKitTensors); + recursive = true +) -operatorpages = ["spinoperators.md", "bosonoperators.md", "fermionoperators.md", - "tjoperators.md", "hubbardoperators.md"] +operatorpages = [ + "spinoperators.md", "bosonoperators.md", "fermionoperators.md", + "tjoperators.md", "hubbardoperators.md", +] makedocs(; - modules=[TensorKitTensors], - authors="QuantumKitHub", - sitename="TensorKitTensors.jl", - format=Documenter.HTML(; - canonical="https://QuantumKitHub.github.io/TensorKitTensors.jl", - edit_link="main", - assets=String[],), - pages=["Home" => "index.md", "Operators" => operatorpages],) + modules = [TensorKitTensors], + authors = "QuantumKitHub", + sitename = "TensorKitTensors.jl", + format = Documenter.HTML(; + canonical = "https://QuantumKitHub.github.io/TensorKitTensors.jl", + edit_link = "main", + assets = String[], + ), + pages = ["Home" => "index.md", "Operators" => operatorpages], +) -deploydocs(; repo="github.com/QuantumKitHub/TensorKitTensors.jl", - devbranch="main", - push_preview=true) +deploydocs(; + repo = "github.com/QuantumKitHub/TensorKitTensors.jl", + devbranch = "main", + push_preview = true +) diff --git a/src/bosonoperators.jl b/src/bosonoperators.jl index 2f9422b..4c6911c 100644 --- a/src/bosonoperators.jl +++ b/src/bosonoperators.jl @@ -140,7 +140,7 @@ function b_plus_b_min(elt::Type{<:Number}, ::Type{U1Irrep}; cutoff::Integer) for (f1, f2) in fusiontrees(b⁺b⁻) c_out, c_in = f1.uncoupled, f2.uncoupled if c_in[1].charge + 1 == c_out[1].charge && - c_in[2].charge - 1 == c_out[2].charge + c_in[2].charge - 1 == c_out[2].charge b⁺b⁻[f1, f2] .= sqrt(c_out[1].charge) * sqrt(c_in[2].charge) end end @@ -169,7 +169,7 @@ function b_min_b_plus(elt::Type{<:Number}, ::Type{U1Irrep}; cutoff::Integer) for (f1, f2) in fusiontrees(b⁻b⁺) c_out, c_in = f1.uncoupled, f2.uncoupled if c_in[1].charge - 1 == c_out[1].charge && - c_in[2].charge + 1 == c_out[2].charge + c_in[2].charge + 1 == c_out[2].charge b⁻b⁺[f1, f2] .= sqrt(c_in[1].charge) * sqrt(c_out[2].charge) end end diff --git a/src/fermionoperators.jl b/src/fermionoperators.jl index 0be2561..e7a98ab 100644 --- a/src/fermionoperators.jl +++ b/src/fermionoperators.jl @@ -30,7 +30,7 @@ end Return the one-body operator that counts the nunber of particles. """ f_num -function f_num(T::Type{<:Number}=ComplexF64) +function f_num(T::Type{<:Number} = ComplexF64) t = single_site_operator(T) block(t, fℤ₂(1)) .= one(T) return t @@ -39,7 +39,7 @@ const n = f_num # Two site operators # ------------------ -function two_site_operator(T::Type{<:Number}=ComplexF64) +function two_site_operator(T::Type{<:Number} = ComplexF64) V = fermion_space() return zeros(T, V ⊗ V ← V ⊗ V) end @@ -50,7 +50,7 @@ end Return the two-body operator that creates a particle at the first site and annihilates a particle at the second. """ f_plus_f_min -function f_plus_f_min(T::Type{<:Number}=ComplexF64) +function f_plus_f_min(T::Type{<:Number} = ComplexF64) t = two_site_operator(T) I = sectortype(t) t[(I(1), I(0), dual(I(0)), dual(I(1)))] .= 1 @@ -64,7 +64,7 @@ const f⁺f⁻ = f_plus_f_min Return the two-body operator that annihilates a particle at the first site and creates a particle at the second. """ f_min_f_plus -function f_min_f_plus(T::Type{<:Number}=ComplexF64) +function f_min_f_plus(T::Type{<:Number} = ComplexF64) t = two_site_operator(T) I = sectortype(t) t[(I(0), I(1), dual(I(1)), dual(I(0)))] .= -1 @@ -78,7 +78,7 @@ const f⁻f⁺ = f_min_f_plus Return the two-body operator that creates a particle at the first and at the second site. """ f_plus_f_plus -function f_plus_f_plus(T::Type{<:Number}=ComplexF64) +function f_plus_f_plus(T::Type{<:Number} = ComplexF64) t = two_site_operator(T) I = sectortype(t) t[(I(1), I(1), dual(I(0)), dual(I(0)))] .= 1 @@ -92,7 +92,7 @@ const f⁺f⁺ = f_plus_f_plus Return the two-body operator that annihilates a particle at the first and at the second site. """ f_min_f_min -function f_min_f_min(T::Type{<:Number}=ComplexF64) +function f_min_f_min(T::Type{<:Number} = ComplexF64) t = two_site_operator(T) I = sectortype(t) t[(I(0), I(0), dual(I(1)), dual(I(1)))] .= 1 @@ -106,7 +106,7 @@ const f⁻f⁻ = f_min_f_min Return the two-body operator that describes a particle that hops between the first and the second site. """ f_hopping -function f_hopping(elt::Type{<:Number}=ComplexF64) +function f_hopping(elt::Type{<:Number} = ComplexF64) return f_plus_f_min(elt) - f_min_f_plus(elt) end const f_hop = f_hopping diff --git a/src/hubbardoperators.jl b/src/hubbardoperators.jl index bf74537..be9e3dd 100644 --- a/src/hubbardoperators.jl +++ b/src/hubbardoperators.jl @@ -33,7 +33,7 @@ Return the local hilbert space for a Hubbard-type model with the given particle ``` The possible symmetries are `Trivial`, `U1Irrep`, and `SU2Irrep`, for both particle number and spin. """ -function hubbard_space((::Type{Trivial})=Trivial, (::Type{Trivial})=Trivial) +function hubbard_space((::Type{Trivial}) = Trivial, (::Type{Trivial}) = Trivial) return Vect[FermionParity](0 => 2, 1 => 2) end function hubbard_space(::Type{Trivial}, ::Type{U1Irrep}) @@ -46,19 +46,25 @@ function hubbard_space(::Type{U1Irrep}, ::Type{Trivial}) return Vect[FermionParity ⊠ U1Irrep]((0, 0) => 1, (1, 1) => 2, (0, 2) => 1) end function hubbard_space(::Type{U1Irrep}, ::Type{U1Irrep}) - return Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]((0, 0, 0) => 1, (1, 1, 1 // 2) => 1, - (1, 1, -1 // 2) => 1, (0, 2, 0) => 1) + return Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]( + (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, + (1, 1, -1 // 2) => 1, (0, 2, 0) => 1 + ) end function hubbard_space(::Type{U1Irrep}, ::Type{SU2Irrep}) - return Vect[FermionParity ⊠ U1Irrep ⊠ SU2Irrep]((0, 0, 0) => 1, (1, 1, 1 // 2) => 1, - (0, 2, 0) => 1) + return Vect[FermionParity ⊠ U1Irrep ⊠ SU2Irrep]( + (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, + (0, 2, 0) => 1 + ) end function hubbard_space(::Type{SU2Irrep}, ::Type{Trivial}) return Vect[FermionParity ⊠ SU2Irrep]((0, 0) => 2, (1, 1 // 2) => 1) end function hubbard_space(::Type{SU2Irrep}, ::Type{U1Irrep}) - return Vect[FermionParity ⊠ SU2Irrep ⊠ U1Irrep]((0, 0, 0) => 1, (1, 1 // 2, 1) => 1, - (0, 0, 2) => 1) + return Vect[FermionParity ⊠ SU2Irrep ⊠ U1Irrep]( + (0, 0, 0) => 1, (1, 1 // 2, 1) => 1, + (0, 0, 2) => 1 + ) end function hubbard_space(::Type{SU2Irrep}, ::Type{SU2Irrep}) return Vect[FermionParity ⊠ SU2Irrep ⊠ SU2Irrep]((1, 1 // 2, 1 // 2) => 1) @@ -66,8 +72,10 @@ end # Single-site operators # --------------------- -function single_site_operator(T, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function single_site_operator( + T, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) V = hubbard_space(particle_symmetry, spin_symmetry) return zeros(T, V ← V) end @@ -79,7 +87,7 @@ end Return the one-body operator that counts the number of spin-up particles. """ u_num u_num(P::Type{<:Sector}, S::Type{<:Sector}) = u_num(ComplexF64, P, S) -function u_num(elt::Type{<:Number}, (::Type{Trivial})=Trivial, (::Type{Trivial})=Trivial) +function u_num(elt::Type{<:Number}, (::Type{Trivial}) = Trivial, (::Type{Trivial}) = Trivial) t = single_site_operator(elt, Trivial, Trivial) I = sectortype(t) t[(I(1), I(1))][1, 1] = 1 @@ -131,7 +139,7 @@ const nꜛ = u_num Return the one-body operator that counts the number of spin-down particles. """ d_num d_num(P::Type{<:Sector}, S::Type{<:Sector}) = d_num(ComplexF64, P, S) -function d_num(elt::Type{<:Number}, (::Type{Trivial})=Trivial, (::Type{Trivial})=Trivial) +function d_num(elt::Type{<:Number}, (::Type{Trivial}) = Trivial, (::Type{Trivial}) = Trivial) t = single_site_operator(elt, Trivial, Trivial) I = sectortype(t) t[(I(1), I(1))][2, 2] = 1 @@ -183,10 +191,12 @@ const nꜜ = d_num Return the one-body operator that counts the number of particles. """ e_num e_num(P::Type{<:Sector}, S::Type{<:Sector}) = e_num(ComplexF64, P, S) -function e_num(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function e_num( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return u_num(elt, particle_symmetry, spin_symmetry) + - d_num(elt, particle_symmetry, spin_symmetry) + d_num(elt, particle_symmetry, spin_symmetry) end function e_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}) t = single_site_operator(elt, Trivial, SU2Irrep) @@ -211,10 +221,12 @@ const n = e_num Return the one-body operator that counts the number of doubly occupied sites. """ ud_num ud_num(P::Type{<:Sector}, S::Type{<:Sector}) = ud_num(ComplexF64, P, S) -function ud_num(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function ud_num( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return u_num(elt, particle_symmetry, spin_symmetry) * - d_num(elt, particle_symmetry, spin_symmetry) + d_num(elt, particle_symmetry, spin_symmetry) end function ud_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}) t = single_site_operator(elt, Trivial, SU2Irrep) @@ -268,8 +280,10 @@ Return the spin-minus operator (only defined for `Trivial` spin symmetry). function S_min(P::Type{<:Sector}, S::Type{<:Sector}) return S_min(ComplexF64, P, S) end -function S_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function S_min( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return copy(adjoint(S_plus(elt, particle_symmetry, spin_symmetry))) end const S⁻ = S_min @@ -280,14 +294,18 @@ const S⁻ = S_min Return the one-body spin-1/2 x-operator on the electrons (only defined for `Trivial` symmetry). . """ S_x -function S_x(P::Type{<:Sector}=Trivial, S::Type{<:Sector}=Trivial) +function S_x(P::Type{<:Sector} = Trivial, S::Type{<:Sector} = Trivial) return S_x(ComplexF64, P, S) end -function S_x(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) - return (S_plus(elt, particle_symmetry, spin_symmetry) +function S_x( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) + return ( + S_plus(elt, particle_symmetry, spin_symmetry) + - S_min(elt, particle_symmetry, spin_symmetry)) / 2 + S_min(elt, particle_symmetry, spin_symmetry) + ) / 2 end const Sˣ = S_x @@ -297,14 +315,18 @@ const Sˣ = S_x Return the one-body spin-1/2 y-operator on the electrons (only defined for `Trivial` symmetry). """ S_y -function S_y(P::Type{<:Sector}=Trivial, S::Type{<:Sector}=Trivial) +function S_y(P::Type{<:Sector} = Trivial, S::Type{<:Sector} = Trivial) return S_y(ComplexF64, P, S) end -function S_y(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) - return (S_plus(elt, particle_symmetry, spin_symmetry) +function S_y( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) + return ( + S_plus(elt, particle_symmetry, spin_symmetry) - - S_min(elt, particle_symmetry, spin_symmetry)) / (2im) + S_min(elt, particle_symmetry, spin_symmetry) + ) / (2im) end const Sʸ = S_y @@ -314,20 +336,26 @@ const Sʸ = S_y Return the one-body spin-1/2 z-operator on the electrons. """ S_z -function S_z(P::Type{<:Sector}=Trivial, S::Type{<:Sector}=Trivial) +function S_z(P::Type{<:Sector} = Trivial, S::Type{<:Sector} = Trivial) return S_z(ComplexF64, P, S) end -function S_z(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) - return (u_num(elt, particle_symmetry, spin_symmetry) - - d_num(elt, particle_symmetry, spin_symmetry)) / 2 +function S_z( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) + return ( + u_num(elt, particle_symmetry, spin_symmetry) - + d_num(elt, particle_symmetry, spin_symmetry) + ) / 2 end const Sᶻ = S_z # Two site operators # ------------------ -function two_site_operator(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function two_site_operator( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) V = hubbard_space(particle_symmetry, spin_symmetry) return zeros(elt, V ⊗ V ← V ⊗ V) end @@ -459,8 +487,10 @@ const d⁺d⁻ = d_plus_d_min Return the two-body operator ``e_{1,↑}, e†_{2,↑}`` that annihilates a spin-up particle at the first site and creates a spin-up particle at the second. """ u_min_u_plus u_min_u_plus(P::Type{<:Sector}, S::Type{<:Sector}) = u_min_u_plus(ComplexF64, P, S) -function u_min_u_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function u_min_u_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return -copy(adjoint(u_plus_u_min(elt, particle_symmetry, spin_symmetry))) end const u⁻u⁺ = u_min_u_plus @@ -472,8 +502,10 @@ const u⁻u⁺ = u_min_u_plus Return the two-body operator ``e_{1,↓}, e†_{2,↓}`` that annihilates a spin-down particle at the first site and creates a spin-down particle at the second. """ d_min_d_plus d_min_d_plus(P::Type{<:Sector}, S::Type{<:Sector}) = d_min_d_plus(ComplexF64, P, S) -function d_min_d_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function d_min_d_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return -copy(adjoint(d_plus_d_min(elt, particle_symmetry, spin_symmetry))) end const d⁻d⁺ = d_min_d_plus @@ -486,10 +518,12 @@ Return the two-body operator that creates a particle at the first site and annih This is the sum of `u_plus_u_min` and `d_plus_d_min`. """ e_plus_e_min e_plus_e_min(P::Type{<:Sector}, S::Type{<:Sector}) = e_plus_e_min(ComplexF64, P, S) -function e_plus_e_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function e_plus_e_min( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return u_plus_u_min(elt, particle_symmetry, spin_symmetry) + - d_plus_d_min(elt, particle_symmetry, spin_symmetry) + d_plus_d_min(elt, particle_symmetry, spin_symmetry) end function e_plus_e_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}) t = two_site_operator(elt, Trivial, SU2Irrep) @@ -535,8 +569,10 @@ Return the two-body operator that annihilates a particle at the first site and c This is the sum of `u_min_u_plus` and `d_min_d_plus`. """ e_min_e_plus e_min_e_plus(P::Type{<:Sector}, S::Type{<:Sector}) = e_min_e_plus(ComplexF64, P, S) -function e_min_e_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function e_min_e_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return -copy(adjoint(e_plus_e_min(elt, particle_symmetry, spin_symmetry))) end const e⁻e⁺ = e_min_e_plus @@ -548,10 +584,12 @@ const e⁻e⁺ = e_min_e_plus Return the two-body operator that describes a particle that hops between the first and the second site. """ e_hop e_hopping(P::Type{<:Sector}, S::Type{<:Sector}) = e_hopping(ComplexF64, P, S) -function e_hopping(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function e_hopping( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return e_plus_e_min(elt, particle_symmetry, spin_symmetry) - - e_min_e_plus(elt, particle_symmetry, spin_symmetry) + e_min_e_plus(elt, particle_symmetry, spin_symmetry) end const e_hop = e_hopping @@ -607,8 +645,10 @@ Return the two-body operator ``e†_{1,↑} e†_{2,↓}`` that annihilates a sp function u_plus_d_plus(P::Type{<:Sector}, S::Type{<:Sector}) return u_plus_d_plus(ComplexF64, P, S) end -function u_plus_d_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function u_plus_d_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return -copy(adjoint(u_min_d_min(elt, particle_symmetry, spin_symmetry))) end const u⁺d⁺ = u_plus_d_plus @@ -665,8 +705,10 @@ Return the two-body operator ``e†_{1,↓} e†_{2,↑}`` that creates a spin-d function d_plus_u_plus(P::Type{<:Sector}, S::Type{<:Sector}) return d_plus_u_plus(ComplexF64, P, S) end -function d_plus_u_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function d_plus_u_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return -copy(adjoint(d_min_u_min(elt, particle_symmetry, spin_symmetry))) end const d⁺u⁺ = d_plus_u_plus @@ -720,8 +762,10 @@ Return the two-body operator ``e†_{1,↑} e†_{2,↑}`` that creates a spin-u function u_plus_u_plus(P::Type{<:Sector}, S::Type{<:Sector}) return u_plus_u_plus(ComplexF64, P, S) end -function u_plus_u_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function u_plus_u_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return -copy(adjoint(u_min_u_min(elt, particle_symmetry, spin_symmetry))) end const u⁺u⁺ = u_plus_u_plus @@ -776,8 +820,10 @@ The nonzero matrix elements are function d_plus_d_plus(P::Type{<:Sector}, S::Type{<:Sector}) return d_plus_d_plus(ComplexF64, P, S) end -function d_plus_d_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function d_plus_d_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return -copy(adjoint(d_min_d_min(elt, particle_symmetry, spin_symmetry))) end const d⁺d⁺ = d_plus_d_plus @@ -792,10 +838,14 @@ which creates the singlet state when acting on vaccum. function singlet_plus(P::Type{<:Sector}, S::Type{<:Sector}) return singlet_plus(ComplexF64, P, S) end -function singlet_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) - return (u_plus_d_plus(elt, particle_symmetry, spin_symmetry) - - d_plus_u_plus(elt, particle_symmetry, spin_symmetry)) / sqrt(2) +function singlet_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) + return ( + u_plus_d_plus(elt, particle_symmetry, spin_symmetry) - + d_plus_u_plus(elt, particle_symmetry, spin_symmetry) + ) / sqrt(2) end const singlet⁺ = singlet_plus @@ -809,8 +859,10 @@ Return the adjoint of `singlet_plus` operator, which is function singlet_min(P::Type{<:Sector}, S::Type{<:Sector}) return singlet_min(ComplexF64, P, S) end -function singlet_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function singlet_min( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return copy(adjoint(singlet_plus(elt, particle_symmetry, spin_symmetry))) end const singlet⁻ = singlet_min @@ -861,8 +913,10 @@ The only nonzero matrix element corresponds to `|↓,↑⟩ <-- |↑,↓⟩`. function S_min_S_plus(P::Type{<:Sector}, S::Type{<:Sector}) return S_min_S_plus(ComplexF64, P, S) end -function S_min_S_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function S_min_S_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) return copy(adjoint(S_plus_S_min(elt, particle_symmetry, spin_symmetry))) end const S⁻S⁺ = S_min_S_plus @@ -875,13 +929,17 @@ Return the spin exchange operator S⋅S. function S_exchange(P::Type{<:Sector}, S::Type{<:Sector}) return S_exchange(ComplexF64, P, S) end -function S_exchange(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}) +function S_exchange( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector} + ) Sz = S_z(elt, particle_symmetry, spin_symmetry) - return (S_plus_S_min(elt, particle_symmetry, spin_symmetry) + return ( + S_plus_S_min(elt, particle_symmetry, spin_symmetry) + - S_min_S_plus(elt, particle_symmetry, spin_symmetry)) / 2 + - Sz ⊗ Sz + S_min_S_plus(elt, particle_symmetry, spin_symmetry) + ) / 2 + + Sz ⊗ Sz end function S_exchange(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}) t = two_site_operator(elt, Trivial, SU2Irrep) diff --git a/src/spinoperators.jl b/src/spinoperators.jl index f020367..787c36f 100644 --- a/src/spinoperators.jl +++ b/src/spinoperators.jl @@ -16,13 +16,13 @@ export SˣSˣ, SʸSʸ, SᶻSᶻ, S⁺S⁻, S⁻S⁺, SS The local Hilbert space for a spin system with a given symmetry and spin. Available symmetries are `Trivial`, `Z2Irrep`, `U1Irrep` and `SU2Irrep`. """ -spin_space(::Type{Trivial}=Trivial; spin=1 // 2) = ComplexSpace(Int(2 * spin + 1)) -function spin_space(::Type{Z2Irrep}; spin=1 // 2) +spin_space(::Type{Trivial} = Trivial; spin = 1 // 2) = ComplexSpace(Int(2 * spin + 1)) +function spin_space(::Type{Z2Irrep}; spin = 1 // 2) spin == 1 // 2 || throw(ArgumentError("Z2 symmetry only implemented for spin 1//2")) return Z2Space(0 => 1, 1 => 1) end -spin_space(::Type{U1Irrep}; spin=1 // 2) = U1Space(i => 1 for i in (-spin):spin) -spin_space(::Type{SU2Irrep}; spin=1 // 2) = SU2Space(spin => 1) +spin_space(::Type{U1Irrep}; spin = 1 // 2) = U1Space(i => 1 for i in (-spin):spin) +spin_space(::Type{SU2Irrep}; spin = 1 // 2) = SU2Space(spin => 1) # Pauli matrices # -------------- @@ -34,8 +34,10 @@ end function _pauliterm(spin, i::U1Irrep, j::U1Irrep) -spin <= i.charge <= spin || return 0.0 -spin <= j.charge <= spin || return 0.0 - return sqrt((spin + 1) * (i.charge + j.charge + 2 * spin + 1) - - (i.charge + spin + 1) * (j.charge + spin + 1)) / 2.0 + return sqrt( + (spin + 1) * (i.charge + j.charge + 2 * spin + 1) - + (i.charge + spin + 1) * (j.charge + spin + 1) + ) / 2.0 end """ @@ -52,7 +54,7 @@ casimir(c::SU2Irrep) = casimir(c.j) The spinmatrices according to [Wikipedia](https://en.wikipedia.org/wiki/Spin_(physics)#Higher_spins). """ -function spinmatrices(spin::Union{Rational{Int},Int}, elt=ComplexF64) +function spinmatrices(spin::Union{Rational{Int}, Int}, elt = ComplexF64) N = Int(2 * spin) Sx = zeros(elt, N + 1, N + 1) @@ -93,7 +95,7 @@ See also [`σˣ`](@ref) S_x(; kwargs...) = S_x(ComplexF64, Trivial; kwargs...) S_x(elt::Type{<:Number}; kwargs...) = S_x(elt, Trivial; kwargs...) S_x(symm::Type{<:Sector}; kwargs...) = S_x(ComplexF64, symm; kwargs...) -function S_x(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_x(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) pspace = spin_space(symmetry; spin) if symmetry === Trivial S_x_mat, = spinmatrices(spin, elt) @@ -123,7 +125,7 @@ See also [`σʸ`](@ref) S_y(; kwargs...) = S_y(ComplexF64, Trivial; kwargs...) S_y(elt::Type{<:Complex}; kwargs...) = S_y(elt, Trivial; kwargs...) S_y(symm::Type{<:Sector}; kwargs...) = S_y(ComplexF64, symm; kwargs...) -function S_y(elt::Type{<:Complex}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_y(elt::Type{<:Complex}, symmetry::Type{<:Sector}; spin = 1 // 2) pspace = spin_space(symmetry; spin) if symmetry === Trivial _, S_y_mat, _ = spinmatrices(spin, elt) @@ -148,7 +150,7 @@ See also [`σᶻ`](@ref) S_z(; kwargs...) = S_z(ComplexF64, Trivial; kwargs...) S_z(elt::Type{<:Number}; kwargs...) = S_z(elt, Trivial; kwargs...) S_z(symm::Type{<:Sector}; kwargs...) = S_z(ComplexF64, symm; kwargs...) -function S_z(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_z(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) pspace = spin_space(symmetry; spin) if symmetry === Trivial _, _, S_z_mat = spinmatrices(spin, elt) @@ -178,7 +180,7 @@ See also [`σ⁺`](@ref) S_plus(; kwargs...) = S_plus(ComplexF64, Trivial; kwargs...) S_plus(elt::Type{<:Number}; kwargs...) = S_plus(elt, Trivial; kwargs...) S_plus(symm::Type{<:Sector}; kwargs...) = S_plus(ComplexF64, symm; kwargs...) -function S_plus(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_plus(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) if symmetry === Trivial S⁺ = S_x(elt, Trivial; spin) + 1im * S_y(complex(elt), Trivial; spin) if elt <: Real @@ -204,7 +206,7 @@ See also [`σ⁻`](@ref) S_min(; kwargs...) = S_min(ComplexF64, Trivial; kwargs...) S_min(elt::Type{<:Number}; kwargs...) = S_min(elt, Trivial; kwargs...) S_min(symm::Type{<:Sector}; kwargs...) = S_min(ComplexF64, symm; kwargs...) -function S_min(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_min(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) if symmetry === Trivial S⁻ = S_x(elt, Trivial; spin) - 1im * S_y(complex(elt), Trivial; spin) if elt <: Real @@ -231,7 +233,7 @@ The spin x exchange operator. S_x_S_x(; kwargs...) = S_x_S_x(ComplexF64, Trivial; kwargs...) S_x_S_x(elt::Type{<:Number}; kwargs...) = S_x_S_x(elt, Trivial; kwargs...) S_x_S_x(symm::Type{<:Sector}; kwargs...) = S_x_S_x(ComplexF64, symm; kwargs...) -function S_x_S_x(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_x_S_x(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) if symmetry === Trivial || symmetry === Z2Irrep XX = S_x(elt, symmetry; spin) ⊗ S_x(elt, symmetry; spin) else @@ -250,7 +252,7 @@ The spin y exchange operator. S_y_S_y(; kwargs...) = S_y_S_y(ComplexF64, Trivial; kwargs...) S_y_S_y(elt::Type{<:Complex}; kwargs...) = S_y_S_y(elt, Trivial; kwargs...) S_y_S_y(symm::Type{<:Sector}; kwargs...) = S_y_S_y(ComplexF64, symm; kwargs...) -function S_y_S_y(elt::Type{<:Complex}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_y_S_y(elt::Type{<:Complex}, symmetry::Type{<:Sector}; spin = 1 // 2) if symmetry === Trivial YY = S_y(elt, Trivial; spin) ⊗ S_y(elt, Trivial; spin) else @@ -269,7 +271,7 @@ The spin z exchange operator. S_z_S_z(; kwargs...) = S_z_S_z(ComplexF64, Trivial; kwargs...) S_z_S_z(elt::Type{<:Number}; kwargs...) = S_z_S_z(elt, Trivial; kwargs...) S_z_S_z(symm::Type{<:Sector}; kwargs...) = S_z_S_z(ComplexF64, symm; kwargs...) -function S_z_S_z(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_z_S_z(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) if symmetry === Trivial || symmetry === U1Irrep ZZ = S_z(elt, symmetry; spin) ⊗ S_z(elt, symmetry; spin) elseif symmetry === Z2Irrep @@ -296,7 +298,7 @@ The spin raising-lowering operator. S_plus_S_min(; kwargs...) = S_plus_S_min(ComplexF64, Trivial; kwargs...) S_plus_S_min(elt::Type{<:Number}; kwargs...) = S_plus_S_min(elt, Trivial; kwargs...) S_plus_S_min(symm::Type{<:Sector}; kwargs...) = S_plus_S_min(ComplexF64, symm; kwargs...) -function S_plus_S_min(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_plus_S_min(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) if symmetry === Trivial S⁺S⁻ = S_plus(elt, symmetry; spin) ⊗ S_min(elt, symmetry; spin) elseif symmetry === U1Irrep @@ -304,10 +306,10 @@ function S_plus_S_min(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2 S⁺S⁻ = zeros(elt, pspace ⊗ pspace ← pspace ⊗ pspace) for (f₁, f₂) in fusiontrees(S⁺S⁻) if f₁.uncoupled[1].charge == f₂.uncoupled[1].charge + 1 && - f₁.uncoupled[2].charge == f₂.uncoupled[2].charge - 1 + f₁.uncoupled[2].charge == f₂.uncoupled[2].charge - 1 m₁, m₂ = getproperty.(f₂.uncoupled, :charge) S⁺S⁻[f₁, f₂] .= sqrt(casimir(spin) - m₁ * (m₁ + 1)) * - sqrt(casimir(spin) - m₂ * (m₂ - 1)) + sqrt(casimir(spin) - m₂ * (m₂ - 1)) end end else @@ -326,7 +328,7 @@ The spin lowering-raising operator. S_min_S_plus(; kwargs...) = S_min_S_plus(ComplexF64, Trivial; kwargs...) S_min_S_plus(elt::Type{<:Number}; kwargs...) = S_min_S_plus(elt, Trivial; kwargs...) S_min_S_plus(symm::Type{<:Sector}; kwargs...) = S_min_S_plus(ComplexF64, symm; kwargs...) -function S_min_S_plus(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_min_S_plus(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) if symmetry === Trivial S⁻S⁺ = S_min(elt, symmetry; spin) ⊗ S_plus(elt, symmetry; spin) elseif symmetry === U1Irrep @@ -334,10 +336,10 @@ function S_min_S_plus(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2 S⁻S⁺ = zeros(elt, pspace ⊗ pspace ← pspace ⊗ pspace) for (f₁, f₂) in fusiontrees(S⁻S⁺) if f₁.uncoupled[1].charge == f₂.uncoupled[1].charge - 1 && - f₁.uncoupled[2].charge == f₂.uncoupled[2].charge + 1 + f₁.uncoupled[2].charge == f₂.uncoupled[2].charge + 1 m₁, m₂ = getproperty.(f₂.uncoupled, :charge) S⁻S⁺[f₁, f₂] .= sqrt(casimir(spin) - m₁ * (m₁ - 1)) * - sqrt(casimir(spin) - m₂ * (m₂ + 1)) + sqrt(casimir(spin) - m₂ * (m₂ + 1)) end end else @@ -358,10 +360,10 @@ S_exchange(elt::Type{<:Number}; kwargs...) = S_exchange(elt, Trivial; kwargs...) function S_exchange(symmetry::Type{<:Sector}; kwargs...) return S_exchange(ComplexF64, symmetry; kwargs...) end -function S_exchange(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin=1 // 2) +function S_exchange(elt::Type{<:Number}, symmetry::Type{<:Sector}; spin = 1 // 2) if symmetry === Trivial || symmetry === U1Irrep SS = (S_plus_S_min(elt, symmetry; spin) + S_min_S_plus(elt, symmetry; spin)) / 2 + - S_z_S_z(elt, symmetry; spin) + S_z_S_z(elt, symmetry; spin) elseif symmetry === SU2Irrep pspace = spin_space(SU2Irrep; spin) SS = zeros(elt, pspace ⊗ pspace ← pspace ⊗ pspace) diff --git a/src/tjoperators.jl b/src/tjoperators.jl index 491025c..e5c15e0 100644 --- a/src/tjoperators.jl +++ b/src/tjoperators.jl @@ -39,39 +39,45 @@ Setting `slave_fermion = true` switches to the slave-fermion basis. - basis states for `slave_fermion = true`: (c_σ = h† b_σ; holon h is fermionic, spinon b_σ is bosonic): |0⟩ = h†|vac⟩, |↑⟩ = (b↑)†|vac⟩, |↓⟩ = (b↓)†|vac⟩ """ -function tj_space(::Type{Trivial}=Trivial, ::Type{Trivial}=Trivial; - slave_fermion::Bool=false) +function tj_space( + ::Type{Trivial} = Trivial, ::Type{Trivial} = Trivial; + slave_fermion::Bool = false + ) return slave_fermion ? Vect[FermionParity](0 => 2, 1 => 1) : - Vect[FermionParity](0 => 1, 1 => 2) + Vect[FermionParity](0 => 1, 1 => 2) end -function tj_space(::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool=false) +function tj_space(::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool = false) return if slave_fermion Vect[FermionParity ⊠ U1Irrep]((1, 0) => 1, (0, 1 // 2) => 1, (0, -1 // 2) => 1) else Vect[FermionParity ⊠ U1Irrep]((0, 0) => 1, (1, 1 // 2) => 1, (1, -1 // 2) => 1) end end -function tj_space(::Type{Trivial}, ::Type{SU2Irrep}; slave_fermion::Bool=false) +function tj_space(::Type{Trivial}, ::Type{SU2Irrep}; slave_fermion::Bool = false) return slave_fermion ? Vect[FermionParity ⊠ SU2Irrep]((1, 0) => 1, (0, 1 // 2) => 1) : - Vect[FermionParity ⊠ SU2Irrep]((0, 0) => 1, (1, 1 // 2) => 1) + Vect[FermionParity ⊠ SU2Irrep]((0, 0) => 1, (1, 1 // 2) => 1) end -function tj_space(::Type{U1Irrep}, ::Type{Trivial}; slave_fermion::Bool=false) +function tj_space(::Type{U1Irrep}, ::Type{Trivial}; slave_fermion::Bool = false) return if slave_fermion Vect[FermionParity ⊠ U1Irrep]((1, 0) => 1, (0, 1) => 2) else Vect[FermionParity ⊠ U1Irrep]((0, 0) => 1, (1, 1) => 2) end end -function tj_space(::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool=false) +function tj_space(::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false) return if slave_fermion - Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]((1, 0, 0) => 1, (0, 1, 1 // 2) => 1, - (0, 1, -1 // 2) => 1) + Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]( + (1, 0, 0) => 1, (0, 1, 1 // 2) => 1, + (0, 1, -1 // 2) => 1 + ) else - Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]((0, 0, 0) => 1, (1, 1, 1 // 2) => 1, - (1, 1, -1 // 2) => 1) + Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]( + (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, + (1, 1, -1 // 2) => 1 + ) end end -function tj_space(::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool=false) +function tj_space(::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false) return if slave_fermion Vect[FermionParity ⊠ U1Irrep ⊠ SU2Irrep]((1, 0, 0) => 1, (0, 1, 1 // 2) => 1) else @@ -81,8 +87,10 @@ end # Single-site operators # --------------------- -function single_site_operator(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false) +function single_site_operator( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false + ) V = tj_space(particle_symmetry, spin_symmetry; slave_fermion) return zeros(elt, V ← V) end @@ -93,47 +101,59 @@ end Return the one-body operator that counts the number of spin-up electrons. """ u_num -function u_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function u_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return u_num(ComplexF64, P, S; slave_fermion) end -function u_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function u_num( + 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] = 1 return t end -function u_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function u_num( + 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)))][1, 1] = 1 return t end -function u_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function u_num( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_num` is not symmetric under `SU2Irrep` spin symmetry")) end -function u_num(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool=false) +function u_num( + 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, 1] = 1 return t end -function u_num(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function u_num( + 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)))] .= 1 return t end -function u_num(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function u_num( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_num` is not symmetric under `SU2Irrep` spin symmetry")) end const nꜛ = u_num @@ -144,47 +164,59 @@ const nꜛ = u_num Return the one-body operator that counts the number of spin-down electrons. """ d_num -function d_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function d_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return d_num(ComplexF64, P, S; slave_fermion) end -function d_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function d_num( + 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)))][2, 2] = 1 return t end -function d_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function d_num( + 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)))][1, 1] = 1 return t end -function d_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function d_num( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_num` is not symmetric under `SU2Irrep` spin symmetry")) end -function d_num(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool=false) +function d_num( + 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)))][2, 2] = 1 return t end -function d_num(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function d_num( + 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)))] .= 1 return t end -function d_num(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function d_num( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_num` is not symmetric under `SU2Irrep` spin symmetry")) end const nꜜ = d_num @@ -195,17 +227,21 @@ const nꜜ = d_num Return the one-body operator that counts the number of particles. """ e_num -function e_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function e_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return e_num(ComplexF64, P, S; slave_fermion) end -function e_num(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function e_num( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return u_num(elt, particle_symmetry, spin_symmetry; slave_fermion) + - d_num(elt, particle_symmetry, spin_symmetry; slave_fermion) + d_num(elt, particle_symmetry, spin_symmetry; slave_fermion) end -function e_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function e_num( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) t = single_site_operator(elt, Trivial, SU2Irrep; slave_fermion) I = sectortype(t) if slave_fermion @@ -215,8 +251,10 @@ function e_num(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; end return t end -function e_num(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function e_num( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) t = single_site_operator(elt, U1Irrep, SU2Irrep; slave_fermion) I = sectortype(t) if slave_fermion @@ -234,12 +272,14 @@ const n = e_num Return the one-body operator that counts the number of holes. """ h_num -function h_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function h_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return h_num(ComplexF64, P, S; slave_fermion) end -function h_num(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function h_num( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) iden = TensorKit.id(tj_space(particle_symmetry, spin_symmetry; slave_fermion)) return iden - e_num(elt, particle_symmetry, spin_symmetry; slave_fermion) end @@ -251,31 +291,39 @@ const nʰ = h_num 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) +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}, ::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] = 1.0 return t end -function S_plus(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] = 1.0 return t end -function S_plus(elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function S_plus( + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`S_plus`, `S_min` are not symmetric under `U1Irrep` spin symmetry")) end -function S_plus(elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function S_plus( + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`S_plus`, `S_min` are not symmetric under `SU2Irrep` spin symmetry")) end const S⁺ = S_plus @@ -286,12 +334,14 @@ const S⁺ = S_plus 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) +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) +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 @@ -302,16 +352,22 @@ const S⁻ = S_min 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) +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) +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 + S_min(elt, particle_symmetry, spin_symmetry; slave_fermion) + ) / 2 end const Sˣ = S_x @@ -321,16 +377,22 @@ const Sˣ = S_x 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) +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}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) - return (S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) +function S_y( + 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)) / (2im) + S_min(elt, particle_symmetry, spin_symmetry; slave_fermion) + ) / (2im) end const Sʸ = S_y @@ -340,22 +402,30 @@ const Sʸ = S_y Return the one-body spin-1/2 z-operator on the electrons. """ S_z -function S_z(P::Type{<:Sector}=Trivial, S::Type{<:Sector}=Trivial; - slave_fermion::Bool=false) +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}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) - return (u_num(elt, particle_symmetry, spin_symmetry; slave_fermion) - - d_num(elt, particle_symmetry, spin_symmetry; slave_fermion)) / 2 +function S_z( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) + 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 # Two site operators # ------------------ -function two_site_operator(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false) +function two_site_operator( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false + ) V = tj_space(particle_symmetry, spin_symmetry; slave_fermion) return zeros(elt, V ⊗ V ← V ⊗ V) end @@ -367,11 +437,13 @@ end Return the two-body operator ``e†_{1,↑}, e_{2,↑}`` that creates a spin-up electron at the first site and annihilates a spin-up electron at the second. The only nonzero matrix element corresponds to `|↑0⟩ <-- |0↑⟩`. """ u_plus_u_min -function u_plus_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function u_plus_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return u_plus_u_min(ComplexF64, P, S; slave_fermion) end -function u_plus_u_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function u_plus_u_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) @@ -385,36 +457,46 @@ function u_plus_u_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; t[(I(b), I(h), dual(I(h)), dual(I(b)))][1, 1, 1, 1] = sgn * 1 return t end -function u_plus_u_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function u_plus_u_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(b, 1 // 2), I(h, 0), dual(I(h, 0)), dual(I(b, 1 // 2)))] .= sgn * 1 return t end -function u_plus_u_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function u_plus_u_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_plus_u_min` is not symmetric under `SU2Irrep` spin symmetry")) end -function u_plus_u_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool=false) +function u_plus_u_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(b, 1), I(h, 0), dual(I(h, 0)), dual(I(b, 1)))][1, 1, 1, 1] = sgn * 1 return t end -function u_plus_u_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function u_plus_u_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, U1Irrep, U1Irrep; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(b, 1, 1 // 2), I(h, 0, 0), dual(I(h, 0, 0)), dual(I(b, 1, 1 // 2)))] .= sgn * 1 return t end -function u_plus_u_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function u_plus_u_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_plus_u_min` is not symmetric under `SU2Irrep` spin symmetry")) end const u⁺u⁻ = u_plus_u_min @@ -426,47 +508,59 @@ const u⁺u⁻ = u_plus_u_min Return the two-body operator ``e†_{1,↓}, e_{2,↓}`` that creates a spin-down electron at the first site and annihilates a spin-down electron at the second. The only nonzero matrix element corresponds to `|↓0⟩ <-- |0↓⟩`. """ d_plus_d_min -function d_plus_d_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function d_plus_d_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return d_plus_d_min(ComplexF64, P, S; slave_fermion) end -function d_plus_d_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function d_plus_d_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(b), I(h), dual(I(h)), dual(I(b)))][2, 1, 1, 2] = sgn * 1 return t end -function d_plus_d_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function d_plus_d_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt::Type{<:Number}, Trivial, U1Irrep; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(b, -1 // 2), I(h, 0), dual(I(h, 0)), dual(I(b, -1 // 2)))] .= sgn * 1 return t end -function d_plus_d_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function d_plus_d_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_plus_d_min` is not symmetric under `SU2Irrep` spin symmetry")) end -function d_plus_d_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool=false) +function d_plus_d_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(b, 1), I(h, 0), dual(I(h, 0)), dual(I(b, 1)))][2, 1, 1, 2] = sgn * 1 return t end -function d_plus_d_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function d_plus_d_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, U1Irrep, U1Irrep; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(b, 1, -1 // 2), I(h, 0, 0), dual(I(h, 0, 0)), dual(I(b, 1, -1 // 2)))] .= sgn * 1 return t end -function d_plus_d_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function d_plus_d_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_plus_d_min` is not symmetric under `SU2Irrep` spin symmetry")) end const d⁺d⁻ = d_plus_d_min @@ -478,12 +572,14 @@ const d⁺d⁻ = d_plus_d_min 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) +function u_min_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return u_min_u_plus(ComplexF64, P, S; slave_fermion) end -function u_min_u_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function u_min_u_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return -copy(adjoint(u_plus_u_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const u⁻u⁺ = u_min_u_plus @@ -495,12 +591,14 @@ const u⁻u⁺ = u_min_u_plus 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) +function d_min_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return d_min_d_plus(ComplexF64, P, S; slave_fermion) end -function d_min_d_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function d_min_d_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return -copy(adjoint(d_plus_d_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const d⁻d⁺ = d_min_d_plus @@ -512,35 +610,45 @@ const d⁻d⁺ = d_min_d_plus Return the two-body operator ``e_{1,↑} e_{2,↓}`` that annihilates a spin-up particle at the first site and a spin-down particle at the second site. The only nonzero matrix element corresponds to `|0,0⟩ <-- |↑,↓⟩`. """ u_min_d_min -function u_min_d_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function u_min_d_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return u_min_d_min(ComplexF64, P, S; slave_fermion) end -function u_min_d_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function u_min_d_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(h), I(h), dual(I(b)), dual(I(b)))][1, 1, 1, 2] = -sgn * 1 return t end -function u_min_d_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function u_min_d_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(h, 0), I(h, 0), dual(I(b, 1 // 2)), dual(I(b, -1 // 2)))] .= -sgn * 1 return t end -function u_min_d_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; - slave_fermion::Bool=false) +function u_min_d_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_min_d_min` is not symmetric under `U1Irrep` particle symmetry")) end -function u_min_d_min(elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function u_min_d_min( + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_min_d_min` is not symmetric under `SU2Irrep` spin symmetry")) end -function u_min_d_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function u_min_d_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_min_d_min` is not symmetric under `U1Irrep` particle symmetry or under `SU2Irrep` spin symmetry")) end const u⁻d⁻ = u_min_d_min @@ -551,12 +659,14 @@ const u⁻d⁻ = u_min_d_min Return the two-body operator ``e†_{1,↑} e†_{2,↓}`` that annihilates a spin-up particle at the first site and a spin-down particle at the second site. """ u_plus_d_plus -function u_plus_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function u_plus_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return u_plus_d_plus(ComplexF64, P, S; slave_fermion) end -function u_plus_d_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function u_plus_d_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return -copy(adjoint(u_min_d_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const u⁺d⁺ = u_plus_d_plus @@ -568,35 +678,45 @@ const u⁺d⁺ = u_plus_d_plus Return the two-body operator ``e_{1,↓} e_{2,↑}`` that annihilates a spin-down particle at the first site and a spin-up particle at the second site. The only nonzero matrix element corresponds to `|0,0⟩ <-- |↓,↑⟩`. """ d_min_u_min -function d_min_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function d_min_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return d_min_u_min(ComplexF64, P, S; slave_fermion) end -function d_min_u_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function d_min_u_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(h), I(h), dual(I(b)), dual(I(b)))][1, 1, 2, 1] = -sgn * 1 return t end -function d_min_u_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function d_min_u_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(h, 0), I(h, 0), dual(I(b, -1 // 2)), dual(I(b, 1 // 2)))] .= -sgn * 1 return t end -function d_min_u_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; - slave_fermion::Bool=false) +function d_min_u_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_min_u_min` is not symmetric under `U1Irrep` particle symmetry")) end -function d_min_u_min(elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function d_min_u_min( + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_min_u_min` is not symmetric under `SU2Irrep` spin symmetry")) end -function d_min_u_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function d_min_u_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_min_u_min` is not symmetric under `U1Irrep` particle symmetry or under `SU2Irrep` particle symmetry")) end const d⁻u⁻ = d_min_u_min @@ -607,12 +727,14 @@ const d⁻u⁻ = d_min_u_min Return the two-body operator ``e†_{1,↓} e†_{2,↑}`` that annihilates a spin-down particle at the first site and a spin-up particle at the second site. """ d_plus_u_plus -function d_plus_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function d_plus_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return d_plus_u_plus(ComplexF64, P, S; slave_fermion) end -function d_plus_u_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function d_plus_u_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return -copy(adjoint(d_min_u_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const d⁺u⁺ = d_plus_u_plus @@ -624,35 +746,47 @@ const d⁺u⁺ = d_plus_u_plus Return the two-body operator ``e_{1,↑} e_{2,↑}`` that annihilates a spin-up particle at both sites. The only nonzero matrix element corresponds to `|0,0⟩ <-- |↑,↑⟩`. """ u_min_u_min -function u_min_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function u_min_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return u_min_u_min(ComplexF64, P, S; slave_fermion) end -function u_min_u_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function u_min_u_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(h), I(h), dual(I(b)), dual(I(b)))][1, 1, 1, 1] = -sgn * 1 return t end -function u_min_u_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; - slave_fermion::Bool=false) +function u_min_u_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_min_u_min` is not symmetric under `U1Irrep` particle symmetry")) end -function u_min_u_min(elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function u_min_u_min( + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_min_u_min` is not symmetric under `U1Irrep` spin symmetry")) end -function u_min_u_min(elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function u_min_u_min( + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_min_u_min` is not symmetric under `SU2Irrep` spin symmetry")) end -function u_min_u_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function u_min_u_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_min_u_min` is not symmetric under `U1Irrep` particle symmetry or under `U1Irrep` particle symmetry")) end -function u_min_u_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function u_min_u_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`u_min_u_min` is not symmetric under `U1Irrep` particle symmetry or under `SU2Irrep` particle symmetry")) end const u⁻u⁻ = u_min_u_min @@ -663,12 +797,14 @@ const u⁻u⁻ = u_min_u_min Return the two-body operator ``e†_{1,↑} e†_{2,↑}`` that annihilates a spin-up particle at both sites. """ u_plus_u_plus -function u_plus_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function u_plus_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return u_plus_u_plus(ComplexF64, P, S; slave_fermion) end -function u_plus_u_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function u_plus_u_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return -copy(adjoint(u_min_u_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const u⁺u⁺ = u_plus_u_plus @@ -680,35 +816,47 @@ const u⁺u⁺ = u_plus_u_plus Return the two-body operator ``e_{1,↓} e_{2,↓}`` that annihilates a spin-down particle at both sites. The only nonzero matrix element corresponds to `|0,0⟩ <-- |↓,↓⟩`. """ d_min_d_min -function d_min_d_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function d_min_d_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return d_min_d_min(ComplexF64, P, S; slave_fermion) end -function d_min_d_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function d_min_d_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) (h, b, sgn) = slave_fermion ? (1, 0, -1) : (0, 1, 1) t[(I(h), I(h), dual(I(b)), dual(I(b)))][1, 1, 2, 2] = -sgn * 1 return t end -function d_min_d_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; - slave_fermion::Bool=false) +function d_min_d_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_min_d_min` is not symmetric under `U1Irrep` particle symmetry")) end -function d_min_d_min(elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function d_min_d_min( + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_min_d_min` is not symmetric under `U1Irrep` spin symmetry")) end -function d_min_d_min(elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function d_min_d_min( + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_min_d_min` is not symmetric under `SU2Irrep` spin symmetry")) end -function d_min_d_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function d_min_d_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_min_d_min` is not symmetric under `U1Irrep` particle symmetry or under `U1Irrep` particle symmetry")) end -function d_min_d_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function d_min_d_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) throw(ArgumentError("`d_min_d_min` is not symmetric under `U1Irrep` particle symmetry or under `SU2Irrep` particle symmetry")) end const d⁻d⁻ = d_min_d_min @@ -719,12 +867,14 @@ const d⁻d⁻ = d_min_d_min Return the two-body operator ``e†_{1,↓} e†_{2,↓}`` that annihilates a spin-down particle at both sites. """ d_plus_d_plus -function d_plus_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function d_plus_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return d_plus_d_plus(ComplexF64, P, S; slave_fermion) end -function d_plus_d_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function d_plus_d_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return -copy(adjoint(d_min_d_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const d⁺d⁺ = d_plus_d_plus @@ -736,17 +886,21 @@ const d⁺d⁺ = d_plus_d_plus Return the two-body operator that creates a particle at the first site and annihilates a particle at the second. This is the sum of `u_plus_u_min` and `d_plus_d_min`. """ e_plus_e_min -function e_plus_e_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function e_plus_e_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return e_plus_e_min(ComplexF64, P, S; slave_fermion) end -function e_plus_e_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function e_plus_e_min( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return u_plus_u_min(elt, particle_symmetry, spin_symmetry; slave_fermion) + - d_plus_d_min(elt, particle_symmetry, spin_symmetry; slave_fermion) + d_plus_d_min(elt, particle_symmetry, spin_symmetry; slave_fermion) end -function e_plus_e_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function e_plus_e_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, SU2Irrep; slave_fermion) I = sectortype(t) (h, b) = slave_fermion ? (1, 0) : (0, 1) @@ -755,8 +909,10 @@ function e_plus_e_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; t[f1, f2][1, 1, 1, 1] = 1 return t end -function e_plus_e_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +function e_plus_e_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, U1Irrep, SU2Irrep; slave_fermion) I = sectortype(t) (h, b) = slave_fermion ? (1, 0) : (0, 1) @@ -775,12 +931,14 @@ const e⁺e⁻ = e_plus_e_min Return the two-body operator that annihilates a particle at the first site and creates a particle at the second. This is the sum of `u_min_u_plus` and `d_min_d_plus`. """ e_min_e_plus -function e_min_e_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function e_min_e_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return e_min_e_plus(ComplexF64, P, S; slave_fermion) end -function e_min_e_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function e_min_e_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return -copy(adjoint(e_plus_e_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const e⁻e⁺ = e_min_e_plus @@ -792,13 +950,17 @@ const e⁻e⁺ = e_min_e_plus Return the two-body singlet operator ``(e^†_{1,↑} e^†_{2,↓} - e^†_{1,↓} e^†_{2,↑}) / sqrt(2)``, which creates the singlet state when acting on vaccum. """ singlet_plus -function singlet_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function singlet_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return singlet_plus(ComplexF64, P, S; slave_fermion) end -function singlet_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false) - return (u_plus_d_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) - - d_plus_u_plus(elt, particle_symmetry, spin_symmetry; slave_fermion)) / sqrt(2) +function singlet_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false + ) + return ( + u_plus_d_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) - + d_plus_u_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) + ) / sqrt(2) end const singlet⁺ = singlet_plus @@ -809,11 +971,13 @@ const singlet⁺ = singlet_plus Return the adjoint of `singlet_plus` operator, which is ``(-e_{1,↑} e_{2,↓} + e_{1,↓} e_{2,↑}) / sqrt(2)`` """ singlet_min -function singlet_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function singlet_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return singlet_min(ComplexF64, P, S; slave_fermion) end -function singlet_min(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; slave_fermion::Bool=false) +function singlet_min( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false + ) return copy(adjoint(singlet_plus(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const singlet⁻ = singlet_min @@ -824,14 +988,16 @@ const singlet⁻ = singlet_min Return the two-body operator that describes a particle that hops between the first and the second site. """ e_hopping -function e_hopping(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function e_hopping(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return e_hopping(ComplexF64, P, S; slave_fermion) end -function e_hopping(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function e_hopping( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return e_plus_e_min(elt, particle_symmetry, spin_symmetry; slave_fermion) - - e_min_e_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) + e_min_e_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) end const e_hop = e_hopping @@ -842,35 +1008,43 @@ const e_hop = e_hopping Return the two-body operator S⁺S⁻. The only nonzero matrix element corresponds to `|↑,↓⟩ <-- |↓,↑⟩`. """ S_plus_S_min -function S_plus_S_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function S_plus_S_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return S_plus_S_min(ComplexF64, P, S; slave_fermion) end -function S_plus_S_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool=false) +function S_plus_S_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) b = slave_fermion ? 0 : 1 t[(I(b), I(b), dual(I(b)), dual(I(b)))][1, 2, 2, 1] = 1 return t end -function S_plus_S_min(elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function S_plus_S_min( + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) b = slave_fermion ? 0 : 1 t[(I(b, 1 // 2), I(b, -1 // 2), dual(I(b, -1 // 2)), dual(I(b, 1 // 2)))] .= 1 return t end -function S_plus_S_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool=false) +function S_plus_S_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) b = slave_fermion ? 0 : 1 t[(I(b, 1), I(b, 1), dual(I(b, 1)), dual(I(b, 1)))][1, 2, 2, 1] = 1 return t end -function S_plus_S_min(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool=false) +function S_plus_S_min( + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; + slave_fermion::Bool = false + ) t = two_site_operator(elt, U1Irrep, U1Irrep; slave_fermion) I = sectortype(t) b = slave_fermion ? 0 : 1 @@ -886,12 +1060,14 @@ const S⁺S⁻ = S_plus_S_min Return the two-body operator S⁻S⁺. The only nonzero matrix element corresponds to `|↓,↑⟩ <-- |↑,↓⟩`. """ S_min_S_plus -function S_min_S_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function S_min_S_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return S_min_S_plus(ComplexF64, P, S; slave_fermion) end -function S_min_S_plus(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function S_min_S_plus( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) return copy(adjoint(S_plus_S_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) end const S⁻S⁺ = S_min_S_plus @@ -901,20 +1077,26 @@ const S⁻S⁺ = S_min_S_plus Return the spin exchange operator S⋅S. """ S_exchange -function S_exchange(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool=false) +function S_exchange(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false) return S_exchange(ComplexF64, P, S; slave_fermion) end -function S_exchange(elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; - slave_fermion::Bool=false) +function S_exchange( + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, + spin_symmetry::Type{<:Sector}; + slave_fermion::Bool = false + ) Sz = S_z(elt, particle_symmetry, spin_symmetry; slave_fermion) - return (1 / 2) * (S_plus_S_min(elt, particle_symmetry, spin_symmetry; slave_fermion) - + - S_min_S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion)) + - Sz ⊗ Sz -end -function S_exchange(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) + return (1 / 2) * ( + S_plus_S_min(elt, particle_symmetry, spin_symmetry; slave_fermion) + + + S_min_S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) + ) + + Sz ⊗ Sz +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 @@ -924,8 +1106,10 @@ function S_exchange(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; end return t end -function S_exchange(elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool=false) +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 diff --git a/test/bosonoperators.jl b/test/bosonoperators.jl index 368ddae..09ef60c 100644 --- a/test/bosonoperators.jl +++ b/test/bosonoperators.jl @@ -66,9 +66,11 @@ end b_pm, b_mp, b_n = rand(rng, 3) O_u1 = (N ⊗ id(V) + id(V) ⊗ N) * b_n + B⁻B⁺ * b_mp + B⁺B⁻ * b_pm - O_triv = (n(; cutoff) ⊗ id(boson_space(Trivial; cutoff)) + - id(boson_space(Trivial; cutoff)) ⊗ n(; cutoff)) * b_n + - b⁺b⁻(; cutoff) * b_pm + b⁻b⁺(; cutoff) * b_mp + O_triv = ( + n(; cutoff) ⊗ id(boson_space(Trivial; cutoff)) + + id(boson_space(Trivial; cutoff)) ⊗ n(; cutoff) + ) * b_n + + b⁺b⁻(; cutoff) * b_pm + b⁻b⁺(; cutoff) * b_mp test_operator(O_u1, O_triv; L) end @@ -87,8 +89,12 @@ end b_pm, b_mp, b_n = rand(rng, 3) O = (N ⊗ id(V) + id(V) ⊗ N) * b_n + B⁻B⁺ * b_mp + B⁺B⁻ * b_pm - true_eigenvals = sort([0, 2 * b_n, b_n + sqrt(b_mp * b_pm), - b_n - sqrt(b_mp * b_pm)]) + true_eigenvals = sort( + [ + 0, 2 * b_n, b_n + sqrt(b_mp * b_pm), + b_n - sqrt(b_mp * b_pm), + ] + ) eigenvals = expanded_eigenvalues(O; L) @test eigenvals ≈ true_eigenvals end diff --git a/test/hubbardoperators.jl b/test/hubbardoperators.jl index c52bf9b..8d214a5 100644 --- a/test/hubbardoperators.jl +++ b/test/hubbardoperators.jl @@ -6,12 +6,14 @@ using .TensorKitTensorsTestSetup using TensorKitTensors.HubbardOperators using StableRNGs -implemented_symmetries = [(Trivial, Trivial), (Trivial, U1Irrep), (Trivial, SU2Irrep), - (U1Irrep, Trivial), (U1Irrep, U1Irrep), (U1Irrep, SU2Irrep)] +implemented_symmetries = [ + (Trivial, Trivial), (Trivial, U1Irrep), (Trivial, SU2Irrep), + (U1Irrep, Trivial), (U1Irrep, U1Irrep), (U1Irrep, SU2Irrep), +] @testset "Compare symmetric with trivial tensors" begin for particle_symmetry in [Trivial, U1Irrep, SU2Irrep], - spin_symmetry in [Trivial, U1Irrep, SU2Irrep] + spin_symmetry in [Trivial, U1Irrep, SU2Irrep] if (particle_symmetry, spin_symmetry) in implemented_symmetries space = hubbard_space(particle_symmetry, spin_symmetry) @@ -42,7 +44,7 @@ end @testset "basic properties" begin for particle_symmetry in (Trivial, U1Irrep, SU2Irrep), - spin_symmetry in (Trivial, U1Irrep, SU2Irrep) + spin_symmetry in (Trivial, U1Irrep, SU2Irrep) space = hubbard_space(particle_symmetry, spin_symmetry) @test dim(space) == 4 @@ -69,13 +71,13 @@ end # test number operator if spin_symmetry !== SU2Irrep @test e_num(particle_symmetry, spin_symmetry) ≈ - u_num(particle_symmetry, spin_symmetry) + - d_num(particle_symmetry, spin_symmetry) + u_num(particle_symmetry, spin_symmetry) + + d_num(particle_symmetry, spin_symmetry) @test ud_num(particle_symmetry, spin_symmetry) ≈ - u_num(particle_symmetry, spin_symmetry) * - d_num(particle_symmetry, spin_symmetry) ≈ - d_num(particle_symmetry, spin_symmetry) * - u_num(particle_symmetry, spin_symmetry) + u_num(particle_symmetry, spin_symmetry) * + d_num(particle_symmetry, spin_symmetry) ≈ + d_num(particle_symmetry, spin_symmetry) * + u_num(particle_symmetry, spin_symmetry) end # test singlet operators @@ -122,9 +124,11 @@ end ε[mod1(i, 3), mod1(i + 1, 3), mod1(i + 2, 3)] = 1 ε[mod1(i, 3), mod1(i - 1, 3), mod1(i - 2, 3)] = -1 end - Svec = [S_x(particle_symmetry, spin_symmetry), - S_y(particle_symmetry, spin_symmetry), - S_z(particle_symmetry, spin_symmetry)] + Svec = [ + S_x(particle_symmetry, spin_symmetry), + S_y(particle_symmetry, spin_symmetry), + S_z(particle_symmetry, spin_symmetry), + ] # Hermiticity for s in Svec @test s' ≈ s @@ -134,15 +138,15 @@ end @test sum(tr(Svec[i]^2) for i in 1:3) / (2S + 1) ≈ S * (S + 1) # test S_plus and S_min @test S_plus_S_min(particle_symmetry, spin_symmetry) ≈ - S_plus(particle_symmetry, spin_symmetry) ⊗ - S_min(particle_symmetry, spin_symmetry) + S_plus(particle_symmetry, spin_symmetry) ⊗ + S_min(particle_symmetry, spin_symmetry) @test S_min_S_plus(particle_symmetry, spin_symmetry) ≈ - S_min(particle_symmetry, spin_symmetry) ⊗ - S_plus(particle_symmetry, spin_symmetry) + S_min(particle_symmetry, spin_symmetry) ⊗ + S_plus(particle_symmetry, spin_symmetry) # commutation relations for i in 1:3, j in 1:3 @test Svec[i] * Svec[j] - Svec[j] * Svec[i] ≈ - sum(im * ε[i, j, k] * Svec[k] for k in 1:3) + sum(im * ε[i, j, k] * Svec[k] for k in 1:3) end else @test_throws ArgumentError S_plus(particle_symmetry, spin_symmetry) @@ -170,14 +174,14 @@ function hubbard_hamiltonian(particle_symmetry, spin_symmetry; t, U, mu, L) chemical_potential = -mu * e_num(particle_symmetry, spin_symmetry) I = id(hubbard_space(particle_symmetry, spin_symmetry)) H = sum(1:(L - 1)) do i - return reduce(⊗, insert!(collect(Any, fill(I, L - 2)), i, hopping)) - end + + return reduce(⊗, insert!(collect(Any, fill(I, L - 2)), i, hopping)) + end + sum(1:L) do i - return reduce(⊗, insert!(collect(Any, fill(I, L - 1)), i, interaction)) - end + + return reduce(⊗, insert!(collect(Any, fill(I, L - 1)), i, interaction)) + end + sum(1:L) do i - return reduce(⊗, insert!(collect(Any, fill(I, L - 1)), i, chemical_potential)) - end + return reduce(⊗, insert!(collect(Any, fill(I, L - 1)), i, chemical_potential)) + end return H end @@ -208,7 +212,7 @@ end @testset "Exact diagonalisation" begin for particle_symmetry in [Trivial, U1Irrep, SU2Irrep], - spin_symmetry in [Trivial, U1Irrep, SU2Irrep] + spin_symmetry in [Trivial, U1Irrep, SU2Irrep] if (particle_symmetry, spin_symmetry) in implemented_symmetries rng = StableRNG(123) @@ -221,10 +225,14 @@ end H_triv = hubbard_hamiltonian(particle_symmetry, spin_symmetry; t, U, mu, L) # Values based on https://arxiv.org/pdf/0807.4878. Introduction to Hubbard Model and Exact Diagonalization - true_eigenvals = sort(vcat(repeat([-t], 2), [E⁻], repeat([0], 4), - repeat([t], 2), - repeat([U - t], 2), [U], [E⁺], repeat([U + t], 2), - [2 * U])) + true_eigenvals = sort( + vcat( + repeat([-t], 2), [E⁻], repeat([0], 4), + repeat([t], 2), + repeat([U - t], 2), [U], [E⁺], repeat([U + t], 2), + [2 * U] + ) + ) eigenvals = expanded_eigenvalues(H_triv; L) @test eigenvals ≈ true_eigenvals end diff --git a/test/spinoperators.jl b/test/spinoperators.jl index 4dd6f17..5d8d33b 100644 --- a/test/spinoperators.jl +++ b/test/spinoperators.jl @@ -38,7 +38,7 @@ end # commutation relations for i in 1:3, j in 1:3 @test Svec[i] * Svec[j] - Svec[j] * Svec[i] ≈ - sum(im * ε[i, j, k] * Svec[k] for k in 1:3) + sum(im * ε[i, j, k] * Svec[k] for k in 1:3) end # definition of +- @@ -65,9 +65,9 @@ end XX = @inferred S_x_S_x(Z2Irrep) ZZ = @inferred S_z_S_z(Z2Irrep) - @test_throws ArgumentError S_x(Z2Irrep; spin=1) - @test_throws ArgumentError S_x_S_x(Z2Irrep; spin=1) - @test_throws ArgumentError S_z_S_z(Z2Irrep; spin=1) + @test_throws ArgumentError S_x(Z2Irrep; spin = 1) + @test_throws ArgumentError S_x_S_x(Z2Irrep; spin = 1) + @test_throws ArgumentError S_z_S_z(Z2Irrep; spin = 1) @test_throws ArgumentError S_plus(Z2Irrep) @test_throws ArgumentError S_min(Z2Irrep) @@ -84,7 +84,7 @@ end O_z2 = (X ⊗ id(domain(X)) + id(domain(X)) ⊗ X) * a_x + XX * a_xx + ZZ * a_zz O_triv = (S_x() ⊗ id(domain(S_x())) + id(domain(S_x())) ⊗ S_x()) * a_x + - S_x_S_x() * a_xx + S_z_S_z() * a_zz + S_x_S_x() * a_xx + S_z_S_z() * a_zz test_operator(O_z2, O_triv; L) end @@ -113,16 +113,18 @@ end a_z, a_zz, a_plusmin, a_minplus, a_exchange = rand(rng, 5) O_u1 = (Z ⊗ id(domain(Z)) + id(domain(Z)) ⊗ Z) * a_z + - ZZ * a_zz + - plusmin * a_plusmin + - minplus * a_minplus + - exchange * a_exchange - O_triv = (S_z(; spin) ⊗ id(domain(S_z(; spin))) + - id(domain(S_z(; spin))) ⊗ S_z(; spin)) * a_z + - S_z_S_z(; spin) * a_zz + - S_plus_S_min(; spin) * a_plusmin + - S_min_S_plus(; spin) * a_minplus + - S_exchange(; spin) * a_exchange + ZZ * a_zz + + plusmin * a_plusmin + + minplus * a_minplus + + exchange * a_exchange + O_triv = ( + S_z(; spin) ⊗ id(domain(S_z(; spin))) + + id(domain(S_z(; spin))) ⊗ S_z(; spin) + ) * a_z + + S_z_S_z(; spin) * a_zz + + S_plus_S_min(; spin) * a_plusmin + + S_min_S_plus(; spin) * a_minplus + + S_exchange(; spin) * a_exchange test_operator(O_u1, O_triv; L) end @@ -152,7 +154,7 @@ end a = rand(rng, 3) O_su2 = a[1] * SS ⊗ I ⊗ I + a[2] * I ⊗ SS ⊗ I + a[3] * I ⊗ I ⊗ SS O_triv = a[1] * SS_triv ⊗ I_triv ⊗ I_triv + a[2] * I_triv ⊗ SS_triv ⊗ I_triv + - a[3] * I_triv ⊗ I_triv ⊗ SS_triv + a[3] * I_triv ⊗ I_triv ⊗ SS_triv test_operator(O_su2, O_triv) end @@ -165,10 +167,10 @@ end O = ZZ + 0.5 * (plusmin + minplus) true_eigenvals = vcat([-2.0], repeat([-1.0], 3), repeat([1.0], 5)) - eigenvals = expanded_eigenvalues(O; L=2) + eigenvals = expanded_eigenvalues(O; L = 2) @test eigenvals ≈ true_eigenvals # Value based on https://doi.org/10.1088/0953-8984/2/26/010. Exact diagonalisations of open spin-1 chains - eigenvals = expanded_eigenvalues(O; L=4) - @test eigenvals[2] - eigenvals[1] ≈ 0.509170 atol = 1e-6 + eigenvals = expanded_eigenvalues(O; L = 4) + @test eigenvals[2] - eigenvals[1] ≈ 0.50917 atol = 1.0e-6 end diff --git a/test/testsetup.jl b/test/testsetup.jl index 29acb23..7d73427 100644 --- a/test/testsetup.jl +++ b/test/testsetup.jl @@ -7,7 +7,7 @@ using TensorKit using TensorKit: scalartype using LinearAlgebra: eigvals -function operator_sum(O::AbstractTensorMap; L::Int=4) +function operator_sum(O::AbstractTensorMap; L::Int = 4) I = id(space(O, 1)) n = numin(O) return sum(1:(L - n + 1)) do i @@ -15,23 +15,25 @@ function operator_sum(O::AbstractTensorMap; L::Int=4) end end -function swap_2sites(op::AbstractTensorMap{T,S,2,2}) where {T,S} +function swap_2sites(op::AbstractTensorMap{T, S, 2, 2}) where {T, S} return permute(op, ((2, 1), (4, 3))) end -function test_operator(O1::AbstractTensorMap, O2::AbstractTensorMap; L::Int=4, - isapproxkwargs...) +function test_operator( + O1::AbstractTensorMap, O2::AbstractTensorMap; L::Int = 4, + isapproxkwargs... + ) eigenvals1 = expanded_eigenvalues(O1; L) eigenvals2 = expanded_eigenvalues(O2; L) - @test isapprox(eigenvals1, eigenvals2; isapproxkwargs...) + return @test isapprox(eigenvals1, eigenvals2; isapproxkwargs...) end -function expanded_eigenvalues(O1::AbstractTensorMap; L::Int=4) +function expanded_eigenvalues(O1::AbstractTensorMap; L::Int = 4) H = operator_sum(O1; L) eigenvals = mapreduce(vcat, eigvals(H)) do (c, vals) return repeat(vals, dim(c)) end - return sort!(eigenvals; by=real) + return sort!(eigenvals; by = real) end end diff --git a/test/tjoperators.jl b/test/tjoperators.jl index 097bc43..cea0669 100644 --- a/test/tjoperators.jl +++ b/test/tjoperators.jl @@ -6,19 +6,23 @@ using .TensorKitTensorsTestSetup using TensorKitTensors.TJOperators using StableRNGs -implemented_symmetries = [(Trivial, Trivial), (Trivial, U1Irrep), (Trivial, SU2Irrep), - (U1Irrep, Trivial), (U1Irrep, U1Irrep), (U1Irrep, SU2Irrep)] +implemented_symmetries = [ + (Trivial, Trivial), (Trivial, U1Irrep), (Trivial, SU2Irrep), + (U1Irrep, Trivial), (U1Irrep, U1Irrep), (U1Irrep, SU2Irrep), +] @testset "Compare symmetric with trivial tensors" begin for slave_fermion in (false, true) for particle_symmetry in [Trivial, U1Irrep], - spin_symmetry in [Trivial, U1Irrep, SU2Irrep] + spin_symmetry in [Trivial, U1Irrep, SU2Irrep] if (particle_symmetry, spin_symmetry) in implemented_symmetries space = tj_space(particle_symmetry, spin_symmetry; slave_fermion) - O = e_plus_e_min(ComplexF64, particle_symmetry, spin_symmetry; - slave_fermion) + O = e_plus_e_min( + ComplexF64, particle_symmetry, spin_symmetry; + slave_fermion + ) O_triv = e_plus_e_min(ComplexF64, Trivial, Trivial; slave_fermion) test_operator(O, O_triv) @@ -30,12 +34,18 @@ implemented_symmetries = [(Trivial, Trivial), (Trivial, U1Irrep), (Trivial, SU2I O_triv = S_exchange(ComplexF64, Trivial, Trivial; slave_fermion) test_operator(O, O_triv) else - @test_broken e_plus_e_min(ComplexF64, particle_symmetry, spin_symmetry; - slave_fermion) - @test_broken e_num(ComplexF64, particle_symmetry, spin_symmetry; - slave_fermion) - @test_broken S_exchange(ComplexF64, particle_symmetry, spin_symmetry; - slave_fermion) + @test_broken e_plus_e_min( + ComplexF64, particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_broken e_num( + ComplexF64, particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_broken S_exchange( + ComplexF64, particle_symmetry, spin_symmetry; + slave_fermion + ) end end end @@ -44,7 +54,7 @@ end @testset "basic properties" begin for slave_fermion in (false, true) for particle_symmetry in [Trivial, U1Irrep], - spin_symmetry in [Trivial, U1Irrep, SU2Irrep] + spin_symmetry in [Trivial, U1Irrep, SU2Irrep] if (particle_symmetry, spin_symmetry) in implemented_symmetries # test hopping operator @@ -59,47 +69,63 @@ end umup = u_min_u_plus(particle_symmetry, spin_symmetry) @test upum' ≈ -umup ≈ swap_2sites(upum) else - @test_throws ArgumentError d_plus_d_min(particle_symmetry, - spin_symmetry; - slave_fermion) - @test_throws ArgumentError d_min_d_plus(particle_symmetry, - spin_symmetry; - slave_fermion) - @test_throws ArgumentError u_plus_u_min(particle_symmetry, - spin_symmetry; - slave_fermion) - @test_throws ArgumentError u_min_u_plus(particle_symmetry, - spin_symmetry; - slave_fermion) + @test_throws ArgumentError d_plus_d_min( + particle_symmetry, + spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError d_min_d_plus( + particle_symmetry, + spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError u_plus_u_min( + particle_symmetry, + spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError u_min_u_plus( + particle_symmetry, + spin_symmetry; + slave_fermion + ) end # test number operator if spin_symmetry !== SU2Irrep pspace = tj_space(particle_symmetry, spin_symmetry; slave_fermion) @test e_num(particle_symmetry, spin_symmetry; slave_fermion) ≈ - u_num(particle_symmetry, spin_symmetry; slave_fermion) + - d_num(particle_symmetry, spin_symmetry; slave_fermion) + u_num(particle_symmetry, spin_symmetry; slave_fermion) + + d_num(particle_symmetry, spin_symmetry; slave_fermion) @test u_num(particle_symmetry, spin_symmetry; slave_fermion) * - d_num(particle_symmetry, spin_symmetry; slave_fermion) ≈ - d_num(particle_symmetry, spin_symmetry; slave_fermion) * - u_num(particle_symmetry, spin_symmetry; slave_fermion) ≈ - zeros(pspace ← pspace) + d_num(particle_symmetry, spin_symmetry; slave_fermion) ≈ + d_num(particle_symmetry, spin_symmetry; slave_fermion) * + u_num(particle_symmetry, spin_symmetry; slave_fermion) ≈ + zeros(pspace ← pspace) @test TensorKit.id(pspace) ≈ - h_num(particle_symmetry, spin_symmetry; slave_fermion) + - e_num(particle_symmetry, spin_symmetry; slave_fermion) + h_num(particle_symmetry, spin_symmetry; slave_fermion) + + e_num(particle_symmetry, spin_symmetry; slave_fermion) else - @test_throws ArgumentError u_num(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError d_num(particle_symmetry, spin_symmetry; - slave_fermion) + @test_throws ArgumentError u_num( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError d_num( + particle_symmetry, spin_symmetry; + slave_fermion + ) end # test singlet operators if particle_symmetry == Trivial && spin_symmetry !== SU2Irrep - singm = singlet_min(particle_symmetry, spin_symmetry; - slave_fermion) - umdm = u_min_d_min(particle_symmetry, spin_symmetry; - slave_fermion) + singm = singlet_min( + particle_symmetry, spin_symmetry; + slave_fermion + ) + umdm = u_min_d_min( + particle_symmetry, spin_symmetry; + slave_fermion + ) dmum = d_min_u_min(particle_symmetry, spin_symmetry; slave_fermion) @test swap_2sites(umdm) ≈ -dmum @test swap_2sites(singm) ≈ singm @@ -108,21 +134,33 @@ end dpup = d_plus_u_plus(particle_symmetry, spin_symmetry; slave_fermion) @test swap_2sites(updp) ≈ -dpup else - @test_throws ArgumentError singlet_plus(particle_symmetry, - spin_symmetry; - slave_fermion) - @test_throws ArgumentError singlet_min(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError u_min_d_min(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError d_min_u_min(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError u_plus_d_plus(particle_symmetry, - spin_symmetry; - slave_fermion) - @test_throws ArgumentError d_plus_u_plus(particle_symmetry, - spin_symmetry; - slave_fermion) + @test_throws ArgumentError singlet_plus( + particle_symmetry, + spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError singlet_min( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError u_min_d_min( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError d_min_u_min( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError u_plus_d_plus( + particle_symmetry, + spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError d_plus_u_plus( + particle_symmetry, + spin_symmetry; + slave_fermion + ) end # test triplet operators @@ -136,14 +174,22 @@ end @test swap_2sites(upup) ≈ -upup @test swap_2sites(dpdp) ≈ -dpdp else - @test_throws ArgumentError u_min_u_min(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError d_min_d_min(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError u_plus_u_plus(particle_symmetry, - spin_symmetry; slave_fermion) - @test_throws ArgumentError d_plus_d_plus(particle_symmetry, - spin_symmetry; slave_fermion) + @test_throws ArgumentError u_min_u_min( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError d_min_d_min( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError u_plus_u_plus( + particle_symmetry, + spin_symmetry; slave_fermion + ) + @test_throws ArgumentError d_plus_d_plus( + particle_symmetry, + spin_symmetry; slave_fermion + ) end # test spin operator @@ -153,9 +199,11 @@ end ε[mod1(i, 3), mod1(i + 1, 3), mod1(i + 2, 3)] = 1 ε[mod1(i, 3), mod1(i - 1, 3), mod1(i - 2, 3)] = -1 end - Svec = [S_x(particle_symmetry, spin_symmetry; slave_fermion), - S_y(particle_symmetry, spin_symmetry; slave_fermion), - S_z(particle_symmetry, spin_symmetry; slave_fermion)] + Svec = [ + S_x(particle_symmetry, spin_symmetry; slave_fermion), + S_y(particle_symmetry, spin_symmetry; slave_fermion), + S_z(particle_symmetry, spin_symmetry; slave_fermion), + ] # Hermiticity for s in Svec @test s' ≈ s @@ -165,28 +213,38 @@ end @test sum(tr(Svec[i]^2) for i in 1:3) / (2S + 1) ≈ S * (S + 1) # test S_plus and S_min @test S_plus_S_min(particle_symmetry, spin_symmetry; slave_fermion) ≈ - S_plus(particle_symmetry, spin_symmetry; slave_fermion) ⊗ - S_min(particle_symmetry, spin_symmetry; slave_fermion) + S_plus(particle_symmetry, spin_symmetry; slave_fermion) ⊗ + S_min(particle_symmetry, spin_symmetry; slave_fermion) @test S_min_S_plus(particle_symmetry, spin_symmetry; slave_fermion) ≈ - S_min(particle_symmetry, spin_symmetry; slave_fermion) ⊗ - S_plus(particle_symmetry, spin_symmetry; slave_fermion) + S_min(particle_symmetry, spin_symmetry; slave_fermion) ⊗ + S_plus(particle_symmetry, spin_symmetry; slave_fermion) # commutation relations for i in 1:3, j in 1:3 @test Svec[i] * Svec[j] - Svec[j] * Svec[i] ≈ - sum(im * ε[i, j, k] * Svec[k] for k in 1:3) + sum(im * ε[i, j, k] * Svec[k] for k in 1:3) end else - @test_throws ArgumentError S_plus(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError S_min(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError S_x(particle_symmetry, spin_symmetry; - slave_fermion) - @test_throws ArgumentError S_y(particle_symmetry, spin_symmetry; - slave_fermion) + @test_throws ArgumentError S_plus( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError S_min( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError S_x( + particle_symmetry, spin_symmetry; + slave_fermion + ) + @test_throws ArgumentError S_y( + particle_symmetry, spin_symmetry; + slave_fermion + ) if spin_symmetry != U1Irrep - @test_throws ArgumentError S_z(particle_symmetry, spin_symmetry; - slave_fermion) + @test_throws ArgumentError S_z( + particle_symmetry, spin_symmetry; + slave_fermion + ) end end else @@ -204,18 +262,22 @@ end function tjhamiltonian(particle_symmetry, spin_symmetry; t, J, mu, L, slave_fermion) num = e_num(particle_symmetry, spin_symmetry; slave_fermion) - hop_heis = (-t) * (e_plus_e_min(particle_symmetry, spin_symmetry; slave_fermion) - - e_min_e_plus(particle_symmetry, spin_symmetry; slave_fermion)) + - J * - (S_exchange(particle_symmetry, spin_symmetry; slave_fermion) - - (1 / 4) * (num ⊗ num)) + hop_heis = (-t) * ( + e_plus_e_min(particle_symmetry, spin_symmetry; slave_fermion) - + e_min_e_plus(particle_symmetry, spin_symmetry; slave_fermion) + ) + + J * + ( + S_exchange(particle_symmetry, spin_symmetry; slave_fermion) - + (1 / 4) * (num ⊗ num) + ) chemical_potential = (-mu) * num I = id(tj_space(particle_symmetry, spin_symmetry; slave_fermion)) H = sum(1:(L - 1)) do i return reduce(⊗, insert!(collect(Any, fill(I, L - 2)), i, hop_heis)) end + sum(1:L) do i - return reduce(⊗, insert!(collect(Any, fill(I, L - 1)), i, chemical_potential)) - end + return reduce(⊗, insert!(collect(Any, fill(I, L - 1)), i, chemical_potential)) + end return H end @@ -232,22 +294,26 @@ end sort!(vals_triv) for particle_symmetry in (Trivial, U1Irrep), - spin_symmetry in (Trivial, U1Irrep, SU2Irrep) + spin_symmetry in (Trivial, U1Irrep, SU2Irrep) if (particle_symmetry, spin_symmetry) in implemented_symmetries if (particle_symmetry, spin_symmetry) == (Trivial, Trivial) continue end - H_symm = tjhamiltonian(particle_symmetry, spin_symmetry; t, J, mu, L, - slave_fermion) + H_symm = tjhamiltonian( + particle_symmetry, spin_symmetry; t, J, mu, L, + slave_fermion + ) vals_symm = mapreduce(vcat, eigvals(H_symm)) do (c, v) return repeat(real.(v), dim(c)) end sort!(vals_symm) @test vals_triv ≈ vals_symm else - @test_broken tjhamiltonian(particle_symmetry, spin_symmetry; t, J, mu, L, - slave_fermion) + @test_broken tjhamiltonian( + particle_symmetry, spin_symmetry; t, J, mu, L, + slave_fermion + ) end end end @@ -258,21 +324,29 @@ end L = 2 for particle_symmetry in [Trivial, U1Irrep], - spin_symmetry in [Trivial, U1Irrep, SU2Irrep] + spin_symmetry in [Trivial, U1Irrep, SU2Irrep] for slave_fermion in (false, true) if (particle_symmetry, spin_symmetry) in implemented_symmetries t, J = rand(rng, 2) num = e_num(particle_symmetry, spin_symmetry; slave_fermion) H = (-t) * - (e_plus_e_min(particle_symmetry, spin_symmetry; slave_fermion) - - e_min_e_plus(particle_symmetry, spin_symmetry; slave_fermion)) + + ( + e_plus_e_min(particle_symmetry, spin_symmetry; slave_fermion) - + e_min_e_plus(particle_symmetry, spin_symmetry; slave_fermion) + ) + J * - (S_exchange(particle_symmetry, spin_symmetry; slave_fermion) - - (1 / 4) * (num ⊗ num)) + ( + S_exchange(particle_symmetry, spin_symmetry; slave_fermion) - + (1 / 4) * (num ⊗ num) + ) - true_eigenvals = sort(vcat([-J], repeat([-t], 2), repeat([t], 2), - repeat([0.0], 4))) + true_eigenvals = sort( + vcat( + [-J], repeat([-t], 2), repeat([t], 2), + repeat([0.0], 4) + ) + ) eigenvals = expanded_eigenvalues(H; L) @test eigenvals ≈ true_eigenvals end From 90f74a0d01aa6ea0102ff26a4210053003d958aa Mon Sep 17 00:00:00 2001 From: Lukas Devos Date: Tue, 5 Aug 2025 09:35:39 -0400 Subject: [PATCH 2/4] remove .JuliaFormatter.toml --- .JuliaFormatter.toml | 2 -- 1 file changed, 2 deletions(-) delete mode 100644 .JuliaFormatter.toml diff --git a/.JuliaFormatter.toml b/.JuliaFormatter.toml deleted file mode 100644 index 309b5ea..0000000 --- a/.JuliaFormatter.toml +++ /dev/null @@ -1,2 +0,0 @@ -# See https://domluna.github.io/JuliaFormatter.jl/stable/ for a list of options -style = "yas" From fbd8631e30b4578a6a91c6b6bd15d28badcf18af Mon Sep 17 00:00:00 2001 From: Lukas Devos Date: Tue, 5 Aug 2025 09:36:53 -0400 Subject: [PATCH 3/4] update format action --- .github/workflows/FormatCheck.yml | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.github/workflows/FormatCheck.yml b/.github/workflows/FormatCheck.yml index dd2454d..40aaca1 100644 --- a/.github/workflows/FormatCheck.yml +++ b/.github/workflows/FormatCheck.yml @@ -1,4 +1,4 @@ -name: "Format Check" +name: FormatCheck on: push: @@ -7,8 +7,11 @@ on: - 'master' tags: '*' pull_request: + branches: + - 'main' + - 'master' jobs: - format-check: + formatcheck: name: "Format Check" - uses: "QuantumKitHub/.github/.github/workflows/formatcheck.yml@main" + uses: "QuantumKitHub/QuantumKitHubActions/.github/workflows/FormatCheck.yml@main" From 9ca7bd5b653a4de68bb6f55b3d9e9f833d62b59d Mon Sep 17 00:00:00 2001 From: Lukas Devos Date: Tue, 5 Aug 2025 10:36:03 -0400 Subject: [PATCH 4/4] some manual formatting changes --- src/hubbardoperators.jl | 23 ++-- src/spinoperators.jl | 7 +- src/tjoperators.jl | 231 ++++++++++++++-------------------------- test/bosonoperators.jl | 5 +- test/tjoperators.jl | 47 +++----- 5 files changed, 102 insertions(+), 211 deletions(-) diff --git a/src/hubbardoperators.jl b/src/hubbardoperators.jl index be9e3dd..ad20f1e 100644 --- a/src/hubbardoperators.jl +++ b/src/hubbardoperators.jl @@ -47,14 +47,12 @@ function hubbard_space(::Type{U1Irrep}, ::Type{Trivial}) end function hubbard_space(::Type{U1Irrep}, ::Type{U1Irrep}) return Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]( - (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, - (1, 1, -1 // 2) => 1, (0, 2, 0) => 1 + (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, (1, 1, -1 // 2) => 1, (0, 2, 0) => 1 ) end function hubbard_space(::Type{U1Irrep}, ::Type{SU2Irrep}) return Vect[FermionParity ⊠ U1Irrep ⊠ SU2Irrep]( - (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, - (0, 2, 0) => 1 + (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, (0, 2, 0) => 1 ) end function hubbard_space(::Type{SU2Irrep}, ::Type{Trivial}) @@ -62,8 +60,7 @@ function hubbard_space(::Type{SU2Irrep}, ::Type{Trivial}) end function hubbard_space(::Type{SU2Irrep}, ::Type{U1Irrep}) return Vect[FermionParity ⊠ SU2Irrep ⊠ U1Irrep]( - (0, 0, 0) => 1, (1, 1 // 2, 1) => 1, - (0, 0, 2) => 1 + (0, 0, 0) => 1, (1, 1 // 2, 1) => 1, (0, 0, 2) => 1 ) end function hubbard_space(::Type{SU2Irrep}, ::Type{SU2Irrep}) @@ -302,8 +299,7 @@ function S_x( spin_symmetry::Type{<:Sector} ) return ( - S_plus(elt, particle_symmetry, spin_symmetry) - + + S_plus(elt, particle_symmetry, spin_symmetry) + S_min(elt, particle_symmetry, spin_symmetry) ) / 2 end @@ -323,8 +319,7 @@ function S_y( spin_symmetry::Type{<:Sector} ) return ( - S_plus(elt, particle_symmetry, spin_symmetry) - - + S_plus(elt, particle_symmetry, spin_symmetry) - S_min(elt, particle_symmetry, spin_symmetry) ) / (2im) end @@ -934,12 +929,10 @@ function S_exchange( spin_symmetry::Type{<:Sector} ) Sz = S_z(elt, particle_symmetry, spin_symmetry) - return ( - S_plus_S_min(elt, particle_symmetry, spin_symmetry) - + + return Sz ⊗ Sz + ( + S_plus_S_min(elt, particle_symmetry, spin_symmetry) + S_min_S_plus(elt, particle_symmetry, spin_symmetry) - ) / 2 + - Sz ⊗ Sz + ) / 2 end function S_exchange(elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}) t = two_site_operator(elt, Trivial, SU2Irrep) diff --git a/src/spinoperators.jl b/src/spinoperators.jl index 787c36f..d8d4c81 100644 --- a/src/spinoperators.jl +++ b/src/spinoperators.jl @@ -32,12 +32,7 @@ function _pauliterm(spin, i, j) return sqrt((spin + 1) * (i + j - 1) - i * j) / 2.0 end function _pauliterm(spin, i::U1Irrep, j::U1Irrep) - -spin <= i.charge <= spin || return 0.0 - -spin <= j.charge <= spin || return 0.0 - return sqrt( - (spin + 1) * (i.charge + j.charge + 2 * spin + 1) - - (i.charge + spin + 1) * (j.charge + spin + 1) - ) / 2.0 + return _pauliterm(spin, i.charge + spin + 1, j.charge + spin + 1) end """ diff --git a/src/tjoperators.jl b/src/tjoperators.jl index e5c15e0..e5f2482 100644 --- a/src/tjoperators.jl +++ b/src/tjoperators.jl @@ -40,8 +40,7 @@ Setting `slave_fermion = true` switches to the slave-fermion basis. |0⟩ = h†|vac⟩, |↑⟩ = (b↑)†|vac⟩, |↓⟩ = (b↓)†|vac⟩ """ function tj_space( - ::Type{Trivial} = Trivial, ::Type{Trivial} = Trivial; - slave_fermion::Bool = false + ::Type{Trivial} = Trivial, ::Type{Trivial} = Trivial; slave_fermion::Bool = false ) return slave_fermion ? Vect[FermionParity](0 => 2, 1 => 1) : Vect[FermionParity](0 => 1, 1 => 2) @@ -67,13 +66,11 @@ end function tj_space(::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false) return if slave_fermion Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]( - (1, 0, 0) => 1, (0, 1, 1 // 2) => 1, - (0, 1, -1 // 2) => 1 + (1, 0, 0) => 1, (0, 1, 1 // 2) => 1, (0, 1, -1 // 2) => 1 ) else Vect[FermionParity ⊠ U1Irrep ⊠ U1Irrep]( - (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, - (1, 1, -1 // 2) => 1 + (0, 0, 0) => 1, (1, 1, 1 // 2) => 1, (1, 1, -1 // 2) => 1 ) end end @@ -115,8 +112,7 @@ function u_num( return t end function u_num( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = single_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) @@ -125,14 +121,12 @@ function u_num( return t end function u_num( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_num` is not symmetric under `SU2Irrep` spin symmetry")) end function u_num( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; slave_fermion::Bool = false ) t = single_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) @@ -141,8 +135,7 @@ function u_num( return t end function u_num( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = single_site_operator(elt, U1Irrep, U1Irrep; slave_fermion) I = sectortype(t) @@ -151,8 +144,7 @@ function u_num( return t end function u_num( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_num` is not symmetric under `SU2Irrep` spin symmetry")) end @@ -168,8 +160,7 @@ function d_num(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = false return d_num(ComplexF64, P, S; slave_fermion) end function d_num( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; slave_fermion::Bool = false ) t = single_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) @@ -178,8 +169,7 @@ function d_num( return t end function d_num( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = single_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) @@ -188,14 +178,12 @@ function d_num( return t end function d_num( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_num` is not symmetric under `SU2Irrep` spin symmetry")) end function d_num( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; slave_fermion::Bool = false ) t = single_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) @@ -204,8 +192,7 @@ function d_num( return t end function d_num( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = single_site_operator(elt, U1Irrep, U1Irrep; slave_fermion) I = sectortype(t) @@ -214,8 +201,7 @@ function d_num( return t end function d_num( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_num` is not symmetric under `SU2Irrep` spin symmetry")) end @@ -239,8 +225,7 @@ function e_num( d_num(elt, particle_symmetry, spin_symmetry; slave_fermion) end function e_num( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) t = single_site_operator(elt, Trivial, SU2Irrep; slave_fermion) I = sectortype(t) @@ -252,8 +237,7 @@ function e_num( return t end function e_num( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) t = single_site_operator(elt, U1Irrep, SU2Irrep; slave_fermion) I = sectortype(t) @@ -305,8 +289,7 @@ function S_plus( return t end function S_plus( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; slave_fermion::Bool = false ) t = single_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) @@ -315,14 +298,12 @@ function S_plus( return t end function S_plus( - elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`S_plus`, `S_min` are not symmetric under `U1Irrep` spin symmetry")) end function S_plus( - elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`S_plus`, `S_min` are not symmetric under `SU2Irrep` spin symmetry")) end @@ -353,8 +334,7 @@ const S⁻ = S_min 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 + P::Type{<:Sector} = Trivial, S::Type{<:Sector} = Trivial; slave_fermion::Bool = false ) return S_x(ComplexF64, P, S; slave_fermion) end @@ -364,8 +344,7 @@ function S_x( slave_fermion::Bool = false ) return ( - S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) - + + S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) + S_min(elt, particle_symmetry, spin_symmetry; slave_fermion) ) / 2 end @@ -378,8 +357,7 @@ const Sˣ = S_x 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 + P::Type{<:Sector} = Trivial, S::Type{<:Sector} = Trivial; slave_fermion::Bool = false ) return S_y(ComplexF64, P, S; slave_fermion) end @@ -389,8 +367,7 @@ function S_y( slave_fermion::Bool = false ) return ( - S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) - - + S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) - S_min(elt, particle_symmetry, spin_symmetry; slave_fermion) ) / (2im) end @@ -403,14 +380,12 @@ const Sʸ = S_y Return the one-body spin-1/2 z-operator on the electrons. """ S_z function S_z( - P::Type{<:Sector} = Trivial, S::Type{<:Sector} = Trivial; - slave_fermion::Bool = false + 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}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return ( @@ -441,8 +416,7 @@ function u_plus_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return u_plus_u_min(ComplexF64, P, S; slave_fermion) end function u_plus_u_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) @@ -458,8 +432,7 @@ function u_plus_u_min( return t end function u_plus_u_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) @@ -468,14 +441,12 @@ function u_plus_u_min( return t end function u_plus_u_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_plus_u_min` is not symmetric under `SU2Irrep` spin symmetry")) end function u_plus_u_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) @@ -484,8 +455,7 @@ function u_plus_u_min( return t end function u_plus_u_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt, U1Irrep, U1Irrep; slave_fermion) I = sectortype(t) @@ -494,8 +464,7 @@ function u_plus_u_min( return t end function u_plus_u_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_plus_u_min` is not symmetric under `SU2Irrep` spin symmetry")) end @@ -522,8 +491,7 @@ function d_plus_d_min( return t end function d_plus_d_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt::Type{<:Number}, Trivial, U1Irrep; slave_fermion) I = sectortype(t) @@ -532,14 +500,12 @@ function d_plus_d_min( return t end function d_plus_d_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_plus_d_min` is not symmetric under `SU2Irrep` spin symmetry")) end function d_plus_d_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) @@ -548,8 +514,7 @@ function d_plus_d_min( return t end function d_plus_d_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt, U1Irrep, U1Irrep; slave_fermion) I = sectortype(t) @@ -558,8 +523,7 @@ function d_plus_d_min( return t end function d_plus_d_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_plus_d_min` is not symmetric under `SU2Irrep` spin symmetry")) end @@ -576,8 +540,7 @@ function u_min_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return u_min_u_plus(ComplexF64, P, S; slave_fermion) end function u_min_u_plus( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return -copy(adjoint(u_plus_u_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) @@ -595,8 +558,7 @@ function d_min_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return d_min_d_plus(ComplexF64, P, S; slave_fermion) end function d_min_d_plus( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return -copy(adjoint(d_plus_d_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) @@ -614,8 +576,7 @@ function u_min_d_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = return u_min_d_min(ComplexF64, P, S; slave_fermion) end function u_min_d_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) @@ -624,8 +585,7 @@ function u_min_d_min( return t end function u_min_d_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) @@ -634,20 +594,17 @@ function u_min_d_min( return t end function u_min_d_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; slave_fermion::Bool = false ) throw(ArgumentError("`u_min_d_min` is not symmetric under `U1Irrep` particle symmetry")) end function u_min_d_min( - elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_min_d_min` is not symmetric under `SU2Irrep` spin symmetry")) end function u_min_d_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_min_d_min` is not symmetric under `U1Irrep` particle symmetry or under `SU2Irrep` spin symmetry")) end @@ -663,8 +620,7 @@ function u_plus_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return u_plus_d_plus(ComplexF64, P, S; slave_fermion) end function u_plus_d_plus( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return -copy(adjoint(u_min_d_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) @@ -682,8 +638,7 @@ function d_min_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = return d_min_u_min(ComplexF64, P, S; slave_fermion) end function d_min_u_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) @@ -692,8 +647,7 @@ function d_min_u_min( return t end function d_min_u_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) @@ -702,20 +656,17 @@ function d_min_u_min( return t end function d_min_u_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; slave_fermion::Bool = false ) throw(ArgumentError("`d_min_u_min` is not symmetric under `U1Irrep` particle symmetry")) end function d_min_u_min( - elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_min_u_min` is not symmetric under `SU2Irrep` spin symmetry")) end function d_min_u_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_min_u_min` is not symmetric under `U1Irrep` particle symmetry or under `SU2Irrep` particle symmetry")) end @@ -731,8 +682,7 @@ function d_plus_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return d_plus_u_plus(ComplexF64, P, S; slave_fermion) end function d_plus_u_plus( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return -copy(adjoint(d_min_u_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) @@ -750,8 +700,7 @@ function u_min_u_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = return u_min_u_min(ComplexF64, P, S; slave_fermion) end function u_min_u_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) @@ -760,32 +709,27 @@ function u_min_u_min( return t end function u_min_u_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; slave_fermion::Bool = false ) throw(ArgumentError("`u_min_u_min` is not symmetric under `U1Irrep` particle symmetry")) end function u_min_u_min( - elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_min_u_min` is not symmetric under `U1Irrep` spin symmetry")) end function u_min_u_min( - elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_min_u_min` is not symmetric under `SU2Irrep` spin symmetry")) end function u_min_u_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_min_u_min` is not symmetric under `U1Irrep` particle symmetry or under `U1Irrep` particle symmetry")) end function u_min_u_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`u_min_u_min` is not symmetric under `U1Irrep` particle symmetry or under `SU2Irrep` particle symmetry")) end @@ -801,8 +745,7 @@ function u_plus_u_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return u_plus_u_plus(ComplexF64, P, S; slave_fermion) end function u_plus_u_plus( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return -copy(adjoint(u_min_u_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) @@ -820,8 +763,7 @@ function d_min_d_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = return d_min_d_min(ComplexF64, P, S; slave_fermion) end function d_min_d_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) @@ -830,32 +772,27 @@ function d_min_d_min( return t end function d_min_d_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{<:Sector}; slave_fermion::Bool = false ) throw(ArgumentError("`d_min_d_min` is not symmetric under `U1Irrep` particle symmetry")) end function d_min_d_min( - elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{U1Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_min_d_min` is not symmetric under `U1Irrep` spin symmetry")) end function d_min_d_min( - elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{<:Sector}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_min_d_min` is not symmetric under `SU2Irrep` spin symmetry")) end function d_min_d_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_min_d_min` is not symmetric under `U1Irrep` particle symmetry or under `U1Irrep` particle symmetry")) end function d_min_d_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) throw(ArgumentError("`d_min_d_min` is not symmetric under `U1Irrep` particle symmetry or under `SU2Irrep` particle symmetry")) end @@ -871,8 +808,7 @@ function d_plus_d_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return d_plus_d_plus(ComplexF64, P, S; slave_fermion) end function d_plus_d_plus( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return -copy(adjoint(d_min_d_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) @@ -890,8 +826,7 @@ function e_plus_e_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return e_plus_e_min(ComplexF64, P, S; slave_fermion) end function e_plus_e_min( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return u_plus_u_min(elt, particle_symmetry, spin_symmetry; slave_fermion) + @@ -910,8 +845,7 @@ function e_plus_e_min( return t end function e_plus_e_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt, U1Irrep, SU2Irrep; slave_fermion) I = sectortype(t) @@ -935,8 +869,7 @@ function e_min_e_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return e_min_e_plus(ComplexF64, P, S; slave_fermion) end function e_min_e_plus( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return -copy(adjoint(e_plus_e_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) @@ -1012,8 +945,7 @@ function S_plus_S_min(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return S_plus_S_min(ComplexF64, P, S; slave_fermion) end function S_plus_S_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, Trivial; slave_fermion) I = sectortype(t) @@ -1022,8 +954,7 @@ function S_plus_S_min( return t end function S_plus_S_min( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{Trivial}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt, Trivial, U1Irrep; slave_fermion) I = sectortype(t) @@ -1032,8 +963,7 @@ function S_plus_S_min( return t end function S_plus_S_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{Trivial}; slave_fermion::Bool = false ) t = two_site_operator(elt, U1Irrep, Trivial; slave_fermion) I = sectortype(t) @@ -1042,8 +972,7 @@ function S_plus_S_min( return t end function S_plus_S_min( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; - slave_fermion::Bool = false + elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{U1Irrep}; slave_fermion::Bool = false ) t = two_site_operator(elt, U1Irrep, U1Irrep; slave_fermion) I = sectortype(t) @@ -1064,8 +993,7 @@ function S_min_S_plus(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool return S_min_S_plus(ComplexF64, P, S; slave_fermion) end function S_min_S_plus( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) return copy(adjoint(S_plus_S_min(elt, particle_symmetry, spin_symmetry; slave_fermion))) @@ -1081,21 +1009,17 @@ function S_exchange(P::Type{<:Sector}, S::Type{<:Sector}; slave_fermion::Bool = return S_exchange(ComplexF64, P, S; slave_fermion) end function S_exchange( - elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, - spin_symmetry::Type{<:Sector}; + elt::Type{<:Number}, particle_symmetry::Type{<:Sector}, spin_symmetry::Type{<:Sector}; slave_fermion::Bool = false ) Sz = S_z(elt, particle_symmetry, spin_symmetry; slave_fermion) return (1 / 2) * ( - S_plus_S_min(elt, particle_symmetry, spin_symmetry; slave_fermion) - + + S_plus_S_min(elt, particle_symmetry, spin_symmetry; slave_fermion) + S_min_S_plus(elt, particle_symmetry, spin_symmetry; slave_fermion) - ) + - Sz ⊗ Sz + ) + Sz ⊗ Sz end function S_exchange( - elt::Type{<:Number}, ::Type{Trivial}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + 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) @@ -1107,8 +1031,7 @@ function S_exchange( return t end function S_exchange( - elt::Type{<:Number}, ::Type{U1Irrep}, ::Type{SU2Irrep}; - slave_fermion::Bool = false + 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) diff --git a/test/bosonoperators.jl b/test/bosonoperators.jl index 09ef60c..0146805 100644 --- a/test/bosonoperators.jl +++ b/test/bosonoperators.jl @@ -90,10 +90,7 @@ end O = (N ⊗ id(V) + id(V) ⊗ N) * b_n + B⁻B⁺ * b_mp + B⁺B⁻ * b_pm true_eigenvals = sort( - [ - 0, 2 * b_n, b_n + sqrt(b_mp * b_pm), - b_n - sqrt(b_mp * b_pm), - ] + [0, 2 * b_n, b_n + sqrt(b_mp * b_pm), b_n - sqrt(b_mp * b_pm)] ) eigenvals = expanded_eigenvalues(O; L) @test eigenvals ≈ true_eigenvals diff --git a/test/tjoperators.jl b/test/tjoperators.jl index cea0669..20dfab4 100644 --- a/test/tjoperators.jl +++ b/test/tjoperators.jl @@ -70,23 +70,19 @@ end @test upum' ≈ -umup ≈ swap_2sites(upum) else @test_throws ArgumentError d_plus_d_min( - particle_symmetry, - spin_symmetry; + particle_symmetry, spin_symmetry; slave_fermion ) @test_throws ArgumentError d_min_d_plus( - particle_symmetry, - spin_symmetry; + particle_symmetry, spin_symmetry; slave_fermion ) @test_throws ArgumentError u_plus_u_min( - particle_symmetry, - spin_symmetry; + particle_symmetry, spin_symmetry; slave_fermion ) @test_throws ArgumentError u_min_u_plus( - particle_symmetry, - spin_symmetry; + particle_symmetry, spin_symmetry; slave_fermion ) end @@ -135,8 +131,7 @@ end @test swap_2sites(updp) ≈ -dpup else @test_throws ArgumentError singlet_plus( - particle_symmetry, - spin_symmetry; + particle_symmetry, spin_symmetry; slave_fermion ) @test_throws ArgumentError singlet_min( @@ -152,13 +147,11 @@ end slave_fermion ) @test_throws ArgumentError u_plus_d_plus( - particle_symmetry, - spin_symmetry; + particle_symmetry, spin_symmetry; slave_fermion ) @test_throws ArgumentError d_plus_u_plus( - particle_symmetry, - spin_symmetry; + particle_symmetry, spin_symmetry; slave_fermion ) end @@ -183,12 +176,12 @@ end slave_fermion ) @test_throws ArgumentError u_plus_u_plus( - particle_symmetry, - spin_symmetry; slave_fermion + particle_symmetry, spin_symmetry; + slave_fermion ) @test_throws ArgumentError d_plus_d_plus( - particle_symmetry, - spin_symmetry; slave_fermion + particle_symmetry, spin_symmetry; + slave_fermion ) end @@ -265,12 +258,7 @@ function tjhamiltonian(particle_symmetry, spin_symmetry; t, J, mu, L, slave_ferm hop_heis = (-t) * ( e_plus_e_min(particle_symmetry, spin_symmetry; slave_fermion) - e_min_e_plus(particle_symmetry, spin_symmetry; slave_fermion) - ) + - J * - ( - S_exchange(particle_symmetry, spin_symmetry; slave_fermion) - - (1 / 4) * (num ⊗ num) - ) + ) + J * (S_exchange(particle_symmetry, spin_symmetry; slave_fermion) - (1 / 4) * (num ⊗ num)) chemical_potential = (-mu) * num I = id(tj_space(particle_symmetry, spin_symmetry; slave_fermion)) H = sum(1:(L - 1)) do i @@ -301,8 +289,7 @@ end continue end H_symm = tjhamiltonian( - particle_symmetry, spin_symmetry; t, J, mu, L, - slave_fermion + particle_symmetry, spin_symmetry; t, J, mu, L, slave_fermion ) vals_symm = mapreduce(vcat, eigvals(H_symm)) do (c, v) return repeat(real.(v), dim(c)) @@ -311,8 +298,7 @@ end @test vals_triv ≈ vals_symm else @test_broken tjhamiltonian( - particle_symmetry, spin_symmetry; t, J, mu, L, - slave_fermion + particle_symmetry, spin_symmetry; t, J, mu, L, slave_fermion ) end end @@ -342,10 +328,7 @@ end ) true_eigenvals = sort( - vcat( - [-J], repeat([-t], 2), repeat([t], 2), - repeat([0.0], 4) - ) + vcat([-J], repeat([-t], 2), repeat([t], 2), repeat([0.0], 4)) ) eigenvals = expanded_eigenvalues(H; L) @test eigenvals ≈ true_eigenvals