some docs fixes

Author: lkdvos

docs/Project.toml

@@ -1,6 +1,7 @@
 [deps]
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+TensorKit = "07d1fe3e-3e46-537d-9eac-e9e13d0d4cec"
 TensorKitSectors = "13a9c161-d5da-41f0-bcbd-e1a08ae0647f"
 
 [compat]

docs/make.jl

@@ -1,6 +1,7 @@
 using Documenter
 using Random
 using TensorKit, TensorKitSectors
+using TensorKit: FusionTreePair, Index2Tuple
 
 pages = ["Home" => "index.md",
          "Manual" => ["man/intro.md", "man/tutorial.md", "man/categories.md",

docs/src/lib/sectors.md

@@ -90,7 +90,7 @@ insertat
 split
 merge
 elementary_trace
-planar_trace(f::FusionTree{I,N}, q1::IndexTuple{N₃}, q2::IndexTuple{N₃}) where {I<:Sector,N,N₃}
+planar_trace(f::FusionTree{I,N}, q::Index2Tuple{N₃,N₃}) where {I<:Sector,N,N₃}
 artin_braid
 braid(f::FusionTree{I,N}, levels::NTuple{N,Int}, p::NTuple{N,Int}) where {I<:Sector,N}
 permute(f::FusionTree{I,N}, p::NTuple{N,Int}) where {I<:Sector,N}
@@ -113,8 +113,8 @@ Finally, these are used to define large manipulations of fusion-splitting tree p
 are then used in the index manipulation of `AbstractTensorMap` objects. The following methods
 defined on fusion splitting tree pairs have an associated definition for tensors.
 ```@docs
-repartition(::FusionTree{I,N₁}, ::FusionTree{I,N₂}, ::Int) where {I<:Sector,N₁,N₂}
-transpose(::FusionTree{I}, ::FusionTree{I}, ::IndexTuple{N₁}, ::IndexTuple{N₂}) where {I<:Sector,N₁,N₂}
-braid(::FusionTree{I}, ::FusionTree{I}, ::IndexTuple, ::IndexTuple, ::IndexTuple{N₁}, ::IndexTuple{N₂}) where {I<:Sector,N₁,N₂}
-permute(::FusionTree{I}, ::FusionTree{I}, ::IndexTuple{N₁}, ::IndexTuple{N₂}) where {I<:Sector,N₁,N₂}
+repartition(::FusionTreePair, ::Int)
+transpose(::FusionTreePair{I}, ::Index2Tuple{N₁,N₂}) where {I,N₁,N₂}
+braid(::FusionTreePair, ::Index2Tuple, ::Index2Tuple)
+permute(::FusionTreePair, ::Index2Tuple)
 ```

docs/src/man/sectors.md

@@ -1155,7 +1155,7 @@ the splitting tree.
 
 The `FusionTree` interface to duality and line bending is given by
 
-[`repartition(f1::FusionTree{I,N₁}, f2::FusionTree{I,N₂}, N::Int)`](@ref repartition)
+[`repartition(f1::FusionTreePair{I,N₁,N₂}, N::Int)`](@ref repartition)
 
 which takes a splitting tree `f1` with `N₁` outgoing sectors, a fusion tree `f2` with `N₂`
 incoming sectors, and applies line bending such that the resulting splitting and fusion
@@ -1180,7 +1180,7 @@ With this basic function, we can now perform arbitrary combinations of braids or
 permutations with line bendings, to completely reshuffle where sectors appear. The
 interface provided for this is given by
 
-[`braid(f1::FusionTree{I,N₁}, f2::FusionTree{I,N₂}, levels1::NTuple{N₁,Int}, levels2::NTuple{N₂,Int}, p1::NTuple{N₁′,Int}, p2::NTuple{N₂′,Int})`](@ref braid(::FusionTree{I}, ::FusionTree{I}, ::IndexTuple, ::IndexTuple, ::IndexTuple{N₁}, ::IndexTuple{N₂}) where {I<:Sector,N₁,N₂})
+[`braid((f₁, f₂)::FusionTreePair, (p1, p2)::Index2Tuple, (levels1, levels2)::Index2Tuple)`](@ref braid(::TensorKit.FusionTreePair, ::Index2Tuple, ::Index2Tuple))
 
 where we now have splitting tree `f1` with `N₁` outgoing sectors, a fusion tree `f2` with
 `N₂` incoming sectors, `levels1` and `levels2` assign a level or depth to the corresponding
@@ -1206,7 +1206,7 @@ As before, there is a simplified interface for the case where
 `BraidingStyle(I) isa SymmetricBraiding` and the levels are not needed. This is simply
 given by
 
-[`permute(f1::FusionTree{I,N₁}, f2::FusionTree{I,N₂}, p1::NTuple{N₁′,Int}, p2::NTuple{N₂′,Int})`](@ref permute(::FusionTree{I}, ::FusionTree{I}, ::IndexTuple{N₁}, ::IndexTuple{N₂}) where {I<:Sector,N₁,N₂})
+[`permute((f₁, f₂)::FusionTreePair, (p1, p2)::Index2Tuple)`](@ref permute(::FusionTreePair, ::Index2Tuple))
 
 The `braid` and `permute` routines for double fusion trees will be the main access point for
 corresponding manipulations on tensors. As a consequence, results from this routine are

src/fusiontrees/manipulations.jl

@@ -487,9 +487,9 @@ outgoing (`f₁`) and incoming sectors (`f₂`) respectively (with identical cou
 repartitioning the tree by bending incoming to outgoing sectors (or vice versa) in order to
 have `N` outgoing sectors.
 """
-@inline function repartition((f₁, f₂)::FusionTreePair{I,N₁,N₂}, N::Int) where {I,N₁,N₂}
+@inline function repartition((f₁, f₂)::FusionTreePair, N::Int)
     f₁.coupled == f₂.coupled || throw(SectorMismatch())
-    @assert 0 <= N <= N₁ + N₂
+    @assert 0 <= N <= length(f₁) + length(f₂)
     return _recursive_repartition((f₁, f₂), Val(N))
 end
 
@@ -1002,8 +1002,7 @@ end
 
 # braid double fusion tree
 """
-    braid((f₁, f₂)::FusionTreePair{I}, (p1, p2)::Index2Tuple{N₁,N₂},
-          (levels1, levels2)::Index2Tuple) where {I,N₁,N₂}
+    braid((f₁, f₂)::FusionTreePair, (p1, p2)::Index2Tuple, (levels1, levels2)::Index2Tuple)
         -> <:AbstractDict{<:FusionTreePair{I, N₁, N₂}}, <:Number}
 
 Input is a fusion-splitting tree pair that describes the fusion of a set of incoming
@@ -1018,9 +1017,8 @@ respectively, which determines how indices braid. In particular, if `i` and `j`
 levels[j]`. This does not allow to encode the most general braid, but a general braid can
 be obtained by combining such operations.
 """
-function braid((f₁, f₂)::FusionTreePair{I}, (p1, p2)::Index2Tuple{N₁,N₂},
-               (levels1, levels2)::Index2Tuple) where {I,N₁,N₂}
-    @assert length(f₁) + length(f₂) == N₁ + N₂
+function braid((f₁, f₂)::FusionTreePair, (p1, p2)::Index2Tuple, (levels1, levels2)::Index2Tuple)
+    @assert length(f₁) + length(f₂) == length(p1) + length(p2)
     @assert length(f₁) == length(levels1) && length(f₂) == length(levels2)
     @assert TupleTools.isperm((p1..., p2...))
     return fsbraid(((f₁, f₂), (p1, p2), (levels1, levels2)))
@@ -1056,7 +1054,7 @@ function CacheStyle(::typeof(fsbraid), k::FSBraidKey{I}) where {I<:Sector}
 end
 
 """
-    permute((f₁, f₂)::FusionTreePair{I}, (p1, p2)::Index2Tuple{N₁, N₂}) where {I, N₁, N₂}
+    permute((f₁, f₂)::FusionTreePair, (p1, p2)::Index2Tuple)
         -> <:AbstractDict{<:FusionTreePair{I, N₁, N₂}}, <:Number}
 
 Input is a double fusion tree that describes the fusion of a set of incoming uncoupled
@@ -1066,8 +1064,8 @@ outgoing (`t1`) and incoming sectors (`t2`) respectively (with identical coupled
 repartitioning and permuting the tree such that sectors `p1` become outgoing and sectors
 `p2` become incoming.
 """
-function permute((f₁, f₂)::FusionTreePair{I}, (p1, p2)::Index2Tuple{N₁,N₂}) where {I,N₁,N₂}
-    @assert BraidingStyle(I) isa SymmetricBraiding
+function permute((f₁, f₂)::FusionTreePair, (p1, p2)::Index2Tuple)
+    @assert BraidingStyle(sectortype(f₁)) isa SymmetricBraiding
     levels1 = ntuple(identity, length(f₁))
     levels2 = length(f₁) .+ ntuple(identity, length(f₂))
     return braid((f₁, f₂), (p1, p2), (levels1, levels2))

src/tensors/linalg.jl

@@ -71,8 +71,6 @@ end
 Construct the identity endomorphism on space `V`, i.e. return a `t::TensorMap` with
 `domain(t) == codomain(t) == V`, where either `scalartype(t) = T` if `T` is a `Number` type
 or `storagetype(t) = T` if `T` is a `DenseVector` type.
-
-See also [`one!`](@ref).
 """ id, id!
 
 id(V::TensorSpace) = id(Float64, V)