Fixes for GradedArrays.jl v0.5

Author: mtfishman

Project.toml

@@ -1,7 +1,7 @@
 name = "FusionTensors"
 uuid = "e16ca583-1f51-4df0-8e12-57d32947d33e"
 authors = ["ITensor developers <[email protected]> and contributors"]
-version = "0.5.14"
+version = "0.5.15"
 
 [deps]
 Accessors = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697"
@@ -22,7 +22,7 @@ WignerSymbols = "9f57e263-0b3d-5e2e-b1be-24f2bb48858b"
 Accessors = "0.1.42"
 BlockArrays = "1.7"
 BlockSparseArrays = "0.10"
-GradedArrays = "0.4, 0.5"
+GradedArrays = "0.5"
 HalfIntegers = "1.6"
 LRUCache = "1.6"
 LinearAlgebra = "1.10"

src/fusion_trees/clebsch_gordan_tensors.jl

@@ -7,10 +7,10 @@ using WignerSymbols: clebschgordan
 
 using GradedArrays:
     AbelianStyle,
-    AbstractSector,
     NotAbelianStyle,
     O2,
-    SU,
+    SU2,
+    SectorRange,
     SymmetryStyle,
     dual,
     istrivial,
@@ -22,15 +22,15 @@ using GradedArrays:
 using TensorAlgebra: contract
 using TensorProducts: ⊗
 
-function symbol_1j(s::AbstractSector)
+function symbol_1j(s::SectorRange)
     cgt = clebsch_gordan_tensor(s, dual(s), trivial(s), 1)
     return sqrt(quantum_dimension(s)) * cgt[:, :, 1]
 end
 
 function clebsch_gordan_tensor(
-        s1::AbstractSector,
-        s2::AbstractSector,
-        s3::AbstractSector,
+        s1::SectorRange,
+        s2::SectorRange,
+        s3::SectorRange,
         arrow1::Bool,
         arrow2::Bool,
         inner_mult_index::Int,
@@ -104,11 +104,11 @@ function clebsch_gordan_tensor(s1::O2, s2::O2, s3::O2)
     return cgt
 end
 
-function clebsch_gordan_tensor(::NotAbelianStyle, s1::SU{2}, s2::SU{2}, s3::SU{2}, ::Int)
+function clebsch_gordan_tensor(::NotAbelianStyle, s1::SU2, s2::SU2, s3::SU2, ::Int)
     return clebsch_gordan_tensor(s1, s2, s3)  # no outer multiplicity
 end
 
-function clebsch_gordan_tensor(s1::SU{2}, s2::SU{2}, s3::SU{2})
+function clebsch_gordan_tensor(s1::SU2, s2::SU2, s3::SU2)
     d1 = quantum_dimension(s1)
     d2 = quantum_dimension(s2)
     d3 = quantum_dimension(s3)
@@ -125,13 +125,14 @@ function clebsch_gordan_tensor(s1::SU{2}, s2::SU{2}, s3::SU{2})
     return cgtensor
 end
 
-function clebsch_gordan_tensor(
-        ::NotAbelianStyle, s1::SU{3}, s2::SU{3}, s3::SU{3}, outer_mult_index::Int
-    )
-    d1 = quantum_dimension(s1)
-    d2 = quantum_dimension(s2)
-    d3 = quantum_dimension(s3)
-    cgtensor = zeros(d1, d2, d3)
-    # dummy
-    return cgtensor
-end
+## TODO: Implement and move to `FusionTensorsSUNRepresentationsExt`.
+## function clebsch_gordan_tensor(
+##         ::NotAbelianStyle, s1::SU{3}, s2::SU{3}, s3::SU{3}, outer_mult_index::Int
+##     )
+##     d1 = quantum_dimension(s1)
+##     d2 = quantum_dimension(s2)
+##     d3 = quantum_dimension(s3)
+##     cgtensor = zeros(d1, d2, d3)
+##     # dummy
+##     return cgtensor
+## end

src/fusion_trees/fusiontree.jl

@@ -5,17 +5,18 @@
 
 using GradedArrays:
     GradedArrays,
-    ×,
     AbstractGradedUnitRange,
-    AbstractSector,
-    SectorProduct,
+    SectorProductRange,
+    SectorRange,
+    ×,
     arguments,
     flip,
     flip_dual,
     isdual,
     nsymbol,
     sector_multiplicities,
     sector_type,
+    sectorproduct,
     sectors,
     to_gradedrange,
     trivial
@@ -125,7 +126,7 @@ function GradedArrays.:×(f1::SectorFusionTree, f2::SectorFusionTree)
     )
 end
 
