Flag manifold

Manifolds.Flag — Type

Flag{T,d} <: AbstractDecoratorManifold{ℝ}

Flag manifold of $d$ subspaces of $ℝ^N$ [YWL21]. By default the manifold uses the Stiefel coordinates representation, embedding it in the Stiefel manifold. The other available representation is an embedding in OrthogonalMatrices. It can be utilized using OrthogonalPoint and OrthogonalTangentVector wrappers.

Tangent space is represented in the block-skew-symmetric form.

Constructor

Flag(N, n_1, n_2, ..., n_d; parameter::Symbol=:type)

Generate the manifold $\operatorname{Flag}(n_1, n_2, ..., n_d; N)$ of subspaces

\[𝕍_1 ⊆ 𝕍_2 ⊆ ⋯ ⊆ V_d, \quad \operatorname{dim}(𝕍_i) = n_i\]

where $𝕍_i$ for $i ∈ 1, 2, …, d$ are subspaces of $ℝ^N$ of dimension $\operatorname{dim} 𝕍_i = n_i$.

parameter: whether a type parameter should be used to store n. By default size is stored in type. Value can either be :field or :type.

Manifolds.OrthogonalPoint — Type

OrthogonalPoint <: AbstractManifoldPoint

A type to represent points on a manifold Flag in the orthogonal coordinates representation, i.e. a rotation matrix.

Manifolds.OrthogonalTangentVector — Type

OrthogonalTangentVector <: AbstractTangentVector

A type to represent tangent vectors to points on a Flag manifold in the orthogonal coordinates representation.

Manifolds.ZeroTuple — Type

ZeroTuple

Internal structure for representing shape of a Flag manifold. Behaves like a normal tuple, except at index zero returns value 0.

Base.convert — Method

convert(::Type{AbstractMatrix}, M::Flag, p::OrthogonalPoint, X::OrthogonalTangentVector)

Convert tangent vector from Flag manifold M from orthogonal representation to Stiefel representation.

Base.convert — Method

convert(::Type{AbstractMatrix}, M::Flag, p::OrthogonalPoint)

Convert point p from Flag manifold M from orthogonal representation to Stiefel representation.

Base.convert — Method

convert(::Type{OrthogonalPoint}, M::Flag, p::AbstractMatrix)

Convert point p from Flag manifold M from Stiefel representation to orthogonal representation.

Base.convert — Method

convert(::Type{OrthogonalTangentVector}, M::Flag, p::AbstractMatrix, X::AbstractMatrix)

Convert tangent vector from Flag manifold M from Stiefel representation to orthogonal representation.

ManifoldsBase.get_embedding — Method

get_embedding(M::Flag)

Get the embedding of the Flag manifold M, i.e. the Stiefel manifold.

ManifoldsBase.injectivity_radius — Method

injectivity_radius(M::Flag)
injectivity_radius(M::Flag, p)

Return the injectivity radius on the Flag M, which is $\frac{π}{2}$.

ManifoldsBase.manifold_dimension — Method

manifold_dimension(M::Flag)

Return dimension of flag manifold $\operatorname{Flag}(n_1, n_2, ..., n_d; N)$. The formula reads $\sum_{i=1}^d (n_i-n_{i-1})(N-n_i)$.

The flag manifold represented as points on the Stiefel manifold

ManifoldsBase.check_vector — Method

check_vector(M::Flag, p::AbstractMatrix, X::AbstractMatrix; kwargs... )

Check whether X is a tangent vector to point p on the Flag manifold M $\operatorname{Flag}(n_1, n_2, ..., n_d; N)$ in the Stiefel representation, i.e. that X is a matrix of the form

\[X = \begin{bmatrix} 0 & B_{1,2} & ⋯ & B_{1,d} \\ -B_{1,2}^\mathrm{T} & 0 & ⋯ & B_{2,d} \\ \vdots & \vdots & ⋱ & \vdots \\ -B_{1,d}^\mathrm{T} & -B_{2,d}^\mathrm{T} & ⋯ & 0 \\ -B_{1,d+1}^\mathrm{T} & -B_{2,d+1}^\mathrm{T} & ⋯ & -B_{d,d+1}^\mathrm{T} \end{bmatrix}\]

