Documentation

TauCeti.Topology.Homotopy.Path

Path homotopy helpers #

Small path and path-homotopy lemmas, mostly for the universal-cover construction. The quotient subpath identities are adapted from Kim Morrison's Mathlib universal-cover drafts, especially #31576 and #38292, following the earlier Tau Ceti work in #42.

Path.exists_homotopy_forall_mem_of_isSimplyConnected is not from that source: it records that SimplyConnectedSpace.paths_homotopic, applied in a subspace ↥V, yields a homotopy in the ambient space whose intermediate paths all stay in V. Analytic continuation consumes it in Analysis/Complex/Conformal/GlobalBranch.lean.

Path.homotopic_of_continuous_square is likewise adapted from Kim Morrison's #38292. It is used by AlgebraicTopology/UniversalCover/BasedPath.lean, where it previously lived privately, and by AlgebraicTopology/Sphere/Puncture.lean. The lemma Path.Homotopic.refl_of_forall_mem_of_nullhomotopic is not from #38292; it was factored out of AlgebraicTopology/SemilocallySimplyConnected/Basic.lean.

Path.exists_monotone_range_subpath_subset subdivides a path, by the Lebesgue number lemma on the unit interval, so that each consecutive subpath lies in a member of a given family of sets. It is used for the generation half of the groupoid van Kampen theorem in AlgebraicTopology/FundamentalGroupoid/CoverGeneration.lean, and, repackaged over a unitInterval.Partition as Path.exists_partition_with_property, for the tube construction in Topology/Homotopy/TubeNeighborhood.lean. That construction also uses unitInterval.exists_vertex_family, the path-connected vertex neighbourhoods of such a subdivision; IsPathHomotopyTrivial, the property of a set that paths in it with common endpoints are homotopic in the ambient space; and the pasting lemma Path.Homotopic.trans_of_subpath_trans, which assembles homotopies over the segments of a partition into a homotopy of the whole paths.

Path.trans_apply_of_le and Path.trans_apply_of_ge express a value of a concatenation as a value of one of its two halves, and Path.subpath_apply_mem bounds the values of a subpath by the values of the path on an interval containing its endpoints. They are used by the gluing construction in AlgebraicTopology/FundamentalGroupoid/Glue.lean.

The path-homotopy quotient API also records that reversing twice is the identity and that the reverse of the constant class is constant.

def Path.codRestrict {X : Type u_1} [TopologicalSpace X] {s : Set X} {x y : ↑s} (γ : Path ↑x ↑y) (hmem : ∀ (t : ↑unitInterval), γ t ∈ s) :
Path x y

Restrict a path whose image lies in a subset to a path in the corresponding subtype. The source and target are the given subtype endpoints, and coercing the restricted path back to X recovers the original path pointwise.

