address review comments

Author: lkdvos

docs/src/appendix/categories.md

@@ -668,7 +668,7 @@ justified.
 Before continuing, let us use some examples to sketch the relevance of the concept of fusion
 categories. As mentioned, the categories ``\mathbf{Vect}_𝕜`` and ``\mathbf{SVect}_𝕜`` have
 ``I ≂ 𝕜`` as simple object. For ``\mathbf{Vect}``, this is the only simple object, i.e. any
-other vector space ``V`` over ``𝕜``, can be thought of as a direct sum over
+other vector space ``V`` over ``𝕜`` can be thought of as a direct sum over
 ``N^V_I = \mathrm{dim}(V)`` multiple copies of ``𝕜``. In ``\mathbf{SVect}``, the object
 ``J = 0 ⊕ 𝕜`` with ``J_0=0`` the zero dimensional space and ``J_1 ≂ 𝕜`` is another simple
 object. Clearly, there are no non-zero grading preserving morphisms between ``I`` and ``J``,
@@ -884,14 +884,15 @@ allows to conclude that
 ``∑_ν [B^{ab}_c]^{ν}_{μ} \overline{[B^{ab}_c]^{ν}_{μ′}} = \delta_{μ,μ′}``, i.e. ``B^{ab}_c``
 is a unitary matrix. The same result follows for ``A^{ab}_c`` in analogue fashion.
 
-!!! note In the context of fusion categories, one often resorts to the so-called *isotopic*
-normalization convention, where splitting tensors are normalized as
-``(X^{ab}_{c,μ})^† ∘ X^{ab}_{c′,\mu′} = \sqrt{\frac{d_a d_b}{d_c}} δ_{c,c′} δ_{μ,μ′} \mathrm{id}_c``.
-This kills some of the quantum dimensions in formulas like the ones above and essentially
-allows to rotate the graphical notation of splitting and fusion tensors (up to a unitary
-transformation). Nonetheless, for our implementation of tensors and manipulations thereof
-(in particular orthonormal factorizations such as the singular value decomposition), we find
-it more convenient to work with the original normalization convention.
+!!! note
+    In the context of fusion categories, one often resorts to the so-called *isotopic*
+    normalization convention, where splitting tensors are normalized as
+    ``(X^{ab}_{c,μ})^† ∘ X^{ab}_{c′,\mu′} = \sqrt{\frac{d_a d_b}{d_c}} δ_{c,c′} δ_{μ,μ′} \mathrm{id}_c``.
+    This kills some of the quantum dimensions in formulas like the ones above and essentially
+    allows to rotate the graphical notation of splitting and fusion tensors (up to a unitary
+    transformation). Nonetheless, for our implementation of tensors and manipulations thereof
+    (in particular orthonormal factorizations such as the singular value decomposition), we find
+    it more convenient to work with the original normalization convention.
 
 Let us again study in more detail the example ``\mathbf{Rep}_{\mathsf{G}}``. The quantum
 dimension ``d_a`` of an irrep ``a`` is just the normal vector space dimension (over ``𝕜``)

docs/src/lib/sectors.md

@@ -54,7 +54,7 @@ TensorKitSectors.Dihedral
 TensorKitSectors.ProductGroup
 ```
 
-The following types are used to characterise different properties of the different types of
+The following types are used to characterize different properties of the different types of
 sectors:
 
 ```@docs

docs/src/lib/spaces.md

@@ -119,7 +119,7 @@ removeunit(::ProductSpace, ::Val{i}) where {i}
 ```
 
 There are also specific methods for `HomSpace` instances, that are used in determining the
-resuling `HomSpace` after applying certain tensor operations.
+resulting `HomSpace` after applying certain tensor operations.
 
 ```@docs
 flip(W::HomSpace{S}, I) where {S}

docs/src/lib/tensors.md

@@ -130,7 +130,7 @@ Base.getindex(::AbstractTensorMap, ::FusionTree, ::FusionTree)
 Base.setindex!(::AbstractTensorMap, ::Any, ::FusionTree, ::FusionTree)
 ```
 
-For a tensor `t` with `FusionType(sectortype(t)) isa UniqueFusion`, fusion trees are
+For a tensor `t` with `FusionStyle(sectortype(t)) isa UniqueFusion`, fusion trees are
 completely determined by the outcoming sectors, and the data can be accessed in a more
 straightforward way:
 ```@docs
