From b0008c09005255c5228bd63446752e70c7888433 Mon Sep 17 00:00:00 2001
From: spaette <111918424+spaette@users.noreply.github.com>
Date: Tue, 11 Jun 2024 14:38:35 -0500
Subject: [PATCH] typos (#728)

---
 CITATION.bib                                   |  2 +-
 NEWS.md                                        |  6 +++++-
 _quarto.yml                                    |  2 +-
 accuracy/Hyperboloid.qmd                       |  4 ++--
 docs/src/features/atlases.md                   |  2 +-
 .../src/manifolds/symmetricpositivedefinite.md |  2 +-
 docs/src/misc/notation.md                      |  2 +-
 docs/src/references.bib                        |  2 +-
 ext/ManifoldsTestExt/tests_general.jl          |  6 +++---
 src/Manifolds.jl                               |  4 ++--
 src/groups/general_unitary_groups.jl           |  2 +-
 src/groups/group.jl                            | 14 +++++++-------
 src/groups/product_group.jl                    |  2 +-
 src/manifolds/Circle.jl                        |  6 +++---
 src/manifolds/Elliptope.jl                     |  2 +-
 src/manifolds/EmbeddedTorus.jl                 |  2 +-
 src/manifolds/Euclidean.jl                     |  6 +++---
 src/manifolds/GeneralizedGrassmann.jl          |  4 ++--
 src/manifolds/Hamiltonian.jl                   |  2 +-
 src/manifolds/Hyperbolic.jl                    | 12 ++++++------
 src/manifolds/HyperbolicPoincareBall.jl        |  2 +-
 src/manifolds/HyperbolicPoincareHalfspace.jl   |  2 +-
 src/manifolds/Hyperrectangle.jl                |  4 ++--
 src/manifolds/MetricManifold.jl                |  2 +-
 src/manifolds/MultinomialDoublyStochastic.jl   |  4 ++--
 src/manifolds/ProbabilitySimplex.jl            |  2 +-
 src/manifolds/Rotations.jl                     |  2 +-
 src/manifolds/Spectrahedron.jl                 |  2 +-
 src/manifolds/Sphere.jl                        |  4 ++--
 src/manifolds/Stiefel.jl                       |  2 +-
 src/manifolds/StiefelEuclideanMetric.jl        |  4 ++--
 src/manifolds/SymmetricPositiveDefinite.jl     |  2 +-
 src/manifolds/Symplectic.jl                    |  2 +-
 src/manifolds/SymplecticGrassmann.jl           |  4 ++--
 src/manifolds/SymplecticGrassmannProjector.jl  |  2 +-
 src/manifolds/Tucker.jl                        |  2 +-
 src/manifolds/Unitary.jl                       |  2 +-
 test/manifolds/symplecticgrassmann.jl          |  2 +-
 test/test_deprecated.jl                        |  6 +++---
 tutorials/getstarted.qmd                       | 18 +++++++++---------
 tutorials/hand-gestures.qmd                    |  2 +-
 tutorials/working-in-charts.jl                 |  4 ++--
 tutorials/working-in-charts.qmd                |  2 +-
 43 files changed, 83 insertions(+), 79 deletions(-)

diff --git a/CITATION.bib b/CITATION.bib
index ca8c186b08..9a0944b015 100644
--- a/CITATION.bib
+++ b/CITATION.bib
@@ -7,7 +7,7 @@ @article{AxenBaranBergmannRzecki:2023
     TITLE      = {Manifolds.jl: An Extensible {J}ulia Framework for Data Analysis on Manifolds},
     YEAR       = {2023}
 }
-@softawre{manifoldsjl-zenodo-mostrecent,
+@software{manifoldsjl-zenodo-mostrecent,
     AUTHOR    = {Seth D. Axen and Mateusz Baran and Ronny Bergmann},
     TITLE     = {Manifolds.jl},
     DOI       = {10.5281/ZENODO.4292129},
diff --git a/NEWS.md b/NEWS.md
index 8553089d63..8e3145e9fe 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -9,9 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-* fixed a few typos in the doc string of the SPD fixed determinant description.
 * Updated `Project.toml` compatibility entries.
 
+### Fixed
+
+* a few typos in the doc string of the SPD fixed determinant description
+* several other typographical errors throughout the documentation
+
 ## [0.9.18] – 2024-05-07
 
 ### Added
diff --git a/_quarto.yml b/_quarto.yml
index a25f29f3cc..44421d48c1 100644
--- a/_quarto.yml
+++ b/_quarto.yml
@@ -1,6 +1,6 @@
 
 project:
-  title: "Manonifolds.jl"
+  title: "Manifolds.jl"
   #execute-dir: project
 
 crossref:
diff --git a/accuracy/Hyperboloid.qmd b/accuracy/Hyperboloid.qmd
index 56763bac74..7b5b2fc6b0 100644
--- a/accuracy/Hyperboloid.qmd
+++ b/accuracy/Hyperboloid.qmd
@@ -12,7 +12,7 @@ cd(@__DIR__)
 Pkg.activate("."); # for reproducibility use the local accuracy environment.
 ```
 
-In this small note we compare different implementations of several functions on the [Hyperboloic]().
+In this small note we compare different implementations of several functions on the [Hyperbolic]().
 We compare the functions prior [PR #]() to vs those introduced therein.
 We compare the previous version (always called `_1`) and the new version `_2`, where we leave out the manifold to indicate, that these are the local functions here.
 We compare this to the one given in `Manifolds.jl` at time of writing (which is the first one), on `BigFloat` on several scales of magnitudes.
@@ -29,7 +29,7 @@ teal = paul_tol["mutedteal"]
 
 ## Reference Data
 
-We choose a “base point”, a direction and create tangent vectors and correcponding points in several magnutudes of distances
+We choose a “base point”, a direction and create tangent vectors and corresponding points in several magnitudes of distances
 ```{julia}
 #| output: false
 M = Hyperbolic(2)
diff --git a/docs/src/features/atlases.md b/docs/src/features/atlases.md
index a0f4067af6..94650d8cfc 100644
--- a/docs/src/features/atlases.md
+++ b/docs/src/features/atlases.md
@@ -1,6 +1,6 @@
 # [Atlases and charts](@id atlases_and_charts)
 
-Atlases on an ``n``-dimensional manifold ``mathcal M``are collections of charts ``\mathcal A = \{(U_i, φ_i) \colon i \in I\}``, where ``I`` is a (finite or infinte) index family, such that ``U_i \subseteq \mathcal M`` is an open set and each chart ``φ_i: U_i → ℝ^n`` is a homeomorphism. This means, that ``φ_i`` is bijective – sometimes also called one-to-one and onto - and continuous, and its inverse ``φ_i^{-1}`` is continuous as well.
+Atlases on an ``n``-dimensional manifold ``mathcal M``are collections of charts ``\mathcal A = \{(U_i, φ_i) \colon i \in I\}``, where ``I`` is a (finite or infinite) index family, such that ``U_i \subseteq \mathcal M`` is an open set and each chart ``φ_i: U_i → ℝ^n`` is a homeomorphism. This means, that ``φ_i`` is bijective – sometimes also called one-to-one and onto - and continuous, and its inverse ``φ_i^{-1}`` is continuous as well.
 The inverse ``φ_i^{-1}`` is called (local) parametrization.
 The resulting _parameters_ ``a=φ(p)`` of ``p`` (with respect to the chart ``φ``) are in the literature also called “(local) coordinates”. To distinguish the parameter ``a`` from  [`get_coordinates`](@ref) in a basis, we use the terminology parameter in this package.
 
diff --git a/docs/src/manifolds/symmetricpositivedefinite.md b/docs/src/manifolds/symmetricpositivedefinite.md
index a2ffc10c9d..3aae554e61 100644
--- a/docs/src/manifolds/symmetricpositivedefinite.md
+++ b/docs/src/manifolds/symmetricpositivedefinite.md
@@ -29,7 +29,7 @@ Pages = ["manifolds/SymmetricPositiveDefiniteAffineInvariant.jl"]
 Order = [:type]
 ```
 
-This metric is also the default metric, i.e. any call of the following functions with `P=SymmetricPositiveDefinite(3)` will result in `MetricManifold(P,AffineInvariantMetric())`and hence yield the formulae described in this seciton.
+This metric is also the default metric, i.e. any call of the following functions with `P=SymmetricPositiveDefinite(3)` will result in `MetricManifold(P,AffineInvariantMetric())`and hence yield the formulae described in this section.
 
 ```@autodocs
 Modules = [Manifolds]
diff --git a/docs/src/misc/notation.md b/docs/src/misc/notation.md
index 0b6033a884..483a4e7388 100644
--- a/docs/src/misc/notation.md
+++ b/docs/src/misc/notation.md
@@ -59,7 +59,7 @@ Within the documented functions, the utf8 symbols are used whenever possible, as
 | ``e_i \in \mathbb R^n`` | the ``i``th unit vector | ``e_i^n`` | the space dimension (``n``) is omitted, when clear from context
 | ``B`` | a vector bundle | |
 | ``\mathcal T_{q\gets p}X`` | vector transport | | of the vector ``X`` from ``T_p\mathcal M`` to ``T_q\mathcal M``
-| ``\mathcal T_{p,Y}X`` | vector transport in direction ``Y`` | | of the vector ``X`` from ``T_p\mathcal M`` to ``T_q\mathcal M``, where ``q`` is deretmined by ``Y``, for example using the exponential map or some retraction. |
+| ``\mathcal T_{p,Y}X`` | vector transport in direction ``Y`` | | of the vector ``X`` from ``T_p\mathcal M`` to ``T_q\mathcal M``, where ``q`` is determined by ``Y``, for example using the exponential map or some retraction. |
 | ``\operatorname{Vol}(\mathcal M)`` | volume of manifold ``\mathcal M`` | |
 | ``\theta_p(X)`` | volume density for vector ``X`` tangent at point ``p`` | |
 | ``\mathcal W`` | the Weingarten map ``\mathcal W: T_p\mathcal M × N_p\mathcal M → T_p\mathcal M`` | ``\mathcal W_p`` | the second notation to emphasize the dependency of the point ``p\in\mathcal M`` |
diff --git a/docs/src/references.bib b/docs/src/references.bib
index dbc921ae8b..c7eb19a168 100644
--- a/docs/src/references.bib
+++ b/docs/src/references.bib
@@ -143,7 +143,7 @@ @article{BergmannGousenbourger:2018
 }
 @book{BinzPods:2008,
     AUTHOR = {Biny, E and Pods, S},
-    PUBLISHER = {American Mathematical Socienty},
+    PUBLISHER = {American Mathematical Society},
     TITLE = {The Geometry of Heisenberg Groups: With Applications in Signal Theory, Optics, Quantization, and Field Quantization},
     YEAR = {2008}
 }
diff --git a/ext/ManifoldsTestExt/tests_general.jl b/ext/ManifoldsTestExt/tests_general.jl
index eee8c3dbe4..c600d00bdc 100644
--- a/ext/ManifoldsTestExt/tests_general.jl
+++ b/ext/ManifoldsTestExt/tests_general.jl
@@ -63,7 +63,7 @@ that lie on it (contained in `pts`).
 - `test_mutating_rand = false` : test the mutating random function for points on manifolds.
 - `test_project_point = false`: test projections onto the manifold.
 - `test_project_tangent = false` : test projections on tangent spaces.
-- `test_representation_size = true` : test repersentation size of points/tvectprs.
+- `test_representation_size = true` : test representation size of points/tvectprs.
 - `test_tangent_vector_broadcasting = true` : test boradcasting operators on TangentSpace.
 - `test_vector_spaces = true` : test Vector bundle of this manifold.
 - `test_default_vector_transport = false` : test the default vector transport (usually
@@ -841,12 +841,12 @@ function test_manifold(
 end
 
 """
-    test_parallel_transport(M,P; along=false, to=true, diretion=true)
+    test_parallel_transport(M,P; along=false, to=true, direction=true)
 
 Generic tests for parallel transport on `M`given at least two pointsin `P`.
 
 The single functions to transport `along` (a curve), `to` (a point) or (towards a) `direction`
-are sub-tests that can be activated by the keywords arguemnts
+are sub-tests that can be activated by the keywords arguments
 
 !!! Note
 Since the interface to specify curves is not yet provided, the along keyword does not have an effect yet
diff --git a/src/Manifolds.jl b/src/Manifolds.jl
index f9af303499..3ae857b7a2 100644
--- a/src/Manifolds.jl
+++ b/src/Manifolds.jl
@@ -157,7 +157,7 @@ import ManifoldsBase:
     vector_transport_along,           # just specified in Euclidean - the next 5 as well
     vector_transport_along!,
     vector_transport_along_diff!,     # For consistency these are imported, but for now not
-    vector_transport_along_project!,  # overwritten with new definitons.
+    vector_transport_along_project!,  # overwritten with new definitions.
     vector_transport_direction,
     vector_transport_direction!,
     vector_transport_direction_diff!,
@@ -496,7 +496,7 @@ include("groups/product_group.jl")
 include("groups/semidirect_product_group.jl")
 include("groups/power_group.jl")
 
-# generic group - commopn (special) unitary/orthogonal functions
+# generic group - common (special) unitary/orthogonal functions
 include("groups/general_unitary_groups.jl")
 # Special Group Manifolds
 include("groups/general_linear.jl")
diff --git a/src/groups/general_unitary_groups.jl b/src/groups/general_unitary_groups.jl
index 3ab3dabdbf..b9ebcc0906 100644
--- a/src/groups/general_unitary_groups.jl
+++ b/src/groups/general_unitary_groups.jl
@@ -1,7 +1,7 @@
 @doc raw"""
     GeneralUnitaryMultiplicationGroup{T,𝔽,S} <: AbstractDecoratorManifold{𝔽}
 
-A generic type for Lie groups based on a unitary property and matrix multiplcation,
+A generic type for Lie groups based on a unitary property and matrix multiplication,
 see e.g. [`Orthogonal`](@ref), [`SpecialOrthogonal`](@ref), [`Unitary`](@ref), and [`SpecialUnitary`](@ref)
 """
 struct GeneralUnitaryMultiplicationGroup{T,𝔽,S} <: AbstractDecoratorManifold{𝔽}
diff --git a/src/groups/group.jl b/src/groups/group.jl
index 131a725f36..b5e0c59232 100644
--- a/src/groups/group.jl
+++ b/src/groups/group.jl
@@ -223,7 +223,7 @@ end
 Identity(::O) where {O<:AbstractGroupOperation} = Identity(O)
 Identity(::Type{O}) where {O<:AbstractGroupOperation} = Identity{O}()
 
-# To ensure allocate_result_type works in general if idenitty apears in the tuple
+# To ensure allocate_result_type works in general if identity appears in the tuple
 number_eltype(::Identity) = Bool
 
 @doc raw"""
@@ -431,7 +431,7 @@ end
 Adjoint action of the element `p` of the Lie group `G` on the element `X`
 of the corresponding Lie algebra.
 
-It is defined as the differential of the group authomorphism ``Ψ_p(q) = pqp⁻¹`` at
+It is defined as the differential of the group automorphism ``Ψ_p(q) = pqp⁻¹`` at
 the identity of `G`.
 
 The formula reads
@@ -703,10 +703,10 @@ function hat!(
     return get_vector_lie!(M, Y, X, VeeOrthogonalBasis())
 end
 function hat(M::AbstractManifold, e::Identity, ::Any)
-    return throw(ErrorException("On $M there exsists no identity $e"))
+    return throw(ErrorException("On $M there exists no identity $e"))
 end
 function hat!(M::AbstractManifold, c, e::Identity, X)
-    return throw(ErrorException("On $M there exsists no identity $e"))
+    return throw(ErrorException("On $M there exists no identity $e"))
 end
 
 @trait_function vee(M::AbstractDecoratorManifold, e::Identity, X)
@@ -745,10 +745,10 @@ function vee!(
     return get_coordinates_lie!(M, Y, X, VeeOrthogonalBasis())
 end
 function vee(M::AbstractManifold, e::Identity, X)
-    return throw(ErrorException("On $M there exsists no identity $e"))
+    return throw(ErrorException("On $M there exists no identity $e"))
 end
 function vee!(M::AbstractManifold, c, e::Identity, X)
-    return throw(ErrorException("On $M there exsists no identity $e"))
+    return throw(ErrorException("On $M there exists no identity $e"))
 end
 
 """
@@ -1245,7 +1245,7 @@ end
 @doc raw"""
     get_vector_lie(G::AbstractDecoratorManifold, a, B::AbstractBasis)
 
-Reconstruct a tangent vector from the Lie algebra of `G` from cooordinates `a` of a basis `B`.
+Reconstruct a tangent vector from the Lie algebra of `G` from coordinates `a` of a basis `B`.
 This is similar to calling [`get_vector`](@ref) at the `p=`[`Identity`](@ref)`(G)`.
 """
 function get_vector_lie(
diff --git a/src/groups/product_group.jl b/src/groups/product_group.jl
index 7565c5f925..b630edf4ef 100644
--- a/src/groups/product_group.jl
+++ b/src/groups/product_group.jl
@@ -65,7 +65,7 @@ end
 
 function is_identity(G::ProductGroup, p::Identity{<:ProductOperation}; kwargs...)
     pes = submanifold_components(G, p)
-    M = G.manifold # Inner prodct manifold (of groups)
+    M = G.manifold # Inner product manifold (of groups)
     return all(map((M, pe) -> is_identity(M, pe; kwargs...), M.manifolds, pes))
 end
 
diff --git a/src/manifolds/Circle.jl b/src/manifolds/Circle.jl
index 0109786e1d..6273d40e04 100644
--- a/src/manifolds/Circle.jl
+++ b/src/manifolds/Circle.jl
@@ -354,7 +354,7 @@ manifold_volume(::Circle) = 2 * π
     mean(M::Circle{ℝ}, x::AbstractVector[, w::AbstractWeights])
 
 Compute the Riemannian [`mean`](@ref mean(M::AbstractManifold, args...)) of `x` of points on
-the [`Circle`](@ref) ``𝕊^1``, reprsented by real numbers, i.e. the angular mean
+the [`Circle`](@ref) ``𝕊^1``, represented by real numbers, i.e. the angular mean
 ````math
 \operatorname{atan}\Bigl( \sum_{i=1}^n w_i\sin(x_i),  \sum_{i=1}^n w_i\sin(x_i) \Bigr).
 ````
@@ -375,7 +375,7 @@ end
     mean(M::Circle{ℂ}, x::AbstractVector[, w::AbstractWeights])
 
 Compute the Riemannian [`mean`](@ref mean(M::AbstractManifold, args...)) of `x` of points on
-the [`Circle`](@ref) ``𝕊^1``, reprsented by complex numbers, i.e. embedded in the complex plane.
+the [`Circle`](@ref) ``𝕊^1``, represented by complex numbers, i.e. embedded in the complex plane.
 Comuting the sum
 ````math
 s = \sum_{i=1}^n x_i
@@ -510,7 +510,7 @@ sym_rem(x, T=π) = map(sym_rem, x, Ref(T))
 Compute the parallel transport of `X` from the tangent space at `p` to the tangent space at
 `q` on the [`Circle`](@ref) `M`.
 For the real-valued case this results in the identity.
-For the complex-valud case, the formula is the same as for the [`Sphere`](@ref)`(1)` in the
+For the complex-valued case, the formula is the same as for the [`Sphere`](@ref)`(1)` in the
 complex plane.
 ````math
 \mathcal P_{q←p} X = X - \frac{⟨\log_p q,X⟩_p}{d^2_{ℂ}(p,q)}
diff --git a/src/manifolds/Elliptope.jl b/src/manifolds/Elliptope.jl
index 638bdbeaef..3f9363249c 100644
--- a/src/manifolds/Elliptope.jl
+++ b/src/manifolds/Elliptope.jl
@@ -56,7 +56,7 @@ end
 @doc raw"""
     check_point(M::Elliptope, q; kwargs...)
 
-checks, whether `q` is a valid reprsentation of a point ``p=qq^{\mathrm{T}}`` on the
+checks, whether `q` is a valid representation of a point ``p=qq^{\mathrm{T}}`` on the
 [`Elliptope`](@ref) `M`, i.e. is a matrix
 of size `(N,K)`, such that ``p`` is symmetric positive semidefinite and has unit trace.
 Since by construction ``p`` is symmetric, this is not explicitly checked.
diff --git a/src/manifolds/EmbeddedTorus.jl b/src/manifolds/EmbeddedTorus.jl
index 9adb27d2d2..7e1f6fe04e 100644
--- a/src/manifolds/EmbeddedTorus.jl
+++ b/src/manifolds/EmbeddedTorus.jl
@@ -34,7 +34,7 @@ Check whether `p` is a valid point on the [`EmbeddedTorus`](@ref) `M`.
 The tolerance for the last test can be set using the `kwargs...`.
 
 The method checks if ``(p_1^2 + p_2^2 + p_3^2 + R^2 - r^2)^2``
-is apprximately equal to ``4R^2(p_1^2 + p_2^2)``.
+is approximately equal to ``4R^2(p_1^2 + p_2^2)``.
 """
 function check_point(M::EmbeddedTorus, p; kwargs...)
     A = (dot(p, p) + M.R^2 - M.r^2)^2
diff --git a/src/manifolds/Euclidean.jl b/src/manifolds/Euclidean.jl
index e2b471fad2..aec3f9c25f 100644
--- a/src/manifolds/Euclidean.jl
+++ b/src/manifolds/Euclidean.jl
@@ -659,7 +659,7 @@ end
 """
     parallel_transport_along(M::Euclidean, p, X, c)
 
-the parallel transport on [`Euclidean`](@ref) is the identiy, i.e. returns `X`.
+the parallel transport on [`Euclidean`](@ref) is the identity, i.e. returns `X`.
 """
 parallel_transport_along(::Euclidean, ::Any, X, c::AbstractVector) = X
 parallel_transport_along!(::Euclidean, Y, ::Any, X, c::AbstractVector) = copyto!(Y, X)
@@ -667,7 +667,7 @@ parallel_transport_along!(::Euclidean, Y, ::Any, X, c::AbstractVector) = copyto!
 """
     parallel_transport_direction(M::Euclidean, p, X, d)
 
-the parallel transport on [`Euclidean`](@ref) is the identiy, i.e. returns `X`.
+the parallel transport on [`Euclidean`](@ref) is the identity, i.e. returns `X`.
 """
 parallel_transport_direction(::Euclidean, ::Any, X, ::Any) = X
 parallel_transport_direction!(::Euclidean, Y, ::Any, X, ::Any) = copyto!(Y, X)
@@ -675,7 +675,7 @@ parallel_transport_direction!(::Euclidean, Y, ::Any, X, ::Any) = copyto!(Y, X)
 """
     parallel_transport_to(M::Euclidean, p, X, q)
 
-the parallel transport on [`Euclidean`](@ref) is the identiy, i.e. returns `X`.
+the parallel transport on [`Euclidean`](@ref) is the identity, i.e. returns `X`.
 """
 parallel_transport_to(::Euclidean, ::Any, X, ::Any) = X
 parallel_transport_to!(::Euclidean, Y, ::Any, X, ::Any) = copyto!(Y, X)
diff --git a/src/manifolds/GeneralizedGrassmann.jl b/src/manifolds/GeneralizedGrassmann.jl
index 05703066f2..fe8ad7a5da 100644
--- a/src/manifolds/GeneralizedGrassmann.jl
+++ b/src/manifolds/GeneralizedGrassmann.jl
@@ -99,7 +99,7 @@ end
     check_point(M::GeneralizedGrassmann, p)
 
 Check whether `p` is representing a point on the [`GeneralizedGrassmann`](@ref) `M`, i.e. its
-a `n`-by-`k` matrix of unitary column vectors with respect to the B inner prudct and
+a `n`-by-`k` matrix of unitary column vectors with respect to the B inner product and
 of correct `eltype` with respect to `𝔽`.
 """
 function check_point(M::GeneralizedGrassmann, p; kwargs...)
@@ -359,7 +359,7 @@ end
 @doc raw"""
     representation_size(M::GeneralizedGrassmann)
 
-Return the represenation size or matrix dimension of a point on the [`GeneralizedGrassmann`](@ref)
+Return the representation size or matrix dimension of a point on the [`GeneralizedGrassmann`](@ref)
 `M`, i.e. ``(n,k)`` for both the real-valued and the complex value case.
 """
 representation_size(M::GeneralizedGrassmann) = get_parameter(M.size)
diff --git a/src/manifolds/Hamiltonian.jl b/src/manifolds/Hamiltonian.jl
index 3b33e00aa9..33c5111b3b 100644
--- a/src/manifolds/Hamiltonian.jl
+++ b/src/manifolds/Hamiltonian.jl
@@ -78,7 +78,7 @@ end
 ManifoldsBase.@default_manifold_fallbacks HamiltonianMatrices Hamiltonian Hamiltonian value value
 
 @doc raw"""
-    ^(A::Hamilonian, ::typeof(+))
+    ^(A::Hamiltonian, ::typeof(+))
 
 Compute the [`symplectic_inverse`](@ref) of a Hamiltonian (A)
 """
diff --git a/src/manifolds/Hyperbolic.jl b/src/manifolds/Hyperbolic.jl
index f7be05f38b..133b56d6e0 100644
--- a/src/manifolds/Hyperbolic.jl
+++ b/src/manifolds/Hyperbolic.jl
@@ -24,7 +24,7 @@ metric. The corresponding sectional curvature is ``-1``.
 If `p` and `X` are `Vector`s of length `n+1` they are assumed to be
 a [`HyperboloidPoint`](@ref) and a [`HyperboloidTVector`](@ref), respectively
 
-Other models are the Poincaré ball model, see [`PoincareBallPoint`](@ref) and [`PoincareBallTVector`](@ref), respectiely
+Other models are the Poincaré ball model, see [`PoincareBallPoint`](@ref) and [`PoincareBallTVector`](@ref), respectively
 and the Poincaré half space model, see [`PoincareHalfSpacePoint`](@ref) and [`PoincareHalfSpaceTVector`](@ref), respectively.
 
 # Constructor
@@ -52,7 +52,7 @@ end
 In the Hyperboloid model of the [`Hyperbolic`](@ref) ``\mathcal H^n`` points are represented
 as vectors in ``ℝ^{n+1}`` with [`MinkowskiMetric`](@ref) equal to ``-1``.
 
-This representation is the default, i.e. `AbstractVector`s are assumed to have this repesentation.
+This representation is the default, i.e. `AbstractVector`s are assumed to have this representation.
 """
 struct HyperboloidPoint{TValue<:AbstractVector} <: AbstractManifoldPoint
     value::TValue
@@ -65,7 +65,7 @@ In the Hyperboloid model of the [`Hyperbolic`](@ref) ``\mathcal H^n`` tangent vc
 as vectors in ``ℝ^{n+1}`` with [`MinkowskiMetric`](@ref) ``⟨p,X⟩_{\mathrm{M}}=0`` to their base
 point ``p``.
 
-This representation is the default, i.e. vectors are assumed to have this repesentation.
+This representation is the default, i.e. vectors are assumed to have this representation.
 """
 struct HyperboloidTVector{TValue<:AbstractVector} <: TVector
     value::TValue
@@ -148,7 +148,7 @@ For the [`HyperboloidPoint`](@ref) or plain vectors this means that, `p` is a ve
 length ``n+1`` with inner product in the embedding of -1, see [`MinkowskiMetric`](@ref).
 The tolerance for the last test can be set using the `kwargs...`.
 
-For the [`PoincareBallPoint`](@ref) a valid point is a vector ``p ∈ ℝ^n`` with a norm stricly
+For the [`PoincareBallPoint`](@ref) a valid point is a vector ``p ∈ ℝ^n`` with a norm strictly
 less than 1.
 
 For the [`PoincareHalfSpacePoint`](@ref) a valid point is a vector from ``p ∈ ℝ^n`` with a positive
@@ -288,7 +288,7 @@ reaches `q` after time 1. The formula reads for ``p ≠ q``
 ```
 
 where ``⟨⋅,⋅⟩_{\mathrm{M}}`` denotes the [`MinkowskiMetric`](@ref) on the embedding,
-the [`Lorentz`](@ref)ian manifold. For ``p=q`` the logarihmic map is equal to the zero vector.
+the [`Lorentz`](@ref)ian manifold. For ``p=q`` the logarithmic map is equal to the zero vector.
 """
 log(::Hyperbolic, ::Any...)
 
@@ -368,7 +368,7 @@ end
 @doc raw"""
     parallel_transport_to(M::Hyperbolic, p, X, q)
 
-Compute the paralllel transport of the `X` from the tangent space at `p` on the
+Compute the parallel transport of the `X` from the tangent space at `p` on the
 [`Hyperbolic`](@ref) space ``\mathcal H^n`` to the tangent at `q` along the [`geodesic`](@extref `ManifoldsBase.geodesic-Tuple{AbstractManifold, Any, Any}`)
 connecting `p` and `q`. The formula reads
 
diff --git a/src/manifolds/HyperbolicPoincareBall.jl b/src/manifolds/HyperbolicPoincareBall.jl
index 160576f031..0e7cd5d5e4 100644
--- a/src/manifolds/HyperbolicPoincareBall.jl
+++ b/src/manifolds/HyperbolicPoincareBall.jl
@@ -303,7 +303,7 @@ end
 @doc raw"""
     project(::Hyperbolic, ::PoincareBallPoint, ::PoincareBallTVector)
 
-projction of tangent vectors in the Poincaré ball model is just the identity, since
+projection of tangent vectors in the Poincaré ball model is just the identity, since
 the tangent space consists of all ``ℝ^n``.
 """
 project(::Hyperbolic, ::PoincareBallPoint, ::PoincareBallTVector)
diff --git a/src/manifolds/HyperbolicPoincareHalfspace.jl b/src/manifolds/HyperbolicPoincareHalfspace.jl
index 8ecc74d2e2..abe44be1a4 100644
--- a/src/manifolds/HyperbolicPoincareHalfspace.jl
+++ b/src/manifolds/HyperbolicPoincareHalfspace.jl
@@ -253,7 +253,7 @@ end
 @doc raw"""
     project(::Hyperbolic, ::PoincareHalfSpacePoint ::PoincareHalfSpaceTVector)
 
-projction of tangent vectors in the Poincaré half space model is just the identity, since
+projection of tangent vectors in the Poincaré half space model is just the identity, since
 the tangent space consists of all $ℝ^n$.
 """
 project(::Hyperbolic, ::PoincareHalfSpacePoint::PoincareHalfSpaceTVector)
diff --git a/src/manifolds/Hyperrectangle.jl b/src/manifolds/Hyperrectangle.jl
index 11c0180fae..457ef59638 100644
--- a/src/manifolds/Hyperrectangle.jl
+++ b/src/manifolds/Hyperrectangle.jl
@@ -321,7 +321,7 @@ LinearAlgebra.norm(::Hyperrectangle, ::Any, X) = norm(X)
 """
     parallel_transport_direction(M::Hyperrectangle, p, X, d)
 
-the parallel transport on [`Hyperrectangle`](@ref) is the identiy, i.e. returns `X`.
+the parallel transport on [`Hyperrectangle`](@ref) is the identity, i.e. returns `X`.
 """
 parallel_transport_direction(::Hyperrectangle, ::Any, X, ::Any) = X
 parallel_transport_direction!(::Hyperrectangle, Y, ::Any, X, ::Any) = copyto!(Y, X)
@@ -329,7 +329,7 @@ parallel_transport_direction!(::Hyperrectangle, Y, ::Any, X, ::Any) = copyto!(Y,
 """
     parallel_transport_to(M::Hyperrectangle, p, X, q)
 
-the parallel transport on [`Hyperrectangle`](@ref) is the identiy, i.e. returns `X`.
+the parallel transport on [`Hyperrectangle`](@ref) is the identity, i.e. returns `X`.
 """
 parallel_transport_to(::Hyperrectangle, ::Any, X, ::Any) = X
 parallel_transport_to!(::Hyperrectangle, Y, ::Any, X, ::Any) = copyto!(Y, X)
diff --git a/src/manifolds/MetricManifold.jl b/src/manifolds/MetricManifold.jl
index 08b8e83af7..430f3735ff 100644
--- a/src/manifolds/MetricManifold.jl
+++ b/src/manifolds/MetricManifold.jl
@@ -500,7 +500,7 @@ end
 @doc raw"""
     log(N::MetricManifold{M,G}, p, q)
 
-Copute the logarithmic map on the [`AbstractManifold`](https://juliamanifolds.github.io/Manifolds.jl/latest/interface.html#ManifoldsBase.AbstractManifold) `M` equipped with the
+Compute the logarithmic map on the [`AbstractManifold`](https://juliamanifolds.github.io/Manifolds.jl/latest/interface.html#ManifoldsBase.AbstractManifold) `M` equipped with the
 [`AbstractMetric`](@extref `ManifoldsBase.AbstractMetric`) `G`.
 
 If the metric was declared the default metric using the [`IsDefaultMetric`](@ref) trait or [`is_default_metric`](@ref), this method
diff --git a/src/manifolds/MultinomialDoublyStochastic.jl b/src/manifolds/MultinomialDoublyStochastic.jl
index 2c2aa5e217..14d09744ca 100644
--- a/src/manifolds/MultinomialDoublyStochastic.jl
+++ b/src/manifolds/MultinomialDoublyStochastic.jl
@@ -17,7 +17,7 @@ end
 @doc raw"""
     representation_size(M::AbstractMultinomialDoublyStochastic)
 
-return the representation size of doubly stochastic matrices, whic are embedded
+return the representation size of doubly stochastic matrices, which are embedded
 in the ``ℝ^{n×n}`` matrices and hence the answer here is ``
 """
 function representation_size(M::AbstractMultinomialDoublyStochastic)
@@ -189,7 +189,7 @@ end
     )
 
 project a matrix `p` with positive entries applying Sinkhorn's algorithm.
-Note that this projct method – different from the usual case, accepts keywords.
+Note that this project method – different from the usual case, accepts keywords.
 """
 function project(M::AbstractMultinomialDoublyStochastic, p; kwargs...)
     q = allocate_result(M, project, p)
diff --git a/src/manifolds/ProbabilitySimplex.jl b/src/manifolds/ProbabilitySimplex.jl
index 114eed9a83..0cfac6e487 100644
--- a/src/manifolds/ProbabilitySimplex.jl
+++ b/src/manifolds/ProbabilitySimplex.jl
@@ -68,7 +68,7 @@ active_traits(f, ::ProbabilitySimplex, args...) = merge_traits(IsEmbeddedManifol
 
 Given a tangent vector with respect to the metric from the embedding, the [`EuclideanMetric`](@extref `ManifoldsBase.EuclideanMetric`),
 the representer of a linear functional on the tangent space is adapted as ``Z = p .* X .- p .* dot(p, X)``.
-The first part “compensates” for the divsion by ``p`` in the Riemannian metric on the [`ProbabilitySimplex`](@ref)
+The first part “compensates” for the division by ``p`` in the Riemannian metric on the [`ProbabilitySimplex`](@ref)
 and the second part performs appropriate projection to keep the vector tangent.
 
 For details see Proposition 2.3 in [AastroemPetraSchmitzerSchnoerr:2017](@cite).
diff --git a/src/manifolds/Rotations.jl b/src/manifolds/Rotations.jl
index 72e27c0649..fccece31c5 100644
--- a/src/manifolds/Rotations.jl
+++ b/src/manifolds/Rotations.jl
@@ -414,7 +414,7 @@ The Riemannian Hessian can be computed by adopting Eq. (5.6) [Nguyen:2023](@cite
 so very similar to the Stiefel manifold.
 The only difference is, that here the tangent vectors are stored
 in the Lie algebra, i.e. the update direction is actually ``pX`` instead of just ``X`` (in Stiefel).
-and that means the inverse has to be appliead to the (Euclidean) Hessian
+and that means the inverse has to be applied to the (Euclidean) Hessian
 to map it into the Lie algebra.
 """
 riemannian_Hessian(M::Rotations, p, G, H, X)
diff --git a/src/manifolds/Spectrahedron.jl b/src/manifolds/Spectrahedron.jl
index 4e12192b3e..6d0de73c96 100644
--- a/src/manifolds/Spectrahedron.jl
+++ b/src/manifolds/Spectrahedron.jl
@@ -56,7 +56,7 @@ active_traits(f, ::Spectrahedron, args...) = merge_traits(IsIsometricEmbeddedMan
 @doc raw"""
     check_point(M::Spectrahedron, q; kwargs...)
 
-checks, whether `q` is a valid reprsentation of a point ``p=qq^{\mathrm{T}}`` on the
+checks, whether `q` is a valid representation of a point ``p=qq^{\mathrm{T}}`` on the
 [`Spectrahedron`](@ref) `M`, i.e. is a matrix
 of size `(N,K)`, such that ``p`` is symmetric positive semidefinite and has unit trace,
 i.e. ``q`` has to have unit frobenius norm.
diff --git a/src/manifolds/Sphere.jl b/src/manifolds/Sphere.jl
index d5266d0d52..a9981cd1b3 100644
--- a/src/manifolds/Sphere.jl
+++ b/src/manifolds/Sphere.jl
@@ -158,7 +158,7 @@ end
 @doc raw"""
     distance(M::AbstractSphere, p, q)
 
-Compute the geodesic distance betweeen `p` and `q` on the [`AbstractSphere`](@ref) `M`.
+Compute the geodesic distance between `p` and `q` on the [`AbstractSphere`](@ref) `M`.
 The formula is given by the (shorter) great arc length on the (or a) great circle
 both `p` and `q` lie on.
 
@@ -182,7 +182,7 @@ embed(::AbstractSphere, p, X) = copy(X)
     exp(M::AbstractSphere, p, X)
 
 Compute the exponential map from `p` in the tangent direction `X` on the [`AbstractSphere`](@ref)
-`M` by following the great arc eminating from `p` in direction `X`.
+`M` by following the great arc emanating from `p` in direction `X`.
 
 ````math
 \exp_p X = \cos(\lVert X \rVert_p)p + \sin(\lVert X \rVert_p)\frac{X}{\lVert X \rVert_p},
diff --git a/src/manifolds/Stiefel.jl b/src/manifolds/Stiefel.jl
index 19dadcd448..b8243dcc26 100644
--- a/src/manifolds/Stiefel.jl
+++ b/src/manifolds/Stiefel.jl
@@ -157,7 +157,7 @@ end
 
 Compute the inverse retraction based on a singular value decomposition
 for two points `p`, `q` on the [`Stiefel`](@ref) manifold `M`.
-This follows the folloing approach: From the Polar retraction we know that
+This follows the following approach: From the Polar retraction we know that
 
 ````math
 \operatorname{retr}_p^{-1}q = qs - t
diff --git a/src/manifolds/StiefelEuclideanMetric.jl b/src/manifolds/StiefelEuclideanMetric.jl
index 96cff8ef09..b909fbe336 100644
--- a/src/manifolds/StiefelEuclideanMetric.jl
+++ b/src/manifolds/StiefelEuclideanMetric.jl
@@ -55,7 +55,7 @@ basis is constructed.
 
 Since ``[p\ p_⊥]`` is an automorphism on ``ℝ^{n×p}`` the elements of ``a`` and ``b`` are
 orthonormal coordinates for the tangent space. To be precise exactly one element in the upper
-trangular entries of ``a`` is set to ``1`` its symmetric entry to ``-1`` and we normalize with
+triangular entries of ``a`` is set to ``1`` its symmetric entry to ``-1`` and we normalize with
 the factor ``\frac{1}{\sqrt{2}}`` and for ``b`` one can just use unit vectors reshaped to a matrix
 to obtain orthonormal set of parameters.
 """
@@ -80,7 +80,7 @@ function get_vector_orthonormal!(M::Stiefel{<:Any,ℝ}, X, p, c, N::RealNumbers)
     V = get_vectors(M, p, DefaultOrthonormalBasis(N))
     zero_vector!(M, X, p)
     length(c) < length(V) && error(
-        "Coordinate vector too short. Excpected $(length(V)), but only got $(length(c)) entries.",
+        "Coordinate vector too short. Expected $(length(V)), but only got $(length(c)) entries.",
     )
     @inbounds for i in 1:length(V)
         X .+= c[i] .* V[i]
diff --git a/src/manifolds/SymmetricPositiveDefinite.jl b/src/manifolds/SymmetricPositiveDefinite.jl
index 8734888d86..716d08bb1f 100644
--- a/src/manifolds/SymmetricPositiveDefinite.jl
+++ b/src/manifolds/SymmetricPositiveDefinite.jl
@@ -160,7 +160,7 @@ end
 
 Check whether `X` is a tangent vector to `p` on the [`SymmetricPositiveDefinite`](@ref) `M`,
 i.e. atfer [`check_point`](@ref)`(M,p)`, `X` has to be of same dimension as `p`
-and a symmetric matrix, i.e. this stores tangent vetors as elements of the corresponding
+and a symmetric matrix, i.e. this stores tangent vectors as elements of the corresponding
 Lie group.
 The tolerance for the last test can be set using the `kwargs...`.
 """
diff --git a/src/manifolds/Symplectic.jl b/src/manifolds/Symplectic.jl
index b8f38dbea8..944ee44218 100644
--- a/src/manifolds/Symplectic.jl
+++ b/src/manifolds/Symplectic.jl
@@ -558,7 +558,7 @@ inverse cayley retraction as long as the following matrices exist.
 
 where ``(⋅)^+`` denotes the [`symplectic_inverse`](@ref).
 
-Then inverse cayley retration at ``p`` applied to ``q`` is
+Then inverse cayley retraction at ``p`` applied to ``q`` is
 ```math
 \mathcal{L}_p^{\mathrm{Sp}}(q)
   = 2p\bigl(V - U\bigr) + 2\bigl((p + q)U - p\bigr) ∈ T_p\mathrm{Sp}(2n).
diff --git a/src/manifolds/SymplecticGrassmann.jl b/src/manifolds/SymplecticGrassmann.jl
index 2438a616cc..c5051af2e2 100644
--- a/src/manifolds/SymplecticGrassmann.jl
+++ b/src/manifolds/SymplecticGrassmann.jl
@@ -38,7 +38,7 @@ representation as projectors, using a [`ProjectorTVector`](@ref) as
 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).
 
-The first repesentation is in [`StiefelPoint`](@ref)s and [`StiefelTVector`](@ref)s,
+The first representation is in [`StiefelPoint`](@ref)s and [`StiefelTVector`](@ref)s,
 which both represent their symplectic Grassmann equivalence class. Arrays are interpreted
 in this representation as well
 
@@ -114,7 +114,7 @@ function Base.show(io::IO, M::SymplecticGrassmann{Tuple{Int,Int},𝔽}) where {
 end
 
 #
-# Representer specific implementations in their corrsponding subfiles
+# Representer specific implementations in their corresponding subfiles
 #
 include("SymplecticGrassmannStiefel.jl")
 include("SymplecticGrassmannProjector.jl")
diff --git a/src/manifolds/SymplecticGrassmannProjector.jl b/src/manifolds/SymplecticGrassmannProjector.jl
index 8a9235a3de..4a623f783a 100644
--- a/src/manifolds/SymplecticGrassmannProjector.jl
+++ b/src/manifolds/SymplecticGrassmannProjector.jl
@@ -2,7 +2,7 @@
     check_point(M::SymplecticGrassmann, p::ProjectorPoint; kwargs...)
 
 Check whether `p` is a valid point on the [`SymplecticGrassmann`](@ref),
-``\operatorname{SpGr}(2n, 2k)``, that is a propoer symplectic projection:
+``\operatorname{SpGr}(2n, 2k)``, that is a proper 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
diff --git a/src/manifolds/Tucker.jl b/src/manifolds/Tucker.jl
index 87e22e03be..94b072197a 100644
--- a/src/manifolds/Tucker.jl
+++ b/src/manifolds/Tucker.jl
@@ -674,7 +674,7 @@ end
     retract(::Tucker, p::TuckerPoint, X::TuckerTVector, ::PolarRetraction)
 
 The truncated HOSVD-based retraction [KressnerSteinlechnerVandereycken:2013](@cite) to the Tucker manifold, i.e.
-the result is the sequentially tuncated HOSVD approximation of ``p + X``.
+the result is the sequentially truncated HOSVD approximation of ``p + X``.
 
 In the exceptional case that the multilinear rank of ``p + X`` is lower than that of ``p``, this
 retraction produces a boundary point, which is outside the manifold.
diff --git a/src/manifolds/Unitary.jl b/src/manifolds/Unitary.jl
index b861058033..fb2412b27e 100644
--- a/src/manifolds/Unitary.jl
+++ b/src/manifolds/Unitary.jl
@@ -183,7 +183,7 @@ The Riemannian Hessian can be computed by adopting Eq. (5.6) [Nguyen:2023](@cite
 so very similar to the complex Stiefel manifold.
 The only difference is, that here the tangent vectors are stored
 in the Lie algebra, i.e. the update direction is actually ``pX`` instead of just ``X`` (in Stiefel).
-and that means the inverse has to be appliead to the (Euclidean) Hessian
+and that means the inverse has to be applied to the (Euclidean) Hessian
 to map it into the Lie algebra.
 """
 riemannian_Hessian(M::UnitaryMatrices, p, G, H, X)
diff --git a/test/manifolds/symplecticgrassmann.jl b/test/manifolds/symplecticgrassmann.jl
index 8bd7f1f1cf..43accdf8df 100644
--- a/test/manifolds/symplecticgrassmann.jl
+++ b/test/manifolds/symplecticgrassmann.jl
@@ -60,7 +60,7 @@ include("../header.jl")
         @test XE == X
         @test embed(M, StiefelPoint(p), StiefelTVector(X)) == X
     end
-    @testset "Expnential and Retractions" begin
+    @testset "Exponential and Retractions" begin
         @test inner(M, p, X, X) ≈ norm(M, p, X)^2
         N = get_embedding(M)
         @test isapprox(N, exp(M, p, X), exp(N, p, X))
diff --git a/test/test_deprecated.jl b/test/test_deprecated.jl
index 1fb4c592f5..926f9c0720 100644
--- a/test/test_deprecated.jl
+++ b/test/test_deprecated.jl
@@ -4,13 +4,13 @@ using StatsBase: AbstractWeights, pweights
 using Random: GLOBAL_RNG, seed!
 
 @testset "Deprecation tests" begin
-    @testset "Depreacte extrinsic_method= keyword" begin
+    @testset "Deprecate extrinsic_method= keyword" begin
         rng = MersenneTwister(47)
         S = Sphere(2)
         x = [normalize(randn(rng, 3)) for _ in 1:10]
         w = pweights([rand(rng) for _ in 1:length(x)])
         mg1 = mean(S, x, w, ExtrinsicEstimation(EfficientEstimator()))
-        # Statistics 414-418, depcreatce former extrinsic_method keyword
+        # Statistics 414-418, deprecate former extrinsic_method keyword
         mg2 = mean(
             S,
             x,
@@ -20,7 +20,7 @@ using Random: GLOBAL_RNG, seed!
         )
         @test isapprox(S, mg1, mg2)
         mg3 = median(S, x, w, ExtrinsicEstimation(CyclicProximalPointEstimation()))
-        # Statistics 692-696, depcreatce former extrinsic_method keyword
+        # Statistics 692-696, deprecate former extrinsic_method keyword
         mg4 = median(
             S,
             x,
diff --git a/tutorials/getstarted.qmd b/tutorials/getstarted.qmd
index 105ffc7541..a0d8d3d7d7 100644
--- a/tutorials/getstarted.qmd
+++ b/tutorials/getstarted.qmd
@@ -68,7 +68,7 @@ The easiest to check is the dimension of a manifold. Here we have three “direc
 manifold_dimension(M₁)
 ```
 
-#### 2. ``[The hyperpolic space](@ref HyperbolicSpace)``{=commonmark}
+#### 2. ``[The hyperbolic space](@ref HyperbolicSpace)``{=commonmark}
 
 The $d$-dimensional ``[hyperbolic space](@ref HyperbolicSpace)``{=commonmark} is usually represented in $\mathbb R^{d+1}$ as the set of points $p\in\mathbb R^3$ fulfilling
 
@@ -101,7 +101,7 @@ or
 is_point(M₂, [1, 0, 1])
 ```
 
-Keyword arguments are passed on to any numerical checks, for example an absolute tolerance when checking the above equiality.
+Keyword arguments are passed on to any numerical checks, for example an absolute tolerance when checking the above equality.
 
 But in an interactive session an error message might be helpful. A positional (third) argument is present to activate this. Setting this parameter to true, we obtain an error message that gives insight into why the point is not a point on `M₂`.
 Note that the `LoadError:` is due to quarto, on `REPL` you would just get the `DomainError`.
@@ -119,7 +119,7 @@ is_point(M₂, [0, 0, 1.001]; error=:error)
 M₃ = Sphere(2)
 ```
 
-If we only have a point that is approximately on the manifold, we can allow for a tolerance. Usually these are the same values of `atol` and `rtol` alowed in `isapprox`,
+If we only have a point that is approximately on the manifold, we can allow for a tolerance. Usually these are the same values of `atol` and `rtol` allowed in `isapprox`,
 i.e. we get
 
 ```{julia}
@@ -128,7 +128,7 @@ is_point(M₃, [0, 0, 1.001]; atol=1e-3)
 
 Here we can show a last nice check: ``[🔗 `is_vector`](@extref `ManifoldsBase.is_vector-Tuple{AbstractManifold, Any, Any, Bool, Bool}`)``{=commonmark} to check whether a tangent vector `X` is a representation of a tangent vector $X∈T_p\mathcal M$ to a point `p` on the manifold.
 
-This function has two positional asrguments, the first to again indicate whether to throw an error, the second to disable the check that `p` is a valid point on the manifold. Usually this validity is essential for the tangent check, but if it was for example performed before, it can be turned off to spare time.
+This function has two positional arguments, the first to again indicate whether to throw an error, the second to disable the check that `p` is a valid point on the manifold. Usually this validity is essential for the tangent check, but if it was for example performed before, it can be turned off to spare time.
 
 For example in our first example the point is not of unit norm
 
@@ -156,7 +156,7 @@ and for these we again get informative error messages
 @expect_error is_vector(M₃, [1, 0, 0], [0.1, 1, 1]; error=:error) DomainError
 ```
 
-To learn about how to define a manifold youself check out the ``[🔗 How to define your own manifold](@extref ManifoldsBase :doc:`tutorials/implement-a-manifold`)``{=commonmark} tutorial of ``[🔗 `ManifoldsBase.jl`](@extref ManifoldsBase :doc:`index`)``{=commonmark}."
+To learn about how to define a manifold yourself check out the ``[🔗 How to define your own manifold](@extref ManifoldsBase :doc:`tutorials/implement-a-manifold`)``{=commonmark} tutorial of ``[🔗 `ManifoldsBase.jl`](@extref ManifoldsBase :doc:`index`)``{=commonmark}."
 
 ### Building more advanced manifolds
 
@@ -214,7 +214,7 @@ p[M₄, 1]
 p₂[M₅, 2]
 ```
 
-Another construtor is the ``[ProductManifold](@ref ProductManifoldSection)``{=commonmark} to combine different manifolds.
+Another constructor is the ``[ProductManifold](@ref ProductManifoldSection)``{=commonmark} to combine different manifolds.
 Here of course the order matters. First we construct these using $×$
 
 ```{julia}
@@ -274,7 +274,7 @@ Which can now be used on any manifold where the shortest geodesic is implemented
 
 Now on several manifolds the [📖 exponential map](https://en.wikipedia.org/wiki/Exponential_map_(Riemannian_geometry)) and its (locally defined) inverse, the logarithmic map might not be available in an implementation. So one way to generalise this, is the use of a retraction (see  [AbsilMahonySepulchre:2008](@cite), Def. 4.1.1 for details) and its (local) inverse.
 
-The function itself is quite similar to the expponential map, just that ``[🔗 `retract(M, p, X, m)`](@extref `ManifoldsBase.retract`)``{=commonmark} has one further parameter, the type of retraction to take, so `m` is a subtype of ``[🔗 `AbstractRetractionMethod`](@extref `ManifoldsBase.AbstractRetractionMethod`)``{=commoonmark} `m`, the same for the ``[🔗 `inverse_retract(M, p, q, n)`](@extref `ManifoldsBase.inverse_retract`)``{=commonmark} with an ``[`AbstractInverseRetractionMethod`](@extref `ManifoldsBase.AbstractInverseRetractionMethod`)``{=commonmark} `n`.
+The function itself is quite similar to the exponential map, just that ``[🔗 `retract(M, p, X, m)`](@extref `ManifoldsBase.retract`)``{=commonmark} has one further parameter, the type of retraction to take, so `m` is a subtype of ``[🔗 `AbstractRetractionMethod`](@extref `ManifoldsBase.AbstractRetractionMethod`)``{=commoonmark} `m`, the same for the ``[🔗 `inverse_retract(M, p, q, n)`](@extref `ManifoldsBase.inverse_retract`)``{=commonmark} with an ``[`AbstractInverseRetractionMethod`](@extref `ManifoldsBase.AbstractInverseRetractionMethod`)``{=commonmark} `n`.
 
 Thinking of a generic implementation, we would like to have a way to specify one, that is available. This can be done by using ``[🔗 `default_retraction_method`](@extref `ManifoldsBase.default_retraction_method-Tuple{AbstractManifold}`)``{=commonmark} and ``[🔗 `default_inverse_retraction_method`](@extref `ManifoldsBase.default_inverse_retraction_method-Tuple{AbstractManifold}`)``{=commonmark}, respectively. We implement
 
@@ -315,7 +315,7 @@ The same mechanism exists for ``[🔗 `parallel_transport_to(M, p, X, q)`](@extr
 
 ## Allocating and in-place computations
 
-Memory allocation is a [🔗 critical performace issue](https://docs.julialang.org/en/v1/manual/performance-tips/#Measure-performance-with-[@time](@ref)-and-pay-attention-to-memory-allocation) when programming in Julia. To take this into account, `Manifolds.jl` provides special functions to reduce the amount of allocations.
+Memory allocation is a [🔗 critical performance issue](https://docs.julialang.org/en/v1/manual/performance-tips/#Measure-performance-with-[@time](@ref)-and-pay-attention-to-memory-allocation) when programming in Julia. To take this into account, `Manifolds.jl` provides special functions to reduce the amount of allocations.
 
 We again look at the [📖 exponential map](https://en.wikip edia.org/wiki/Exponential_map_(Riemannian_geometry)). On a manifold `M` the exponential map needs a point `p` (to start from) and a tangent vector `X`, which can be seen as direction to “walk into” as well as the length to walk into this direction. In `Manifolds.jl` the function can then be called with `q = exp(M, p, X)` (see ``[🔗 `exp(M, p, X)`](@extref `Base.exp-Tuple{AbstractManifold, Any, Any}`)``{=commonmark}). This function returns the resulting point `q`, which requires to allocate new memory.
 
@@ -423,7 +423,7 @@ The same approach is used for
 * specifying a certain ``[🔗 embedding](@extref ManifoldsBase The-Manifold-decorator)``{=commonmark}s
 * specify a certain ``[group action](@ref GroupManifoldSection)``{=commonmark}
 
-Again, for all of these, the concrete types only have to be used if you want to do a second, different from the details, property, for example a second way to embed a manfiold. If a manifold is (in its usual representation) an embedded manifold, this works with the default manifold type already, since then it is again set as the reasonable default.
+Again, for all of these, the concrete types only have to be used if you want to do a second, different from the details, property, for example a second way to embed a manifold. If a manifold is (in its usual representation) an embedded manifold, this works with the default manifold type already, since then it is again set as the reasonable default.
 
 ## Literature
 
diff --git a/tutorials/hand-gestures.qmd b/tutorials/hand-gestures.qmd
index c591f46975..a60815dcdf 100644
--- a/tutorials/hand-gestures.qmd
+++ b/tutorials/hand-gestures.qmd
@@ -85,7 +85,7 @@ Now let's show explained variance of each principal component.
 plot(principalvars(fp), title="explained variance", label="Tangent PCA")
 ```
 
-The next plot shows how projections on the first two pricipal components look like.
+The next plot shows how projections on the first two principal components look like.
 ```{julia}
 fig = plot(; title="coordinates per gesture of the first two principal components")
 for label_num in [0, 1]
diff --git a/tutorials/working-in-charts.jl b/tutorials/working-in-charts.jl
index 4c7a227809..34e59ce1e8 100644
--- a/tutorials/working-in-charts.jl
+++ b/tutorials/working-in-charts.jl
@@ -28,13 +28,13 @@ The first one, widespread in differential geometry textbooks, is based on defini
 
 The second one is beneficial if there exists a representation of points and tangent vectors for a manifold which allows for efficient closed-form formulas for standard functions like the exponential map or Riemannian distance in this representation. These computations are then chart-free. `Manifolds.jl` supports both approaches, although the chart-free approach is the main focus of the library.
 
-In this tutorial we focsus on chart-based computation.
+In this tutorial we focus on chart-based computation.
 """
 
 # ╔═╡ b85a56ad-3b74-402d-8fbe-9f0d130253e6
 md"""
 The manifold we consider is the `M` is the torus in form of the [`EmbeddedTorus`](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/torus.html#Manifolds.EmbeddedTorus), that is the representation defined as a surface of revolution of a circle of radius 2 around a circle of radius 3.
-The atlas we will perform computations in is its [`DefaultTorusAtlas`](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/torus.html#Manifolds.DefaultTorusAtlas) `A`, consistting of a family of charts indexed by two angles, that specify the base point of the chart.
+The atlas we will perform computations in is its [`DefaultTorusAtlas`](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/torus.html#Manifolds.DefaultTorusAtlas) `A`, consisting of a family of charts indexed by two angles, that specify the base point of the chart.
 
 We will draw geodesics time between `0` and `t_end`, and then sample the solution at multiples of `dt` and draw a line connecting sampled points.
 """
diff --git a/tutorials/working-in-charts.qmd b/tutorials/working-in-charts.qmd
index 70c2f4bce2..46aaa080b4 100644
--- a/tutorials/working-in-charts.qmd
+++ b/tutorials/working-in-charts.qmd
@@ -29,7 +29,7 @@ using Manifolds, RecursiveArrayTools, OrdinaryDiffEq, DiffEqCallbacks, BoundaryV
 ```
 
 The manifold we consider is the `M` is the torus in form of the [`EmbeddedTorus`](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/torus.html#Manifolds.EmbeddedTorus), that is the representation defined as a surface of revolution of a circle of radius 2 around a circle of radius 3.
-The atlas we will perform computations in is its [`DefaultTorusAtlas`](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/torus.html#Manifolds.DefaultTorusAtlas) `A`, consistting of a family of charts indexed by two angles, that specify the base point of the chart.
+The atlas we will perform computations in is its [`DefaultTorusAtlas`](https://juliamanifolds.github.io/Manifolds.jl/latest/manifolds/torus.html#Manifolds.DefaultTorusAtlas) `A`, consisting of a family of charts indexed by two angles, that specify the base point of the chart.
 
 We will draw geodesics time between `0` and `t_end`, and then sample the solution at multiples of `dt` and draw a line connecting sampled points.