Vector bundles

TangentSpace(M::AbstractManifold, p)

Return a TangentSpaceAtPoint representing tangent space at p on the AbstractManifold M.

CotangentSpaceAtPoint(M::AbstractManifold, p)

Return an object of type VectorSpaceAtPoint representing cotangent space at p.

struct SasakiRetraction <: AbstractRetractionMethod end

Exponential map on TangentBundle computed via Euler integration as described in [MF12]. The system of equations for $\gamma : ℝ \to T\mathcal M$ such that $\gamma(1) = \exp_{p,X}(X_M, X_F)$ and $\gamma(0)=(p, X)$ reads

\[\dot{\gamma}(t) = (\dot{p}(t), \dot{X}(t)) = (R(X(t), \dot{X}(t))\dot{p}(t), 0)\]

where $R$ is the Riemann curvature tensor (see riemann_tensor).

Constructor

SasakiRetraction(L::Int)

In this constructor L is the number of integration steps.

TangentBundle{𝔽,M} = VectorBundle{𝔽,TangentSpaceType,M} where {𝔽,M<:AbstractManifold{𝔽}}

Tangent bundle for manifold of type M, as a manifold with the Sasaki metric [Sas58].

Exact retraction and inverse retraction can be approximated using VectorBundleProductRetraction, VectorBundleInverseProductRetraction and SasakiRetraction. VectorBundleProductVectorTransport can be used as a vector transport.

Constructors

TangentBundle(M::AbstractManifold)
TangentBundle(M::AbstractManifold, vtm::VectorBundleProductVectorTransport)

TangentSpaceAtPoint{M}

Alias for VectorSpaceAtPoint for the tangent space at a point.

TangentSpaceAtPoint(M::AbstractManifold, p)

Return an object of type VectorSpaceAtPoint representing tangent space at p on the AbstractManifold M.

TensorProductType(spaces::VectorSpaceType...)

Vector space type corresponding to the tensor product of given vector space types.

VectorBundle{𝔽,TVS<:VectorSpaceType,TM<:AbstractManifold{𝔽}} <: AbstractManifold{𝔽}

Vector bundle on a AbstractManifold M of type VectorSpaceType.

Constructor

VectorBundle(M::AbstractManifold, type::VectorSpaceType)

VectorBundleFibers(fiber::VectorSpaceType, M::AbstractManifold)

Type representing a family of vector spaces (fibers) of a vector bundle over M with vector spaces of type fiber. In contrast with VectorBundle, operations on VectorBundleFibers expect point-like and vector-like parts to be passed separately instead of being bundled together. It can be thought of as a representation of vector spaces from a vector bundle but without storing the point at which a vector space is attached (which is specified separately in various functions).

struct VectorBundleInverseProductRetraction <: AbstractInverseRetractionMethod end

Inverse retraction of the point y at point p from vector bundle B over manifold B.fiber (denoted $\mathcal M$). The inverse retraction is derived as a product manifold-style approximation to the logarithmic map in the Sasaki metric. The considered product manifold is the product between the manifold $\mathcal M$ and the topological vector space isometric to the fiber.

Notation:

• The point $p = (x_p, V_p)$ where $x_p ∈ \mathcal M$ and $V_p$ belongs to the fiber $F=π^{-1}(\{x_p\})$ of the vector bundle $B$ where $π$ is the canonical projection of that vector bundle $B$. Similarly, $q = (x_q, V_q)$.

The inverse retraction is calculated as

\[\operatorname{retr}^{-1}_p q = (\operatorname{retr}^{-1}_{x_p}(x_q), V_{\operatorname{retr}^{-1}} - V_p)\]

where $V_{\operatorname{retr}^{-1}}$ is the result of vector transport of $V_q$ to the point $x_p$. The difference $V_{\operatorname{retr}^{-1}} - V_p$ corresponds to the logarithmic map in the vector space $F$.

See also VectorBundleProductRetraction.

