renaming to IsingBimodule

Author: borisdevos

src/TensorKit.jl

@@ -15,7 +15,7 @@ export BraidingStyle, SymmetricBraiding, Bosonic, Fermionic, Anyonic, NoBraiding
 export Trivial, Z2Irrep, Z3Irrep, Z4Irrep, ZNIrrep, U1Irrep, SU2Irrep, CU1Irrep
 export ProductSector
 export FermionParity, FermionNumber, FermionSpin
-export FibonacciAnyon, IsingAnyon, IsingBimod
+export FibonacciAnyon, IsingAnyon, IsingBimodule
 export leftone, rightone
 
 export VectorSpace, Field, ElementarySpace # abstract vector spaces
@@ -229,7 +229,7 @@ include("planar/planaroperations.jl")
 # deprecations: to be removed in version 1.0 or sooner
 include("auxiliary/deprecate.jl")
 
-# Additional methods for IsingBimod Sector
+# Additional methods for IsingBimodule Sector
 # ----------------------------------------
 include("spaces/multifusionspace.jl")
 

src/spaces/multifusionspace.jl

@@ -1,15 +1,13 @@
 # additional interface to deal with IsingBimodule Sector
 #------------------------------------------------------------------------------
 
-const IsingBimod = IsingBimodule #TODO: do the rename after compat fix
-
-function dim(V::Vect[IsingBimod])
+function dim(V::Vect[IsingBimodule])
     T = Base.promote_op(*, Int, real(sectorscalartype(sectortype(V))))
     return reduce(+, dim(V, c) * dim(c) for c in sectors(V);
                   init=zero(T))
 end
 
-function scalar(t::AbstractTensorMap{T,Vect[IsingBimod],0,0}) where {T}
+function scalar(t::AbstractTensorMap{T,Vect[IsingBimodule],0,0}) where {T}
     Bs = collect(blocks(t))
     inds = findall(!iszero ∘ last, Bs)
     isempty(inds) && return zero(scalartype(t))
@@ -18,7 +16,7 @@ end
 
 # no custom fuse: we choose to return empty graded space when fusion is forbidden
 
-function Base.oneunit(S::Vect[IsingBimod])
+function Base.oneunit(S::Vect[IsingBimodule])
     !isempty(sectors(S)) || throw(ArgumentError("Cannot determine type of empty space"))
     allequal(a.row for a in sectors(S)) && allequal(a.col for a in sectors(S)) ||
         throw(ArgumentError("sectors of $S are not all equal"))
@@ -28,18 +26,18 @@ function Base.oneunit(S::Vect[IsingBimod])
     return spacetype(S)(sector => 1)
 end
 
-Base.zero(S::Type{Vect[IsingBimod]}) = Vect[IsingBimod]()
+Base.zero(S::Type{Vect[IsingBimodule]}) = Vect[IsingBimodule]()
 
-function blocksectors(W::TensorMapSpace{Vect[IsingBimod],N₁,N₂}) where {N₁,N₂}
+function blocksectors(W::TensorMapSpace{Vect[IsingBimodule],N₁,N₂}) where {N₁,N₂}
     codom = codomain(W)
     dom = domain(W)
     if N₁ == 0 && N₂ == 0
-        return [IsingBimod(1, 1, 0), IsingBimod(2, 2, 0)]
+        return [IsingBimodule(1, 1, 0), IsingBimodule(2, 2, 0)]
     elseif N₁ == 0
-        @assert N₂ != 0 "one of Type IsingBimod doesn't exist"
+        @assert N₂ != 0 "one of Type IsingBimodule doesn't exist"
         return filter!(isone, collect(blocksectors(dom))) # is this what we want? doesn't allow M/Mop to end at empty space
     elseif N₂ == 0
-        @assert N₁ != 0 "one of Type IsingBimod doesn't exist"
+        @assert N₁ != 0 "one of Type IsingBimodule doesn't exist"
         return filter!(isone, collect(blocksectors(codom)))
     elseif N₂ <= N₁ # keep intersection
         return filter!(c -> hasblock(codom, c), collect(blocksectors(dom)))
