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

full_name: HasFDerivAtFilter.isLittleO
code: /-- A function `f` has the continuous linear map `f'` as derivative along the filter `L` if
`f x' = f x + f' (x' - x) + o (x' - x)` when `x'` converges along the filter `L`. This definition
is designed to be specialized for `L = 𝓝 x` (in `HasFDerivAt`), giving rise to the usual notion
of Fréchet derivative, and for `L = 𝓝[s] x` (in `HasFDerivWithinAt`), giving rise to
the notion of Fréchet derivative along the set `s`. -/
@[mk_iff hasFDerivAtFilter_iff_isLittleO]
structure HasFDerivAtFilter (f : E → F) (f' : E →L[𝕜] F) (x : E) (L : Filter E) : Prop where
  of_isLittleO :: isLittleO : (fun x' => f x' - f x - f' (x' - x)) =o[L] fun x' => x' - x
goal: (fun x' => f x' - f x - f' (x' - x)) =o[L] fun x' => x' - x

full_name: HasFDerivAtFilter.of_isLittleO
code: /-- A function `f` has the continuous linear map `f'` as derivative along the filter `L` if
`f x' = f x + f' (x' - x) + o (x' - x)` when `x'` converges along the filter `L`. This definition
is designed to be specialized for `L = 𝓝 x` (in `HasFDerivAt`), giving rise to the usual notion
of Fréchet derivative, and for `L = 𝓝[s] x` (in `HasFDerivWithinAt`), giving rise to
the notion of Fréchet derivative along the set `s`. -/
@[mk_iff hasFDerivAtFilter_iff_isLittleO]
structure HasFDerivAtFilter (f : E → F) (f' : E →L[𝕜] F) (x : E) (L : Filter E) : Prop where
  of_isLittleO :: isLittleO : (fun x' => f x' - f x - f' (x' - x)) =o[L] fun x' => x' - x
goal: HasFDerivAtFilter f f' x L

full_name: hasFDerivAtFilter_iff_isLittleO
code: /-- A function `f` has the continuous linear map `f'` as derivative along the filter `L` if
`f x' = f x + f' (x' - x) + o (x' - x)` when `x'` converges along the filter `L`. This definition
is designed to be specialized for `L = 𝓝 x` (in `HasFDerivAt`), giving rise to the usual notion
of Fréchet derivative, and for `L = 𝓝[s] x` (in `HasFDerivWithinAt`), giving rise to
the notion of Fréchet derivative along the set `s`. -/
@[mk_iff hasFDerivAtFilter_iff_isLittleO]
structure HasFDerivAtFilter (f : E → F) (f' : E →L[𝕜] F) (x : E) (L : Filter E) : Prop where
  of_isLittleO :: isLittleO : (fun x' => f x' - f x - f' (x' - x)) =o[L] fun x' => x' - x