@@ -157,24 +157,24 @@ Random.randexp!
 The operations that can be performed on an `AbstractTensorMap` can be organized into the
 following categories:
 
-* *vector operations*: these do not change the `space` or index strucure of a tensor and can
+* *vector operations*: these do not change the `space` or index structure of a tensor and can
   be straightforwardly implemented on on the full data. All the methods described in
   [VectorInterface.jl](https://github.com/Jutho/VectorInterface.jl) are supported. For
   compatibility reasons, we also provide implementations for equivalent methods from
   LinearAlgebra.jl, such as `axpy!`, `axpby!`.
 
 * *index manipulations*: these change (permute) the index structure of a tensor, which
   affects the data in a way that is fully determined by the categorical data of the
-  `sectortype` of the tensor.
-          
+  `sectortype` of the tensor .
+
 * *(planar) contractions* and *(planar) traces* (i.e., contractions with identity tensors).
   Tensor contractions correspond to a combination of some index manipulations followed by a
   composition or multiplication of the tensors in their role as linear maps. Tensor
-  contractions are however of such important and frequency that they require a dedicated
+  contractions are however of such importance and frequency that they require a dedicated
   implementation.
 
-* *tensor factorisations*, which relies on their identification of tensors with linear maps
-  between tensor spaces. The factorisations are applied as ordinary matrix factorisations to
+* *tensor factorizations*, which relies on their identification of tensors with linear maps
+  between tensor spaces. The factorizations are applied as ordinary matrix factorizations to
   the matrix blocks associated with the coupled charges.
 
 ### Index manipulations
@@ -222,7 +222,7 @@ contract!
 
 ## `TensorMap` factorizations
 
-The factorisation methods are powered by
+The factorization methods are powered by
 [MatrixAlgebraKit.jl](https://github.com/QuantumKitHub/MatrixAlgebraKit.jl) and all follow
 the same strategy. The idea is that the `TensorMap` is interpreted as a linear map based on
 the current partition of indices between `domain` and `codomain`, and then the entire range

docs/src/man/fusiontrees.md

@@ -398,24 +398,25 @@ abelian groups, all irreps are one-dimensional.
 
 Some examples:
 ```@repl fusiontrees
+using LinearAlgebra # hide
 s = Irrep[SU₂](1/2)
 iter = fusiontrees((s, s, s, s), SU2Irrep(1))
 f = first(iter)
 convert(Array, f)
 
 LinearAlgebra.I ≈ convert(Array, FusionTree((SU2Irrep(1/2),), SU2Irrep(1/2), (false,), ()))
 Z = adjoint(convert(Array, FusionTree((SU2Irrep(1/2),), SU2Irrep(1/2), (true,), ())))
-transpose(Z) ≈ frobeniusschur(SU2Irrep(1/2)) * Z
+transpose(Z) ≈ frobenius_schur_phase(SU2Irrep(1/2)) * Z
 
 LinearAlgebra.I ≈ convert(Array, FusionTree((Irrep[SU₂](1),), Irrep[SU₂](1), (false,), ()))
 Z = adjoint(convert(Array, FusionTree((Irrep[SU₂](1),), Irrep[SU₂](1), (true,), ())))
-transpose(Z) ≈ frobeniusschur(Irrep[SU₂](1)) * Z
+transpose(Z) ≈ frobenius_schur_phase(Irrep[SU₂](1)) * Z
 
 #check orthogonality
 for f1 in iter
   for f2 in iter
     dotproduct  = dot(convert(Array, f1), convert(Array, f2))
-    println("< $f1, $f2> = $dotproduct")
+    println("<$f1, $f2> = $dotproduct")
   end
 end
 ```

docs/src/man/gradedspaces.md

@@ -14,7 +14,7 @@ struct GradedSpace{I<:Sector, D} <: ElementarySpace
 end
 ```
 Here, `D` is a type parameter to denote the data structure used to store the degeneracy or
-multiplicity dimensions ``n_a`` of the different sectors. For conviency, `Vect[I]` will
+multiplicity dimensions ``n_a`` of the different sectors. For convenience, `Vect[I]` will
 return the fully concrete type with `D` specified.
 
 Note that, conventionally, a graded vector space is a space that has a natural direct sum

docs/src/man/intro.md

@@ -55,8 +55,8 @@ map ``W → V`` is often denoted as a rank 2 tensor in ``V ⊗ W^*``, where ``W^
 to the dual space of ``W``. This simple example introduces two new concepts.
 
 1.  Typical vector spaces can appear in the domain and codomain in different related forms,
-    e.g. as normal space or dual space. In fact, the most generic case is that every vector
-    space ``V`` has associated with it a
+    e.g. as normal spaces or dual spaces. In fact, the most generic case is that every
+    vector space ``V`` has associated with it a
     [dual space](https://en.wikipedia.org/wiki/Dual_space) ``V^*``, a
     [conjugate space](https://en.wikipedia.org/wiki/Complex_conjugate_vector_space)
     ``\overline{V}`` and a conjugate dual space ``\overline{V}^*``. The four different

docs/src/man/spaces.md

@@ -15,7 +15,7 @@ abstract type VectorSpace end
 Technically speaking, this name does not capture the full generality that TensorKit.jl
 supports, as instances of subtypes of `VectorSpace` can encode general objects in linear
 monoidal categories, which are not necessarily vector spaces. However, in order not to make
-the remaining discussion to abstract or complicated, we will simply use the nomenclature of
+the remaining discussion too abstract or complicated, we will simply use the nomenclature of
 vector spaces. In particular, we define two abstract subtypes
 ```julia
 abstract type ElementarySpace <: VectorSpace end

docs/src/man/tutorial.md

@@ -17,12 +17,12 @@ The most important objects in TensorKit.jl are tensors, which we now create with
 A = randn(ℝ^3 ⊗ ℝ^2 ⊗ ℝ^4)
 ```
 
-Note that we entered the tensor size not as plain dimensions, by specifying the vector space
-associated with these tensor indices, in this case `ℝ^n`, which can be obtained by typing
-`\bbR+TAB`. The tensor then lives in the tensor product of the different spaces, which we
-can obtain by typing `⊗` (i.e. `\otimes+TAB`), although for simplicity also the usual
-multiplication sign `*` does the job. Note also that `A` is printed as an instance of a
-parametric type `TensorMap`, which we will discuss below and contains `Tensor`.
+Note that we entered the tensor size not as plain dimensions, but by specifying the vector
+space associated with these tensor indices, in this case `ℝ^n`, which can be obtained by
+typing `\bbR+TAB`. The tensor then lives in the tensor product of the different spaces,
+which we can obtain by typing `⊗` (i.e. `\otimes+TAB`), although for simplicity also the
+usual multiplication sign `*` does the job. Note also that `A` is printed as an instance of
+a parametric type `TensorMap`, which we will discuss below and contains `Tensor`.
 
 Let us briefly sidetrack into the nature of `ℝ^n`:
 
@@ -35,8 +35,8 @@ supertype(ElementarySpace)
 ```
 
 i.e. `ℝ^n` can also be created without Unicode using the longer syntax `CartesianSpace(n)`.
-It is subtype of `ElementarySpace`, with a standard (Euclidean) inner product over the real
-numbers. Furthermore,
+It is a subtype of `ElementarySpace`, with a standard (Euclidean) inner product over the
+real numbers. Furthermore,
 
 ```@repl tutorial
 W = ℝ^3 ⊗ ℝ^2 ⊗ ℝ^4
@@ -57,7 +57,7 @@ B = randn(ℝ^3 * ℝ^2 * ℝ^4);
 C = 0.5*A + 2.5*B
 ```
 
-Given that they are behave as vectors, they also have a scalar product and norm, which they
+Given that they behave as vectors, they also have a scalar product and norm, which they
 inherit from the Euclidean inner product on the individual `ℝ^n` spaces:
 
 ```@repl tutorial
@@ -106,9 +106,11 @@ Finally, we can factorize a tensor, creating a bipartition of a subset of its in
 its complement. With a plain Julia `Array`, one would apply `permutedims` and `reshape` to
 cast the array into a matrix before applying e.g. the singular value decomposition. With
 TensorKit.jl, one just specifies which indices go to the left (rows) and right (columns)
+with a tuple of tuples, selecting the respective indices for either side.
 
 ```@repl tutorial
-U, S, Vd = tsvd(A, ((1,3), (2,)));
+A_matrix = permute(A, ((1, 3), (2,)));
+U, S, Vd = svd_compact(A_matrix);
 @tensor A′[a,b,c] := U[a,c,d] * S[d,e] * Vd[e,b];
 A ≈ A′
 U
@@ -155,11 +157,12 @@ space(M₃)
 
 Note that for the construction of `M₁`, in accordance with how one specifies the dimensions
 of a matrix (e.g. `randn(4,3)`), the first space is the codomain and the second the domain.
-This is somewhat opposite to the general notation for a function `f:domain→codomain`, so
-that we also support this more mathemical notation, as illustrated in the construction of
-`M₂`. However, as this is confusing from the perspective of rows and columns, we also
-support the syntax `codomain ← domain` and actually use this as the default way of printing
-`HomSpace` instances.
+This is somewhat opposite to the general notation for a function
+``f : \text{domain} \rightarrow \text{codomain}``, so that we also support this more
+mathematical notation, as illustrated in the construction of `M₂`. However, as this is
+confusing from the perspective of rows and columns, we also support the syntax
+`codomain ← domain` and actually use this as the default way of printing `HomSpace`
+instances.
 
 The 'matrix-vector' or 'matrix-matrix' product can be computed between any two `TensorMap`
 instances for which the domain of the first matches with the codomain of the second, e.g.
@@ -179,7 +182,7 @@ codomain(U)
 domain(U)
 space(U)
 U' * U # should be the identity on the corresponding domain = codomain
-U' * U ≈ one(U'*U)
+U' * U ≈ one(U' * U)
 P = U * U' # should be a projector
 P * P ≈ P
 ```
@@ -197,9 +200,9 @@ codomain(A2)
 domain(A2)
 ```
 
