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

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

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

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

full_name: HasDerivAt.add
code: nonrec theorem HasDerivAt.add (hf : HasDerivAt f f' x) (hg : HasDerivAt g g' x) :
    HasDerivAt (fun x => f x + g x) (f' + g') x 
goal: HasDerivAt (fun x => f x + g x) (f' + g') x

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

full_name: deriv_add
code: @[simp]
theorem deriv_add (hf : DifferentiableAt 𝕜 f x) (hg : DifferentiableAt 𝕜 g x) :
    deriv (fun y => f y + g y) x = deriv f x + deriv g x 
goal: deriv (fun y => f y + g y) x = deriv f x + deriv g x

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

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

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

full_name: HasDerivAt.add_const
code: nonrec theorem HasDerivAt.add_const (hf : HasDerivAt f f' x) (c : F) :
    HasDerivAt (fun x => f x + c) f' x 
goal: HasDerivAt (fun x => f x + c) f' x

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

full_name: deriv_add_const
code: theorem deriv_add_const (c : F) : deriv (fun y => f y + c) x = deriv f x 
goal: deriv (fun y => f y + c) x = deriv f x

full_name: deriv_add_const'
code: @[simp]
theorem deriv_add_const' (c : F) : (deriv fun y => f y + c) = deriv f 
goal: (deriv fun y => f y + c) = deriv f

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

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

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

full_name: HasDerivAt.const_add
code: nonrec theorem HasDerivAt.const_add (c : F) (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => c + f x) f' x 
goal: HasDerivAt (fun x => c + f x) f' x

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

full_name: deriv_const_add
code: theorem deriv_const_add (c : F) : deriv (fun y => c + f y) x = deriv f x 
goal: deriv (fun y => c + f y) x = deriv f x

full_name: deriv_const_add'
code: @[simp]
theorem deriv_const_add' (c : F) : (deriv fun y => c + f y) = deriv f 
goal: (deriv fun y => c + f y) = deriv f

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

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

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

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

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

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

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

full_name: HasDerivWithinAt.neg
code: nonrec theorem HasDerivWithinAt.neg (h : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => -f x) (-f') s x 
goal: HasDerivWithinAt (fun x => -f x) (-f') s x

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

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

full_name: derivWithin.neg
code: theorem derivWithin.neg (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun y => -f y) s x = -derivWithin f s x 
goal: derivWithin (fun y => -f y) s x = -derivWithin f s x

full_name: deriv.neg
code: theorem deriv.neg : deriv (fun y => -f y) x = -deriv f x 
goal: deriv (fun y => -f y) x = -deriv f x

full_name: deriv.neg'
code: @[simp]
theorem deriv.neg' : (deriv fun y => -f y) = fun x => -deriv f x 
goal: (deriv fun y => -f y) = fun x => -deriv f x

full_name: hasDerivAtFilter_neg
code: theorem hasDerivAtFilter_neg : HasDerivAtFilter Neg.neg (-1) x L 
goal: HasDerivAtFilter Neg.neg (-1) x L

full_name: hasDerivWithinAt_neg
code: theorem hasDerivWithinAt_neg : HasDerivWithinAt Neg.neg (-1) s x 
goal: HasDerivWithinAt Neg.neg (-1) s x

full_name: hasDerivAt_neg
code: theorem hasDerivAt_neg : HasDerivAt Neg.neg (-1) x 
goal: HasDerivAt Neg.neg (-1) x

full_name: hasDerivAt_neg'
code: theorem hasDerivAt_neg' : HasDerivAt (fun x => -x) (-1) x 
goal: HasDerivAt (fun x => -x) (-1) x

full_name: hasStrictDerivAt_neg
code: theorem hasStrictDerivAt_neg : HasStrictDerivAt Neg.neg (-1) x 
goal: HasStrictDerivAt Neg.neg (-1) x

full_name: deriv_neg
code: theorem deriv_neg : deriv Neg.neg x = -1 
goal: deriv Neg.neg x = -1

full_name: deriv_neg'
code: @[simp]
theorem deriv_neg' : deriv (Neg.neg : 𝕜 → 𝕜) = fun _ => -1 
goal: deriv Neg.neg = fun x => -1

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

full_name: derivWithin_neg
code: theorem derivWithin_neg (hxs : UniqueDiffWithinAt 𝕜 s x) : derivWithin Neg.neg s x = -1 
goal: derivWithin Neg.neg s x = -1

full_name: differentiable_neg
code: theorem differentiable_neg : Differentiable 𝕜 (Neg.neg : 𝕜 → 𝕜) 
goal: Differentiable 𝕜 Neg.neg

full_name: differentiableOn_neg
code: theorem differentiableOn_neg : DifferentiableOn 𝕜 (Neg.neg : 𝕜 → 𝕜) s 
goal: DifferentiableOn 𝕜 Neg.neg s

full_name: not_differentiableAt_abs_zero
code: theorem not_differentiableAt_abs_zero : ¬ DifferentiableAt ℝ (abs : ℝ → ℝ) 0 
goal: ¬DifferentiableAt ℝ abs 0

full_name: differentiableAt_comp_neg_iff
code: lemma differentiableAt_comp_neg_iff {a : 𝕜} :
    DifferentiableAt 𝕜 f (-a) ↔ DifferentiableAt 𝕜 (fun x ↦ f (-x)) a 
goal: DifferentiableAt 𝕜 f (-a) ↔ DifferentiableAt 𝕜 (fun x => f (-x)) a

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

full_name: HasDerivWithinAt.sub
code: nonrec theorem HasDerivWithinAt.sub (hf : HasDerivWithinAt f f' s x)
    (hg : HasDerivWithinAt g g' s x) : HasDerivWithinAt (fun x => f x - g x) (f' - g') s x 
goal: HasDerivWithinAt (fun x => f x - g x) (f' - g') s x

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

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

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

full_name: deriv_sub
code: @[simp]
theorem deriv_sub (hf : DifferentiableAt 𝕜 f x) (hg : DifferentiableAt 𝕜 g x) :
    deriv (fun y => f y - g y) x = deriv f x - deriv g x 
goal: deriv (fun y => f y - g y) x = deriv f x - deriv g x

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

full_name: HasDerivWithinAt.sub_const
code: nonrec theorem HasDerivWithinAt.sub_const (hf : HasDerivWithinAt f f' s x) (c : F) :
    HasDerivWithinAt (fun x => f x - c) f' s x 
goal: HasDerivWithinAt (fun x => f x - c) f' s x

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

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

full_name: deriv_sub_const
code: theorem deriv_sub_const (c : F) : deriv (fun y => f y - c) x = deriv f x 
goal: deriv (fun y => f y - c) x = deriv f x

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

full_name: HasDerivWithinAt.const_sub
code: nonrec theorem HasDerivWithinAt.const_sub (c : F) (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => c - f x) (-f') s x 
goal: HasDerivWithinAt (fun x => c - f x) (-f') s x

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

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

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

full_name: deriv_const_sub
code: theorem deriv_const_sub (c : F) : deriv (fun y => c - f y) x = -deriv f x 
goal: deriv (fun y => c - f y) x = -deriv f x