struct VectorBundleProductRetraction <: AbstractRetractionMethod end

Product retraction map of tangent vector $X$ at point $p$ from vector bundle B over manifold B.fiber (denoted $\mathcal M$). The retraction is derived as a product manifold-style approximation to the exponential map in the Sasaki metric. The considered product manifold is the product between the manifold $\mathcal M$ and the topological vector space isometric to the fiber.

Notation:

• The point $p = (x_p, V_p)$ where $x_p ∈ \mathcal M$ and $V_p$ belongs to the fiber $F=π^{-1}(\{x_p\})$ of the vector bundle $B$ where $π$ is the canonical projection of that vector bundle $B$.
• The tangent vector $X = (V_{X,M}, V_{X,F}) ∈ T_pB$ where $V_{X,M}$ is a tangent vector from the tangent space $T_{x_p}\mathcal M$ and $V_{X,F}$ is a tangent vector from the tangent space $T_{V_p}F$ (isomorphic to $F$).

The retraction is calculated as

\[\operatorname{retr}_p(X) = (\exp_{x_p}(V_{X,M}), V_{\exp})\]

where $V_{\exp}$ is the result of vector transport of $V_p + V_{X,F}$ to the point $\exp_{x_p}(V_{X,M})$. The sum $V_p + V_{X,F}$ corresponds to the exponential map in the vector space $F$.

See also VectorBundleInverseProductRetraction.

VectorBundleProductVectorTransport{
    TMP<:AbstractVectorTransportMethod,
    TMV<:AbstractVectorTransportMethod,
} <: AbstractVectorTransportMethod

Vector transport type on VectorBundle. method_point is used for vector transport of the point part and method_vector is used for transport of the vector part.

The vector transport is derived as a product manifold-style vector transport. The considered product manifold is the product between the manifold $\mathcal M$ and the topological vector space isometric to the fiber.

Constructor

VectorBundleProductVectorTransport(
    method_point::AbstractVectorTransportMethod,
    method_vector::AbstractVectorTransportMethod,
)
VectorBundleProductVectorTransport()

By default both methods are set to ParallelTransport.

const VectorBundleVectorTransport = VectorBundleProductVectorTransport

Deprecated: an alias for VectorBundleProductVectorTransport.

VectorSpaceAtPoint{
    𝔽,
    TFiber<:VectorBundleFibers{<:VectorSpaceType,<:AbstractManifold{𝔽}},
    TX,
} <: AbstractManifold{𝔽}

A vector space at a point p on the manifold. This is modelled using VectorBundleFibers with only a vector-like part and fixing the point-like part to be just p.

This vector space itself is also a manifold. Especially, it's flat and hence isometric to the Euclidean manifold.

Constructor

VectorSpaceAtPoint(fiber::VectorBundleFibers, p)

A vector space (fiber type fiber of a vector bundle) at point p from the manifold fiber.manifold.

exp(M::TangentSpaceAtPoint, p, X)

Exponential map of tangent vectors X and p from the tangent space M. It is calculated as their sum.

getindex(p::ArrayPartition, M::VectorBundle, s::Symbol)
p[M::VectorBundle, s]

Access the element(s) at index s of a point p on a VectorBundle M by using the symbols :point and :vector for the base and vector component, respectively.

getindex(p::ProductRepr, M::VectorBundle, s::Symbol)
p[M::VectorBundle, s]

Access the element(s) at index s of a point p on a VectorBundle M by using the symbols :point and :vector for the base and vector component, respectively.

log(M::TangentSpaceAtPoint, p, q)

Logarithmic map on the tangent space manifold M, calculated as the difference of tangent vectors q and p from M.

setindex!(p::ArrayPartition, val, M::VectorBundle, s::Symbol)
p[M::VectorBundle, s] = val

Set the element(s) at index s of a point p on a VectorBundle M to val by using the symbols :point and :vector for the base and vector component, respectively.

