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

full_name: HasStrictFDerivAt.const_smul
code: @[fun_prop]
theorem HasStrictFDerivAt.const_smul (h : HasStrictFDerivAt f f' x) (c : R) :
    HasStrictFDerivAt (fun x => c • f x) (c • f') x 
goal: HasStrictFDerivAt (fun x => c • f x) (c • f') x

full_name: HasFDerivAtFilter.const_smul
code: theorem HasFDerivAtFilter.const_smul (h : HasFDerivAtFilter f f' x L) (c : R) :
    HasFDerivAtFilter (fun x => c • f x) (c • f') x L 
goal: HasFDerivAtFilter (fun x => c • f x) (c • f') x L

full_name: HasFDerivWithinAt.const_smul
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.const_smul (h : HasFDerivWithinAt f f' s x) (c : R) :
    HasFDerivWithinAt (fun x => c • f x) (c • f') s x 
goal: HasFDerivWithinAt (fun x => c • f x) (c • f') s x

full_name: HasFDerivAt.const_smul
code: @[fun_prop]
nonrec theorem HasFDerivAt.const_smul (h : HasFDerivAt f f' x) (c : R) :
    HasFDerivAt (fun x => c • f x) (c • f') x 
goal: HasFDerivAt (fun x => c • f x) (c • f') x

full_name: DifferentiableWithinAt.const_smul
code: @[fun_prop]
theorem DifferentiableWithinAt.const_smul (h : DifferentiableWithinAt 𝕜 f s x) (c : R) :
    DifferentiableWithinAt 𝕜 (fun y => c • f y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => c • f y) s x

full_name: DifferentiableAt.const_smul
code: @[fun_prop]
theorem DifferentiableAt.const_smul (h : DifferentiableAt 𝕜 f x) (c : R) :
    DifferentiableAt 𝕜 (fun y => c • f y) x 
goal: DifferentiableAt 𝕜 (fun y => c • f y) x

full_name: DifferentiableOn.const_smul
code: @[fun_prop]
theorem DifferentiableOn.const_smul (h : DifferentiableOn 𝕜 f s) (c : R) :
    DifferentiableOn 𝕜 (fun y => c • f y) s 
goal: DifferentiableOn 𝕜 (fun y => c • f y) s

full_name: Differentiable.const_smul
code: @[fun_prop]
theorem Differentiable.const_smul (h : Differentiable 𝕜 f) (c : R) :
    Differentiable 𝕜 fun y => c • f y 
goal: Differentiable 𝕜 fun y => c • f y

full_name: fderivWithin_const_smul
code: theorem fderivWithin_const_smul (hxs : UniqueDiffWithinAt 𝕜 s x)
    (h : DifferentiableWithinAt 𝕜 f s x) (c : R) :
    fderivWithin 𝕜 (fun y => c • f y) s x = c • fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 (fun y => c • f y) s x = c • fderivWithin 𝕜 f s x

full_name: fderiv_const_smul
code: theorem fderiv_const_smul (h : DifferentiableAt 𝕜 f x) (c : R) :
    fderiv 𝕜 (fun y => c • f y) x = c • fderiv 𝕜 f x 
goal: fderiv 𝕜 (fun y => c • f y) x = c • fderiv 𝕜 f x

full_name: HasStrictFDerivAt.add
code: @[fun_prop]
nonrec theorem HasStrictFDerivAt.add (hf : HasStrictFDerivAt f f' x)
    (hg : HasStrictFDerivAt g g' x) : HasStrictFDerivAt (fun y => f y + g y) (f' + g') x 
goal: HasStrictFDerivAt (fun y => f y + g y) (f' + g') x

full_name: HasFDerivAtFilter.add
code: theorem HasFDerivAtFilter.add (hf : HasFDerivAtFilter f f' x L)
    (hg : HasFDerivAtFilter g g' x L) : HasFDerivAtFilter (fun y => f y + g y) (f' + g') x L 
goal: HasFDerivAtFilter (fun y => f y + g y) (f' + g') x L

full_name: HasFDerivWithinAt.add
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.add (hf : HasFDerivWithinAt f f' s x)
    (hg : HasFDerivWithinAt g g' s x) : HasFDerivWithinAt (fun y => f y + g y) (f' + g') s x 
goal: HasFDerivWithinAt (fun y => f y + g y) (f' + g') s x

full_name: HasFDerivAt.add
code: @[fun_prop]
nonrec theorem HasFDerivAt.add (hf : HasFDerivAt f f' x) (hg : HasFDerivAt g g' x) :
    HasFDerivAt (fun x => f x + g x) (f' + g') x 
goal: HasFDerivAt (fun x => f x + g x) (f' + g') x

full_name: DifferentiableWithinAt.add
code: @[fun_prop]
theorem DifferentiableWithinAt.add (hf : DifferentiableWithinAt 𝕜 f s x)
    (hg : DifferentiableWithinAt 𝕜 g s x) : DifferentiableWithinAt 𝕜 (fun y => f y + g y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => f y + g y) s x

full_name: DifferentiableAt.add
code: @[simp, fun_prop]
theorem DifferentiableAt.add (hf : DifferentiableAt 𝕜 f x) (hg : DifferentiableAt 𝕜 g x) :
    DifferentiableAt 𝕜 (fun y => f y + g y) x 
goal: DifferentiableAt 𝕜 (fun y => f y + g y) x

full_name: DifferentiableOn.add
code: @[fun_prop]
theorem DifferentiableOn.add (hf : DifferentiableOn 𝕜 f s) (hg : DifferentiableOn 𝕜 g s) :
    DifferentiableOn 𝕜 (fun y => f y + g y) s 
goal: DifferentiableOn 𝕜 (fun y => f y + g y) s

full_name: Differentiable.add
code: @[simp, fun_prop]
theorem Differentiable.add (hf : Differentiable 𝕜 f) (hg : Differentiable 𝕜 g) :
    Differentiable 𝕜 fun y => f y + g y 
goal: Differentiable 𝕜 fun y => f y + g y

full_name: fderivWithin_add
code: theorem fderivWithin_add (hxs : UniqueDiffWithinAt 𝕜 s x) (hf : DifferentiableWithinAt 𝕜 f s x)
    (hg : DifferentiableWithinAt 𝕜 g s x) :
    fderivWithin 𝕜 (fun y => f y + g y) s x = fderivWithin 𝕜 f s x + fderivWithin 𝕜 g s x 
goal: fderivWithin 𝕜 (fun y => f y + g y) s x = fderivWithin 𝕜 f s x + fderivWithin 𝕜 g s x

full_name: fderiv_add
code: theorem fderiv_add (hf : DifferentiableAt 𝕜 f x) (hg : DifferentiableAt 𝕜 g x) :
    fderiv 𝕜 (fun y => f y + g y) x = fderiv 𝕜 f x + fderiv 𝕜 g x 
goal: fderiv 𝕜 (fun y => f y + g y) x = fderiv 𝕜 f x + fderiv 𝕜 g x

full_name: HasStrictFDerivAt.add_const
code: @[fun_prop]
theorem HasStrictFDerivAt.add_const (hf : HasStrictFDerivAt f f' x) (c : F) :
    HasStrictFDerivAt (fun y => f y + c) f' x 
goal: HasStrictFDerivAt (fun y => f y + c) f' x

full_name: HasFDerivAtFilter.add_const
code: theorem HasFDerivAtFilter.add_const (hf : HasFDerivAtFilter f f' x L) (c : F) :
    HasFDerivAtFilter (fun y => f y + c) f' x L 
goal: HasFDerivAtFilter (fun y => f y + c) f' x L

full_name: HasFDerivWithinAt.add_const
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.add_const (hf : HasFDerivWithinAt f f' s x) (c : F) :
    HasFDerivWithinAt (fun y => f y + c) f' s x 
goal: HasFDerivWithinAt (fun y => f y + c) f' s x

full_name: HasFDerivAt.add_const
code: @[fun_prop]
nonrec theorem HasFDerivAt.add_const (hf : HasFDerivAt f f' x) (c : F) :
    HasFDerivAt (fun x => f x + c) f' x 
goal: HasFDerivAt (fun x => f x + c) f' x

full_name: DifferentiableWithinAt.add_const
code: @[fun_prop]
theorem DifferentiableWithinAt.add_const (hf : DifferentiableWithinAt 𝕜 f s x) (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => f y + c) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => f y + c) s x

full_name: differentiableWithinAt_add_const_iff
code: @[simp]
theorem differentiableWithinAt_add_const_iff (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => f y + c) s x ↔ DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 (fun y => f y + c) s x ↔ DifferentiableWithinAt 𝕜 f s x

full_name: DifferentiableAt.add_const
code: @[fun_prop]
theorem DifferentiableAt.add_const (hf : DifferentiableAt 𝕜 f x) (c : F) :
    DifferentiableAt 𝕜 (fun y => f y + c) x 
goal: DifferentiableAt 𝕜 (fun y => f y + c) x

full_name: differentiableAt_add_const_iff
code: @[simp]
theorem differentiableAt_add_const_iff (c : F) :
    DifferentiableAt 𝕜 (fun y => f y + c) x ↔ DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 (fun y => f y + c) x ↔ DifferentiableAt 𝕜 f x

full_name: DifferentiableOn.add_const
code: @[fun_prop]
theorem DifferentiableOn.add_const (hf : DifferentiableOn 𝕜 f s) (c : F) :
    DifferentiableOn 𝕜 (fun y => f y + c) s 
goal: DifferentiableOn 𝕜 (fun y => f y + c) s

full_name: differentiableOn_add_const_iff
code: @[simp]
theorem differentiableOn_add_const_iff (c : F) :
    DifferentiableOn 𝕜 (fun y => f y + c) s ↔ DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 (fun y => f y + c) s ↔ DifferentiableOn 𝕜 f s

full_name: Differentiable.add_const
code: @[fun_prop]
theorem Differentiable.add_const (hf : Differentiable 𝕜 f) (c : F) :
    Differentiable 𝕜 fun y => f y + c 
goal: Differentiable 𝕜 fun y => f y + c

full_name: differentiable_add_const_iff
code: @[simp]
theorem differentiable_add_const_iff (c : F) :
    (Differentiable 𝕜 fun y => f y + c) ↔ Differentiable 𝕜 f 
goal: (Differentiable 𝕜 fun y => f y + c) ↔ Differentiable 𝕜 f

full_name: fderivWithin_add_const
code: theorem fderivWithin_add_const (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    fderivWithin 𝕜 (fun y => f y + c) s x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 (fun y => f y + c) s x = fderivWithin 𝕜 f s x

full_name: fderiv_add_const
code: theorem fderiv_add_const (c : F) : fderiv 𝕜 (fun y => f y + c) x = fderiv 𝕜 f x 
goal: fderiv 𝕜 (fun y => f y + c) x = fderiv 𝕜 f x

full_name: HasStrictFDerivAt.const_add
code: @[fun_prop]
theorem HasStrictFDerivAt.const_add (hf : HasStrictFDerivAt f f' x) (c : F) :
    HasStrictFDerivAt (fun y => c + f y) f' x 
goal: HasStrictFDerivAt (fun y => c + f y) f' x

full_name: HasFDerivAtFilter.const_add
code: theorem HasFDerivAtFilter.const_add (hf : HasFDerivAtFilter f f' x L) (c : F) :
    HasFDerivAtFilter (fun y => c + f y) f' x L 
goal: HasFDerivAtFilter (fun y => c + f y) f' x L

full_name: HasFDerivWithinAt.const_add
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.const_add (hf : HasFDerivWithinAt f f' s x) (c : F) :
    HasFDerivWithinAt (fun y => c + f y) f' s x 
goal: HasFDerivWithinAt (fun y => c + f y) f' s x

full_name: HasFDerivAt.const_add
code: @[fun_prop]
nonrec theorem HasFDerivAt.const_add (hf : HasFDerivAt f f' x) (c : F) :
    HasFDerivAt (fun x => c + f x) f' x 
goal: HasFDerivAt (fun x => c + f x) f' x

full_name: DifferentiableWithinAt.const_add
code: @[fun_prop]
theorem DifferentiableWithinAt.const_add (hf : DifferentiableWithinAt 𝕜 f s x) (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => c + f y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => c + f y) s x

full_name: differentiableWithinAt_const_add_iff
code: @[simp]
theorem differentiableWithinAt_const_add_iff (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => c + f y) s x ↔ DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 (fun y => c + f y) s x ↔ DifferentiableWithinAt 𝕜 f s x

full_name: DifferentiableAt.const_add
code: @[fun_prop]
theorem DifferentiableAt.const_add (hf : DifferentiableAt 𝕜 f x) (c : F) :
    DifferentiableAt 𝕜 (fun y => c + f y) x 
goal: DifferentiableAt 𝕜 (fun y => c + f y) x

full_name: differentiableAt_const_add_iff
code: @[simp]
theorem differentiableAt_const_add_iff (c : F) :
    DifferentiableAt 𝕜 (fun y => c + f y) x ↔ DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 (fun y => c + f y) x ↔ DifferentiableAt 𝕜 f x

full_name: DifferentiableOn.const_add
code: @[fun_prop]
theorem DifferentiableOn.const_add (hf : DifferentiableOn 𝕜 f s) (c : F) :
    DifferentiableOn 𝕜 (fun y => c + f y) s 
goal: DifferentiableOn 𝕜 (fun y => c + f y) s

full_name: differentiableOn_const_add_iff
code: @[simp]
theorem differentiableOn_const_add_iff (c : F) :
    DifferentiableOn 𝕜 (fun y => c + f y) s ↔ DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 (fun y => c + f y) s ↔ DifferentiableOn 𝕜 f s

full_name: Differentiable.const_add
code: @[fun_prop]
theorem Differentiable.const_add (hf : Differentiable 𝕜 f) (c : F) :
    Differentiable 𝕜 fun y => c + f y 
goal: Differentiable 𝕜 fun y => c + f y

full_name: differentiable_const_add_iff
code: @[simp]
theorem differentiable_const_add_iff (c : F) :
    (Differentiable 𝕜 fun y => c + f y) ↔ Differentiable 𝕜 f 
goal: (Differentiable 𝕜 fun y => c + f y) ↔ Differentiable 𝕜 f

full_name: fderivWithin_const_add
code: theorem fderivWithin_const_add (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    fderivWithin 𝕜 (fun y => c + f y) s x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 (fun y => c + f y) s x = fderivWithin 𝕜 f s x

full_name: fderiv_const_add
code: theorem fderiv_const_add (c : F) : fderiv 𝕜 (fun y => c + f y) x = fderiv 𝕜 f x 
goal: fderiv 𝕜 (fun y => c + f y) x = fderiv 𝕜 f x

full_name: HasStrictFDerivAt.sum
code: @[fun_prop]
theorem HasStrictFDerivAt.sum (h : ∀ i ∈ u, HasStrictFDerivAt (A i) (A' i) x) :
    HasStrictFDerivAt (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x 
goal: HasStrictFDerivAt (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x

full_name: HasFDerivAtFilter.sum
code: theorem HasFDerivAtFilter.sum (h : ∀ i ∈ u, HasFDerivAtFilter (A i) (A' i) x L) :
    HasFDerivAtFilter (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x L 
goal: HasFDerivAtFilter (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x L

full_name: HasFDerivWithinAt.sum
code: @[fun_prop]
theorem HasFDerivWithinAt.sum (h : ∀ i ∈ u, HasFDerivWithinAt (A i) (A' i) s x) :
    HasFDerivWithinAt (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) s x 
goal: HasFDerivWithinAt (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) s x

full_name: HasFDerivAt.sum
code: @[fun_prop]
theorem HasFDerivAt.sum (h : ∀ i ∈ u, HasFDerivAt (A i) (A' i) x) :
    HasFDerivAt (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x 
goal: HasFDerivAt (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x

full_name: DifferentiableWithinAt.sum
code: @[fun_prop]
theorem DifferentiableWithinAt.sum (h : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (A i) s x) :
    DifferentiableWithinAt 𝕜 (fun y => ∑ i ∈ u, A i y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => ∑ i ∈ u, A i y) s x

full_name: DifferentiableAt.sum
code: @[simp, fun_prop]
theorem DifferentiableAt.sum (h : ∀ i ∈ u, DifferentiableAt 𝕜 (A i) x) :
    DifferentiableAt 𝕜 (fun y => ∑ i ∈ u, A i y) x 
goal: DifferentiableAt 𝕜 (fun y => ∑ i ∈ u, A i y) x

full_name: DifferentiableOn.sum
code: @[fun_prop]
theorem DifferentiableOn.sum (h : ∀ i ∈ u, DifferentiableOn 𝕜 (A i) s) :
    DifferentiableOn 𝕜 (fun y => ∑ i ∈ u, A i y) s 
goal: DifferentiableOn 𝕜 (fun y => ∑ i ∈ u, A i y) s

full_name: Differentiable.sum
code: @[simp, fun_prop]
theorem Differentiable.sum (h : ∀ i ∈ u, Differentiable 𝕜 (A i)) :
    Differentiable 𝕜 fun y => ∑ i ∈ u, A i y 
goal: Differentiable 𝕜 fun y => ∑ i ∈ u, A i y

full_name: fderivWithin_sum
code: theorem fderivWithin_sum (hxs : UniqueDiffWithinAt 𝕜 s x)
    (h : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (A i) s x) :
    fderivWithin 𝕜 (fun y => ∑ i ∈ u, A i y) s x = ∑ i ∈ u, fderivWithin 𝕜 (A i) s x 
goal: fderivWithin 𝕜 (fun y => ∑ i ∈ u, A i y) s x = ∑ i ∈ u, fderivWithin 𝕜 (A i) s x

full_name: fderiv_sum
code: theorem fderiv_sum (h : ∀ i ∈ u, DifferentiableAt 𝕜 (A i) x) :
    fderiv 𝕜 (fun y => ∑ i ∈ u, A i y) x = ∑ i ∈ u, fderiv 𝕜 (A i) x 
goal: fderiv 𝕜 (fun y => ∑ i ∈ u, A i y) x = ∑ i ∈ u, fderiv 𝕜 (A i) x

full_name: HasStrictFDerivAt.neg
code: @[fun_prop]
theorem HasStrictFDerivAt.neg (h : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => -f x) (-f') x 
goal: HasStrictFDerivAt (fun x => -f x) (-f') x

full_name: HasFDerivAtFilter.neg
code: theorem HasFDerivAtFilter.neg (h : HasFDerivAtFilter f f' x L) :
    HasFDerivAtFilter (fun x => -f x) (-f') x L 
goal: HasFDerivAtFilter (fun x => -f x) (-f') x L

full_name: HasFDerivWithinAt.neg
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.neg (h : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => -f x) (-f') s x 
goal: HasFDerivWithinAt (fun x => -f x) (-f') s x

full_name: HasFDerivAt.neg
code: @[fun_prop]
nonrec theorem HasFDerivAt.neg (h : HasFDerivAt f f' x) : HasFDerivAt (fun x => -f x) (-f') x 
goal: HasFDerivAt (fun x => -f x) (-f') x

full_name: DifferentiableWithinAt.neg
code: @[fun_prop]
theorem DifferentiableWithinAt.neg (h : DifferentiableWithinAt 𝕜 f s x) :
    DifferentiableWithinAt 𝕜 (fun y => -f y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => -f y) s x

full_name: differentiableWithinAt_neg_iff
code: @[simp]
theorem differentiableWithinAt_neg_iff :
    DifferentiableWithinAt 𝕜 (fun y => -f y) s x ↔ DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 (fun y => -f y) s x ↔ DifferentiableWithinAt 𝕜 f s x

full_name: DifferentiableAt.neg
code: @[fun_prop]
theorem DifferentiableAt.neg (h : DifferentiableAt 𝕜 f x) : DifferentiableAt 𝕜 (fun y => -f y) x 
goal: DifferentiableAt 𝕜 (fun y => -f y) x

full_name: differentiableAt_neg_iff
code: @[simp]
theorem differentiableAt_neg_iff : DifferentiableAt 𝕜 (fun y => -f y) x ↔ DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 (fun y => -f y) x ↔ DifferentiableAt 𝕜 f x

full_name: DifferentiableOn.neg
code: @[fun_prop]
theorem DifferentiableOn.neg (h : DifferentiableOn 𝕜 f s) : DifferentiableOn 𝕜 (fun y => -f y) s 
goal: DifferentiableOn 𝕜 (fun y => -f y) s

full_name: differentiableOn_neg_iff
code: @[simp]
theorem differentiableOn_neg_iff : DifferentiableOn 𝕜 (fun y => -f y) s ↔ DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 (fun y => -f y) s ↔ DifferentiableOn 𝕜 f s

full_name: Differentiable.neg
code: @[fun_prop]
theorem Differentiable.neg (h : Differentiable 𝕜 f) : Differentiable 𝕜 fun y => -f y 
goal: Differentiable 𝕜 fun y => -f y

full_name: differentiable_neg_iff
code: @[simp]
theorem differentiable_neg_iff : (Differentiable 𝕜 fun y => -f y) ↔ Differentiable 𝕜 f 
goal: (Differentiable 𝕜 fun y => -f y) ↔ Differentiable 𝕜 f

full_name: fderivWithin_neg
code: theorem fderivWithin_neg (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun y => -f y) s x = -fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 (fun y => -f y) s x = -fderivWithin 𝕜 f s x

full_name: fderiv_neg
code: @[simp]
theorem fderiv_neg : fderiv 𝕜 (fun y => -f y) x = -fderiv 𝕜 f x 
goal: fderiv 𝕜 (fun y => -f y) x = -fderiv 𝕜 f x

full_name: HasStrictFDerivAt.sub
code: @[fun_prop]
theorem HasStrictFDerivAt.sub (hf : HasStrictFDerivAt f f' x) (hg : HasStrictFDerivAt g g' x) :
    HasStrictFDerivAt (fun x => f x - g x) (f' - g') x 
goal: HasStrictFDerivAt (fun x => f x - g x) (f' - g') x

full_name: HasFDerivAtFilter.sub
code: theorem HasFDerivAtFilter.sub (hf : HasFDerivAtFilter f f' x L) (hg : HasFDerivAtFilter g g' x L) :
    HasFDerivAtFilter (fun x => f x - g x) (f' - g') x L 
goal: HasFDerivAtFilter (fun x => f x - g x) (f' - g') x L

full_name: HasFDerivWithinAt.sub
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.sub (hf : HasFDerivWithinAt f f' s x)
    (hg : HasFDerivWithinAt g g' s x) : HasFDerivWithinAt (fun x => f x - g x) (f' - g') s x 
goal: HasFDerivWithinAt (fun x => f x - g x) (f' - g') s x

full_name: HasFDerivAt.sub
code: @[fun_prop]
nonrec theorem HasFDerivAt.sub (hf : HasFDerivAt f f' x) (hg : HasFDerivAt g g' x) :
    HasFDerivAt (fun x => f x - g x) (f' - g') x 
goal: HasFDerivAt (fun x => f x - g x) (f' - g') x

full_name: DifferentiableWithinAt.sub
code: @[fun_prop]
theorem DifferentiableWithinAt.sub (hf : DifferentiableWithinAt 𝕜 f s x)
    (hg : DifferentiableWithinAt 𝕜 g s x) : DifferentiableWithinAt 𝕜 (fun y => f y - g y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => f y - g y) s x

full_name: DifferentiableAt.sub
code: @[simp, fun_prop]
theorem DifferentiableAt.sub (hf : DifferentiableAt 𝕜 f x) (hg : DifferentiableAt 𝕜 g x) :
    DifferentiableAt 𝕜 (fun y => f y - g y) x 
goal: DifferentiableAt 𝕜 (fun y => f y - g y) x

full_name: DifferentiableAt.add_iff_left
code: @[simp]
lemma DifferentiableAt.add_iff_left (hg : DifferentiableAt 𝕜 g x) :
    DifferentiableAt 𝕜 (fun y => f y + g y) x ↔ DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 (fun y => f y + g y) x ↔ DifferentiableAt 𝕜 f x

full_name: DifferentiableAt.add_iff_right
code: @[simp]
lemma DifferentiableAt.add_iff_right (hg : DifferentiableAt 𝕜 f x) :
    DifferentiableAt 𝕜 (fun y => f y + g y) x ↔ DifferentiableAt 𝕜 g x 
goal: DifferentiableAt 𝕜 (fun y => f y + g y) x ↔ DifferentiableAt 𝕜 g x

full_name: DifferentiableAt.sub_iff_left
code: @[simp]
lemma DifferentiableAt.sub_iff_left (hg : DifferentiableAt 𝕜 g x) :
    DifferentiableAt 𝕜 (fun y => f y - g y) x ↔ DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 (fun y => f y - g y) x ↔ DifferentiableAt 𝕜 f x

full_name: DifferentiableAt.sub_iff_right
code: @[simp]
lemma DifferentiableAt.sub_iff_right (hg : DifferentiableAt 𝕜 f x) :
    DifferentiableAt 𝕜 (fun y => f y - g y) x ↔ DifferentiableAt 𝕜 g x 
goal: DifferentiableAt 𝕜 (fun y => f y - g y) x ↔ DifferentiableAt 𝕜 g x

full_name: DifferentiableOn.sub
code: @[fun_prop]
theorem DifferentiableOn.sub (hf : DifferentiableOn 𝕜 f s) (hg : DifferentiableOn 𝕜 g s) :
    DifferentiableOn 𝕜 (fun y => f y - g y) s 
goal: DifferentiableOn 𝕜 (fun y => f y - g y) s

full_name: DifferentiableOn.add_iff_left
code: @[simp]
lemma DifferentiableOn.add_iff_left (hg : DifferentiableOn 𝕜 g s) :
    DifferentiableOn 𝕜 (fun y => f y + g y) s ↔ DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 (fun y => f y + g y) s ↔ DifferentiableOn 𝕜 f s

full_name: DifferentiableOn.add_iff_right
code: @[simp]
lemma DifferentiableOn.add_iff_right (hg : DifferentiableOn 𝕜 f s) :
    DifferentiableOn 𝕜 (fun y => f y + g y) s ↔ DifferentiableOn 𝕜 g s 
goal: DifferentiableOn 𝕜 (fun y => f y + g y) s ↔ DifferentiableOn 𝕜 g s

full_name: DifferentiableOn.sub_iff_left
code: @[simp]
lemma DifferentiableOn.sub_iff_left (hg : DifferentiableOn 𝕜 g s) :
    DifferentiableOn 𝕜 (fun y => f y - g y) s ↔ DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 (fun y => f y - g y) s ↔ DifferentiableOn 𝕜 f s

full_name: DifferentiableOn.sub_iff_right
code: @[simp]
lemma DifferentiableOn.sub_iff_right (hg : DifferentiableOn 𝕜 f s) :
    DifferentiableOn 𝕜 (fun y => f y - g y) s ↔ DifferentiableOn 𝕜 g s 
goal: DifferentiableOn 𝕜 (fun y => f y - g y) s ↔ DifferentiableOn 𝕜 g s

full_name: Differentiable.sub
code: @[simp, fun_prop]
theorem Differentiable.sub (hf : Differentiable 𝕜 f) (hg : Differentiable 𝕜 g) :
    Differentiable 𝕜 fun y => f y - g y 
goal: Differentiable 𝕜 fun y => f y - g y

full_name: Differentiable.add_iff_left
code: @[simp]
lemma Differentiable.add_iff_left (hg : Differentiable 𝕜 g) :
    Differentiable 𝕜 (fun y => f y + g y) ↔ Differentiable 𝕜 f 
goal: (Differentiable 𝕜 fun y => f y + g y) ↔ Differentiable 𝕜 f

full_name: Differentiable.add_iff_right
code: @[simp]
lemma Differentiable.add_iff_right (hg : Differentiable 𝕜 f) :
    Differentiable 𝕜 (fun y => f y + g y) ↔ Differentiable 𝕜 g 
goal: (Differentiable 𝕜 fun y => f y + g y) ↔ Differentiable 𝕜 g

full_name: Differentiable.sub_iff_left
code: @[simp]
lemma Differentiable.sub_iff_left (hg : Differentiable 𝕜 g) :
    Differentiable 𝕜 (fun y => f y - g y) ↔ Differentiable 𝕜 f 
goal: (Differentiable 𝕜 fun y => f y - g y) ↔ Differentiable 𝕜 f

full_name: Differentiable.sub_iff_right
code: @[simp]
lemma Differentiable.sub_iff_right (hg : Differentiable 𝕜 f) :
    Differentiable 𝕜 (fun y => f y - g y) ↔ Differentiable 𝕜 g 
goal: (Differentiable 𝕜 fun y => f y - g y) ↔ Differentiable 𝕜 g

full_name: fderivWithin_sub
code: theorem fderivWithin_sub (hxs : UniqueDiffWithinAt 𝕜 s x) (hf : DifferentiableWithinAt 𝕜 f s x)
    (hg : DifferentiableWithinAt 𝕜 g s x) :
    fderivWithin 𝕜 (fun y => f y - g y) s x = fderivWithin 𝕜 f s x - fderivWithin 𝕜 g s x 
goal: fderivWithin 𝕜 (fun y => f y - g y) s x = fderivWithin 𝕜 f s x - fderivWithin 𝕜 g s x

full_name: fderiv_sub
code: theorem fderiv_sub (hf : DifferentiableAt 𝕜 f x) (hg : DifferentiableAt 𝕜 g x) :
    fderiv 𝕜 (fun y => f y - g y) x = fderiv 𝕜 f x - fderiv 𝕜 g x 
goal: fderiv 𝕜 (fun y => f y - g y) x = fderiv 𝕜 f x - fderiv 𝕜 g x

full_name: HasStrictFDerivAt.sub_const
code: @[fun_prop]
theorem HasStrictFDerivAt.sub_const (hf : HasStrictFDerivAt f f' x) (c : F) :
    HasStrictFDerivAt (fun x => f x - c) f' x 
goal: HasStrictFDerivAt (fun x => f x - c) f' x

full_name: HasFDerivAtFilter.sub_const
code: theorem HasFDerivAtFilter.sub_const (hf : HasFDerivAtFilter f f' x L) (c : F) :
    HasFDerivAtFilter (fun x => f x - c) f' x L 
goal: HasFDerivAtFilter (fun x => f x - c) f' x L

full_name: HasFDerivWithinAt.sub_const
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.sub_const (hf : HasFDerivWithinAt f f' s x) (c : F) :
    HasFDerivWithinAt (fun x => f x - c) f' s x 
goal: HasFDerivWithinAt (fun x => f x - c) f' s x

full_name: HasFDerivAt.sub_const
code: @[fun_prop]
nonrec theorem HasFDerivAt.sub_const (hf : HasFDerivAt f f' x) (c : F) :
    HasFDerivAt (fun x => f x - c) f' x 
goal: HasFDerivAt (fun x => f x - c) f' x

full_name: hasStrictFDerivAt_sub_const
code: @[fun_prop]
theorem hasStrictFDerivAt_sub_const {x : F} (c : F) : HasStrictFDerivAt (· - c) (id 𝕜 F) x 
goal: HasStrictFDerivAt (fun x => x - c) (ContinuousLinearMap.id 𝕜 F) x

full_name: hasFDerivAt_sub_const
code: @[fun_prop]
theorem hasFDerivAt_sub_const {x : F} (c : F) : HasFDerivAt (· - c) (id 𝕜 F) x 
goal: HasFDerivAt (fun x => x - c) (ContinuousLinearMap.id 𝕜 F) x

full_name: DifferentiableWithinAt.sub_const
code: @[fun_prop]
theorem DifferentiableWithinAt.sub_const (hf : DifferentiableWithinAt 𝕜 f s x) (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => f y - c) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => f y - c) s x

full_name: differentiableWithinAt_sub_const_iff
code: @[simp]
theorem differentiableWithinAt_sub_const_iff (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => f y - c) s x ↔ DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 (fun y => f y - c) s x ↔ DifferentiableWithinAt 𝕜 f s x

full_name: DifferentiableAt.sub_const
code: @[fun_prop]
theorem DifferentiableAt.sub_const (hf : DifferentiableAt 𝕜 f x) (c : F) :
    DifferentiableAt 𝕜 (fun y => f y - c) x 
goal: DifferentiableAt 𝕜 (fun y => f y - c) x

full_name: differentiableAt_sub_const_iff
code: @[deprecated DifferentiableAt.sub_iff_left (since := "2024-07-11")]
theorem differentiableAt_sub_const_iff (c : F) :
    DifferentiableAt 𝕜 (fun y => f y - c) x ↔ DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 (fun y => f y - c) x ↔ DifferentiableAt 𝕜 f x

full_name: DifferentiableOn.sub_const
code: @[fun_prop]
theorem DifferentiableOn.sub_const (hf : DifferentiableOn 𝕜 f s) (c : F) :
    DifferentiableOn 𝕜 (fun y => f y - c) s 
goal: DifferentiableOn 𝕜 (fun y => f y - c) s

full_name: differentiableOn_sub_const_iff
code: @[deprecated DifferentiableOn.sub_iff_left (since := "2024-07-11")]
theorem differentiableOn_sub_const_iff (c : F) :
    DifferentiableOn 𝕜 (fun y => f y - c) s ↔ DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 (fun y => f y - c) s ↔ DifferentiableOn 𝕜 f s

full_name: Differentiable.sub_const
code: @[fun_prop]
theorem Differentiable.sub_const (hf : Differentiable 𝕜 f) (c : F) :
    Differentiable 𝕜 fun y => f y - c 
goal: Differentiable 𝕜 fun y => f y - c

full_name: differentiable_sub_const_iff
code: @[deprecated Differentiable.sub_iff_left (since := "2024-07-11")]
theorem differentiable_sub_const_iff (c : F) :
    (Differentiable 𝕜 fun y => f y - c) ↔ Differentiable 𝕜 f 
goal: (Differentiable 𝕜 fun y => f y - c) ↔ Differentiable 𝕜 f

full_name: fderivWithin_sub_const
code: theorem fderivWithin_sub_const (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    fderivWithin 𝕜 (fun y => f y - c) s x = fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 (fun y => f y - c) s x = fderivWithin 𝕜 f s x

full_name: fderiv_sub_const
code: theorem fderiv_sub_const (c : F) : fderiv 𝕜 (fun y => f y - c) x = fderiv 𝕜 f x 
goal: fderiv 𝕜 (fun y => f y - c) x = fderiv 𝕜 f x

full_name: HasStrictFDerivAt.const_sub
code: @[fun_prop]
theorem HasStrictFDerivAt.const_sub (hf : HasStrictFDerivAt f f' x) (c : F) :
    HasStrictFDerivAt (fun x => c - f x) (-f') x 
goal: HasStrictFDerivAt (fun x => c - f x) (-f') x

full_name: HasFDerivAtFilter.const_sub
code: theorem HasFDerivAtFilter.const_sub (hf : HasFDerivAtFilter f f' x L) (c : F) :
    HasFDerivAtFilter (fun x => c - f x) (-f') x L 
goal: HasFDerivAtFilter (fun x => c - f x) (-f') x L

full_name: HasFDerivWithinAt.const_sub
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.const_sub (hf : HasFDerivWithinAt f f' s x) (c : F) :
    HasFDerivWithinAt (fun x => c - f x) (-f') s x 
goal: HasFDerivWithinAt (fun x => c - f x) (-f') s x

full_name: HasFDerivAt.const_sub
code: @[fun_prop]
nonrec theorem HasFDerivAt.const_sub (hf : HasFDerivAt f f' x) (c : F) :
    HasFDerivAt (fun x => c - f x) (-f') x 
goal: HasFDerivAt (fun x => c - f x) (-f') x

full_name: DifferentiableWithinAt.const_sub
code: @[fun_prop]
theorem DifferentiableWithinAt.const_sub (hf : DifferentiableWithinAt 𝕜 f s x) (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => c - f y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => c - f y) s x

full_name: differentiableWithinAt_const_sub_iff
code: @[simp]
theorem differentiableWithinAt_const_sub_iff (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => c - f y) s x ↔ DifferentiableWithinAt 𝕜 f s x 
goal: DifferentiableWithinAt 𝕜 (fun y => c - f y) s x ↔ DifferentiableWithinAt 𝕜 f s x

full_name: DifferentiableAt.const_sub
code: @[fun_prop]
theorem DifferentiableAt.const_sub (hf : DifferentiableAt 𝕜 f x) (c : F) :
    DifferentiableAt 𝕜 (fun y => c - f y) x 
goal: DifferentiableAt 𝕜 (fun y => c - f y) x

full_name: differentiableAt_const_sub_iff
code: @[deprecated DifferentiableAt.sub_iff_right (since := "2024-07-11")]
theorem differentiableAt_const_sub_iff (c : F) :
    DifferentiableAt 𝕜 (fun y => c - f y) x ↔ DifferentiableAt 𝕜 f x 
goal: DifferentiableAt 𝕜 (fun y => c - f y) x ↔ DifferentiableAt 𝕜 f x

full_name: DifferentiableOn.const_sub
code: @[fun_prop]
theorem DifferentiableOn.const_sub (hf : DifferentiableOn 𝕜 f s) (c : F) :
    DifferentiableOn 𝕜 (fun y => c - f y) s 
goal: DifferentiableOn 𝕜 (fun y => c - f y) s

full_name: differentiableOn_const_sub_iff
code: @[deprecated DifferentiableOn.sub_iff_right (since := "2024-07-11")]
theorem differentiableOn_const_sub_iff (c : F) :
    DifferentiableOn 𝕜 (fun y => c - f y) s ↔ DifferentiableOn 𝕜 f s 
goal: DifferentiableOn 𝕜 (fun y => c - f y) s ↔ DifferentiableOn 𝕜 f s

full_name: Differentiable.const_sub
code: @[fun_prop]
theorem Differentiable.const_sub (hf : Differentiable 𝕜 f) (c : F) :
    Differentiable 𝕜 fun y => c - f y 
goal: Differentiable 𝕜 fun y => c - f y

full_name: differentiable_const_sub_iff
code: @[deprecated Differentiable.sub_iff_right (since := "2024-07-11")]
theorem differentiable_const_sub_iff (c : F) :
    (Differentiable 𝕜 fun y => c - f y) ↔ Differentiable 𝕜 f 
goal: (Differentiable 𝕜 fun y => c - f y) ↔ Differentiable 𝕜 f

full_name: fderivWithin_const_sub
code: theorem fderivWithin_const_sub (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    fderivWithin 𝕜 (fun y => c - f y) s x = -fderivWithin 𝕜 f s x 
goal: fderivWithin 𝕜 (fun y => c - f y) s x = -fderivWithin 𝕜 f s x

full_name: fderiv_const_sub
code: theorem fderiv_const_sub (c : F) : fderiv 𝕜 (fun y => c - f y) x = -fderiv 𝕜 f x 
goal: fderiv 𝕜 (fun y => c - f y) x = -fderiv 𝕜 f x