where $B_{i,j} ∈ ℝ^{(n_i - n_{i-1}) × (n_j - n_{j-1})}$, for $1 ≤ i < j ≤ d+1$.

ManifoldsBase.default_inverse_retraction_method — Method

default_inverse_retraction_method(M::Flag)

Return PolarInverseRetraction as the default inverse retraction for the Flag manifold.

ManifoldsBase.default_retraction_method — Method

default_retraction_method(M::Flag)

Return PolarRetraction as the default retraction for the Flag manifold.

ManifoldsBase.default_vector_transport_method — Method

default_vector_transport_method(M::Flag)

Return the ProjectionTransport as the default vector transport method for the Flag manifold.

ManifoldsBase.inverse_retract — Method

inverse_retract(M::Flag, p, q, ::PolarInverseRetraction)

Compute the inverse retraction for the PolarRetraction, on the Flag manifold M.

ManifoldsBase.project — Method

project(::Flag, p, X)

Project vector X in the Euclidean embedding to the tangent space at point p on Flag manifold. The formula reads [YWL21]:

\[Y_i = X_i - (p_i p_i^{\mathrm{T}}) X_i + \sum_{j \neq i} p_j X_j^{\mathrm{T}} p_i\]

for $i$ from 1 to $d$ where the resulting vector is $Y = [Y_1, Y_2, …, Y_d]$ and $X = [X_1, X_2, …, X_d]$, $p = [p_1, p_2, …, p_d]$ are decompositions into basis vector matrices for consecutive subspaces of the flag.

ManifoldsBase.retract — Method

retract(M::Flag, p, X, ::PolarRetraction)

Compute the SVD-based retraction PolarRetraction on the Flag M. With $USV = p + X$ the retraction reads

\[\operatorname{retr}_p X = UV^\mathrm{H},\]

where $\cdot^{\mathrm{H}}$ denotes the complex conjugate transposed or Hermitian.

The flag manifold represented as orthogonal matrices

ManifoldsBase.check_vector — Method

check_vector(M::Flag, p::OrthogonalPoint, X::OrthogonalTangentVector; kwargs... )

Check whether X is a tangent vector to point p on the Flag manifold M $\operatorname{Flag}(n_1, n_2, ..., n_d; N)$ in the orthogonal matrix representation, i.e. that X is block-skew-symmetric with zero diagonal:

\[X = \begin{bmatrix} 0 & B_{1,2} & ⋯ & B_{1,d+1} \\ -B_{1,2}^\mathrm{T} & 0 & ⋯ & B_{2,d+1} \\ \vdots & \vdots & ⋱ & \vdots \\ -B_{1,d+1}^\mathrm{T} & -B_{2,d+1}^\mathrm{T} & ⋯ & 0 \end{bmatrix}\]

where $B_{i,j} ∈ ℝ^{(n_i - n_{i-1}) × (n_j - n_{j-1})}$, for $1 ≤ i < j ≤ d+1$.

ManifoldsBase.get_embedding — Method

get_embedding(M::Flag, p::OrthogonalPoint)

Get embedding of Flag manifold M, i.e. the manifold OrthogonalMatrices.

ManifoldsBase.project — Method

project(M::Flag, p::OrthogonalPoint, X::OrthogonalTangentVector)

Project vector X to tangent space at point p from Flag manifold M $\operatorname{Flag}(n_1, n_2, ..., n_d; N)$, in the orthogonal matrix representation. It works by first projecting X to the space of SkewHermitianMatrices and then setting diagonal blocks to 0:

\[X = \begin{bmatrix} 0 & B_{1,2} & ⋯ & B_{1,d+1} \\ -B_{1,2}^\mathrm{T} & 0 & ⋯ & B_{2,d+1} \\ \vdots & \vdots & ⋱ & \vdots \\ -B_{1,d+1}^\mathrm{T} & -B_{2,d+1}^\mathrm{T} & ⋯ & 0 \end{bmatrix}\]

where $B_{i,j} ∈ ℝ^{(n_i - n_{i-1}) × (n_j - n_{j-1})}$, for $1 ≤ i < j ≤ d+1$.

ManifoldsBase.retract — Method