setindex!(p::ProductRepr, val, M::VectorBundle, s::Symbol)
p[M::VectorBundle, s] = val

Set the element(s) at index s of a point p on a VectorBundle M to val by using the symbols :point and :vector for the base and vector component, respectively.

norm(B::VectorBundleFibers, p, q)

Norm of the vector X from the vector space of type B.fiber at point p from manifold B.manifold.

bundle_projection(B::VectorBundle, p::ArrayPartition)

Projection of point p from the bundle M to the base manifold. Returns the point on the base manifold B.manifold at which the vector part of p is attached.

inverse_retract_product(M::VectorBundle, p, q)

Compute the allocating variant of the VectorBundleInverseProductRetraction, which by default allocates and calls inverse_retract_product!.

retract_product(M::VectorBundle, p, q, t::Number)

Compute the allocating variant of the VectorBundleProductRetraction, which by default allocates and calls retract_product!.

retract_sasaki(M::AbstractManifold, p, X, t::Number, m::SasakiRetraction)

Compute the allocating variant of the SasakiRetraction, which by default allocates and calls retract_sasaki!.

vector_bundle_transport(fiber::VectorSpaceType, M::AbstractManifold)

Determine the vector tranport used for exp and log maps on a vector bundle with vector space type fiber and manifold M.

Y = Weingarten(M::VectorSpaceAtPoint, p, X, V)
Weingarten!(M::VectorSpaceAtPoint, Y, p, X, V)

Compute the Weingarten map $\mathcal W_p$ at p on the VectorSpaceAtPoint M with respect to the tangent vector $X \in T_p\mathcal M$ and the normal vector $V \in N_p\mathcal M$.

Since this a flat space by itself, the result is always the zero tangent vector.

allocate_result(B::VectorBundleFibers, f, x...)

Allocates an array for the result of function f that is an element of the vector space of type B.fiber on manifold B.manifold and arguments x... for implementing the non-modifying operation using the modifying operation.

allocate_result_type(B::VectorBundleFibers, f, args::NTuple{N,Any}) where N

Return type of element of the array that will represent the result of function f for representing an operation with result in the vector space fiber for manifold M on given arguments (passed at a tuple).

distance(M::TangentSpaceAtPoint, p, q)

Distance between vectors p and q from the vector space M. It is calculated as the norm of their difference.

distance(B::VectorBundleFibers, p, X, Y)

Distance between vectors X and Y from the vector space at point p from the manifold B.manifold, that is the base manifold of M.

injectivity_radius(M::TangentBundle)

Injectivity radius of TangentBundle manifold is infinite if the base manifold is flat and 0 otherwise. See https://mathoverflow.net/questions/94322/injectivity-radius-of-the-sasaki-metric.

injectivity_radius(M::TangentSpaceAtPoint)

Return the injectivity radius on the TangentSpaceAtPoint M, which is $∞$.

inner(M::TangentSpaceAtPoint, p, X, Y)

Inner product of vectors X and Y from the tangent space at M.

inner(B::VectorBundle, p, X, Y)

Inner product of tangent vectors X and Y at point p from the vector bundle B over manifold B.fiber (denoted $\mathcal M$).

Notation:

• The point $p = (x_p, V_p)$ where $x_p ∈ \mathcal M$ and $V_p$ belongs to the fiber $F=π^{-1}(\{x_p\})$ of the vector bundle $B$ where $π$ is the canonical projection of that vector bundle $B$.
• The tangent vector $v = (V_{X,M}, V_{X,F}) ∈ T_{x}B$ where $V_{X,M}$ is a tangent vector from the tangent space $T_{x_p}\mathcal M$ and $V_{X,F}$ is a tangent vector from the tangent space $T_{V_p}F$ (isomorphic to $F$). Similarly for the other tangent vector $w = (V_{Y,M}, V_{Y,F}) ∈ T_{x}B$.

The inner product is calculated as

