fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
homotopyGroupEquivFundamentalGroupOfUnique (N) [Unique N] :
HomotopyGroup N X x ≃ FundamentalGroup X x := by
refine Equiv.trans ?_ (CategoryTheory.Groupoid.isoEquivHom _ _).symm
refine Quotient.congr (genLoopEquivOfUnique N) ?_
intro a₁ a₂; constructor <;> rintro ⟨H⟩
· exact
⟨{ toFun := fun tx => H (tx.fst, fun _ => tx.snd)
map_zero_left := fun _ => H.apply_zero _
map_one_left := fun _ => H.apply_one _
prop' := fun t y iH => H.prop' _ _ ⟨default, iH⟩ }⟩
refine
⟨⟨⟨⟨fun tx => H (tx.fst, tx.snd default), H.continuous.comp ?_⟩, fun y => ?_, fun y => ?_⟩, ?_⟩⟩
· fun_prop
· exact (H.apply_zero _).trans (congr_arg a₁ (eq_const_of_unique y).symm)
· exact (H.apply_one _).trans (congr_arg a₂ (eq_const_of_unique y).symm)
· rintro t y ⟨i, iH⟩
cases Unique.eq_default i
exact (H.eq_fst _ iH).trans (congr_arg a₁ (eq_const_of_unique y).symm) | def | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | homotopyGroupEquivFundamentalGroupOfUnique | The homotopy group at `x` indexed by a singleton is in bijection with the fundamental group,
i.e. the loops based at `x` up to homotopy. |
HomotopyGroup.pi1EquivFundamentalGroup : π_ 1 X x ≃ FundamentalGroup X x :=
homotopyGroupEquivFundamentalGroupOfUnique (Fin 1) | def | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | HomotopyGroup.pi1EquivFundamentalGroup | The first homotopy group at `x` is in bijection with the fundamental group. |
group (N) [DecidableEq N] [Nonempty N] : Group (HomotopyGroup N X x) :=
(homotopyGroupEquivFundamentalGroup <| Classical.arbitrary N).group | instance | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | group | Group structure on `HomotopyGroup N X x` for nonempty `N` (in particular `π_(n+1) X x`). |
auxGroup (i : N) : Group (HomotopyGroup N X x) :=
(homotopyGroupEquivFundamentalGroup i).group | abbrev | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | auxGroup | Group structure on `HomotopyGroup` obtained by pulling back path composition along the
`i`th direction. The group structures for two different `i j : N` distribute over each
other, and therefore are equal by the Eckmann-Hilton argument. |
isUnital_auxGroup (i : N) :
EckmannHilton.IsUnital (auxGroup i).mul (⟦const⟧ : HomotopyGroup N X x) where
left_id := (auxGroup i).one_mul
right_id := (auxGroup i).mul_one | theorem | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | isUnital_auxGroup | null |
auxGroup_indep (i j : N) : (auxGroup i : Group (HomotopyGroup N X x)) = auxGroup j := by
by_cases h : i = j; · rw [h]
refine Group.ext (EckmannHilton.mul (isUnital_auxGroup i) (isUnital_auxGroup j) ?_)
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ ⟨d⟩
change Quotient.mk' _ = _
apply congr_arg Quotient.mk'
simp only [fromLoop_trans_toLoop, transAt_distrib h, coe_toEquiv, loopHomeo_apply,
coe_symm_toEquiv, loopHomeo_symm_apply] | theorem | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | auxGroup_indep | null |
transAt_indep {i} (j) (f g : Ω^ N X x) :
(⟦transAt i f g⟧ : HomotopyGroup N X x) = ⟦transAt j f g⟧ := by
simp_rw [← fromLoop_trans_toLoop]
let m := fun (G) (_ : Group G) => ((· * ·) : G → G → G)
exact congr_fun₂ (congr_arg (m <| HomotopyGroup N X x) <| auxGroup_indep i j) ⟦g⟧ ⟦f⟧ | theorem | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | transAt_indep | null |
symmAt_indep {i} (j) (f : Ω^ N X x) :
(⟦symmAt i f⟧ : HomotopyGroup N X x) = ⟦symmAt j f⟧ := by
simp_rw [← fromLoop_symm_toLoop]
let inv := fun (G) (_ : Group G) => ((·⁻¹) : G → G)
exact congr_fun (congr_arg (inv <| HomotopyGroup N X x) <| auxGroup_indep i j) ⟦f⟧ | theorem | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | symmAt_indep | null |
one_def [Nonempty N] : (1 : HomotopyGroup N X x) = ⟦const⟧ :=
rfl | theorem | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | one_def | Characterization of multiplicative identity |
mul_spec [Nonempty N] {i} {p q : Ω^ N X x} :
((· * ·) : _ → _ → HomotopyGroup N X x) ⟦p⟧ ⟦q⟧ = ⟦transAt i q p⟧ := by
rw [transAt_indep (Classical.arbitrary N) q, ← fromLoop_trans_toLoop]
apply Quotient.sound
rfl | theorem | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | mul_spec | Characterization of multiplication |
inv_spec [Nonempty N] {i} {p : Ω^ N X x} :
((⟦p⟧)⁻¹ : HomotopyGroup N X x) = ⟦symmAt i p⟧ := by
rw [symmAt_indep (Classical.arbitrary N) p, ← fromLoop_symm_toLoop]
apply Quotient.sound
rfl | theorem | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | inv_spec | Characterization of multiplicative inverse |
commGroup [Nontrivial N] : CommGroup (HomotopyGroup N X x) :=
let h := exists_ne (Classical.arbitrary N)
@EckmannHilton.commGroup (HomotopyGroup N X x) _ 1 (isUnital_auxGroup <| Classical.choose h) _
(by
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ ⟨d⟩
apply congr_arg Quotient.mk'
simp only [fromLoop_trans_toLoop, transAt_distrib <| Classical.choose_spec h, coe_toEquiv,
loopHomeo_apply, coe_symm_toEquiv, loopHomeo_symm_apply]) | instance | Topology | [
"Mathlib.Algebra.Group.Ext",
"Mathlib.Algebra.Group.TransferInstance",
"Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup",
"Mathlib.GroupTheory.EckmannHilton"
] | Mathlib/Topology/Homotopy/HomotopyGroup.lean | commGroup | Multiplication on `HomotopyGroup N X x` is commutative for nontrivial `N`.
In particular, multiplication on `π_(n+2)` is commutative. |
HSpace (X : Type u) [TopologicalSpace X] where
hmul : C(X × X, X)
e : X
hmul_e_e : hmul (e, e) = e
eHmul :
(hmul.comp <| (const X e).prodMk <| ContinuousMap.id X).HomotopyRel (ContinuousMap.id X) {e}
hmulE :
(hmul.comp <| (ContinuousMap.id X).prodMk <| const X e).HomotopyRel (ContinuousMap.id X) {e} | class | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | HSpace | A topological space `X` is an H-space if it behaves like a (potentially non-associative)
topological group, but where the axioms for a group only hold up to homotopy. |
@[to_additive
/-- The definition `toHSpace` is not an instance because it comes together with a
multiplicative version which would lead to a diamond since a topological field would inherit
two `HSpace` structures, one from the `MulOneClass` and one from the `AddZeroClass`.
In the case of an additive group, we make `IsTopologicalAddGroup.hSpace` an instance. -/]
toHSpace (M : Type u) [MulOneClass M] [TopologicalSpace M] [ContinuousMul M] : HSpace M where
hmul := ⟨Function.uncurry Mul.mul, continuous_mul⟩
e := 1
hmul_e_e := one_mul 1
eHmul := (HomotopyRel.refl _ _).cast rfl (by ext1; apply one_mul)
hmulE := (HomotopyRel.refl _ _).cast rfl (by ext1; apply mul_one)
@[to_additive] | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | toHSpace | The binary operation `hmul` on an `H`-space -/
scoped[HSpaces] notation x "⋀" y => HSpace.hmul (x, y)
open HSpaces
instance HSpace.prod (X : Type u) (Y : Type v) [TopologicalSpace X] [TopologicalSpace Y] [HSpace X]
[HSpace Y] : HSpace (X × Y) where
hmul := ⟨fun p => (p.1.1 ⋀ p.2.1, p.1.2 ⋀ p.2.2), by fun_prop⟩
e := (HSpace.e, HSpace.e)
hmul_e_e := by
simp only [ContinuousMap.coe_mk, Prod.mk_inj]
exact ⟨HSpace.hmul_e_e, HSpace.hmul_e_e⟩
eHmul := by
let G : I × X × Y → X × Y := fun p => (HSpace.eHmul (p.1, p.2.1), HSpace.eHmul (p.1, p.2.2))
have hG : Continuous G := by fun_prop
use! ⟨G, hG⟩
· rintro ⟨x, y⟩
exact Prod.ext (HSpace.eHmul.1.2 x) (HSpace.eHmul.1.2 y)
· rintro ⟨x, y⟩
exact Prod.ext (HSpace.eHmul.1.3 x) (HSpace.eHmul.1.3 y)
· rintro t ⟨x, y⟩ h
replace h := Prod.mk_inj.mp h
exact Prod.ext (HSpace.eHmul.2 t x h.1) (HSpace.eHmul.2 t y h.2)
hmulE := by
let G : I × X × Y → X × Y := fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2))
have hG : Continuous G := by fun_prop
use! ⟨G, hG⟩
· rintro ⟨x, y⟩
exact Prod.ext (HSpace.hmulE.1.2 x) (HSpace.hmulE.1.2 y)
· rintro ⟨x, y⟩
exact Prod.ext (HSpace.hmulE.1.3 x) (HSpace.hmulE.1.3 y)
· rintro t ⟨x, y⟩ h
replace h := Prod.mk_inj.mp h
exact Prod.ext (HSpace.hmulE.2 t x h.1) (HSpace.hmulE.2 t y h.2)
namespace IsTopologicalGroup
/-- The definition `toHSpace` is not an instance because its additive version would
lead to a diamond since a topological field would inherit two `HSpace` structures, one from the
`MulOneClass` and one from the `AddZeroClass`. In the case of a group, we make
`IsTopologicalGroup.hSpace` an instance." |
one_eq_hSpace_e {G : Type u} [TopologicalSpace G] [Group G] [IsTopologicalGroup G] :
(1 : G) = HSpace.e :=
rfl
/- In the following example we see that the H-space structure on the product of two topological
groups is definitionally equally to the product H-space-structure of the two groups. -/ | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | one_eq_hSpace_e | null |
qRight (p : I × I) : I :=
Set.projIcc 0 1 zero_le_one (2 * p.1 / (1 + p.2))
@[fun_prop] | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | qRight | `qRight` is analogous to the function `Q` defined on p. 475 of [serre1951] that helps proving
continuity of `delayReflRight`. |
continuous_qRight : Continuous qRight :=
continuous_projIcc.comp <|
Continuous.div (by fun_prop) (by fun_prop) fun _ ↦ (add_pos zero_lt_one).ne' | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | continuous_qRight | null |
qRight_zero_left (θ : I) : qRight (0, θ) = 0 :=
Set.projIcc_of_le_left _ <| by simp only [coe_zero, mul_zero, zero_div, le_refl] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | qRight_zero_left | null |
qRight_one_left (θ : I) : qRight (1, θ) = 1 :=
Set.projIcc_of_right_le _ <|
(le_div_iff₀ <| add_pos zero_lt_one).2 <| by
dsimp only
rw [coe_one, one_mul, mul_one, add_comm, ← one_add_one_eq_two]
simp only [add_le_add_iff_right]
exact le_one _ | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | qRight_one_left | null |
qRight_zero_right (t : I) :
(qRight (t, 0) : ℝ) = if (t : ℝ) ≤ 1 / 2 then (2 : ℝ) * t else 1 := by
simp only [qRight, coe_zero, add_zero, div_one]
split_ifs
· rw [Set.projIcc_of_mem _ ((mul_pos_mem_iff zero_lt_two).2 _)]
refine ⟨t.2.1, ?_⟩
tauto
· rw [(Set.projIcc_eq_right _).2]
· linarith
· exact zero_lt_one | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | qRight_zero_right | null |
qRight_one_right (t : I) : qRight (t, 1) = t :=
Eq.trans (by rw [qRight]; norm_num) <| Set.projIcc_val zero_le_one _ | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | qRight_one_right | null |
delayReflRight (θ : I) (γ : Path x y) : Path x y where
toFun t := γ (qRight (t, θ))
continuous_toFun := by fun_prop
source' := by
rw [qRight_zero_left, γ.source]
target' := by
rw [qRight_one_left, γ.target] | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | delayReflRight | This is the function analogous to the one on p. 475 of [serre1951], defining a homotopy from
the product path `γ ∧ e` to `γ`. |
continuous_delayReflRight : Continuous fun p : I × Path x y => delayReflRight p.1 p.2 :=
continuous_uncurry_iff.mp <|
(continuous_snd.comp continuous_fst).eval <|
continuous_qRight.comp <| continuous_snd.prodMk <| continuous_fst.comp continuous_fst | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | continuous_delayReflRight | null |
delayReflRight_zero (γ : Path x y) : delayReflRight 0 γ = γ.trans (Path.refl y) := by
ext t
simp only [delayReflRight, trans_apply, Path.coe_mk_mk,
refl_apply]
split_ifs with h; swap
on_goal 1 => conv_rhs => rw [← γ.target]
all_goals apply congr_arg γ; ext1; rw [qRight_zero_right]
exacts [if_neg h, if_pos h] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | delayReflRight_zero | null |
delayReflRight_one (γ : Path x y) : delayReflRight 1 γ = γ := by
ext t
exact congr_arg γ (qRight_one_right t) | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | delayReflRight_one | null |
delayReflLeft (θ : I) (γ : Path x y) : Path x y :=
(delayReflRight θ γ.symm).symm | def | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | delayReflLeft | This is the function on p. 475 of [serre1951], defining a homotopy from a path `γ` to the
product path `e ∧ γ`. |
continuous_delayReflLeft : Continuous fun p : I × Path x y => delayReflLeft p.1 p.2 :=
Path.continuous_symm.comp <|
continuous_delayReflRight.comp <|
continuous_fst.prodMk <| Path.continuous_symm.comp continuous_snd | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | continuous_delayReflLeft | null |
delayReflLeft_zero (γ : Path x y) : delayReflLeft 0 γ = (Path.refl x).trans γ := by
simp only [delayReflLeft, delayReflRight_zero, trans_symm, refl_symm, Path.symm_symm] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | delayReflLeft_zero | null |
delayReflLeft_one (γ : Path x y) : delayReflLeft 1 γ = γ := by
simp only [delayReflLeft, delayReflRight_one, Path.symm_symm] | theorem | Topology | [
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Path"
] | Mathlib/Topology/Homotopy/HSpaces.lean | delayReflLeft_one | null |
exists_lift_nhds {f : C(I × A, X)} {g : I × A → E} (g_lifts : p ∘ g = f)
(cont_0 : Continuous (g ⟨0, ·⟩)) (a : A) (cont_a : Continuous (g ⟨·, a⟩)) :
∃ N ∈ 𝓝 a, ∃ g' : I × A → E, ContinuousOn g' (Set.univ ×ˢ N) ∧ p ∘ g' = f ∧
(∀ a, g' (0, a) = g (0, a)) ∧ ∀ t, g' (t, a) = g (t, a) := by
choose q mem_source hpq using homeo
/- Using the hypothesis `cont_a`, we partition the unit interval so that for each
subinterval `[tₙ, tₙ₊₁]`, the image `g ([tₙ, tₙ₊₁] × {a})` is contained in the
domain of some local homeomorphism `q e`. -/
obtain ⟨t, t_0, t_mono, ⟨n_max, h_max⟩, t_sub⟩ :=
exists_monotone_Icc_subset_open_cover_unitInterval
(fun e ↦ (q e).open_source.preimage cont_a)
fun t _ ↦ Set.mem_iUnion.mpr ⟨g (t, a), mem_source _⟩
/- We aim to inductively prove the existence of Nₙ and g' continuous on [0, tₙ] × Nₙ for each n,
and get the desired result by taking some n with tₙ = 1. -/
suffices ∀ n, ∃ N, a ∈ N ∧ IsOpen N ∧ ∃ g' : I × A → E, ContinuousOn g' (Set.Icc 0 (t n) ×ˢ N) ∧
p ∘ g' = f ∧ (∀ a, g' (0, a) = g (0, a)) ∧ ∀ t' ≤ t n, g' (t', a) = g (t', a) by
obtain ⟨N, haN, N_open, hN⟩ := this n_max
simp_rw [h_max _ le_rfl] at hN
refine ⟨N, N_open.mem_nhds haN, ?_⟩; convert hN
· rw [eq_comm, Set.eq_univ_iff_forall]; exact fun t ↦ ⟨bot_le, le_top⟩
· rw [imp_iff_right]; exact le_top
refine Nat.rec ⟨_, Set.mem_univ a, isOpen_univ, g, ?_, g_lifts, fun a ↦ rfl, fun _ _ ↦ rfl⟩
(fun n ⟨N, haN, N_open, g', cont_g', g'_lifts, g'_0, g'_a⟩ ↦ ?_)
· -- the n = 0 case is covered by the hypothesis cont_0.
refine (cont_0.comp continuous_snd).continuousOn.congr (fun ta ⟨ht, _⟩ ↦ ?_)
rw [t_0, Set.Icc_self, Set.mem_singleton_iff] at ht; rw [← ta.eta, ht]; rfl
/- Since g ([tₙ, tₙ₊₁] × {a}) is contained in the domain of some local homeomorphism `q e` and
g lifts f, f ([tₙ, tₙ₊₁] × {a}) is contained in the codomain (`target`) of `q e`. -/
obtain ⟨e, h_sub⟩ := t_sub n
have : Set.Icc (t n) (t (n + 1)) ×ˢ {a} ⊆ f ⁻¹' (q e).target := by
rintro ⟨t0, a'⟩ ⟨ht, ha⟩
rw [Set.mem_singleton_iff] at ha; dsimp only at ha
rw [← g_lifts, hpq e, ha]
exact (q e).map_source (h_sub ht)
/- Using compactness of [tₙ, tₙ₊₁], we can find a neighborhood v of a such that
f ([tₙ, tₙ₊₁] × v) is contained in the codomain of `q e`. -/
obtain ⟨u, v, -, v_open, hu, hav, huv⟩ := generalized_tube_lemma isClosed_Icc.isCompact
isCompact_singleton ((q e).open_target.preimage f.continuous) this
classical
/- Use the inverse of `q e` to extend g' from [0, tₙ] × Nₙ₊₁ to [0, tₙ₊₁] × Nₙ₊₁, where
Nₙ₊₁ ⊆ v ∩ Nₙ is such that {tₙ} × Nₙ₊₁ is mapped to the domain (`source`) of `q e` by `g'`. -/
refine ⟨_, ?_, v_open.inter <| (cont_g'.comp (Continuous.prodMk_right <| t n).continuousOn
fun a ha ↦ ⟨?_, ha⟩).isOpen_inter_preimage N_open (q e).open_source,
fun ta ↦ if ta.1 ≤ t n then g' ta else if f ta ∈ (q e).target then (q e).symm (f ta) else g ta,
.if (fun ta ⟨⟨_, hav, _, ha⟩, hfr⟩ ↦ ?_) (cont_g'.mono fun ta ⟨hta, ht⟩ ↦ ?_) ?_,
?_, fun a ↦ ?_, fun t0 htn1 ↦ ?_⟩
· refine ⟨Set.singleton_subset_iff.mp hav, haN, ?_⟩
change g' (t n, a) ∈ (q e).source; rw [g'_a _ le_rfl]
exact h_sub ⟨le_rfl, t_mono n.le_succ⟩
· rw [← t_0]; exact ⟨t_mono n.zero_le, le_rfl⟩
· have ht := Set.mem_setOf.mp (frontier_le_subset_eq continuous_fst continuous_const hfr)
... | theorem | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | exists_lift_nhds | If `p : E → X` is a local homeomorphism, and if `g : I × A → E` is a lift of `f : C(I × A, X)`
continuous on `{0} × A ∪ I × {a}` for some `a : A`, then there exists a neighborhood `N ∈ 𝓝 a`
and `g' : I × A → E` continuous on `I × N` that agrees with `g` on `{0} × A ∪ I × {a}`.
The proof follows [hatcher02], Proof of Theorem 1.7, p.30.
Possible TODO: replace `I` by an arbitrary space assuming `A` is locally connected
and `p` is a separated map, which guarantees uniqueness and therefore well-definedness
on the intersections. |
continuous_lift (f : C(I × A, X)) {g : I × A → E} (g_lifts : p ∘ g = f)
(cont_0 : Continuous (g ⟨0, ·⟩)) (cont_A : ∀ a, Continuous (g ⟨·, a⟩)) : Continuous g := by
rw [continuous_iff_continuousAt]
intro ⟨t, a⟩
obtain ⟨N, haN, g', cont_g', g'_lifts, g'_0, -⟩ :=
homeo.exists_lift_nhds g_lifts cont_0 a (cont_A a)
refine (cont_g'.congr fun ⟨t, a⟩ ⟨_, ha⟩ ↦ ?_).continuousAt (prod_mem_nhds Filter.univ_mem haN)
refine congr_fun (sep.eq_of_comp_eq homeo.isLocallyInjective (cont_A a)
(cont_g'.comp_continuous (.prodMk_left a) fun _ ↦ ⟨⟨⟩, ha⟩) ?_ 0 (g'_0 a).symm) t
ext t; apply congr_fun (g_lifts.trans g'_lifts.symm) | theorem | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | continuous_lift | null |
monodromy_theorem {γ₀ γ₁ : C(I, X)} (γ : γ₀.HomotopyRel γ₁ {0,1}) (Γ : I → C(I, E))
(Γ_lifts : ∀ t s, p (Γ t s) = γ (t, s)) (Γ_0 : ∀ t, Γ t 0 = Γ 0 0) (t : I) :
Γ t 1 = Γ 0 1 := by
have := homeo.continuous_lift sep (.comp γ .prodSwap) (g := fun st ↦ Γ st.2 st.1) ?_ ?_ ?_
· apply sep.const_of_comp homeo.isLocallyInjective (this.comp (.prodMk_right 1))
intro t t'; change p (Γ _ _) = p (Γ _ _); simp_rw [Γ_lifts, γ.eq_fst _ (.inr rfl)]
· ext; apply Γ_lifts
· simp_rw [Γ_0]; exact continuous_const
· exact fun t ↦ (Γ t).2
omit sep
open PathConnectedSpace (somePath) in | theorem | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | monodromy_theorem | The abstract monodromy theorem: if `γ₀` and `γ₁` are two paths in a topological space `X`,
`γ` is a homotopy between them relative to the endpoints, and the path at each time step of
the homotopy, `γ (t, ·)`, lifts to a continuous path `Γ t` through a separated local
homeomorphism `p : E → X`, starting from some point in `E` independent of `t`. Then the
endpoints of these lifts are also independent of `t`.
This can be applied to continuation of analytic functions as follows: for a sheaf of analytic
functions on an analytic manifold `X`, we may consider its étale space `E` (whose points are
analytic germs) with the natural projection `p : E → X`, which is a local homeomorphism and a
separated map (because two analytic functions agreeing on a nonempty open set agree on the
whole connected component). An analytic continuation of a germ along a path `γ (t, ·) : C(I, X)`
corresponds to a continuous lift of `γ (t, ·)` to `E` starting from that germ. If `γ` is a
homotopy and the germ admits continuation along every path `γ (t, ·)`, then the result of the
continuations are independent of `t`. In particular, if `X` is simply connected and an analytic
germ at `p : X` admits a continuation along every path in `X` from `p` to `q : X`, then the
continuation to `q` is independent of the path chosen. |
existsUnique_continuousMap_lifts [PathConnectedSpace A] [LocPathConnectedSpace A]
(f : C(A, X)) (a₀ : A) (e₀ : E) (he : p e₀ = f a₀)
(ex : ∀ γ : C(I, A), γ 0 = a₀ → ∃ Γ : C(I, E), Γ 0 = e₀ ∧ p ∘ Γ = f.comp γ)
(uniq : ∀ γ γ' : C(I, A), ∀ Γ Γ' : C(I, E), γ 0 = a₀ → γ' 0 = a₀ → Γ 0 = e₀ → Γ' 0 = e₀ →
p ∘ Γ = f.comp γ → p ∘ Γ' = f.comp γ' → γ 1 = γ' 1 → Γ 1 = Γ' 1) :
∃! F : C(A, E), F a₀ = e₀ ∧ p ∘ F = f := by
choose Γ Γ_0 Γ_lifts using ex
let F (a : A) : E := Γ _ (somePath a₀ a).source 1
have (a : A) : p (F a) = f a := by simpa using congr_fun (Γ_lifts _ (Path.source _)) 1
refine ⟨⟨F, continuous_iff_continuousAt.mpr fun a ↦ ?_⟩, ⟨?_, funext this⟩, fun F' ⟨F'_0, hpF'⟩ ↦
DFunLike.ext _ _ fun a ↦ ?_⟩
· obtain ⟨p, hep, rfl⟩ := homeo (F a)
have hfap : f a ∈ p.target := by rw [← this]; exact p.map_source hep
refine ContinuousAt.congr (f := p.symm ∘ f) ((p.continuousOn_symm.continuousAt <|
p.open_target.mem_nhds hfap).comp f.2.continuousAt) ?_
have ⟨U, ⟨haU, U_conn⟩, hUp⟩ := (path_connected_basis a).mem_iff.mp
((p.open_target.preimage f.continuous).mem_nhds hfap)
refine Filter.mem_of_superset haU fun x hxU ↦ ?_
have ⟨γ, hγ⟩ := U_conn.joinedIn _ (mem_of_mem_nhds haU) _ hxU
let Γ' : Path e₀ ((p.symm ∘ f) a) :=
⟨Γ _ (somePath a₀ a).source, Γ_0 .., by simp [← this, hep, F]⟩
specialize uniq ((somePath a₀ a).trans γ) _ (Γ'.trans <| γ.map' <| p.continuousOn_symm.comp
f.2.continuousOn <| by rintro _ ⟨t, rfl⟩; exact hUp (hγ _)) _ (by simp) (somePath a₀ x).source
(by simp) (Γ_0 _ (somePath a₀ x).source) _ (Γ_lifts ..) (by simp)
· ext
simp only [Function.comp, ContinuousMap.coe_coe, Path.trans_apply, ContinuousMap.coe_comp]
split_ifs
· apply congr_fun (Γ_lifts ..)
· simp [Path.map', p.right_inv (hUp (hγ _))]
simpa using uniq
· exact uniq _ (.const I a₀) _ (.const I e₀) (somePath a₀ a₀).source rfl (Γ_0 ..) rfl (Γ_lifts ..)
(by simpa) (Path.target _)
· let γ := somePath a₀ a
simpa using uniq _ _ (F'.comp γ) (Γ _ γ.source) γ.source γ.source (by simpa) (Γ_0 ..)
(by simp [← Function.comp_assoc, hpF']) (Γ_lifts ..) rfl | theorem | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | existsUnique_continuousMap_lifts | A map `f` from a path-connected, locally path-connected space `A` to another space `X` lifts
uniquely through a local homeomorphism `p : E → X` if for every path `γ` in `A`, the composed
path `f ∘ γ` in `X` lifts to `E` with endpoint only dependent on the endpoint of `γ` and
independent of the path chosen. In this theorem, we require that a specific point `a₀ : A` is
lifted to a specific point `e₀ : E` over `a₀`. |
exists_path_lifts : ∃ Γ : C(I, E), p ∘ Γ = γ ∧ Γ 0 = e := by
let U x := (cov x).2.choose
choose mem_base U_open _ H _ using fun x ↦ (cov x).2.choose_spec
obtain ⟨t, t_0, t_mono, ⟨n_max, h_max⟩, t_sub⟩ :=
exists_monotone_Icc_subset_open_cover_unitInterval
(fun x ↦ (U_open x).preimage γ.continuous) fun t _ ↦ Set.mem_iUnion.2 ⟨γ t, mem_base _⟩
suffices ∀ n, ∃ Γ : I → E, ContinuousOn Γ (Set.Icc 0 (t n)) ∧
(Set.Icc 0 (t n)).EqOn (p ∘ Γ) γ ∧ Γ 0 = e by
obtain ⟨Γ, cont, eqOn, Γ_0⟩ := this n_max
rw [h_max _ le_rfl] at cont eqOn
exact ⟨⟨Γ, continuousOn_univ.mp
(by convert cont; rw [eq_comm, Set.eq_univ_iff_forall]; exact fun t ↦ ⟨bot_le, le_top⟩)⟩,
funext fun _ ↦ eqOn ⟨bot_le, le_top⟩, Γ_0⟩
intro n
induction n with
| zero =>
refine ⟨fun _ ↦ e, continuous_const.continuousOn, fun t ht ↦ ?_, rfl⟩
rw [t_0, Set.Icc_self, Set.mem_singleton_iff] at ht; subst ht; exact γ_0.symm
| succ n ih => ?_
obtain ⟨Γ, cont, eqOn, Γ_0⟩ := ih
obtain ⟨x, t_sub⟩ := t_sub n
have pΓtn : p (Γ (t n)) = γ (t n) := eqOn ⟨t_0 ▸ t_mono n.zero_le, le_rfl⟩
have : Nonempty (p ⁻¹' {x}) :=
⟨(H x ⟨Γ (t n), Set.mem_preimage.mpr (pΓtn ▸ t_sub ⟨le_rfl, t_mono n.le_succ⟩)⟩).2⟩
let q := (cov x).toTrivialization
refine ⟨fun s ↦ if s ≤ t n then Γ s else q.invFun (γ s, (q (Γ (t n))).2),
.if (fun s hs ↦ ?_) (cont.mono fun _ h ↦ ?_) ?_, fun s hs ↦ ?_, ?_⟩
· cases frontier_Iic_subset _ hs.2
rw [← pΓtn]
refine (q.symm_apply_mk_proj ?_).symm
rw [q.mem_source, pΓtn]
exact t_sub ⟨le_rfl, t_mono n.le_succ⟩
· rw [closure_le_eq continuous_id' continuous_const] at h; exact ⟨h.1.1, h.2⟩
· apply q.continuousOn_invFun.comp ((Continuous.prodMk_left _).comp γ.2).continuousOn
simp_rw [not_le, q.target_eq]; intro s h
exact ⟨t_sub ⟨closure_lt_subset_le continuous_const continuous_subtype_val h.2, h.1.2⟩, ⟨⟩⟩
· rw [Function.comp_apply]; split_ifs with h
exacts [eqOn ⟨hs.1, h⟩, q.proj_symm_apply' (t_sub ⟨le_of_not_ge h, hs.2⟩)]
· dsimp only; rwa [if_pos (t_0 ▸ t_mono n.zero_le)] | theorem | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | exists_path_lifts | The path lifting property (existence) for covering maps. |
noncomputable liftPath : C(I, E) := (cov.exists_path_lifts γ e γ_0).choose | def | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | liftPath | The lift of a path to a covering space given a lift of the left endpoint. |
liftPath_lifts : p ∘ cov.liftPath γ e γ_0 = γ := (cov.exists_path_lifts γ e γ_0).choose_spec.1 | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | liftPath_lifts | null |
liftPath_zero : cov.liftPath γ e γ_0 0 = e := (cov.exists_path_lifts γ e γ_0).choose_spec.2
variable {γ e} | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | liftPath_zero | null |
eq_liftPath_iff {Γ : I → E} : Γ = cov.liftPath γ e γ_0 ↔ Continuous Γ ∧ p ∘ Γ = γ ∧ Γ 0 = e :=
have lifts := cov.liftPath_lifts γ e γ_0
have zero := cov.liftPath_zero γ e γ_0
⟨(· ▸ ⟨(cov.liftPath γ e γ_0).2, lifts, zero⟩), fun ⟨Γ_cont, Γ_lifts, Γ_0⟩ ↦ cov.eq_of_comp_eq
Γ_cont (cov.liftPath γ e γ_0).continuous (Γ_lifts ▸ lifts.symm) 0 (Γ_0 ▸ zero.symm)⟩ | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | eq_liftPath_iff | null |
eq_liftPath_iff' {Γ : C(I, E)} : Γ = cov.liftPath γ e γ_0 ↔ p ∘ Γ = γ ∧ Γ 0 = e := by
simp_rw [← DFunLike.coe_fn_eq, eq_liftPath_iff, and_iff_right (ContinuousMap.continuous _)] | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | eq_liftPath_iff' | Unique characterization of the lifted path. |
@[simps] noncomputable liftHomotopy : C(I × A, E) where
toFun ta := cov.liftPath (H.comp <| (ContinuousMap.id I).prodMk <| .const I ta.2)
(f ta.2) (H_0 ta.2) ta.1
continuous_toFun := cov.isLocalHomeomorph.continuous_lift cov.isSeparatedMap H
(by ext ⟨t, a⟩; exact congr_fun (cov.liftPath_lifts ..) t)
(by convert f.continuous with a; exact cov.liftPath_zero ..)
fun a ↦ by dsimp only; exact (cov.liftPath (γ_0 := by simp [*])).2 | def | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | liftHomotopy | The existence of `liftHomotopy` satisfying `liftHomotopy_lifts` and `liftHomotopy_zero` is
the homotopy lifting property for covering maps.
In other words, a covering map is a Hurewicz fibration. |
liftHomotopy_lifts : p ∘ cov.liftHomotopy H f H_0 = H :=
funext fun ⟨t, _⟩ ↦ congr_fun (cov.liftPath_lifts ..) t | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | liftHomotopy_lifts | null |
liftHomotopy_zero (a : A) : cov.liftHomotopy H f H_0 (0, a) = f a := cov.liftPath_zero ..
variable {H f} | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | liftHomotopy_zero | null |
eq_liftHomotopy_iff (H' : I × A → E) : H' = cov.liftHomotopy H f H_0 ↔
(∀ a, Continuous (H' ⟨·, a⟩)) ∧ p ∘ H' = H ∧ ∀ a, H' (0, a) = f a := by
refine ⟨?_, fun ⟨H'_cont, H'_lifts, H'_0⟩ ↦ funext fun ⟨t, a⟩ ↦ ?_⟩
· rintro rfl; refine ⟨fun a ↦ ?_, cov.liftHomotopy_lifts H f H_0, cov.liftHomotopy_zero H f H_0⟩
simp_rw [liftHomotopy_apply]; exact (cov.liftPath _ _ <| H_0 a).2
· apply congr_fun ((cov.eq_liftPath_iff _).mpr ⟨H'_cont a, _, H'_0 a⟩) t
ext ⟨t, a⟩; exact congr_fun H'_lifts _ | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | eq_liftHomotopy_iff | null |
eq_liftHomotopy_iff' (H' : C(I × A, E)) :
H' = cov.liftHomotopy H f H_0 ↔ p ∘ H' = H ∧ ∀ a, H' (0, a) = f a := by
simp_rw [← DFunLike.coe_fn_eq, eq_liftHomotopy_iff]
exact and_iff_right fun a ↦ H'.2.comp (.prodMk_left a)
variable {f₀ f₁ : C(A, X)} {S : Set A} (F : f₀.HomotopyRel f₁ S)
open ContinuousMap in | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | eq_liftHomotopy_iff' | null |
noncomputable liftHomotopyRel [PreconnectedSpace A]
{f₀' f₁' : C(A, E)} (he : ∃ a ∈ S, f₀' a = f₁' a)
(h₀ : p ∘ f₀' = f₀) (h₁ : p ∘ f₁' = f₁) : f₀'.HomotopyRel f₁' S :=
have F_0 : ∀ a, F (0, a) = p (f₀' a) := fun a ↦ (F.apply_zero a).trans (congr_fun h₀ a).symm
have rel : ∀ t, ∀ a ∈ S, cov.liftHomotopy F f₀' F_0 (t, a) = f₀' a := fun t a ha ↦ by
rw [liftHomotopy_apply, cov.const_of_comp (ContinuousMap.continuous _) _ t 0]
· apply cov.liftPath_zero
· intro t t'; simp_rw [← p.comp_apply, cov.liftPath_lifts]
exact (F.prop t a ha).trans (F.prop t' a ha).symm
{ toContinuousMap := cov.liftHomotopy F f₀' F_0
map_zero_left := cov.liftHomotopy_zero F f₀' F_0
map_one_left := by
obtain ⟨a, ha, he⟩ := he
simp_rw [toFun_eq_coe, ← curry_apply]
refine congr_fun (cov.eq_of_comp_eq
(ContinuousMap.continuous _) f₁'.continuous ?_ a <| (rel 1 a ha).trans he)
ext a; rw [h₁, Function.comp_apply, curry_apply]
exact (congr_fun (cov.liftHomotopy_lifts F f₀' _) (1, a)).trans (F.apply_one a)
prop' := rel } | def | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | liftHomotopyRel | The lift to a covering space of a homotopy between two continuous maps relative to a set
given compatible lifts of the continuous maps. |
homotopicRel_iff_comp [PreconnectedSpace A] {f₀ f₁ : C(A, E)} {S : Set A}
(he : ∃ a ∈ S, f₀ a = f₁ a) : f₀.HomotopicRel f₁ S ↔
(ContinuousMap.comp ⟨p, cov.continuous⟩ f₀).HomotopicRel (.comp ⟨p, cov.continuous⟩ f₁) S :=
⟨fun ⟨F⟩ ↦ ⟨F.compContinuousMap _⟩, fun ⟨F⟩ ↦ ⟨cov.liftHomotopyRel F he rfl rfl⟩⟩ | theorem | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | homotopicRel_iff_comp | Two continuous maps from a preconnected space to the total space of a covering map
are homotopic relative to a set `S` if and only if their compositions with the covering map
are homotopic relative to `S`, assuming that they agree at a point in `S`. |
liftPath_apply_one_eq_of_homotopicRel {γ₀ γ₁ : C(I, X)}
(h : γ₀.HomotopicRel γ₁ {0,1}) (e : E) (h₀ : γ₀ 0 = p e) (h₁ : γ₁ 0 = p e) :
cov.liftPath γ₀ e h₀ 1 = cov.liftPath γ₁ e h₁ 1 := by
obtain ⟨H⟩ := h
have := cov.liftHomotopyRel (f₀' := cov.liftPath γ₀ e h₀) (f₁' := cov.liftPath γ₁ e h₁) H
⟨0, .inl rfl, by simp_rw [liftPath_zero]⟩ (liftPath_lifts ..) (liftPath_lifts ..)
rw [← this.eq_fst 0 (.inr rfl), ← this.eq_snd 0 (.inr rfl)] | theorem | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | liftPath_apply_one_eq_of_homotopicRel | Lifting two paths that are homotopic relative to {0,1}
starting from the same point also ends up in the same point. |
injective_path_homotopic_mapFn (e₀ e₁ : E) :
Function.Injective fun γ : Path.Homotopic.Quotient e₀ e₁ ↦ γ.mapFn ⟨p, cov.continuous⟩ := by
refine Quotient.ind₂ fun γ₀ γ₁ ↦ ?_
dsimp only
simp_rw [← Path.Homotopic.map_lift]
iterate 2 rw [Quotient.eq]
exact (cov.homotopicRel_iff_comp ⟨0, .inl rfl, γ₀.source.trans γ₁.source.symm⟩).mpr | lemma | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | injective_path_homotopic_mapFn | A covering map induces an injection on all Hom-sets of the fundamental groupoid,
in particular on the fundamental group. |
existsUnique_continuousMap_lifts [SimplyConnectedSpace A] [LocPathConnectedSpace A]
(f : C(A, X)) (a₀ : A) (e₀ : E) (he : p e₀ = f a₀) :
∃! F : C(A, E), F a₀ = e₀ ∧ p ∘ F = f := by
refine cov.isLocalHomeomorph.existsUnique_continuousMap_lifts f a₀ e₀ he (fun γ γ_0 ↦ ?_)
fun γ γ' Γ Γ' γ_0 γ'_0 Γ_0 Γ'_0 Γ_lifts Γ'_lifts γγ'1 ↦ ?_
· simpa [and_comm] using cov.exists_path_lifts (f.comp γ) e₀ (by simp [γ_0, he])
let pγ : Path a₀ (γ 1) := ⟨γ, γ_0, rfl⟩
let pγ' : Path a₀ (γ 1) := ⟨γ', γ'_0, γγ'1.symm⟩
convert cov.liftPath_apply_one_eq_of_homotopicRel (ContinuousMap.HomotopicRel.comp_continuousMap
(SimplyConnectedSpace.paths_homotopic pγ pγ') f) e₀ (by simp [he]) (by simp [he]) <;>
rw [eq_liftPath_iff']
exacts [⟨Γ_lifts, Γ_0⟩, ⟨Γ'_lifts, Γ'_0⟩] | theorem | Topology | [
"Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Topology.Covering",
"Mathlib.Topology.Homotopy.Path",
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Homotopy/Lifting.lean | existsUnique_continuousMap_lifts | A map `f` from a simply-connected, locally path-connected space `A` to another space `X` lifts
uniquely through a covering map `p : E → X`, after specifying any lift `e₀ : E` of any point
`a₀ : A`. |
Homotopy (p₀ p₁ : Path x₀ x₁) :=
ContinuousMap.HomotopyRel p₀.toContinuousMap p₁.toContinuousMap {0, 1} | abbrev | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | Homotopy | The type of homotopies between two paths. |
coeFn_injective : @Function.Injective (Homotopy p₀ p₁) (I × I → X) (⇑) :=
DFunLike.coe_injective
@[simp] | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | coeFn_injective | null |
source (F : Homotopy p₀ p₁) (t : I) : F (t, 0) = x₀ :=
calc F (t, 0) = p₀ 0 := ContinuousMap.HomotopyRel.eq_fst _ _ (.inl rfl)
_ = x₀ := p₀.source
@[simp] | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | source | null |
target (F : Homotopy p₀ p₁) (t : I) : F (t, 1) = x₁ :=
calc F (t, 1) = p₀ 1 := ContinuousMap.HomotopyRel.eq_fst _ _ (.inr rfl)
_ = x₁ := p₀.target | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | target | null |
eval (F : Homotopy p₀ p₁) (t : I) : Path x₀ x₁ where
toFun := F.toHomotopy.curry t
source' := by simp
target' := by simp
@[simp] | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | eval | Evaluating a path homotopy at an intermediate point, giving us a `Path`. |
eval_zero (F : Homotopy p₀ p₁) : F.eval 0 = p₀ := by
ext t
simp [eval]
@[simp] | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | eval_zero | null |
eval_one (F : Homotopy p₀ p₁) : F.eval 1 = p₁ := by
ext t
simp [eval] | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | eval_one | null |
@[simps!]
refl (p : Path x₀ x₁) : Homotopy p p :=
ContinuousMap.HomotopyRel.refl p.toContinuousMap {0, 1} | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | refl | Given a path `p`, we can define a `Homotopy p p` by `F (t, x) = p x`. |
@[simps!]
symm (F : Homotopy p₀ p₁) : Homotopy p₁ p₀ :=
ContinuousMap.HomotopyRel.symm F
@[simp] | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | symm | Given a `Homotopy p₀ p₁`, we can define a `Homotopy p₁ p₀` by reversing the homotopy. |
symm_symm (F : Homotopy p₀ p₁) : F.symm.symm = F :=
ContinuousMap.HomotopyRel.symm_symm F | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | symm_symm | null |
symm_bijective : Function.Bijective (Homotopy.symm : Homotopy p₀ p₁ → Homotopy p₁ p₀) :=
Function.bijective_iff_has_inverse.mpr ⟨_, symm_symm, symm_symm⟩ | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | symm_bijective | null |
trans (F : Homotopy p₀ p₁) (G : Homotopy p₁ p₂) : Homotopy p₀ p₂ :=
ContinuousMap.HomotopyRel.trans F G | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | trans | Given `Homotopy p₀ p₁` and `Homotopy p₁ p₂`, we can define a `Homotopy p₀ p₂` by putting the first
homotopy on `[0, 1/2]` and the second on `[1/2, 1]`. |
trans_apply (F : Homotopy p₀ p₁) (G : Homotopy p₁ p₂) (x : I × I) :
(F.trans G) x =
if h : (x.1 : ℝ) ≤ 1 / 2 then
F (⟨2 * x.1, (unitInterval.mul_pos_mem_iff zero_lt_two).2 ⟨x.1.2.1, h⟩⟩, x.2)
else
G (⟨2 * x.1 - 1, unitInterval.two_mul_sub_one_mem_iff.2 ⟨(not_le.1 h).le, x.1.2.2⟩⟩, x.2) :=
ContinuousMap.HomotopyRel.trans_apply _ _ _ | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | trans_apply | null |
symm_trans (F : Homotopy p₀ p₁) (G : Homotopy p₁ p₂) :
(F.trans G).symm = G.symm.trans F.symm :=
ContinuousMap.HomotopyRel.symm_trans _ _ | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | symm_trans | null |
@[simps!]
cast {p₀ p₁ q₀ q₁ : Path x₀ x₁} (F : Homotopy p₀ p₁) (h₀ : p₀ = q₀) (h₁ : p₁ = q₁) :
Homotopy q₀ q₁ :=
ContinuousMap.HomotopyRel.cast F (congr_arg _ h₀) (congr_arg _ h₁) | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | cast | Casting a `Homotopy p₀ p₁` to a `Homotopy q₀ q₁` where `p₀ = q₀` and `p₁ = q₁`. |
hcomp (F : Homotopy p₀ q₀) (G : Homotopy p₁ q₁) : Homotopy (p₀.trans p₁) (q₀.trans q₁) where
toFun x :=
if (x.2 : ℝ) ≤ 1 / 2 then (F.eval x.1).extend (2 * x.2) else (G.eval x.1).extend (2 * x.2 - 1)
continuous_toFun := continuous_if_le (continuous_induced_dom.comp continuous_snd) continuous_const
(F.toHomotopy.continuous.comp (by continuity)).continuousOn
(G.toHomotopy.continuous.comp (by continuity)).continuousOn fun x hx => by norm_num [hx]
map_zero_left x := by simp [Path.trans]
map_one_left x := by simp [Path.trans]
prop' x t ht := by
rcases ht with ht | ht
· norm_num [ht]
· rw [Set.mem_singleton_iff] at ht
norm_num [ht] | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | hcomp | Suppose `p₀` and `q₀` are paths from `x₀` to `x₁`, `p₁` and `q₁` are paths from `x₁` to `x₂`.
Furthermore, suppose `F : Homotopy p₀ q₀` and `G : Homotopy p₁ q₁`. Then we can define a homotopy
from `p₀.trans p₁` to `q₀.trans q₁`. |
hcomp_apply (F : Homotopy p₀ q₀) (G : Homotopy p₁ q₁) (x : I × I) :
F.hcomp G x =
if h : (x.2 : ℝ) ≤ 1 / 2 then
F.eval x.1 ⟨2 * x.2, (unitInterval.mul_pos_mem_iff zero_lt_two).2 ⟨x.2.2.1, h⟩⟩
else
G.eval x.1
⟨2 * x.2 - 1, unitInterval.two_mul_sub_one_mem_iff.2 ⟨(not_le.1 h).le, x.2.2.2⟩⟩ :=
show ite _ _ _ = _ by split_ifs <;> exact Path.extend_extends _ _ | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | hcomp_apply | null |
hcomp_half (F : Homotopy p₀ q₀) (G : Homotopy p₁ q₁) (t : I) :
F.hcomp G (t, ⟨1 / 2, by norm_num, by norm_num⟩) = x₁ :=
show ite _ _ _ = _ by norm_num | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | hcomp_half | null |
reparam (p : Path x₀ x₁) (f : I → I) (hf : Continuous f) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
Homotopy p (p.reparam f hf hf₀ hf₁) where
toFun x := p ⟨σ x.1 * x.2 + x.1 * f x.2,
show (σ x.1 : ℝ) • (x.2 : ℝ) + (x.1 : ℝ) • (f x.2 : ℝ) ∈ I from
convex_Icc _ _ x.2.2 (f x.2).2 (by unit_interval) (by unit_interval) (by simp)⟩
map_zero_left x := by norm_num
map_one_left x := by norm_num
prop' t x hx := by
rcases hx with hx | hx
· rw [hx]
simp [hf₀]
· rw [Set.mem_singleton_iff] at hx
rw [hx]
simp [hf₁]
continuous_toFun := by fun_prop | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | reparam | Suppose `p` is a path, then we have a homotopy from `p` to `p.reparam f` by the convexity of `I`. |
@[simps]
symm₂ {p q : Path x₀ x₁} (F : p.Homotopy q) : p.symm.Homotopy q.symm where
toFun x := F ⟨x.1, σ x.2⟩
map_zero_left := by simp [Path.symm]
map_one_left := by simp [Path.symm]
prop' t x hx := by
rcases hx with hx | hx
· rw [hx]
simp
· rw [Set.mem_singleton_iff] at hx
rw [hx]
simp | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | symm₂ | Suppose `F : Homotopy p q`. Then we have a `Homotopy p.symm q.symm` by reversing the second
argument. |
@[simps]
map {p q : Path x₀ x₁} (F : p.Homotopy q) (f : C(X, Y)) :
Homotopy (p.map f.continuous) (q.map f.continuous) where
toFun := f ∘ F
map_zero_left := by simp
map_one_left := by simp
prop' t x hx := by
rcases hx with hx | hx
· simp [hx]
· rw [Set.mem_singleton_iff] at hx
simp [hx] | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | map | Given `F : Homotopy p q`, and `f : C(X, Y)`, we can define a homotopy from `p.map f.continuous` to
`q.map f.continuous`. |
Homotopic (p₀ p₁ : Path x₀ x₁) : Prop :=
Nonempty (p₀.Homotopy p₁) | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | Homotopic | Two paths `p₀` and `p₁` are `Path.Homotopic` if there exists a `Homotopy` between them. |
@[refl]
refl (p : Path x₀ x₁) : p.Homotopic p :=
⟨Homotopy.refl p⟩
@[symm] | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | refl | null |
symm ⦃p₀ p₁ : Path x₀ x₁⦄ (h : p₀.Homotopic p₁) : p₁.Homotopic p₀ :=
h.map Homotopy.symm
@[trans] | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | symm | null |
trans ⦃p₀ p₁ p₂ : Path x₀ x₁⦄ (h₀ : p₀.Homotopic p₁) (h₁ : p₁.Homotopic p₂) :
p₀.Homotopic p₂ :=
h₀.map2 Homotopy.trans h₁ | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | trans | null |
equivalence : Equivalence (@Homotopic X _ x₀ x₁) :=
⟨refl, (symm ·), (trans · ·)⟩
nonrec theorem map {p q : Path x₀ x₁} (h : p.Homotopic q) (f : C(X, Y)) :
Homotopic (p.map f.continuous) (q.map f.continuous) :=
h.map fun F => F.map f | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | equivalence | null |
hcomp {p₀ p₁ : Path x₀ x₁} {q₀ q₁ : Path x₁ x₂} (hp : p₀.Homotopic p₁)
(hq : q₀.Homotopic q₁) : (p₀.trans q₀).Homotopic (p₁.trans q₁) :=
hp.map2 Homotopy.hcomp hq | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | hcomp | null |
protected setoid (x₀ x₁ : X) : Setoid (Path x₀ x₁) :=
⟨Homotopic, equivalence⟩ | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | setoid | The setoid on `Path`s defined by the equivalence relation `Path.Homotopic`. That is, two paths are
equivalent if there is a `Homotopy` between them. |
protected Quotient (x₀ x₁ : X) :=
Quotient (Homotopic.setoid x₀ x₁)
attribute [local instance] Homotopic.setoid | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | Quotient | The quotient on `Path x₀ x₁` by the equivalence relation `Path.Homotopic`. |
Quotient.comp (P₀ : Path.Homotopic.Quotient x₀ x₁) (P₁ : Path.Homotopic.Quotient x₁ x₂) :
Path.Homotopic.Quotient x₀ x₂ :=
Quotient.map₂ Path.trans (fun (_ : Path x₀ x₁) _ hp (_ : Path x₁ x₂) _ hq => hcomp hp hq) P₀ P₁ | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | Quotient.comp | The composition of path homotopy classes. This is `Path.trans` descended to the quotient. |
comp_lift (P₀ : Path x₀ x₁) (P₁ : Path x₁ x₂) : ⟦P₀.trans P₁⟧ = Quotient.comp ⟦P₀⟧ ⟦P₁⟧ :=
rfl | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | comp_lift | null |
Quotient.mapFn (P₀ : Path.Homotopic.Quotient x₀ x₁) (f : C(X, Y)) :
Path.Homotopic.Quotient (f x₀) (f x₁) :=
Quotient.map (fun q : Path x₀ x₁ => q.map f.continuous) (fun _ _ h => Path.Homotopic.map h f) P₀ | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | Quotient.mapFn | The image of a path homotopy class `P₀` under a map `f`.
This is `Path.map` descended to the quotient. |
map_lift (P₀ : Path x₀ x₁) (f : C(X, Y)) : ⟦P₀.map f.continuous⟧ = Quotient.mapFn ⟦P₀⟧ f :=
rfl | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | map_lift | null |
hpath_hext {p₁ : Path x₀ x₁} {p₂ : Path x₂ x₃} (hp : ∀ t, p₁ t = p₂ t) :
HEq (α := Path.Homotopic.Quotient _ _) ⟦p₁⟧ (β := Path.Homotopic.Quotient _ _) ⟦p₂⟧ := by
obtain rfl : x₀ = x₂ := by convert hp 0 <;> simp
obtain rfl : x₁ = x₃ := by convert hp 1 <;> simp
rw [heq_iff_eq]; congr; ext t; exact hp t | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | hpath_hext | null |
@[simps!]
toHomotopyConst (p : Path x₀ x₁) :
(ContinuousMap.const Y x₀).Homotopy (ContinuousMap.const Y x₁) where
toContinuousMap := p.toContinuousMap.comp ContinuousMap.fst
map_zero_left _ := p.source
map_one_left _ := p.target | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | toHomotopyConst | A path `Path x₀ x₁` generates a homotopy between constant functions `fun _ ↦ x₀` and
`fun _ ↦ x₁`. |
@[simp]
ContinuousMap.homotopic_const_iff [Nonempty Y] :
(ContinuousMap.const Y x₀).Homotopic (ContinuousMap.const Y x₁) ↔ Joined x₀ x₁ := by
inhabit Y
refine ⟨fun ⟨H⟩ ↦ ⟨⟨(H.toContinuousMap.comp .prodSwap).curry default, ?_, ?_⟩⟩,
fun ⟨p⟩ ↦ ⟨p.toHomotopyConst⟩⟩ <;> simp | theorem | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | ContinuousMap.homotopic_const_iff | Two constant continuous maps with nonempty domain are homotopic if and only if their values are
joined by a path in the codomain. |
evalAt {X : Type*} {Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f g : C(X, Y)}
(H : ContinuousMap.Homotopy f g) (x : X) : Path (f x) (g x) where
toFun t := H (t, x)
source' := H.apply_zero x
target' := H.apply_one x | def | Topology | [
"Mathlib.Topology.Homotopy.Basic",
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Analysis.Convex.Basic"
] | Mathlib/Topology/Homotopy/Path.lean | evalAt | Given a homotopy `H : f ∼ g`, get the path traced by the point `x` as it moves from
`f x` to `g x`. |
@[simps!]
HomotopyRel.pi (homotopies : ∀ i : I, HomotopyRel (f i) (g i) S) :
HomotopyRel (pi f) (pi g) S :=
{ Homotopy.pi fun i => (homotopies i).toHomotopy with
prop' := by
intro t x hx
dsimp only [coe_mk, pi_eval, toFun_eq_coe, HomotopyWith.coe_toContinuousMap]
simp only [funext_iff]
intro i
exact (homotopies i).prop' t x hx } | def | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | HomotopyRel.pi | The relative product homotopy of `homotopies` between functions `f` and `g` |
@[simps]
Homotopy.prod (F : Homotopy f₀ f₁) (G : Homotopy g₀ g₁) :
Homotopy (ContinuousMap.prodMk f₀ g₀) (ContinuousMap.prodMk f₁ g₁) where
toFun t := (F t, G t)
map_zero_left x := by simp only [prod_eval, Homotopy.apply_zero]
map_one_left x := by simp only [prod_eval, Homotopy.apply_one] | def | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | Homotopy.prod | The product of homotopies `F` and `G`,
where `F` takes `f₀` to `f₁` and `G` takes `g₀` to `g₁` |
@[simps!]
HomotopyRel.prod (F : HomotopyRel f₀ f₁ S) (G : HomotopyRel g₀ g₁ S) :
HomotopyRel (prodMk f₀ g₀) (prodMk f₁ g₁) S where
toHomotopy := Homotopy.prod F.toHomotopy G.toHomotopy
prop' t x hx := Prod.ext (F.prop' t x hx) (G.prop' t x hx) | def | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | HomotopyRel.prod | The relative product of homotopies `F` and `G`,
where `F` takes `f₀` to `f₁` and `G` takes `g₀` to `g₁` |
piHomotopy (γ₀ γ₁ : ∀ i, Path (as i) (bs i)) (H : ∀ i, Path.Homotopy (γ₀ i) (γ₁ i)) :
Path.Homotopy (Path.pi γ₀) (Path.pi γ₁) :=
ContinuousMap.HomotopyRel.pi H | def | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | piHomotopy | The product of a family of path homotopies. This is just a specialization of `HomotopyRel`. |
pi (γ : ∀ i, Path.Homotopic.Quotient (as i) (bs i)) : Path.Homotopic.Quotient as bs :=
(Quotient.map Path.pi fun x y hxy =>
Nonempty.map (piHomotopy x y) (Classical.nonempty_pi.mpr hxy)) (Quotient.choice γ) | def | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | pi | The product of a family of path homotopy classes. |
pi_lift (γ : ∀ i, Path (as i) (bs i)) :
(Path.Homotopic.pi fun i => ⟦γ i⟧) = ⟦Path.pi γ⟧ := by unfold pi; simp | theorem | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | pi_lift | null |
comp_pi_eq_pi_comp (γ₀ : ∀ i, Path.Homotopic.Quotient (as i) (bs i))
(γ₁ : ∀ i, Path.Homotopic.Quotient (bs i) (cs i)) : pi γ₀ ⬝ pi γ₁ = pi fun i ↦ γ₀ i ⬝ γ₁ i := by
induction γ₁ using Quotient.induction_on_pi with | _ a =>
induction γ₀ using Quotient.induction_on_pi
simp only [pi_lift]
rw [← Path.Homotopic.comp_lift, Path.trans_pi_eq_pi_trans, ← pi_lift]
rfl | theorem | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | comp_pi_eq_pi_comp | Composition and products commute.
This is `Path.trans_pi_eq_pi_trans` descended to path homotopy classes. |
proj (i : ι) (p : Path.Homotopic.Quotient as bs) : Path.Homotopic.Quotient (as i) (bs i) :=
p.mapFn ⟨_, continuous_apply i⟩ | abbrev | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | proj | Abbreviation for projection onto the ith coordinate. |
@[simp]
proj_pi (i : ι) (paths : ∀ i, Path.Homotopic.Quotient (as i) (bs i)) :
proj i (pi paths) = paths i := by
induction paths using Quotient.induction_on_pi
rw [proj, pi_lift, ← Path.Homotopic.map_lift]
congr
@[simp] | theorem | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | proj_pi | Lemmas showing projection is the inverse of pi. |
pi_proj (p : Path.Homotopic.Quotient as bs) : (pi fun i => proj i p) = p := by
induction p using Quotient.inductionOn
simp_rw [proj, ← Path.Homotopic.map_lift]
erw [pi_lift]
congr | theorem | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | pi_proj | null |
prodHomotopy (h₁ : Path.Homotopy p₁ p₁') (h₂ : Path.Homotopy p₂ p₂') :
Path.Homotopy (p₁.prod p₂) (p₁'.prod p₂') :=
ContinuousMap.HomotopyRel.prod h₁ h₂ | def | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | prodHomotopy | The product of homotopies h₁ and h₂.
This is `HomotopyRel.prod` specialized for path homotopies. |
prod (q₁ : Path.Homotopic.Quotient a₁ a₂) (q₂ : Path.Homotopic.Quotient b₁ b₂) :
Path.Homotopic.Quotient (a₁, b₁) (a₂, b₂) :=
Quotient.map₂ Path.prod (fun _ _ h₁ _ _ h₂ => Nonempty.map2 prodHomotopy h₁ h₂) q₁ q₂
variable (p₁ p₁' p₂ p₂') | def | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | prod | The product of path classes q₁ and q₂. This is `Path.prod` descended to the quotient. |
prod_lift : prod ⟦p₁⟧ ⟦p₂⟧ = ⟦p₁.prod p₂⟧ :=
rfl
variable (r₁ : Path.Homotopic.Quotient a₂ a₃) (r₂ : Path.Homotopic.Quotient b₂ b₃) | theorem | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | prod_lift | null |
comp_prod_eq_prod_comp : prod q₁ q₂ ⬝ prod r₁ r₂ = prod (q₁ ⬝ r₁) (q₂ ⬝ r₂) := by
induction q₁, q₂ using Quotient.inductionOn₂
induction r₁, r₂ using Quotient.inductionOn₂
simp only [prod_lift, ← Path.Homotopic.comp_lift, Path.trans_prod_eq_prod_trans]
variable {c₁ c₂ : α × β} | theorem | Topology | [
"Mathlib.Topology.Constructions",
"Mathlib.Topology.Homotopy.Path"
] | Mathlib/Topology/Homotopy/Product.lean | comp_prod_eq_prod_comp | Products commute with path composition.
This is `trans_prod_eq_prod_trans` descended to the quotient. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.