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

full_name: HasStrictFDerivAt.approximates_deriv_on_nhds
code: /-- If `f` has derivative `f'` at `a` in the strict sense and `c > 0`, then `f` approximates `f'`
with constant `c` on some neighborhood of `a`. -/
theorem approximates_deriv_on_nhds {f : E → F} {f' : E →L[𝕜] F} {a : E}
    (hf : HasStrictFDerivAt f f' a) {c : ℝ≥0} (hc : Subsingleton E ∨ 0 < c) :
    ∃ s ∈ 𝓝 a, ApproximatesLinearOn f f' s c 
goal: ∃ s ∈ 𝓝 a, ApproximatesLinearOn f f' s c

full_name: HasStrictFDerivAt.map_nhds_eq_of_surj
code: theorem map_nhds_eq_of_surj [CompleteSpace E] [CompleteSpace F] {f : E → F} {f' : E →L[𝕜] F} {a : E}
    (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) (h : LinearMap.range f' = ⊤) :
    map f (𝓝 a) = 𝓝 (f a) 
goal: Filter.map f (𝓝 a) = 𝓝 (f a)

full_name: HasStrictFDerivAt.approximates_deriv_on_open_nhds
code: theorem approximates_deriv_on_open_nhds (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    ∃ s : Set E, a ∈ s ∧ IsOpen s ∧
      ApproximatesLinearOn f (f' : E →L[𝕜] F) s (‖(f'.symm : F →L[𝕜] E)‖₊⁻¹ / 2) 
goal: ∃ s, a ∈ s ∧ IsOpen s ∧ ApproximatesLinearOn f (↑f') s (‖↑f'.symm‖₊⁻¹ / 2)

full_name: HasStrictFDerivAt.toPartialHomeomorph
code: /-- Given a function with an invertible strict derivative at `a`, returns a `PartialHomeomorph`
with `to_fun = f` and `a ∈ source`. This is a part of the inverse function theorem.
The other part `HasStrictFDerivAt.to_localInverse` states that the inverse function
of this `PartialHomeomorph` has derivative `f'.symm`. -/
def toPartialHomeomorph (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) : PartialHomeomorph E F 
goal: PartialHomeomorph E F

full_name: HasStrictFDerivAt.toPartialHomeomorph_coe
code: @[simp]
theorem toPartialHomeomorph_coe (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    (hf.toPartialHomeomorph f : E → F) = f 
goal: ↑(HasStrictFDerivAt.toPartialHomeomorph f hf) = f

full_name: HasStrictFDerivAt.mem_toPartialHomeomorph_source
code: theorem mem_toPartialHomeomorph_source (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    a ∈ (hf.toPartialHomeomorph f).source 
goal: a ∈ (HasStrictFDerivAt.toPartialHomeomorph f hf).source

full_name: HasStrictFDerivAt.image_mem_toPartialHomeomorph_target
code: theorem image_mem_toPartialHomeomorph_target (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    f a ∈ (hf.toPartialHomeomorph f).target 
goal: f a ∈ (HasStrictFDerivAt.toPartialHomeomorph f hf).target

full_name: HasStrictFDerivAt.map_nhds_eq_of_equiv
code: theorem map_nhds_eq_of_equiv (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    map f (𝓝 a) = 𝓝 (f a) 
goal: Filter.map f (𝓝 a) = 𝓝 (f a)

full_name: HasStrictFDerivAt.localInverse
code: /-- Given a function `f` with an invertible derivative, returns a function that is locally inverse
to `f`. -/
def localInverse (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) : F → E 
goal: F → E

full_name: HasStrictFDerivAt.localInverse_def
code: theorem localInverse_def (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    hf.localInverse f _ _ = (hf.toPartialHomeomorph f).symm 
goal: HasStrictFDerivAt.localInverse f f' a hf = ↑(HasStrictFDerivAt.toPartialHomeomorph f hf).symm

full_name: HasStrictFDerivAt.eventually_left_inverse
code: theorem eventually_left_inverse (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    ∀ᶠ x in 𝓝 a, hf.localInverse f f' a (f x) = x 
goal: ∀ᶠ (x : E) in 𝓝 a, HasStrictFDerivAt.localInverse f f' a hf (f x) = x

full_name: HasStrictFDerivAt.localInverse_apply_image
code: @[simp]
theorem localInverse_apply_image (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    hf.localInverse f f' a (f a) = a 
goal: HasStrictFDerivAt.localInverse f f' a hf (f a) = a

full_name: HasStrictFDerivAt.eventually_right_inverse
code: theorem eventually_right_inverse (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    ∀ᶠ y in 𝓝 (f a), f (hf.localInverse f f' a y) = y 
goal: ∀ᶠ (y : F) in 𝓝 (f a), f (HasStrictFDerivAt.localInverse f f' a hf y) = y

full_name: HasStrictFDerivAt.localInverse_continuousAt
code: theorem localInverse_continuousAt (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    ContinuousAt (hf.localInverse f f' a) (f a) 
goal: ContinuousAt (HasStrictFDerivAt.localInverse f f' a hf) (f a)

full_name: HasStrictFDerivAt.localInverse_tendsto
code: theorem localInverse_tendsto (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    Tendsto (hf.localInverse f f' a) (𝓝 <| f a) (𝓝 a) 
goal: Filter.Tendsto (HasStrictFDerivAt.localInverse f f' a hf) (𝓝 (f a)) (𝓝 a)

full_name: HasStrictFDerivAt.localInverse_unique
code: theorem localInverse_unique (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) {g : F → E}
    (hg : ∀ᶠ x in 𝓝 a, g (f x) = x) : ∀ᶠ y in 𝓝 (f a), g y = localInverse f f' a hf y 
goal: ∀ᶠ (y : F) in 𝓝 (f a), g y = HasStrictFDerivAt.localInverse f f' a hf y

full_name: HasStrictFDerivAt.to_localInverse
code: /-- If `f` has an invertible derivative `f'` at `a` in the sense of strict differentiability `(hf)`,
then the inverse function `hf.localInverse f` has derivative `f'.symm` at `f a`. -/
theorem to_localInverse (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    HasStrictFDerivAt (hf.localInverse f f' a) (f'.symm : F →L[𝕜] E) (f a) 
goal: HasStrictFDerivAt (HasStrictFDerivAt.localInverse f f' a hf) (↑f'.symm) (f a)

full_name: HasStrictFDerivAt.to_local_left_inverse
code: /-- If `f : E → F` has an invertible derivative `f'` at `a` in the sense of strict differentiability
and `g (f x) = x` in a neighborhood of `a`, then `g` has derivative `f'.symm` at `f a`.

For a version assuming `f (g y) = y` and continuity of `g` at `f a` but not `[CompleteSpace E]`
see `of_local_left_inverse`.  -/
theorem to_local_left_inverse (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) {g : F → E}
    (hg : ∀ᶠ x in 𝓝 a, g (f x) = x) : HasStrictFDerivAt g (f'.symm : F →L[𝕜] E) (f a) 
goal: HasStrictFDerivAt g (↑f'.symm) (f a)

full_name: isOpenMap_of_hasStrictFDerivAt_equiv
code: /-- If a function has an invertible strict derivative at all points, then it is an open map. -/
theorem isOpenMap_of_hasStrictFDerivAt_equiv [CompleteSpace E] {f : E → F} {f' : E → E ≃L[𝕜] F}
    (hf : ∀ x, HasStrictFDerivAt f (f' x : E →L[𝕜] F) x) : IsOpenMap f 
goal: IsOpenMap f