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

full_name: HasGradientAtFilter
code: /-- A function `f` has the gradient `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`. -/
def HasGradientAtFilter (f : F → 𝕜) (f' x : F) (L : Filter F) 
goal: Prop

full_name: HasGradientWithinAt
code: /-- `f` has the gradient `f'` at the point `x` within the subset `s` if
  `f x' = f x + ⟨f', x' - x⟩ + o (x' - x)` where `x'` converges to `x` inside `s`. -/
def HasGradientWithinAt (f : F → 𝕜) (f' : F) (s : Set F) (x : F) 
goal: Prop

full_name: HasGradientAt
code: /-- `f` has the gradient `f'` at the point `x` if
  `f x' = f x + ⟨f', x' - x⟩ + o (x' - x)` where `x'` converges to `x`. -/
def HasGradientAt (f : F → 𝕜) (f' x : F) 
goal: Prop

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

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

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

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

full_name: Gradient.«_aux_Mathlib_Analysis_Calculus_Gradient_Basic___macroRules_Gradient_term∇_1»
code: @[inherit_doc]
scoped[Gradient] notation "∇" => gradient
goal: Lean.Macro

full_name: Gradient._aux_Mathlib_Analysis_Calculus_Gradient_Basic___unexpand_gradient_1
code: @[inherit_doc]
scoped[Gradient] notation "∇" => gradient
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Analysis_Calculus_Gradient_Basic___macroRules_term⟪_,_⟫_1»
code: local notation "⟪" x ", " y "⟫" => @inner 𝕜 _ _ x y
goal: Lean.Macro

full_name: hasGradientWithinAt_iff_hasFDerivWithinAt
code: theorem hasGradientWithinAt_iff_hasFDerivWithinAt {s : Set F} :
    HasGradientWithinAt f f' s x ↔ HasFDerivWithinAt f (toDual 𝕜 F f') s x 
goal: HasGradientWithinAt f f' s x ↔ HasFDerivWithinAt f ((InnerProductSpace.toDual 𝕜 F) f') s x

full_name: hasFDerivWithinAt_iff_hasGradientWithinAt
code: theorem hasFDerivWithinAt_iff_hasGradientWithinAt {frechet : F →L[𝕜] 𝕜} {s : Set F} :
    HasFDerivWithinAt f frechet s x ↔ HasGradientWithinAt f ((toDual 𝕜 F).symm frechet) s x 
goal: HasFDerivWithinAt f frechet s x ↔ HasGradientWithinAt f ((InnerProductSpace.toDual 𝕜 F).symm frechet) s x

full_name: hasGradientAt_iff_hasFDerivAt
code: theorem hasGradientAt_iff_hasFDerivAt :
    HasGradientAt f f' x ↔ HasFDerivAt f (toDual 𝕜 F f') x 
goal: HasGradientAt f f' x ↔ HasFDerivAt f ((InnerProductSpace.toDual 𝕜 F) f') x

full_name: hasFDerivAt_iff_hasGradientAt
code: theorem hasFDerivAt_iff_hasGradientAt {frechet : F →L[𝕜] 𝕜} :
    HasFDerivAt f frechet x ↔ HasGradientAt f ((toDual 𝕜 F).symm frechet) x 
goal: HasFDerivAt f frechet x ↔ HasGradientAt f ((InnerProductSpace.toDual 𝕜 F).symm frechet) x

full_name: gradient_eq_zero_of_not_differentiableAt
code: theorem gradient_eq_zero_of_not_differentiableAt (h : ¬DifferentiableAt 𝕜 f x) : ∇ f x = 0 
goal: ∇ f x = 0

full_name: HasGradientAt.unique
code: theorem HasGradientAt.unique {gradf gradg : F}
    (hf : HasGradientAt f gradf x) (hg : HasGradientAt f gradg x) :
    gradf = gradg 
goal: gradf = gradg

full_name: DifferentiableAt.hasGradientAt
code: theorem DifferentiableAt.hasGradientAt (h : DifferentiableAt 𝕜 f x) :
    HasGradientAt f (∇ f x) x 
goal: HasGradientAt f (∇ f x) x

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

