diff --git a/Project.toml b/Project.toml
index ca04395..cf8f4cd 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,7 +1,7 @@
 name = "GradedUnitRanges"
 uuid = "e2de450a-8a67-46c7-b59c-01d5a3d041c5"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
-version = "0.1.6"
+version = "0.2.0"
 
 [deps]
 BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
diff --git a/src/GradedUnitRanges.jl b/src/GradedUnitRanges.jl
index e675bc4..748ca77 100644
--- a/src/GradedUnitRanges.jl
+++ b/src/GradedUnitRanges.jl
@@ -5,8 +5,6 @@ export gradedrange
 include("blockedunitrange.jl")
 include("gradedunitrange.jl")
 include("dual.jl")
-include("labelledunitrangedual.jl")
-include("gradedunitrangedual.jl")
 include("onetoone.jl")
 include("fusion.jl")
 
diff --git a/src/dual.jl b/src/dual.jl
index d9f0be6..800bafe 100644
--- a/src/dual.jl
+++ b/src/dual.jl
@@ -8,17 +8,20 @@ By default, it just returns `x`, i.e. it assumes the object
 is self-dual.
 """
 dual(x) = x
+isdual(x) = isdual(typeof(x))
+isdual(::Type) = false
 
-nondual(r::AbstractUnitRange) = r
-isdual(::AbstractUnitRange) = false
-
-dual_type(x) = dual_type(typeof(x))
 dual_type(T::Type) = T
-nondual_type(x) = nondual_type(typeof(x))
-nondual_type(T::Type) = T
+nondual_type(T::Type) = isdual(T) ? dual_type(T) : T
+nondual(r::AbstractUnitRange) = map_blocklabels(nondual, r)
+isdual(R::Type{<:AbstractUnitRange}) = isdual(eltype(R))
+isdual(L::Type{<:LabelledInteger}) = isdual(label_type(L))
 
 dual(i::LabelledInteger) = labelled(unlabel(i), dual(label(i)))
-flip(a::AbstractUnitRange) = dual(map_blocklabels(dual, a))
+dual(a::AbstractUnitRange) = map_blocklabels(dual, a)
+flip(a::AbstractUnitRange) = map_blocklabels(flip, a)
+
+flip_dual(x) = isdual(x) ? flip(x) : x
 
 """
     dag(r::AbstractUnitRange)