-In fact, `tsvd(A, ((1, 3), (2,)))` is a shorthand for `tsvd(permute(A, ((1, 3), (2,))))`,
-where `tsvd(A::TensorMap)` will just compute the singular value decomposition according to
-the given codomain and domain of `A`.
+In fact, this was already what we used in `svd_compact(A_matrix)` to create the matricized
+tensor `A_matrix`, and where `svd_compact(A::AbstractTensorMap)` will just compute the
+singular value decomposition according to the given codomain and domain of `A`.
 
 Note, finally, that the `@tensor` macro treats all indices at the same footing and thus does
 not distinguish between codomain and domain. The linear numbering is first all indices in
@@ -243,12 +246,12 @@ where `ℂ` is obtained as `\bbC+TAB` and we also have the non-Unicode alternati
 
 ```@repl tutorial
 B = randn(ℂ^3 * ℂ^2 * ℂ^4);
-C = im*A + (2.5 - 0.8im) * B
+C = im * A + (2.5 - 0.8im) * B
 scalarBA = dot(B, A)
 scalarAA = dot(A, A)
 normA² = norm(A)^2
-U, S, Vd = tsvd(A, ((1, 3), (2,)));
-@tensor A′[a,b,c] := U[a,c,d] * S[d,e] * Vd[e,b];
+U, S, Vd = svd_compact(permute(A, ((1, 3), (2,))));
+@tensor A′[a, b, c] := U[a, c, d] * S[d, e] * Vd[e, b];
 A′ ≈ A
 permute(A, ((1, 3), (2,))) ≈ U * S * Vd
 ```
