docs update, further tests update

Author: Jutho

docs/src/man/intro.md

@@ -244,10 +244,10 @@ rules"
 ``λ_{V^*}^{-1} ∘ (ϵ_V ⊗ \mathrm{id}_{V^*}) ∘ (\mathrm{id}_{V^*} ⊗ η_V) ∘ ρ_{V^*}^{-1} = \mathrm{id}_{V^*}``
 
 Given a morphism ``t::W→V``, we can now identify it with ``(t ⊗ \mathrm{id}_{W^*}) ∘ η_W``
-to obtain a morphism ``I→V⊗W^*``. For the category ``Vect``, this is the identification
-between linear maps ``W→V`` and tensors in ``V⊗W^*``. In particular, for complex vector
-spaces, using a bra-ket notation and a generic basis ``{|n⟩}`` for ``V`` and dual basis
-``{⟨m|}`` for ``V^*`` (such that ``⟨m|n⟩ = δ_{m,n}``), the unit is
+to obtain a morphism ``I→V⊗W^*``. For the category ``\mathbf{Vect}``, this is the
+identification between linear maps ``W→V`` and tensors in ``V⊗W^*``. In particular, for
+complex vector spaces, using a bra-ket notation and a generic basis ``{|n⟩}`` for ``V`` and
+dual basis ``{⟨m|}`` for ``V^*`` (such that ``⟨m|n⟩ = δ_{m,n}``), the unit is
 ``η_V:ℂ → V ⊗ V^*:λ → λ ∑_n |n⟩ ⊗ ⟨n|`` and the co-unit is
 ``⁠ϵ_V:V^* ⊗ V → ℂ: ⟨m| ⊗ |n⟩ → δ_{m,n}``. Note that this does not require an inner
 product, i.e. no mapping from ``|n⟩`` to ``⟨n|`` was defined. Furthermore, note that we
@@ -264,7 +264,7 @@ It does makes sense to define or identify
 
 In general categories, one can distinguish between a left and right dual, but we always
 assume that both objects are naturally isomorphic. Equivalently, ``V^{**} ≂ V`` and the
-category is said to be  **pivotal**. For every morphism `f:W→V`, there is then a well
+category is said to be  **pivotal**. For every morphism ``f:W→V``, there is then a well
 defined notion of a transpose (also called adjoint mate) ``f^*:V^* → W^*`` as
 
 ``f^* = λ_{W^*} ∘ (ϵ_V ⊗ \mathrm{id}_{W^*}) ∘ (\mathrm{id}_{V^*} ⊗ f ⊗ \mathrm{id}_{W^*}) ∘ (\mathrm{id}_{V^*} ⊗ η_{W}) ∘ ρ_{V^*}^{-1}``
@@ -273,18 +273,19 @@ defined notion of a transpose (also called adjoint mate) ``f^*:V^* → W^*`` as
 
 and both definitions coincide (which is not the case if the category is not pivotal). In a graphical representation, this means that boxes (representing tensor maps or morphisms more generally) can be rotated. The transpose corresponds to a 180˚ rotation (either way).
 
-A braiding ``σ_{V,V^*}`` provides a particular way to construct an exact pairing
-``ϵ_{V^*} = ϵ_V ∘ σ_{V,V^*} : V⊗V^* → I`` and ``η_{V^*} = σ_{V^*,V}^{-1} \circ η_V: I→ V^*⊗V``,
-but this mapping is not canonical for general braidings, so that a braided autonomous
-category is not automatically pivotal. A category that is both braided and pivotal
-automatically has a twist (and is thus balanced), vice versa a balanced autonomous category
-is automatically pivotal. However, the graphical representation using ribbons is only
-consistent if we furthermore have
+A braiding ``σ_{V,V^*}`` provides a particular way to construct an maps
+``ϵ_{V^*} = ϵ_V ∘ σ_{V,V^*} : V⊗V^* → I`` and
+``η_{V^*} = σ_{V^*,V}^{-1} \circ η_V: I→ V^*⊗V``, but these maps are not canonical for
+general braidings, so that a braided autonomous category is not automatically pivotal. A
+category that is both braided and pivotal automatically has a twist (and is thus balanced),
+vice versa a balanced autonomous category is automatically pivotal. However, the graphical
+representation using ribbons is only consistent if we furthermore have
 ``θ_{V^*} = θ_V^*`` (i.e. the transpose), in which case the category is said to be
 **tortile** or also a **ribbon category**.
 
 In the case of a symmetric braiding, most of these difficulties go away and the pivotal