diff --git a/src/fusion.jl b/src/fusion.jl
index 14ea931..32ecb41 100644
--- a/src/fusion.jl
+++ b/src/fusion.jl
@@ -15,7 +15,6 @@ function tensor_product(
 end
 
 flip_dual(r::AbstractUnitRange) = r
-flip_dual(r::GradedUnitRangeDual) = flip(r)
 function tensor_product(a1::AbstractUnitRange, a2::AbstractUnitRange)
   return tensor_product(flip_dual(a1), flip_dual(a2))
 end
@@ -93,7 +92,6 @@ function blockmergesort(g::AbstractGradedUnitRange)
   return gradedrange(new_blocklengths)
 end
 
-blockmergesort(g::GradedUnitRangeDual) = flip(blockmergesort(flip(g)))
 blockmergesort(g::AbstractUnitRange) = g
 
 # fusion_product produces a sorted, non-dual GradedUnitRange
@@ -102,7 +100,6 @@ function fusion_product(g1, g2)
 end
 
 fusion_product(g::AbstractUnitRange) = blockmergesort(g)
-fusion_product(g::GradedUnitRangeDual) = fusion_product(flip(g))
 
 # recursive fusion_product. Simpler than reduce + fix type stability issues with reduce
 function fusion_product(g1, g2, g3...)
diff --git a/src/gradedunitrange.jl b/src/gradedunitrange.jl
index 6980e22..18ca4db 100644
--- a/src/gradedunitrange.jl
+++ b/src/gradedunitrange.jl
@@ -9,6 +9,7 @@ using BlockArrays:
   BlockedUnitRange,
   block,
   blockedrange,
+  blockfirsts,
   blockisequal,
   blocklasts,
   blocklength,
@@ -72,10 +73,6 @@ function LabelledNumbers.labelled_isequal(a1::AbstractUnitRange, a2::AbstractUni
   return blockisequal(a1, a2) && (blocklabels(a1) == blocklabels(a2))
 end
 
-function space_isequal(a1::AbstractUnitRange, a2::AbstractUnitRange)
-  return (isdual(a1) == isdual(a2)) && labelled_isequal(a1, a2)
-end
-
 # needed in BlockSparseArrays
 function Base.AbstractUnitRange{T}(
   a::AbstractGradedUnitRange{<:LabelledInteger{T}}
@@ -95,8 +92,9 @@ LabelledNumbers.label_type(T::Type{<:AbstractGradedUnitRange}) = label_type(elty
 to_sector(x) = x
 
 sector_type(x) = sector_type(typeof(x))
-sector_type(T::Type) = error("Not implemented")
-sector_type(T::Type{<:AbstractUnitRange}) = label_type(T)
+sector_type(::Type) = error("Not implemented")
+sector_type(T::Type{<:AbstractUnitRange}) = sector_type(eltype(T))
+sector_type(T::Type{<:LabelledInteger}) = nondual_type(label_type(T))
 
 # To help with generic code.
 function BlockArrays.blockedrange(lblocklengths::AbstractVector{<:LabelledInteger})
diff --git a/src/gradedunitrangedual.jl b/src/gradedunitrangedual.jl
deleted file mode 100644
index 2983cb7..0000000
--- a/src/gradedunitrangedual.jl
+++ /dev/null
@@ -1,155 +0,0 @@
-using BlockArrays:
-  BlockArrays,
-  BlockIndex,
-  BlockIndexRange,
-  BlockSlice,
-  BlockVector,
-  blockaxes,
-  blockfirsts,
-  combine_blockaxes
-using LabelledNumbers: LabelledNumbers, LabelledUnitRange, label_type, unlabel
-
-struct GradedUnitRangeDual{
-  T,BlockLasts,NondualUnitRange<:AbstractGradedUnitRange{T,BlockLasts}
-} <: AbstractGradedUnitRange{T,BlockLasts}
-  nondual_unitrange::NondualUnitRange
-end
-
-dual(a::AbstractGradedUnitRange) = GradedUnitRangeDual(a)
-nondual(a::GradedUnitRangeDual) = a.nondual_unitrange
-dual(a::GradedUnitRangeDual) = nondual(a)
-flip(a::GradedUnitRangeDual) = dual(flip(nondual(a)))
-isdual(::GradedUnitRangeDual) = true
-
-function nondual_type(
-  ::Type{<:GradedUnitRangeDual{<:Any,<:Any,NondualUnitRange}}
-) where {NondualUnitRange}
-  return NondualUnitRange
-end
-dual_type(T::Type{<:GradedUnitRangeDual}) = nondual_type(T)
-function dual_type(type::Type{<:AbstractGradedUnitRange{T,BlockLasts}}) where {T,BlockLasts}
-  return GradedUnitRangeDual{T,BlockLasts,type}
-end
-function LabelledNumbers.label_type(type::Type{<:GradedUnitRangeDual})
-  # `dual_type` right now doesn't do anything but anticipates defining `SectorDual`.
-  return dual_type(label_type(nondual_type(type)))
-end
-
-## TODO: Define this to instantiate a dual unit range.
-## materialize_dual(a::GradedUnitRangeDual) = materialize_dual(nondual(a))
-
-Base.first(a::GradedUnitRangeDual) = dual(first(nondual(a)))
-Base.last(a::GradedUnitRangeDual) = dual(last(nondual(a)))
-Base.step(a::GradedUnitRangeDual) = dual(step(nondual(a)))
-
-Base.view(a::GradedUnitRangeDual, index::Block{1}) = a[index]
-
-function blockedunitrange_getindices(
-  a::GradedUnitRangeDual, indices::AbstractUnitRange{<:Integer}
-)
-  return dual(getindex(nondual(a), indices))
-end
-
-function blockedunitrange_getindices(a::GradedUnitRangeDual, indices::Integer)
-  return dual(getindex(nondual(a), indices))
-end
-
-function blockedunitrange_getindices(a::GradedUnitRangeDual, indices::Block{1})
-  return dual(getindex(nondual(a), indices))
-end
-
-function blockedunitrange_getindices(a::GradedUnitRangeDual, indices::BlockRange)
-  return dual(getindex(nondual(a), indices))
-end
-
-function blockedunitrange_getindices(a::GradedUnitRangeDual, indices::BlockIndexRange{1})
-  return dual(nondual(a)[indices])
-end
-
-# fix ambiguity
-function blockedunitrange_getindices(
-  a::GradedUnitRangeDual, indices::BlockRange{1,<:Tuple{AbstractUnitRange{Int}}}
-)
-  return dual(getindex(nondual(a), indices))
-end
-
-function BlockArrays.blocklengths(a::GradedUnitRangeDual)
-  return dual.(blocklengths(nondual(a)))
-end
-
-# TODO: Move this to a `BlockArraysExtensions` library.
-function blockedunitrange_getindices(
-  a::GradedUnitRangeDual, indices::Vector{<:BlockIndexRange{1}}
-)
-  # dual v axes to stay consistent with other cases where axes(v) are used
-  return dual_axes(blockedunitrange_getindices(nondual(a), indices))
-end
-
-function blockedunitrange_getindices(
-  a::GradedUnitRangeDual,
-  indices::BlockVector{<:BlockIndex{1},<:Vector{<:BlockIndexRange{1}}},
-)
-  # dual v axis to preserve dual information
-  # axes(v) will appear in axes(view(::BlockSparseArray, [Block(1)[1:1]]))
-  return dual_axes(blockedunitrange_getindices(nondual(a), indices))
-end
-
-function blockedunitrange_getindices(
-  a::GradedUnitRangeDual, indices::AbstractVector{<:Union{Block{1},BlockIndexRange{1}}}
-)
-  # dual v axis to preserve dual information
-  # axes(v) will appear in axes(view(::BlockSparseArray, [Block(1)]))
-  return dual_axes(blockedunitrange_getindices(nondual(a), indices))
-end
-
-# Fixes ambiguity error.
-function blockedunitrange_getindices(
-  a::GradedUnitRangeDual, indices::AbstractBlockVector{<:Block{1}}
-)
-  v = blockedunitrange_getindices(nondual(a), indices)
-  # v elements are not dualled by dual_axes due to different structure.
-  # take element dual here.
-  return dual_axes(dual.(v))
-end
-
-function dual_axes(v::BlockVector)
-  # dual both v elements and v axes
-  block_axes = dual.(axes(v))
-  return mortar(dual.(blocks(v)), block_axes)
-end
-
-Base.axes(a::GradedUnitRangeDual) = dual.(axes(nondual(a)))
-
-function BlockArrays.BlockSlice(b::Block, a::LabelledUnitRange)
-  return BlockSlice(b, unlabel(a))
-end
-
-function BlockArrays.BlockSlice(b::Block, r::GradedUnitRangeDual)
-  return BlockSlice(b, dual(r))
-end
-
-function Base.iterate(a::GradedUnitRangeDual, i)
-  i == last(a) && return nothing
-  return dual.(iterate(nondual(a), i))
-end
-
-BlockArrays.blockaxes(a::GradedUnitRangeDual) = blockaxes(nondual(a))
-BlockArrays.blockfirsts(a::GradedUnitRangeDual) = dual.(blockfirsts(nondual(a)))
-BlockArrays.blocklasts(a::GradedUnitRangeDual) = dual.(blocklasts(nondual(a)))
-function BlockArrays.findblock(a::GradedUnitRangeDual, index::Integer)
-  return findblock(nondual(a), index)
-end
-
-blocklabels(a::GradedUnitRangeDual) = dual.(blocklabels(nondual(a)))
-
-function BlockArrays.combine_blockaxes(a1::GradedUnitRangeDual, a2::GradedUnitRangeDual)
-  return dual(combine_blockaxes(nondual(a1), nondual(a2)))
-end
-
-function unlabel_blocks(a::GradedUnitRangeDual)
-  return unlabel_blocks(nondual(a))
-end
-
-function map_blocklabels(f, g::GradedUnitRangeDual)
-  return dual(map_blocklabels(f, dual(g)))
-end
diff --git a/src/labelledunitrangedual.jl b/src/labelledunitrangedual.jl
deleted file mode 100644
index 51f0164..0000000
--- a/src/labelledunitrangedual.jl
+++ /dev/null
@@ -1,66 +0,0 @@
-using LabelledNumbers:
-  LabelledNumbers, IsLabelled, LabelledUnitRange, label, label_type, unlabel
-
-# LabelledUnitRangeDual is obtained by slicing a GradedUnitRangeDual with a block
-
-struct LabelledUnitRangeDual{T,NondualUnitRange<:AbstractUnitRange{T}} <:
-       AbstractUnitRange{T}
-  nondual_unitrange::NondualUnitRange
-end
-
-dual(a::LabelledUnitRange) = LabelledUnitRangeDual(a)
-nondual(a::LabelledUnitRangeDual) = a.nondual_unitrange
-dual(a::LabelledUnitRangeDual) = nondual(a)
-isdual(::LabelledUnitRangeDual) = true
-blocklabels(la::LabelledUnitRangeDual) = [label(la)]
-
-map_blocklabels(f, la::LabelledUnitRange) = labelled(unlabel(la), f(label(la)))
-map_blocklabels(f, lad::LabelledUnitRangeDual) = dual(map_blocklabels(f, nondual(lad)))
-
-function nondual_type(
-  ::Type{<:LabelledUnitRangeDual{<:Any,NondualUnitRange}}
-) where {NondualUnitRange}
-  return NondualUnitRange
-end
-dual_type(T::Type{<:LabelledUnitRangeDual}) = nondual_type(T)
-function dual_type(T::Type{<:LabelledUnitRange})
-  return LabelledUnitRangeDual{eltype(T),T}
-end
-
-LabelledNumbers.label(a::LabelledUnitRangeDual) = dual(label(nondual(a)))
-LabelledNumbers.unlabel(a::LabelledUnitRangeDual) = unlabel(nondual(a))
-LabelledNumbers.LabelledStyle(::LabelledUnitRangeDual) = IsLabelled()
-function LabelledNumbers.label_type(type::Type{<:LabelledUnitRangeDual})
-  # `dual_type` right now doesn't do anything but anticipates defining `SectorDual`.
-  return dual_type(label_type(nondual_type(type)))
-end
-
-for f in [:first, :getindex, :last, :length, :step]
-  @eval Base.$f(a::LabelledUnitRangeDual, args...) =
-    labelled($f(unlabel(a), args...), label(a))
-end
-
-# fix ambiguities
-Base.getindex(a::LabelledUnitRangeDual, i::Integer) = dual(nondual(a)[i])
-function Base.getindex(a::LabelledUnitRangeDual, indices::AbstractUnitRange{<:Integer})
-  return dual(nondual(a)[indices])
-end
-
-function Base.iterate(a::LabelledUnitRangeDual, i)
-  i == last(a) && return nothing
-  next = convert(eltype(a), labelled(i + step(a), label(a)))
-  return (next, next)
-end
-
-function Base.show(io::IO, ::MIME"text/plain", a::LabelledUnitRangeDual)
-  println(io, typeof(a))
-  return print(io, label(a), " => ", unlabel(a))
-end
-
-function Base.show(io::IO, a::LabelledUnitRangeDual)
-  return print(io, nameof(typeof(a)), " ", label(a), " => ", unlabel(a))
-end
-
-function Base.AbstractUnitRange{T}(a::LabelledUnitRangeDual) where {T}
-  return AbstractUnitRange{T}(nondual(a))
-end
diff --git a/test/Project.toml b/test/Project.toml
index 062f1b4..eb91f45 100644
--- a/test/Project.toml
+++ b/test/Project.toml
@@ -7,6 +7,7 @@ LabelledNumbers = "f856a3a6-4152-4ec4-b2a7-02c1a55d7993"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
 Suppressor = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+TypeParameterAccessors = "7e5a90cf-f82e-492e-a09b-e3e26432c138"
 
 [compat]
 Aqua = "0.8.9"
diff --git a/test/test_basics.jl b/test/test_basics.jl
index cbd9bc4..524a4b2 100644
--- a/test/test_basics.jl
+++ b/test/test_basics.jl
@@ -19,7 +19,7 @@ using GradedUnitRanges:
   blocklabels,
   gradedrange,
   sector_type,
-  space_isequal
+  labelled_isequal
 using LabelledNumbers:
   LabelledUnitRange, islabelled, label, labelled, labelled_isequal, unlabel
 using Test: @test, @test_broken, @testset
@@ -110,7 +110,7 @@ end
     b = combine_blockaxes(a, a)
     @test b isa GradedOneTo
     @test b == 1:5
-    @test space_isequal(b, a)
+    @test labelled_isequal(b, a)
   end
 
   # Slicing operations
diff --git a/test/test_dual.jl b/test/test_dual.jl
index 88623e6..09cfa44 100644
--- a/test/test_dual.jl
+++ b/test/test_dual.jl
@@ -17,38 +17,48 @@ using BlockSparseArrays: BlockSparseArray
 using GradedUnitRanges:
   AbstractGradedUnitRange,
   GradedUnitRanges,
-  GradedUnitRangeDual,
-  LabelledUnitRangeDual,
   OneToOne,
   blocklabels,
   blockmergesortperm,
   blocksortperm,
   dag,
   dual,
-  dual_type,
   flip,
   gradedrange,
   isdual,
   nondual,
-  nondual_type,
-  space_isequal,
   sector_type
 using LabelledNumbers:
   LabelledInteger, LabelledUnitRange, label, label_type, labelled, labelled_isequal, unlabel
 using Test: @test, @test_broken, @testset
+using TypeParameterAccessors: unspecify_type_parameters
+
 struct U1
   n::Int
 end
-GradedUnitRanges.dual(c::U1) = U1(-c.n)
+struct DualU1
+  nondual::U1
+end
+GradedUnitRanges.nondual(s::U1) = s
+GradedUnitRanges.nondual(s::DualU1) = s.nondual
+GradedUnitRanges.dual(s::U1) = DualU1(s)
+GradedUnitRanges.dual(s::DualU1) = nondual(s)
+GradedUnitRanges.flip(s::U1) = DualU1(U1(-s.n))
+GradedUnitRanges.flip(s::DualU1) = U1(-nondual(s).n)
+GradedUnitRanges.isdual(::Type{DualU1}) = true
+GradedUnitRanges.sector_type(::Type{U1}) = U1
+GradedUnitRanges.sector_type(::Type{DualU1}) = U1
+GradedUnitRanges.dual_type(::Type{DualU1}) = U1
+GradedUnitRanges.dual_type(::Type{U1}) = DualU1
 Base.isless(c1::U1, c2::U1) = c1.n < c2.n
+Base.isless(c1::DualU1, c2::DualU1) = nondual(c1) < nondual(c2)
 
 @testset "AbstractUnitRange" begin
   a0 = OneToOne()
   @test !isdual(a0)
   @test dual(a0) isa OneToOne
-  @test space_isequal(a0, a0)
   @test labelled_isequal(a0, a0)
-  @test space_isequal(a0, dual(a0))
+  @test labelled_isequal(a0, dual(a0))
 
   a = 1:3
   ad = dual(a)
@@ -59,8 +69,8 @@ Base.isless(c1::U1, c2::U1) = c1.n < c2.n
   @test !isdual(af)
   @test ad isa UnitRange
   @test af isa UnitRange
-  @test space_isequal(ad, a)
-  @test space_isequal(af, a)
+  @test labelled_isequal(ad, a)
+  @test labelled_isequal(af, a)
 
   a = blockedrange([2, 3])
   ad = dual(a)
@@ -73,122 +83,24 @@ Base.isless(c1::U1, c2::U1) = c1.n < c2.n
   @test blockisequal(af, a)
 end
 
-@testset "LabelledUnitRangeDual" begin
-  la = labelled(1:2, U1(1))
-  @test la isa LabelledUnitRange
-  @test label(la) == U1(1)
-  @test blocklabels(la) == [U1(1)]
-  @test unlabel(la) == 1:2
-  @test la == 1:2
-  @test !isdual(la)
-  @test labelled_isequal(la, la)
-  @test space_isequal(la, la)
-  @test label_type(la) === U1
-  @test sector_type(la) === U1
-
-  @test iterate(la) == (1, 1)
-  @test iterate(la) == (1, 1)
-  @test iterate(la, 1) == (2, 2)
-  @test isnothing(iterate(la, 2))
-
-  lad = dual(la)
-  @test lad isa LabelledUnitRangeDual
-  @test label(lad) == U1(-1)
-  @test blocklabels(lad) == [U1(-1)]
-  @test unlabel(lad) == 1:2
-  @test lad == 1:2
-  @test labelled_isequal(lad, lad)
-  @test space_isequal(lad, lad)
-  @test !labelled_isequal(la, lad)
-  @test !space_isequal(la, lad)
-  @test isdual(lad)
-  @test isdual(dag(la))
-  @test nondual(lad) === la
-  @test dual(lad) === la
-  @test label_type(lad) === U1
-  @test sector_type(lad) === U1
-
-  @test dual_type(la) === typeof(lad)
-  @test dual_type(lad) === typeof(la)
-  @test nondual_type(lad) === typeof(la)
-  @test nondual_type(la) === typeof(la)
-
-  @test iterate(lad) == (1, 1)
-  @test iterate(lad) == (1, 1)
-  @test iterate(lad, 1) == (2, 2)
-  @test isnothing(iterate(lad, 2))
-
-  lad2 = lad[1:1]
-  @test lad2 isa LabelledUnitRangeDual
-  @test label(lad2) == U1(-1)
-  @test unlabel(lad2) == 1:1
-
-  laf = flip(la)
-  @test laf isa LabelledUnitRangeDual
-  @test label(laf) == U1(1)
-  @test unlabel(laf) == 1:2
-  @test labelled_isequal(la, laf)
-  @test !space_isequal(la, laf)
-
-  ladf = flip(dual(la))
-  @test ladf isa LabelledUnitRange
-  @test label(ladf) == U1(-1)
-  @test unlabel(ladf) == 1:2
-
-  lafd = dual(flip(la))
-  @test lafd isa LabelledUnitRange
-  @test label(lafd) == U1(-1)
-  @test unlabel(lafd) == 1:2
-
-  # check default behavior for objects without dual
-  la = labelled(1:2, 'x')
-  lad = dual(la)
-  @test lad isa LabelledUnitRangeDual
-  @test label(lad) == 'x'
-  @test blocklabels(lad) == ['x']
-  @test unlabel(lad) == 1:2
-  @test lad == 1:2
-  @test labelled_isequal(lad, lad)
-  @test space_isequal(lad, lad)
-  @test labelled_isequal(la, lad)
-  @test !space_isequal(la, lad)
-  @test isdual(lad)
-  @test nondual(lad) === la
-  @test dual(lad) === la
-
-  laf = flip(la)
-  @test laf isa LabelledUnitRangeDual
-  @test label(laf) == 'x'
-  @test unlabel(laf) == 1:2
-
-  ladf = flip(lad)
-  @test ladf isa LabelledUnitRange
-  @test label(ladf) == 'x'
-  @test unlabel(ladf) == 1:2
-end
-
-@testset "GradedUnitRangeDual" begin
+@testset "dual GradedUnitRange" begin
   for a in
       [gradedrange([U1(0) => 2, U1(1) => 3]), gradedrange([U1(0) => 2, U1(1) => 3])[1:5]]
     ad = dual(a)
-    @test ad isa GradedUnitRangeDual
+    @test ad isa unspecify_type_parameters(typeof(a))
     @test ad isa AbstractGradedUnitRange
-    @test eltype(ad) == LabelledInteger{Int,U1}
+    @test eltype(ad) == LabelledInteger{Int,DualU1}
     @test blocklengths(ad) isa Vector
-    @test eltype(blocklengths(ad)) == eltype(blocklengths(a))
+    @test sector_type(eltype(blocklengths(ad))) == sector_type(eltype(blocklengths(a)))
     @test sector_type(a) === U1
+    @test sector_type(ad) === U1
 
-    @test space_isequal(dual(ad), a)
-    @test space_isequal(nondual(ad), a)
-    @test space_isequal(nondual(a), a)
-    @test space_isequal(ad, ad)
-    @test !space_isequal(a, ad)
-    @test !space_isequal(ad, a)
-
-    @test dual_type(a) === typeof(ad)
-    @test dual_type(ad) === typeof(a)
-    @test nondual_type(ad) === typeof(a)
-    @test nondual_type(a) === typeof(a)
+    @test labelled_isequal(dual(ad), a)
+    @test labelled_isequal(nondual(ad), a)
+    @test labelled_isequal(nondual(a), a)
+    @test labelled_isequal(ad, ad)
+    @test !labelled_isequal(a, ad)
+    @test !labelled_isequal(ad, a)
 
     @test isdual(ad)
     @test isdual(dag(a))
@@ -197,43 +109,43 @@ end
     @test axes(Base.Slice(a)) isa Tuple{typeof(a)}
     @test AbstractUnitRange{Int}(ad) == 1:5
     b = combine_blockaxes(ad, ad)
-    @test b isa GradedUnitRangeDual
+    @test isdual(b)
     @test b == 1:5
-    @test space_isequal(b, ad)
+    @test labelled_isequal(b, ad)
 
     for x in iterate(ad)
       @test x == 1
-      @test label(x) == U1(0)
+      @test label(x) == dual(U1(0))
     end
-    for x in iterate(ad, labelled(3, U1(-1)))
+    for x in iterate(ad, labelled(3, dual(U1(1))))
       @test x == 4
-      @test label(x) == U1(-1)
+      @test label(x) == dual(U1(1))
     end
 
-    @test blockfirsts(ad) == [labelled(1, U1(0)), labelled(3, U1(-1))]
-    @test blocklasts(ad) == [labelled(2, U1(0)), labelled(5, U1(-1))]
+    @test blockfirsts(ad) == [labelled(1, U1(0)), labelled(3, dual(U1(1)))]
+    @test blocklasts(ad) == [labelled(2, U1(0)), labelled(5, dual(U1(1)))]
     @test blocklength(ad) == 2
     @test blocklengths(ad) == [2, 3]
-    @test blocklabels(ad) == [U1(0), U1(-1)]
-    @test label.(blocklengths(ad)) == [U1(0), U1(-1)]
+    @test blocklabels(ad) == [dual(U1(0)), dual(U1(1))]
+    @test label.(blocklengths(ad)) == [dual(U1(0)), dual(U1(1))]
     @test findblock(ad, 4) == Block(2)
     @test only(blockaxes(ad)) == Block(1):Block(2)
-    @test blocks(ad) == [labelled(1:2, U1(0)), labelled(3:5, U1(-1))]
+    @test blocks(ad) == [labelled(1:2, dual(U1(0))), labelled(3:5, dual(U1(1)))]
     @test ad[4] == 4
-    @test label(ad[4]) == U1(-1)
+    @test label(ad[4]) == dual(U1(1))
     @test ad[2:4] == 2:4
-    @test ad[2:4] isa GradedUnitRangeDual
-    @test label(ad[2:4][Block(2)]) == U1(-1)
+    @test isdual(ad[2:4])
+    @test label(ad[2:4][Block(2)]) == dual(U1(1))
     @test ad[[2, 4]] == [2, 4]
-    @test label(ad[[2, 4]][2]) == U1(-1)
+    @test label(ad[[2, 4]][2]) == dual(U1(1))
     @test ad[Block(2)] == 3:5
-    @test label(ad[Block(2)]) == U1(-1)
+    @test label(ad[Block(2)]) == dual(U1(1))
     @test ad[Block(1):Block(2)][Block(2)] == 3:5
-    @test label(ad[Block(1):Block(2)][Block(2)]) == U1(-1)
+    @test label(ad[Block(1):Block(2)][Block(2)]) == dual(U1(1))
     @test ad[[Block(2), Block(1)]][Block(1)] == 3:5
-    @test label(ad[[Block(2), Block(1)]][Block(1)]) == U1(-1)
+    @test label(ad[[Block(2), Block(1)]][Block(1)]) == dual(U1(1))
     @test ad[[Block(2)[1:2], Block(1)[1:2]]][Block(1)] == 3:4
-    @test label(ad[[Block(2)[1:2], Block(1)[1:2]]][Block(1)]) == U1(-1)
+    @test label(ad[[Block(2)[1:2], Block(1)[1:2]]][Block(1)]) == dual(U1(1))
     @test blocksortperm(a) == [Block(1), Block(2)]
     @test blocksortperm(ad) == [Block(1), Block(2)]
     @test blocklength(blockmergesortperm(a)) == 2
@@ -243,40 +155,40 @@ end
 
     @test isdual(ad[Block(1)])
     @test isdual(ad[Block(1)[1:1]])
-    @test ad[Block(1)] isa LabelledUnitRangeDual
-    @test ad[Block(1)[1:1]] isa LabelledUnitRangeDual
-    @test label(ad[Block(2)]) == U1(-1)
-    @test label(ad[Block(2)[1:1]]) == U1(-1)
+    @test ad[Block(1)] isa LabelledUnitRange
+    @test ad[Block(1)[1:1]] isa LabelledUnitRange
+    @test label(ad[Block(2)]) == dual(U1(1))
+    @test label(ad[Block(2)[1:1]]) == dual(U1(1))
 
     v = ad[[Block(2)[1:1]]]
-    @test v isa AbstractVector{LabelledInteger{Int64,U1}}
+    @test v isa AbstractVector{LabelledInteger{Int64,DualU1}}
     @test length(v) == 1
-    @test label(first(v)) == U1(-1)
+    @test label(first(v)) == dual(U1(1))
     @test unlabel(first(v)) == 3
     @test isdual(v[Block(1)])
     @test isdual(axes(v, 1))
-    @test blocklabels(axes(v, 1)) == [U1(-1)]
+    @test blocklabels(axes(v, 1)) == [dual(U1(1))]
 
     v = ad[mortar([Block(2)[1:1]])]
-    @test v isa AbstractVector{LabelledInteger{Int64,U1}}
+    @test v isa AbstractVector{LabelledInteger{Int64,DualU1}}
     @test isdual(axes(v, 1))  # used in view(::BlockSparseVector, [Block(1)[1:1]])
-    @test label(first(v)) == U1(-1)
+    @test label(first(v)) == dual(U1(1))
     @test unlabel(first(v)) == 3
-    @test blocklabels(axes(v, 1)) == [U1(-1)]
+    @test blocklabels(axes(v, 1)) == [dual(U1(1))]
 
     v = ad[[Block(2)]]
-    @test v isa AbstractVector{LabelledInteger{Int64,U1}}
+    @test v isa AbstractVector{LabelledInteger{Int64,DualU1}}
     @test isdual(axes(v, 1))  # used in view(::BlockSparseVector, [Block(1)])
-    @test label(first(v)) == U1(-1)
+    @test label(first(v)) == dual(U1(1))
     @test unlabel(first(v)) == 3
-    @test blocklabels(axes(v, 1)) == [U1(-1)]
+    @test blocklabels(axes(v, 1)) == [dual(U1(1))]
 
     v = ad[mortar([[Block(2)], [Block(1)]])]
-    @test v isa AbstractVector{LabelledInteger{Int64,U1}}
+    @test v isa AbstractVector{LabelledInteger{Int64,DualU1}}
     @test isdual(axes(v, 1))
-    @test label(first(v)) == U1(-1)
+    @test label(first(v)) == dual(U1(1))
     @test unlabel(first(v)) == 3
-    @test blocklabels(axes(v, 1)) == [U1(-1), U1(0)]
+    @test blocklabels(axes(v, 1)) == [dual(U1(1)), dual(U1(0))]
   end
 end
 
@@ -284,12 +196,12 @@ end
   for a in
       [gradedrange([U1(0) => 2, U1(1) => 3]), gradedrange([U1(0) => 2, U1(1) => 3])[1:5]]
     ad = dual(a)
-    @test space_isequal(flip(a), dual(gradedrange([U1(0) => 2, U1(-1) => 3])))
-    @test space_isequal(flip(ad), gradedrange([U1(0) => 2, U1(-1) => 3]))
+    @test labelled_isequal(flip(a), dual(gradedrange([U1(0) => 2, U1(-1) => 3])))
+    @test labelled_isequal(flip(ad), gradedrange([U1(0) => 2, U1(-1) => 3]))
 
     @test blocklabels(a) == [U1(0), U1(1)]
-    @test blocklabels(dual(a)) == [U1(0), U1(-1)]
-    @test blocklabels(flip(a)) == [U1(0), U1(1)]
+    @test blocklabels(dual(a)) == [dual(U1(0)), dual(U1(1))]
+    @test blocklabels(flip(a)) == [dual(U1(0)), dual(U1(-1))]
     @test blocklabels(flip(dual(a))) == [U1(0), U1(-1)]
     @test blocklabels(dual(flip(a))) == [U1(0), U1(-1)]
 
diff --git a/test/test_tensor_product.jl b/test/test_tensor_product.jl
index 604f1d0..a952acd 100644
--- a/test/test_tensor_product.jl
+++ b/test/test_tensor_product.jl
@@ -11,7 +11,7 @@ using GradedUnitRanges:
   fusion_product,
   flip,
   gradedrange,
-  space_isequal,
+  labelled_isequal,
   isdual,
   tensor_product
 
@@ -70,19 +70,19 @@ end
   b = fusion_product(ad)
   @test b isa GradedOneTo
   @test !isdual(b)
-  @test space_isequal(b, gradedrange([U1(-2) => 3, U1(-1) => 2]))
+  @test labelled_isequal(b, gradedrange([U1(-2) => 3, U1(-1) => 2]))
 
   c = fusion_product(ad, ad)
   @test c isa GradedOneTo
   @test !isdual(c)
-  @test space_isequal(c, gradedrange([U1(-4) => 9, U1(-3) => 12, U1(-2) => 4]))
+  @test labelled_isequal(c, gradedrange([U1(-4) => 9, U1(-3) => 12, U1(-2) => 4]))
 
   d = fusion_product(ad, a)
   @test !isdual(d)
-  @test space_isequal(d, gradedrange([U1(-1) => 6, U1(0) => 13, U1(1) => 6]))
+  @test labelled_isequal(d, gradedrange([U1(-1) => 6, U1(0) => 13, U1(1) => 6]))
 
   e = fusion_product(a, ad)
   @test !isdual(d)
-  @test space_isequal(e, d)
+  @test labelled_isequal(e, d)
 end
 end