@@ -321,8 +324,8 @@ convert(Array, A)
 
 Here, we create a 5-dimensional space `V1`, which has a three-dimensional subspace
 associated with charge 0 (the trivial irrep of ``ℤ₂``) and a two-dimensional subspace with
-charge 1 (the non-trivial irrep). Similar for `V2`, where both subspaces are one-
-dimensional. Representing the tensor as a dense `Array`, we see that it is zero in those
+charge 1 (the non-trivial irrep). Similar for `V2`, where both subspaces are
+one-dimensional. Representing the tensor as a dense `Array`, we see that it is zero in those
 regions where the charges don't add to zero (modulo 2). Of course, the `Tensor(Map)` type in
 TensorKit.jl won't store these zero blocks, and only stores the non-zero information, which
 we can recognize also in the full `Array` representation.
@@ -333,7 +336,7 @@ encountered in the previous examples.
 ```@repl tutorial
 B = randn(V1' * V1 * V2);
 @tensor C[a,b] := A[a,c,d] * B[c,b,d]
-U, S, V = tsvd(A, ((1, 3), (2,)));
+U, S, V = svd_compact(permute(A, ((1, 3), (2,))));
 U' * U # should be the identity on the corresponding domain = codomain
 U' * U ≈ one(U'*U)
 P = U * U' # should be a projector
@@ -349,7 +352,7 @@ A = randn(V * V, V)
 dim(A)
 convert(Array, A)
 
-V = Rep[U₁×ℤ₂]((0, 0) => 2, (1, 1) => 1, (-1, 0) => 1)
+V = Rep[U₁ × ℤ₂]((0, 0) => 2, (1, 1) => 1, (-1, 0) => 1)
 dim(V)
 A = randn(V * V, V)
 dim(A)
@@ -366,12 +369,12 @@ more general sectortypes `I` it can be constructed as `Vect[I]`. Furthermore, `
 synonyms, e.g.
 
 ```@repl tutorial
-Rep[U₁](0=>3, 1=>2, -1=>1) == U1Space(-1=>1, 1=>2, 0=>3)
-V = U₁Space(1=>2, 0=>3, -1=>1)
+Rep[U₁](0 => 3, 1 => 2, -1 => 1) == U1Space(-1 => 1, 1 => 2, 0 => 3)
+V = U₁Space(1 => 2, 0 => 3, -1 => 1)
 for s in sectors(V)
   @show s, dim(V, s)
 end
-U₁Space(-1=>1, 0=>3, 1=>2) == GradedSpace(Irrep[U₁](1)=>2, Irrep[U₁](0)=>3, Irrep[U₁](-1)=>1)
+U₁Space(-1 => 1, 0 => 3, 1 => 2) == GradedSpace(Irrep[U₁](1) => 2, Irrep[U₁](0) => 3, Irrep[U₁](-1) => 1)
 supertype(GradedSpace)
 ```
 