-structure follows
+structure follows. A symmetric monoidal category with duals is known as a **compact closed
+category**.
 
 ### Adjoints
 

docs/src/man/spaces.md

@@ -10,8 +10,8 @@ codomain of the map. The starting point is an abstract type `VectorSpace`
 ```julia
 abstract type VectorSpace end
 ```
-which serves in a sense as the category ``Vect``. All instances of subtypes of `VectorSpace`
-will represent vector spaces. In particular, we define two abstract subtypes
+which serves in a sense as the category ``\mathbf{Vect}``. All instances of subtypes of
+`VectorSpace` will represent vector spaces. In particular, we define two abstract subtypes
 ```julia
 abstract type ElementarySpace{𝕜} <: VectorSpace end
 const IndexSpace = ElementarySpace
@@ -68,19 +68,18 @@ objects of the same concrete type (i.e. with the same type parameters in case of
 parametric type). In particular, every `ElementarySpace` should implement the following
 methods
 
-*   `dim(::ElementarySpace) -> ::Int`
-    return the dimension of the space as an `Int`
+*   `dim(::ElementarySpace) -> ::Int` returns the dimension of the space as an `Int`
 
-*   `dual{S<:ElementarySpace}(::S) -> ::S`
-    return the [dual space](http://en.wikipedia.org/wiki/Dual_space) `dual(V)`, using an
-    instance of the same concrete type (i.e. not via type parameters); this should satisfy
+*   `dual{S<:ElementarySpace}(::S) -> ::S` returns the
+    [dual space](http://en.wikipedia.org/wiki/Dual_space) `dual(V)`, using an instance of
+    the same concrete type (i.e. not via type parameters); this should satisfy
     `dual(dual(V)==V`
 
-*   `conj{S<:ElementarySpace}(::S) -> ::S`
-    return the [complex conjugate space](http://en.wikipedia.org/wiki/Complex_conjugate_vector_space)
+*   `conj{S<:ElementarySpace}(::S) -> ::S` returns the
+    [complex conjugate space](http://en.wikipedia.org/wiki/Complex_conjugate_vector_space)
     `conj(V)`, using an instance of the same concrete type (i.e. not via type parameters);
     this should satisfy `conj(conj(V))==V` and we automatically have
-    `conj{F<:Real}(V::ElementarySpace{F}) = V`.
+    `conj(V::ElementarySpace{ℝ}) = V`.
 
 For convenience, the dual of a space `V` can also be obtained as `V'`.
 
@@ -98,17 +97,18 @@ We furthermore define the abstract type
 ```julia
 abstract InnerProductSpace{𝕜} <: ElementarySpace{𝕜}
 ```
-to contain all vector spaces `V` which have an inner product and thus a canonical mapping from
-`dual(V)` to `V` (for `𝕜 ⊆ ℝ`) or from `dual(V)` to `conj(V)` (otherwise). This mapping
-is provided by the metric, but no further support for working with metrics is currently implemented.
+to contain all vector spaces `V` which have an inner product and thus a canonical mapping
+from `dual(V)` to `V` (for `𝕜 ⊆ ℝ`) or from `dual(V)` to `conj(V)` (otherwise). This
+mapping is provided by the metric, but no further support for working with metrics is
+currently implemented.
 
 Finally there is
 ```julia
 abstract EuclideanSpace{𝕜} <: InnerProductSpace{𝕜}
 ```
 to contain all spaces `V` with a standard Euclidean inner product (i.e. where the metric is
-the identity). These spaces have the natural isomorphisms `dual(V) == V` (for ` 𝕜<:Real`) or
-`dual(V) == conj(V)` (for ` 𝕜<:Complex`). In particular, we have two concrete types
+the identity). These spaces have the natural isomorphisms `dual(V) == V` (for ` 𝕜<:Real`)
+or `dual(V) == conj(V)` (for ` 𝕜<:Complex`). In particular, we have two concrete types
 ```julia
 immutable CartesianSpace <: EuclideanSpace{ℝ}
     d::Int
@@ -118,10 +118,10 @@ immutable ComplexSpace <: EuclideanSpace{ℂ}
   dual::Bool
 end
 ```
