fix tests

Author: ogauthe

NDTensors/src/lib/GradedAxes/ext/GradedAxesSectorsExt/Project.toml

@@ -1,8 +1,8 @@
 module GradedAxes
 include("blockedunitrange.jl")
 include("gradedunitrange.jl")
-include("gradedunitrangedual.jl")
 include("dual.jl")
+include("gradedunitrangedual.jl")
 include("unitrangedual.jl")
-include("../ext/GradedAxesSectorsExt/src/GradedAxesSectorsExt.jl")
+include("fusion.jl")
 end

NDTensors/src/lib/GradedAxes/ext/GradedAxesSectorsExt/src/GradedAxesSectorsExt.jl

@@ -6,3 +6,5 @@ using NDTensors.LabelledNumbers:
 label_dual(x) = label_dual(LabelledStyle(x), x)
 label_dual(::NotLabelled, x) = x
 label_dual(::IsLabelled, x) = labelled(unlabel(x), dual(label(x)))
+
+flip(g::AbstractGradedUnitRange) = dual(gradedrange(label_dual.(blocklengths(g))))

NDTensors/src/lib/GradedAxes/ext/GradedAxesSectorsExt/test/Project.toml

@@ -6,6 +6,10 @@ OneToOne() = OneToOne{Bool}()
 Base.first(a::OneToOne) = one(eltype(a))
 Base.last(a::OneToOne) = one(eltype(a))
 
+gradedisequal(::AbstractUnitRange, ::OneToOne) = false
+gradedisequal(::OneToOne, ::AbstractUnitRange) = false
+gradedisequal(::OneToOne, ::OneToOne) = true
+
 # https://github.com/ITensor/ITensors.jl/blob/v0.3.57/NDTensors/src/lib/GradedAxes/src/tensor_product.jl
 # https://en.wikipedia.org/wiki/Tensor_product
 # https://github.com/KeitaNakamura/Tensorial.jl
@@ -18,7 +22,7 @@ function tensor_product(
   return foldl(tensor_product, (a1, a2, a3, a_rest...))
 end
 
-function tensor_product(a1::AbstractUnitRange, a2::AbstractUnitRange)
+function tensor_product(::AbstractUnitRange, ::AbstractUnitRange)
   return error("Not implemented yet.")
 end
 
@@ -34,7 +38,7 @@ function tensor_product(a1::AbstractBlockedUnitRange, ::OneToOne)
   return a1
 end
 
-function tensor_product(a1::OneToOne, a2::OneToOne)
+function tensor_product(::OneToOne, ::OneToOne)
   return OneToOne()
 end
 
@@ -66,18 +70,20 @@ function fuse_blocklengths(x::LabelledInteger, y::LabelledInteger)
   return labelled(unlabel(x) * unlabel(y), fuse_labels(label(x), label(y)))
 end
 
+flatten_maybe_nested(v::Vector{<:Integer}) = v
+flatten_maybe_nested(v::Vector{<:AbstractGradedUnitRange}) = reduce(vcat, blocklengths.(v))
+
 using BlockArrays: blockedrange, blocks
 function tensor_product(a1::AbstractBlockedUnitRange, a2::AbstractBlockedUnitRange)
-  blocklengths = map(vec(collect(Iterators.product(blocks(a1), blocks(a2))))) do x
-    return mapreduce(length, fuse_blocklengths, x)
-  end
+  maybe_nested = map(
+    it -> mapreduce(length, fuse_blocklengths, it),
+    Iterators.flatten((Iterators.product(blocks(a1), blocks(a2)),)),
+  )
+  blocklengths = flatten_maybe_nested(maybe_nested)
   return blockedrange(blocklengths)
 end
 
 function blocksortperm(a::AbstractBlockedUnitRange)
-  # TODO: Figure out how to deal with dual sectors.
-  # TODO: `rev=isdual(a)`  may not be correct for symmetries beyond `U(1)`.
-  ## return Block.(sortperm(nondual_sectors(a); rev=isdual(a)))
   return Block.(sortperm(blocklabels(a)))
 end
 
@@ -101,12 +107,6 @@ end
 # Get the permutation for sorting, then group by common elements.
 # groupsortperm([2, 1, 2, 3]) == [[2], [1, 3], [4]]
 function blockmergesortperm(a::AbstractBlockedUnitRange)
-  # If it is dual, reverse the sorting so the sectors
-  # end up sorted in the same way whether or not the space
-  # is dual.
-  # TODO: Figure out how to deal with dual sectors.
-  # TODO: `rev=isdual(a)`  may not be correct for symmetries beyond `U(1)`.
-  ## return Block.(groupsortperm(nondual_sectors(a); rev=isdual(a)))
   return Block.(groupsortperm(blocklabels(a)))
 end
 

NDTensors/src/lib/GradedAxes/ext/GradedAxesSectorsExt/test/runtests.jl

@@ -12,7 +12,7 @@ using BlockArrays:
   blockedrange,
   BlockIndexRange,
   blockfirsts,
-  blocklasts,
+  blockisequal,
   blocklength,
   blocklengths,
   findblock,
@@ -37,6 +37,11 @@ function Base.OrdinalRange{T,T}(a::GradedOneTo{<:LabelledInteger{T}}) where {T}
   return unlabel_blocks(a)
 end
 
+# == is just a range comparison that ignores labels. Need dedicated function to check equality.
+function gradedisequal(a1::AbstractUnitRange, a2::AbstractUnitRange)
+  return blockisequal(a1, a2) && (blocklabels(a1) == blocklabels(a2))
+end
+
 # This is only needed in certain Julia versions below 1.10
 # (for example Julia 1.6).
 # TODO: Delete this once we drop Julia 1.6 support.

NDTensors/src/lib/GradedAxes/src/GradedAxes.jl

@@ -91,9 +91,17 @@ end
   ad = dual(a)
   @test ad isa GradedUnitRangeDual
   @test eltype(ad) == LabelledInteger{Int,U1}
-  @test dual(ad) == a
-  @test nondual(ad) == a
-  @test nondual(a) == a
+
+  @test gradedisequal(dual(ad), a)
+  @test gradedisequal(nondual(ad), a)
+  @test gradedisequal(nondual(a), a)
+  @test gradedisequal(ad, ad)
+  @test !gradedisequal(a, ad)
+  @test !gradedisequal(ad, a)
+
+  @test isdual(ad)
+  @test !isdual(a)
+
   @test blockfirsts(ad) == [labelled(1, U1(0)), labelled(3, U1(-1))]
   @test blocklasts(ad) == [labelled(2, U1(0)), labelled(5, U1(-1))]
   @test blocklength(ad) == 2