-function GradedArrays.arguments(f::SectorFusionTree{<:SectorProduct})
+function GradedArrays.arguments(f::SectorFusionTree{<:SectorProductRange})
     transposed_indices = outer_multiplicity_split.(
         Base.tail(leaves(f)),
         branch_sectors(f),
@@ -136,7 +137,7 @@ function GradedArrays.arguments(f::SectorFusionTree{<:SectorProduct})
     arguments_leaves = arguments.(leaves(f))
     arguments_branch_sectors = arguments.(branch_sectors(f))
     # TODO way to avoid explicit ntuple?
-    # works fine for Tuple and NamedTuple SectorProduct
+    # works fine for Tuple and NamedTuple SectorProductRange
     return ntuple(
         i -> SectorFusionTree(
             getindex.(arguments_leaves, i),
@@ -149,21 +150,21 @@ function GradedArrays.arguments(f::SectorFusionTree{<:SectorProduct})
     )
 end
 
-function GradedArrays.arguments(f::SectorFusionTree{<:SectorProduct, 0})
+function GradedArrays.arguments(f::SectorFusionTree{<:SectorProductRange, 0})
     return map(arg -> SectorFusionTree((), (), arg, (), ()), arguments(root_sector(f)))
 end
 
-function GradedArrays.arguments(f::SectorFusionTree{<:SectorProduct, 1})
+function GradedArrays.arguments(f::SectorFusionTree{<:SectorProductRange, 1})
     arguments_root = arguments(root_sector(f))
     arguments_leave = arguments(only(leaves(f)))
-    # use map(keys) to stay agnostic with respect to SectorProduct implementation
+    # use map(keys) to stay agnostic with respect to SectorProductRange implementation
     return map(keys(arguments_root)) do k
         return SectorFusionTree((arguments_leave[k],), arrows(f), arguments_root[k], (), ())
     end
 end
 
 # TBD change type depending on AbelianStyle?
-fusiontree_eltype(::Type{<:AbstractSector}) = Float64
+fusiontree_eltype(::Type{<:SectorRange}) = Float64
 
 # constructors
 function build_trees(legs::Vararg{AbstractGradedUnitRange})
@@ -175,7 +176,7 @@ function build_trees(legs::Vararg{AbstractGradedUnitRange})
 end
 
 function build_trees(
-        sectors_to_fuse::NTuple{N, <:AbstractSector}, arrows_to_fuse::NTuple{N, Bool}
+        sectors_to_fuse::NTuple{N, <:SectorRange}, arrows_to_fuse::NTuple{N, Bool}
     ) where {N}
     # construct all authorized trees with fixed outer sectors
     trees = [SectorFusionTree(first(sectors_to_fuse), first(arrows_to_fuse))]
@@ -186,18 +187,18 @@ end
 # =====================================  Internals  ========================================
 #
 
-# --------------- SectorProduct helper functions  ---------------
+# --------------- SectorProductRange helper functions  ---------------
 function outer_multiplicity_kron(
         sec1, sec2, fused, outer_multiplicity1, outer_multiplicity2
     )
-    n = nsymbol(sec1, sec2, fused)
+    n = Int(nsymbol(sec1, sec2, fused))
     linear_inds = LinearIndices((n, outer_multiplicity2))
     return linear_inds[outer_multiplicity1, outer_multiplicity2]
 end
 
 function outer_multiplicity_split(
         sec1::S, sec2::S, fused::S, outer_mult_index::Integer
-    ) where {S <: SectorProduct}
+    ) where {S <: SectorProductRange}
     args1 = arguments(sec1)
     args2 = arguments(sec2)
     args12 = arguments(fused)
@@ -207,15 +208,15 @@ end
 
 # --------------- Build trees  ---------------
 # zero leg: need S to get sector type information
-function SectorFusionTree{S}() where {S <: AbstractSector}
+function SectorFusionTree{S}() where {S <: SectorRange}
     return SectorFusionTree((), (), trivial(S), (), ())
 end
-function SectorFusionTree{S}(::Tuple{}, ::Tuple{}) where {S <: AbstractSector}
+function SectorFusionTree{S}(::Tuple{}, ::Tuple{}) where {S <: SectorRange}
     return SectorFusionTree((), (), trivial(S), (), ())
 end
 
 # one leg
-function SectorFusionTree(sect::AbstractSector, arrow::Bool)
+function SectorFusionTree(sect::SectorRange, arrow::Bool)
     return SectorFusionTree((sect,), (arrow,), sect, (), ())
 end
 
@@ -227,7 +228,7 @@ end
 
 function append_tree_leave(
         parent_tree::SectorFusionTree,
-        branch_sector::AbstractSector,
+        branch_sector::SectorRange,
         level_arrow::Bool,
         child_root_sector,
         outer_mult,
@@ -242,7 +243,7 @@ function append_tree_leave(
 end
 
 function fuse_next_sector(
-        parent_tree::SectorFusionTree, branch_sector::AbstractSector, level_arrow::Bool
+        parent_tree::SectorFusionTree, branch_sector::SectorRange, level_arrow::Bool
     )
     new_space = to_gradedrange(root_sector(parent_tree) ⊗ branch_sector)
     return mapreduce(
@@ -282,7 +283,7 @@ function to_array(f::SectorFusionTree)
     return grow_tensor_tree(tree_tensor, f)
 end
 
-function to_array(f::SectorFusionTree{<:SectorProduct})
+function to_array(f::SectorFusionTree{<:SectorProductRange})
     args = convert.(Array, arguments(f))
     return reduce(_tensor_kron, args)
 end

src/fusiontensor/fusiontensor.jl

@@ -6,7 +6,7 @@ using BlockSparseArrays:
     AbstractBlockSparseMatrix, BlockSparseArray, eachblockstoredindex, to_block_indices
 using GradedArrays:
     AbstractGradedUnitRange,
-    SectorProduct,
+    SymmetryStyle,
     TrivialSector,
     dual,
     findfirstblock,
@@ -35,7 +35,7 @@ function flip_domain(nonflipped_col_axis, nonflipped_trees_to_ranges)
     return col_axis, domain_trees_to_ranges_mapping
 end
 
-function fuse_axes(::Type{S}, ::Tuple{}) where {S <: AbstractSector}
+function fuse_axes(::Type{S}, ::Tuple{}) where {S <: SectorRange}
     fused_axis = trivial_axis(S)
     trees_to_ranges_mapping = Dict([SectorFusionTree{S}() => Block(1)[1:1]])
     return fused_axis, trees_to_ranges_mapping
@@ -253,7 +253,9 @@ function GradedArrays.sector_type(::Type{FT}) where {FT <: FusionTensor}
     return sector_type(type_parameters(FT, 3))
 end
 
-SymmetryStyle(::Type{FT}) where {FT <: FusionTensor} = SymmetryStyle(sector_type(FT))
+function GradedArrays.SymmetryStyle(::Type{FT}) where {FT <: FusionTensor}
+    return SymmetryStyle(sector_type(FT))
+end
 
 # ==============================  FusionTensor interface  ==================================
 

src/fusiontensor/fusiontensoraxes.jl

@@ -2,7 +2,6 @@ using BlockArrays: BlockArrays
 using GradedArrays:
     GradedArrays,
     AbstractGradedUnitRange,
-    AbstractSector,
     SymmetryStyle,
     TrivialSector,
     dual,

test/Project.toml

@@ -6,6 +6,7 @@ FusionTensors = "e16ca583-1f51-4df0-8e12-57d32947d33e"
 GradedArrays = "bc96ca6e-b7c8-4bb6-888e-c93f838762c2"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+SUNRepresentations = "1a50b95c-7aac-476d-a9ce-2bfc675fc617"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
 Suppressor = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
 TensorAlgebra = "68bd88dc-f39d-4e12-b2ca-f046b68fcc6a"
@@ -17,9 +18,10 @@ Aqua = "0.8.11"
 BlockArrays = "1.6"
 BlockSparseArrays = "0.10"
 FusionTensors = "0.5"
-GradedArrays = "0.4, 0.5"
+GradedArrays = "0.5"
 LinearAlgebra = "1.10.0"
 Random = "1.10"
+SUNRepresentations = "0.3.1"
 SafeTestsets = "0.1.0"
 Suppressor = "0.2.8"
 TensorAlgebra = "0.4"

test/test_array_cast.jl

@@ -4,7 +4,7 @@ using Test: @test, @test_throws, @testset
 using BlockArrays: Block, BlockedArray, blocksize
 
 using FusionTensors: FusionTensor, data_matrix, to_fusiontensor
-using GradedArrays: O2, SectorProduct, SU2, TrivialSector, U1, dual, gradedrange
+using GradedArrays: O2, SU2, TrivialSector, U1, dual, gradedrange, sectorproduct
 using TensorProducts: tensor_product
 
 include("setup.jl")
@@ -389,20 +389,21 @@ end
             tRVB[i, 1, 1, 1, i + 1] = 1.0
         end
 
-        gd = gradedrange([SectorProduct(s, U1(3)) => 1])
+        gd = gradedrange([sectorproduct(s, U1(3)) => 1])
         codomain_legs = (dual(gd),)
-        gD = gradedrange([SectorProduct(SU2(0), U1(1)) => 1, SectorProduct(s, U1(0)) => 1])
+        gD = gradedrange([sectorproduct(SU2(0), U1(1)) => 1, sectorproduct(s, U1(0)) => 1])
         domain_legs = (gD, gD, gD, gD)
         ft = to_fusiontensor(tRVB, codomain_legs, domain_legs)
         @test isnothing(check_sanity(ft))
         @test Array(ft) ≈ tRVB
 
         # same with NamedTuples
-        gd_nt = gradedrange([SectorProduct(; S = s, N = U1(3)) => 1])
+        gd_nt = gradedrange([sectorproduct((; S = s, N = U1(3))) => 1])
         codomain_legs_nt = (dual(gd_nt),)
         gD_nt = gradedrange(
             [
-                SectorProduct(; S = SU2(0), N = U1(1)) => 1, SectorProduct(; S = s, N = U1(0)) => 1,
+                sectorproduct((; S = SU2(0), N = U1(1))) => 1,
+                sectorproduct((; S = s, N = U1(0))) => 1,
             ]
         )
         domain_legs_nt = (gD_nt, gD_nt, gD_nt, gD_nt)