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

full_name: HasDerivAtFilter
code: /-- `f` has the derivative `f'` at the point `x` as `x` goes along the filter `L`.

That is, `f x' = f x + (x' - x) • f' + o(x' - x)` where `x'` converges along the filter `L`.
-/
def HasDerivAtFilter (f : 𝕜 → F) (f' : F) (x : 𝕜) (L : Filter 𝕜) 
goal: Prop

full_name: HasDerivWithinAt
code: /-- `f` has the derivative `f'` at the point `x` within the subset `s`.

That is, `f x' = f x + (x' - x) • f' + o(x' - x)` where `x'` converges to `x` inside `s`.
-/
def HasDerivWithinAt (f : 𝕜 → F) (f' : F) (s : Set 𝕜) (x : 𝕜) 
goal: Prop

full_name: HasDerivAt
code: /-- `f` has the derivative `f'` at the point `x`.

That is, `f x' = f x + (x' - x) • f' + o(x' - x)` where `x'` converges to `x`.
-/
def HasDerivAt (f : 𝕜 → F) (f' : F) (x : 𝕜) 
goal: Prop

full_name: HasStrictDerivAt
code: /-- `f` has the derivative `f'` at the point `x` in the sense of strict differentiability.

That is, `f y - f z = (y - z) • f' + o(y - z)` as `y, z → x`. -/
def HasStrictDerivAt (f : 𝕜 → F) (f' : F) (x : 𝕜) 
goal: Prop

full_name: derivWithin
code: /-- Derivative of `f` at the point `x` within the set `s`, if it exists.  Zero otherwise.

If the derivative exists (i.e., `∃ f', HasDerivWithinAt f f' s x`), then
`f x' = f x + (x' - x) • derivWithin f s x + o(x' - x)` where `x'` converges to `x` inside `s`.
-/
def derivWithin (f : 𝕜 → F) (s : Set 𝕜) (x : 𝕜) 
goal: F

full_name: deriv
code: /-- Derivative of `f` at the point `x`, if it exists.  Zero otherwise.

If the derivative exists (i.e., `∃ f', HasDerivAt f f' x`), then
`f x' = f x + (x' - x) • deriv f x + o(x' - x)` where `x'` converges to `x`.
-/
def deriv (f : 𝕜 → F) (x : 𝕜) 
goal: F

full_name: hasFDerivAtFilter_iff_hasDerivAtFilter
code: /-- Expressing `HasFDerivAtFilter f f' x L` in terms of `HasDerivAtFilter` -/
theorem hasFDerivAtFilter_iff_hasDerivAtFilter {f' : 𝕜 →L[𝕜] F} :
    HasFDerivAtFilter f f' x L ↔ HasDerivAtFilter f (f' 1) x L 
goal: HasFDerivAtFilter f f' x L ↔ HasDerivAtFilter f (f' 1) x L

full_name: HasFDerivAtFilter.hasDerivAtFilter
code: theorem HasFDerivAtFilter.hasDerivAtFilter {f' : 𝕜 →L[𝕜] F} :
    HasFDerivAtFilter f f' x L → HasDerivAtFilter f (f' 1) x L 
goal: HasFDerivAtFilter f f' x L → HasDerivAtFilter f (f' 1) x L

full_name: hasFDerivWithinAt_iff_hasDerivWithinAt
code: /-- Expressing `HasFDerivWithinAt f f' s x` in terms of `HasDerivWithinAt` -/
theorem hasFDerivWithinAt_iff_hasDerivWithinAt {f' : 𝕜 →L[𝕜] F} :
    HasFDerivWithinAt f f' s x ↔ HasDerivWithinAt f (f' 1) s x 
goal: HasFDerivWithinAt f f' s x ↔ HasDerivWithinAt f (f' 1) s x

full_name: hasDerivWithinAt_iff_hasFDerivWithinAt
code: /-- Expressing `HasDerivWithinAt f f' s x` in terms of `HasFDerivWithinAt` -/
theorem hasDerivWithinAt_iff_hasFDerivWithinAt {f' : F} :
    HasDerivWithinAt f f' s x ↔ HasFDerivWithinAt f (smulRight (1 : 𝕜 →L[𝕜] 𝕜) f') s x 
goal: HasDerivWithinAt f f' s x ↔ HasFDerivWithinAt f (ContinuousLinearMap.smulRight 1 f') s x