retract(M::Flag, p::OrthogonalPoint, X::OrthogonalTangentVector, ::QRRetraction)

Compute the QR retraction on the Flag in the orthogonal matrix representation as the first order approximation to the exponential map. Similar to QR retraction for [GeneralUnitaryMatrices].

Flag{T,d} <: AbstractDecoratorManifold{ℝ}

Flag manifold of subspaces of [YWL21].

OrthogonalPoint <: AbstractManifoldPoint

A type to represent points on a manifold Flag in the orthogonal coordinates representation, i.e. a rotation matrix.

OrthogonalTangentVector <: AbstractTangentVector

A type to represent tangent vectors to points on a Flag manifold in the orthogonal coordinates representation.

check_vector(M::Flag, p::AbstractMatrix, X::AbstractMatrix; kwargs... )

Check whether X is a tangent vector to point p on the Flag manifold M in the Stiefel representation, i.e. that X is a matrix of the form

check_vector(M::Flag, p::OrthogonalPoint, X::OrthogonalTangentVector; kwargs... )

Check whether X is a tangent vector to point p on the Flag manifold M in the orthogonal matrix representation, i.e. that X is block-skew-symmetric with zero diagonal:

get_embedding(M::Flag, p::OrthogonalPoint)

Get embedding of Flag manifold M, i.e. the manifold OrthogonalMatrices.

manifold_dimension(M::Flag)

Return dimension of flag manifold .

project(::Flag, p, X)

Project vector X in the Euclidean embedding to the tangent space at point p on Flag manifold.

project(M::Flag, p::OrthogonalPoint, X::OrthogonalTangentVector)

Project vector X to tangent space at point p from Flag manifold M , in the orthogonal matrix representation.