@@ -48,7 +46,7 @@ function blocksectors(W::TensorMapSpace{Vect[IsingBimod],N₁,N₂}) where {N₁
     end
 end
 
-function rightoneunit(S::Vect[IsingBimod])
+function rightoneunit(S::Vect[IsingBimodule])
     !isempty(sectors(S)) || throw(ArgumentError("Cannot determine type of empty space"))
     allequal(a.col for a in sectors(S)) ||
         throw(ArgumentError("sectors of $S do not have the same rightone"))
@@ -57,7 +55,7 @@ function rightoneunit(S::Vect[IsingBimod])
     return spacetype(S)(sector => 1)
 end
 
-function leftoneunit(S::Vect[IsingBimod])
+function leftoneunit(S::Vect[IsingBimodule])
     !isempty(sectors(S)) || throw(ArgumentError("Cannot determine type of empty space"))
     allequal(a.row for a in sectors(S)) ||
         throw(ArgumentError("sectors of $S do not have the same leftone"))
@@ -66,7 +64,7 @@ function leftoneunit(S::Vect[IsingBimod])
     return spacetype(S)(sector => 1)
 end
 
-function insertrightunit(P::ProductSpace{Vect[IsingBimod],N}, ::Val{i};
+function insertrightunit(P::ProductSpace{Vect[IsingBimodule],N}, ::Val{i};
                          conj::Bool=false,
                          dual::Bool=false) where {i,N}
     i > N && error("cannot insert a sensible right unit onto $P at index $(i+1)")
@@ -82,7 +80,7 @@ function insertrightunit(P::ProductSpace{Vect[IsingBimod],N}, ::Val{i};
 end
 
 # TODO?: overwrite defaults at level of HomSpace and TensorMap?
-function insertleftunit(P::ProductSpace{Vect[IsingBimod],N}, ::Val{i}; # want no defaults?
+function insertleftunit(P::ProductSpace{Vect[IsingBimodule],N}, ::Val{i}; # want no defaults?
                         conj::Bool=false,
                         dual::Bool=false) where {i,N}
     i > N && error("cannot insert a sensible left unit onto $P at index $i") # do we want this to error in the diagonal case?
@@ -96,9 +94,9 @@ function insertleftunit(P::ProductSpace{Vect[IsingBimod],N}, ::Val{i}; # want no
     return ProductSpace(TupleTools.insertafter(P.spaces, i - 1, (u,)))
 end
 
-# is this even necessary? can let it error at fusiontrees.jl:93 from the one(IsingBimod) call
+# is this even necessary? can let it error at fusiontrees.jl:93 from the one(IsingBimodule) call
 # but these errors are maybe more informative
-function FusionTree(uncoupled::Tuple{IsingBimod,Vararg{IsingBimod}})
+function FusionTree(uncoupled::Tuple{IsingBimodule,Vararg{IsingBimodule}})
     coupled = collect(⊗(uncoupled...))
     if length(coupled) == 0 # illegal fusion somewhere
         throw(ArgumentError("Forbidden fusion with uncoupled sectors $uncoupled"))
@@ -108,6 +106,6 @@ function FusionTree(uncoupled::Tuple{IsingBimod,Vararg{IsingBimod}})
 end
 
 # this one might also be overkill, since `FusionTreeIterator`s don't check whether the fusion is allowed
-function fusiontrees(uncoupled::Tuple{IsingBimod,Vararg{IsingBimod}})
-    return throw(ArgumentError("coupled sector must be provided for IsingBimod fusion"))
+function fusiontrees(uncoupled::Tuple{IsingBimodule,Vararg{IsingBimodule}})
+    return throw(ArgumentError("coupled sector must be provided for IsingBimodule fusion"))
 end

test/multifusion.jl

@@ -1,4 +1,4 @@
-I = IsingBimod
+I = IsingBimodule
 Istr = TK.type_repr(I)
 
 println("------------------------------------")