full_name: HasFDerivWithinAt.hasDerivWithinAt
code: theorem HasFDerivWithinAt.hasDerivWithinAt {f' : 𝕜 →L[𝕜] F} :
    HasFDerivWithinAt f f' s x → HasDerivWithinAt f (f' 1) s x 
goal: HasFDerivWithinAt f f' s x → HasDerivWithinAt f (f' 1) s x

full_name: HasDerivWithinAt.hasFDerivWithinAt
code: theorem HasDerivWithinAt.hasFDerivWithinAt {f' : F} :
    HasDerivWithinAt f f' s x → HasFDerivWithinAt f (smulRight (1 : 𝕜 →L[𝕜] 𝕜) f') s x 
goal: HasDerivWithinAt f f' s x → HasFDerivWithinAt f (ContinuousLinearMap.smulRight 1 f') s x

full_name: hasFDerivAt_iff_hasDerivAt
code: /-- Expressing `HasFDerivAt f f' x` in terms of `HasDerivAt` -/
theorem hasFDerivAt_iff_hasDerivAt {f' : 𝕜 →L[𝕜] F} : HasFDerivAt f f' x ↔ HasDerivAt f (f' 1) x 
goal: HasFDerivAt f f' x ↔ HasDerivAt f (f' 1) x

full_name: HasFDerivAt.hasDerivAt
code: theorem HasFDerivAt.hasDerivAt {f' : 𝕜 →L[𝕜] F} : HasFDerivAt f f' x → HasDerivAt f (f' 1) x 
goal: HasFDerivAt f f' x → HasDerivAt f (f' 1) x

full_name: hasStrictFDerivAt_iff_hasStrictDerivAt
code: theorem hasStrictFDerivAt_iff_hasStrictDerivAt {f' : 𝕜 →L[𝕜] F} :
    HasStrictFDerivAt f f' x ↔ HasStrictDerivAt f (f' 1) x 
goal: HasStrictFDerivAt f f' x ↔ HasStrictDerivAt f (f' 1) x

full_name: HasStrictFDerivAt.hasStrictDerivAt
code: protected theorem HasStrictFDerivAt.hasStrictDerivAt {f' : 𝕜 →L[𝕜] F} :
    HasStrictFDerivAt f f' x → HasStrictDerivAt f (f' 1) x 
goal: HasStrictFDerivAt f f' x → HasStrictDerivAt f (f' 1) x

full_name: hasStrictDerivAt_iff_hasStrictFDerivAt
code: theorem hasStrictDerivAt_iff_hasStrictFDerivAt :
    HasStrictDerivAt f f' x ↔ HasStrictFDerivAt f (smulRight (1 : 𝕜 →L[𝕜] 𝕜) f') x 
goal: HasStrictDerivAt f f' x ↔ HasStrictFDerivAt f (ContinuousLinearMap.smulRight 1 f') x

full_name: hasDerivAt_iff_hasFDerivAt
code: /-- Expressing `HasDerivAt f f' x` in terms of `HasFDerivAt` -/
theorem hasDerivAt_iff_hasFDerivAt {f' : F} :
    HasDerivAt f f' x ↔ HasFDerivAt f (smulRight (1 : 𝕜 →L[𝕜] 𝕜) f') x 
goal: HasDerivAt f f' x ↔ HasFDerivAt f (ContinuousLinearMap.smulRight 1 f') x

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

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

full_name: derivWithin_zero_of_nmem_closure
code: theorem derivWithin_zero_of_nmem_closure (h : x ∉ closure s) : derivWithin f s x = 0 
goal: derivWithin f s x = 0

