File: Mathlib/Topology/MetricSpace/Lipschitz.lean

full_name: lipschitzWith_iff_dist_le_mul
code: theorem lipschitzWith_iff_dist_le_mul [PseudoMetricSpace α] [PseudoMetricSpace β] {K : ℝ≥0}
    {f : α → β} : LipschitzWith K f ↔ ∀ x y, dist (f x) (f y) ≤ K * dist x y 
goal: LipschitzWith K f ↔ ∀ (x y : α), dist (f x) (f y) ≤ ↑K * dist x y

full_name: lipschitzOnWith_iff_dist_le_mul
code: theorem lipschitzOnWith_iff_dist_le_mul [PseudoMetricSpace α] [PseudoMetricSpace β] {K : ℝ≥0}
    {s : Set α} {f : α → β} :
    LipschitzOnWith K f s ↔ ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ K * dist x y 
goal: LipschitzOnWith K f s ↔ ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ ↑K * dist x y

full_name: LipschitzWith.of_dist_le'
code: protected theorem of_dist_le' {K : ℝ} (h : ∀ x y, dist (f x) (f y) ≤ K * dist x y) :
    LipschitzWith (Real.toNNReal K) f 
goal: LipschitzWith K.toNNReal f

full_name: LipschitzWith.mk_one
code: protected theorem mk_one (h : ∀ x y, dist (f x) (f y) ≤ dist x y) : LipschitzWith 1 f 
goal: LipschitzWith 1 f

full_name: LipschitzWith.of_le_add_mul'
code: /-- For functions to `ℝ`, it suffices to prove `f x ≤ f y + K * dist x y`; this version
doesn't assume `0≤K`. -/
protected theorem of_le_add_mul' {f : α → ℝ} (K : ℝ) (h : ∀ x y, f x ≤ f y + K * dist x y) :
    LipschitzWith (Real.toNNReal K) f 
goal: LipschitzWith K.toNNReal f

full_name: LipschitzWith.of_le_add_mul
code: /-- For functions to `ℝ`, it suffices to prove `f x ≤ f y + K * dist x y`; this version
assumes `0≤K`. -/
protected theorem of_le_add_mul {f : α → ℝ} (K : ℝ≥0) (h : ∀ x y, f x ≤ f y + K * dist x y) :
    LipschitzWith K f 
goal: LipschitzWith K f

full_name: LipschitzWith.of_le_add
code: protected theorem of_le_add {f : α → ℝ} (h : ∀ x y, f x ≤ f y + dist x y) : LipschitzWith 1 f 
goal: LipschitzWith 1 f

full_name: LipschitzWith.le_add_mul
code: protected theorem le_add_mul {f : α → ℝ} {K : ℝ≥0} (h : LipschitzWith K f) (x y) :
    f x ≤ f y + K * dist x y 
goal: f x ≤ f y + ↑K * dist x y

full_name: LipschitzWith.iff_le_add_mul
code: protected theorem iff_le_add_mul {f : α → ℝ} {K : ℝ≥0} :
    LipschitzWith K f ↔ ∀ x y, f x ≤ f y + K * dist x y 
goal: LipschitzWith K f ↔ ∀ (x y : α), f x ≤ f y + ↑K * dist x y

full_name: LipschitzWith.nndist_le
code: theorem nndist_le (hf : LipschitzWith K f) (x y : α) : nndist (f x) (f y) ≤ K * nndist x y 
goal: nndist (f x) (f y) ≤ K * nndist x y

full_name: LipschitzWith.dist_le_mul_of_le
code: theorem dist_le_mul_of_le (hf : LipschitzWith K f) (hr : dist x y ≤ r) : dist (f x) (f y) ≤ K * r 
goal: dist (f x) (f y) ≤ ↑K * r

full_name: LipschitzWith.mapsTo_closedBall
code: theorem mapsTo_closedBall (hf : LipschitzWith K f) (x : α) (r : ℝ) :
    MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) (K * r)) 
goal: Set.MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) (↑K * r))