full_name: DifferentiableWithinAt.hasGradientWithinAt
code: theorem DifferentiableWithinAt.hasGradientWithinAt (h : DifferentiableWithinAt 𝕜 f s x) :
    HasGradientWithinAt f (gradientWithin f s x) s x 
goal: HasGradientWithinAt f (gradientWithin f s x) s x

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

full_name: hasGradientWithinAt_univ
code: @[simp]
theorem hasGradientWithinAt_univ : HasGradientWithinAt f f' univ x ↔ HasGradientAt f f' x 
goal: HasGradientWithinAt f f' Set.univ x ↔ HasGradientAt f f' x

full_name: DifferentiableOn.hasGradientAt
code: theorem DifferentiableOn.hasGradientAt (h : DifferentiableOn 𝕜 f s) (hs : s ∈ 𝓝 x) :
    HasGradientAt f (∇ f x) x 
goal: HasGradientAt f (∇ f x) x

full_name: HasGradientAt.gradient
code: theorem HasGradientAt.gradient (h : HasGradientAt f f' x) : ∇ f x = f' 
goal: ∇ f x = f'

full_name: gradient_eq
code: theorem gradient_eq {f' : F → F} (h : ∀ x, HasGradientAt f (f' x) x) : ∇ f = f' 
goal: ∇ f = f'