-to represent the Euclidean spaces $ℝ^d$ or $ℂ^d$ without further inner structure. They can be
-created using the syntax `ℝ^d` and `ℂ^d`, or `(ℂ^d)'`for the dual space of the latter. Note
-that the brackets are required because of the precedence rules, since `d' == d` for `d::Integer``.
-Some examples
+to represent the Euclidean spaces $ℝ^d$ or $ℂ^d$ without further inner structure. They can
+be created using the syntax `ℝ^d` and `ℂ^d`, or `(ℂ^d)'`for the dual space of the latter.
+Note that the brackets are required because of the precedence rules, since `d' == d` for
+`d::Integer`. Some examples:
 ```@repl tensorkit
 dim(ℝ^10)
 (ℝ^10)' == ℝ^10
@@ -136,19 +136,19 @@ an inner structure corresponding to the irreducible representations of a group.
 
 ## Composite spaces
 
-Composite spaces are vector spaces that are built up out of individual elementary vector spaces.
-The most prominent (and currently only) example is a tensor product of `N` elementary spaces
-of the same type `S`, which is implemented as
+Composite spaces are vector spaces that are built up out of individual elementary vector
+spaces. The most prominent (and currently only) example is a tensor product of `N` elementary spaces of the same type `S`, which is implemented as
 ```julia
 struct ProductSpace{S<:ElementarySpace, N} <: CompositeSpace{S}
     spaces::NTuple{N, S}
 end
 ```
 Given some `V1::S`, `V2::S`, `V3::S` of the same type `S<:ElementarySpace`, we can easily
-construct `ProductSpace{S,3}((V1,V2,V3))` as `ProductSpace(V1,V2,V3)` or using `V1 ⊗ V2 ⊗ V3`,
-where `⊗` is simply obtained by typing `\otimes`+TAB. In fact, for convenience, even the regular
-multiplication operator `*` acts as tensor product between vector spaces, and as a consequence
-so does raising a vector space to a positive integer power, i.e.
+construct `ProductSpace{S,3}((V1,V2,V3))` as `ProductSpace(V1,V2,V3)` or using
+`V1 ⊗ V2 ⊗ V3`, where `⊗` is simply obtained by typing `\otimes`+TAB. In fact, for
+convenience, also the regular multiplication operator `*` acts as tensor product between
+vector spaces, and as a consequence so does raising a vector space to a positive integer
+power, i.e.
 ```@repl tensorkit
 V1 = ℂ^2
 V2 = ℂ^3