full_name: differentiableWithinAt_of_derivWithin_ne_zero
code: theorem differentiableWithinAt_of_derivWithin_ne_zero (h : derivWithin f s x ≠ 0) :
    DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 f s x

full_name: deriv_zero_of_not_differentiableAt
code: theorem deriv_zero_of_not_differentiableAt (h : ¬DifferentiableAt 𝕜 f x) : deriv f x = 0 
goal: deriv f x = 0

full_name: differentiableAt_of_deriv_ne_zero
code: theorem differentiableAt_of_deriv_ne_zero (h : deriv f x ≠ 0) : DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 f x

full_name: UniqueDiffWithinAt.eq_deriv
code: theorem UniqueDiffWithinAt.eq_deriv (s : Set 𝕜) (H : UniqueDiffWithinAt 𝕜 s x)
    (h : HasDerivWithinAt f f' s x) (h₁ : HasDerivWithinAt f f₁' s x) : f' = f₁' 
goal: f' = f₁'

full_name: hasDerivAtFilter_iff_isLittleO
code: theorem hasDerivAtFilter_iff_isLittleO :
    HasDerivAtFilter f f' x L ↔ (fun x' : 𝕜 => f x' - f x - (x' - x) • f') =o[L] fun x' => x' - x 
goal: HasDerivAtFilter f f' x L ↔ (fun x' => f x' - f x - (x' - x) • f') =o[L] fun x' => x' - x

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

full_name: hasDerivWithinAt_iff_isLittleO
code: theorem hasDerivWithinAt_iff_isLittleO :
    HasDerivWithinAt f f' s x ↔
      (fun x' : 𝕜 => f x' - f x - (x' - x) • f') =o[𝓝[s] x] fun x' => x' - x 
goal: HasDerivWithinAt f f' s x ↔ (fun x' => f x' - f x - (x' - x) • f') =o[𝓝[s] x] fun x' => x' - x

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

full_name: hasDerivAt_iff_isLittleO
code: theorem hasDerivAt_iff_isLittleO :
    HasDerivAt f f' x ↔ (fun x' : 𝕜 => f x' - f x - (x' - x) • f') =o[𝓝 x] fun x' => x' - x 
goal: HasDerivAt f f' x ↔ (fun x' => f x' - f x - (x' - x) • f') =o[𝓝 x] fun x' => x' - x

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