full_name: LipschitzWith.dist_lt_mul_of_lt
code: theorem dist_lt_mul_of_lt (hf : LipschitzWith K f) (hK : K ≠ 0) (hr : dist x y < r) :
    dist (f x) (f y) < K * r 
goal: dist (f x) (f y) < ↑K * r

full_name: LipschitzWith.mapsTo_ball
code: theorem mapsTo_ball (hf : LipschitzWith K f) (hK : K ≠ 0) (x : α) (r : ℝ) :
    MapsTo f (Metric.ball x r) (Metric.ball (f x) (K * r)) 
goal: Set.MapsTo f (Metric.ball x r) (Metric.ball (f x) (↑K * r))

full_name: LipschitzWith.toLocallyBoundedMap
code: /-- A Lipschitz continuous map is a locally bounded map. -/
def toLocallyBoundedMap (f : α → β) (hf : LipschitzWith K f) : LocallyBoundedMap α β 
goal: LocallyBoundedMap α β

full_name: LipschitzWith.coe_toLocallyBoundedMap
code: @[simp]
theorem coe_toLocallyBoundedMap (hf : LipschitzWith K f) : ⇑(hf.toLocallyBoundedMap f) = f 
goal: ⇑(LipschitzWith.toLocallyBoundedMap f hf) = f

full_name: LipschitzWith.comap_cobounded_le
code: theorem comap_cobounded_le (hf : LipschitzWith K f) :
    comap f (Bornology.cobounded β) ≤ Bornology.cobounded α 
goal: Filter.comap f (Bornology.cobounded β) ≤ Bornology.cobounded α

full_name: LipschitzWith.isBounded_image
code: /-- The image of a bounded set under a Lipschitz map is bounded. -/
theorem isBounded_image (hf : LipschitzWith K f) {s : Set α} (hs : IsBounded s) :
    IsBounded (f '' s) 
goal: Bornology.IsBounded (f '' s)

full_name: LipschitzWith.diam_image_le
code: theorem diam_image_le (hf : LipschitzWith K f) (s : Set α) (hs : IsBounded s) :
    Metric.diam (f '' s) ≤ K * Metric.diam s 
goal: Metric.diam (f '' s) ≤ ↑K * Metric.diam s

full_name: LipschitzWith.dist_left
code: protected theorem dist_left (y : α) : LipschitzWith 1 (dist · y) 
goal: LipschitzWith 1 fun x => dist x y

full_name: LipschitzWith.dist_right
code: protected theorem dist_right (x : α) : LipschitzWith 1 (dist x) 
goal: LipschitzWith 1 (dist x)

full_name: LipschitzWith.dist
code: protected theorem dist : LipschitzWith 2 (Function.uncurry <| @dist α _) 
goal: LipschitzWith 2 (Function.uncurry dist)

full_name: LipschitzWith.dist_iterate_succ_le_geometric
code: theorem dist_iterate_succ_le_geometric {f : α → α} (hf : LipschitzWith K f) (x n) :
    dist (f^[n] x) (f^[n + 1] x) ≤ dist x (f x) * (K : ℝ) ^ n 
goal: dist (f^[n] x) (f^[n + 1] x) ≤ dist x (f x) * ↑K ^ n

full_name: lipschitzWith_max
code: theorem _root_.lipschitzWith_max : LipschitzWith 1 fun p : ℝ × ℝ => max p.1 p.2 
goal: LipschitzWith 1 fun p => max p.1 p.2

full_name: lipschitzWith_min
code: theorem _root_.lipschitzWith_min : LipschitzWith 1 fun p : ℝ × ℝ => min p.1 p.2 
goal: LipschitzWith 1 fun p => min p.1 p.2

full_name: Real.lipschitzWith_toNNReal
code: lemma _root_.Real.lipschitzWith_toNNReal : LipschitzWith 1 Real.toNNReal 
goal: LipschitzWith 1 Real.toNNReal

full_name: LipschitzWith.cauchySeq_comp
code: lemma cauchySeq_comp (hf : LipschitzWith K f) {u : ℕ → α} (hu : CauchySeq u) :
    CauchySeq (f ∘ u) 
goal: CauchySeq (f ∘ u)

