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/sectors.md

@@ -173,11 +173,11 @@ particular, the quantum dimensions ``d_a`` and Frobenius-Schur phase ``χ_a`` an
 (only if ``a == \overline{a}``) are encoded in the F-symbol. They are obtained as
 [`dim(a)`](@ref), [`frobenius_schur_phase(a)`](@ref) and
 [`frobenius_schur_indicator(a)`](@ref). These functions have default definitions which
-compute the requested data from `Fsymbol(a, conj(a), a, a, one(a), one(a))`, but they can be
-overloaded in case the value can be computed more efficiently. The same holds for related
+compute the requested data from `Fsymbol(a, conj(a), a, a, unit(a), unit(a))`, but they can
+be overloaded in case the value can be computed more efficiently. The same holds for related
 fusion manipulations such as the B-symbol, which is obtained as [`Bsymbol(a, b, c)`](@ref).
 Finally, the twist associated with a sector `a` is obtained as [`twist(a)`](@ref), which
-also has a default implementation in terms of the R-symbol. In addition, tThe function
+also has a default implementation in terms of the R-symbol. In addition, the function
 `isunit` is provided to facilitate checking whether a sector is a unit sector, in particular
 for the non-trivial case of the multi-fusion category case, which we do not discuss here.
 
@@ -374,7 +374,7 @@ Irrep[U₁](0.5)
 U1Irrep(0.4)
 U1Irrep(1) ⊗ Irrep[U₁](1//2)
 u = first(U1Irrep(1) ⊗ Irrep[U₁](1//2))
-Nsymbol(u, conj(u), one(u))
+Nsymbol(u, dual(u), unit(u))
 ```
 
 We similarly implement the irreps of the finite cyclic groups ``\mathbb{Z}_N``, where we
@@ -505,7 +505,7 @@ explicitly restricted the scalar type of `SU2Irrep` to `Float64` for efficiency.
 The following example illustrates the usage of `SU2Irrep`
 ```@repl sectors
 s = SU2Irrep(3//2)
-conj(s)
+dual(s)
 dim(s)
 collect(s ⊗ s)
 for s2 in s ⊗ s
@@ -516,17 +516,19 @@ end
 ```
 
 Other non-abelian groups for which the irreps are implemented are the dihedral groups
-``\mathsf{D}_N``, and the semidirect product ``\mathsf{U}₁ ⋉ ℤ_2``. In the context of
-quantum systems, the latter occurs in the case of systems with particle hole symmetry and
-the non-trivial element of ``ℤ_2`` acts as charge conjugation ``C``. It has the effect of
-interchaning ``\mathsf{U}_1`` irreps ``n`` and ``-n``, and turns them together in a joint
-2-dimensional index, except for the case ``n=0``. Irreps are therefore labeled by integers
-``n ≧ 0``, however for ``n=0`` the ``ℤ₂`` symmetry can be realized trivially or
-non-trivially, resulting in an even and odd one-dimensional irrep with ``\mathsf{U})_1``
-charge ``0``. Given ``\mathsf{U}_1 ≂ \mathsf{SO}_2``, this group is also simply known as
-``\mathsf{O}_2``, and the two representations with `` n = 0`` are the scalar and
-pseudo-scalar, respectively. However, because we also allow for half integer
-representations, we refer to it as `Irrep[CU₁]` or `CU1Irrep` in full.
+``\mathsf{D}_N``, the alternating group of order four ``mathsf{A}_4`` and the semidirect
+product ``\mathsf{U}₁ ⋉ ℤ_2``. In the context of quantum systems, the latter occurs in the
+case of systems with particle hole symmetry and the non-trivial element of ``ℤ_2`` acts as
+charge conjugation ``C``. It has the effect of interchanging ``\mathsf{U}_1`` irreps ``n``
+and ``-n``, and turns them together in a joint two-dimensional index, except for the case
+``n=0``. Irreps are therefore labeled by integers ``n ≧ 0``, however for ``n=0`` the ``ℤ₂``
+symmetry can be realized trivially or non-trivially, resulting in an even and odd
+one-dimensional irrep with ``\mathsf{U}_1`` charge ``0``. Given
+``\mathsf{U}_1 ≂ \mathsf{SO}_2``, this group is also simply known as ``\mathsf{O}_2``, and
+the two representations with `` n = 0`` are the scalar and pseudo-scalar, respectively.
+However, because we also allow for half integer representations, we refer to it as
+`Irrep[CU₁]` or `CU1Irrep` in full.
+
 ```julia
 struct CU1Irrep <: AbstractIrrep{CU₁}
     j::HalfInt # value of the U1 charge
@@ -556,8 +558,8 @@ the different cases for the arguments of `Fsymbol`. For the dihedrial groups
 the representation theory is obtained quite similarly, and is implmented as the type
 [`DNIrrep{N}`](@ref).
 
-By default, none of the groups mentioned above have a reprenenstation theory for which
-`FusionStyle(I) == GenericFusion()`, i.e. where fusion mulitplicities are required. An
+Of the aforementioned groups, only ``mathsf{A}_4`` has a representation theory for which
+`FusionStyle(I) == GenericFusion()`, i.e. where fusion mulitplicities are required. Another
 example where this does appear is for the irreps of `SU{N}` for `N>2`. Such sectors are
 supported through
 [SUNRepresentations.jl](https://github.com/QuantumKitHub/SUNRepresentations.jl), which
@@ -575,22 +577,22 @@ examples
 ```@repl sectors
 a = Z3Irrep(1) ⊠ Irrep[U₁](1)
 typeof(a)
-conj(a)
-one(a)
+dual(a)
+unit(a)
 dim(a)
 collect(a ⊗ a)
 FusionStyle(a)
 b = Irrep[ℤ₃](1) ⊠ Irrep[SU₂](3//2)
 typeof(b)
-conj(b)
-one(b)
+dual(b)
+unit(b)
 dim(b)
 collect(b ⊗ b)
 FusionStyle(b)
 c = Irrep[SU₂](1) ⊠ SU2Irrep(3//2)
 typeof(c)
-conj(c)
-one(c)
+dual(c)
+unit(c)
 dim(c)
 collect(c ⊗ c)
 FusionStyle(c)
@@ -608,7 +610,7 @@ used to create `ProductSector{Tuple{Irrep[ℤ₃], Irrep[CU₁]}}`. Instances of
 constructed by giving a number of arguments, where the first argument is used to construct
 the first sector, and so forth. Furthermore, for representations of groups, we also enabled
 the notation `Irrep[ℤ₃ × CU₁]`, with `×` obtained using `\times+TAB`. However, this is
-merely for convience, as `Irrep[ℤ₃] ⊠ Irrep[CU₁]` is not a subtype of the abstract type
+merely for convenience, as `Irrep[ℤ₃] ⊠ Irrep[CU₁]` is not a subtype of the abstract type
 `AbstractIrrep{ℤ₃ × CU₁}`. As is often the case with the Julia type system, the purpose of
 subtyping `AbstractIrrep` was to share common functionality and thereby simplify the
 implementation of irreps of the different groups discussed above, but not to express a
@@ -831,13 +833,13 @@ Finally, as mentioned above, a recent extension prepares TensorKitSectors.jl to
 multi-fusion categories, where the sectors (simple objects) are organized in a matrix-like
 structure and thus have an additional row and column index. Fusion between sectors is only
 possible when the row and column indices match appropriately; otherwise the fusion product
-is empty. In this structure, the different groups of "diagonal" sectors define separate
-fusion categories, whereas the off-diagonal sectors define bimodule categories between these
-fusion categories. Every diagonal group has its own unit sector, which also acts as the left
-/ right unit for other sectors in the same column / row. The global unit object is not
-simple, but rather given by the direct sum of all diagonal unit sectors. We do not document
-or illustrate this structure here, but refer to the relevant functions [`leftunit`](@ref),
-[`rightunit`](@ref), [`allunits`](@ref) and [`UnitStyle`](@ref) for more information.
-Furthermore, we refer to
+is empty. In this structure, the different *diagonal* sectors define separate fusion
+categories, whereas the *off-diagonal* sectors define bimodule categories between these
+fusion categories. Every diagonal set of sectors has its own unit sector, which also acts as
+the left / right unit for other sectors in the same column / row. The global unit object is
+not simple, but rather given by the direct sum of all diagonal unit sectors. We do not
+document or illustrate this structure here, but refer to the relevant functions
+[`leftunit`](@ref), [`rightunit`](@ref), [`allunits`](@ref) and [`UnitStyle`](@ref) for more
+information. Furthermore, we refer to
 [MultiTensorKit.jl](https://github.com/QuantumKitHub/MultiTensorKit.jl) for examples and
-ongoing development work on using multi-fusion categories.
+ongoing development work on using multi-fusion categories.

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/tensormanipulations.md

@@ -220,7 +220,7 @@ note that we have a conjugation syntax within the context of [tensor contraction
 ss_tensor_contraction).
 
 To show the effect of `twist`, we now consider a type of sector `I` for which
-`BraidingStyle{I} != Bosonic()`. In particular, we use `FibonacciAnyon`. We cannot convert
+`BraidingStyle(I) != Bosonic()`. In particular, we use `FibonacciAnyon`. We cannot convert
 the resulting `TensorMap` to an `Array`, so we have to rely on indirect tests to verify our
 results.