Fix docs and tests.

docs/src/manifolds/grassmann.md

@@ -10,7 +10,7 @@ Order = [:type,:function]
 
 ```@autodocs
 Modules = [Manifolds]
-Pages = ["GrassmannStiefel.jl"]
+Pages = ["manifolds/GrassmannStiefel.jl"]
 Order = [:type,:function]
 ```
 

docs/src/manifolds/hamiltonian.md

@@ -1,4 +1,4 @@
-# Symmetric matrices
+# Hamiltonian matrices
 
 ```@autodocs
 Modules = [Manifolds]

src/Manifolds.jl

@@ -637,6 +637,7 @@ export Euclidean,
     GeneralizedGrassmann,
     GeneralizedStiefel,
     Grassmann,
+    HamiltonianMatrices,
     HeisenbergGroup,
     Hyperbolic,
     KendallsPreShapeSpace,

src/manifolds/Hamiltonian.jl

@@ -28,6 +28,43 @@ function Matrix(A::Hamiltonian)
     return copy(A.value)
 end
 
+@doc raw"""
+    HamiltonianMatrices{T,𝔽} <: AbstractDecoratorManifold{𝔽}
+
+The [`AbstractManifold`](https://juliamanifolds.github.io/ManifoldsBase.jl/stable/types.html#ManifoldsBase.AbstractManifold)
+consisting of (real-valued) hamiltonian matrices of size ``n × n``, i.e. the set
+
+````math
+\mathfrak{sp}(2n,𝔽) = \bigl\{p  ∈ 𝔽^{2n × 2n}\ \big|\ p^+ = p \bigr\},
+````
+where ``\cdot^{+}`` denotes the [`symplectic_inverse`](@ref),. and ``𝔽 ∈ \{ ℝ, ℂ\}``.
+
+Though it is slightly redundant, usually the matrices are stored as ``2n × 2n`` arrays.
+
+The symbol refers to the main usage within `Manifolds.jl` that is the
+Lie algebra to the [`Symplectic`](@ref) as a Lie group with the matrix operation as group operation.
+
+# Constructor
+
+    HamiltonianMatrices(n::Int, field::AbstractNumbers=ℝ)
+
+Generate the manifold of ``n × n`` symmetric matrices.
+"""
+struct HamiltonianMatrices{T,𝔽} <: AbstractDecoratorManifold{𝔽}
+    size::T
+end
+
+function HamiltonianMatrices(n::Int, field::AbstractNumbers=ℝ; parameter::Symbol=:type)
+    size = wrap_type_parameter(parameter, (n,))
+    return HamiltonianMatrices{typeof(size),field}(size)
+end
+
+function active_traits(f, ::HamiltonianMatrices, args...)
+    return merge_traits(IsEmbeddedSubmanifold())
+end
+
+ManifoldsBase.@default_manifold_fallbacks HamiltonianMatrices Hamiltonian Hamiltonian value value
+
 @doc raw"""
     ^(A::Hamilonian, ::typeof(+))
 
@@ -37,6 +74,59 @@ function ^(A::Hamiltonian, ::typeof(+))
     return Hamiltonian(symplectic_inverse(A.value))
 end
 
+@doc raw"""
+    check_point(M::HamiltonianMatrices{n,𝔽}, p; kwargs...)
+
+Check whether `p` is a valid manifold point on the [`HamiltonianMatrices`](@ref) `M`, i.e.
+whether `p` [`is_hamiltonian`](@ref).
+
+The tolerance for the test of `p` can be set using `kwargs...`.
+"""
+function check_point(M::HamiltonianMatrices, p; kwargs...)
+    if !is_hamiltonian(p; kwargs...)
+        return DomainError(
+            norm((Hamiltonian(p)^+) + p),
+            "The point $(p) does not lie on $M, since it is not hamiltonian.",
+        )
+    end
+    return nothing
+end
+
+"""
+    check_vector(M::HamiltonianMatrices{n,𝔽}, p, X; kwargs... )
+
+Check whether `X` is a tangent vector to manifold point `p` on the
+[`HamiltonianMatrices`](@ref) `M`, i.e. `X` has to be a Hamiltonian matrix
+The tolerance for [`is_hamiltonian`](@ref) `X` can be set using `kwargs...`.
+"""
+function check_vector(M::HamiltonianMatrices, p, X; kwargs...)
+    if !is_hamiltonian(X; kwargs...)
+        return DomainError(
+            norm((Hamiltonian(X)^+) + X),
+            "The vector $(X) is not a tangent vector to $(p) on $(M), since it is not hamiltonian.",
+        )
+    end
+    return nothing
+end
+
+embed(::HamiltonianMatrices, p) = p
+embed(::HamiltonianMatrices, p, X) = X
+
+function get_embedding(::HamiltonianMatrices{TypeParameter{Tuple{N}},𝔽}) where {N,𝔽}
+    return Euclidean(N, N; field=𝔽)
+end
+function get_embedding(M::HamiltonianMatrices{Tuple{Int},𝔽}) where {𝔽}
+    N = get_parameter(M.size)[1]
+    return Euclidean(N, N; field=𝔽, parameter=:field)
+end
+
+"""
+    is_flat(::HamiltonianMatrices)
+
+Return true. [`HamiltonianMatrices`](@ref) is a flat manifold.
+"""
+is_flat(M::HamiltonianMatrices) = true
+
 @doc raw"""
     is_hamiltonian(A; kwargs...)
 
@@ -48,7 +138,7 @@ A^+ = -A
 ```
 where ``A^+`` denotes the [`symplectic_inverse`](@ref) of `A`.
 