@@ -416,13 +419,13 @@ less obvious to recognize the dense blocks, as there are additional zeros and th
 the original tensor data do not match with those in the `Array`. The reason is of course
 that the original tensor data now needs to be transformed with a construction known as
 fusion trees, which are made up out of the Clebsch-Gordan coefficients of the group. Indeed,
-note that the non-zero blocks are also no longer labeled by a list of sectors, but by pairs
-of fusion trees. This will be explained further in the manual. However, the Clebsch-Gordan
-coefficients of the group are only needed to actually convert a tensor to an `Array`. For
-working with tensors with `SU₂Space` indices, e.g. contracting or factorizing them, the
-Clebsch-Gordan coefficients are never needed explicitly. Instead, recoupling relations are
-used to symbolically manipulate the basis of fusion trees, and this only requires what is
-known as the topological data of the group (or its representation theory).
+note that the non-zero subblocks are also no longer labeled by a list of sectors, but by
+pairs of fusion trees. This will be explained further in the manual. However, the
+Clebsch-Gordan coefficients of the group are only needed to actually convert a tensor to an
+`Array`. For working with tensors with `SU₂Space` indices, e.g. contracting or factorizing
+them, the Clebsch-Gordan coefficients are never needed explicitly. Instead, recoupling
+relations are used to symbolically manipulate the basis of fusion trees, and this only
+requires what is known as the topological data of the group (or its representation theory).
 
 In fact, this formalism extends beyond the case of group representations on vector spaces,
 and can also deal with super vector spaces (to describe fermions) and more general (unitary)