Equations
Instances For
    @[simp]
    theorem Path.codRestrict_coe {X : Type u_1} [TopologicalSpace X] {s : Set X} {x y : ↑s} (γ : Path ↑x ↑y) (hmem : ∀ (t : ↑unitInterval), γ t ∈ s) (t : ↑unitInterval) :
    ↑((γ.codRestrict hmem) t) = γ t

    The underlying point of γ.codRestrict hmem at time t is just γ t, viewed in X.

    @[simp]
    theorem Path.map_codRestrict {X : Type u_1} [TopologicalSpace X] {s : Set X} {x y : ↑s} (γ : Path ↑x ↑y) (hmem : ∀ (t : ↑unitInterval), γ t ∈ s) :
    (γ.codRestrict hmem).map ⋯ = γ

    Mapping γ.codRestrict hmem back along the subtype inclusion recovers γ.

    @[simp]
    theorem Path.map_refl {X : Type u_1} [TopologicalSpace X] {Y : Type u_2} [TopologicalSpace Y] {f : X → Y} (hf : Continuous f) (a : X) :
    (refl a).map hf = refl (f a)

    Mapping a constant path gives the constant path at the image point.

    theorem Path.trans_apply_of_le {X : Type u_1} [TopologicalSpace X] {x y z : X} (γ : Path x y) (δ : Path y z) {u : ↑unitInterval} (hu : ↑u ≤ 1 / 2) (v : ↑unitInterval) (hv : ↑v = 2 * ↑u) :
    (γ.trans δ) u = γ v

    The value of γ.trans δ at a parameter in the first half is a value of γ.

    theorem Path.trans_apply_of_ge {X : Type u_1} [TopologicalSpace X] {x y z : X} (γ : Path x y) (δ : Path y z) {u : ↑unitInterval} (hu : 1 / 2 ≤ ↑u) (v : ↑unitInterval) (hv : ↑v = 2 * ↑u - 1) :
    (γ.trans δ) u = δ v

    The value of γ.trans δ at a parameter in the second half is a value of δ.

    theorem Path.subpath_apply_mem {X : Type u_1} [TopologicalSpace X] {x y : X} {γ : Path x y} {V : Set X} {lo hi : ↑unitInterval} (hγ : ∀ t ∈ Set.Icc lo hi, γ t ∈ V) {a b : ↑unitInterval} (ha : a ∈ Set.Icc lo hi) (hb : b ∈ Set.Icc lo hi) (t : ↑unitInterval) :
    (γ.subpath a b) t ∈ V

    A subpath of γ between two parameters of an interval that γ maps into V lies in V.

    theorem Path.truncateOfLE_range_subset {X : Type u_1} [TopologicalSpace X] {a b : X} (γ : Path a b) {t₀ t₁ : ℝ} (h : t₀ ≤ t₁) {U : Set X} (hU : Set.Icc t₀ t₁ ⊆ ⇑γ.extend ⁻¹' U) :
    Set.range ⇑(γ.truncateOfLE h) ⊆ U

    If the extended path stays inside U throughout [t₀, t₁], then the truncated subpath has range in U.

    noncomputable def Path.initialSegmentFamily {X : Type u_1} [TopologicalSpace X] {a b : X} (γ : Path a b) (t : ↑unitInterval) :
    Path a (γ t)

    The family of initial segments of γ : Path a b: at parameter t : I, the path s ↦ γ.extend (min s t) from a to γ t (initialSegmentFamily_apply). At t = 0 this is the constant path at a (initialSegmentFamily_zero); at t = 1 it is γ itself, up to a trivial right-endpoint cast (initialSegmentFamily_one). The property consumers actually need is joint continuity in (t, s), recorded as continuous_initialSegmentFamily_uncurry.

    Equations
    Instances For
      theorem Path.mem_pathComponent {X : Type u_1} [TopologicalSpace X] {a b : X} (γ : Path a b) (t : ↑unitInterval) :

      Every point on a path lies in the path component of its source.

      theorem Path.mem_pathComponent_of_mem {X : Type u_1} [TopologicalSpace X] {a b x₀ : X} (γ : Path a b) (ha : a ∈ pathComponent x₀) (t : ↑unitInterval) :
      γ t ∈ pathComponent x₀

      A path whose source lies in a path component remains in that path component.

      @[simp]
      theorem Path.initialSegmentFamily_apply {X : Type u_1} [TopologicalSpace X] {a b : X} (γ : Path a b) (t s : ↑unitInterval) :
      (γ.initialSegmentFamily t) s = γ.extend (min ↑s ↑t)
      @[simp]
      theorem Path.initialSegmentFamily_zero {X : Type u_1} [TopologicalSpace X] {a b : X} (γ : Path a b) :
      γ.initialSegmentFamily 0 = (refl a).cast ⋯ ⋯
      @[simp]
      theorem Path.initialSegmentFamily_one {X : Type u_1} [TopologicalSpace X] {a b : X} (γ : Path a b) :
      γ.initialSegmentFamily 1 = γ.cast ⋯ ⋯
      theorem Path.exists_homotopy_forall_mem_of_isSimplyConnected {X : Type u_1} [TopologicalSpace X] {V : Set X} (hV : IsSimplyConnected V) {a b : X} {p q : Path a b} (hp : ∀ (t : ↑unitInterval), p t ∈ V) (hq : ∀ (t : ↑unitInterval), q t ∈ V) :
      ∃ (K : p.Homotopy q), ∀ (t x : ↑unitInterval), K (t, x) ∈ V

      Two paths with the same endpoints in a simply connected set are homotopic inside it. For p and q running in V between the same two points of V, there is a homotopy from p to q every intermediate path of which again lies in V.

      The homotopy is stated in the ambient space rather than in ↥V, with membership in V as a separate conclusion: that is the form consumers want, and it spares them transporting along the subtype.

      theorem Path.homotopic_of_continuous_square {X : Type u_1} [TopologicalSpace X] {a b : X} {p q : Path a b} (K : ↑unitInterval × ↑unitInterval → X) (hK_cont : Continuous K) (hK_zero : ∀ (s : ↑unitInterval), K (0, s) = p s) (hK_one : ∀ (s : ↑unitInterval), K (1, s) = q s) (hK_left : ∀ (t : ↑unitInterval), K (t, 0) = a) (hK_right : ∀ (t : ↑unitInterval), K (t, 1) = b) :

      A square with prescribed edges is a path homotopy. A continuous map on I × I that restricts to p at t = 0 and to q at t = 1, and is constant along each of the edges s = 0 and s = 1, exhibits p and q as homotopic paths.

      theorem Path.exists_monotone_range_subpath_subset {X : Type u_1} [TopologicalSpace X] {ι : Type u_2} {U : ι → Set X} {x y : X} (γ : Path x y) (hU : ∀ (s : ↑unitInterval), ∃ (i : ι), ⇑γ ⁻¹' U i ∈ nhds s) :
      ∃ (n : ℕ) (t : Fin (n + 1) → ↑unitInterval), t 0 = 0 ∧ t (Fin.last n) = 1 ∧ Monotone t ∧ ∀ (k : Fin n), ∃ (i : ι), Set.range ⇑(γ.subpath (t k.castSucc) (t k.succ)) ⊆ U i

      If every parameter s has some γ ⁻¹' U i as a neighbourhood, then γ can be subdivided at finitely many monotone times, starting at 0 and ending at 1, so that the subpath between any two consecutive times has range in some U i.

      theorem Path.exists_partition_with_property {X : Type u_1} [TopologicalSpace X] {x y : X} (γ : Path x y) (P : Set X → Prop) (h : ∀ z ∈ Set.range ⇑γ, ∃ (U : Set X), IsOpen U ∧ z ∈ U ∧ P U) :
      ∃ (n : ℕ) (part : unitInterval.Partition n), ∀ (i : Fin n), ∃ (U : Set X), IsOpen U ∧ P U ∧ Set.MapsTo (⇑γ) (Set.Icc (part.t i.castSucc) (part.t i.succ)) U

      If every point on a path has an open neighborhood satisfying P, then there is a partition 0 = t₀ ≤ ⋯ ≤ tₙ = 1 such that each segment γ [tᵢ, tᵢ₊₁] lies in an open set satisfying P.

      theorem unitInterval.exists_vertex_family {X : Type u_1} [TopologicalSpace X] [LocallyPathConnectedSpace X] {n : ℕ} {f : ↑unitInterval → X} {t : Fin (n + 1) → ↑unitInterval} {U : Fin n → Set X} (h_mono : Monotone t) (hU_open : ∀ (i : Fin n), IsOpen (U i)) (hU : ∀ (i : Fin n), Set.MapsTo f (Set.Icc (t i.castSucc) (t i.succ)) (U i)) :
      ∃ (V : Fin (n + 1) → Set X), (∀ (j : Fin (n + 1)), IsOpen (V j)) ∧ (∀ (j : Fin (n + 1)), IsPathConnected (V j)) ∧ (∀ (j : Fin (n + 1)), f (t j) ∈ V j) ∧ (∀ (i : Fin n), V i.castSucc ⊆ U i) ∧ ∀ (i : Fin n), V i.succ ⊆ U i

      Given open sets U i into which f maps the consecutive segments [t i, t (i + 1)] of a monotone sequence in the unit interval, the path components of f (t j) in the intersections of the adjacent U i are open, path-connected vertex sets, each contained in its adjacent U i.

      @[simp]
      theorem Path.Homotopic.Quotient.symm_symm {X : Type u_1} [TopologicalSpace X] {x₀ x₁ : X} (γ : Homotopic.Quotient x₀ x₁) :
      γ.symm.symm = γ

      Reversing a path-homotopy class twice recovers the original class.

      @[simp]

      The reverse of the constant path-homotopy class is the constant class.

      @[instance_reducible]

      The quotient topology on path-homotopy classes. This instance is load-bearing: Path.Homotopic.Quotient is a def over Quotient, and instance search does not unfold it to find the generic TopologicalSpace (Quotient _).

      Equations

      A set of path-homotopy classes is open exactly when its preimage under quotient construction is open.

      theorem Path.Homotopic.Quotient.subpath_cast_trans {X : Type u_1} [TopologicalSpace X] {x y : X} (p : Path x y) (a b c : ↑unitInterval) {x₀ x₁ x₂ : X} (h₀ : x₀ = p a) (h₁ : x₁ = p b) (h₂ : x₂ = p c) :
      (mk ((p.subpath a b).cast h₀ h₁)).trans (mk ((p.subpath b c).cast h₁ h₂)) = mk ((p.subpath a c).cast h₀ h₂)

      The concatenation identity Path.Homotopic.mk_subpath_trans_mk_subpath with endpoints recast to given points. This cuts a path into pieces with prescribed, named endpoints.

      theorem Path.Homotopic.Quotient.subpath_self {X : Type u_1} [TopologicalSpace X] {x y : X} (p : Path x y) (a : ↑unitInterval) :
      mk (p.subpath a a) = refl (p a)

      A degenerate subpath represents the reflexivity class at its endpoint.

      theorem Path.Homotopic.Quotient.subpath_zero_one {X : Type u_1} [TopologicalSpace X] {x y : X} (p : Path x y) :
      mk (p.subpath 0 1) = (mk p).cast ⋯ ⋯

      The full [0,1] subpath represents the original path, up to the endpoint casts inserted by Path.subpath.

      theorem Path.Homotopic.trans_left_of_nullhomotopic {X : Type u_1} [TopologicalSpace X] {x₀ x₁ : X} {γ₀ : Path x₀ x₀} {γ₁ : Path x₀ x₁} (hγ₀ : γ₀.Homotopic (Path.refl x₀)) :
      (γ₀.trans γ₁).Homotopic γ₁

      Composing on the left with a null-homotopic loop does not change the homotopy class.

      theorem Path.Homotopic.trans_right_of_nullhomotopic {X : Type u_1} [TopologicalSpace X] {x₀ x₁ : X} {γ₀ : Path x₀ x₁} {γ₁ : Path x₁ x₁} (hγ₁ : γ₁.Homotopic (Path.refl x₁)) :
      (γ₀.trans γ₁).Homotopic γ₀

      Composing on the right with a null-homotopic loop does not change the homotopy class.

      theorem Path.Homotopic.of_trans_symm {X : Type u_1} [TopologicalSpace X] {x₀ x₁ : X} {γ γ' : Path x₀ x₁} (h : (γ.trans γ'.symm).Homotopic (Path.refl x₀)) :
      γ.Homotopic γ'

      If γ.trans γ'.symm is nullhomotopic, then γ and γ' are homotopic. This is the path-homotopy analogue of a * b⁻¹ = 1 → a = b.

      theorem Path.Homotopic.trans_right_cancel {X : Type u_1} [TopologicalSpace X] {x₀ x₁ x₂ : X} {γ δ : Path x₀ x₁} {e : Path x₁ x₂} (h : (γ.trans e).Homotopic (δ.trans e)) :
      γ.Homotopic δ

      Right cancellation in the fundamental groupoid: if γ.trans e and δ.trans e are homotopic, then γ and δ are homotopic. This is the path-homotopy analogue of a * c = b * c → a = b.

      theorem Path.Homotopic.trans_left_cancel {X : Type u_1} [TopologicalSpace X] {x₀ x₁ x₂ : X} {e : Path x₀ x₁} {γ δ : Path x₁ x₂} (h : (e.trans γ).Homotopic (e.trans δ)) :
      γ.Homotopic δ

      Left cancellation in the fundamental groupoid: if e.trans γ and e.trans δ are homotopic, then γ and δ are homotopic. This is the path-homotopy analogue of c * a = c * b → a = b.

      theorem Path.Homotopic.of_conj_nullhomotopic {X : Type u_1} [TopologicalSpace X] {x₀ x₁ : X} {α : Path x₀ x₁} {δ : Path x₁ x₁} (h : ((α.trans δ).trans α.symm).Homotopic (Path.refl x₀)) :

      A loop whose conjugate by a path is null-homotopic is itself null-homotopic. This is the path-homotopy analogue of a * b * a⁻¹ = 1 → b = 1.

      theorem Path.Homotopic.map_nullhomotopic_of_nullhomotopic {X : Type u_1} [TopologicalSpace X] {Y : Type u_2} [TopologicalSpace Y] {f : C(X, Y)} (hf : f.Nullhomotopic) {a : X} (γ : Path a a) :
      (γ.map ⋯).Homotopic (Path.refl (f a))

      The image of a based loop under a null-homotopic continuous map is null-homotopic in the target: a map homotopic to a constant collapses every loop to the constant loop.

      theorem Path.Homotopic.refl_of_forall_mem_of_nullhomotopic {X : Type u_1} [TopologicalSpace X] {s : Set X} (hs : { toFun := Subtype.val, continuous_toFun := ⋯ }.Nullhomotopic) {x : X} (γ : Path x x) (hγ : ∀ (t : ↑unitInterval), γ t ∈ s) :

      A loop that stays in a set whose inclusion is null-homotopic is itself null-homotopic in the ambient space.

      @[simp]
      theorem Path.Homotopic.Quotient.refl_cast {X : Type u_1} [TopologicalSpace X] {x y : X} (h : y = x) :
      (refl x).cast h h = refl y

      Casting the reflexivity class at x along h : y = x gives the reflexivity class at y.

      theorem Path.Homotopic.Quotient.eq_of_trans_symm {X : Type u_1} [TopologicalSpace X] {x₀ x₁ : X} {γ γ' : Homotopic.Quotient x₀ x₁} (h : γ.trans γ'.symm = refl x₀) :
      γ = γ'

      If trans γ (symm γ') = refl, then γ = γ'. This is the quotient analogue of eq_of_div_eq_one : a / b = 1 → a = b.

      A subset U of a topological space X is path-homotopy-trivial if any two paths in X whose images lie in U and which share endpoints are homotopic in X. This is the form of "U is simply connected" used in the universal-cover construction: it is weaker than IsSimplyConnected U because the homotopy is not required to lie inside U.

      Equations
      Instances For
        theorem isPathHomotopyTrivial_def {X : Type u_1} [TopologicalSpace X] {U : Set X} :
        IsPathHomotopyTrivial U ↔ ∀ ⦃a b : X⦄ (p q : Path a b), Set.range ⇑p ⊆ U → Set.range ⇑q ⊆ U → p.Homotopic q

        The defining characterization of a path-homotopy-trivial set.

        theorem IsPathHomotopyTrivial.nullhomotopic {X : Type u_1} [TopologicalSpace X] {U : Set X} (hU : IsPathHomotopyTrivial U) {x : X} (γ : Path x x) (hγ : Set.range ⇑γ ⊆ U) :

        A loop in a path-homotopy-trivial set is nullhomotopic.

        theorem Path.Homotopic.trans_of_subpath_trans {X : Type u_1} [TopologicalSpace X] {n : ℕ} {x y x' y' : X} (γ : Path x y) (γ' : Path x' y') (part : unitInterval.Partition n) (α : (j : Fin (n + 1)) → Path (γ (part.t j)) (γ' (part.t j))) (h_rect : ∀ (i : Fin n), ((γ.subpath (part.t i.castSucc) (part.t i.succ)).trans (α i.succ)).Homotopic ((α i.castSucc).trans (γ'.subpath (part.t i.castSucc) (part.t i.succ)))) :
        (γ.trans ((α (Fin.last n)).cast ⋯ ⋯)).Homotopic (((α 0).cast ⋯ ⋯).trans γ')

        The pasting lemma. Let γ : Path x y and γ' : Path x' y', and let α j be "rung" paths from γ (t j) to γ' (t j) at the vertices of a partition. If on each segment γ|[tᵢ, tᵢ₊₁] · αᵢ₊₁ is homotopic to αᵢ · γ'|[tᵢ, tᵢ₊₁], then γ · αₙ is homotopic to α₀ · γ'.