goal: HasFDerivAtFilter f f' x L ↔ (fun x' => f x' - f x - f' (x' - x)) =o[L] fun x' => x' - x

full_name: HasFDerivAtFilter
code: /-- A function `f` has the continuous linear map `f'` as derivative along the filter `L` if
`f x' = f x + f' (x' - x) + o (x' - x)` when `x'` converges along the filter `L`. This definition
is designed to be specialized for `L = 𝓝 x` (in `HasFDerivAt`), giving rise to the usual notion
of Fréchet derivative, and for `L = 𝓝[s] x` (in `HasFDerivWithinAt`), giving rise to
the notion of Fréchet derivative along the set `s`. -/
@[mk_iff hasFDerivAtFilter_iff_isLittleO]
structure HasFDerivAtFilter (f : E → F) (f' : E →L[𝕜] F) (x : E) (L : Filter E) : Prop where
  of_isLittleO :: isLittleO : (fun x' => f x' - f x - f' (x' - x)) =o[L] fun x' => x' - x
goal: Prop

full_name: HasFDerivWithinAt
code: /-- A function `f` has the continuous linear map `f'` as derivative at `x` within a set `s` if
`f x' = f x + f' (x' - x) + o (x' - x)` when `x'` tends to `x` inside `s`. -/
@[fun_prop]
def HasFDerivWithinAt (f : E → F) (f' : E →L[𝕜] F) (s : Set E) (x : E) 
goal: Prop

full_name: HasFDerivAt
code: /-- A function `f` has the continuous linear map `f'` as derivative at `x` if
`f x' = f x + f' (x' - x) + o (x' - x)` when `x'` tends to `x`. -/
@[fun_prop]
def HasFDerivAt (f : E → F) (f' : E →L[𝕜] F) (x : E) 
goal: Prop

full_name: HasStrictFDerivAt
code: /-- A function `f` has derivative `f'` at `a` in the sense of *strict differentiability*
if `f x - f y - f' (x - y) = o(x - y)` as `x, y → a`. This form of differentiability is required,
e.g., by the inverse function theorem. Any `C^1` function on a vector space over `ℝ` is strictly
differentiable but this definition works, e.g., for vector spaces over `p`-adic numbers. -/
@[fun_prop]
def HasStrictFDerivAt (f : E → F) (f' : E →L[𝕜] F) (x : E) 
goal: Prop

full_name: DifferentiableWithinAt
code: /-- A function `f` is differentiable at a point `x` within a set `s` if it admits a derivative
there (possibly non-unique). -/
@[fun_prop]
def DifferentiableWithinAt (f : E → F) (s : Set E) (x : E) 
goal: Prop

full_name: DifferentiableAt
code: /-- A function `f` is differentiable at a point `x` if it admits a derivative there (possibly
non-unique). -/
@[fun_prop]
def DifferentiableAt (f : E → F) (x : E) 
goal: Prop

full_name: fderivWithin
code: /-- If `f` has a derivative at `x` within `s`, then `fderivWithin 𝕜 f s x` is such a derivative.
Otherwise, it is set to `0`. If `x` is isolated in `s`, we take the derivative within `s` to
be zero for convenience. -/
irreducible_def fderivWithin (f : E → F) (s : Set E) (x : E) : E →L[𝕜] F 
goal: E →L[𝕜] F

full_name: wrapped._@.Mathlib.Analysis.Calculus.FDeriv.Basic._hyg.667
code: /-- If `f` has a derivative at `x` within `s`, then `fderivWithin 𝕜 f s x` is such a derivative.
Otherwise, it is set to `0`. If `x` is isolated in `s`, we take the derivative within `s` to
be zero for convenience. -/
irreducible_def fderivWithin (f : E → F) (s : Set E) (x : E) : E →L[𝕜] F 
goal: Subtype (Eq definition✝)

full_name: definition._@.Mathlib.Analysis.Calculus.FDeriv.Basic._hyg.667
code: /-- If `f` has a derivative at `x` within `s`, then `fderivWithin 𝕜 f s x` is such a derivative.
Otherwise, it is set to `0`. If `x` is isolated in `s`, we take the derivative within `s` to
be zero for convenience. -/
irreducible_def fderivWithin (f : E → F) (s : Set E) (x : E) : E →L[𝕜] F 
goal: E →L[𝕜] F

full_name: fderivWithin_def
code: /-- If `f` has a derivative at `x` within `s`, then `fderivWithin 𝕜 f s x` is such a derivative.
Otherwise, it is set to `0`. If `x` is isolated in `s`, we take the derivative within `s` to
be zero for convenience. -/
irreducible_def fderivWithin (f : E → F) (s : Set E) (x : E) : E →L[𝕜] F 
goal: fderivWithin 𝕜 f s x =
  if 𝓝[s \ {x}] x = ⊥ then 0 else if h : ∃ f', HasFDerivWithinAt f f' s x then Classical.choose h else 0

full_name: fderiv_def
code: /-- If `f` has a derivative at `x`, then `fderiv 𝕜 f x` is such a derivative. Otherwise, it is
set to `0`. -/
irreducible_def fderiv (f : E → F) (x : E) : E →L[𝕜] F 
goal: fderiv 𝕜 f x = if h : ∃ f', HasFDerivAt f f' x then Classical.choose h else 0

full_name: fderiv
code: /-- If `f` has a derivative at `x`, then `fderiv 𝕜 f x` is such a derivative. Otherwise, it is
set to `0`. -/
irreducible_def fderiv (f : E → F) (x : E) : E →L[𝕜] F 
goal: E →L[𝕜] F

full_name: definition._@.Mathlib.Analysis.Calculus.FDeriv.Basic._hyg.1003
code: /-- If `f` has a derivative at `x`, then `fderiv 𝕜 f x` is such a derivative. Otherwise, it is
set to `0`. -/
irreducible_def fderiv (f : E → F) (x : E) : E →L[𝕜] F 
goal: E →L[𝕜] F

full_name: wrapped._@.Mathlib.Analysis.Calculus.FDeriv.Basic._hyg.1003
code: /-- If `f` has a derivative at `x`, then `fderiv 𝕜 f x` is such a derivative. Otherwise, it is
set to `0`. -/
irreducible_def fderiv (f : E → F) (x : E) : E →L[𝕜] F 
goal: Subtype (Eq definition✝)

full_name: DifferentiableOn
code: /-- `DifferentiableOn 𝕜 f s` means that `f` is differentiable within `s` at any point of `s`. -/
@[fun_prop]
def DifferentiableOn (f : E → F) (s : Set E) 
goal: Prop

full_name: Differentiable
code: /-- `Differentiable 𝕜 f` means that `f` is differentiable at any point. -/
@[fun_prop]
def Differentiable (f : E → F) 
goal: Prop

full_name: fderivWithin_zero_of_isolated
code: theorem fderivWithin_zero_of_isolated (h : 𝓝[s \ {x}] x = ⊥) : fderivWithin 𝕜 f s x = 0 
goal: fderivWithin 𝕜 f s x = 0

full_name: fderivWithin_zero_of_nmem_closure
code: theorem fderivWithin_zero_of_nmem_closure (h : x ∉ closure s) : fderivWithin 𝕜 f s x = 0 
goal: fderivWithin 𝕜 f s x = 0

full_name: fderivWithin_zero_of_not_differentiableWithinAt
code: theorem fderivWithin_zero_of_not_differentiableWithinAt (h : ¬DifferentiableWithinAt 𝕜 f s x) :
    fderivWithin 𝕜 f s x = 0 
goal: fderivWithin 𝕜 f s x = 0

full_name: fderiv_zero_of_not_differentiableAt
code: theorem fderiv_zero_of_not_differentiableAt (h : ¬DifferentiableAt 𝕜 f x) : fderiv 𝕜 f x = 0 
goal: fderiv 𝕜 f x = 0

full_name: HasFDerivWithinAt.lim
code: /-- If a function f has a derivative f' at x, a rescaled version of f around x converges to f',
i.e., `n (f (x + (1/n) v) - f x)` converges to `f' v`. More generally, if `c n` tends to infinity
and `c n * d n` tends to `v`, then `c n * (f (x + d n) - f x)` tends to `f' v`. This lemma expresses
this fact, for functions having a derivative within a set. Its specific formulation is useful for
tangent cone related discussions. -/
theorem HasFDerivWithinAt.lim (h : HasFDerivWithinAt f f' s x) {α : Type*} (l : Filter α)
    {c : α → 𝕜} {d : α → E} {v : E} (dtop : ∀ᶠ n in l, x + d n ∈ s)
    (clim : Tendsto (fun n => ‖c n‖) l atTop) (cdlim : Tendsto (fun n => c n • d n) l (𝓝 v)) :
    Tendsto (fun n => c n • (f (x + d n) - f x)) l (𝓝 (f' v)) 
goal: Filter.Tendsto (fun n => c n • (f (x + d n) - f x)) l (𝓝 (f' v))

full_name: HasFDerivWithinAt.unique_on
code: /-- If `f'` and `f₁'` are two derivatives of `f` within `s` at `x`, then they are equal on the
tangent cone to `s` at `x` -/
theorem HasFDerivWithinAt.unique_on (hf : HasFDerivWithinAt f f' s x)
    (hg : HasFDerivWithinAt f f₁' s x) : EqOn f' f₁' (tangentConeAt 𝕜 s x) 
goal: Set.EqOn (⇑f') (⇑f₁') (tangentConeAt 𝕜 s x)

full_name: UniqueDiffWithinAt.eq
code: /-- `UniqueDiffWithinAt` achieves its goal: it implies the uniqueness of the derivative. -/
theorem UniqueDiffWithinAt.eq (H : UniqueDiffWithinAt 𝕜 s x) (hf : HasFDerivWithinAt f f' s x)
    (hg : HasFDerivWithinAt f f₁' s x) : f' = f₁' 
goal: f' = f₁'

full_name: UniqueDiffOn.eq
code: theorem UniqueDiffOn.eq (H : UniqueDiffOn 𝕜 s) (hx : x ∈ s) (h : HasFDerivWithinAt f f' s x)
    (h₁ : HasFDerivWithinAt f f₁' s x) : f' = f₁' 
goal: f' = f₁'

full_name: hasFDerivAtFilter_iff_tendsto
code: theorem hasFDerivAtFilter_iff_tendsto :
    HasFDerivAtFilter f f' x L ↔
      Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (𝓝 0) 
goal: HasFDerivAtFilter f f' x L ↔ Filter.Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (𝓝 0)

full_name: hasFDerivWithinAt_iff_tendsto
code: theorem hasFDerivWithinAt_iff_tendsto :
    HasFDerivWithinAt f f' s x ↔
      Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) (𝓝[s] x) (𝓝 0) 
goal: HasFDerivWithinAt f f' s x ↔ Filter.Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) (𝓝[s] x) (𝓝 0)

full_name: hasFDerivAt_iff_tendsto
code: theorem hasFDerivAt_iff_tendsto :
    HasFDerivAt f f' x ↔ Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) (𝓝 x) (𝓝 0) 
goal: HasFDerivAt f f' x ↔ Filter.Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) (𝓝 x) (𝓝 0)

full_name: hasFDerivAt_iff_isLittleO_nhds_zero
code: theorem hasFDerivAt_iff_isLittleO_nhds_zero :
    HasFDerivAt f f' x ↔ (fun h : E => f (x + h) - f x - f' h) =o[𝓝 0] fun h => h 
goal: HasFDerivAt f f' x ↔ (fun h => f (x + h) - f x - f' h) =o[𝓝 0] fun h => h

full_name: HasFDerivAt.le_of_lip'
code: /-- Converse to the mean value inequality: if `f` is differentiable at `x₀` and `C`-lipschitz
on a neighborhood of `x₀` then its derivative at `x₀` has norm bounded by `C`. This version
only assumes that `‖f x - f x₀‖ ≤ C * ‖x - x₀‖` in a neighborhood of `x`. -/
theorem HasFDerivAt.le_of_lip' {f : E → F} {f' : E →L[𝕜] F} {x₀ : E} (hf : HasFDerivAt f f' x₀)
    {C : ℝ} (hC₀ : 0 ≤ C) (hlip : ∀ᶠ x in 𝓝 x₀, ‖f x - f x₀‖ ≤ C * ‖x - x₀‖) : ‖f'‖ ≤ C 
goal: ‖f'‖ ≤ C

full_name: HasFDerivAt.le_of_lipschitzOn
code: /-- Converse to the mean value inequality: if `f` is differentiable at `x₀` and `C`-lipschitz
on a neighborhood of `x₀` then its derivative at `x₀` has norm bounded by `C`. -/
theorem HasFDerivAt.le_of_lipschitzOn
    {f : E → F} {f' : E →L[𝕜] F} {x₀ : E} (hf : HasFDerivAt f f' x₀)
    {s : Set E} (hs : s ∈ 𝓝 x₀) {C : ℝ≥0} (hlip : LipschitzOnWith C f s) : ‖f'‖ ≤ C 
goal: ‖f'‖ ≤ ↑C

full_name: HasFDerivAt.le_of_lipschitz
code: /-- Converse to the mean value inequality: if `f` is differentiable at `x₀` and `C`-lipschitz
then its derivative at `x₀` has norm bounded by `C`. -/
theorem HasFDerivAt.le_of_lipschitz {f : E → F} {f' : E →L[𝕜] F} {x₀ : E} (hf : HasFDerivAt f f' x₀)
    {C : ℝ≥0} (hlip : LipschitzWith C f) : ‖f'‖ ≤ C 
goal: ‖f'‖ ≤ ↑C

full_name: HasFDerivAtFilter.mono
code: nonrec theorem HasFDerivAtFilter.mono (h : HasFDerivAtFilter f f' x L₂) (hst : L₁ ≤ L₂) :
    HasFDerivAtFilter f f' x L₁ 
goal: HasFDerivAtFilter f f' x L₁

full_name: HasFDerivWithinAt.mono_of_mem
code: theorem HasFDerivWithinAt.mono_of_mem (h : HasFDerivWithinAt f f' t x) (hst : t ∈ 𝓝[s] x) :
    HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' s x

full_name: HasFDerivWithinAt.mono
code: nonrec theorem HasFDerivWithinAt.mono (h : HasFDerivWithinAt f f' t x) (hst : s ⊆ t) :
    HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' s x

full_name: HasFDerivAt.hasFDerivAtFilter
code: theorem HasFDerivAt.hasFDerivAtFilter (h : HasFDerivAt f f' x) (hL : L ≤ 𝓝 x) :
    HasFDerivAtFilter f f' x L 
goal: HasFDerivAtFilter f f' x L

full_name: HasFDerivAt.hasFDerivWithinAt
code: @[fun_prop]
theorem HasFDerivAt.hasFDerivWithinAt (h : HasFDerivAt f f' x) : HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' s x

full_name: HasFDerivWithinAt.differentiableWithinAt
code: @[fun_prop]
theorem HasFDerivWithinAt.differentiableWithinAt (h : HasFDerivWithinAt f f' s x) :
    DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 f s x

full_name: HasFDerivAt.differentiableAt
code: @[fun_prop]
theorem HasFDerivAt.differentiableAt (h : HasFDerivAt f f' x) : DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 f x

full_name: hasFDerivWithinAt_univ
code: @[simp]
theorem hasFDerivWithinAt_univ : HasFDerivWithinAt f f' univ x ↔ HasFDerivAt f f' x 
goal: HasFDerivWithinAt f f' Set.univ x ↔ HasFDerivAt f f' x

full_name: hasFDerivWithinAt_of_mem_nhds
code: theorem hasFDerivWithinAt_of_mem_nhds (h : s ∈ 𝓝 x) :
    HasFDerivWithinAt f f' s x ↔ HasFDerivAt f f' x 
goal: HasFDerivWithinAt f f' s x ↔ HasFDerivAt f f' x

full_name: hasFDerivWithinAt_of_isOpen
code: lemma hasFDerivWithinAt_of_isOpen (h : IsOpen s) (hx : x ∈ s) :
    HasFDerivWithinAt f f' s x ↔ HasFDerivAt f f' x 
goal: HasFDerivWithinAt f f' s x ↔ HasFDerivAt f f' x

full_name: hasFDerivWithinAt_insert
code: theorem hasFDerivWithinAt_insert {y : E} :
    HasFDerivWithinAt f f' (insert y s) x ↔ HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' (insert y s) x ↔ HasFDerivWithinAt f f' s x

full_name: HasFDerivWithinAt.insert
code: protected theorem HasFDerivWithinAt.insert (h : HasFDerivWithinAt g g' s x) :
    HasFDerivWithinAt g g' (insert x s) x 
goal: HasFDerivWithinAt g g' (insert x s) x

full_name: hasFDerivWithinAt_diff_singleton
code: theorem hasFDerivWithinAt_diff_singleton (y : E) :
    HasFDerivWithinAt f f' (s \ {y}) x ↔ HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' (s \ {y}) x ↔ HasFDerivWithinAt f f' s x

full_name: HasStrictFDerivAt.isBigO_sub
code: theorem HasStrictFDerivAt.isBigO_sub (hf : HasStrictFDerivAt f f' x) :
    (fun p : E × E => f p.1 - f p.2) =O[𝓝 (x, x)] fun p : E × E => p.1 - p.2 
goal: (fun p => f p.1 - f p.2) =O[𝓝 (x, x)] fun p => p.1 - p.2

full_name: HasFDerivAtFilter.isBigO_sub
code: theorem HasFDerivAtFilter.isBigO_sub (h : HasFDerivAtFilter f f' x L) :
    (fun x' => f x' - f x) =O[L] fun x' => x' - x 
goal: (fun x' => f x' - f x) =O[L] fun x' => x' - x

full_name: HasStrictFDerivAt.hasFDerivAt
code: @[fun_prop]
protected theorem HasStrictFDerivAt.hasFDerivAt (hf : HasStrictFDerivAt f f' x) :
    HasFDerivAt f f' x 
goal: HasFDerivAt f f' x

full_name: HasStrictFDerivAt.differentiableAt
code: protected theorem HasStrictFDerivAt.differentiableAt (hf : HasStrictFDerivAt f f' x) :
    DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 f x

full_name: HasStrictFDerivAt.exists_lipschitzOnWith_of_nnnorm_lt
code: /-- If `f` is strictly differentiable at `x` with derivative `f'` and `K > ‖f'‖₊`, then `f` is
`K`-Lipschitz in a neighborhood of `x`. -/
theorem HasStrictFDerivAt.exists_lipschitzOnWith_of_nnnorm_lt (hf : HasStrictFDerivAt f f' x)
    (K : ℝ≥0) (hK : ‖f'‖₊ < K) : ∃ s ∈ 𝓝 x, LipschitzOnWith K f s 
goal: ∃ s ∈ 𝓝 x, LipschitzOnWith K f s

full_name: HasStrictFDerivAt.exists_lipschitzOnWith
code: /-- If `f` is strictly differentiable at `x` with derivative `f'`, then `f` is Lipschitz in a
neighborhood of `x`. See also `HasStrictFDerivAt.exists_lipschitzOnWith_of_nnnorm_lt` for a
more precise statement. -/
theorem HasStrictFDerivAt.exists_lipschitzOnWith (hf : HasStrictFDerivAt f f' x) :
    ∃ K, ∃ s ∈ 𝓝 x, LipschitzOnWith K f s 
goal: ∃ K, ∃ s ∈ 𝓝 x, LipschitzOnWith K f s

full_name: HasFDerivAt.lim
code: /-- Directional derivative agrees with `HasFDeriv`. -/
theorem HasFDerivAt.lim (hf : HasFDerivAt f f' x) (v : E) {α : Type*} {c : α → 𝕜} {l : Filter α}
    (hc : Tendsto (fun n => ‖c n‖) l atTop) :
    Tendsto (fun n => c n • (f (x + (c n)⁻¹ • v) - f x)) l (𝓝 (f' v)) 
goal: Filter.Tendsto (fun n => c n • (f (x + (c n)⁻¹ • v) - f x)) l (𝓝 (f' v))

full_name: HasFDerivAt.unique
code: theorem HasFDerivAt.unique (h₀ : HasFDerivAt f f₀' x) (h₁ : HasFDerivAt f f₁' x) : f₀' = f₁' 
goal: f₀' = f₁'

full_name: hasFDerivWithinAt_inter'
code: theorem hasFDerivWithinAt_inter' (h : t ∈ 𝓝[s] x) :
    HasFDerivWithinAt f f' (s ∩ t) x ↔ HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' (s ∩ t) x ↔ HasFDerivWithinAt f f' s x

full_name: hasFDerivWithinAt_inter
code: theorem hasFDerivWithinAt_inter (h : t ∈ 𝓝 x) :
    HasFDerivWithinAt f f' (s ∩ t) x ↔ HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' (s ∩ t) x ↔ HasFDerivWithinAt f f' s x

full_name: HasFDerivWithinAt.union
code: theorem HasFDerivWithinAt.union (hs : HasFDerivWithinAt f f' s x)
    (ht : HasFDerivWithinAt f f' t x) : HasFDerivWithinAt f f' (s ∪ t) x 
goal: HasFDerivWithinAt f f' (s ∪ t) x

full_name: HasFDerivWithinAt.hasFDerivAt
code: theorem HasFDerivWithinAt.hasFDerivAt (h : HasFDerivWithinAt f f' s x) (hs : s ∈ 𝓝 x) :
    HasFDerivAt f f' x 
goal: HasFDerivAt f f' x

full_name: DifferentiableWithinAt.differentiableAt
code: theorem DifferentiableWithinAt.differentiableAt (h : DifferentiableWithinAt 𝕜 f s x)
    (hs : s ∈ 𝓝 x) : DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 f x

full_name: HasFDerivWithinAt.of_nhdsWithin_eq_bot
code: /-- If `x` is isolated in `s`, then `f` has any derivative at `x` within `s`,
as this statement is empty. -/
theorem HasFDerivWithinAt.of_nhdsWithin_eq_bot (h : 𝓝[s\{x}] x = ⊥) :
    HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' s x

full_name: hasFDerivWithinAt_of_nmem_closure
code: /-- If `x` is not in the closure of `s`, then `f` has any derivative at `x` within `s`,
as this statement is empty. -/
theorem hasFDerivWithinAt_of_nmem_closure (h : x ∉ closure s) : HasFDerivWithinAt f f' s x 
goal: HasFDerivWithinAt f f' s x

full_name: DifferentiableWithinAt.hasFDerivWithinAt
code: theorem DifferentiableWithinAt.hasFDerivWithinAt (h : DifferentiableWithinAt 𝕜 f s x) :
    HasFDerivWithinAt f (fderivWithin 𝕜 f s x) s x 
goal: HasFDerivWithinAt f (fderivWithin 𝕜 f s x) s x

full_name: DifferentiableAt.hasFDerivAt
code: theorem DifferentiableAt.hasFDerivAt (h : DifferentiableAt 𝕜 f x) :
    HasFDerivAt f (fderiv 𝕜 f x) x 
goal: HasFDerivAt f (fderiv 𝕜 f x) x

full_name: DifferentiableOn.hasFDerivAt
code: theorem DifferentiableOn.hasFDerivAt (h : DifferentiableOn 𝕜 f s) (hs : s ∈ 𝓝 x) :
    HasFDerivAt f (fderiv 𝕜 f x) x 
goal: HasFDerivAt f (fderiv 𝕜 f x) x

full_name: DifferentiableOn.differentiableAt
code: theorem DifferentiableOn.differentiableAt (h : DifferentiableOn 𝕜 f s) (hs : s ∈ 𝓝 x) :
    DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 f x

full_name: DifferentiableOn.eventually_differentiableAt
code: theorem DifferentiableOn.eventually_differentiableAt (h : DifferentiableOn 𝕜 f s) (hs : s ∈ 𝓝 x) :
    ∀ᶠ y in 𝓝 x, DifferentiableAt 𝕜 f y 
goal: ∀ᶠ (y : E) in 𝓝 x, DifferentiableAt 𝕜 f y

full_name: HasFDerivAt.fderiv
code: protected theorem HasFDerivAt.fderiv (h : HasFDerivAt f f' x) : fderiv 𝕜 f x = f' 
goal: fderiv 𝕜 f x = f'

full_name: fderiv_eq
code: theorem fderiv_eq {f' : E → E →L[𝕜] F} (h : ∀ x, HasFDerivAt f (f' x) x) : fderiv 𝕜 f = f' 
goal: fderiv 𝕜 f = f'

full_name: norm_fderiv_le_of_lip'
code: /-- Converse to the mean value inequality: if `f` is `C`-lipschitz
on a neighborhood of `x₀` then its derivative at `x₀` has norm bounded by `C`. This version
only assumes that `‖f x - f x₀‖ ≤ C * ‖x - x₀‖` in a neighborhood of `x`. -/
theorem norm_fderiv_le_of_lip' {f : E → F} {x₀ : E}
    {C : ℝ} (hC₀ : 0 ≤ C) (hlip : ∀ᶠ x in 𝓝 x₀, ‖f x - f x₀‖ ≤ C * ‖x - x₀‖) :
    ‖fderiv 𝕜 f x₀‖ ≤ C 
goal: ‖fderiv 𝕜 f x₀‖ ≤ C

full_name: norm_fderiv_le_of_lipschitzOn
code: /-- Converse to the mean value inequality: if `f` is `C`-lipschitz
on a neighborhood of `x₀` then its derivative at `x₀` has norm bounded by `C`.
Version using `fderiv`. -/
-- Porting note: renamed so that dot-notation makes sense
theorem norm_fderiv_le_of_lipschitzOn {f : E → F} {x₀ : E} {s : Set E} (hs : s ∈ 𝓝 x₀)
    {C : ℝ≥0} (hlip : LipschitzOnWith C f s) : ‖fderiv 𝕜 f x₀‖ ≤ C 
goal: ‖fderiv 𝕜 f x₀‖ ≤ ↑C

full_name: norm_fderiv_le_of_lipschitz
code: /-- Converse to the mean value inequality: if `f` is `C`-lipschitz then
its derivative at `x₀` has norm bounded by `C`.
Version using `fderiv`. -/
theorem norm_fderiv_le_of_lipschitz {f : E → F} {x₀ : E}
    {C : ℝ≥0} (hlip : LipschitzWith C f) : ‖fderiv 𝕜 f x₀‖ ≤ C 
goal: ‖fderiv 𝕜 f x₀‖ ≤ ↑C

full_name: HasFDerivWithinAt.fderivWithin
code: protected theorem HasFDerivWithinAt.fderivWithin (h : HasFDerivWithinAt f f' s x)
    (hxs : UniqueDiffWithinAt 𝕜 s x) : fderivWithin 𝕜 f s x = f' 
goal: fderivWithin 𝕜 f s x = f'

full_name: DifferentiableWithinAt.mono
code: theorem DifferentiableWithinAt.mono (h : DifferentiableWithinAt 𝕜 f t x) (st : s ⊆ t) :
    DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 f s x

full_name: DifferentiableWithinAt.mono_of_mem
code: theorem DifferentiableWithinAt.mono_of_mem (h : DifferentiableWithinAt 𝕜 f s x) {t : Set E}
    (hst : s ∈ 𝓝[t] x) : DifferentiableWithinAt 𝕜 f t x 
goal: DifferentiableWithinAt 𝕜 f t x

full_name: differentiableWithinAt_univ
code: theorem differentiableWithinAt_univ :
    DifferentiableWithinAt 𝕜 f univ x ↔ DifferentiableAt 𝕜 f x 
goal: DifferentiableWithinAt 𝕜 f Set.univ x ↔ DifferentiableAt 𝕜 f x

full_name: differentiableWithinAt_inter
code: theorem differentiableWithinAt_inter (ht : t ∈ 𝓝 x) :
    DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x

full_name: differentiableWithinAt_inter'
code: theorem differentiableWithinAt_inter' (ht : t ∈ 𝓝[s] x) :
    DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x

full_name: DifferentiableAt.differentiableWithinAt
code: theorem DifferentiableAt.differentiableWithinAt (h : DifferentiableAt 𝕜 f x) :
    DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 f s x

full_name: Differentiable.differentiableAt
code: @[fun_prop]
theorem Differentiable.differentiableAt (h : Differentiable 𝕜 f) : DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 f x

full_name: DifferentiableAt.fderivWithin
code: protected theorem DifferentiableAt.fderivWithin (h : DifferentiableAt 𝕜 f x)
    (hxs : UniqueDiffWithinAt 𝕜 s x) : fderivWithin 𝕜 f s x = fderiv 𝕜 f x 
goal: fderivWithin 𝕜 f s x = fderiv 𝕜 f x

full_name: DifferentiableOn.mono
code: theorem DifferentiableOn.mono (h : DifferentiableOn 𝕜 f t) (st : s ⊆ t) : DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 f s

full_name: differentiableOn_univ
code: theorem differentiableOn_univ : DifferentiableOn 𝕜 f univ ↔ Differentiable 𝕜 f 
goal: DifferentiableOn 𝕜 f Set.univ ↔ Differentiable 𝕜 f

full_name: Differentiable.differentiableOn
code: @[fun_prop]
theorem Differentiable.differentiableOn (h : Differentiable 𝕜 f) : DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 f s

full_name: differentiableOn_of_locally_differentiableOn
code: theorem differentiableOn_of_locally_differentiableOn
    (h : ∀ x ∈ s, ∃ u, IsOpen u ∧ x ∈ u ∧ DifferentiableOn 𝕜 f (s ∩ u)) :
    DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 f s

full_name: fderivWithin_of_mem
code: theorem fderivWithin_of_mem (st : t ∈ 𝓝[s] x) (ht : UniqueDiffWithinAt 𝕜 s x)
    (h : DifferentiableWithinAt 𝕜 f t x) : fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x 
goal: fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x

full_name: fderivWithin_subset
code: theorem fderivWithin_subset (st : s ⊆ t) (ht : UniqueDiffWithinAt 𝕜 s x)
    (h : DifferentiableWithinAt 𝕜 f t x) : fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x 
goal: fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x

full_name: fderivWithin_inter
code: theorem fderivWithin_inter (ht : t ∈ 𝓝 x) : fderivWithin 𝕜 f (s ∩ t) x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 f (s ∩ t) x = fderivWithin 𝕜 f s x

full_name: fderivWithin_univ
code: @[simp]
theorem fderivWithin_univ : fderivWithin 𝕜 f univ = fderiv 𝕜 f 
goal: fderivWithin 𝕜 f Set.univ = fderiv 𝕜 f

full_name: fderivWithin_of_mem_nhds
code: theorem fderivWithin_of_mem_nhds (h : s ∈ 𝓝 x) : fderivWithin 𝕜 f s x = fderiv 𝕜 f x 
goal: fderivWithin 𝕜 f s x = fderiv 𝕜 f x

full_name: fderivWithin_of_isOpen
code: theorem fderivWithin_of_isOpen (hs : IsOpen s) (hx : x ∈ s) : fderivWithin 𝕜 f s x = fderiv 𝕜 f x 
goal: fderivWithin 𝕜 f s x = fderiv 𝕜 f x

full_name: fderivWithin_eq_fderiv
code: theorem fderivWithin_eq_fderiv (hs : UniqueDiffWithinAt 𝕜 s x) (h : DifferentiableAt 𝕜 f x) :
    fderivWithin 𝕜 f s x = fderiv 𝕜 f x 
goal: fderivWithin 𝕜 f s x = fderiv 𝕜 f x

full_name: fderiv_mem_iff
code: theorem fderiv_mem_iff {f : E → F} {s : Set (E →L[𝕜] F)} {x : E} : fderiv 𝕜 f x ∈ s ↔
    DifferentiableAt 𝕜 f x ∧ fderiv 𝕜 f x ∈ s ∨ ¬DifferentiableAt 𝕜 f x ∧ (0 : E →L[𝕜] F) ∈ s 
goal: fderiv 𝕜 f x ∈ s ↔ DifferentiableAt 𝕜 f x ∧ fderiv 𝕜 f x ∈ s ∨ ¬DifferentiableAt 𝕜 f x ∧ 0 ∈ s

full_name: fderivWithin_mem_iff
code: theorem fderivWithin_mem_iff {f : E → F} {t : Set E} {s : Set (E →L[𝕜] F)} {x : E} :
    fderivWithin 𝕜 f t x ∈ s ↔
      DifferentiableWithinAt 𝕜 f t x ∧ fderivWithin 𝕜 f t x ∈ s ∨
        ¬DifferentiableWithinAt 𝕜 f t x ∧ (0 : E →L[𝕜] F) ∈ s 
goal: fderivWithin 𝕜 f t x ∈ s ↔
  DifferentiableWithinAt 𝕜 f t x ∧ fderivWithin 𝕜 f t x ∈ s ∨ ¬DifferentiableWithinAt 𝕜 f t x ∧ 0 ∈ s

full_name: Asymptotics.IsBigO.hasFDerivWithinAt
code: theorem Asymptotics.IsBigO.hasFDerivWithinAt {s : Set E} {x₀ : E} {n : ℕ}
    (h : f =O[𝓝[s] x₀] fun x => ‖x - x₀‖ ^ n) (hx₀ : x₀ ∈ s) (hn : 1 < n) :
    HasFDerivWithinAt f (0 : E →L[𝕜] F) s x₀ 
goal: HasFDerivWithinAt f 0 s x₀

full_name: Asymptotics.IsBigO.hasFDerivAt
code: theorem Asymptotics.IsBigO.hasFDerivAt {x₀ : E} {n : ℕ} (h : f =O[𝓝 x₀] fun x => ‖x - x₀‖ ^ n)
    (hn : 1 < n) : HasFDerivAt f (0 : E →L[𝕜] F) x₀ 
goal: HasFDerivAt f 0 x₀

full_name: HasFDerivWithinAt.isBigO_sub
code: nonrec theorem HasFDerivWithinAt.isBigO_sub {f : E → F} {s : Set E} {x₀ : E} {f' : E →L[𝕜] F}
    (h : HasFDerivWithinAt f f' s x₀) : (f · - f x₀) =O[𝓝[s] x₀] (· - x₀) 
goal: (fun x => f x - f x₀) =O[𝓝[s] x₀] fun x => x - x₀

full_name: DifferentiableWithinAt.isBigO_sub
code: lemma DifferentiableWithinAt.isBigO_sub {f : E → F} {s : Set E} {x₀ : E}
    (h : DifferentiableWithinAt 𝕜 f s x₀) : (f · - f x₀) =O[𝓝[s] x₀] (· - x₀) 
goal: (fun x => f x - f x₀) =O[𝓝[s] x₀] fun x => x - x₀

full_name: HasFDerivAt.isBigO_sub
code: nonrec theorem HasFDerivAt.isBigO_sub {f : E → F} {x₀ : E} {f' : E →L[𝕜] F}
    (h : HasFDerivAt f f' x₀) : (f · - f x₀) =O[𝓝 x₀] (· - x₀) 
goal: (fun x => f x - f x₀) =O[𝓝 x₀] fun x => x - x₀

full_name: DifferentiableAt.isBigO_sub
code: nonrec theorem DifferentiableAt.isBigO_sub {f : E → F} {x₀ : E} (h : DifferentiableAt 𝕜 f x₀) :
    (f · - f x₀) =O[𝓝 x₀] (· - x₀) 
goal: (fun x => f x - f x₀) =O[𝓝 x₀] fun x => x - x₀

full_name: HasFDerivAtFilter.tendsto_nhds
code: theorem HasFDerivAtFilter.tendsto_nhds (hL : L ≤ 𝓝 x) (h : HasFDerivAtFilter f f' x L) :
    Tendsto f L (𝓝 (f x)) 
goal: Filter.Tendsto f L (𝓝 (f x))

full_name: HasFDerivWithinAt.continuousWithinAt
code: theorem HasFDerivWithinAt.continuousWithinAt (h : HasFDerivWithinAt f f' s x) :
    ContinuousWithinAt f s x 
goal: ContinuousWithinAt f s x

full_name: HasFDerivAt.continuousAt
code: theorem HasFDerivAt.continuousAt (h : HasFDerivAt f f' x) : ContinuousAt f x 
goal: ContinuousAt f x

full_name: DifferentiableWithinAt.continuousWithinAt
code: @[fun_prop]
theorem DifferentiableWithinAt.continuousWithinAt (h : DifferentiableWithinAt 𝕜 f s x) :
    ContinuousWithinAt f s x 
goal: ContinuousWithinAt f s x

full_name: DifferentiableAt.continuousAt
code: @[fun_prop]
theorem DifferentiableAt.continuousAt (h : DifferentiableAt 𝕜 f x) : ContinuousAt f x 
goal: ContinuousAt f x

full_name: DifferentiableOn.continuousOn
code: @[fun_prop]
theorem DifferentiableOn.continuousOn (h : DifferentiableOn 𝕜 f s) : ContinuousOn f s 
goal: ContinuousOn f s

full_name: Differentiable.continuous
code: @[fun_prop]
theorem Differentiable.continuous (h : Differentiable 𝕜 f) : Continuous f 
goal: Continuous f

full_name: HasStrictFDerivAt.continuousAt
code: protected theorem HasStrictFDerivAt.continuousAt (hf : HasStrictFDerivAt f f' x) :
    ContinuousAt f x 
goal: ContinuousAt f x

full_name: HasStrictFDerivAt.isBigO_sub_rev
code: theorem HasStrictFDerivAt.isBigO_sub_rev {f' : E ≃L[𝕜] F}
    (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) x) :
    (fun p : E × E => p.1 - p.2) =O[𝓝 (x, x)] fun p : E × E => f p.1 - f p.2 
goal: (fun p => p.1 - p.2) =O[𝓝 (x, x)] fun p => f p.1 - f p.2

full_name: HasFDerivAtFilter.isBigO_sub_rev
code: theorem HasFDerivAtFilter.isBigO_sub_rev (hf : HasFDerivAtFilter f f' x L) {C}
    (hf' : AntilipschitzWith C f') : (fun x' => x' - x) =O[L] fun x' => f x' - f x 
goal: (fun x' => x' - x) =O[L] fun x' => f x' - f x

full_name: hasFDerivWithinAt_congr_set'
code: theorem hasFDerivWithinAt_congr_set' (y : E) (h : s =ᶠ[𝓝[{y}ᶜ] x] t) :
    HasFDerivWithinAt f f' s x ↔ HasFDerivWithinAt f f' t x 
goal: HasFDerivWithinAt f f' s x ↔ HasFDerivWithinAt f f' t x

full_name: hasFDerivWithinAt_congr_set
code: theorem hasFDerivWithinAt_congr_set (h : s =ᶠ[𝓝 x] t) :
    HasFDerivWithinAt f f' s x ↔ HasFDerivWithinAt f f' t x 
goal: HasFDerivWithinAt f f' s x ↔ HasFDerivWithinAt f f' t x

full_name: differentiableWithinAt_congr_set'
code: theorem differentiableWithinAt_congr_set' (y : E) (h : s =ᶠ[𝓝[{y}ᶜ] x] t) :
    DifferentiableWithinAt 𝕜 f s x ↔ DifferentiableWithinAt 𝕜 f t x 
goal: DifferentiableWithinAt 𝕜 f s x ↔ DifferentiableWithinAt 𝕜 f t x

full_name: differentiableWithinAt_congr_set
code: theorem differentiableWithinAt_congr_set (h : s =ᶠ[𝓝 x] t) :
    DifferentiableWithinAt 𝕜 f s x ↔ DifferentiableWithinAt 𝕜 f t x 
goal: DifferentiableWithinAt 𝕜 f s x ↔ DifferentiableWithinAt 𝕜 f t x

full_name: fderivWithin_congr_set'
code: theorem fderivWithin_congr_set' (y : E) (h : s =ᶠ[𝓝[{y}ᶜ] x] t) :
    fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x 
goal: fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x

full_name: fderivWithin_congr_set
code: theorem fderivWithin_congr_set (h : s =ᶠ[𝓝 x] t) : fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x 
goal: fderivWithin 𝕜 f s x = fderivWithin 𝕜 f t x

full_name: fderivWithin_eventually_congr_set'
code: theorem fderivWithin_eventually_congr_set' (y : E) (h : s =ᶠ[𝓝[{y}ᶜ] x] t) :
    fderivWithin 𝕜 f s =ᶠ[𝓝 x] fderivWithin 𝕜 f t 
goal: fderivWithin 𝕜 f s =ᶠ[𝓝 x] fderivWithin 𝕜 f t

full_name: fderivWithin_eventually_congr_set
code: theorem fderivWithin_eventually_congr_set (h : s =ᶠ[𝓝 x] t) :
    fderivWithin 𝕜 f s =ᶠ[𝓝 x] fderivWithin 𝕜 f t 
goal: fderivWithin 𝕜 f s =ᶠ[𝓝 x] fderivWithin 𝕜 f t

full_name: Filter.EventuallyEq.hasStrictFDerivAt_iff
code: theorem Filter.EventuallyEq.hasStrictFDerivAt_iff (h : f₀ =ᶠ[𝓝 x] f₁) (h' : ∀ y, f₀' y = f₁' y) :
    HasStrictFDerivAt f₀ f₀' x ↔ HasStrictFDerivAt f₁ f₁' x 
goal: HasStrictFDerivAt f₀ f₀' x ↔ HasStrictFDerivAt f₁ f₁' x

full_name: HasStrictFDerivAt.congr_fderiv
code: theorem HasStrictFDerivAt.congr_fderiv (h : HasStrictFDerivAt f f' x) (h' : f' = g') :
    HasStrictFDerivAt f g' x 
goal: HasStrictFDerivAt f g' x

full_name: HasFDerivAt.congr_fderiv
code: theorem HasFDerivAt.congr_fderiv (h : HasFDerivAt f f' x) (h' : f' = g') : HasFDerivAt f g' x 
goal: HasFDerivAt f g' x

full_name: HasFDerivWithinAt.congr_fderiv
code: theorem HasFDerivWithinAt.congr_fderiv (h : HasFDerivWithinAt f f' s x) (h' : f' = g') :
    HasFDerivWithinAt f g' s x 
goal: HasFDerivWithinAt f g' s x

full_name: HasStrictFDerivAt.congr_of_eventuallyEq
code: theorem HasStrictFDerivAt.congr_of_eventuallyEq (h : HasStrictFDerivAt f f' x)
    (h₁ : f =ᶠ[𝓝 x] f₁) : HasStrictFDerivAt f₁ f' x 
goal: HasStrictFDerivAt f₁ f' x

full_name: Filter.EventuallyEq.hasFDerivAtFilter_iff
code: theorem Filter.EventuallyEq.hasFDerivAtFilter_iff (h₀ : f₀ =ᶠ[L] f₁) (hx : f₀ x = f₁ x)
    (h₁ : ∀ x, f₀' x = f₁' x) : HasFDerivAtFilter f₀ f₀' x L ↔ HasFDerivAtFilter f₁ f₁' x L 
goal: HasFDerivAtFilter f₀ f₀' x L ↔ HasFDerivAtFilter f₁ f₁' x L

full_name: HasFDerivAtFilter.congr_of_eventuallyEq
code: theorem HasFDerivAtFilter.congr_of_eventuallyEq (h : HasFDerivAtFilter f f' x L) (hL : f₁ =ᶠ[L] f)
    (hx : f₁ x = f x) : HasFDerivAtFilter f₁ f' x L 
goal: HasFDerivAtFilter f₁ f' x L

full_name: Filter.EventuallyEq.hasFDerivAt_iff
code: theorem Filter.EventuallyEq.hasFDerivAt_iff (h : f₀ =ᶠ[𝓝 x] f₁) :
    HasFDerivAt f₀ f' x ↔ HasFDerivAt f₁ f' x 
goal: HasFDerivAt f₀ f' x ↔ HasFDerivAt f₁ f' x

full_name: Filter.EventuallyEq.differentiableAt_iff
code: theorem Filter.EventuallyEq.differentiableAt_iff (h : f₀ =ᶠ[𝓝 x] f₁) :
    DifferentiableAt 𝕜 f₀ x ↔ DifferentiableAt 𝕜 f₁ x 
goal: DifferentiableAt 𝕜 f₀ x ↔ DifferentiableAt 𝕜 f₁ x

full_name: Filter.EventuallyEq.hasFDerivWithinAt_iff
code: theorem Filter.EventuallyEq.hasFDerivWithinAt_iff (h : f₀ =ᶠ[𝓝[s] x] f₁) (hx : f₀ x = f₁ x) :
    HasFDerivWithinAt f₀ f' s x ↔ HasFDerivWithinAt f₁ f' s x 
goal: HasFDerivWithinAt f₀ f' s x ↔ HasFDerivWithinAt f₁ f' s x

full_name: Filter.EventuallyEq.hasFDerivWithinAt_iff_of_mem
code: theorem Filter.EventuallyEq.hasFDerivWithinAt_iff_of_mem (h : f₀ =ᶠ[𝓝[s] x] f₁) (hx : x ∈ s) :
    HasFDerivWithinAt f₀ f' s x ↔ HasFDerivWithinAt f₁ f' s x 
goal: HasFDerivWithinAt f₀ f' s x ↔ HasFDerivWithinAt f₁ f' s x

full_name: Filter.EventuallyEq.differentiableWithinAt_iff
code: theorem Filter.EventuallyEq.differentiableWithinAt_iff (h : f₀ =ᶠ[𝓝[s] x] f₁) (hx : f₀ x = f₁ x) :
    DifferentiableWithinAt 𝕜 f₀ s x ↔ DifferentiableWithinAt 𝕜 f₁ s x 
goal: DifferentiableWithinAt 𝕜 f₀ s x ↔ DifferentiableWithinAt 𝕜 f₁ s x

full_name: Filter.EventuallyEq.differentiableWithinAt_iff_of_mem
code: theorem Filter.EventuallyEq.differentiableWithinAt_iff_of_mem (h : f₀ =ᶠ[𝓝[s] x] f₁) (hx : x ∈ s) :
    DifferentiableWithinAt 𝕜 f₀ s x ↔ DifferentiableWithinAt 𝕜 f₁ s x 
goal: DifferentiableWithinAt 𝕜 f₀ s x ↔ DifferentiableWithinAt 𝕜 f₁ s x

full_name: HasFDerivWithinAt.congr_mono
code: theorem HasFDerivWithinAt.congr_mono (h : HasFDerivWithinAt f f' s x) (ht : EqOn f₁ f t)
    (hx : f₁ x = f x) (h₁ : t ⊆ s) : HasFDerivWithinAt f₁ f' t x 
goal: HasFDerivWithinAt f₁ f' t x

full_name: HasFDerivWithinAt.congr
code: theorem HasFDerivWithinAt.congr (h : HasFDerivWithinAt f f' s x) (hs : EqOn f₁ f s)
    (hx : f₁ x = f x) : HasFDerivWithinAt f₁ f' s x 
goal: HasFDerivWithinAt f₁ f' s x

full_name: HasFDerivWithinAt.congr'
code: theorem HasFDerivWithinAt.congr' (h : HasFDerivWithinAt f f' s x) (hs : EqOn f₁ f s) (hx : x ∈ s) :
    HasFDerivWithinAt f₁ f' s x 
goal: HasFDerivWithinAt f₁ f' s x

full_name: HasFDerivWithinAt.congr_of_eventuallyEq
code: theorem HasFDerivWithinAt.congr_of_eventuallyEq (h : HasFDerivWithinAt f f' s x)
    (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) : HasFDerivWithinAt f₁ f' s x 
goal: HasFDerivWithinAt f₁ f' s x

full_name: HasFDerivAt.congr_of_eventuallyEq
code: theorem HasFDerivAt.congr_of_eventuallyEq (h : HasFDerivAt f f' x) (h₁ : f₁ =ᶠ[𝓝 x] f) :
    HasFDerivAt f₁ f' x 
goal: HasFDerivAt f₁ f' x

full_name: DifferentiableWithinAt.congr_mono
code: theorem DifferentiableWithinAt.congr_mono (h : DifferentiableWithinAt 𝕜 f s x) (ht : EqOn f₁ f t)
    (hx : f₁ x = f x) (h₁ : t ⊆ s) : DifferentiableWithinAt 𝕜 f₁ t x 
goal: DifferentiableWithinAt 𝕜 f₁ t x

full_name: DifferentiableWithinAt.congr
code: theorem DifferentiableWithinAt.congr (h : DifferentiableWithinAt 𝕜 f s x) (ht : ∀ x ∈ s, f₁ x = f x)
    (hx : f₁ x = f x) : DifferentiableWithinAt 𝕜 f₁ s x 
goal: DifferentiableWithinAt 𝕜 f₁ s x

full_name: DifferentiableWithinAt.congr_of_eventuallyEq
code: theorem DifferentiableWithinAt.congr_of_eventuallyEq (h : DifferentiableWithinAt 𝕜 f s x)
    (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) : DifferentiableWithinAt 𝕜 f₁ s x 
goal: DifferentiableWithinAt 𝕜 f₁ s x

full_name: DifferentiableOn.congr_mono
code: theorem DifferentiableOn.congr_mono (h : DifferentiableOn 𝕜 f s) (h' : ∀ x ∈ t, f₁ x = f x)
    (h₁ : t ⊆ s) : DifferentiableOn 𝕜 f₁ t 
goal: DifferentiableOn 𝕜 f₁ t

full_name: DifferentiableOn.congr
code: theorem DifferentiableOn.congr (h : DifferentiableOn 𝕜 f s) (h' : ∀ x ∈ s, f₁ x = f x) :
    DifferentiableOn 𝕜 f₁ s 
goal: DifferentiableOn 𝕜 f₁ s

full_name: differentiableOn_congr
code: theorem differentiableOn_congr (h' : ∀ x ∈ s, f₁ x = f x) :
    DifferentiableOn 𝕜 f₁ s ↔ DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 f₁ s ↔ DifferentiableOn 𝕜 f s

full_name: DifferentiableAt.congr_of_eventuallyEq
code: theorem DifferentiableAt.congr_of_eventuallyEq (h : DifferentiableAt 𝕜 f x) (hL : f₁ =ᶠ[𝓝 x] f) :
    DifferentiableAt 𝕜 f₁ x 
goal: DifferentiableAt 𝕜 f₁ x

full_name: DifferentiableWithinAt.fderivWithin_congr_mono
code: theorem DifferentiableWithinAt.fderivWithin_congr_mono (h : DifferentiableWithinAt 𝕜 f s x)
    (hs : EqOn f₁ f t) (hx : f₁ x = f x) (hxt : UniqueDiffWithinAt 𝕜 t x) (h₁ : t ⊆ s) :
    fderivWithin 𝕜 f₁ t x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 f₁ t x = fderivWithin 𝕜 f s x

full_name: Filter.EventuallyEq.fderivWithin_eq
code: theorem Filter.EventuallyEq.fderivWithin_eq (hs : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) :
    fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x

full_name: Filter.EventuallyEq.fderivWithin'
code: theorem Filter.EventuallyEq.fderivWithin' (hs : f₁ =ᶠ[𝓝[s] x] f) (ht : t ⊆ s) :
    fderivWithin 𝕜 f₁ t =ᶠ[𝓝[s] x] fderivWithin 𝕜 f t 
goal: fderivWithin 𝕜 f₁ t =ᶠ[𝓝[s] x] fderivWithin 𝕜 f t

full_name: Filter.EventuallyEq.fderivWithin
code: protected theorem Filter.EventuallyEq.fderivWithin (hs : f₁ =ᶠ[𝓝[s] x] f) :
    fderivWithin 𝕜 f₁ s =ᶠ[𝓝[s] x] fderivWithin 𝕜 f s 
goal: fderivWithin 𝕜 f₁ s =ᶠ[𝓝[s] x] fderivWithin 𝕜 f s

full_name: Filter.EventuallyEq.fderivWithin_eq_nhds
code: theorem Filter.EventuallyEq.fderivWithin_eq_nhds (h : f₁ =ᶠ[𝓝 x] f) :
    fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x

full_name: fderivWithin_congr
code: theorem fderivWithin_congr (hs : EqOn f₁ f s) (hx : f₁ x = f x) :
    fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x

full_name: fderivWithin_congr'
code: theorem fderivWithin_congr' (hs : EqOn f₁ f s) (hx : x ∈ s) :
    fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x

full_name: Filter.EventuallyEq.fderiv_eq
code: theorem Filter.EventuallyEq.fderiv_eq (h : f₁ =ᶠ[𝓝 x] f) : fderiv 𝕜 f₁ x = fderiv 𝕜 f x 
goal: fderiv 𝕜 f₁ x = fderiv 𝕜 f x

full_name: Filter.EventuallyEq.fderiv
code: protected theorem Filter.EventuallyEq.fderiv (h : f₁ =ᶠ[𝓝 x] f) : fderiv 𝕜 f₁ =ᶠ[𝓝 x] fderiv 𝕜 f 
goal: fderiv 𝕜 f₁ =ᶠ[𝓝 x] fderiv 𝕜 f

full_name: hasStrictFDerivAt_id
code: @[fun_prop]
theorem hasStrictFDerivAt_id (x : E) : HasStrictFDerivAt id (id 𝕜 E) x 
goal: HasStrictFDerivAt id (ContinuousLinearMap.id 𝕜 E) x

full_name: hasFDerivAtFilter_id
code: theorem hasFDerivAtFilter_id (x : E) (L : Filter E) : HasFDerivAtFilter id (id 𝕜 E) x L 
goal: HasFDerivAtFilter id (ContinuousLinearMap.id 𝕜 E) x L

full_name: hasFDerivWithinAt_id
code: @[fun_prop]
theorem hasFDerivWithinAt_id (x : E) (s : Set E) : HasFDerivWithinAt id (id 𝕜 E) s x 
goal: HasFDerivWithinAt id (ContinuousLinearMap.id 𝕜 E) s x

full_name: hasFDerivAt_id
code: @[fun_prop]
theorem hasFDerivAt_id (x : E) : HasFDerivAt id (id 𝕜 E) x 
goal: HasFDerivAt id (ContinuousLinearMap.id 𝕜 E) x

full_name: differentiableAt_id
code: @[simp, fun_prop]
theorem differentiableAt_id : DifferentiableAt 𝕜 id x 
goal: DifferentiableAt 𝕜 id x

full_name: differentiableAt_id'
code: @[simp]
theorem differentiableAt_id' : DifferentiableAt 𝕜 (fun x => x) x 
goal: DifferentiableAt 𝕜 (fun x => x) x

full_name: differentiableWithinAt_id
code: @[fun_prop]
theorem differentiableWithinAt_id : DifferentiableWithinAt 𝕜 id s x 
goal: DifferentiableWithinAt 𝕜 id s x

full_name: differentiable_id
code: @[simp, fun_prop]
theorem differentiable_id : Differentiable 𝕜 (id : E → E) 
goal: Differentiable 𝕜 id

full_name: differentiable_id'
code: @[simp]
theorem differentiable_id' : Differentiable 𝕜 fun x : E => x 
goal: Differentiable 𝕜 fun x => x

full_name: differentiableOn_id
code: @[fun_prop]
theorem differentiableOn_id : DifferentiableOn 𝕜 id s 
goal: DifferentiableOn 𝕜 id s

full_name: fderiv_id
code: @[simp]
theorem fderiv_id : fderiv 𝕜 id x = id 𝕜 E 
goal: fderiv 𝕜 id x = ContinuousLinearMap.id 𝕜 E

full_name: fderiv_id'
code: @[simp]
theorem fderiv_id' : fderiv 𝕜 (fun x : E => x) x = ContinuousLinearMap.id 𝕜 E 
goal: fderiv 𝕜 (fun x => x) x = ContinuousLinearMap.id 𝕜 E

full_name: fderivWithin_id
code: theorem fderivWithin_id (hxs : UniqueDiffWithinAt 𝕜 s x) : fderivWithin 𝕜 id s x = id 𝕜 E 
goal: fderivWithin 𝕜 id s x = ContinuousLinearMap.id 𝕜 E

full_name: fderivWithin_id'
code: theorem fderivWithin_id' (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun x : E => x) s x = ContinuousLinearMap.id 𝕜 E 
goal: fderivWithin 𝕜 (fun x => x) s x = ContinuousLinearMap.id 𝕜 E

full_name: hasStrictFDerivAt_const
code: @[fun_prop]
theorem hasStrictFDerivAt_const (c : F) (x : E) :
    HasStrictFDerivAt (fun _ => c) (0 : E →L[𝕜] F) x 
goal: HasStrictFDerivAt (fun x => c) 0 x

full_name: hasFDerivAtFilter_const
code: theorem hasFDerivAtFilter_const (c : F) (x : E) (L : Filter E) :
    HasFDerivAtFilter (fun _ => c) (0 : E →L[𝕜] F) x L 
goal: HasFDerivAtFilter (fun x => c) 0 x L

full_name: hasFDerivWithinAt_const
code: @[fun_prop]
theorem hasFDerivWithinAt_const (c : F) (x : E) (s : Set E) :
    HasFDerivWithinAt (fun _ => c) (0 : E →L[𝕜] F) s x 
goal: HasFDerivWithinAt (fun x => c) 0 s x

full_name: hasFDerivAt_const
code: @[fun_prop]
theorem hasFDerivAt_const (c : F) (x : E) : HasFDerivAt (fun _ => c) (0 : E →L[𝕜] F) x 
goal: HasFDerivAt (fun x => c) 0 x

full_name: differentiableAt_const
code: @[simp, fun_prop]
theorem differentiableAt_const (c : F) : DifferentiableAt 𝕜 (fun _ => c) x 
goal: DifferentiableAt 𝕜 (fun x => c) x

full_name: differentiableWithinAt_const
code: @[fun_prop]
theorem differentiableWithinAt_const (c : F) : DifferentiableWithinAt 𝕜 (fun _ => c) s x 
goal: DifferentiableWithinAt 𝕜 (fun x => c) s x

full_name: fderiv_const_apply
code: theorem fderiv_const_apply (c : F) : fderiv 𝕜 (fun _ => c) x = 0 
goal: fderiv 𝕜 (fun x => c) x = 0

full_name: fderiv_const
code: @[simp]
theorem fderiv_const (c : F) : (fderiv 𝕜 fun _ : E => c) = 0 
goal: (fderiv 𝕜 fun x => c) = 0

full_name: fderivWithin_const_apply
code: theorem fderivWithin_const_apply (c : F) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun _ => c) s x = 0 
goal: fderivWithin 𝕜 (fun x => c) s x = 0

full_name: differentiable_const
code: @[simp, fun_prop]
theorem differentiable_const (c : F) : Differentiable 𝕜 fun _ : E => c 
goal: Differentiable 𝕜 fun x => c

full_name: differentiableOn_const
code: @[simp, fun_prop]
theorem differentiableOn_const (c : F) : DifferentiableOn 𝕜 (fun _ => c) s 
goal: DifferentiableOn 𝕜 (fun x => c) s

full_name: hasFDerivWithinAt_singleton
code: @[fun_prop]
theorem hasFDerivWithinAt_singleton (f : E → F) (x : E) :
    HasFDerivWithinAt f (0 : E →L[𝕜] F) {x} x 
goal: HasFDerivWithinAt f 0 {x} x

full_name: hasFDerivAt_of_subsingleton
code: @[fun_prop]
theorem hasFDerivAt_of_subsingleton [h : Subsingleton E] (f : E → F) (x : E) :
    HasFDerivAt f (0 : E →L[𝕜] F) x 
goal: HasFDerivAt f 0 x

full_name: differentiableOn_empty
code: @[fun_prop]
theorem differentiableOn_empty : DifferentiableOn 𝕜 f ∅ 
goal: DifferentiableOn 𝕜 f ∅

full_name: differentiableOn_singleton
code: @[fun_prop]
theorem differentiableOn_singleton : DifferentiableOn 𝕜 f {x} 
goal: DifferentiableOn 𝕜 f {x}

full_name: Set.Subsingleton.differentiableOn
code: @[fun_prop]
theorem Set.Subsingleton.differentiableOn (hs : s.Subsingleton) : DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 f s

full_name: hasFDerivAt_zero_of_eventually_const
code: theorem hasFDerivAt_zero_of_eventually_const (c : F) (hf : f =ᶠ[𝓝 x] fun _ => c) :
    HasFDerivAt f (0 : E →L[𝕜] F) x 
goal: HasFDerivAt f 0 x

full_name: HasStrictFDerivAt.of_nmem_tsupport
code: theorem HasStrictFDerivAt.of_nmem_tsupport (h : x ∉ tsupport f) :
    HasStrictFDerivAt f (0 : E →L[𝕜] F) x 
goal: HasStrictFDerivAt f 0 x

full_name: HasFDerivAt.of_nmem_tsupport
code: theorem HasFDerivAt.of_nmem_tsupport (h : x ∉ tsupport f) :
    HasFDerivAt f (0 : E →L[𝕜] F) x 
goal: HasFDerivAt f 0 x

full_name: HasFDerivWithinAt.of_not_mem_tsupport
code: theorem HasFDerivWithinAt.of_not_mem_tsupport {s : Set E} {x : E} (h : x ∉ tsupport f) :
    HasFDerivWithinAt f (0 : E →L[𝕜] F) s x 
goal: HasFDerivWithinAt f 0 s x

full_name: fderiv_of_not_mem_tsupport
code: theorem fderiv_of_not_mem_tsupport (h : x ∉ tsupport f) : fderiv 𝕜 f x = 0 
goal: fderiv 𝕜 f x = 0

full_name: support_fderiv_subset
code: theorem support_fderiv_subset : support (fderiv 𝕜 f) ⊆ tsupport f 
goal: Function.support (fderiv 𝕜 f) ⊆ tsupport f

full_name: tsupport_fderiv_subset
code: theorem tsupport_fderiv_subset : tsupport (fderiv 𝕜 f) ⊆ tsupport f 
goal: tsupport (fderiv 𝕜 f) ⊆ tsupport f

full_name: HasCompactSupport.fderiv
code: protected theorem HasCompactSupport.fderiv (hf : HasCompactSupport f) :
    HasCompactSupport (fderiv 𝕜 f) 
goal: HasCompactSupport (fderiv 𝕜 f)

full_name: HasCompactSupport.fderiv_apply
code: protected theorem HasCompactSupport.fderiv_apply (hf : HasCompactSupport f) (v : E) :
    HasCompactSupport (fderiv 𝕜 f · v) 
goal: HasCompactSupport fun x => (fderiv 𝕜 f x) v