Standardized SectorProductIterator (#30)

* Add SectorProductIterator

* replace `DNIrrepProdIterator`

* Add `show` for SectorProductIterator

* replace `CU1ProdIterator`

* Replace `SU2IrrepProdIterator`

* test printing

* Replace `FibonacciIterator`

* Replace `IsingIterator`

* Replace `IsingBimoduleIterator`

* some slight reorganization

Author: lkdvos

src/anyons.jl

@@ -81,17 +81,12 @@ FusionStyle(::Type{FibonacciAnyon}) = SimpleFusion()
 BraidingStyle(::Type{FibonacciAnyon}) = Anyonic()
 Base.isreal(::Type{FibonacciAnyon}) = false
 
-⊗(a::FibonacciAnyon, b::FibonacciAnyon) = FibonacciIterator(a, b)
+const FibonacciAnyonProdIterator = SectorProductIterator{FibonacciAnyon}
 
-struct FibonacciIterator
-    a::FibonacciAnyon
-    b::FibonacciAnyon
-end
-Base.IteratorSize(::Type{FibonacciIterator}) = Base.HasLength()
-Base.IteratorEltype(::Type{FibonacciIterator}) = Base.HasEltype()
-Base.length(iter::FibonacciIterator) = (isunit(iter.a) || isunit(iter.b)) ? 1 : 2
-Base.eltype(::Type{FibonacciIterator}) = FibonacciAnyon
-function Base.iterate(iter::FibonacciIterator, state = 1)
+Base.IteratorSize(::Type{FibonacciAnyonProdIterator}) = Base.HasLength()
+Base.length(iter::FibonacciAnyonProdIterator) = (isunit(iter.a) || isunit(iter.b)) ? 1 : 2
+
+function Base.iterate(iter::FibonacciAnyonProdIterator, state = 1)
     I = FibonacciAnyon(:I)
     τ = FibonacciAnyon(:τ)
     if state == 1 # first iteration
@@ -200,23 +195,15 @@ FusionStyle(::Type{IsingAnyon}) = SimpleFusion()
 BraidingStyle(::Type{IsingAnyon}) = Anyonic()
 Base.isreal(::Type{IsingAnyon}) = false
 
-⊗(a::IsingAnyon, b::IsingAnyon) = IsingIterator(a, b)
-
-struct IsingIterator
-    a::IsingAnyon
-    b::IsingAnyon
-end
-
-Base.IteratorSize(::Type{IsingIterator}) = Base.HasLength()
-Base.IteratorEltype(::Type{IsingIterator}) = Base.HasEltype()
-Base.eltype(::Type{IsingIterator}) = IsingAnyon
+const IsingAnyonProdIterator = SectorProductIterator{IsingAnyon}
 
-function Base.length(iter::IsingIterator)
+Base.IteratorSize(::Type{IsingAnyonProdIterator}) = Base.HasLength()
+function Base.length(iter::IsingAnyonProdIterator)
     σ = IsingAnyon(:σ)
     return (iter.a == σ && iter.b == σ) ? 2 : 1
 end
 
-function Base.iterate(iter::IsingIterator, state = 1)
+function Base.iterate(iter::IsingAnyonProdIterator, state = 1)
     I, σ, ψ = all_isinganyons
     if state == 1 # first iteration
         iter.a == I && return (iter.b, 2)

src/irreps/cu1irrep.jl

@@ -69,11 +69,20 @@ Base.convert(::Type{CU1Irrep}, js::Tuple{Real, Int}) = CU1Irrep(js...)
 unit(::Type{CU1Irrep}) = CU1Irrep(zero(HalfInt), 0)
 dual(c::CU1Irrep) = c
 
-struct CU1ProdIterator
-    a::CU1Irrep
-    b::CU1Irrep
+const CU1IrrepProdIterator = SectorProductIterator{CU1Irrep}
+
+Base.IteratorSize(::Type{CU1IrrepProdIterator}) = Base.HasLength()
+function Base.length(p::CU1IrrepProdIterator)
+    if p.a.j == zero(HalfInt) || p.b.j == zero(HalfInt)
+        return 1
+    elseif p.a == p.b
+        return 3
+    else
+        return 2
+    end
 end
-function Base.iterate(p::CU1ProdIterator, s::Int = 1)
+
+function Base.iterate(p::CU1IrrepProdIterator, s::Int = 1)
     if s == 1
         if p.a.j == p.b.j == zero(HalfInt)
             return CU1Irrep(zero(HalfInt), xor(p.a.s, p.b.s)), 4
@@ -94,18 +103,6 @@ function Base.iterate(p::CU1ProdIterator, s::Int = 1)
         return nothing
     end
 end
-function Base.length(p::CU1ProdIterator)
-    if p.a.j == zero(HalfInt) || p.b.j == zero(HalfInt)
-        return 1
-    elseif p.a == p.b
-        return 3
-    else
-        return 2
-    end
-end
-Base.eltype(::Type{CU1ProdIterator}) = CU1Irrep
-
-⊗(a::CU1Irrep, b::CU1Irrep) = CU1ProdIterator(a, b)
 
 dim(c::CU1Irrep) = ifelse(c.j == zero(HalfInt), 1, 2)
 

src/irreps/dnirrep.jl

@@ -102,15 +102,11 @@ end
 
 # Product iterator
 # ----------------
-struct DNIrrepProdIterator{N}
-    a::DNIrrep{N}
-    b::DNIrrep{N}
-end
 
-⊗(a::DNIrrep{N}, b::DNIrrep{N}) where {N} = a <= b ? DNIrrepProdIterator(a, b) : DNIrrepProdIterator(b, a)
+const DNIrrepProdIterator{N} = SectorProductIterator{DNIrrep{N}}
+⊗(a::DNIrrep{N}, b::DNIrrep{N}) where {N} = SectorProductIterator((a <= b ? (a, b) : (b, a))...)
 
-Base.eltype(::Type{DNIrrepProdIterator{N}}) where {N} = DNIrrep{N}
-Base.IteratorSize(x::DNIrrepProdIterator) = Base.HasLength()
+Base.IteratorSize(::Type{DNIrrepProdIterator{N}}) where {N} = Base.HasLength()
 function Base.length(x::DNIrrepProdIterator{N}) where {N}
     a, b = x.a, x.b
     if a.j == 0 || b.j == 0 || (N == 2 * a.j) || (N == 2 * b.j)

src/irreps/su2irrep.jl

@@ -32,7 +32,15 @@ Base.convert(::Type{SU2Irrep}, j::Real) = SU2Irrep(j)
 const _su2one = SU2Irrep(zero(HalfInt))
 unit(::Type{SU2Irrep}) = _su2one
 dual(s::SU2Irrep) = s
-⊗(s1::SU2Irrep, s2::SU2Irrep) = SectorSet{SU2Irrep}(abs(s1.j - s2.j):(s1.j + s2.j))
+
+const SU2IrrepProdIterator = SectorProductIterator{SU2Irrep}
+
+Base.IteratorSize(::Type{SU2IrrepProdIterator}) = Base.HasLength()
+Base.length(it::SU2IrrepProdIterator) = length(abs(it.a.j - it.b.j):(it.a.j + it.b.j))
+
+function Base.iterate(it::SU2IrrepProdIterator, state = abs(it.a.j - it.b.j))
+    return state > (it.a.j + it.b.j) ? nothing : (SU2Irrep(state), state + 1)
+end
 
 Base.IteratorSize(::Type{SectorValues{SU2Irrep}}) = IsInfinite()
 Base.iterate(::SectorValues{SU2Irrep}, i::Int = 0) = (SU2Irrep(half(i)), i + 1)

src/multifusion.jl

@@ -27,18 +27,12 @@ Base.IteratorSize(::Type{SectorValues{IsingBimodule}}) = Base.SizeUnknown()
 Base.iterate(::SectorValues{IsingBimodule}, i = 1) = iterate(all_isingbimod_objects, i)
 Base.length(::SectorValues{IsingBimodule}) = length(all_isingbimod_objects)
 
-⊗(a::IsingBimodule, b::IsingBimodule) = IsingBimoduleIterator(a, b)
+const IsingBimoduleProdIterator = SectorProductIterator{IsingBimodule}
+⊗(a::IsingBimodule, b::IsingBimodule) = SectorProductIterator(a, b)
 
-struct IsingBimoduleIterator
-    a::IsingBimodule
-    b::IsingBimodule
-end
-
-Base.IteratorSize(::Type{IsingBimoduleIterator}) = Base.SizeUnknown()
-Base.IteratorEltype(::Type{IsingBimoduleIterator}) = Base.HasEltype()
-Base.eltype(::Type{IsingBimoduleIterator}) = IsingBimodule
+Base.IteratorSize(::Type{IsingBimoduleProdIterator}) = Base.SizeUnknown()
 
-function Base.iterate(iter::IsingBimoduleIterator, state = 0)
+function Base.iterate(iter::IsingBimoduleProdIterator, state = 0)
     a, b = iter.a, iter.b
     a.col == b.row || return nothing
 

src/sectors.jl

@@ -206,6 +206,54 @@ const otimes = ⊗
     end
 end
 
+"""
+    SectorProductIterator(a::I, b::I) where {I <: Sector}
+
+Custom iterator to represent the (unique) fusion outputs of ``a ⊗ b``.
+
+Custom sectors that aim to use this have to provide the following functionality:
+
+* `Base.iterate(::SectorProductIterator{I}, state...) where {I <: Sector}`: iterate over
+    the fusion outputs of `a ⊗ b`
+
+If desired and it is possible to easily compute the number of unique fusion outputs, it is also
+possible to define `Base.IteratorSize(::Type{SectorProductIterator{I}}) = Base.HasLength()`, in which
+case `Base.length(::SectorProductIterator{I})` has to be implemented.
+
+See also [`⊗`](@ref).
+"""
+struct SectorProductIterator{I <: Sector}
+    a::I
+    b::I
+end
+
+⊗(a::I, b::I) where {I <: Sector} = SectorProductIterator(a, b)
+
+Base.IteratorSize(::Type{SectorProductIterator{I}}) where {I} = Base.SizeUnknown()
+Base.IteratorEltype(::Type{SectorProductIterator{I}}) where {I} = Base.HasEltype()
+Base.eltype(::Type{SectorProductIterator{I}}) where {I} = I
+
+function Base.show(io::IO, it::SectorProductIterator)
+    show(io, it.a)
+    print(io, " ⊗ ")
+    show(io, it.b)
+    return nothing
+end
+
+function Base.show(io::IO, mime::MIME"text/plain", ab::SectorProductIterator)
+    show(io, ab.a)
+    print(io, " ⊗ ")
+    show(io, ab.b)
+    get(io, :compact, false) && return nothing
+    print(io, ":")
+    ioc = IOContext(io, :typeinfo => eltype(ab))
+    for c in ab
+        print(io, "\n ")
+        show(ioc, mime, c)
+    end
+    return nothing
+end
+
 """
     Nsymbol(a::I, b::I, c::I) where {I<:Sector} -> Integer
 
@@ -535,7 +583,7 @@ function hexagon_equation(a::I, b::I, c::I; kwargs...) where {I <: Sector}
 end
 
 # SectorSet:
-#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------------------
 # Custom generator to represent sets of sectors with type inference
 struct SectorSet{I <: Sector, F, S}
     f::F

test/runtests.jl

@@ -88,6 +88,16 @@ end
     @test size(Rsymbol(a, b, c)) == (0, 0)
 end
 
+@testset "SectorProduct printing" begin
+    a = SU2Irrep(1)
+    @test repr(a ⊗ a) == "Irrep[SU₂](1) ⊗ Irrep[SU₂](1)"
+    @test repr("text/plain", a ⊗ a) == "Irrep[SU₂](1) ⊗ Irrep[SU₂](1):\n 0\n 1\n 2"
+
+    b = D4Irrep(1)
+    @test repr(b ⊗ b) == "Irrep[D₄](1, false) ⊗ Irrep[D₄](1, false)"
+    @test repr("text/plain", b ⊗ b) == "Irrep[D₄](1, false) ⊗ Irrep[D₄](1, false):\n (0, false)\n (0, true)\n (2, false)\n (2, true)"
+end
+
 include("multifusion.jl")
 
 @testset "Aqua" begin