Frobenius-Schur disambiguation (#28)

* `frobenius_schur_indicator` and `frobenius_schur_phase`

* deprecate `frobeniusschur`

* Bump coverage slightly

Author: lkdvos

src/TensorKitSectors.jl

@@ -7,7 +7,7 @@ export Irrep, GroupElement
 
 export Nsymbol, Fsymbol, Rsymbol, Asymbol, Bsymbol
 export sectorscalartype
-export dim, sqrtdim, invsqrtdim, frobeniusschur, twist, fusiontensor, dual
+export dim, sqrtdim, invsqrtdim, frobenius_schur_indicator, frobenius_schur_phase, twist, fusiontensor, dual
 export otimes, deligneproduct, times
 export FusionStyle, UniqueFusion, MultipleFusion, SimpleFusion, GenericFusion,
     MultiplicityFreeFusion
@@ -74,4 +74,8 @@ function __precompile__()
     return
 end
 
+# deprecate
+# ---------
+@deprecate frobeniusschur(a::Sector) frobenius_schur_phase(a)
+
 end # module TensorKitSectors

src/groupelements.jl

@@ -24,7 +24,7 @@ Base.inv(c::GroupElement) -> GroupElement
 TensorKitSectors.cocycle(c1::GroupElement, c2::GroupElement, c3::GroupElement) -> Number
 ```
 The methods `conj`, `dual`, `⊗`, `Nsymbol`, `Fsymbol`, `dim`, `Asymbol`, `Bsymbol` and
-`frobeniusschur` will then be automatically defined. If no `cocycle` method is defined,
+`frobenius_schur_phase` will then be automatically defined. If no `cocycle` method is defined,
 the cocycle will be assumed to be trivial, i.e. equal to `1`.
 
 """
@@ -46,9 +46,9 @@ function Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {I <: AbstractGroupEl
     end
 end
 dim(c::AbstractGroupElement) = 1
-frobeniusschur(c::AbstractGroupElement) = cocycle(c, inv(c), c)
+frobenius_schur_phase(c::AbstractGroupElement) = cocycle(c, inv(c), c)
 function Asymbol(a::I, b::I, c::I) where {I <: AbstractGroupElement}
-    A = frobeniusschur(dual(a)) * cocycle(inv(a), a, b)
+    A = frobenius_schur_phase(dual(a)) * cocycle(inv(a), a, b)
     return c == a * b ? A : zero(A)
 end
 function Bsymbol(a::I, b::I, c::I) where {I <: AbstractGroupElement}

src/irreps/cu1irrep.jl

@@ -251,4 +251,4 @@ function fusiontensor(a::CU1Irrep, b::CU1Irrep, c::CU1Irrep)
     end
     return C
 end
-frobeniusschur(::CU1Irrep) = 1
+frobenius_schur_phase(::CU1Irrep) = 1

src/irreps/irreps.jl

@@ -54,7 +54,7 @@ Nsymbol(a::I, b::I, c::I) where {I <: AbelianIrrep} = c == first(a ⊗ b)
 function Fsymbol(a::I, b::I, c::I, d::I, e::I, f::I) where {I <: AbelianIrrep}
     return Int(Nsymbol(a, b, e) * Nsymbol(e, c, d) * Nsymbol(b, c, f) * Nsymbol(a, f, d))
 end
-frobeniusschur(a::AbelianIrrep) = 1
+frobenius_schur_phase(a::AbelianIrrep) = 1
 Asymbol(a::I, b::I, c::I) where {I <: AbelianIrrep} = Int(Nsymbol(a, b, c))
 Bsymbol(a::I, b::I, c::I) where {I <: AbelianIrrep} = Int(Nsymbol(a, b, c))
 Rsymbol(a::I, b::I, c::I) where {I <: AbelianIrrep} = Int(Nsymbol(a, b, c))

src/precompile.jl

@@ -25,7 +25,8 @@ function precompile_sector(::Type{I}) where {I <: Sector}
     precompile(unit, (I,))
     precompile(allunits, (I,))
     precompile(twist, (I,))
-    precompile(frobeniusschur, (I,))
+    precompile(frobenius_schur_phase, (I,))
+    precompile(frobenius_schur_indicator, (I,))
     precompile(fusiontensor, (I, I, I))
 
     return nothing

src/product.jl

@@ -191,7 +191,8 @@ function Asymbol(a::P, b::P, c::P) where {P <: ProductSector{<:Tuple{Sector}}}
     return Asymbol(map(_firstsector, (a, b, c))...)
 end
 
-frobeniusschur(p::ProductSector) = prod(map(frobeniusschur, p.sectors))
+frobenius_schur_phase(p::ProductSector) = prod(frobenius_schur_phase, p.sectors)
+frobenius_schur_indicator(p::ProductSector) = prod(frobenius_schur_indicator, p.sectors)
 
 function fusiontensor(a::P, b::P, c::P) where {P <: ProductSector}
     return _kron(

src/sectors.jl

@@ -22,7 +22,8 @@ Every new `I<:Sector` should implement the following methods:
     `UniqueFusion`/`SimpleFusion`) or matrix (in case of `GenericFusion`)
 and optionally
 *   `dim(a::I)`: quantum dimension of sector `a`
-*   `frobeniusschur(a::I)`: Frobenius-Schur indicator of `a`
+*   `frobenius_schur_indicator(a::I)`: Frobenius-Schur indicator of `a` (1, 0, -1)
+*   `frobenius_schur_phase(a::I)`: Frobenius-Schur phase of `a` (±1)
 *   `Bsymbol(a::I, b::I, c::I)`: B-symbol: scalar (in case of
     `UniqueFusion`/`SimpleFusion`) or matrix (in case of `GenericFusion`)
 *   `twist(a::I)` -> twist of sector `a`
@@ -316,27 +317,43 @@ sqrtdim(a::Sector) = (FusionStyle(a) isa UniqueFusion) ? 1 : sqrt(dim(a))
 invsqrtdim(a::Sector) = (FusionStyle(a) isa UniqueFusion) ? 1 : inv(sqrt(dim(a)))
 
 """
-    frobeniusschur(a::Sector)
+    frobenius_schur_phase(a::Sector)
 
-Return the Frobenius-Schur indicator of a sector `a`.
+Return the Frobenius-Schur phase of a sector ``\\kappa_a ∈ {1, -1}``, which coincides with
+the Frobenius-Schur indicator if `a == dual(a)`, and can otherwise be gauged to be `1`.
+
+See also [`frobenius_schur_indicator`](@ref) for the group-theoretic version.
 """
-function frobeniusschur(a::Sector)
+function frobenius_schur_phase(a::Sector)
     return if FusionStyle(a) isa UniqueFusion || FusionStyle(a) isa SimpleFusion
         sign(Fsymbol(a, dual(a), a, a, leftunit(a), rightunit(a)))
     else
         sign(Fsymbol(a, dual(a), a, a, leftunit(a), rightunit(a))[1])
     end
 end
 
+"""
+    frobenius_schur_indicator(a::Sector)
+
+Return the Frobenius-Schur indicator of a sector ``\\nu_a ∈ {1, 0, -1}``, which distinguishes
+between real, complex and quaternionic representations.
+
+See also [`frobenius_schur_phase`](@ref) for the category-theoretic version.
+"""
+function frobenius_schur_indicator(a::Sector)
+    ν = frobenius_schur_phase(a)
+    return a == conj(a) ? zero(ν) : ν
+end
+
 # Not necessary
 function Asymbol(a::I, b::I, c::I) where {I <: Sector}
     return if FusionStyle(I) isa UniqueFusion || FusionStyle(I) isa SimpleFusion
         (sqrtdim(a) * sqrtdim(b) * invsqrtdim(c)) *
-            conj(frobeniusschur(a) * Fsymbol(dual(a), a, b, b, leftunit(a), c))
+            conj(frobenius_schur_phase(a) * Fsymbol(dual(a), a, b, b, leftunit(a), c))
     else
         reshape(
             (sqrtdim(a) * sqrtdim(b) * invsqrtdim(c)) *
-                conj(frobeniusschur(a) * Fsymbol(dual(a), a, b, b, leftunit(a), c)),
+                conj(frobenius_schur_phase(a) * Fsymbol(dual(a), a, b, b, leftunit(a), c)),
             (Nsymbol(a, b, c), Nsymbol(dual(a), c, b))
         )
     end

test/multifusion.jl

@@ -41,7 +41,7 @@ Istr = TensorKitSectors.type_repr(I)
         @constinferred dual(s)
         @test dual(dual(s)) == s
         @constinferred dim(s)
-        @constinferred frobeniusschur(s)
+        @constinferred frobenius_schur_phase(s)
         @constinferred convert(IsingAnyon, s)
 
         @constinferred Bsymbol(C, C, C)

test/sectors.jl

@@ -8,8 +8,10 @@ Istr = TKS.type_repr(I)
     @test @constinferred(unit(s[1])) == @constinferred(unit(I))
     @constinferred dual(s[1])
     @constinferred dim(s[1])
-    @constinferred frobeniusschur(s[1])
+    @constinferred frobenius_schur_phase(s[1])
+    @constinferred frobenius_schur_indicator(s[1])
     @constinferred Nsymbol(s...)
+    @constinferred Asymbol(s...)
     B = @constinferred Bsymbol(s...)
     F = @constinferred Fsymbol(s..., s...)
     if BraidingStyle(I) isa HasBraiding