# Special Manifolds build upon one or more Riemannian manifolds

## Tangent bundle

The tangent bundle $T\mathcal M$ of a manifold $\mathcal M$ consists of all tuples $(x,\xi) \in T\mathcal M$, where $\xi\in T_x\mathcal M$, $x\in \mathcal M$, where the metric is inherited component wise and for the exponential and logarithmic map, the second component requires a `parallelTransport`

.

### Tangent Bundle Types

`Manopt.TBPoint`

— Type.`TBPoint <: MPoint`

A point $N\in \mathcal M$ on the manifold $\mathcal M = T\mathcal N$ represented by a tuple `(x,ξ)`

, where $x\in\mathcal N$ is a point on the manifold and $\xi=\xi_x\in T_x\mathcal N$ is a point in the tangent space at $x$.

Two constructors are available:

`TBPoint(x,ξ)`

to construct a tangent bundle point by specifying both an`MPoint`

`x`

and a`TVector`

`ξ`

.`TBPoint( (X) )`

to construct a tangent bundle point from a tuple`X=(x,ξ)`

,

i.e. the value of another tangent bundle point.

`Manopt.TBTVector`

— Type.`TBTVector <: TVector`

A tangent vector $\Xi \in T_X\mathcal M$ on the manifold $\mathcal M = T\mathcal N$ for the (base) manifold $\mathcal N$. Both tangent components can be represented by elements from the base point $x$ from within $X=(x,\xi)$. Both components are from the same space since $TT_x\mathcal N= T_x\mathcal N$, hence the tangent vector is a tuple $(\xi\,\nu)\in T_x\mathcal N\times T_x\mathcal N$. As for the `TBPoint`

two constructors are available, one for stwo seperate tangent vectors, one for a tuple of two tangent vectors.

`Manopt.TangentBundle`

— Type.`TangentBundle <: Manifold`

The manifold $\mathcal M = T\mathcal N$ obtained by looking at the tangent bundle of a `Manifold`

s tangent spaces. The manifold obtained is of dimension $2d$, where $d$ is the dimension of the manifold $\mathcal N$ considered.

To keep notations clear, small letters will always refer to points (`x,y`

) or tangent vectors (`ξ,η`

) on the manifold $\mathcal N$, while capital letters (`X, Y, Z`

and `Ξ,Η`

) will refer to points and tangent vectors in the tangent bundle respectively.

**Abbreviation**

`TB`

**Constructor**

`TangentBundle(M)`

generates the tangent bundle to the `Manifold`

`M`

.

### Tangent Bundle Functions

`Base.exp`

— Function.`exp(M,X,Ξ[, t=1.0])`

Compute the exponential map on the `TangentBundle`

`M`

$=T\mathcal N$ with respect to the `TBPoint`

`X=(x,ξ)`

and the `TBTVector`

`Ξ=(Ξx,Ξξ)`