-The passed keyword arguments are passed on to the [`isapprox`](@ref)
+The passed keyword arguments are passed on to `isapprox`
 check within
 """
 function is_hamiltonian(A::AbstractMatrix; kwargs...)
@@ -61,5 +151,11 @@ end
 function show(io::IO, ::MIME"text/plain", A::Hamiltonian)
     return print(io, "Hamiltonian($(A.value))")
 end
-
+function Base.show(io::IO, ::HamiltonianMatrices{TypeParameter{Tuple{n}},F}) where {n,F}
+    return print(io, "HamiltonianMatrices($(n), $(F))")
+end
+function Base.show(io::IO, M::HamiltonianMatrices{Tuple{Int},F}) where {F}
+    n = get_parameter(M.size)[1]
+    return print(io, "HamiltonianMatrices($(n), $(F); parameter=:field)")
+end
 size(A::Hamiltonian) = size(A.value)

src/manifolds/Symmetric.jl

@@ -1,16 +1,16 @@
 @doc raw"""
     SymmetricMatrices{n,𝔽} <: AbstractDecoratorManifold{𝔽}
 
-The [`AbstractManifold`](https://juliamanifolds.github.io/ManifoldsBase.jl/stable/types.html#ManifoldsBase.AbstractManifold)  $ \operatorname{Sym}(n)$ consisting of the real- or complex-valued
-symmetric matrices of size $n × n$, i.e. the set
+The [`AbstractManifold`](https://juliamanifolds.github.io/ManifoldsBase.jl/stable/types.html#ManifoldsBase.AbstractManifold)  ``\operatorname{Sym}(n)`` consisting of the real- or complex-valued
+symmetric matrices of size ``n × n``, i.e. the set
 
 ````math
 \operatorname{Sym}(n) = \bigl\{p  ∈ 𝔽^{n × n}\ \big|\ p^{\mathrm{H}} = p \bigr\},
 ````
-where $\cdot^{\mathrm{H}}$ denotes the Hermitian, i.e. complex conjugate transpose,
-and the field $𝔽 ∈ \{ ℝ, ℂ\}$.
+where ``\cdot^{\mathrm{H}}`` denotes the Hermitian, i.e. complex conjugate transpose,
+and the field ``𝔽 ∈ \{ ℝ, ℂ\}``.
 
-Though it is slightly redundant, usually the matrices are stored as $n × n$ arrays.
+Though it is slightly redundant, usually the matrices are stored as ``n × n`` arrays.
 
 Note that in this representation, the complex valued case has to have a real-valued diagonal,
 which is also reflected in the [`manifold_dimension`](@ref manifold_dimension(::SymmetricMatrices)).
@@ -19,7 +19,7 @@ which is also reflected in the [`manifold_dimension`](@ref manifold_dimension(::
 
     SymmetricMatrices(n::Int, field::AbstractNumbers=ℝ)
 
-Generate the manifold of $n × n$ symmetric matrices.
+Generate the manifold of ``n × n`` symmetric matrices.
 """
 struct SymmetricMatrices{T,𝔽} <: AbstractDecoratorManifold{𝔽}
     size::T
@@ -186,7 +186,7 @@ Return the dimension of the [`SymmetricMatrices`](@ref) matrix `M` over the numb
 \end{aligned}
 ````
 
-where the last $-n$ is due to the zero imaginary part for Hermitian matrices
+where the last ``-n`` is due to the zero imaginary part for Hermitian matrices
 """
 function manifold_dimension(M::SymmetricMatrices{<:Any,𝔽}) where {𝔽}
     N = get_parameter(M.size)[1]
@@ -202,7 +202,7 @@ Projects `p` from the embedding onto the [`SymmetricMatrices`](@ref) `M`, i.e.
 \operatorname{proj}_{\operatorname{Sym}(n)}(p) = \frac{1}{2} \bigl( p + p^{\mathrm{H}} \bigr),
 ````
 
-where $\cdot^{\mathrm{H}}$ denotes the Hermitian, i.e. complex conjugate transposed.
+where ``\cdot^{\mathrm{H}}`` denotes the Hermitian, i.e. complex conjugate transposed.
 """
 project(::SymmetricMatrices, ::Any)
 
@@ -220,7 +220,7 @@ Project the matrix `X` onto the tangent space at `p` on the [`SymmetricMatrices`
 \operatorname{proj}_p(X) = \frac{1}{2} \bigl( X + X^{\mathrm{H}} \bigr),
 ````
 
-where $\cdot^{\mathrm{H}}$ denotes the Hermitian, i.e. complex conjugate transposed.
+where ``\cdot^{\mathrm{H}}`` denotes the Hermitian, i.e. complex conjugate transposed.
 """
 project(::SymmetricMatrices, ::Any, ::Any)
 

src/manifolds/SymplecticGrassmann.jl

@@ -6,27 +6,17 @@ The symplectic Grassmann manifold consists of all symplectic subspaces of
 
 This manifold can be represented as corresponding representers on the [`SymplecticStiefel`](@ref)
 
-````math
-\operatorname{SpGr}(2n,2k) := \bigl\{ \operatorname{span}(p)  \ \big| \ p ∈ \operatorname{SpSt}(2n, 2k, \mathhb R)\},
-````
+```math
+\operatorname{SpGr}(2n,2k) = \bigl\{ \operatorname{span}(p)\ \big| \ p ∈ \operatorname{SpSt}(2n, 2k, ℝ)\},
+```
 
 or as projectors
 
-````math
+```math
 \operatorname{SpGr}(2n, 2k, ℝ) = \bigl\{ p ∈ ℝ^{2n × 2n} \ \big| \ p^2 = p, \operatorname{rank}(p) = 2k, p^+=p \bigr\},
-````
-
-where ``⋅^+`` is defined even more general for ``q∈\mathbb R^{2n × 2k}`` matrices as
+```
 
-````math
-q^+ := J_{2k}^{\mathrm{T}}q^{\mathrm{T}}J_{2n}
-\quad\text{ with }\quad
-J_{2n} =
-\begin{bmatrix}
-  0_n & I_n \\
- -I_n & 0_n
-\end{bmatrix}.
-````
+where ``⋅^+`` is the [`symplectic_inverse`](@ref).
 
 See also [`ProjectorPoint`](@ref) and [`StiefelPoint`](@ref) for these two representations,
 where arrays are interpreted as those on the Stiefel manifold.
@@ -36,15 +26,12 @@ tangent vectors are representers of their corresponding congruence classes, or f
 representation as projectors, using a [`ProjectorTVector`](@ref) as
 
 ```math
-  T_p\operatorname{SpGr}(2n, 2k, ℝ)
-  = \bigl\{
-    [X,p] \ \mid\ X ∈ \mathfrac{sp(2n,\mathbb R), Xp+pX = X
-  \bigr\},
+  T_p\operatorname{SpGr}(2n, 2k, ℝ) =
+  \bigl\{ [X,p] \ \mid\ X ∈ \mathfrak{sp}(2n,ℝ), Xp+pX = X \bigr\},
 ```
-where
-``[X,p] = Xp-pX`` denotes the matrix commutator and
-``\mathfrac{sp}(2n,\mathbb R) = \{ X \in \mathbb R^{2n × 2n} \ \mid\ X^+ = -X\}``
-is the Lie algebra of the Hamiltonian matrices.
+
+where ``[X,p] = Xp-pX`` denotes the matrix commutator and
+``\mathfrak{sp}(2n,ℝ)`` is the Lie algebra of the symplectic group consisting of [`HamiltonianMatrices`](@ref)
 
 For simplicity, the [`ProjectorTVector`](@ref) is stored as just ``X`` from the representation above.
 
@@ -90,7 +77,7 @@ Return the dimension of the [`SymplecticGrassmann`](@ref)`(2n,2k)`, which is
 \operatorname{dim}\operatorname{SpGr}(2n, 2k) = 4(n-k)k,
 ````
 
-see [BendokatZimmermann](@cite), Section 4.
+see [BendokatZimmermann:2021](@cite), Section 4.
 """
 function manifold_dimension(::SymplecticGrassmann{<:Any,ℝ})
     n, k = get_parameter(M.size)

src/manifolds/SymplecticGrassmannProjector.jl

@@ -5,7 +5,7 @@ Check whether `p` is a valid point on the [`SymplecticGrassmann`](@ref),
 ``\operatorname{SpGr}(2n, 2k)``, that is a propoer symplectic projection:
 
 * ``p^2 = p``, that is ``p`` is a projection
-* ``\operatorname{rank(p) = 2k``, that is, the supspace projected onto is of right dimension
+* ``\operatorname{rank}(p) = 2k``, that is, the supspace projected onto is of right dimension
 * ``p^+ = p`` the projection is symplectic.
 """
 function check_point(M::SymplecticGrassmann, p::ProjectorPoint; kwargs...)
@@ -42,10 +42,10 @@ Check whether `X` is a valid tangent vector at `p` on the [`SymplecticGrassmann`
 * ``X^+ = -X``, verify that `X` is [`Hamiltonian`](@ref)
 * ``X = Xp + pX``
 
-For details see Proposition 4.2 in [BendokatZimmermannAbsil:2020](@cite) and the definition of ``\mathfrac{sp}_P(2n)`` before,
+For details see Proposition 4.2 in [BendokatZimmermann:2021](@cite) and the definition of ``\mathfrak{sp}_P(2n)`` before,
 especially the ``\bar{Ω}``, which is the representation for ``X`` used here.
 """
-function check_point(
+function check_vector(
     M::SymplecticGrassmann,
     p::ProjectorPoint,
     X::ProjectorTVector;
@@ -54,7 +54,7 @@ function check_point(
     n, k = get_parameter(M.size)
     if !is_hamiltonian(X.value; kwargs...)
         return DomainError(
-            norm(Hamiltonian(X.value)^+X.value),
+            norm((Hamiltonian(X.value)^+) + X.value),
             (
                 "The matrix X is not in the tangent space at $p of $M, since X is not Hamiltonian."
             ),

src/manifolds/SymplecticGrassmannStiefel.jl

@@ -19,7 +19,7 @@ Check whether `X` is a valid tangent vector at `p` on the [`SymplecticGrassmann`
 is a valid representer of an equivalence class of the corersponding
 [`SymplecticStiefel`](@ref) manifolds tangent space at `p`.
 """
-function check_point(M::SymplecticGrassmann, p, X; kwargs...)
+function check_vector(M::SymplecticGrassmann, p, X; kwargs...)
     n, k = get_parameter(M.size)
     return check_vector(SymplecticStiefel(2 * n, 2 * k), p, X; kwargs...)
 end

test/manifolds/symplecticstiefel.jl

@@ -311,7 +311,7 @@ end
     @testset "field parameter" begin
         SpSt_6_4 = SymplecticStiefel(2 * 3, 2 * 2; parameter=:field)
         @test typeof(get_embedding(SpSt_6_4)) === Euclidean{Tuple{Int,Int},ℝ}
-        @test repr(SpSt_6_4) == "SymplecticStiefel(6, 4, ℝ; parameter=:field)"
+        @test repr(SpSt_6_4) == "SymplecticStiefel(6, 4; field=ℝ; parameter=:field)"
         @test get_total_space(SpSt_6_4) == Symplectic(6; parameter=:field)
     end
 end