\[⟨X, Y⟩_p = ⟨V_{X,M}, V_{Y,M}⟩_{x_p} + ⟨V_{X,F}, V_{Y,F}⟩_{V_p}.\]

inner(B::VectorBundleFibers, p, X, Y)

Inner product of vectors X and Y from the vector space of type B.fiber at point p from manifold B.manifold.

is_flat(::TangentSpaceAtPoint)

Return true. TangentSpaceAtPoint is a flat manifold.

is_flat(::VectorBundle)

Return true if the underlying manifold of VectorBundle M is flat.

project(M::TangentSpaceAtPoint, p, X)

Project the vector X from the tangent space M, that is project the vector X tangent at M.point.

project(M::TangentSpaceAtPoint, p)

Project the point p from the tangent space M, that is project the vector p tangent at M.point.

project(B::VectorBundle, p, X)

Project the element X of the ambient space of the tangent space $T_p B$ to the tangent space $T_p B$.

Notation:

• The point $p = (x_p, V_p)$ where $x_p ∈ \mathcal M$ and $V_p$ belongs to the fiber $F=π^{-1}(\{x_p\})$ of the vector bundle $B$ where $π$ is the canonical projection of that vector bundle $B$.
• The vector $x = (V_{X,M}, V_{X,F})$ where $x_p$ belongs to the ambient space of $T_{x_p}\mathcal M$ and $V_{X,F}$ belongs to the ambient space of the fiber $F=π^{-1}(\{x_p\})$ of the vector bundle $B$ where $π$ is the canonical projection of that vector bundle $B$.

The projection is calculated by projecting $V_{X,M}$ to tangent space $T_{x_p}\mathcal M$ and then projecting the vector $V_{X,F}$ to the fiber $F$.

project(B::VectorBundle, p)

Project the point p from the ambient space of the vector bundle B over manifold B.fiber (denoted $\mathcal M$) to the vector bundle.

Notation:

• The point $p = (x_p, V_p)$ where $x_p$ belongs to the ambient space of $\mathcal M$ and $V_p$ belongs to the ambient space of the fiber $F=π^{-1}(\{x_p\})$ of the vector bundle $B$ where $π$ is the canonical projection of that vector bundle $B$.

The projection is calculated by projecting the point $x_p$ to the manifold $\mathcal M$ and then projecting the vector $V_p$ to the tangent space $T_{x_p}\mathcal M$.

project(B::VectorBundleFibers, p, X)

Project vector X from the vector space of type B.fiber at point p.

vector_transport_to(M::VectorBundle, p, X, q, m::VectorBundleProductVectorTransport)

Compute the vector transport the tangent vector Xat p to q on the VectorBundle M using the VectorBundleProductVectorTransport m.

zero_vector!(B::VectorBundleFibers, X, p)

Save the zero vector from the vector space of type B.fiber at point p from manifold B.manifold to X.

zero_vector(M::TangentSpaceAtPoint, p)

Zero tangent vector at point p from the tangent space M, that is the zero tangent vector at point M.point.

zero_vector(B::VectorBundle, p)

Zero tangent vector at point p from the vector bundle B over manifold B.fiber (denoted $\mathcal M$). The zero vector belongs to the space $T_{p}B$

Notation:

• The point $p = (x_p, V_p)$ where $x_p ∈ \mathcal M$ and $V_p$ belongs to the fiber $F=π^{-1}(\{x_p\})$ of the vector bundle $B$ where $π$ is the canonical projection of that vector bundle $B$.

The zero vector is calculated as

\[\mathbf{0}_{p} = (\mathbf{0}_{x_p}, \mathbf{0}_F)\]

where $\mathbf{0}_{x_p}$ is the zero tangent vector from $T_{x_p}\mathcal M$ and $\mathbf{0}_F$ is the zero element of the vector space $F$.

zero_vector(B::VectorBundleFibers, p)

Compute the zero vector from the vector space of type B.fiber at point p from manifold B.manifold.