@@ -158,51 +158,52 @@ dim(V1 ⊗ V2)
 dims(V1 ⊗ V2)
 dual(V1 ⊗ V2)
 ```
-Here, the new function `dims` maps `dim` to the individual spaces in a `ProductSpace` and returns
-the result as a tuple. Note that the rationale for the last result was explained in the subsection
-[Duals](@ref) of [Properties of monoidal categories](@ref).
+Here, the new function `dims` maps `dim` to the individual spaces in a `ProductSpace` and
+returns the result as a tuple. Note that the rationale for the last result was explained in
+the subsection [Duals](@ref) of [Properties of monoidal categories](@ref).
 
 Following Julia's Base library, the function `one` applied to a `ProductSpace{S,N}` returns
 the multiplicative identity, which is `ProductSpace{S,0}`. The same result is obtained when
-acting on an instance `V` of `S::ElementarySpace` directly, however note that `V ⊗ one(V)` will
-yield a `ProductSpace{S,1}(V)` and not `V` itself. Similar to Julia Base, `one` also works in
-the type domain.
-
-In the future, other `CompositeSpace` types could be added. For example, the wave function of
-an `N`-particle quantum system in first quantization would require the introduction of a `SymmetricSpace{S,N}`
-or a `AntiSymmetricSpace{S,N}` for bosons or fermions respectively, which correspond to the
-symmetric (permutation invariant) or antisymmetric subspace of `V^N`, where `V::S` represents
-the Hilbert space of the single particle system. Other domains, like general relativity, might
-also benefit from tensors living in a subspace with certain symmetries under specific index
-permutations.
+acting on an instance `V` of `S::ElementarySpace` directly, however note that `V ⊗ one(V)`
+will yield a `ProductSpace{S,1}(V)` and not `V` itself. Similar to Julia Base, `one` also
+works in the type domain.
+
+In the future, other `CompositeSpace` types could be added. For example, the wave function
+of an `N`-particle quantum system in first quantization would require the introduction of a
+`SymmetricSpace{S,N}` or a `AntiSymmetricSpace{S,N}` for bosons or fermions respectively,
+which correspond to the symmetric (permutation invariant) or antisymmetric subspace of
+`V^N`, where `V::S` represents the Hilbert space of the single particle system. Other
+domains, like general relativity, might also benefit from tensors living in a subspace with
+certain symmetries under specific index permutations.
 
 ## Some more functionality
-Some more convenience functions are provided for the euclidean spaces [`CartesianSpace`](@ref)
-and [`ComplexSpace`](@ref), as well as for [`RepresentationSpace`](@ref) discussed in the next
-section. All functions below that act on more than a single elementary space, are only defined
-when the different spaces are of the same concrete subtype `S<:ElementarySpace`
-
-The function `fuse(V1, V2, ...)` or `fuse(V1 ⊗ V2 ⊗ ...)` returns an elementary space that is
-isomorphic to `V1 ⊗ V2 ⊗ ...`, in the sense that a unitary tensor map can be constructed between
-those spaces, e.g. from `W = V1 ⊗ V2 ⊗ ...` to `V = fuse(V1 ⊗ V2 ⊗ ...)`. The function `flip(V1)`
-returns a space that is isomorphic to `V1` but has `isdual(flip(V1)) == isdual(V1')`, i.e. if
-`V1` is a normal space than `flip(V1)` is a dual space. Again, isomorphism here implies that
-a unitary map (but there is no canonical choice) can be constructed between both spaces. `flip(V1)`
-is different from `dual(V1)` in the case of [`RepresentationSpace`](@ref). It is useful to
-flip a tensor index from a ket to a bra (or vice versa), by contracting that index with a unitary
-map from `V1` to `map(V1)`. We refer to `[Index operations](@ref)` for further information.
-Some examples
+Some more convenience functions are provided for the euclidean spaces
+[`CartesianSpace`](@ref) and [`ComplexSpace`](@ref), as well as for
+[`RepresentationSpace`](@ref) discussed in the next section. All functions below that act
+on more than a single elementary space, are only defined when the different spaces are of
+the same concrete subtype `S<:ElementarySpace`
+
+The function `fuse(V1, V2, ...)` or `fuse(V1 ⊗ V2 ⊗ ...)` returns an elementary space that
+is isomorphic to `V1 ⊗ V2 ⊗ ...`, in the sense that a unitary tensor map can be constructed
+between those spaces, e.g. from `W = V1 ⊗ V2 ⊗ ...` to `V = fuse(V1 ⊗ V2 ⊗ ...)`. The
+function `flip(V1)` returns a space that is isomorphic to `V1` but has
+`isdual(flip(V1)) == isdual(V1')`, i.e. if `V1` is a normal space than `flip(V1)` is a dual
+space. Again, isomorphism here implies that a unitary map (but there is no canonical
+choice) can be constructed between both spaces. `flip(V1)` is different from `dual(V1)` in
+the case of [`RepresentationSpace`](@ref). It is useful to flip a tensor index from a ket
+to a bra (or vice versa), by contracting that index with a unitary map from `V1` to
+`flip(V1)`. We refer to `[Index operations](@ref)` for further information. Some examples:
 ```@repl tensorkit
 fuse(ℝ^5, ℝ^3)
 fuse(ℂ^3, (ℂ^5)', ℂ^2)
 flip(ℂ^4)
 ```
 
 We also define the direct sum `V1` and `V2` as `V1 ⊕ V2`, where `⊕` is obtained by typing
-`\oplus`+TAB. This is possible only if `isdual(V1) == isdual(V2)`. With a little pun on Julia
-Base, `oneunit` applied to an elementary space (in the value or type domain) returns the one-dimensional
-space, which is isomorphic to the scalar field of the spaceitself. Some examples illustrate
-this better
+`\oplus`+TAB. This is possible only if `isdual(V1) == isdual(V2)`. With a little pun on
+Julia Base, `oneunit` applied to an elementary space (in the value or type domain) returns
+the one-dimensional space, which is isomorphic to the scalar field of the spaceitself. Some
+examples illustrate this better
 ```@repl tensorkit
 ℝ^5 ⊕ ℝ^3
 ℂ^5 ⊕ ℂ^3
@@ -214,13 +215,13 @@ oneunit((ℂ^3)')
 (ℂ^5)' ⊕ oneunit((ℂ^5)')
 ```
 
-For two spaces `V1` and `V2`, `min(V1,V2)` returns the space with the smallest dimension, whereas
-`max(V1,V2)` returns the space with the largest dimension, as illustrated by
+For two spaces `V1` and `V2`, `min(V1,V2)` returns the space with the smallest dimension,
+whereas `max(V1,V2)` returns the space with the largest dimension, as illustrated by
 ```@repl tensorkit
 min(ℝ^5, ℝ^3)
 max(ℂ^5, ℂ^3)
 max(ℂ^5, (ℂ^3)')
 ```
 Again, we impose `isdual(V1) == isdual(V2)`. Again, the use of these methods is to construct
-unitary or isometric tensors that map between different spaces, which will be elaborated upon
-in the section on Tensors
+unitary or isometric tensors that map between different spaces, which will be elaborated
+upon in the section on Tensors.

test/runtests.jl

@@ -9,22 +9,22 @@ using TupleTools
 using TupleTools: StaticLength
 
 smallset(::Type{ZNIrrep{N}}) where {N} = map(ZNIrrep{N}, 1:N)
-smallset(::Type{CU₁}) = map(t->CU₁(t[1],t[2]), [(0,0),(0,1),(1//2,2),(1,2),(3//2,2),(2,2),(5//2,2),(3,2),(7//2,2),(4,2),(9//2,2),(5,2)])
+smallset(::Type{CU₁}) =
+    map(t->CU₁(t[1],t[2]), [(0,0), (0,1), (1//2,2), (1,2), (3//2,2), (2,2), (5//2,2),
+    (3,2), (7//2,2), (4,2), (9//2,2), (5,2)])
 smallset(::Type{U₁}) = map(U₁, -10:10)
 smallset(::Type{SU₂}) = map(SU₂, 1//2:1//2:2) # no zero, such that always non-trivial
-smallset(::Type{ProductSector{Tuple{G1,G2}}}) where {G1,G2} = rand([i × j for i in smallset(G1), j in smallset(G2)], 5)
+smallset(::Type{ProductSector{Tuple{G1,G2}}}) where {G1,G2} =
+    rand([i × j for i in smallset(G1), j in smallset(G2) if dim(i)*dim(j) <= 6], 5)
 
 randsector(::Type{ZNIrrep{N}}) where {N} = rand(smallset(ZNIrrep{N}))
 randsector(::Type{CU₁}) = rand(smallset(CU₁))
 randsector(::Type{U₁}) = rand(smallset(U₁))
 randsector(::Type{SU₂}) = rand(smallset(SU₂))
 randsector(::Type{ProductSector{Tuple{G1,G2}}}) where {G1,G2} =
-    randsector(G1) × randsector(G2)
+    rand([i × j for i in smallset(G1), j in smallset(G2) if dim(i)*dim(j) <= 6])
 randsector(::Type{ProductSector{Tuple{G1,G2,G3}}}) where {G1,G2,G3} =
     randsector(G1) × randsector(G2) × randsector(G3)
-# special case: make sure dimensions are not too big
-randsector(P::Type{SU₂×SU₂}) =
-    rand(collect(i × j for i in map(SU₂, 1//2:1//2:1), j in map(SU₂, 1//2:1//2:1)))
 
 include("sectors.jl")
 include("spaces.jl")