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 ⌀ |
|---|---|---|---|---|---|---|
Set.MapsTo.lipschitzOnWith_iff_restrict {t : Set β} (h : MapsTo f s t) :
LipschitzOnWith K f s ↔ LipschitzWith K (h.restrict f s t) :=
_root_.lipschitzOnWith_iff_restrict
alias ⟨LipschitzOnWith.mapsToRestrict, _⟩ := Set.MapsTo.lipschitzOnWith_iff_restrict
@[deprecated (since := "05-09-2025")]
alias LipschitzOnWith.to_restric_mapsTo := LipschitzOnWith.mapsToRestrict | lemma | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | Set.MapsTo.lipschitzOnWith_iff_restrict | null |
protected lipschitzOnWith (h : LipschitzWith K f) : LipschitzOnWith K f s :=
fun x _ y _ => h x y | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | lipschitzOnWith | null |
edist_le_mul (h : LipschitzWith K f) (x y : α) : edist (f x) (f y) ≤ K * edist x y :=
h x y | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | edist_le_mul | null |
edist_le_mul_of_le (h : LipschitzWith K f) (hr : edist x y ≤ r) :
edist (f x) (f y) ≤ K * r :=
(h x y).trans <| mul_right_mono hr | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | edist_le_mul_of_le | null |
edist_lt_mul_of_lt (h : LipschitzWith K f) (hK : K ≠ 0) (hr : edist x y < r) :
edist (f x) (f y) < K * r :=
(h x y).trans_lt <| (ENNReal.mul_lt_mul_left (ENNReal.coe_ne_zero.2 hK) ENNReal.coe_ne_top).2 hr | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | edist_lt_mul_of_lt | null |
mapsTo_emetric_closedBall (h : LipschitzWith K f) (x : α) (r : ℝ≥0∞) :
MapsTo f (closedBall x r) (closedBall (f x) (K * r)) := fun _y hy => h.edist_le_mul_of_le hy | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | mapsTo_emetric_closedBall | null |
mapsTo_emetric_ball (h : LipschitzWith K f) (hK : K ≠ 0) (x : α) (r : ℝ≥0∞) :
MapsTo f (ball x r) (ball (f x) (K * r)) := fun _y hy => h.edist_lt_mul_of_lt hK hy | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | mapsTo_emetric_ball | null |
edist_lt_top (hf : LipschitzWith K f) {x y : α} (h : edist x y ≠ ⊤) :
edist (f x) (f y) < ⊤ :=
(hf x y).trans_lt (by finiteness) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | edist_lt_top | null |
mul_edist_le (h : LipschitzWith K f) (x y : α) :
(K⁻¹ : ℝ≥0∞) * edist (f x) (f y) ≤ edist x y := by
rw [mul_comm, ← div_eq_mul_inv]
exact ENNReal.div_le_of_le_mul' (h x y) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | mul_edist_le | null |
protected of_edist_le (h : ∀ x y, edist (f x) (f y) ≤ edist x y) : LipschitzWith 1 f :=
fun x y => by simp only [ENNReal.coe_one, one_mul, h] | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | of_edist_le | null |
protected weaken (hf : LipschitzWith K f) {K' : ℝ≥0} (h : K ≤ K') : LipschitzWith K' f :=
fun x y => le_trans (hf x y) <| mul_left_mono (ENNReal.coe_le_coe.2 h) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | weaken | null |
ediam_image_le (hf : LipschitzWith K f) (s : Set α) :
EMetric.diam (f '' s) ≤ K * EMetric.diam s := by
apply EMetric.diam_le
rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩
exact hf.edist_le_mul_of_le (EMetric.edist_le_diam_of_mem hx hy) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | ediam_image_le | null |
edist_lt_of_edist_lt_div (hf : LipschitzWith K f) {x y : α} {d : ℝ≥0∞}
(h : edist x y < d / K) : edist (f x) (f y) < d :=
calc
edist (f x) (f y) ≤ K * edist x y := hf x y
_ < d := ENNReal.mul_lt_of_lt_div' h | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | edist_lt_of_edist_lt_div | null |
protected uniformContinuous (hf : LipschitzWith K f) : UniformContinuous f :=
EMetric.uniformContinuous_iff.2 fun ε εpos =>
⟨ε / K, ENNReal.div_pos_iff.2 ⟨ne_of_gt εpos, ENNReal.coe_ne_top⟩, hf.edist_lt_of_edist_lt_div⟩ | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | uniformContinuous | A Lipschitz function is uniformly continuous. |
protected continuous (hf : LipschitzWith K f) : Continuous f :=
hf.uniformContinuous.continuous | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuous | A Lipschitz function is continuous. |
protected const (b : β) : LipschitzWith 0 fun _ : α => b := fun x y => by
simp only [edist_self, zero_le] | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | const | Constant functions are Lipschitz (with any constant). |
protected const' (b : β) {K : ℝ≥0} : LipschitzWith K fun _ : α => b := fun x y => by
simp only [edist_self, zero_le] | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | const' | null |
protected id : LipschitzWith 1 (@id α) :=
LipschitzWith.of_edist_le fun _ _ => le_rfl | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | id | The identity is 1-Lipschitz. |
protected subtype_val (s : Set α) : LipschitzWith 1 (Subtype.val : s → α) :=
LipschitzWith.of_edist_le fun _ _ => le_rfl | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | subtype_val | The inclusion of a subset is 1-Lipschitz. |
subtype_mk (hf : LipschitzWith K f) {p : β → Prop} (hp : ∀ x, p (f x)) :
LipschitzWith K (fun x => ⟨f x, hp x⟩ : α → { y // p y }) :=
hf | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | subtype_mk | null |
protected eval {α : ι → Type u} [∀ i, PseudoEMetricSpace (α i)] [Fintype ι] (i : ι) :
LipschitzWith 1 (Function.eval i : (∀ i, α i) → α i) :=
LipschitzWith.of_edist_le fun f g => by convert edist_le_pi_edist f g i | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | eval | null |
protected restrict (hf : LipschitzWith K f) (s : Set α) : LipschitzWith K (s.restrict f) :=
fun x y => hf x y | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | restrict | The restriction of a `K`-Lipschitz function is `K`-Lipschitz. |
protected comp {Kf Kg : ℝ≥0} {f : β → γ} {g : α → β} (hf : LipschitzWith Kf f)
(hg : LipschitzWith Kg g) : LipschitzWith (Kf * Kg) (f ∘ g) := fun x y =>
calc
edist (f (g x)) (f (g y)) ≤ Kf * edist (g x) (g y) := hf _ _
_ ≤ Kf * (Kg * edist x y) := mul_right_mono (hg _ _)
_ = (Kf * Kg : ℝ≥0) * edist x y := by rw [← mul_assoc, ENNReal.coe_mul] | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | comp | The composition of Lipschitz functions is Lipschitz. |
comp_lipschitzOnWith {Kf Kg : ℝ≥0} {f : β → γ} {g : α → β} {s : Set α}
(hf : LipschitzWith Kf f) (hg : LipschitzOnWith Kg g s) : LipschitzOnWith (Kf * Kg) (f ∘ g) s :=
lipschitzOnWith_iff_restrict.mpr <| hf.comp hg.to_restrict | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | comp_lipschitzOnWith | null |
protected prod_fst : LipschitzWith 1 (@Prod.fst α β) :=
LipschitzWith.of_edist_le fun _ _ => le_max_left _ _ | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prod_fst | null |
protected prod_snd : LipschitzWith 1 (@Prod.snd α β) :=
LipschitzWith.of_edist_le fun _ _ => le_max_right _ _ | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prod_snd | null |
protected prodMk {f : α → β} {Kf : ℝ≥0} (hf : LipschitzWith Kf f) {g : α → γ} {Kg : ℝ≥0}
(hg : LipschitzWith Kg g) : LipschitzWith (max Kf Kg) fun x => (f x, g x) := by
intro x y
rw [ENNReal.coe_mono.map_max, Prod.edist_eq, max_mul]
exact max_le_max (hf x y) (hg x y)
@[deprecated (since := "2025-03-10")]
protected alias prod := LipschitzWith.prodMk | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prodMk | If `f` and `g` are Lipschitz functions, so is the induced map `f × g` to the product type. |
protected prodMk_left (a : α) : LipschitzWith 1 (Prod.mk a : β → α × β) := by
simpa only [max_eq_right zero_le_one] using (LipschitzWith.const a).prodMk LipschitzWith.id
@[deprecated (since := "2025-03-10")]
protected alias prod_mk_left := LipschitzWith.prodMk_left | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prodMk_left | null |
protected prodMk_right (b : β) : LipschitzWith 1 fun a : α => (a, b) := by
simpa only [max_eq_left zero_le_one] using LipschitzWith.id.prodMk (LipschitzWith.const b)
@[deprecated (since := "2025-03-10")]
protected alias prod_mk_right := LipschitzWith.prodMk_right | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prodMk_right | null |
protected uncurry {f : α → β → γ} {Kα Kβ : ℝ≥0} (hα : ∀ b, LipschitzWith Kα fun a => f a b)
(hβ : ∀ a, LipschitzWith Kβ (f a)) : LipschitzWith (Kα + Kβ) (Function.uncurry f) := by
rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩
simp only [Function.uncurry, ENNReal.coe_add, add_mul]
apply le_trans (edist_triangle _ (f a₂ b₁) _)
exact
add_le_add (le_trans (hα _ _ _) <| mul_right_mono <| le_max_left _ _)
(le_trans (hβ _ _ _) <| mul_right_mono <| le_max_right _ _) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | uncurry | null |
protected iterate {f : α → α} (hf : LipschitzWith K f) : ∀ n, LipschitzWith (K ^ n) f^[n]
| 0 => by simpa only [pow_zero] using LipschitzWith.id
| n + 1 => by rw [pow_succ]; exact (LipschitzWith.iterate hf n).comp hf | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | iterate | Iterates of a Lipschitz function are Lipschitz. |
edist_iterate_succ_le_geometric {f : α → α} (hf : LipschitzWith K f) (x n) :
edist (f^[n] x) (f^[n+1] x) ≤ edist x (f x) * (K : ℝ≥0∞) ^ n := by
rw [iterate_succ, mul_comm]
simpa only [ENNReal.coe_pow] using (hf.iterate n) x (f x) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | edist_iterate_succ_le_geometric | null |
protected mul_end {f g : Function.End α} {Kf Kg} (hf : LipschitzWith Kf f)
(hg : LipschitzWith Kg g) : LipschitzWith (Kf * Kg) (f * g : Function.End α) :=
hf.comp hg | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | mul_end | null |
protected list_prod (f : ι → Function.End α) (K : ι → ℝ≥0)
(h : ∀ i, LipschitzWith (K i) (f i)) : ∀ l : List ι, LipschitzWith (l.map K).prod (l.map f).prod
| [] => by simpa using LipschitzWith.id
| i::l => by
simp only [List.map_cons, List.prod_cons]
exact (h i).mul_end (LipschitzWith.list_prod f K h l) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | list_prod | The product of a list of Lipschitz continuous endomorphisms is a Lipschitz continuous
endomorphism. |
protected pow_end {f : Function.End α} {K} (h : LipschitzWith K f) :
∀ n : ℕ, LipschitzWith (K ^ n) (f ^ n : Function.End α)
| 0 => by simpa only [pow_zero] using LipschitzWith.id
| n + 1 => by
rw [pow_succ, pow_succ]
exact (LipschitzWith.pow_end h n).mul_end h | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | pow_end | null |
protected uniformContinuousOn (hf : LipschitzOnWith K f s) : UniformContinuousOn f s :=
uniformContinuousOn_iff_restrict.mpr hf.to_restrict.uniformContinuous | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | uniformContinuousOn | null |
protected continuousOn (hf : LipschitzOnWith K f s) : ContinuousOn f s :=
hf.uniformContinuousOn.continuousOn | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuousOn | null |
edist_le_mul_of_le (h : LipschitzOnWith K f s) {x y : α} (hx : x ∈ s) (hy : y ∈ s)
{r : ℝ≥0∞} (hr : edist x y ≤ r) :
edist (f x) (f y) ≤ K * r :=
(h hx hy).trans <| mul_right_mono hr | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | edist_le_mul_of_le | null |
edist_lt_of_edist_lt_div (hf : LipschitzOnWith K f s) {x y : α} (hx : x ∈ s) (hy : y ∈ s)
{d : ℝ≥0∞} (hd : edist x y < d / K) : edist (f x) (f y) < d :=
hf.to_restrict.edist_lt_of_edist_lt_div <| show edist (⟨x, hx⟩ : s) ⟨y, hy⟩ < d / K from hd | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | edist_lt_of_edist_lt_div | null |
protected comp {g : β → γ} {t : Set β} {Kg : ℝ≥0} (hg : LipschitzOnWith Kg g t)
(hf : LipschitzOnWith K f s) (hmaps : MapsTo f s t) : LipschitzOnWith (Kg * K) (g ∘ f) s :=
lipschitzOnWith_iff_restrict.mpr <| hg.to_restrict.comp (hf.mapsToRestrict hmaps) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | comp | null |
protected prodMk {g : α → γ} {Kf Kg : ℝ≥0} (hf : LipschitzOnWith Kf f s)
(hg : LipschitzOnWith Kg g s) : LipschitzOnWith (max Kf Kg) (fun x => (f x, g x)) s := by
intro _ hx _ hy
rw [ENNReal.coe_mono.map_max, Prod.edist_eq, max_mul]
exact max_le_max (hf hx hy) (hg hx hy)
@[deprecated (since := "2025-03-10")]
protected alias prod := LipschitzOnWith.prodMk | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prodMk | If `f` and `g` are Lipschitz on `s`, so is the induced map `f × g` to the product type. |
ediam_image2_le (f : α → β → γ) {K₁ K₂ : ℝ≥0} (s : Set α) (t : Set β)
(hf₁ : ∀ b ∈ t, LipschitzOnWith K₁ (f · b) s) (hf₂ : ∀ a ∈ s, LipschitzOnWith K₂ (f a) t) :
EMetric.diam (Set.image2 f s t) ≤ ↑K₁ * EMetric.diam s + ↑K₂ * EMetric.diam t := by
simp only [EMetric.diam_le_iff, forall_mem_image2]
intro a₁ ha₁ b₁ hb₁ a₂ ha₂ b₂ hb₂
refine (edist_triangle _ (f a₂ b₁) _).trans ?_
exact
add_le_add
((hf₁ b₁ hb₁ ha₁ ha₂).trans <| mul_right_mono <| EMetric.edist_le_diam_of_mem ha₁ ha₂)
((hf₂ a₂ ha₂ hb₁ hb₂).trans <| mul_right_mono <| EMetric.edist_le_diam_of_mem hb₁ hb₂) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | ediam_image2_le | null |
protected _root_.LipschitzWith.locallyLipschitz {K : ℝ≥0} (hf : LipschitzWith K f) :
LocallyLipschitz f :=
fun _ ↦ ⟨K, univ, Filter.univ_mem, lipschitzOnWith_univ.mpr hf⟩ | lemma | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | _root_.LipschitzWith.locallyLipschitz | A Lipschitz function is locally Lipschitz. |
protected id : LocallyLipschitz (@id α) := LipschitzWith.id.locallyLipschitz | lemma | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | id | The identity function is locally Lipschitz. |
protected const (b : β) : LocallyLipschitz (fun _ : α ↦ b) :=
(LipschitzWith.const b).locallyLipschitz | lemma | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | const | Constant functions are locally Lipschitz. |
protected continuous {f : α → β} (hf : LocallyLipschitz f) : Continuous f := by
rw [continuous_iff_continuousAt]
intro x
rcases (hf x) with ⟨K, t, ht, hK⟩
exact (hK.continuousOn).continuousAt ht | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuous | A locally Lipschitz function is continuous. (The converse is false: for example,
$x ↦ \sqrt{x}$ is continuous, but not locally Lipschitz at 0.) |
protected comp {f : β → γ} {g : α → β}
(hf : LocallyLipschitz f) (hg : LocallyLipschitz g) : LocallyLipschitz (f ∘ g) := by
intro x
rcases hg x with ⟨Kg, t, ht, hgL⟩
rcases hf (g x) with ⟨Kf, u, hu, hfL⟩
refine ⟨Kf * Kg, t ∩ g⁻¹' u, inter_mem ht (hg.continuous.continuousAt hu), ?_⟩
exact hfL.comp (hgL.mono inter_subset_left)
((mapsTo_preimage g u).mono_left inter_subset_right) | lemma | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | comp | The composition of locally Lipschitz functions is locally Lipschitz. |
protected prodMk {f : α → β} (hf : LocallyLipschitz f) {g : α → γ} (hg : LocallyLipschitz g) :
LocallyLipschitz fun x => (f x, g x) := by
intro x
rcases hf x with ⟨Kf, t₁, h₁t, hfL⟩
rcases hg x with ⟨Kg, t₂, h₂t, hgL⟩
refine ⟨max Kf Kg, t₁ ∩ t₂, Filter.inter_mem h₁t h₂t, ?_⟩
exact (hfL.mono inter_subset_left).prodMk (hgL.mono inter_subset_right)
@[deprecated (since := "2025-03-10")]
protected alias prod := LocallyLipschitz.prodMk | lemma | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prodMk | If `f` and `g` are locally Lipschitz, so is the induced map `f × g` to the product type. |
protected prodMk_left (a : α) : LocallyLipschitz (Prod.mk a : β → α × β) :=
(LipschitzWith.prodMk_left a).locallyLipschitz
@[deprecated (since := "2025-03-10")]
protected alias prod_mk_left := LocallyLipschitz.prodMk_left | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prodMk_left | null |
protected prodMk_right (b : β) : LocallyLipschitz (fun a : α => (a, b)) :=
(LipschitzWith.prodMk_right b).locallyLipschitz
@[deprecated (since := "2025-03-10")]
protected alias prod_mk_right := LocallyLipschitz.prodMk_right | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | prodMk_right | null |
protected iterate {f : α → α} (hf : LocallyLipschitz f) : ∀ n, LocallyLipschitz f^[n]
| 0 => by simpa only [pow_zero] using LocallyLipschitz.id
| n + 1 => by rw [iterate_add, iterate_one]; exact (hf.iterate n).comp hf | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | iterate | null |
protected mul_end {f g : Function.End α} (hf : LocallyLipschitz f)
(hg : LocallyLipschitz g) : LocallyLipschitz (f * g : Function.End α) := hf.comp hg | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | mul_end | null |
protected pow_end {f : Function.End α} (h : LocallyLipschitz f) :
∀ n : ℕ, LocallyLipschitz (f ^ n : Function.End α)
| 0 => by simpa only [pow_zero] using LocallyLipschitz.id
| n + 1 => by
rw [pow_succ]
exact (h.pow_end n).mul_end h | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | pow_end | null |
protected continuousOn (hf : LocallyLipschitzOn s f) : ContinuousOn f s :=
continuousOn_iff_continuous_restrict.2 hf.restrict.continuous | lemma | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuousOn | null |
continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith [PseudoEMetricSpace α]
[TopologicalSpace β] [PseudoEMetricSpace γ] (f : α × β → γ) {s s' : Set α} {t : Set β}
(hs' : s' ⊆ s) (hss' : s ⊆ closure s') (K : ℝ≥0)
(ha : ∀ a ∈ s', ContinuousOn (fun y => f (a, y)) t)
(hb : ∀ b ∈ t, LipschitzOnWith K (fun x => f (x, b)) s) : ContinuousOn f (s ×ˢ t) := by
rintro ⟨x, y⟩ ⟨hx : x ∈ s, hy : y ∈ t⟩
refine EMetric.nhds_basis_closed_eball.tendsto_right_iff.2 fun ε (ε0 : 0 < ε) => ?_
replace ε0 : 0 < ε / 2 := ENNReal.half_pos ε0.ne'
obtain ⟨δ, δpos, hδ⟩ : ∃ δ : ℝ≥0, 0 < δ ∧ (δ : ℝ≥0∞) * ↑(3 * K) < ε / 2 :=
ENNReal.exists_nnreal_pos_mul_lt ENNReal.coe_ne_top ε0.ne'
rw [← ENNReal.coe_pos] at δpos
rcases EMetric.mem_closure_iff.1 (hss' hx) δ δpos with ⟨x', hx', hxx'⟩
have A : s ∩ EMetric.ball x δ ∈ 𝓝[s] x :=
inter_mem_nhdsWithin _ (EMetric.ball_mem_nhds _ δpos)
have B : t ∩ { b | edist (f (x', b)) (f (x', y)) ≤ ε / 2 } ∈ 𝓝[t] y :=
inter_mem self_mem_nhdsWithin (ha x' hx' y hy (EMetric.closedBall_mem_nhds (f (x', y)) ε0))
filter_upwards [nhdsWithin_prod A B] with ⟨a, b⟩ ⟨⟨has, hax⟩, ⟨hbt, hby⟩⟩
calc
edist (f (a, b)) (f (x, y)) ≤ edist (f (a, b)) (f (x', b)) + edist (f (x', b)) (f (x', y)) +
edist (f (x', y)) (f (x, y)) := edist_triangle4 _ _ _ _
_ ≤ K * (δ + δ) + ε / 2 + K * δ := by
gcongr
· refine (hb b hbt).edist_le_mul_of_le has (hs' hx') ?_
exact (edist_triangle _ _ _).trans (add_le_add (le_of_lt hax) hxx'.le)
· exact hby
· exact (hb y hy).edist_le_mul_of_le (hs' hx') hx ((edist_comm _ _).trans_le hxx'.le)
_ = δ * ↑(3 * K) + ε / 2 := by push_cast; ring
_ ≤ ε / 2 + ε / 2 := by gcongr
_ = ε := ENNReal.add_halves _ | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith | Consider a function `f : α × β → γ`. Suppose that it is continuous on each “vertical fiber”
`{a} × t`, `a ∈ s`, and is Lipschitz continuous on each “horizontal fiber” `s × {b}`, `b ∈ t`
with the same Lipschitz constant `K`. Then it is continuous on `s × t`. Moreover, it suffices
to require continuity on vertical fibers for `a` from a subset `s' ⊆ s` that is dense in `s`.
The actual statement uses (Lipschitz) continuity of `fun y ↦ f (a, y)` and `fun x ↦ f (x, b)`
instead of continuity of `f` on subsets of the product space. |
continuousOn_prod_of_continuousOn_lipschitzOnWith [PseudoEMetricSpace α]
[TopologicalSpace β] [PseudoEMetricSpace γ] (f : α × β → γ) {s : Set α} {t : Set β} (K : ℝ≥0)
(ha : ∀ a ∈ s, ContinuousOn (fun y => f (a, y)) t)
(hb : ∀ b ∈ t, LipschitzOnWith K (fun x => f (x, b)) s) : ContinuousOn f (s ×ˢ t) :=
continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith
f Subset.rfl subset_closure K ha hb | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuousOn_prod_of_continuousOn_lipschitzOnWith | Consider a function `f : α × β → γ`. Suppose that it is continuous on each “vertical fiber”
`{a} × t`, `a ∈ s`, and is Lipschitz continuous on each “horizontal fiber” `s × {b}`, `b ∈ t`
with the same Lipschitz constant `K`. Then it is continuous on `s × t`.
The actual statement uses (Lipschitz) continuity of `fun y ↦ f (a, y)` and `fun x ↦ f (x, b)`
instead of continuity of `f` on subsets of the product space. |
continuous_prod_of_dense_continuous_lipschitzWith [PseudoEMetricSpace α]
[TopologicalSpace β] [PseudoEMetricSpace γ] (f : α × β → γ) (K : ℝ≥0) {s : Set α}
(hs : Dense s) (ha : ∀ a ∈ s, Continuous fun y => f (a, y))
(hb : ∀ b, LipschitzWith K fun x => f (x, b)) : Continuous f := by
simp only [← continuousOn_univ, ← univ_prod_univ, ← lipschitzOnWith_univ] at *
exact continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith f (subset_univ _)
hs.closure_eq.ge K ha fun b _ => hb b | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuous_prod_of_dense_continuous_lipschitzWith | Consider a function `f : α × β → γ`. Suppose that it is continuous on each “vertical section”
`{a} × univ` for `a : α` from a dense set. Suppose that it is Lipschitz continuous on each
“horizontal section” `univ × {b}`, `b : β` with the same Lipschitz constant `K`. Then it is
continuous.
The actual statement uses (Lipschitz) continuity of `fun y ↦ f (a, y)` and `fun x ↦ f (x, b)`
instead of continuity of `f` on subsets of the product space. |
continuous_prod_of_continuous_lipschitzWith [PseudoEMetricSpace α] [TopologicalSpace β]
[PseudoEMetricSpace γ] (f : α × β → γ) (K : ℝ≥0) (ha : ∀ a, Continuous fun y => f (a, y))
(hb : ∀ b, LipschitzWith K fun x => f (x, b)) : Continuous f :=
continuous_prod_of_dense_continuous_lipschitzWith f K dense_univ (fun _ _ ↦ ha _) hb | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuous_prod_of_continuous_lipschitzWith | Consider a function `f : α × β → γ`. Suppose that it is continuous on each “vertical section”
`{a} × univ`, `a : α`, and is Lipschitz continuous on each “horizontal section”
`univ × {b}`, `b : β` with the same Lipschitz constant `K`. Then it is continuous.
The actual statement uses (Lipschitz) continuity of `fun y ↦ f (a, y)` and `fun x ↦ f (x, b)`
instead of continuity of `f` on subsets of the product space. |
continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith' [TopologicalSpace α]
[PseudoEMetricSpace β] [PseudoEMetricSpace γ] (f : α × β → γ) {s : Set α} {t t' : Set β}
(ht' : t' ⊆ t) (htt' : t ⊆ closure t') (K : ℝ≥0)
(ha : ∀ a ∈ s, LipschitzOnWith K (fun y => f (a, y)) t)
(hb : ∀ b ∈ t', ContinuousOn (fun x => f (x, b)) s) : ContinuousOn f (s ×ˢ t) :=
have : ContinuousOn (f ∘ Prod.swap) (t ×ˢ s) :=
continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith _ ht' htt' K hb ha
this.comp continuous_swap.continuousOn (mapsTo_swap_prod _ _) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith' | null |
continuousOn_prod_of_continuousOn_lipschitzOnWith' [TopologicalSpace α]
[PseudoEMetricSpace β] [PseudoEMetricSpace γ] (f : α × β → γ) {s : Set α} {t : Set β} (K : ℝ≥0)
(ha : ∀ a ∈ s, LipschitzOnWith K (fun y => f (a, y)) t)
(hb : ∀ b ∈ t, ContinuousOn (fun x => f (x, b)) s) : ContinuousOn f (s ×ˢ t) :=
have : ContinuousOn (f ∘ Prod.swap) (t ×ˢ s) :=
continuousOn_prod_of_continuousOn_lipschitzOnWith _ K hb ha
this.comp continuous_swap.continuousOn (mapsTo_swap_prod _ _) | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuousOn_prod_of_continuousOn_lipschitzOnWith' | null |
continuous_prod_of_dense_continuous_lipschitzWith' [TopologicalSpace α]
[PseudoEMetricSpace β] [PseudoEMetricSpace γ] (f : α × β → γ) (K : ℝ≥0) {t : Set β}
(ht : Dense t) (ha : ∀ a, LipschitzWith K fun y => f (a, y))
(hb : ∀ b ∈ t, Continuous fun x => f (x, b)) : Continuous f :=
have : Continuous (f ∘ Prod.swap) :=
continuous_prod_of_dense_continuous_lipschitzWith _ K ht hb ha
this.comp continuous_swap | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuous_prod_of_dense_continuous_lipschitzWith' | null |
continuous_prod_of_continuous_lipschitzWith' [TopologicalSpace α] [PseudoEMetricSpace β]
[PseudoEMetricSpace γ] (f : α × β → γ) (K : ℝ≥0) (ha : ∀ a, LipschitzWith K fun y => f (a, y))
(hb : ∀ b, Continuous fun x => f (x, b)) : Continuous f :=
have : Continuous (f ∘ Prod.swap) :=
continuous_prod_of_continuous_lipschitzWith _ K hb ha
this.comp continuous_swap | theorem | Topology | [
"Mathlib.Algebra.Group.End",
"Mathlib.Tactic.Finiteness",
"Mathlib.Topology.EMetricSpace.Diam"
] | Mathlib/Topology/EMetricSpace/Lipschitz.lean | continuous_prod_of_continuous_lipschitzWith' | null |
t4Space [EMetricSpace α] : T4Space α := inferInstance | theorem | Topology | [
"Mathlib.Tactic.GCongr",
"Mathlib.Topology.Compactness.Paracompact",
"Mathlib.Topology.EMetricSpace.Basic",
"Mathlib.SetTheory.Cardinal.Order"
] | Mathlib/Topology/EMetricSpace/Paracompact.lean | t4Space | null |
edist_pi_def [∀ b, EDist (X b)] (f g : ∀ b, X b) :
edist f g = Finset.sup univ fun b => edist (f b) (g b) :=
rfl | theorem | Topology | [
"Mathlib.Topology.EMetricSpace.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/EMetricSpace/Pi.lean | edist_pi_def | null |
edist_le_pi_edist [∀ b, EDist (X b)] (f g : ∀ b, X b) (b : β) :
edist (f b) (g b) ≤ edist f g :=
le_sup (f := fun b => edist (f b) (g b)) (Finset.mem_univ b) | theorem | Topology | [
"Mathlib.Topology.EMetricSpace.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/EMetricSpace/Pi.lean | edist_le_pi_edist | null |
edist_pi_le_iff [∀ b, EDist (X b)] {f g : ∀ b, X b} {d : ℝ≥0∞} :
edist f g ≤ d ↔ ∀ b, edist (f b) (g b) ≤ d :=
Finset.sup_le_iff.trans <| by simp only [Finset.mem_univ, forall_const] | theorem | Topology | [
"Mathlib.Topology.EMetricSpace.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/EMetricSpace/Pi.lean | edist_pi_le_iff | null |
edist_pi_const_le (a b : α) : (edist (fun _ : β => a) fun _ => b) ≤ edist a b :=
edist_pi_le_iff.2 fun _ => le_rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.EMetricSpace.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/EMetricSpace/Pi.lean | edist_pi_const_le | null |
edist_pi_const [Nonempty β] (a b : α) : (edist (fun _ : β => a) fun _ => b) = edist a b :=
Finset.sup_const univ_nonempty (edist a b) | theorem | Topology | [
"Mathlib.Topology.EMetricSpace.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/EMetricSpace/Pi.lean | edist_pi_const | null |
pseudoEMetricSpacePi [∀ b, PseudoEMetricSpace (X b)] : PseudoEMetricSpace (∀ b, X b) where
edist_self f := bot_unique <| Finset.sup_le <| by simp
edist_comm f g := by simp [edist_pi_def, edist_comm]
edist_triangle _ g _ := edist_pi_le_iff.2 fun b => le_trans (edist_triangle _ (g b) _)
(add_le_add (edist_le_pi_edist _ _ _) (edist_le_pi_edist _ _ _))
toUniformSpace := Pi.uniformSpace _
uniformity_edist := by
simp only [Pi.uniformity, PseudoEMetricSpace.uniformity_edist, comap_iInf, gt_iff_lt,
preimage_setOf_eq, comap_principal, edist_pi_def]
rw [iInf_comm]; congr; funext ε
rw [iInf_comm]; congr; funext εpos
simp [setOf_forall, εpos] | instance | Topology | [
"Mathlib.Topology.EMetricSpace.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/EMetricSpace/Pi.lean | pseudoEMetricSpacePi | The product of a finite number of pseudoemetric spaces, with the max distance, is still
a pseudoemetric space.
This construction would also work for infinite products, but it would not give rise
to the product topology. Hence, we only formalize it in the good situation of finitely many
spaces. |
emetricSpacePi [∀ b, EMetricSpace (X b)] : EMetricSpace (∀ b, X b) :=
.ofT0PseudoEMetricSpace _ | instance | Topology | [
"Mathlib.Topology.EMetricSpace.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/EMetricSpace/Pi.lean | emetricSpacePi | The product of a finite number of emetric spaces, with the max distance, is still
an emetric space.
This construction would also work for infinite products, but it would not give rise
to the product topology. Hence, we only formalize it in the good situation of finitely many
spaces. |
FiberBundle where
totalSpaceMk_isInducing' : ∀ b : B, IsInducing (@TotalSpace.mk B F E b)
trivializationAtlas' : Set (Trivialization F (π F E))
trivializationAt' : B → Trivialization F (π F E)
mem_baseSet_trivializationAt' : ∀ b : B, b ∈ (trivializationAt' b).baseSet
trivialization_mem_atlas' : ∀ b : B, trivializationAt' b ∈ trivializationAtlas' | class | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | FiberBundle | A (topological) fiber bundle with fiber `F` over a base `B` is a space projecting on `B`
for which the fibers are all homeomorphic to `F`, such that the local situation around each point
is a direct product. |
totalSpaceMk_isInducing : IsInducing (@TotalSpace.mk B F E b) := totalSpaceMk_isInducing' b | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | totalSpaceMk_isInducing | null |
trivializationAtlas : Set (Trivialization F (π F E)) := trivializationAtlas' | abbrev | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | trivializationAtlas | Atlas of a fiber bundle. |
trivializationAt : Trivialization F (π F E) := trivializationAt' b | abbrev | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | trivializationAt | Trivialization of a fiber bundle at a point. |
mem_baseSet_trivializationAt : b ∈ (trivializationAt F E b).baseSet :=
mem_baseSet_trivializationAt' b | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_baseSet_trivializationAt | null |
trivialization_mem_atlas : trivializationAt F E b ∈ trivializationAtlas F E :=
trivialization_mem_atlas' b | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | trivialization_mem_atlas | null |
@[mk_iff]
MemTrivializationAtlas [FiberBundle F E] (e : Trivialization F (π F E)) : Prop where
out : e ∈ trivializationAtlas F E | class | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | MemTrivializationAtlas | Given a type `E` equipped with a fiber bundle structure, this is a `Prop` typeclass
for trivializations of `E`, expressing that a trivialization is in the designated atlas for the
bundle. This is needed because lemmas about the linearity of trivializations or the continuity (as
functions to `F →L[R] F`, where `F` is the model fiber) of the transition functions are only
expected to hold for trivializations in the designated atlas. |
map_proj_nhds (x : TotalSpace F E) : map (π F E) (𝓝 x) = 𝓝 x.proj :=
(trivializationAt F E x.proj).map_proj_nhds <|
(trivializationAt F E x.proj).mem_source.2 <| mem_baseSet_trivializationAt F E x.proj
variable (E) | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | map_proj_nhds | null |
@[continuity]
continuous_proj : Continuous (π F E) :=
continuous_iff_continuousAt.2 fun x => (map_proj_nhds F x).le | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuous_proj | The projection from a fiber bundle to its base is continuous. |
isOpenMap_proj : IsOpenMap (π F E) :=
IsOpenMap.of_nhds_le fun x => (map_proj_nhds F x).ge | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | isOpenMap_proj | The projection from a fiber bundle to its base is an open map. |
surjective_proj [Nonempty F] : Function.Surjective (π F E) := fun b =>
let ⟨p, _, hpb⟩ :=
(trivializationAt F E b).proj_surjOn_baseSet (mem_baseSet_trivializationAt F E b)
⟨p, hpb⟩ | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | surjective_proj | The projection from a fiber bundle with a nonempty fiber to its base is a surjective
map. |
isQuotientMap_proj [Nonempty F] : IsQuotientMap (π F E) :=
(isOpenMap_proj F E).isQuotientMap (continuous_proj F E) (surjective_proj F E) | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | isQuotientMap_proj | The projection from a fiber bundle with a nonempty fiber to its base is a quotient
map. |
continuous_totalSpaceMk (x : B) : Continuous (@TotalSpace.mk B F E x) :=
(totalSpaceMk_isInducing F E x).continuous | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuous_totalSpaceMk | null |
totalSpaceMk_isEmbedding (x : B) : IsEmbedding (@TotalSpace.mk B F E x) :=
⟨totalSpaceMk_isInducing F E x, TotalSpace.mk_injective x⟩ | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | totalSpaceMk_isEmbedding | null |
totalSpaceMk_isClosedEmbedding [T1Space B] (x : B) :
IsClosedEmbedding (@TotalSpace.mk B F E x) :=
⟨totalSpaceMk_isEmbedding F E x, by
rw [TotalSpace.range_mk]
exact isClosed_singleton.preimage <| continuous_proj F E⟩
variable {E F}
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | totalSpaceMk_isClosedEmbedding | null |
mem_trivializationAt_proj_source {x : TotalSpace F E} :
x ∈ (trivializationAt F E x.proj).source :=
(Trivialization.mem_source _).mpr <| mem_baseSet_trivializationAt F E x.proj | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_trivializationAt_proj_source | null |
trivializationAt_proj_fst {x : TotalSpace F E} :
((trivializationAt F E x.proj) x).1 = x.proj :=
Trivialization.coe_fst' _ <| mem_baseSet_trivializationAt F E x.proj
variable (F)
open Trivialization | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | trivializationAt_proj_fst | null |
continuousWithinAt_totalSpace (f : X → TotalSpace F E) {s : Set X} {x₀ : X} :
ContinuousWithinAt f s x₀ ↔
ContinuousWithinAt (fun x => (f x).proj) s x₀ ∧
ContinuousWithinAt (fun x => ((trivializationAt F E (f x₀).proj) (f x)).2) s x₀ :=
(trivializationAt F E (f x₀).proj).tendsto_nhds_iff mem_trivializationAt_proj_source | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuousWithinAt_totalSpace | Characterization of continuous functions (at a point, within a set) into a fiber bundle. |
continuousAt_totalSpace (f : X → TotalSpace F E) {x₀ : X} :
ContinuousAt f x₀ ↔
ContinuousAt (fun x => (f x).proj) x₀ ∧
ContinuousAt (fun x => ((trivializationAt F E (f x₀).proj) (f x)).2) x₀ :=
(trivializationAt F E (f x₀).proj).tendsto_nhds_iff mem_trivializationAt_proj_source | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuousAt_totalSpace | Characterization of continuous functions (at a point) into a fiber bundle. |
FiberBundle.exists_trivialization_Icc_subset [ConditionallyCompleteLinearOrder B]
[OrderTopology B] [FiberBundle F E] (a b : B) :
∃ e : Trivialization F (π F E), Icc a b ⊆ e.baseSet := by
obtain ⟨ea, hea⟩ : ∃ ea : Trivialization F (π F E), a ∈ ea.baseSet :=
⟨trivializationAt F E a, mem_baseSet_trivializationAt F E a⟩
rcases lt_or_ge b a with _ | hab
· exact ⟨ea, by simp [*]⟩
/- Let `s` be the set of points `x ∈ [a, b]` such that `E` is trivializable over `[a, x]`.
We need to show that `b ∈ s`. Let `c = Sup s`. We will show that `c ∈ s` and `c = b`. -/
set s : Set B := { x ∈ Icc a b | ∃ e : Trivialization F (π F E), Icc a x ⊆ e.baseSet }
have ha : a ∈ s := ⟨left_mem_Icc.2 hab, ea, by simp [hea]⟩
have sne : s.Nonempty := ⟨a, ha⟩
have hsb : b ∈ upperBounds s := fun x hx => hx.1.2
have sbd : BddAbove s := ⟨b, hsb⟩
set c := sSup s
have hsc : IsLUB s c := isLUB_csSup sne sbd
have hc : c ∈ Icc a b := ⟨hsc.1 ha, hsc.2 hsb⟩
obtain ⟨-, ec : Trivialization F (π F E), hec : Icc a c ⊆ ec.baseSet⟩ : c ∈ s := by
rcases hc.1.eq_or_lt with heq | hlt
· rwa [← heq]
refine ⟨hc, ?_⟩
/- In order to show that `c ∈ s`, consider a trivialization `ec` of `proj` over a neighborhood
of `c`. Its base set includes `(c', c]` for some `c' ∈ [a, c)`. -/
obtain ⟨ec, hc⟩ : ∃ ec : Trivialization F (π F E), c ∈ ec.baseSet :=
⟨trivializationAt F E c, mem_baseSet_trivializationAt F E c⟩
obtain ⟨c', hc', hc'e⟩ : ∃ c' ∈ Ico a c, Ioc c' c ⊆ ec.baseSet :=
(mem_nhdsLE_iff_exists_mem_Ico_Ioc_subset hlt).1
(mem_nhdsWithin_of_mem_nhds <| IsOpen.mem_nhds ec.open_baseSet hc)
/- Since `c' < c = Sup s`, there exists `d ∈ s ∩ (c', c]`. Let `ead` be a trivialization of
`proj` over `[a, d]`. Then we can glue `ead` and `ec` into a trivialization over `[a, c]`. -/
obtain ⟨d, ⟨hdab, ead, had⟩, hd⟩ : ∃ d ∈ s, d ∈ Ioc c' c := hsc.exists_between hc'.2
refine ⟨ead.piecewiseLe ec d (had ⟨hdab.1, le_rfl⟩) (hc'e hd), subset_ite.2 ?_⟩
exact ⟨fun x hx => had ⟨hx.1.1, hx.2⟩, fun x hx => hc'e ⟨hd.1.trans (not_le.1 hx.2), hx.1.2⟩⟩
/- So, `c ∈ s`. Let `ec` be a trivialization of `proj` over `[a, c]`. If `c = b`, then we are
done. Otherwise we show that `proj` can be trivialized over a larger interval `[a, d]`,
`d ∈ (c, b]`, hence `c` is not an upper bound of `s`. -/
rcases hc.2.eq_or_lt with heq | hlt
· exact ⟨ec, heq ▸ hec⟩
rsuffices ⟨d, hdcb, hd⟩ : ∃ d ∈ Ioc c b, ∃ e : Trivialization F (π F E), Icc a d ⊆ e.baseSet
· exact ((hsc.1 ⟨⟨hc.1.trans hdcb.1.le, hdcb.2⟩, hd⟩).not_gt hdcb.1).elim
/- Since the base set of `ec` is open, it includes `[c, d)` (hence, `[a, d)`) for some
`d ∈ (c, b]`. -/
obtain ⟨d, hdcb, hd⟩ : ∃ d ∈ Ioc c b, Ico c d ⊆ ec.baseSet :=
(mem_nhdsGE_iff_exists_mem_Ioc_Ico_subset hlt).1
(mem_nhdsWithin_of_mem_nhds <| IsOpen.mem_nhds ec.open_baseSet (hec ⟨hc.1, le_rfl⟩))
have had : Ico a d ⊆ ec.baseSet := Ico_subset_Icc_union_Ico.trans (union_subset hec hd)
by_cases he : Disjoint (Iio d) (Ioi c)
· /- If `(c, d) = ∅`, then let `ed` be a trivialization of `proj` over a neighborhood of `d`.
Then the disjoint union of `ec` restricted to `(-∞, d)` and `ed` restricted to `(c, ∞)` is
a trivialization over `[a, d]`. -/
obtain ⟨ed, hed⟩ : ∃ ed : Trivialization F (π F E), d ∈ ed.baseSet :=
... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | FiberBundle.exists_trivialization_Icc_subset | If `E` is a fiber bundle over a conditionally complete linear order,
then it is trivial over any closed interval. |
FiberBundleCore (ι : Type*) (B : Type*) [TopologicalSpace B] (F : Type*)
[TopologicalSpace F] where
baseSet : ι → Set B
isOpen_baseSet : ∀ i, IsOpen (baseSet i)
indexAt : B → ι
mem_baseSet_at : ∀ x, x ∈ baseSet (indexAt x)
coordChange : ι → ι → B → F → F
coordChange_self : ∀ i, ∀ x ∈ baseSet i, ∀ v, coordChange i i x v = v
continuousOn_coordChange : ∀ i j,
ContinuousOn (fun p : B × F => coordChange i j p.1 p.2) ((baseSet i ∩ baseSet j) ×ˢ univ)
coordChange_comp : ∀ i j k, ∀ x ∈ baseSet i ∩ baseSet j ∩ baseSet k, ∀ v,
(coordChange j k x) (coordChange i j x v) = coordChange i k x v | structure | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | FiberBundleCore | Core data defining a locally trivial bundle with fiber `F` over a topological
space `B`. Note that "bundle" is used in its mathematical sense. This is the (computer science)
bundled version, i.e., all the relevant data is contained in the following structure. A family of
local trivializations is indexed by a type `ι`, on open subsets `baseSet i` for each `i : ι`.
Trivialization changes from `i` to `j` are given by continuous maps `coordChange i j` from
`baseSet i ∩ baseSet j` to the set of homeomorphisms of `F`, but we express them as maps
`B → F → F` and require continuity on `(baseSet i ∩ baseSet j) × F` to avoid the topology on the
space of continuous maps on `F`. |
@[nolint unusedArguments]
Index (_Z : FiberBundleCore ι B F) := ι | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | Index | The index set of a fiber bundle core, as a convenience function for dot notation |
@[nolint unusedArguments, reducible]
Base (_Z : FiberBundleCore ι B F) := B | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | Base | The base space of a fiber bundle core, as a convenience function for dot notation |
@[nolint unusedArguments]
Fiber (_ : FiberBundleCore ι B F) (_x : B) := F | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | Fiber | The fiber of a fiber bundle core, as a convenience function for dot notation and
typeclass inference |
topologicalSpaceFiber (x : B) : TopologicalSpace (Z.Fiber x) := ‹_› | instance | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | topologicalSpaceFiber | null |
TotalSpace := Bundle.TotalSpace F Z.Fiber | abbrev | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | TotalSpace | The total space of the fiber bundle, as a convenience function for dot notation.
It is by definition equal to `Bundle.TotalSpace F Z.Fiber`. |
@[reducible, simp, mfld_simps]
proj : Z.TotalSpace → B :=
Bundle.TotalSpace.proj | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | proj | The projection from the total space of a fiber bundle core, on its base. |
trivChange (i j : ι) : OpenPartialHomeomorph (B × F) (B × F) where
source := (Z.baseSet i ∩ Z.baseSet j) ×ˢ univ
target := (Z.baseSet i ∩ Z.baseSet j) ×ˢ univ
toFun p := ⟨p.1, Z.coordChange i j p.1 p.2⟩
invFun p := ⟨p.1, Z.coordChange j i p.1 p.2⟩
map_source' p hp := by simpa using hp
map_target' p hp := by simpa using hp
left_inv' := by
rintro ⟨x, v⟩ hx
simp only [prodMk_mem_set_prod_eq, mem_inter_iff, and_true, mem_univ] at hx
dsimp only
rw [coordChange_comp, Z.coordChange_self]
exacts [hx.1, ⟨⟨hx.1, hx.2⟩, hx.1⟩]
right_inv' := by
rintro ⟨x, v⟩ hx
simp only [prodMk_mem_set_prod_eq, mem_inter_iff, and_true, mem_univ] at hx
dsimp only
rw [Z.coordChange_comp, Z.coordChange_self]
· exact hx.2
· simp [hx]
open_source := ((Z.isOpen_baseSet i).inter (Z.isOpen_baseSet j)).prod isOpen_univ
open_target := ((Z.isOpen_baseSet i).inter (Z.isOpen_baseSet j)).prod isOpen_univ
continuousOn_toFun := continuous_fst.continuousOn.prodMk (Z.continuousOn_coordChange i j)
continuousOn_invFun := by
simpa [inter_comm] using continuous_fst.continuousOn.prodMk (Z.continuousOn_coordChange j i)
@[simp, mfld_simps] | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | trivChange | Local homeomorphism version of the trivialization change. |
mem_trivChange_source (i j : ι) (p : B × F) :
p ∈ (Z.trivChange i j).source ↔ p.1 ∈ Z.baseSet i ∩ Z.baseSet j := by
rw [trivChange, mem_prod]
simp | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_trivChange_source | null |
localTrivAsPartialEquiv (i : ι) : PartialEquiv Z.TotalSpace (B × F) where
source := Z.proj ⁻¹' Z.baseSet i
target := Z.baseSet i ×ˢ univ
invFun p := ⟨p.1, Z.coordChange i (Z.indexAt p.1) p.1 p.2⟩
toFun p := ⟨p.1, Z.coordChange (Z.indexAt p.1) i p.1 p.2⟩
map_source' p hp := by
simpa only [Set.mem_preimage, and_true, Set.mem_univ, Set.prodMk_mem_set_prod_eq] using hp
map_target' p hp := by
simpa only [Set.mem_preimage, and_true, Set.mem_univ, Set.mem_prod] using hp
left_inv' := by
rintro ⟨x, v⟩ hx
replace hx : x ∈ Z.baseSet i := hx
dsimp only
rw [Z.coordChange_comp, Z.coordChange_self] <;> apply_rules [mem_baseSet_at, mem_inter]
right_inv' := by
rintro ⟨x, v⟩ hx
simp only [prodMk_mem_set_prod_eq, and_true, mem_univ] at hx
dsimp only
rw [Z.coordChange_comp, Z.coordChange_self]
exacts [hx, ⟨⟨hx, Z.mem_baseSet_at _⟩, hx⟩]
variable (i : ι) | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAsPartialEquiv | Associate to a trivialization index `i : ι` the corresponding trivialization, i.e., a bijection
between `proj ⁻¹ (baseSet i)` and `baseSet i × F`. As the fiber above `x` is `F` but read in the
chart with index `index_at x`, the trivialization in the fiber above x is by definition the
coordinate change from i to `index_at x`, so it depends on `x`.
The local trivialization will ultimately be an open partial homeomorphism. For now, we only
introduce the partial equivalence version, denoted with a prime.
In further developments, avoid this auxiliary version, and use `Z.local_triv` instead. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.