File: Mathlib/Analysis/Calculus/InverseFunctionTheorem/ApproximatesLinearOn.lean

full_name: ApproximatesLinearOn
code: /-- We say that `f` approximates a continuous linear map `f'` on `s` with constant `c`,
if `‖f x - f y - f' (x - y)‖ ≤ c * ‖x - y‖` whenever `x, y ∈ s`.

This predicate is defined to facilitate the splitting of the inverse function theorem into small
lemmas. Some of these lemmas can be useful, e.g., to prove that the inverse function is defined
on a specific set. -/
def ApproximatesLinearOn (f : E → F) (f' : E →L[𝕜] F) (s : Set E) (c : ℝ≥0) : Prop 
goal: Prop

full_name: approximatesLinearOn_empty
code: @[simp]
theorem approximatesLinearOn_empty (f : E → F) (f' : E →L[𝕜] F) (c : ℝ≥0) :
    ApproximatesLinearOn f f' ∅ c 
goal: ApproximatesLinearOn f f' ∅ c

full_name: ApproximatesLinearOn.mono_num
code: theorem mono_num (hc : c ≤ c') (hf : ApproximatesLinearOn f f' s c) :
    ApproximatesLinearOn f f' s c' 
goal: ApproximatesLinearOn f f' s c'

full_name: ApproximatesLinearOn.mono_set
code: theorem mono_set (hst : s ⊆ t) (hf : ApproximatesLinearOn f f' t c) :
    ApproximatesLinearOn f f' s c 
goal: ApproximatesLinearOn f f' s c

full_name: ApproximatesLinearOn.approximatesLinearOn_iff_lipschitzOnWith
code: theorem approximatesLinearOn_iff_lipschitzOnWith {f : E → F} {f' : E →L[𝕜] F} {s : Set E}
    {c : ℝ≥0} : ApproximatesLinearOn f f' s c ↔ LipschitzOnWith c (f - ⇑f') s 
goal: ApproximatesLinearOn f f' s c ↔ LipschitzOnWith c (f - ⇑f') s

full_name: ApproximatesLinearOn.lipschitz_sub
code: theorem lipschitz_sub (hf : ApproximatesLinearOn f f' s c) :
    LipschitzWith c fun x : s => f x - f' x 
goal: LipschitzWith c fun x => f ↑x - f' ↑x

full_name: ApproximatesLinearOn.lipschitz
code: protected theorem lipschitz (hf : ApproximatesLinearOn f f' s c) :
    LipschitzWith (‖f'‖₊ + c) (s.restrict f) 
goal: LipschitzWith (‖f'‖₊ + c) (s.restrict f)

full_name: ApproximatesLinearOn.continuous
code: protected theorem continuous (hf : ApproximatesLinearOn f f' s c) : Continuous (s.restrict f) 
goal: Continuous (s.restrict f)

full_name: ApproximatesLinearOn.continuousOn
code: protected theorem continuousOn (hf : ApproximatesLinearOn f f' s c) : ContinuousOn f s 
goal: ContinuousOn f s

full_name: ApproximatesLinearOn.surjOn_closedBall_of_nonlinearRightInverse
code: /-- If a function is linearly approximated by a continuous linear map with a (possibly nonlinear)
right inverse, then it is locally onto: a ball of an explicit radius is included in the image
of the map. -/
theorem surjOn_closedBall_of_nonlinearRightInverse (hf : ApproximatesLinearOn f f' s c)
    (f'symm : f'.NonlinearRightInverse) {ε : ℝ} {b : E} (ε0 : 0 ≤ ε) (hε : closedBall b ε ⊆ s) :
    SurjOn f (closedBall b ε) (closedBall (f b) (((f'symm.nnnorm : ℝ)⁻¹ - c) * ε)) 
goal: Set.SurjOn f (Metric.closedBall b ε) (Metric.closedBall (f b) (((↑f'symm.nnnorm)⁻¹ - ↑c) * ε))

full_name: ApproximatesLinearOn.open_image
code: theorem open_image (hf : ApproximatesLinearOn f f' s c) (f'symm : f'.NonlinearRightInverse)
    (hs : IsOpen s) (hc : Subsingleton F ∨ c < f'symm.nnnorm⁻¹) : IsOpen (f '' s) 
goal: IsOpen (f '' s)

full_name: ApproximatesLinearOn.image_mem_nhds
code: theorem image_mem_nhds (hf : ApproximatesLinearOn f f' s c) (f'symm : f'.NonlinearRightInverse)
    {x : E} (hs : s ∈ 𝓝 x) (hc : Subsingleton F ∨ c < f'symm.nnnorm⁻¹) : f '' s ∈ 𝓝 (f x) 
goal: f '' s ∈ 𝓝 (f x)

full_name: ApproximatesLinearOn.map_nhds_eq
code: theorem map_nhds_eq (hf : ApproximatesLinearOn f f' s c) (f'symm : f'.NonlinearRightInverse) {x : E}
    (hs : s ∈ 𝓝 x) (hc : Subsingleton F ∨ c < f'symm.nnnorm⁻¹) : map f (𝓝 x) = 𝓝 (f x) 
goal: Filter.map f (𝓝 x) = 𝓝 (f x)

full_name: ApproximatesLinearOn._aux_Mathlib_Analysis_Calculus_InverseFunctionTheorem_ApproximatesLinearOn___macroRules_ApproximatesLinearOn_termN_1
code: local notation "N" => ‖(f'.symm : F →L[𝕜] E)‖₊
goal: Lean.Macro

full_name: ApproximatesLinearOn.antilipschitz
code: protected theorem antilipschitz (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) : AntilipschitzWith (N⁻¹ - c)⁻¹ (s.restrict f) 
goal: AntilipschitzWith (‖↑f'.symm‖₊⁻¹ - c)⁻¹ (s.restrict f)

full_name: ApproximatesLinearOn.injective
code: protected theorem injective (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) : Injective (s.restrict f) 
goal: Function.Injective (s.restrict f)

full_name: ApproximatesLinearOn.injOn
code: protected theorem injOn (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) : InjOn f s 
goal: Set.InjOn f s

full_name: ApproximatesLinearOn.surjective
code: protected theorem surjective [CompleteSpace E] (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) univ c)
    (hc : Subsingleton E ∨ c < N⁻¹) : Surjective f 
goal: Function.Surjective f

full_name: ApproximatesLinearOn.toPartialEquiv
code: /-- A map approximating a linear equivalence on a set defines a partial equivalence on this set.
Should not be used outside of this file, because it is superseded by `toPartialHomeomorph` below.

This is a first step towards the inverse function. -/
def toPartialEquiv (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) : PartialEquiv E F 
goal: PartialEquiv E F

full_name: ApproximatesLinearOn.inverse_continuousOn
code: /-- The inverse function is continuous on `f '' s`.
Use properties of `PartialHomeomorph` instead. -/
theorem inverse_continuousOn (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) : ContinuousOn (hf.toPartialEquiv hc).symm (f '' s) 
goal: ContinuousOn (↑(hf.toPartialEquiv hc).symm) (f '' s)

full_name: ApproximatesLinearOn.to_inv
code: /-- The inverse function is approximated linearly on `f '' s` by `f'.symm`. -/
theorem to_inv (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c) (hc : Subsingleton E ∨ c < N⁻¹) :
    ApproximatesLinearOn (hf.toPartialEquiv hc).symm (f'.symm : F →L[𝕜] E) (f '' s)
      (N * (N⁻¹ - c)⁻¹ * c) 
goal: ApproximatesLinearOn (↑(hf.toPartialEquiv hc).symm) (↑f'.symm) (f '' s) (‖↑f'.symm‖₊ * (‖↑f'.symm‖₊⁻¹ - c)⁻¹ * c)

full_name: ApproximatesLinearOn.toPartialHomeomorph
code: /-- Given a function `f` that approximates a linear equivalence on an open set `s`,
returns a partial homeomorphism with `toFun = f` and `source = s`. -/
def toPartialHomeomorph (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) (hs : IsOpen s) : PartialHomeomorph E F 
goal: PartialHomeomorph E F

full_name: ApproximatesLinearOn.toPartialHomeomorph_coe
code: @[simp]
theorem toPartialHomeomorph_coe (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) (hs : IsOpen s) :
    (hf.toPartialHomeomorph f s hc hs : E → F) = f 
goal: ↑(ApproximatesLinearOn.toPartialHomeomorph f s hf hc hs) = f

full_name: ApproximatesLinearOn.toPartialHomeomorph_source
code: @[simp]
theorem toPartialHomeomorph_source (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) (hs : IsOpen s) :
    (hf.toPartialHomeomorph f s hc hs).source = s 
goal: (ApproximatesLinearOn.toPartialHomeomorph f s hf hc hs).source = s

full_name: ApproximatesLinearOn.toPartialHomeomorph_target
code: @[simp]
theorem toPartialHomeomorph_target (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) (hs : IsOpen s) :
    (hf.toPartialHomeomorph f s hc hs).target = f '' s 
goal: (ApproximatesLinearOn.toPartialHomeomorph f s hf hc hs).target = f '' s

full_name: ApproximatesLinearOn.toHomeomorph
code: /-- A function `f` that approximates a linear equivalence on the whole space is a homeomorphism. -/
def toHomeomorph (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) univ c)
    (hc : Subsingleton E ∨ c < N⁻¹) : E ≃ₜ F 
goal: E ≃ₜ F

full_name: ApproximatesLinearOn.closedBall_subset_target
code: theorem closedBall_subset_target (hf : ApproximatesLinearOn f (f' : E →L[𝕜] F) s c)
    (hc : Subsingleton E ∨ c < N⁻¹) (hs : IsOpen s) {b : E} (ε0 : 0 ≤ ε) (hε : closedBall b ε ⊆ s) :
    closedBall (f b) ((N⁻¹ - c) * ε) ⊆ (hf.toPartialHomeomorph f s hc hs).target 
goal: Metric.closedBall (f b) ((↑‖↑f'.symm‖₊⁻¹ - ↑c) * ε) ⊆ (ApproximatesLinearOn.toPartialHomeomorph f s hf hc hs).target