, which consists of the exponential map in the first component (`exp(x,Ξx,t)`

and a (scaled) addition in the second (`ξ + tΞξ`

) in the second component followed by a parallel transport.

`Base.log`

— Method.`log(M,X,Y)`

Compute the logarithmic map on the `TangentBundle`

$\mathcal M=T\mathcal N$, i.e. the `log`

for the base manifold component and a parallel transport and a minus for the tangent components.

`LinearAlgebra.dot`

— Method.`dot(M,X,Ξ,Η)`

Compute the Riemannian inner product for two `TBTVector`

s `Ξ`

and `Η`

from $T_X\mathcal M$ of the `TangentBundle`

`M = TN`

given by the sum of the two inner products of the tangent vector components

`LinearAlgebra.norm`

— Method.`norm(M,X,Ξ)`

Computes the norm of the `TBTVector`

`Ξ`

in the tangent space $T_x\mathcal M$ at `TBPoint`

`X`

of the `TangentBundle`

`M`

.

`Manopt.distance`

— Method.`distance(M,X,Y)`

Compute the Riemannian distance on $\mathcal M=T\mathcal N$ by employing the distance on the manifold for the base component and the vector norm on the tangent space, and then take the Eucklidean Norm of the vector from $\mathbb R^2$.

`Manopt.getBase`

— Method.`Manopt.getBase`

— Method.`getBase(M)`

return the base manifold of the `TangentBundle`

`Manifold`

`M`

.

`Manopt.getBase`

— Method.`Manopt.getTangent`

— Method.`Manopt.getTangent`

— Method.`Manopt.getValue`

— Method.`Manopt.getValue`

— Method.`Manopt.manifoldDimension`

— Method.`manifoldDimension(X)`

returns the dimension of the `TangentBundle`

`M`

$=T\mathcal N$ to which `X`

bvelongs, which is twice the dimension of the base manifold.

`Manopt.manifoldDimension`

— Method.`manifoldDimension(M)`

returns the dimension of the `TangentBundle`

`M`

$=T\mathcal N$, i.e., twice the dimension of the base manifold `N`

.

`Manopt.parallelTransport`

— Method.`parallelTransport(M,X,Y,Ξ)`

Compute the paralllel transport of the `TBTVector`

`Ξ`

from the tangent space $T_X\mathcal M$ at `TBPoint`

`X`

to $T_Y\mathcal M$ at `TBPoint`

`Y`

on the `TangentBundle`

`M`

provided that the corresponding `geodesic`

$g(\cdot;x,y)$ is unique. Then both components of $\Xi=(\Xi_x,\Xi_\xi)$ are parallely transported using the parallel transport of the underlying base manifold.

`Manopt.randomMPoint`

— Method.`randomMPoint(M)`

returns a random point on the `TangentBundle`

`M`

by producing a `randomMPoint`

random point on the base manifold and `randomTVector`

in the correspoinding tangent plane.

`Manopt.randomTVector`

— Method.`randomTVector(M,x)`

returns a random tangent vector the `TangentBundle`

`M`

by producing two `randomTVector`

s in the correspoinding tangent plane of the `getBase`

of the `TBPoint`

`x`

.

`Manopt.tangentONB`

— Method.`tangentONB(M,X,Y)`

constructs a tangent ONB in the tangent space of the `TBPoint`

`X`

on the `TangentBundle`

`M`

, where $\log_XY$ is the first component.

`Manopt.tangentONB`

— Method.`Η,κ = tangentONB(M,X,Ξ)`

constructs a tangent ONB in $T_X\mathcal M$, i.e. in the tangent space of the `TBPoint`

`x`

on the `TangentBundle`

`M`

whose first vector is given by the `TBTVector`

`Ξ`

. It is constructed by using twice the tangent ONB of the base manifold.

`Manopt.typicalDistance`

— Method.`typicalDistance(M)`

returns the typical distance on the `TangentBundle`

`M`

, i.e. for $\mathcal M = T\mathcal N$ we obtain $t_{\mathcal M} = \sqrt{t_{\mathcal N}^2 + d_{\mathcal N}^2}$, where $d$ denotes the manifold dimension.

`Manopt.validateMPoint`

— Method.`validateMPoint(M,X)`

validate that the `TBPoint`

`X`

is a valid point on the `TangentBundle`

`M`

, i.e. the first component is a point on the base manifold and the second a tangent vector is the tangent space of the first

`Manopt.validateTVector`

— Method.`validateTVector(M,X,Ξ)`

validate, that the `TBTVector`

`Ξ`

is a valid tangent vector in the tangent space of the `TBPoint`

`X`

on the `TangentBundle`

`M`

, i.e. both components of `Ξ`

are tangent vectors in the tangent space of the base component of `X`

, since the tangent space of the tangent space is represented as the tangent space itself.

`Manopt.zeroTVector`

— Method.`zeroTVector(M,X)`

returns a zero vector in the tangent space $T_X\mathcal M$ of the `TangentBundle`

$X=(x,ξ)\in T\mathcal N$ by creating two zero vectors in $T_x\mathcal M$.

## Power Manifold

The product manifold $\mathcal M^n$, where $n\in\mathbb N^k$ represents arrays that are manifold-valued, for example, if $n$ is a number ($k=1$) we obtain a manifold-valued signal $f\in\mathcal M^n$. Many operations are performed element wise, while for example the distance on the power manifold is the $\ell^2$ norm of the element wise distances.

### Power Manifold Types

`Manopt.PowPoint`

— Type.`PowPoint <: MPoint`

A point on the power manifold $\mathcal M = \mathcal N^n$ represented by an array (of size `n`

) of `MPoint`

s.

`Manopt.PowTVector`

— Type.`PowTVector <: TVector`

A tangent vector on the power manifold $\mathcal M = \mathcal N^n$ represented by an array (of size `n`

) of `TVector`

s.

`Manopt.Power`

— Type.`Power{M<:Manifold} <: Manifold`

A power manifold $\mathcal M = \mathcal N^n$, where $n$ can be an integer or an integer vector.

**Abbreviation**

`Pow`

**Constructors**

`Power(M,n)`

construct the power manifold $\mathcal M^n$ for a `Manifold`

`M`

and a natural number `n`

.

`Power(M,n)`

construct the power manifold $\mathcal M^{n_1\times n_2\times\cdots\times n_d}$ for a `Manifold`

`M`

and a `Tuple`

or `Array`

`n`

of natural numbers.

### Power Manifold Functions

`Base.exp`

— Function.`Base.log`

— Method.`log(M,x,y)`

compute the product logarithmic map on the `Power`

manifold `M`

and return the corresponding `PowTVector`

.

`LinearAlgebra.dot`

— Method.`dot(M,x,ξ,ν)`

compute the inner product as sum of the component inner products on the `Power`

manifold `M`

.

`LinearAlgebra.norm`

— Method.`norm(M,x,ξ)`

compute the norm of the [`PowTVector`

] `ξ`

induced by the metric on the manifold components of the `Power`

manifold `M`

.

`Manopt.distance`

— Method.`distance(M,x,y)`

compute a vectorized version of distance on the [`Power`

] manifold `M`

for two `PowPoint`

`x`

and `y`

.

`Manopt.manifoldDimension`

— Method.`Manopt.manifoldDimension`

— Method.`manifoldDimension(M)`

return the (product of) dimension(s) of the `Power`

manifold `M`

.

`Manopt.parallelTransport`

— Method.`parallelTransport(M,x,y,ξ)`

compute the product parallelTransport map on the `Power`

manifold `M`

from the `PowPoint`

`x`

to `y`

of the `PowTVector`

`ξ`

.

`Manopt.randomMPoint`

— Method.`Manopt.randomTVector`

— Method.`Manopt.tangentONB`

— Method.`(Ξ,κ) = tangentONB(M,x,y)`

compute an ONB within the tangent space $T_x\mathcal M$ such that $\xi=\log_xy$ is the first vector and compute the eigenvalues of the curvature tensor $R(\Xi,\dot g)\dot g$, where $g=g_{x,\xi}$ is the geodesic with $g(0)=x$, $\dot g(0) = \xi$, i.e. $\kappa_1$ corresponding to $\Xi_1=\xi$ is zero.

**See also**

`Manopt.typicalDistance`

— Method.`typicalDistance(M)`

returns the typical distance on the `Power`

manifold `M`

, which is based on the elementwise manifold.

`Manopt.zeroTVector`

— Method.## Product Manifold

A little more general is the product manifold, where $\mathcal M = \mathcal N_1\times\cdots\times\mathcal N_n$, $n\in\mathbb N^k$ is a product of manifolds, i.e. for a value $f\in\mathcal M$ we have that $f_i\in\mathcal N_i$, where $i$ might be a multi-index.

### Product Manifold Types

`Manopt.ProdPoint`

— Type.`Manopt.ProdTVector`

— Type.`Manopt.Product`

— Type.`Product{M<:Manifold} <: Manifold`

a product manifold $\mathcal M = \mathcal N_1\times\mathcal N_2\times\cdots\times\mathcal N_m$, $m\in\mathbb N$, concatinates a set of manifolds $\mathcal N_i$, $i=1,\ldots,m$, into one using the sum of the metrics to impose a metric on this manifold. The manifold can also be an arbitrary Array of manifolds, not necessarily only a vector.

**Abbreviation**

`Prod`

**Constructor**

`Product(m)`

constructs a `Power`

`Manifold`

based on an array `m`

of `Manifold`

s.

### Product Manifold Functions

`Base.exp`

— Function.`Base.log`

— Method.log(M,x,y)

computes the product logarithmic map from `PowPoint`

`x`

to `y`

on the `Product`

manifold `M`

and returns the corresponding `ProdTVector`

.

`LinearAlgebra.dot`

— Method.`dot(M,x,ξ,ν)`

compute the inner product as sum of the component inner products on the `Product`

manifold `M`

.

`LinearAlgebra.norm`

— Method.`norm(M,x,ξ)`

norm of the `ProdTVector`

`ξ`

induced by the metric on the manifold components of the `Product`

manifold `M`

.

`Manopt.distance`

— Method.`Manopt.manifoldDimension`

— Method.`Manopt.manifoldDimension`

— Method.`manifoldDimension(M)`

returns the (product of) dimension(s) of the `Product`

manifold `M`

.

`Manopt.parallelTransport`

— Method.`parallelTransport(M,x,ξ)`

computes the product parallelTransport map on the `Product`

manifold `M`

and returns the corresponding `ProdTVector`

.

`Manopt.randomMPoint`

— Method.`randomMPoint(M)`

generate a random point on `Product`

manifold `M`

.

`Manopt.randomTVector`

— Method.`Manopt.typicalDistance`

— Method.`typicalDistance(M)`

returns the typical distance on `Product`

manifold `M`

, which is the minimum of the internal ones.

`Manopt.validateMPoint`

— Method.`Manopt.validateTVector`

— Method.`validateTVector(M,x,ξ)`

validate, that the `ProdTVector`

`ξ`

is a valid tangent vector to the `ProdPoint`

`x`

on the `Product`

manifold `M`

, i.e. that all three array dimensions match and this validation holds elementwise.

`Manopt.zeroTVector`

— Method.## Graph Manifold

The Graph manifold provides methods for two often interacting manifolds on a given graph $\mathcal G = (\mathcal V,\mathcal E)$: A vertex graph manifold, $\mathcal M^{\lvert \mathcal V\rvert}$ and an edge manifold $\mathcal N^{\lvert \mathcal E\rvert}$ for two `Manifold`

s $\mathcal M$ and $\mathcal N$. For example $\mathcal N$ might be the tangent bundle of $\mathcal M$.

### Types

`Manopt.Graph`

— Type.`Graph{M<:Manifold} <: Manifold`

The graph manifold models manifold-valued data on a graph $\mathcal G = (\mathcal V, \mathcal E)$, both on vertices and edges as well as their interplay. The adjacency is stored in a matrix, and may contain also the weights.

Since there are two possibilities in dimensions, $\lvert\mathcal V\rvert$ and $\lvert\mathcal E\rvert$, the manifold itself will refer to the first one, while depending on the type of `MPoint`

one of them is returned.

**Fields**

the default values are given in brackets

`adjacency`

– the (sparse) adjacency matrix, might also carry weights, i.e. all $a_{ij}>0$ refer to adjacent nodes $i$ and $j$`name`

– (`A Graph manifold of \$Submanifold.`

) name of the manifold`manifold`

– the internal manifold present at vertices (edges) for

`GraphVertexPoint`

(`GraphEdgePoint`

)

`dimension`

– stores the dimension of the manifold of a`GraphVertexPoint`

`isDirected`

– (`false`

) indicates whether the graph is directed or not.

`Manopt.GraphEdgePoint`

— Type.`GraphEdgePoint <: MPoint`

A point graph edge power manifold $\mathcal M = \mathcal N^{\lvert\mathcal E\rvert}$ represented by a (sparse/not completely filled matrix of corresponding `MPoint`

s.

`Manopt.GraphEdgeTVector`

— Type.`GraphEdgeTVector <: TVector`

A tangent vector $\xi\in T_x\mathcal M$ to the graph edge power manifold $\mathcal M = \mathcal N^{\lvert\mathcal E\rvert}$ represented by a (sparse/not completely filled) matrix of corresponding `TVector`

s.

`Manopt.GraphVertexPoint`

— Type.`GraphVertexPoint <: MPoint`

A point graph vertex power manifold $\mathcal M = \mathcal N^{\lvert\mathcal V\rvert}$ represented by a vector of corresponding `MPoint`

s.

`Manopt.GraphVertexTVector`

— Type.`GraphVertexTVector <: TVector`

A tangent vector $\xi\in T_x\mathcal M$ to the graph vertex power manifold $\mathcal M = \mathcal N^{\lvert\mathcal V\rvert}$ represented by a vector of corresponding `TVector`

s.

### Functions

`Base.exp`

— Function.`exp(M,x,ξ[, t=1.0])`

computes the product exponential map on the `Graph`

vertices and returns the corresponding `GraphVertexPoint`

.

`Base.log`

— Method.`log(M,x,y)`

computes the product logarithmic map on the `Graph`

for two `GraphEdgePoint`

`x`

and `y`

and returns the corresponding `GraphEdgeTVector`

.

`Base.log`

— Method.`log(M,x,y)`

computes the product logarithmic map on the `Graph`

for two `GraphVertexPoint`

`x`

and `y`

and returns the corresponding `GraphVertexTVector`

.

`LinearAlgebra.dot`

— Method.`dot(M,x,ξ,ν)`

computes the inner product as sum of the component inner products on the `Graph`

edges.

`LinearAlgebra.dot`

— Method.`dot(M,x,ξ,ν)`

computes the inner product as sum of the component inner products on the `Graph`

vertices.

`LinearAlgebra.norm`

— Method.`norm(M,x,ξ)`

norm of the `GraphEdgeTVector`

`ξ`

induced by the metric on the manifold components of the `Graph`

manifold `M`

.

`LinearAlgebra.norm`

— Method.`norm(M,x,ξ)`

norm of the `GraphVertexTVector`

`ξ`

induced by the metric on the manifold components of the `Graph`

manifold `M`

.

`Manopt.distance`

— Method.`distance(M,x,y)`

compute a vectorized version of distance on the `Graph`

manifold `M`

for two `GraphEdgePoint`

`x`

and `y`

.

`Manopt.distance`

— Method.`distance(M,x,y)`

compute a vectorized version of distance on the `Graph`

manifold `M`

for two `GraphVertexPoint`

`x`

and `y`

.

`Manopt.manifoldDimension`

— Method.`manifoldDimension(x)`

returns the (product of) dimension(s) of the `Graph`

manifold `M`

the `GraphEdgePoint`

`x`

belongs to.

`Manopt.manifoldDimension`

— Method.`manifoldDimension(x)`

returns the (product of) dimension(s) of the `Graph`

manifold `M`

the `GraphVertexPoint`

`x`

belongs to.

`Manopt.manifoldDimension`

— Method.`manifoldDimension(M)`

returns the (product of) dimension(s) of the `Graph`

manifold `M`

seen as a vertex power manifold.

`Manopt.parallelTransport`

— Method.`parallelTransport(M,x,ξ)`

compute the product parallelTransport map on the `Graph`

edge power manifold and returns the corresponding `GraphVertexTVector`

.

`Manopt.parallelTransport`

— Method.`parallelTransport(M,x,ξ)`

compute the product parallelTransport map on the `Graph`

vertex power manifold $\mathcal M^{\lvert\mathcal V\rvert}$ and returns the corresponding `GraphVertexTVector`

.

`Manopt.randomMPoint`

— Method.`randomMPoint(M,[,:Vertex])`

compute a random point on the `Graph`

manifold, where by default a point on the vertices is produces, use `:Edge`

to generate a `GraphEdgePoint`

. Further optional parameters are passed on to the element wise random point function.

`Manopt.randomTVector`

— Method.`randomTVector(M,x)`

compute a random `GraphEdgeTVector`

to the `GraphVertexPoint`

`x`

on the `Graph`

manifold `M`

by calling the inner random vector generation for every edge

`Manopt.zeroTVector`

— Method.`ξ = zeroTVector(M,x)`

returns a zero vector in the tangent space $T_x\mathcal M$ of the `GraphEdgePoint`

$x\in\mathcal M$ on the `Graph`

edge manifold `M`

.

`Manopt.zeroTVector`

— Method.`ξ = zeroTVector(M,x)`

returns a zero vector in the tangent space $T_x\mathcal M$ of the `GraphVertexPoint`

$x\in\mathcal M$ on the `Graph`

vertex manifold `M`

.

`Manopt.startEdgePoint`

— Method.`startEdgePoint(M,x)`

For a `Graph`

manifold and a `GraphVertexPoint`

, this function constructs the corresponding `GraphEdgePoint`

, such that each edge has its start point vertex value assigned.

`Manopt.sumEdgeTVector`

— Function.`sumEdgeTVector(M,ξ)`

return the `GraphVertexTVector`

where edge tangents are summed in their start point.

For an `GraphEdgeTVector`

`ξ`

on a `Graph`

manifold `M`

this function assumes that all edge tangents are attached in a tangent space corresponding to the same point on the base manifold, i.e. all these vectors can be summed. This sum per vectex is then returned as a `GraphVertexTVector`

.