full_name: HasGradientAtFilter.hasDerivAtFilter
code: theorem HasGradientAtFilter.hasDerivAtFilter (h : HasGradientAtFilter g g' u L') :
    HasDerivAtFilter g (starRingEnd 𝕜 g') u L' 
goal: HasDerivAtFilter g ((starRingEnd 𝕜) g') u L'

full_name: HasDerivAtFilter.hasGradientAtFilter
code: theorem HasDerivAtFilter.hasGradientAtFilter (h : HasDerivAtFilter g g' u L') :
    HasGradientAtFilter g (starRingEnd 𝕜 g') u L' 
goal: HasGradientAtFilter g ((starRingEnd 𝕜) g') u L'

full_name: HasGradientAt.hasDerivAt
code: theorem HasGradientAt.hasDerivAt (h : HasGradientAt g g' u) :
    HasDerivAt g (starRingEnd 𝕜 g') u 
goal: HasDerivAt g ((starRingEnd 𝕜) g') u

full_name: HasDerivAt.hasGradientAt
code: theorem HasDerivAt.hasGradientAt (h : HasDerivAt g g' u) :
    HasGradientAt g (starRingEnd 𝕜 g') u 
goal: HasGradientAt g ((starRingEnd 𝕜) g') u

full_name: gradient_eq_deriv
code: theorem gradient_eq_deriv : ∇ g u = starRingEnd 𝕜 (deriv g u) 
goal: ∇ g u = (starRingEnd 𝕜) (deriv g u)

full_name: HasGradientAtFilter.hasDerivAtFilter'
code: theorem HasGradientAtFilter.hasDerivAtFilter' (h : HasGradientAtFilter g g' u L') :
    HasDerivAtFilter g g' u L' 
goal: HasDerivAtFilter g g' u L'

full_name: HasDerivAtFilter.hasGradientAtFilter'
code: theorem HasDerivAtFilter.hasGradientAtFilter' (h : HasDerivAtFilter g g' u L') :
    HasGradientAtFilter g g' u L' 
goal: HasGradientAtFilter g g' u L'

full_name: HasGradientAt.hasDerivAt'
code: theorem HasGradientAt.hasDerivAt' (h : HasGradientAt g g' u) :
    HasDerivAt g g' u 
goal: HasDerivAt g g' u

full_name: HasDerivAt.hasGradientAt'
code: theorem HasDerivAt.hasGradientAt' (h : HasDerivAt g g' u) :
    HasGradientAt g g' u 
goal: HasGradientAt g g' u

full_name: gradient_eq_deriv'
code: theorem gradient_eq_deriv' : ∇ g u = deriv g u 
goal: ∇ g u = deriv g u

full_name: hasGradientAtFilter_iff_isLittleO
code: theorem hasGradientAtFilter_iff_isLittleO :
    HasGradientAtFilter f f' x L ↔
    (fun x' : F => f x' - f x - ⟪f', x' - x⟫) =o[L] fun x' => x' - x 
goal: HasGradientAtFilter f f' x L ↔ (fun x' => f x' - f x - ⟪f', x' - x⟫_𝕜) =o[L] fun x' => x' - x

full_name: hasGradientWithinAt_iff_isLittleO
code: theorem hasGradientWithinAt_iff_isLittleO :
    HasGradientWithinAt f f' s x ↔
    (fun x' : F => f x' - f x - ⟪f', x' - x⟫) =o[𝓝[s] x] fun x' => x' - x 
goal: HasGradientWithinAt f f' s x ↔ (fun x' => f x' - f x - ⟪f', x' - x⟫_𝕜) =o[𝓝[s] x] fun x' => x' - x

full_name: hasGradientWithinAt_iff_tendsto
code: theorem hasGradientWithinAt_iff_tendsto :
    HasGradientWithinAt f f' s x ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - ⟪f', x' - x⟫‖) (𝓝[s] x) (𝓝 0) 
goal: HasGradientWithinAt f f' s x ↔ Filter.Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - ⟪f', x' - x⟫_𝕜‖) (𝓝[s] x) (𝓝 0)

full_name: hasGradientAt_iff_isLittleO
code: theorem hasGradientAt_iff_isLittleO : HasGradientAt f f' x ↔
    (fun x' : F => f x' - f x - ⟪f', x' - x⟫) =o[𝓝 x] fun x' => x' - x 
goal: HasGradientAt f f' x ↔ (fun x' => f x' - f x - ⟪f', x' - x⟫_𝕜) =o[𝓝 x] fun x' => x' - x

full_name: hasGradientAt_iff_tendsto
code: theorem hasGradientAt_iff_tendsto :
    HasGradientAt f f' x ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - ⟪f', x' - x⟫‖) (𝓝 x) (𝓝 0) 
goal: HasGradientAt f f' x ↔ Filter.Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - ⟪f', x' - x⟫_𝕜‖) (𝓝 x) (𝓝 0)

full_name: HasGradientAtFilter.isBigO_sub
code: theorem HasGradientAtFilter.isBigO_sub (h : HasGradientAtFilter 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: hasGradientWithinAt_congr_set'
code: theorem hasGradientWithinAt_congr_set' {s t : Set F} (y : F) (h : s =ᶠ[𝓝[{y}ᶜ] x] t) :
    HasGradientWithinAt f f' s x ↔ HasGradientWithinAt f f' t x 
goal: HasGradientWithinAt f f' s x ↔ HasGradientWithinAt f f' t x

full_name: hasGradientWithinAt_congr_set
code: theorem hasGradientWithinAt_congr_set {s t : Set F} (h : s =ᶠ[𝓝 x] t) :
    HasGradientWithinAt f f' s x ↔ HasGradientWithinAt f f' t x 
goal: HasGradientWithinAt f f' s x ↔ HasGradientWithinAt f f' t x

full_name: hasGradientAt_iff_isLittleO_nhds_zero
code: theorem hasGradientAt_iff_isLittleO_nhds_zero : HasGradientAt f f' x ↔
    (fun h => f (x + h) - f x - ⟪f', h⟫) =o[𝓝 0] fun h => h 
goal: HasGradientAt f f' x ↔ (fun h => f (x + h) - f x - ⟪f', h⟫_𝕜) =o[𝓝 0] fun h => h

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

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

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

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

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

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

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

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

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

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

full_name: hasGradientAtFilter_const
code: theorem hasGradientAtFilter_const : HasGradientAtFilter (fun _ => c) 0 x L 
goal: HasGradientAtFilter (fun x => c) 0 x L

full_name: hasGradientWithinAt_const
code: theorem hasGradientWithinAt_const : HasGradientWithinAt (fun _ => c) 0 s x 
goal: HasGradientWithinAt (fun x => c) 0 s x

full_name: hasGradientAt_const
code: theorem hasGradientAt_const : HasGradientAt (fun _ => c) 0 x 
goal: HasGradientAt (fun x => c) 0 x

full_name: gradient_const
code: theorem gradient_const : ∇ (fun _ => c) x = 0 
goal: ∇ (fun x => c) x = 0

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

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

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

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

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