full_name: LipschitzWith.max
code: protected theorem max (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
    LipschitzWith (max Kf Kg) fun x => max (f x) (g x) 
goal: LipschitzWith (max Kf Kg) fun x => max (f x) (g x)

full_name: LipschitzWith.min
code: protected theorem min (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
    LipschitzWith (max Kf Kg) fun x => min (f x) (g x) 
goal: LipschitzWith (max Kf Kg) fun x => min (f x) (g x)

full_name: LipschitzWith.max_const
code: theorem max_const (hf : LipschitzWith Kf f) (a : ℝ) : LipschitzWith Kf fun x => max (f x) a 
goal: LipschitzWith Kf fun x => max (f x) a

full_name: LipschitzWith.const_max
code: theorem const_max (hf : LipschitzWith Kf f) (a : ℝ) : LipschitzWith Kf fun x => max a (f x) 
goal: LipschitzWith Kf fun x => max a (f x)

full_name: LipschitzWith.min_const
code: theorem min_const (hf : LipschitzWith Kf f) (a : ℝ) : LipschitzWith Kf fun x => min (f x) a 
goal: LipschitzWith Kf fun x => min (f x) a

full_name: LipschitzWith.const_min
code: theorem const_min (hf : LipschitzWith Kf f) (a : ℝ) : LipschitzWith Kf fun x => min a (f x) 
goal: LipschitzWith Kf fun x => min a (f x)

full_name: LipschitzWith.projIcc
code: protected theorem projIcc {a b : ℝ} (h : a ≤ b) : LipschitzWith 1 (projIcc a b h) 
goal: LipschitzWith 1 (Set.projIcc a b h)

full_name: LipschitzOnWith.of_dist_le'
code: protected theorem of_dist_le' {K : ℝ} (h : ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ K * dist x y) :
    LipschitzOnWith (Real.toNNReal K) f s 
goal: LipschitzOnWith K.toNNReal f s

full_name: LipschitzOnWith.mk_one
code: protected theorem mk_one (h : ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ dist x y) :
    LipschitzOnWith 1 f s 
goal: LipschitzOnWith 1 f s

full_name: LipschitzOnWith.of_le_add_mul'
code: /-- For functions to `ℝ`, it suffices to prove `f x ≤ f y + K * dist x y`; this version
doesn't assume `0≤K`. -/
protected theorem of_le_add_mul' {f : α → ℝ} (K : ℝ)
    (h : ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + K * dist x y) : LipschitzOnWith (Real.toNNReal K) f s 
goal: LipschitzOnWith K.toNNReal f s

full_name: LipschitzOnWith.of_le_add_mul
code: /-- For functions to `ℝ`, it suffices to prove `f x ≤ f y + K * dist x y`; this version
assumes `0≤K`. -/
protected theorem of_le_add_mul {f : α → ℝ} (K : ℝ≥0)
    (h : ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + K * dist x y) : LipschitzOnWith K f s 
goal: LipschitzOnWith K f s

full_name: LipschitzOnWith.of_le_add
code: protected theorem of_le_add {f : α → ℝ} (h : ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + dist x y) :
    LipschitzOnWith 1 f s 
goal: LipschitzOnWith 1 f s

full_name: LipschitzOnWith.le_add_mul
code: protected theorem le_add_mul {f : α → ℝ} {K : ℝ≥0} (h : LipschitzOnWith K f s) {x : α} (hx : x ∈ s)
    {y : α} (hy : y ∈ s) : f x ≤ f y + K * dist x y 
goal: f x ≤ f y + ↑K * dist x y

full_name: LipschitzOnWith.iff_le_add_mul
code: protected theorem iff_le_add_mul {f : α → ℝ} {K : ℝ≥0} :
    LipschitzOnWith K f s ↔ ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + K * dist x y 
goal: LipschitzOnWith K f s ↔ ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + ↑K * dist x y

full_name: LipschitzOnWith.isBounded_image2
code: theorem isBounded_image2 (f : α → β → γ) {K₁ K₂ : ℝ≥0} {s : Set α} {t : Set β}
    (hs : Bornology.IsBounded s) (ht : Bornology.IsBounded t)
    (hf₁ : ∀ b ∈ t, LipschitzOnWith K₁ (fun a => f a b) s)
    (hf₂ : ∀ a ∈ s, LipschitzOnWith K₂ (f a) t) : Bornology.IsBounded (Set.image2 f s t) 
goal: Bornology.IsBounded (Set.image2 f s t)

full_name: LipschitzOnWith.cauchySeq_comp
code: lemma cauchySeq_comp (hf : LipschitzOnWith K f s)
    {u : ℕ → α} (hu : CauchySeq u) (h'u : range u ⊆ s) :
    CauchySeq (f ∘ u) 
goal: CauchySeq (f ∘ u)

full_name: LocallyLipschitz.min
code: /-- The minimum of locally Lipschitz functions is locally Lipschitz. -/
protected lemma min (hf : LocallyLipschitz f) (hg : LocallyLipschitz g) :
    LocallyLipschitz (fun x => min (f x) (g x)) 
goal: LocallyLipschitz fun x => min (f x) (g x)

full_name: LocallyLipschitz.max
code: /-- The maximum of locally Lipschitz functions is locally Lipschitz. -/
protected lemma max (hf : LocallyLipschitz f) (hg : LocallyLipschitz g) :
    LocallyLipschitz (fun x => max (f x) (g x)) 
goal: LocallyLipschitz fun x => max (f x) (g x)

full_name: LocallyLipschitz.max_const
code: theorem max_const (hf : LocallyLipschitz f) (a : ℝ) : LocallyLipschitz fun x => max (f x) a 
goal: LocallyLipschitz fun x => max (f x) a

full_name: LocallyLipschitz.const_max
code: theorem const_max (hf : LocallyLipschitz f) (a : ℝ) : LocallyLipschitz fun x => max a (f x) 
goal: LocallyLipschitz fun x => max a (f x)

full_name: LocallyLipschitz.min_const
code: theorem min_const (hf : LocallyLipschitz f) (a : ℝ) : LocallyLipschitz fun x => min (f x) a 
goal: LocallyLipschitz fun x => min (f x) a

full_name: LocallyLipschitz.const_min
code: theorem const_min (hf : LocallyLipschitz f) (a : ℝ) : LocallyLipschitz fun x => min a (f x) 
goal: LocallyLipschitz fun x => min a (f x)

full_name: continuousAt_of_locally_lipschitz
code: /-- If a function is locally Lipschitz around a point, then it is continuous at this point. -/
theorem continuousAt_of_locally_lipschitz {x : α} {r : ℝ} (hr : 0 < r) (K : ℝ)
    (h : ∀ y, dist y x < r → dist (f y) (f x) ≤ K * dist y x) : ContinuousAt f x 
goal: ContinuousAt f x

full_name: LipschitzOnWith.extend_real
code: /-- A function `f : α → ℝ` which is `K`-Lipschitz on a subset `s` admits a `K`-Lipschitz extension
to the whole space. -/
theorem LipschitzOnWith.extend_real {f : α → ℝ} {s : Set α} {K : ℝ≥0} (hf : LipschitzOnWith K f s) :
    ∃ g : α → ℝ, LipschitzWith K g ∧ EqOn f g s 
goal: ∃ g, LipschitzWith K g ∧ Set.EqOn f g s

full_name: LipschitzOnWith.extend_pi
code: /-- A function `f : α → (ι → ℝ)` which is `K`-Lipschitz on a subset `s` admits a `K`-Lipschitz
extension to the whole space. The same result for the space `ℓ^∞ (ι, ℝ)` over a possibly infinite
type `ι` is implemented in `LipschitzOnWith.extend_lp_infty`. -/
theorem LipschitzOnWith.extend_pi [Fintype ι] {f : α → ι → ℝ} {s : Set α}
    {K : ℝ≥0} (hf : LipschitzOnWith K f s) : ∃ g : α → ι → ℝ, LipschitzWith K g ∧ EqOn f g s 
goal: ∃ g, LipschitzWith K g ∧ Set.EqOn f g s