check_vector(M::CenteredMatrices, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the CenteredMatrices M, i.e. that X is a matrix of size (m, n) whose columns sum to zero and its values are from the correct AbstractNumbers.

manifold_dimension(M::CenteredMatrices)

Return the manifold dimension of the CenteredMatrices m-by-n matrix M over the number system 𝔽, i.e.

project(M::CenteredMatrices, p, X)

Project the matrix X onto the tangent space at p on the CenteredMatrices M, i.e.

check_vector(M::CholeskySpace, p, X; kwargs... )

Check whether v is a tangent vector to p on the CholeskySpace M, i.e. after check_point(M,p), X has to have the same dimension as p and a symmetric matrix.

manifold_dimension(M::CholeskySpace)

Return the manifold dimension for the CholeskySpace M, i.e.

check_vector(M::Circle, p, X; kwargs...)

Check whether X is a tangent vector in the tangent space of p on the Circle M.

manifold_dimension(M::Circle)

Return the dimension of the Circle M, i.e. .

project(M::Circle, p, X)

Project a value X onto the tangent space of the point p on the Circle M.

check_vector(M::DeterminantOneMatrices{n,𝔽}, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the DeterminantOneMatrices M, which are all matrices of size with trace 0.

manifold_dimension(M::DeterminantOneMatrices{n,𝔽})

Return the dimension of the DeterminantOneMatrices matrix M over the number system 𝔽, which is one dimension less than its embedding, the Euclidean(n, n; field=𝔽).

project(G::DeterminantOneMatrices, p, X)
project!(G::DeterminantOneMatrices, Y, p, X)

Orthogonally project onto the tangent space of to the DeterminantOneMatrices.

check_vector(M::Elliptope, q, Y; kwargs... )

Check whether is a tangent vector to on the Elliptope M, i.e. Y has to be of same dimension as q and a has to be a symmetric matrix with zero diagonal.

manifold_dimension(M::Elliptope)

returns the dimension of Elliptope M , i.e.

project(M::Elliptope, q, Y)

Project Y onto the tangent space at q, i.e. row-wise onto the oblique manifold.

check_vector(M::EssentialManifold, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the EssentialManifold M, i.e. X has to be a 2-element array of 3-by-3 skew-symmetric matrices.

manifold_dimension(M::EssentialManifold{is_signed, ℝ})

Return the manifold dimension of the EssentialManifold, which is 5[TD17].

project(M::EssentialManifold, p, X)

Project the matrix X onto the tangent space

manifold_dimension(M::Euclidean)

Return the manifold dimension of the Euclidean M, i.e. the product of all array dimensions and the real_dimension of the underlying number system.

project(M::Euclidean, p, X)

Project an arbitrary vector X into the tangent space of a point p on the Euclidean M, which is just the identity, since any tangent space of M can be identified with all of M.

check_vector(M::FixedRankMatrices, p, X; kwargs...)

Check whether the tangent UMVTangentVector X is from the tangent space of the SVDMPoint p on the FixedRankMatrices M.

manifold_dimension(M::FixedRankMatrices)

Return the manifold dimension for the 𝔽-valued FixedRankMatrices M of dimension mxn of rank k, namely

project(M, p, A)

Project the matrix or from the embedding the tangent space at on the FixedRankMatrices M, further decomposing the result into , i.e. a UMVTangentVector.

check_vector(M::GeneralizedGrassmann, p, X; kwargs...)

Check whether X is a tangent vector in the tangent space of p on the GeneralizedGrassmann M, i.e. that X is of size and type as well as that

manifold_dimension(M::GeneralizedGrassmann)

Return the dimension of the GeneralizedGrassmann(n,k,𝔽) manifold M, i.e.

project(M::GeneralizedGrassmann, p, X)

Project the n-by-k X onto the tangent space of p on the GeneralizedGrassmann M, which is computed by

check_vector(M::GeneralizedStiefel, p, X; kwargs...)

Check whether X is a valid tangent vector at p on the GeneralizedStiefel M=.

manifold_dimension(M::GeneralizedStiefel)

Return the dimension of the GeneralizedStiefel manifold M=.

project(M:GeneralizedStiefel, p, X)

Project X onto the tangent space of p to the GeneralizedStiefel manifold M.

check_vector(M::UnitaryMatrices, p, X; kwargs... )
check_vector(M::OrthogonalMatrices, p, X; kwargs... )
check_vector(M::Rotations, p, X; kwargs... )
check_vector(M::GeneralUnitaryMatrices, p, X; kwargs... )

Check whether X is a tangent vector to p on the UnitaryMatrices space M, i.e. after check_point(M,p), X has to be skew symmetric (Hermitian) and orthogonal to p.

manifold_dimension(M::Rotations)
manifold_dimension(M::OrthogonalMatrices)

Return the dimension of the manifold orthogonal matrices and of the manifold of rotations

manifold_dimension(M::SpecialUnitaryMatrices)

Return the dimension of the manifold of special unitary matrices.

manifold_dimension(M::UnitaryMatrices{n,ℂ}) where {n}

Return the dimension of the manifold unitary matrices.

manifold_dimension(M::UnitaryMatrices{<:Any,ℍ})

Return the dimension of the manifold unitary matrices.

project(M::OrthogonalMatrices, p, X)
project(M::Rotations, p, X)
project(M::UnitaryMatrices, p, X)

Orthogonally project the tangent vector , to the tangent space of M at p, and change the representer to use the corresponding Lie algebra, i.e. we compute

check_vector(M::GraphManifold, p, X; kwargs...)

Check whether X is a valid tangent vector at p on the GraphManifold M.

manifold_dimension(N::GraphManifold{G,𝔽,M,EdgeManifold})

returns the manifold dimension of the GraphManifold N on the edges of a graph , i.e.

manifold_dimension(N::GraphManifold{G,𝔽,M,VertexManifold})

returns the manifold dimension of the GraphManifold N on the vertices of a graph , i.e.

check_vector(::Grassmann, p::ProjectorPoint, X::ProjectorTangentVector; kwargs...)

Check whether the ProjectorTangentVector X is from the tangent space at the ProjectorPoint p on the Grassmann manifold .

get_embedding(M::Grassmann, ::Type{<:ProjectorPoint})

Return the embedding of the ProjectorPoint representation of the Grassmann manifold, i.e. the Euclidean space .

manifold_dimension(M::Grassmann)

Return the dimension of the Grassmann(n,k,𝔽) manifold M, i.e.

project(M::Grassmann, p, X)

Project the n-by-k X onto the tangent space of p on the Grassmann M, which is computed by

check_vector(M::HamiltonianMatrices, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the HamiltonianMatrices M, i.e. X has to be a Hamiltonian matrix The tolerance for is_hamiltonian X can be set using kwargs....

manifold_dimension(M::HeisenbergMatrices)

Return the dimension of HeisenbergMatrices(n), which is equal to .

check_vector(M::Hyperbolic, p, X; kwargs... )

Check whether X is a tangent vector to p on the Hyperbolic M, i.e. after check_point(M,p), X has to be of the same dimension as p.

manifold_dimension(M::Hyperbolic)

Return the dimension of the hyperbolic space manifold , i.e. .

project(M::Hyperbolic, p, X)

Perform an orthogonal projection with respect to the Minkowski inner product of X onto the tangent space at p of the Hyperbolic space M.

project(::Hyperbolic, ::PoincareBallPoint, ::PoincareBallTangentVector)

projection of tangent vectors in the Poincaré ball model is just the identity, since the tangent space consists of all .

injectivity_radius(M::Hyperrectangle, p)

Return the injectivity radius on the Hyperrectangle M at point p, which is the distance to the nearest boundary the point is not on.

manifold_dimension(M::Hyperrectangle)

Return the manifold dimension of the Hyperrectangle M, i.e. the product of all array dimensions.

project(M::Hyperrectangle, p, X)

Project an arbitrary vector X into the tangent space of a point p on the Hyperrectangle M.

check_vector(M::InvertibleMatrices{n,𝔽}, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the InvertibleMatrices M, which are all matrices of size its values have to be from the correct AbstractNumbers.

manifold_dimension(M::InvertibleMatrices{n,𝔽})

Return the dimension of the InvertibleMatrices matrix M over the number system 𝔽, which is the same dimension as its embedding, the Euclidean(n, n; field=𝔽).

check_vector(M::MultinomialMatrices p, X; kwargs...)

Checks whether X is a valid tangent vector to p on the MultinomialMatrices M.

check_vector(M::MultinomialDoubleStochastic p, X; kwargs...)

Checks whether X is a valid tangent vector to p on the MultinomialDoubleStochastic M.

manifold_dimension(M::MultinomialDoubleStochastic)

returns the dimension of the MultinomialDoubleStochastic manifold namely

project(M::MultinomialDoubleStochastic, p, Y)

Project Y onto the tangent space at p on the MultinomialDoubleStochastic M, return the result in X.

check_vector(M::MultinomialSymmetric p, X; kwargs...)

Checks whether X is a valid tangent vector to p on the MultinomialSymmetric M.

manifold_dimension(M::MultinomialSymmetric)

returns the dimension of the MultinomialSymmetric manifold namely

project(M::MultinomialSymmetric, p, Y)

Project Y onto the tangent space at p on the MultinomialSymmetric M, return the result in X.

check_vector(M::Oblique p, X; kwargs...)

Checks whether X is a valid tangent vector to p on the Oblique M.

check_vector(M::PositiveNumbers, p, X; kwargs...)

Check whether X is a tangent vector in the tangent space of p on the PositiveNumbers M.

manifold_dimension(M::PositiveNumbers)

Return the dimension of the PositiveNumbers M, i.e. of the 1-dimensional hyperbolic space,

project(M::PositiveNumbers, p, X)

Project a value X onto the tangent space of the point p on the PositiveNumbers M, which is just the identity.

check_vector(M::ProbabilitySimplex, p, X; kwargs... )

Check whether X is a tangent vector to p on the ProbabilitySimplex M, i.e. after check_point(M,p), X has to be of same dimension as p and its elements have to sum to one.

injectivity_radius(M::ProbabilitySimplex, p)

Compute the injectivity radius on the ProbabilitySimplex M at the point p, i.e. the distance radius to a point near/on the boundary, that could be reached by following the geodesic.

manifold_dimension(M::ProbabilitySimplex)

Returns the manifold dimension of the probability simplex in , i.e.

project(M::ProbabilitySimplex, p, Y)

Project Y from the embedding onto the tangent space at p on the ProbabilitySimplex M.

check_vector(M::AbstractProjectiveSpace, p, X; kwargs... )

Check whether X is a tangent vector in the tangent space of p on the AbstractProjectiveSpace M.

manifold_dimension(M::AbstractProjectiveSpace{𝔽}) where {𝔽}

Return the real dimension of the AbstractProjectiveSpace M, respectively i.e. the real dimension of the embedding minus the real dimension of the field 𝔽.

project(M::AbstractProjectiveSpace, p, X)

Orthogonally project the point X onto the tangent space at p on the AbstractProjectiveSpace M:

injectivity_radius(M::Rotations, ::PolarRetraction)

Return the radius of injectivity for the PolarRetraction on the Rotations M which is .

check_vector(M::KendallsPreShapeSpace, p, X; kwargs... )

Check whether X is a valid tangent vector on KendallsPreShapeSpace, i.e. whether each row has zero mean.

manifold_dimension(M::KendallsPreShapeSpace)

Return the dimension of the KendallsPreShapeSpace manifold M.

manifold_dimension(M::KendallsShapeSpace)

Return the dimension of the KendallsShapeSpace manifold M.

project(M::KendallsPreShapeSpace, p, X)

Project tangent vector X at point p from the embedding to KendallsPreShapeSpace by selecting the right element from the tangent space to orthogonal section representing the quotient manifold M.

check_vector(M::SkewHermitianMatrices, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the SkewHermitianMatrices M, i.e. X must be a skew-hermitian matrix of size (n,n) and its values have to be from the correct AbstractNumbers.

manifold_dimension(M::SkewHermitianMatrices)

Return the dimension of the SkewHermitianMatrices matrix M over the number system 𝔽, i.e.

project(M::SkewHermitianMatrices, p, X)

Project the matrix X onto the tangent space at p on the SkewHermitianMatrices M,

check_vector(M::SPDFixedDeterminant, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the SPDFixedDeterminant M, i.e. X has to be a tangent vector on SymmetricPositiveDefinite, so a symmetric matrix, and additionally fulfill .

Y = project(M::SPDFixedDeterminant, p, X)
project!(M::SPDFixedDeterminant, Y, p, X)

Project the symmetric matrix X onto the tangent space at p of the (sub-)manifold of s.p.d. matrices of determinant M.d (in place of Y), by setting its diagonal (and hence its trace) to zero.

check_vector(M::Spectrahedron, q, Y; kwargs...)

Check whether is a tangent vector to on the Spectrahedron M, i.e. after check_point of q, Y has to be of same dimension as q and a has to be a symmetric matrix with trace.

manifold_dimension(M::Spectrahedron)

returns the dimension of Spectrahedron M, i.e.

project(M::Spectrahedron, q, Y)

Project Y onto the tangent space at q, i.e. row-wise onto the Spectrahedron manifold.

check_vector(M::AbstractSphere, p, X; kwargs... )

Check whether X is a tangent vector to p on the AbstractSphere M, i.e. after check_point(M,p), X has to be of same dimension as p and orthogonal to p.

injectivity_radius(M::AbstractSphere[, p, ::ExponentialRetraction])

Return the injectivity radius for the AbstractSphere M, which is globally .

injectivity_radius(M::Sphere, ::ProjectionRetraction)
injectivity_radius(M::Sphere, p, ::ProjectionRetraction)

Return the injectivity radius for the ProjectionRetraction on the AbstractSphere, which is globally .

manifold_dimension(M::AbstractSphere)

Return the dimension of the AbstractSphere M, respectively i.e. the dimension of the embedding -1.

project(M::AbstractSphere, p, X)

Project the point X onto the tangent space at p on the Sphere M.

check_vector(M::SphereSymmetricMatrices, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the SphereSymmetricMatrices M, i.e. X has to be a symmetric matrix of size (n,n) of unit Frobenius norm.

manifold_dimension(M::SphereSymmetricMatrices{<:Any,𝔽})

Return the manifold dimension of the SphereSymmetricMatrices n-by-n symmetric matrix M of unit Frobenius norm over the number system 𝔽, i.e.

project(M::SphereSymmetricMatrices, p, X)

Project the matrix X onto the tangent space at p on the SphereSymmetricMatrices M, i.e.

check_vector(M::Stiefel, p, X; kwargs...)

Checks whether X is a valid tangent vector at p on the Stiefel M=, i.e. the AbstractNumbers fits and it (approximately) holds that .

manifold_dimension(M::Stiefel)

Return the dimension of the Stiefel manifold M=.

project(M::Stiefel, p)

Projects p from the embedding onto the Stiefel M, i.e. compute q as the polar decomposition of such that is the identity, where denotes the hermitian, i.e. complex conjugate transposed.

project(M::Stiefel, p, X)

Project X onto the tangent space of p to the Stiefel manifold M.

check_vector(M::SymmetricMatrices{n,𝔽}, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the SymmetricMatrices M, i.e. X has to be a symmetric matrix of size (n,n) and its values have to be from the correct AbstractNumbers.

manifold_dimension(M::SymmetricMatrices{n,𝔽})

Return the dimension of the SymmetricMatrices matrix M over the number system 𝔽, i.e.

project(M::SymmetricMatrices, p, X)

Project the matrix X onto the tangent space at p on the SymmetricMatrices M,

check_vector(M::SymmetricPositiveDefinite, p, X; kwargs... )

Check whether X is a tangent vector to p on the SymmetricPositiveDefinite M.

manifold_dimension(M::SymmetricPositiveDefinite)

returns the dimension of SymmetricPositiveDefinite M , i.e.

project(M::SymmetricPositiveDefinite, p, X)

project a matrix from the embedding onto the tangent space of the SymmetricPositiveDefinite matrices, i.e. the set of symmetric matrices.

check_vector(M::SymmetricPositiveSemidefiniteFixedRank, p, X; kwargs... )

Check whether X is a tangent vector to manifold point p on the SymmetricPositiveSemidefiniteFixedRank M.

manifold_dimension(M::SymmetricPositiveSemidefiniteFixedRank)

Return the dimension of the SymmetricPositiveSemidefiniteFixedRank matrix M over the number system 𝔽, i.e.

check_vector(M::SymplecticMatrices, p, X; kwargs...)

Checks whether X is a valid tangent vector at p on the SymplecticMatrices M=, which requires that

manifold_dimension(::SymplecticMatrices)

Returns the dimension of the symplectic manifold embedded in , i.e.

project(::SymplecticMatrices, p, A)
project!(::SymplecticMatrices, Y, p, A)

Given a point , project an element onto the tangent space relative to the euclidean metric of the embedding .

check_vector(M::SymplecticGrassmann, p, X; kwargs...)

Check whether X is a valid tangent vector at p on the SymplecticGrassmann manifold M.

check_vector(M::SymplecticGrassmann, p::ProjectorPoint, X::ProjectorTangentVector; kwargs...)

Check whether X is a valid tangent vector at p on the SymplecticGrassmann, manifold by verifying that it

manifold_dimension(::SymplecticGrassmann)

Return the dimension of the SymplecticGrassmann(2n,2k), which is

check_vector(M::SymplecticMatrices, p, X; kwargs...)

Checks whether X is a valid tangent vector at p on the SymplecticStiefel, manifold.

manifold_dimension(::SymplecticStiefel)

Returns the dimension of the symplectic Stiefel manifold embedded in , i.e. [BZ21]

project(::SymplecticStiefel, p, A)
project!(::SymplecticStiefel, Y, p, A)

Given a point , project an element onto the tangent space relative to the euclidean metric of the embedding .

check_vector(M::EmbeddedTorus, p, X; atol=eps(eltype(p)), kwargs...)

Check whether X is a valid vector tangent to p on the EmbeddedTorus M.

check_vector(M::Torus{n}, p, X; kwargs...)

Checks whether X is a valid tangent vector to p on the Torus M.

manifold_dimension(M::EmbeddedTorus)

Return the dimension of the EmbeddedTorus M that is 2.

check_vector(M::Tucker{<:Any,D}, p::TuckerPoint{T,D}, X::TuckerTangentVector) where {T,D}

Check whether a TuckerTangentVector X is is in the tangent space to the Dth order Tucker manifold M at the Dth order TuckerPoint p.

manifold_dimension(::Tucker)

The dimension of the manifold of tensors of multilinear rank , i.e.

project(B::VectorBundle, p, X)

Project the element X of the ambient space of the tangent space to the tangent space .