full_name: HasDerivAtFilter.isBigO_sub
code: theorem HasDerivAtFilter.isBigO_sub (h : HasDerivAtFilter 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: HasDerivAtFilter.isBigO_sub_rev
code: nonrec theorem HasDerivAtFilter.isBigO_sub_rev (hf : HasDerivAtFilter f f' x L) (hf' : f' ≠ 0) :
    (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: HasStrictDerivAt.hasDerivAt
code: theorem HasStrictDerivAt.hasDerivAt (h : HasStrictDerivAt f f' x) : HasDerivAt f f' x 
goal: HasDerivAt f f' x

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

full_name: hasDerivWithinAt_congr_set
code: theorem hasDerivWithinAt_congr_set {s t : Set 𝕜} (h : s =ᶠ[𝓝 x] t) :
    HasDerivWithinAt f f' s x ↔ HasDerivWithinAt f f' t x 
goal: HasDerivWithinAt f f' s x ↔ HasDerivWithinAt f f' t x

full_name: hasDerivWithinAt_diff_singleton
code: @[simp]
theorem hasDerivWithinAt_diff_singleton :
    HasDerivWithinAt f f' (s \ {x}) x ↔ HasDerivWithinAt f f' s x 
goal: HasDerivWithinAt f f' (s \ {x}) x ↔ HasDerivWithinAt f f' s x

full_name: hasDerivWithinAt_Ioi_iff_Ici
code: @[simp]
theorem hasDerivWithinAt_Ioi_iff_Ici [PartialOrder 𝕜] :
    HasDerivWithinAt f f' (Ioi x) x ↔ HasDerivWithinAt f f' (Ici x) x 
goal: HasDerivWithinAt f f' (Set.Ioi x) x ↔ HasDerivWithinAt f f' (Set.Ici x) x

full_name: hasDerivWithinAt_Iio_iff_Iic
code: @[simp]
theorem hasDerivWithinAt_Iio_iff_Iic [PartialOrder 𝕜] :
    HasDerivWithinAt f f' (Iio x) x ↔ HasDerivWithinAt f f' (Iic x) x 
goal: HasDerivWithinAt f f' (Set.Iio x) x ↔ HasDerivWithinAt f f' (Set.Iic x) x

full_name: HasDerivWithinAt.Ioi_iff_Ioo
code: theorem HasDerivWithinAt.Ioi_iff_Ioo [LinearOrder 𝕜] [OrderClosedTopology 𝕜] {x y : 𝕜} (h : x < y) :
    HasDerivWithinAt f f' (Ioo x y) x ↔ HasDerivWithinAt f f' (Ioi x) x 
goal: HasDerivWithinAt f f' (Set.Ioo x y) x ↔ HasDerivWithinAt f f' (Set.Ioi x) x

full_name: hasDerivAt_iff_isLittleO_nhds_zero
code: theorem hasDerivAt_iff_isLittleO_nhds_zero :
    HasDerivAt f f' x ↔ (fun h => f (x + h) - f x - h • f') =o[𝓝 0] fun h => h 
goal: HasDerivAt f f' x ↔ (fun h => f (x + h) - f x - h • f') =o[𝓝 0] fun h => h

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

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

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

full_name: HasDerivAt.hasDerivAtFilter
code: theorem HasDerivAt.hasDerivAtFilter (h : HasDerivAt f f' x) (hL : L ≤ 𝓝 x) :
    HasDerivAtFilter f f' x L 
goal: HasDerivAtFilter f f' x L

full_name: HasDerivAt.hasDerivWithinAt
code: theorem HasDerivAt.hasDerivWithinAt (h : HasDerivAt f f' x) : HasDerivWithinAt f f' s x 
goal: HasDerivWithinAt f f' s x

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

full_name: HasDerivAt.differentiableAt
code: theorem HasDerivAt.differentiableAt (h : HasDerivAt f f' x) : DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 f x

full_name: hasDerivWithinAt_univ
code: @[simp]
theorem hasDerivWithinAt_univ : HasDerivWithinAt f f' univ x ↔ HasDerivAt f f' x 
goal: HasDerivWithinAt f f' Set.univ x ↔ HasDerivAt f f' x

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

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

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

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

full_name: HasDerivWithinAt.hasDerivAt
code: theorem HasDerivWithinAt.hasDerivAt (h : HasDerivWithinAt f f' s x) (hs : s ∈ 𝓝 x) :
    HasDerivAt f f' x 
goal: HasDerivAt f f' x

full_name: DifferentiableWithinAt.hasDerivWithinAt
code: theorem DifferentiableWithinAt.hasDerivWithinAt (h : DifferentiableWithinAt 𝕜 f s x) :
    HasDerivWithinAt f (derivWithin f s x) s x 
goal: HasDerivWithinAt f (derivWithin f s x) s x

full_name: DifferentiableAt.hasDerivAt
code: theorem DifferentiableAt.hasDerivAt (h : DifferentiableAt 𝕜 f x) : HasDerivAt f (deriv f x) x 
goal: HasDerivAt f (deriv f x) x

full_name: hasDerivAt_deriv_iff
code: @[simp]
theorem hasDerivAt_deriv_iff : HasDerivAt f (deriv f x) x ↔ DifferentiableAt 𝕜 f x 
goal: HasDerivAt f (deriv f x) x ↔ DifferentiableAt 𝕜 f x

full_name: hasDerivWithinAt_derivWithin_iff
code: @[simp]
theorem hasDerivWithinAt_derivWithin_iff :
    HasDerivWithinAt f (derivWithin f s x) s x ↔ DifferentiableWithinAt 𝕜 f s x 
goal: HasDerivWithinAt f (derivWithin f s x) s x ↔ DifferentiableWithinAt 𝕜 f s x

full_name: DifferentiableOn.hasDerivAt
code: theorem DifferentiableOn.hasDerivAt (h : DifferentiableOn 𝕜 f s) (hs : s ∈ 𝓝 x) :
    HasDerivAt f (deriv f x) x 
goal: HasDerivAt f (deriv f x) x

full_name: HasDerivAt.deriv
code: theorem HasDerivAt.deriv (h : HasDerivAt f f' x) : deriv f x = f' 
goal: deriv f x = f'

full_name: deriv_eq
code: theorem deriv_eq {f' : 𝕜 → F} (h : ∀ x, HasDerivAt f (f' x) x) : deriv f = f' 
goal: deriv f = f'

full_name: HasDerivWithinAt.derivWithin
code: theorem HasDerivWithinAt.derivWithin (h : HasDerivWithinAt f f' s x)
    (hxs : UniqueDiffWithinAt 𝕜 s x) : derivWithin f s x = f' 
goal: derivWithin f s x = f'

full_name: fderivWithin_derivWithin
code: theorem fderivWithin_derivWithin : (fderivWithin 𝕜 f s x : 𝕜 → F) 1 = derivWithin f s x 
goal: (fderivWithin 𝕜 f s x) 1 = derivWithin f s x

full_name: derivWithin_fderivWithin
code: theorem derivWithin_fderivWithin :
    smulRight (1 : 𝕜 →L[𝕜] 𝕜) (derivWithin f s x) = fderivWithin 𝕜 f s x 
goal: ContinuousLinearMap.smulRight 1 (derivWithin f s x) = fderivWithin 𝕜 f s x

full_name: norm_derivWithin_eq_norm_fderivWithin
code: theorem norm_derivWithin_eq_norm_fderivWithin : ‖derivWithin f s x‖ = ‖fderivWithin 𝕜 f s x‖ 
goal: ‖derivWithin f s x‖ = ‖fderivWithin 𝕜 f s x‖

full_name: fderiv_deriv
code: theorem fderiv_deriv : (fderiv 𝕜 f x : 𝕜 → F) 1 = deriv f x 
goal: (fderiv 𝕜 f x) 1 = deriv f x

full_name: fderiv_eq_smul_deriv
code: @[simp]
theorem fderiv_eq_smul_deriv (y : 𝕜) : (fderiv 𝕜 f x : 𝕜 → F) y = y • deriv f x 
goal: (fderiv 𝕜 f x) y = y • deriv f x

full_name: deriv_fderiv
code: theorem deriv_fderiv : smulRight (1 : 𝕜 →L[𝕜] 𝕜) (deriv f x) = fderiv 𝕜 f x 
goal: ContinuousLinearMap.smulRight 1 (deriv f x) = fderiv 𝕜 f x

full_name: fderiv_eq_deriv_mul
code: lemma fderiv_eq_deriv_mul {f : 𝕜 → 𝕜} {x y : 𝕜} : (fderiv 𝕜 f x : 𝕜 → 𝕜) y = (deriv f x) * y 
goal: (fderiv 𝕜 f x) y = deriv f x * y

full_name: norm_deriv_eq_norm_fderiv
code: theorem norm_deriv_eq_norm_fderiv : ‖deriv f x‖ = ‖fderiv 𝕜 f x‖ 
goal: ‖deriv f x‖ = ‖fderiv 𝕜 f x‖

full_name: DifferentiableAt.derivWithin
code: theorem DifferentiableAt.derivWithin (h : DifferentiableAt 𝕜 f x) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin f s x = deriv f x 
goal: derivWithin f s x = deriv f x

full_name: HasDerivWithinAt.deriv_eq_zero
code: theorem HasDerivWithinAt.deriv_eq_zero (hd : HasDerivWithinAt f 0 s x)
    (H : UniqueDiffWithinAt 𝕜 s x) : deriv f x = 0 
goal: deriv f x = 0

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

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

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

full_name: derivWithin_congr_set
code: theorem derivWithin_congr_set (h : s =ᶠ[𝓝 x] t) : derivWithin f s x = derivWithin f t x 
goal: derivWithin f s x = derivWithin f t x

full_name: derivWithin_univ
code: @[simp]
theorem derivWithin_univ : derivWithin f univ = deriv f 
goal: derivWithin f Set.univ = deriv f

full_name: derivWithin_inter
code: theorem derivWithin_inter (ht : t ∈ 𝓝 x) : derivWithin f (s ∩ t) x = derivWithin f s x 
goal: derivWithin f (s ∩ t) x = derivWithin f s x

full_name: derivWithin_of_mem_nhds
code: theorem derivWithin_of_mem_nhds (h : s ∈ 𝓝 x) : derivWithin f s x = deriv f x 
goal: derivWithin f s x = deriv f x

full_name: derivWithin_of_isOpen
code: theorem derivWithin_of_isOpen (hs : IsOpen s) (hx : x ∈ s) : derivWithin f s x = deriv f x 
goal: derivWithin f s x = deriv f x

full_name: deriv_eqOn
code: lemma deriv_eqOn {f' : 𝕜 → F} (hs : IsOpen s) (hf' : ∀ x ∈ s, HasDerivWithinAt f (f' x) s x) :
    s.EqOn (deriv f) f' 
goal: Set.EqOn (deriv f) f' s

full_name: deriv_mem_iff
code: theorem deriv_mem_iff {f : 𝕜 → F} {s : Set F} {x : 𝕜} :
    deriv f x ∈ s ↔
      DifferentiableAt 𝕜 f x ∧ deriv f x ∈ s ∨ ¬DifferentiableAt 𝕜 f x ∧ (0 : F) ∈ s 
goal: deriv f x ∈ s ↔ DifferentiableAt 𝕜 f x ∧ deriv f x ∈ s ∨ ¬DifferentiableAt 𝕜 f x ∧ 0 ∈ s

full_name: derivWithin_mem_iff
code: theorem derivWithin_mem_iff {f : 𝕜 → F} {t : Set 𝕜} {s : Set F} {x : 𝕜} :
    derivWithin f t x ∈ s ↔
      DifferentiableWithinAt 𝕜 f t x ∧ derivWithin f t x ∈ s ∨
        ¬DifferentiableWithinAt 𝕜 f t x ∧ (0 : F) ∈ s 
goal: derivWithin f t x ∈ s ↔ DifferentiableWithinAt 𝕜 f t x ∧ derivWithin f t x ∈ s ∨ ¬DifferentiableWithinAt 𝕜 f t x ∧ 0 ∈ s

full_name: differentiableWithinAt_Ioi_iff_Ici
code: theorem differentiableWithinAt_Ioi_iff_Ici [PartialOrder 𝕜] :
    DifferentiableWithinAt 𝕜 f (Ioi x) x ↔ DifferentiableWithinAt 𝕜 f (Ici x) x 
goal: DifferentiableWithinAt 𝕜 f (Set.Ioi x) x ↔ DifferentiableWithinAt 𝕜 f (Set.Ici x) x

full_name: derivWithin_Ioi_eq_Ici
code: theorem derivWithin_Ioi_eq_Ici {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] (f : ℝ → E)
    (x : ℝ) : derivWithin f (Ioi x) x = derivWithin f (Ici x) x 
goal: derivWithin f (Set.Ioi x) x = derivWithin f (Set.Ici x) x

full_name: Filter.EventuallyEq.hasDerivAtFilter_iff
code: theorem Filter.EventuallyEq.hasDerivAtFilter_iff (h₀ : f₀ =ᶠ[L] f₁) (hx : f₀ x = f₁ x)
    (h₁ : f₀' = f₁') : HasDerivAtFilter f₀ f₀' x L ↔ HasDerivAtFilter f₁ f₁' x L 
goal: HasDerivAtFilter f₀ f₀' x L ↔ HasDerivAtFilter f₁ f₁' x L

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

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

full_name: HasDerivWithinAt.congr
code: theorem HasDerivWithinAt.congr (h : HasDerivWithinAt f f' s x) (hs : ∀ x ∈ s, f₁ x = f x)
    (hx : f₁ x = f x) : HasDerivWithinAt f₁ f' s x 
goal: HasDerivWithinAt f₁ f' s x

full_name: HasDerivWithinAt.congr_of_mem
code: theorem HasDerivWithinAt.congr_of_mem (h : HasDerivWithinAt f f' s x) (hs : ∀ x ∈ s, f₁ x = f x)
    (hx : x ∈ s) : HasDerivWithinAt f₁ f' s x 
goal: HasDerivWithinAt f₁ f' s x

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

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

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

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

full_name: HasStrictDerivAt.congr_deriv
code: theorem HasStrictDerivAt.congr_deriv (h : HasStrictDerivAt f f' x) (h' : f' = g') :
    HasStrictDerivAt f g' x 
goal: HasStrictDerivAt f g' x

full_name: HasDerivAt.congr_deriv
code: theorem HasDerivAt.congr_deriv (h : HasDerivAt f f' x) (h' : f' = g') : HasDerivAt f g' x 
goal: HasDerivAt f g' x

full_name: HasDerivWithinAt.congr_deriv
code: theorem HasDerivWithinAt.congr_deriv (h : HasDerivWithinAt f f' s x) (h' : f' = g') :
    HasDerivWithinAt f g' s x 
goal: HasDerivWithinAt f g' s x

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

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

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

full_name: derivWithin_congr
code: theorem derivWithin_congr (hs : EqOn f₁ f s) (hx : f₁ x = f x) :
    derivWithin f₁ s x = derivWithin f s x 
goal: derivWithin f₁ s x = derivWithin f s x

full_name: Filter.EventuallyEq.deriv_eq
code: theorem Filter.EventuallyEq.deriv_eq (hL : f₁ =ᶠ[𝓝 x] f) : deriv f₁ x = deriv f x 
goal: deriv f₁ x = deriv f x

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

full_name: hasDerivAtFilter_id
code: theorem hasDerivAtFilter_id : HasDerivAtFilter id 1 x L 
goal: HasDerivAtFilter id 1 x L

full_name: hasDerivWithinAt_id
code: theorem hasDerivWithinAt_id : HasDerivWithinAt id 1 s x 
goal: HasDerivWithinAt id 1 s x

full_name: hasDerivAt_id
code: theorem hasDerivAt_id : HasDerivAt id 1 x 
goal: HasDerivAt id 1 x

full_name: hasDerivAt_id'
code: theorem hasDerivAt_id' : HasDerivAt (fun x : 𝕜 => x) 1 x 
goal: HasDerivAt (fun x => x) 1 x

full_name: hasStrictDerivAt_id
code: theorem hasStrictDerivAt_id : HasStrictDerivAt id 1 x 
goal: HasStrictDerivAt id 1 x

full_name: deriv_id
code: theorem deriv_id : deriv id x = 1 
goal: deriv id x = 1

full_name: deriv_id'
code: @[simp]
theorem deriv_id' : deriv (@id 𝕜) = fun _ => 1 
goal: deriv id = fun x => 1

full_name: deriv_id''
code: @[simp]
theorem deriv_id'' : (deriv fun x : 𝕜 => x) = fun _ => 1 
goal: (deriv fun x => x) = fun x => 1

full_name: derivWithin_id
code: theorem derivWithin_id (hxs : UniqueDiffWithinAt 𝕜 s x) : derivWithin id s x = 1 
goal: derivWithin id s x = 1

full_name: hasDerivAtFilter_const
code: theorem hasDerivAtFilter_const : HasDerivAtFilter (fun _ => c) 0 x L 
goal: HasDerivAtFilter (fun x => c) 0 x L

full_name: hasStrictDerivAt_const
code: theorem hasStrictDerivAt_const : HasStrictDerivAt (fun _ => c) 0 x 
goal: HasStrictDerivAt (fun x => c) 0 x

full_name: hasDerivWithinAt_const
code: theorem hasDerivWithinAt_const : HasDerivWithinAt (fun _ => c) 0 s x 
goal: HasDerivWithinAt (fun x => c) 0 s x

full_name: hasDerivAt_const
code: theorem hasDerivAt_const : HasDerivAt (fun _ => c) 0 x 
goal: HasDerivAt (fun x => c) 0 x

full_name: deriv_const
code: theorem deriv_const : deriv (fun _ => c) x = 0 
goal: deriv (fun x => c) x = 0

full_name: deriv_const'
code: @[simp]
theorem deriv_const' : (deriv fun _ : 𝕜 => c) = fun _ => 0 
goal: (deriv fun x => c) = fun x => 0

full_name: derivWithin_const
code: theorem derivWithin_const (hxs : UniqueDiffWithinAt 𝕜 s x) : derivWithin (fun _ => c) s x = 0 
goal: derivWithin (fun x => c) s x = 0

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

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

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

full_name: HasDerivAt.continuousOn
code: protected theorem HasDerivAt.continuousOn {f f' : 𝕜 → F} (hderiv : ∀ x ∈ s, HasDerivAt f (f' x) x) :
    ContinuousOn f s 
goal: ContinuousOn f s

full_name: HasDerivAt.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 HasDerivAt.le_of_lip' {f : 𝕜 → F} {f' : F} {x₀ : 𝕜} (hf : HasDerivAt 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: HasDerivAt.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 HasDerivAt.le_of_lipschitzOn {f : 𝕜 → F} {f' : F} {x₀ : 𝕜} (hf : HasDerivAt f f' x₀)
    {s : Set 𝕜} (hs : s ∈ 𝓝 x₀) {C : ℝ≥0} (hlip : LipschitzOnWith C f s) : ‖f'‖ ≤ C 
goal: ‖f'‖ ≤ ↑C

full_name: HasDerivAt.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 HasDerivAt.le_of_lipschitz {f : 𝕜 → F} {f' : F} {x₀ : 𝕜} (hf : HasDerivAt f f' x₀)
    {C : ℝ≥0} (hlip : LipschitzWith C f) : ‖f'‖ ≤ C 
goal: ‖f'‖ ≤ ↑C

full_name: norm_deriv_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_deriv_le_of_lip' {f : 𝕜 → F} {x₀ : 𝕜}
    {C : ℝ} (hC₀ : 0 ≤ C) (hlip : ∀ᶠ x in 𝓝 x₀, ‖f x - f x₀‖ ≤ C * ‖x - x₀‖) :
    ‖deriv f x₀‖ ≤ C 
goal: ‖deriv f x₀‖ ≤ C

full_name: norm_deriv_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 `deriv`. -/
theorem norm_deriv_le_of_lipschitzOn {f : 𝕜 → F} {x₀ : 𝕜} {s : Set 𝕜} (hs : s ∈ 𝓝 x₀)
    {C : ℝ≥0} (hlip : LipschitzOnWith C f s) : ‖deriv f x₀‖ ≤ C 
goal: ‖deriv f x₀‖ ≤ ↑C

full_name: norm_deriv_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 `deriv`. -/
theorem norm_deriv_le_of_lipschitz {f : 𝕜 → F} {x₀ : 𝕜}
    {C : ℝ≥0} (hlip : LipschitzWith C f) : ‖deriv f x₀‖ ≤ C 
goal: ‖deriv f x₀‖ ≤ ↑C