analysis.calculus.deriv.mul ⟷ Mathlib.Analysis.Calculus.Deriv.Mul

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -4,8 +4,8 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Gabriel Ebner, Anatole Dedecker, Yury Kudryashov
 -/
 import Analysis.Calculus.Deriv.Basic
-import Analysis.Calculus.Fderiv.Mul
-import Analysis.Calculus.Fderiv.Add
+import Analysis.Calculus.FDeriv.Mul
+import Analysis.Calculus.FDeriv.Add
 
 #align_import analysis.calculus.deriv.mul from "leanprover-community/mathlib"@"f60c6087a7275b72d5db3c5a1d0e19e35a429c0a"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -103,7 +103,7 @@ theorem HasStrictDerivAt.smul_const (hc : HasStrictDerivAt c c' x) (f : F) :
     HasStrictDerivAt (fun y => c y • f) (c' • f) x :=
   by
   have := hc.smul (hasStrictDerivAt_const x f)
-  rwa [smul_zero, zero_add] at this 
+  rwa [smul_zero, zero_add] at this
 #align has_strict_deriv_at.smul_const HasStrictDerivAt.smul_const
 -/
 
@@ -112,7 +112,7 @@ theorem HasDerivWithinAt.smul_const (hc : HasDerivWithinAt c c' s x) (f : F) :
     HasDerivWithinAt (fun y => c y • f) (c' • f) s x :=
   by
   have := hc.smul (hasDerivWithinAt_const x s f)
-  rwa [smul_zero, zero_add] at this 
+  rwa [smul_zero, zero_add] at this
 #align has_deriv_within_at.smul_const HasDerivWithinAt.smul_const
 -/
 
@@ -207,7 +207,7 @@ theorem HasDerivWithinAt.mul (hc : HasDerivWithinAt c c' s x) (hd : HasDerivWith
   rwa [ContinuousLinearMap.add_apply, ContinuousLinearMap.smul_apply,
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.smulRight_apply,
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
-    add_comm] at this 
+    add_comm] at this
 #align has_deriv_within_at.mul HasDerivWithinAt.mul
 -/
 
@@ -228,7 +228,7 @@ theorem HasStrictDerivAt.mul (hc : HasStrictDerivAt c c' x) (hd : HasStrictDeriv
   rwa [ContinuousLinearMap.add_apply, ContinuousLinearMap.smul_apply,
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.smulRight_apply,
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
-    add_comm] at this 
+    add_comm] at this
 #align has_strict_deriv_at.mul HasStrictDerivAt.mul
 -/
 
@@ -457,7 +457,7 @@ theorem HasStrictDerivAt.clm_comp (hc : HasStrictDerivAt c c' x) (hd : HasStrict
   by
   have := (hc.has_strict_fderiv_at.clm_comp hd.has_strict_fderiv_at).HasStrictDerivAt
   rwa [add_apply, comp_apply, comp_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this 
+    one_smul, add_comm] at this
 #align has_strict_deriv_at.clm_comp HasStrictDerivAt.clm_comp
 -/
 
@@ -468,7 +468,7 @@ theorem HasDerivWithinAt.clm_comp (hc : HasDerivWithinAt c c' s x)
   by
   have := (hc.has_fderiv_within_at.clm_comp hd.has_fderiv_within_at).HasDerivWithinAt
   rwa [add_apply, comp_apply, comp_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this 
+    one_smul, add_comm] at this
 #align has_deriv_within_at.clm_comp HasDerivWithinAt.clm_comp
 -/
 
@@ -503,7 +503,7 @@ theorem HasStrictDerivAt.clm_apply (hc : HasStrictDerivAt c c' x) (hu : HasStric
   by
   have := (hc.has_strict_fderiv_at.clm_apply hu.has_strict_fderiv_at).HasStrictDerivAt
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this 
+    one_smul, add_comm] at this
 #align has_strict_deriv_at.clm_apply HasStrictDerivAt.clm_apply
 -/
 
@@ -514,7 +514,7 @@ theorem HasDerivWithinAt.clm_apply (hc : HasDerivWithinAt c c' s x)
   by
   have := (hc.has_fderiv_within_at.clm_apply hu.has_fderiv_within_at).HasDerivWithinAt
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this 
+    one_smul, add_comm] at this
 #align has_deriv_within_at.clm_apply HasDerivWithinAt.clm_apply
 -/
 
@@ -524,7 +524,7 @@ theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
   by
   have := (hc.has_fderiv_at.clm_apply hu.has_fderiv_at).HasDerivAt
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this 
+    one_smul, add_comm] at this
 #align has_deriv_at.clm_apply HasDerivAt.clm_apply
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,9 +3,9 @@ Copyright (c) 2019 Gabriel Ebner. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Gabriel Ebner, Anatole Dedecker, Yury Kudryashov
 -/
-import Mathbin.Analysis.Calculus.Deriv.Basic
-import Mathbin.Analysis.Calculus.Fderiv.Mul
-import Mathbin.Analysis.Calculus.Fderiv.Add
+import Analysis.Calculus.Deriv.Basic
+import Analysis.Calculus.Fderiv.Mul
+import Analysis.Calculus.Fderiv.Add
 
 #align_import analysis.calculus.deriv.mul from "leanprover-community/mathlib"@"f60c6087a7275b72d5db3c5a1d0e19e35a429c0a"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,16 +2,13 @@
 Copyright (c) 2019 Gabriel Ebner. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Gabriel Ebner, Anatole Dedecker, Yury Kudryashov
-
-! This file was ported from Lean 3 source module analysis.calculus.deriv.mul
-! leanprover-community/mathlib commit f60c6087a7275b72d5db3c5a1d0e19e35a429c0a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.Calculus.Deriv.Basic
 import Mathbin.Analysis.Calculus.Fderiv.Mul
 import Mathbin.Analysis.Calculus.Fderiv.Add
 
+#align_import analysis.calculus.deriv.mul from "leanprover-community/mathlib"@"f60c6087a7275b72d5db3c5a1d0e19e35a429c0a"
+
 /-!
 # Derivative of `f x * g x`
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -63,65 +63,85 @@ section Smul
 variable {𝕜' : Type _} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] [NormedSpace 𝕜' F]
   [IsScalarTower 𝕜 𝕜' F] {c : 𝕜 → 𝕜'} {c' : 𝕜'}
 
+#print HasDerivWithinAt.smul /-
 theorem HasDerivWithinAt.smul (hc : HasDerivWithinAt c c' s x) (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun y => c y • f y) (c x • f' + c' • f x) s x := by
   simpa using (HasFDerivWithinAt.smul hc hf).HasDerivWithinAt
 #align has_deriv_within_at.smul HasDerivWithinAt.smul
+-/
 
+#print HasDerivAt.smul /-
 theorem HasDerivAt.smul (hc : HasDerivAt c c' x) (hf : HasDerivAt f f' x) :
     HasDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x :=
   by
   rw [← hasDerivWithinAt_univ] at *
   exact hc.smul hf
 #align has_deriv_at.smul HasDerivAt.smul
+-/
 
+#print HasStrictDerivAt.smul /-
 theorem HasStrictDerivAt.smul (hc : HasStrictDerivAt c c' x) (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x := by
   simpa using (hc.smul hf).HasStrictDerivAt
 #align has_strict_deriv_at.smul HasStrictDerivAt.smul
+-/
 
+#print derivWithin_smul /-
 theorem derivWithin_smul (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
     (hf : DifferentiableWithinAt 𝕜 f s x) :
     derivWithin (fun y => c y • f y) s x = c x • derivWithin f s x + derivWithin c s x • f x :=
   (hc.HasDerivWithinAt.smul hf.HasDerivWithinAt).derivWithin hxs
 #align deriv_within_smul derivWithin_smul
+-/
 
+#print deriv_smul /-
 theorem deriv_smul (hc : DifferentiableAt 𝕜 c x) (hf : DifferentiableAt 𝕜 f x) :
     deriv (fun y => c y • f y) x = c x • deriv f x + deriv c x • f x :=
   (hc.HasDerivAt.smul hf.HasDerivAt).deriv
 #align deriv_smul deriv_smul
+-/
 
+#print HasStrictDerivAt.smul_const /-
 theorem HasStrictDerivAt.smul_const (hc : HasStrictDerivAt c c' x) (f : F) :
     HasStrictDerivAt (fun y => c y • f) (c' • f) x :=
   by
   have := hc.smul (hasStrictDerivAt_const x f)
   rwa [smul_zero, zero_add] at this 
 #align has_strict_deriv_at.smul_const HasStrictDerivAt.smul_const
+-/
 
+#print HasDerivWithinAt.smul_const /-
 theorem HasDerivWithinAt.smul_const (hc : HasDerivWithinAt c c' s x) (f : F) :
     HasDerivWithinAt (fun y => c y • f) (c' • f) s x :=
   by
   have := hc.smul (hasDerivWithinAt_const x s f)
   rwa [smul_zero, zero_add] at this 
 #align has_deriv_within_at.smul_const HasDerivWithinAt.smul_const
+-/
 
+#print HasDerivAt.smul_const /-
 theorem HasDerivAt.smul_const (hc : HasDerivAt c c' x) (f : F) :
     HasDerivAt (fun y => c y • f) (c' • f) x :=
   by
   rw [← hasDerivWithinAt_univ] at *
   exact hc.smul_const f
 #align has_deriv_at.smul_const HasDerivAt.smul_const
+-/
 
+#print derivWithin_smul_const /-
 theorem derivWithin_smul_const (hxs : UniqueDiffWithinAt 𝕜 s x)
     (hc : DifferentiableWithinAt 𝕜 c s x) (f : F) :
     derivWithin (fun y => c y • f) s x = derivWithin c s x • f :=
   (hc.HasDerivWithinAt.smul_const f).derivWithin hxs
 #align deriv_within_smul_const derivWithin_smul_const
+-/
 
+#print deriv_smul_const /-
 theorem deriv_smul_const (hc : DifferentiableAt 𝕜 c x) (f : F) :
     deriv (fun y => c y • f) x = deriv c x • f :=
   (hc.HasDerivAt.smul_const f).deriv
 #align deriv_smul_const deriv_smul_const
+-/
 
 end Smul
 
@@ -129,36 +149,48 @@ section ConstSmul
 
 variable {R : Type _} [Semiring R] [Module R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F]
 
+#print HasStrictDerivAt.const_smul /-
 theorem HasStrictDerivAt.const_smul (c : R) (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun y => c • f y) (c • f') x := by
   simpa using (hf.const_smul c).HasStrictDerivAt
 #align has_strict_deriv_at.const_smul HasStrictDerivAt.const_smul
+-/
 
+#print HasDerivAtFilter.const_smul /-
 theorem HasDerivAtFilter.const_smul (c : R) (hf : HasDerivAtFilter f f' x L) :
     HasDerivAtFilter (fun y => c • f y) (c • f') x L := by
   simpa using (hf.const_smul c).HasDerivAtFilter
 #align has_deriv_at_filter.const_smul HasDerivAtFilter.const_smul
+-/
 
+#print HasDerivWithinAt.const_smul /-
 theorem HasDerivWithinAt.const_smul (c : R) (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun y => c • f y) (c • f') s x :=
   hf.const_smul c
 #align has_deriv_within_at.const_smul HasDerivWithinAt.const_smul
+-/
 
+#print HasDerivAt.const_smul /-
 theorem HasDerivAt.const_smul (c : R) (hf : HasDerivAt f f' x) :
     HasDerivAt (fun y => c • f y) (c • f') x :=
   hf.const_smul c
 #align has_deriv_at.const_smul HasDerivAt.const_smul
+-/
 
+#print derivWithin_const_smul /-
 theorem derivWithin_const_smul (hxs : UniqueDiffWithinAt 𝕜 s x) (c : R)
     (hf : DifferentiableWithinAt 𝕜 f s x) :
     derivWithin (fun y => c • f y) s x = c • derivWithin f s x :=
   (hf.HasDerivWithinAt.const_smul c).derivWithin hxs
 #align deriv_within_const_smul derivWithin_const_smul
+-/
 
+#print deriv_const_smul /-
 theorem deriv_const_smul (c : R) (hf : DifferentiableAt 𝕜 f x) :
     deriv (fun y => c • f y) x = c • deriv f x :=
   (hf.HasDerivAt.const_smul c).deriv
 #align deriv_const_smul deriv_const_smul
+-/
 
 end ConstSmul
 
@@ -170,6 +202,7 @@ section Mul
 variable {𝕜' 𝔸 : Type _} [NormedField 𝕜'] [NormedRing 𝔸] [NormedAlgebra 𝕜 𝕜'] [NormedAlgebra 𝕜 𝔸]
   {c d : 𝕜 → 𝔸} {c' d' : 𝔸} {u v : 𝕜 → 𝕜'}
 
+#print HasDerivWithinAt.mul /-
 theorem HasDerivWithinAt.mul (hc : HasDerivWithinAt c c' s x) (hd : HasDerivWithinAt d d' s x) :
     HasDerivWithinAt (fun y => c y * d y) (c' * d x + c x * d') s x :=
   by
@@ -179,14 +212,18 @@ theorem HasDerivWithinAt.mul (hc : HasDerivWithinAt c c' s x) (hd : HasDerivWith
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
     add_comm] at this 
 #align has_deriv_within_at.mul HasDerivWithinAt.mul
+-/
 
+#print HasDerivAt.mul /-
 theorem HasDerivAt.mul (hc : HasDerivAt c c' x) (hd : HasDerivAt d d' x) :
     HasDerivAt (fun y => c y * d y) (c' * d x + c x * d') x :=
   by
   rw [← hasDerivWithinAt_univ] at *
   exact hc.mul hd
 #align has_deriv_at.mul HasDerivAt.mul
+-/
 
+#print HasStrictDerivAt.mul /-
 theorem HasStrictDerivAt.mul (hc : HasStrictDerivAt c c' x) (hd : HasStrictDerivAt d d' x) :
     HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x :=
   by
@@ -196,54 +233,72 @@ theorem HasStrictDerivAt.mul (hc : HasStrictDerivAt c c' x) (hd : HasStrictDeriv
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
     add_comm] at this 
 #align has_strict_deriv_at.mul HasStrictDerivAt.mul
+-/
 
+#print derivWithin_mul /-
 theorem derivWithin_mul (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
     (hd : DifferentiableWithinAt 𝕜 d s x) :
     derivWithin (fun y => c y * d y) s x = derivWithin c s x * d x + c x * derivWithin d s x :=
   (hc.HasDerivWithinAt.mul hd.HasDerivWithinAt).derivWithin hxs
 #align deriv_within_mul derivWithin_mul
+-/
 
+#print deriv_mul /-
 @[simp]
 theorem deriv_mul (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
     deriv (fun y => c y * d y) x = deriv c x * d x + c x * deriv d x :=
   (hc.HasDerivAt.mul hd.HasDerivAt).deriv
 #align deriv_mul deriv_mul
+-/
 
+#print HasDerivWithinAt.mul_const /-
 theorem HasDerivWithinAt.mul_const (hc : HasDerivWithinAt c c' s x) (d : 𝔸) :
     HasDerivWithinAt (fun y => c y * d) (c' * d) s x :=
   by
   convert hc.mul (hasDerivWithinAt_const x s d)
   rw [MulZeroClass.mul_zero, add_zero]
 #align has_deriv_within_at.mul_const HasDerivWithinAt.mul_const
+-/
 
+#print HasDerivAt.mul_const /-
 theorem HasDerivAt.mul_const (hc : HasDerivAt c c' x) (d : 𝔸) :
     HasDerivAt (fun y => c y * d) (c' * d) x :=
   by
   rw [← hasDerivWithinAt_univ] at *
   exact hc.mul_const d
 #align has_deriv_at.mul_const HasDerivAt.mul_const
+-/
 
+#print hasDerivAt_mul_const /-
 theorem hasDerivAt_mul_const (c : 𝕜) : HasDerivAt (fun x => x * c) c x := by
   simpa only [one_mul] using (hasDerivAt_id' x).mul_const c
 #align has_deriv_at_mul_const hasDerivAt_mul_const
+-/
 
+#print HasStrictDerivAt.mul_const /-
 theorem HasStrictDerivAt.mul_const (hc : HasStrictDerivAt c c' x) (d : 𝔸) :
     HasStrictDerivAt (fun y => c y * d) (c' * d) x :=
   by
   convert hc.mul (hasStrictDerivAt_const x d)
   rw [MulZeroClass.mul_zero, add_zero]
 #align has_strict_deriv_at.mul_const HasStrictDerivAt.mul_const
+-/
 
+#print derivWithin_mul_const /-
 theorem derivWithin_mul_const (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
     (d : 𝔸) : derivWithin (fun y => c y * d) s x = derivWithin c s x * d :=
   (hc.HasDerivWithinAt.mul_const d).derivWithin hxs
 #align deriv_within_mul_const derivWithin_mul_const
+-/
 
+#print deriv_mul_const /-
 theorem deriv_mul_const (hc : DifferentiableAt 𝕜 c x) (d : 𝔸) :
     deriv (fun y => c y * d) x = deriv c x * d :=
   (hc.HasDerivAt.mul_const d).deriv
 #align deriv_mul_const deriv_mul_const
+-/
 
+#print deriv_mul_const_field /-
 theorem deriv_mul_const_field (v : 𝕜') : deriv (fun y => u y * v) x = deriv u x * v :=
   by
   by_cases hu : DifferentiableAt 𝕜 u x
@@ -254,52 +309,69 @@ theorem deriv_mul_const_field (v : 𝕜') : deriv (fun y => u y * v) x = deriv u
     · refine' deriv_zero_of_not_differentiableAt (mt (fun H => _) hu)
       simpa only [mul_inv_cancel_right₀ hd] using H.mul_const v⁻¹
 #align deriv_mul_const_field deriv_mul_const_field
+-/
 
+#print deriv_mul_const_field' /-
 @[simp]
 theorem deriv_mul_const_field' (v : 𝕜') : (deriv fun x => u x * v) = fun x => deriv u x * v :=
   funext fun _ => deriv_mul_const_field v
 #align deriv_mul_const_field' deriv_mul_const_field'
+-/
 
+#print HasDerivWithinAt.const_mul /-
 theorem HasDerivWithinAt.const_mul (c : 𝔸) (hd : HasDerivWithinAt d d' s x) :
     HasDerivWithinAt (fun y => c * d y) (c * d') s x :=
   by
   convert (hasDerivWithinAt_const x s c).mul hd
   rw [MulZeroClass.zero_mul, zero_add]
 #align has_deriv_within_at.const_mul HasDerivWithinAt.const_mul
+-/
 
+#print HasDerivAt.const_mul /-
 theorem HasDerivAt.const_mul (c : 𝔸) (hd : HasDerivAt d d' x) :
     HasDerivAt (fun y => c * d y) (c * d') x :=
   by
   rw [← hasDerivWithinAt_univ] at *
   exact hd.const_mul c
 #align has_deriv_at.const_mul HasDerivAt.const_mul
+-/
 
+#print HasStrictDerivAt.const_mul /-
 theorem HasStrictDerivAt.const_mul (c : 𝔸) (hd : HasStrictDerivAt d d' x) :
     HasStrictDerivAt (fun y => c * d y) (c * d') x :=
   by
   convert (hasStrictDerivAt_const _ _).mul hd
   rw [MulZeroClass.zero_mul, zero_add]
 #align has_strict_deriv_at.const_mul HasStrictDerivAt.const_mul
+-/
 
+#print derivWithin_const_mul /-
 theorem derivWithin_const_mul (hxs : UniqueDiffWithinAt 𝕜 s x) (c : 𝔸)
     (hd : DifferentiableWithinAt 𝕜 d s x) :
     derivWithin (fun y => c * d y) s x = c * derivWithin d s x :=
   (hd.HasDerivWithinAt.const_mul c).derivWithin hxs
 #align deriv_within_const_mul derivWithin_const_mul
+-/
 
+#print deriv_const_mul /-
 theorem deriv_const_mul (c : 𝔸) (hd : DifferentiableAt 𝕜 d x) :
     deriv (fun y => c * d y) x = c * deriv d x :=
   (hd.HasDerivAt.const_mul c).deriv
 #align deriv_const_mul deriv_const_mul
+-/
 
+#print deriv_const_mul_field /-
 theorem deriv_const_mul_field (u : 𝕜') : deriv (fun y => u * v y) x = u * deriv v x := by
   simp only [mul_comm u, deriv_mul_const_field]
 #align deriv_const_mul_field deriv_const_mul_field
+-/
 
+#print deriv_const_mul_field' /-
 @[simp]
 theorem deriv_const_mul_field' (u : 𝕜') : (deriv fun x => u * v x) = fun x => u * deriv v x :=
   funext fun x => deriv_const_mul_field u
 #align deriv_const_mul_field' deriv_const_mul_field'
+-/
 
 end Mul
 
@@ -307,50 +379,68 @@ section Div
 
 variable {𝕜' : Type _} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'} {c' d' : 𝕜'}
 
+#print HasDerivAt.div_const /-
 theorem HasDerivAt.div_const (hc : HasDerivAt c c' x) (d : 𝕜') :
     HasDerivAt (fun x => c x / d) (c' / d) x := by
   simpa only [div_eq_mul_inv] using hc.mul_const d⁻¹
 #align has_deriv_at.div_const HasDerivAt.div_const
+-/
 
+#print HasDerivWithinAt.div_const /-
 theorem HasDerivWithinAt.div_const (hc : HasDerivWithinAt c c' s x) (d : 𝕜') :
     HasDerivWithinAt (fun x => c x / d) (c' / d) s x := by
   simpa only [div_eq_mul_inv] using hc.mul_const d⁻¹
 #align has_deriv_within_at.div_const HasDerivWithinAt.div_const
+-/
 
+#print HasStrictDerivAt.div_const /-
 theorem HasStrictDerivAt.div_const (hc : HasStrictDerivAt c c' x) (d : 𝕜') :
     HasStrictDerivAt (fun x => c x / d) (c' / d) x := by
   simpa only [div_eq_mul_inv] using hc.mul_const d⁻¹
 #align has_strict_deriv_at.div_const HasStrictDerivAt.div_const
+-/
 
+#print DifferentiableWithinAt.div_const /-
 theorem DifferentiableWithinAt.div_const (hc : DifferentiableWithinAt 𝕜 c s x) (d : 𝕜') :
     DifferentiableWithinAt 𝕜 (fun x => c x / d) s x :=
   (hc.HasDerivWithinAt.div_const _).DifferentiableWithinAt
 #align differentiable_within_at.div_const DifferentiableWithinAt.div_const
+-/
 
+#print DifferentiableAt.div_const /-
 @[simp]
 theorem DifferentiableAt.div_const (hc : DifferentiableAt 𝕜 c x) (d : 𝕜') :
     DifferentiableAt 𝕜 (fun x => c x / d) x :=
   (hc.HasDerivAt.div_const _).DifferentiableAt
 #align differentiable_at.div_const DifferentiableAt.div_const
+-/
 
+#print DifferentiableOn.div_const /-
 theorem DifferentiableOn.div_const (hc : DifferentiableOn 𝕜 c s) (d : 𝕜') :
     DifferentiableOn 𝕜 (fun x => c x / d) s := fun x hx => (hc x hx).div_const d
 #align differentiable_on.div_const DifferentiableOn.div_const
+-/
 
+#print Differentiable.div_const /-
 @[simp]
 theorem Differentiable.div_const (hc : Differentiable 𝕜 c) (d : 𝕜') :
     Differentiable 𝕜 fun x => c x / d := fun x => (hc x).div_const d
 #align differentiable.div_const Differentiable.div_const
+-/
 
+#print derivWithin_div_const /-
 theorem derivWithin_div_const (hc : DifferentiableWithinAt 𝕜 c s x) (d : 𝕜')
     (hxs : UniqueDiffWithinAt 𝕜 s x) : derivWithin (fun x => c x / d) s x = derivWithin c s x / d :=
   by simp [div_eq_inv_mul, derivWithin_const_mul, hc, hxs]
 #align deriv_within_div_const derivWithin_div_const
+-/
 
+#print deriv_div_const /-
 @[simp]
 theorem deriv_div_const (d : 𝕜') : deriv (fun x => c x / d) x = deriv c x / d := by
   simp only [div_eq_mul_inv, deriv_mul_const_field]
 #align deriv_div_const deriv_div_const
+-/
 
 end Div
 
@@ -364,6 +454,7 @@ open ContinuousLinearMap
 variable {G : Type _} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {c : 𝕜 → F →L[𝕜] G} {c' : F →L[𝕜] G}
   {d : 𝕜 → E →L[𝕜] F} {d' : E →L[𝕜] F} {u : 𝕜 → F} {u' : F}
 
+#print HasStrictDerivAt.clm_comp /-
 theorem HasStrictDerivAt.clm_comp (hc : HasStrictDerivAt c c' x) (hd : HasStrictDerivAt d d' x) :
     HasStrictDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x :=
   by
@@ -371,7 +462,9 @@ theorem HasStrictDerivAt.clm_comp (hc : HasStrictDerivAt c c' x) (hd : HasStrict
   rwa [add_apply, comp_apply, comp_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
     one_smul, add_comm] at this 
 #align has_strict_deriv_at.clm_comp HasStrictDerivAt.clm_comp
+-/
 
+#print HasDerivWithinAt.clm_comp /-
 theorem HasDerivWithinAt.clm_comp (hc : HasDerivWithinAt c c' s x)
     (hd : HasDerivWithinAt d d' s x) :
     HasDerivWithinAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') s x :=
@@ -380,26 +473,34 @@ theorem HasDerivWithinAt.clm_comp (hc : HasDerivWithinAt c c' s x)
   rwa [add_apply, comp_apply, comp_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
     one_smul, add_comm] at this 
 #align has_deriv_within_at.clm_comp HasDerivWithinAt.clm_comp
+-/
 
+#print HasDerivAt.clm_comp /-
 theorem HasDerivAt.clm_comp (hc : HasDerivAt c c' x) (hd : HasDerivAt d d' x) :
     HasDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x :=
   by
   rw [← hasDerivWithinAt_univ] at *
   exact hc.clm_comp hd
 #align has_deriv_at.clm_comp HasDerivAt.clm_comp
+-/
 
+#print derivWithin_clm_comp /-
 theorem derivWithin_clm_comp (hc : DifferentiableWithinAt 𝕜 c s x)
     (hd : DifferentiableWithinAt 𝕜 d s x) (hxs : UniqueDiffWithinAt 𝕜 s x) :
     derivWithin (fun y => (c y).comp (d y)) s x =
       (derivWithin c s x).comp (d x) + (c x).comp (derivWithin d s x) :=
   (hc.HasDerivWithinAt.clm_comp hd.HasDerivWithinAt).derivWithin hxs
 #align deriv_within_clm_comp derivWithin_clm_comp
+-/
 
+#print deriv_clm_comp /-
 theorem deriv_clm_comp (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
     deriv (fun y => (c y).comp (d y)) x = (deriv c x).comp (d x) + (c x).comp (deriv d x) :=
   (hc.HasDerivAt.clm_comp hd.HasDerivAt).deriv
 #align deriv_clm_comp deriv_clm_comp
+-/
 
+#print HasStrictDerivAt.clm_apply /-
 theorem HasStrictDerivAt.clm_apply (hc : HasStrictDerivAt c c' x) (hu : HasStrictDerivAt u u' x) :
     HasStrictDerivAt (fun y => (c y) (u y)) (c' (u x) + c x u') x :=
   by
@@ -407,7 +508,9 @@ theorem HasStrictDerivAt.clm_apply (hc : HasStrictDerivAt c c' x) (hu : HasStric
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
     one_smul, add_comm] at this 
 #align has_strict_deriv_at.clm_apply HasStrictDerivAt.clm_apply
+-/
 
+#print HasDerivWithinAt.clm_apply /-
 theorem HasDerivWithinAt.clm_apply (hc : HasDerivWithinAt c c' s x)
     (hu : HasDerivWithinAt u u' s x) :
     HasDerivWithinAt (fun y => (c y) (u y)) (c' (u x) + c x u') s x :=
@@ -416,7 +519,9 @@ theorem HasDerivWithinAt.clm_apply (hc : HasDerivWithinAt c c' s x)
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
     one_smul, add_comm] at this 
 #align has_deriv_within_at.clm_apply HasDerivWithinAt.clm_apply
+-/
 
+#print HasDerivAt.clm_apply /-
 theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
     HasDerivAt (fun y => (c y) (u y)) (c' (u x) + c x u') x :=
   by
@@ -424,17 +529,22 @@ theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
     one_smul, add_comm] at this 
 #align has_deriv_at.clm_apply HasDerivAt.clm_apply
+-/
 
+#print derivWithin_clm_apply /-
 theorem derivWithin_clm_apply (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
     (hu : DifferentiableWithinAt 𝕜 u s x) :
     derivWithin (fun y => (c y) (u y)) s x = derivWithin c s x (u x) + c x (derivWithin u s x) :=
   (hc.HasDerivWithinAt.clm_apply hu.HasDerivWithinAt).derivWithin hxs
 #align deriv_within_clm_apply derivWithin_clm_apply
+-/
 
+#print deriv_clm_apply /-
 theorem deriv_clm_apply (hc : DifferentiableAt 𝕜 c x) (hu : DifferentiableAt 𝕜 u x) :
     deriv (fun y => (c y) (u y)) x = deriv c x (u x) + c x (deriv u x) :=
   (hc.HasDerivAt.clm_apply hu.HasDerivAt).deriv
 #align deriv_clm_apply deriv_clm_apply
+-/
 
 end ClmCompApply
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -263,7 +263,7 @@ theorem deriv_mul_const_field' (v : 𝕜') : (deriv fun x => u x * v) = fun x =>
 theorem HasDerivWithinAt.const_mul (c : 𝔸) (hd : HasDerivWithinAt d d' s x) :
     HasDerivWithinAt (fun y => c * d y) (c * d') s x :=
   by
-  convert(hasDerivWithinAt_const x s c).mul hd
+  convert (hasDerivWithinAt_const x s c).mul hd
   rw [MulZeroClass.zero_mul, zero_add]
 #align has_deriv_within_at.const_mul HasDerivWithinAt.const_mul
 
@@ -277,7 +277,7 @@ theorem HasDerivAt.const_mul (c : 𝔸) (hd : HasDerivAt d d' x) :
 theorem HasStrictDerivAt.const_mul (c : 𝔸) (hd : HasStrictDerivAt d d' x) :
     HasStrictDerivAt (fun y => c * d y) (c * d') x :=
   by
-  convert(hasStrictDerivAt_const _ _).mul hd
+  convert (hasStrictDerivAt_const _ _).mul hd
   rw [MulZeroClass.zero_mul, zero_add]
 #align has_strict_deriv_at.const_mul HasStrictDerivAt.const_mul
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -95,14 +95,14 @@ theorem HasStrictDerivAt.smul_const (hc : HasStrictDerivAt c c' x) (f : F) :
     HasStrictDerivAt (fun y => c y • f) (c' • f) x :=
   by
   have := hc.smul (hasStrictDerivAt_const x f)
-  rwa [smul_zero, zero_add] at this
+  rwa [smul_zero, zero_add] at this 
 #align has_strict_deriv_at.smul_const HasStrictDerivAt.smul_const
 
 theorem HasDerivWithinAt.smul_const (hc : HasDerivWithinAt c c' s x) (f : F) :
     HasDerivWithinAt (fun y => c y • f) (c' • f) s x :=
   by
   have := hc.smul (hasDerivWithinAt_const x s f)
-  rwa [smul_zero, zero_add] at this
+  rwa [smul_zero, zero_add] at this 
 #align has_deriv_within_at.smul_const HasDerivWithinAt.smul_const
 
 theorem HasDerivAt.smul_const (hc : HasDerivAt c c' x) (f : F) :
@@ -177,7 +177,7 @@ theorem HasDerivWithinAt.mul (hc : HasDerivWithinAt c c' s x) (hd : HasDerivWith
   rwa [ContinuousLinearMap.add_apply, ContinuousLinearMap.smul_apply,
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.smulRight_apply,
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
-    add_comm] at this
+    add_comm] at this 
 #align has_deriv_within_at.mul HasDerivWithinAt.mul
 
 theorem HasDerivAt.mul (hc : HasDerivAt c c' x) (hd : HasDerivAt d d' x) :
@@ -194,7 +194,7 @@ theorem HasStrictDerivAt.mul (hc : HasStrictDerivAt c c' x) (hd : HasStrictDeriv
   rwa [ContinuousLinearMap.add_apply, ContinuousLinearMap.smul_apply,
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.smulRight_apply,
     ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
-    add_comm] at this
+    add_comm] at this 
 #align has_strict_deriv_at.mul HasStrictDerivAt.mul
 
 theorem derivWithin_mul (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
@@ -369,7 +369,7 @@ theorem HasStrictDerivAt.clm_comp (hc : HasStrictDerivAt c c' x) (hd : HasStrict
   by
   have := (hc.has_strict_fderiv_at.clm_comp hd.has_strict_fderiv_at).HasStrictDerivAt
   rwa [add_apply, comp_apply, comp_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this
+    one_smul, add_comm] at this 
 #align has_strict_deriv_at.clm_comp HasStrictDerivAt.clm_comp
 
 theorem HasDerivWithinAt.clm_comp (hc : HasDerivWithinAt c c' s x)
@@ -378,7 +378,7 @@ theorem HasDerivWithinAt.clm_comp (hc : HasDerivWithinAt c c' s x)
   by
   have := (hc.has_fderiv_within_at.clm_comp hd.has_fderiv_within_at).HasDerivWithinAt
   rwa [add_apply, comp_apply, comp_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this
+    one_smul, add_comm] at this 
 #align has_deriv_within_at.clm_comp HasDerivWithinAt.clm_comp
 
 theorem HasDerivAt.clm_comp (hc : HasDerivAt c c' x) (hd : HasDerivAt d d' x) :
@@ -405,7 +405,7 @@ theorem HasStrictDerivAt.clm_apply (hc : HasStrictDerivAt c c' x) (hu : HasStric
   by
   have := (hc.has_strict_fderiv_at.clm_apply hu.has_strict_fderiv_at).HasStrictDerivAt
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this
+    one_smul, add_comm] at this 
 #align has_strict_deriv_at.clm_apply HasStrictDerivAt.clm_apply
 
 theorem HasDerivWithinAt.clm_apply (hc : HasDerivWithinAt c c' s x)
@@ -414,7 +414,7 @@ theorem HasDerivWithinAt.clm_apply (hc : HasDerivWithinAt c c' s x)
   by
   have := (hc.has_fderiv_within_at.clm_apply hu.has_fderiv_within_at).HasDerivWithinAt
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this
+    one_smul, add_comm] at this 
 #align has_deriv_within_at.clm_apply HasDerivWithinAt.clm_apply
 
 theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
@@ -422,7 +422,7 @@ theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
   by
   have := (hc.has_fderiv_at.clm_apply hu.has_fderiv_at).HasDerivAt
   rwa [add_apply, comp_apply, flip_apply, smul_right_apply, smul_right_apply, one_apply, one_smul,
-    one_smul, add_comm] at this
+    one_smul, add_comm] at this 
 #align has_deriv_at.clm_apply HasDerivAt.clm_apply
 
 theorem derivWithin_clm_apply (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Gabriel Ebner, Anatole Dedecker, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module analysis.calculus.deriv.mul
-! leanprover-community/mathlib commit 3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe
+! leanprover-community/mathlib commit f60c6087a7275b72d5db3c5a1d0e19e35a429c0a
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.Analysis.Calculus.Fderiv.Add
 /-!
 # Derivative of `f x * g x`
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we prove formulas for `(f x * g x)'` and `(f x • g x)'`.
 
 For a more detailed overview of one-dimensional derivatives in mathlib, see the module docstring of

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -30,7 +30,7 @@ universe u v w
 
 noncomputable section
 
-open Classical Topology BigOperators Filter ENNReal
+open scoped Classical Topology BigOperators Filter ENNReal
 
 open Filter Asymptotics Set
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

We already have the fderiv versions.

@@ -36,12 +36,46 @@ open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
 variable {𝕜 : Type u} [NontriviallyNormedField 𝕜]
 variable {F : Type v} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
 variable {E : Type w} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+variable {G : Type*} [NormedAddCommGroup G] [NormedSpace 𝕜 G]
 variable {f f₀ f₁ g : 𝕜 → F}
 variable {f' f₀' f₁' g' : F}
 variable {x : 𝕜}
 variable {s t : Set 𝕜}
 variable {L L₁ L₂ : Filter 𝕜}
 
+/-! ### Derivative of bilinear maps -/
+
+namespace ContinuousLinearMap
+
+variable {B : E →L[𝕜] F →L[𝕜] G} {u : 𝕜 → E} {v : 𝕜 → F} {u' : E} {v' : F}
+
+theorem hasDerivWithinAt_of_bilinear
+    (hu : HasDerivWithinAt u u' s x) (hv : HasDerivWithinAt v v' s x) :
+    HasDerivWithinAt (fun x ↦ B (u x) (v x)) (B (u x) v' + B u' (v x)) s x := by
+  simpa using (B.hasFDerivWithinAt_of_bilinear
+    hu.hasFDerivWithinAt hv.hasFDerivWithinAt).hasDerivWithinAt
+
+theorem hasDerivAt_of_bilinear (hu : HasDerivAt u u' x) (hv : HasDerivAt v v' x) :
+    HasDerivAt (fun x ↦ B (u x) (v x)) (B (u x) v' + B u' (v x)) x := by
+  simpa using (B.hasFDerivAt_of_bilinear hu.hasFDerivAt hv.hasFDerivAt).hasDerivAt
+
+theorem hasStrictDerivAt_of_bilinear (hu : HasStrictDerivAt u u' x) (hv : HasStrictDerivAt v v' x) :
+    HasStrictDerivAt (fun x ↦ B (u x) (v x)) (B (u x) v' + B u' (v x)) x := by
+  simpa using
+    (B.hasStrictFDerivAt_of_bilinear hu.hasStrictFDerivAt hv.hasStrictFDerivAt).hasStrictDerivAt
+
+theorem derivWithin_of_bilinear (hxs : UniqueDiffWithinAt 𝕜 s x)
+    (hu : DifferentiableWithinAt 𝕜 u s x) (hv : DifferentiableWithinAt 𝕜 v s x) :
+    derivWithin (fun y => B (u y) (v y)) s x =
+      B (u x) (derivWithin v s x) + B (derivWithin u s x) (v x) :=
+  (B.hasDerivWithinAt_of_bilinear hu.hasDerivWithinAt hv.hasDerivWithinAt).derivWithin hxs
+
+theorem deriv_of_bilinear (hu : DifferentiableAt 𝕜 u x) (hv : DifferentiableAt 𝕜 v x) :
+    deriv (fun y => B (u y) (v y)) x = B (u x) (deriv v x) + B (deriv u x) (v x) :=
+  (B.hasDerivAt_of_bilinear hu.hasDerivAt hv.hasDerivAt).deriv
+
+end ContinuousLinearMap
+
 section SMul
 
 /-! ### Derivative of the multiplication of a scalar function and a vector function -/

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -34,19 +34,12 @@ open Filter Asymptotics Set
 open ContinuousLinearMap (smulRight smulRight_one_eq_iff)
 
 variable {𝕜 : Type u} [NontriviallyNormedField 𝕜]
-
 variable {F : Type v} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
-
 variable {E : Type w} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
-
 variable {f f₀ f₁ g : 𝕜 → F}
-
 variable {f' f₀' f₁' g' : F}
-
 variable {x : 𝕜}
-
 variable {s t : Set 𝕜}
-
 variable {L L₁ L₂ : Filter 𝕜}
 
 section SMul

This adds

lemma deriv_comp_neg (f : 𝕜 → F) (a : 𝕜) : deriv (fun x ↦ f (-x)) a = -deriv f (-a)

/-- A variant of `deriv_const_smul` without differentiability assumption when the scalar
multiplication is by field elements. -/
lemma deriv_const_smul' {f : 𝕜 → F} {x : 𝕜} {R : Type*} [Field R] [Module R F] [SMulCommClass 𝕜 R F]
    [ContinuousConstSMul R F] (c : R) :
    deriv (fun y ↦ c • f y) x = c • deriv f x

lemma iteratedDeriv_neg (n : ℕ) (f : 𝕜 → F) (a : 𝕜) :
    iteratedDeriv n (fun x ↦ -(f x)) a = -(iteratedDeriv n f a)

lemma iteratedDeriv_comp_neg (n : ℕ) (f : 𝕜 → F) (a : 𝕜) :
    iteratedDeriv n (fun x ↦ f (-x)) a = (-1 : 𝕜) ^ n • iteratedDeriv n f (-a)

which will come in handy in some future PRs on L-series.

See here on Zulip.

@@ -150,6 +150,22 @@ theorem deriv_const_smul (c : R) (hf : DifferentiableAt 𝕜 f x) :
   (hf.hasDerivAt.const_smul c).deriv
 #align deriv_const_smul deriv_const_smul
 
+/-- A variant of `deriv_const_smul` without differentiability assumption when the scalar
+multiplication is by field elements. -/
+lemma deriv_const_smul' {f : 𝕜 → F} {x : 𝕜} {R : Type*} [Field R] [Module R F] [SMulCommClass 𝕜 R F]
+    [ContinuousConstSMul R F] (c : R) :
+    deriv (fun y ↦ c • f y) x = c • deriv f x := by
+  by_cases hf : DifferentiableAt 𝕜 f x
+  · exact deriv_const_smul c hf
+  · rcases eq_or_ne c 0 with rfl | hc
+    · simp only [zero_smul, deriv_const']
+    · have H : ¬DifferentiableAt 𝕜 (fun y ↦ c • f y) x := by
+        contrapose! hf
+        change DifferentiableAt 𝕜 (fun y ↦ f y) x
+        conv => enter [2, y]; rw [← inv_smul_smul₀ hc (f y)]
+        exact DifferentiableAt.const_smul hf c⁻¹
+      rw [deriv_zero_of_not_differentiableAt hf, deriv_zero_of_not_differentiableAt H, smul_zero]
+
 end ConstSMul
 
 section Mul

add (iterated) deriv for prod

• Add HasFDerivAt + variants for Finset.prod (and ContinuousMultilinearMap.mkPiAlgebra)
• Add missing iteratedFDerivWithin equivalents for zero, const (resolves a todo in Analysis.Calculus.ContDiff.Basic)
• Add iteratedFDeriv[Within]_sum for symmetry
• Add a couple of convenience lemmas for Sym and Finset.{prod,sum}

@@ -283,6 +283,38 @@ theorem deriv_const_mul_field' (u : 𝕜') : (deriv fun x => u * v x) = fun x =>
 
 end Mul
 
+section Prod
+
+variable {ι : Type*} [DecidableEq ι] {𝔸' : Type*} [NormedCommRing 𝔸'] [NormedAlgebra 𝕜 𝔸']
+  {u : Finset ι} {f : ι → 𝕜 → 𝔸'} {f' : ι → 𝔸'}
+
+theorem HasDerivAt.finset_prod (hf : ∀ i ∈ u, HasDerivAt (f i) (f' i) x) :
+    HasDerivAt (∏ i in u, f i ·) (∑ i in u, (∏ j in u.erase i, f j x) • f' i) x := by
+  simpa [ContinuousLinearMap.sum_apply, ContinuousLinearMap.smul_apply] using
+    (HasFDerivAt.finset_prod (fun i hi ↦ (hf i hi).hasFDerivAt)).hasDerivAt
+
+theorem HasDerivWithinAt.finset_prod (hf : ∀ i ∈ u, HasDerivWithinAt (f i) (f' i) s x) :
+    HasDerivWithinAt (∏ i in u, f i ·) (∑ i in u, (∏ j in u.erase i, f j x) • f' i) s x := by
+  simpa [ContinuousLinearMap.sum_apply, ContinuousLinearMap.smul_apply] using
+    (HasFDerivWithinAt.finset_prod (fun i hi ↦ (hf i hi).hasFDerivWithinAt)).hasDerivWithinAt
+
+theorem HasStrictDerivAt.finset_prod (hf : ∀ i ∈ u, HasStrictDerivAt (f i) (f' i) x) :
+    HasStrictDerivAt (∏ i in u, f i ·) (∑ i in u, (∏ j in u.erase i, f j x) • f' i) x := by
+  simpa [ContinuousLinearMap.sum_apply, ContinuousLinearMap.smul_apply] using
+    (HasStrictFDerivAt.finset_prod (fun i hi ↦ (hf i hi).hasStrictFDerivAt)).hasStrictDerivAt
+
+theorem deriv_finset_prod (hf : ∀ i ∈ u, DifferentiableAt 𝕜 (f i) x) :
+    deriv (∏ i in u, f i ·) x = ∑ i in u, (∏ j in u.erase i, f j x) • deriv (f i) x :=
+  (HasDerivAt.finset_prod fun i hi ↦ (hf i hi).hasDerivAt).deriv
+
+theorem derivWithin_finset_prod (hxs : UniqueDiffWithinAt 𝕜 s x)
+    (hf : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (f i) s x) :
+    derivWithin (∏ i in u, f i ·) s x =
+      ∑ i in u, (∏ j in u.erase i, f j x) • derivWithin (f i) s x :=
+  (HasDerivWithinAt.finset_prod fun i hi ↦ (hf i hi).hasDerivWithinAt).derivWithin hxs
+
+end Prod
+
 section Div
 
 variable {𝕜' : Type*} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'} {c' d' : 𝕜'}

Rename

• Complex.equivRealProdClm → Complex.equivRealProdCLM;
  • TODO: should this one use CLE?
• Complex.reClm → Complex.reCLM;
• Complex.imClm → Complex.imCLM;
• Complex.conjLie → Complex.conjLIE;
• Complex.conjCle → Complex.conjCLE;
• Complex.ofRealLi → Complex.ofRealLI;
• Complex.ofRealClm → Complex.ofRealCLM;
• fderivInnerClm → fderivInnerCLM;
• LinearPMap.adjointDomainMkClm → LinearPMap.adjointDomainMkCLM;
• LinearPMap.adjointDomainMkClmExtend → LinearPMap.adjointDomainMkCLMExtend;
• IsROrC.reClm → IsROrC.reCLM;
• IsROrC.imClm → IsROrC.imCLM;
• IsROrC.conjLie → IsROrC.conjLIE;
• IsROrC.conjCle → IsROrC.conjCLE;
• IsROrC.ofRealLi → IsROrC.ofRealLI;
• IsROrC.ofRealClm → IsROrC.ofRealCLM;
• MeasureTheory.condexpL1Clm → MeasureTheory.condexpL1CLM;
• algebraMapClm → algebraMapCLM;
• WeakDual.CharacterSpace.toClm → WeakDual.CharacterSpace.toCLM;
• BoundedContinuousFunction.evalClm → BoundedContinuousFunction.evalCLM;
• ContinuousMap.evalClm → ContinuousMap.evalCLM;
• TrivSqZeroExt.fstClm → TrivSqZeroExt.fstClm;
• TrivSqZeroExt.sndClm → TrivSqZeroExt.sndCLM;
• TrivSqZeroExt.inlClm → TrivSqZeroExt.inlCLM;
• TrivSqZeroExt.inrClm → TrivSqZeroExt.inrCLM

and related theorems.

@@ -334,7 +334,7 @@ theorem deriv_div_const (d : 𝕜') : deriv (fun x => c x / d) x = deriv c x / d
 
 end Div
 
-section ClmCompApply
+section CLMCompApply
 
 /-! ### Derivative of the pointwise composition/application of continuous linear maps -/
 
@@ -410,4 +410,4 @@ theorem deriv_clm_apply (hc : DifferentiableAt 𝕜 c x) (hu : DifferentiableAt
   (hc.hasDerivAt.clm_apply hu.hasDerivAt).deriv
 #align deriv_clm_apply deriv_clm_apply
 
-end ClmCompApply
+end CLMCompApply

Normalising to naming convention rule number 6.

@@ -49,7 +49,7 @@ variable {s t : Set 𝕜}
 
 variable {L L₁ L₂ : Filter 𝕜}
 
-section Smul
+section SMul
 
 /-! ### Derivative of the multiplication of a scalar function and a vector function -/
 
@@ -113,9 +113,9 @@ theorem deriv_smul_const (hc : DifferentiableAt 𝕜 c x) (f : F) :
   (hc.hasDerivAt.smul_const f).deriv
 #align deriv_smul_const deriv_smul_const
 
-end Smul
+end SMul
 
-section ConstSmul
+section ConstSMul
 
 variable {R : Type*} [Semiring R] [Module R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F]
 
@@ -150,7 +150,7 @@ theorem deriv_const_smul (c : R) (hf : DifferentiableAt 𝕜 f x) :
   (hf.hasDerivAt.const_smul c).deriv
 #align deriv_const_smul deriv_const_smul
 
-end ConstSmul
+end ConstSMul
 
 section Mul
 
@@ -411,4 +411,3 @@ theorem deriv_clm_apply (hc : DifferentiableAt 𝕜 c x) (hu : DifferentiableAt
 #align deriv_clm_apply deriv_clm_apply
 
 end ClmCompApply
-

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

@@ -231,9 +231,9 @@ theorem deriv_mul_const (hc : DifferentiableAt 𝕜 c x) (d : 𝔸) :
 theorem deriv_mul_const_field (v : 𝕜') : deriv (fun y => u y * v) x = deriv u x * v := by
   by_cases hu : DifferentiableAt 𝕜 u x
   · exact deriv_mul_const hu v
-  · rw [deriv_zero_of_not_differentiableAt hu, MulZeroClass.zero_mul]
+  · rw [deriv_zero_of_not_differentiableAt hu, zero_mul]
     rcases eq_or_ne v 0 with (rfl | hd)
-    · simp only [MulZeroClass.mul_zero, deriv_const]
+    · simp only [mul_zero, deriv_const]
     · refine' deriv_zero_of_not_differentiableAt (mt (fun H => _) hu)
       simpa only [mul_inv_cancel_right₀ hd] using H.mul_const v⁻¹
 #align deriv_mul_const_field deriv_mul_const_field

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -54,7 +54,7 @@ section Smul
 /-! ### Derivative of the multiplication of a scalar function and a vector function -/
 
 
-variable {𝕜' : Type _} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] [NormedSpace 𝕜' F]
+variable {𝕜' : Type*} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] [NormedSpace 𝕜' F]
   [IsScalarTower 𝕜 𝕜' F] {c : 𝕜 → 𝕜'} {c' : 𝕜'}
 
 theorem HasDerivWithinAt.smul (hc : HasDerivWithinAt c c' s x) (hf : HasDerivWithinAt f f' s x) :
@@ -117,7 +117,7 @@ end Smul
 
 section ConstSmul
 
-variable {R : Type _} [Semiring R] [Module R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F]
+variable {R : Type*} [Semiring R] [Module R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F]
 
 nonrec theorem HasStrictDerivAt.const_smul (c : R) (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun y => c • f y) (c • f') x := by
@@ -157,7 +157,7 @@ section Mul
 /-! ### Derivative of the multiplication of two functions -/
 
 
-variable {𝕜' 𝔸 : Type _} [NormedField 𝕜'] [NormedRing 𝔸] [NormedAlgebra 𝕜 𝕜'] [NormedAlgebra 𝕜 𝔸]
+variable {𝕜' 𝔸 : Type*} [NormedField 𝕜'] [NormedRing 𝔸] [NormedAlgebra 𝕜 𝕜'] [NormedAlgebra 𝕜 𝔸]
   {c d : 𝕜 → 𝔸} {c' d' : 𝔸} {u v : 𝕜 → 𝕜'}
 
 theorem HasDerivWithinAt.mul (hc : HasDerivWithinAt c c' s x) (hd : HasDerivWithinAt d d' s x) :
@@ -285,7 +285,7 @@ end Mul
 
 section Div
 
-variable {𝕜' : Type _} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'} {c' d' : 𝕜'}
+variable {𝕜' : Type*} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'} {c' d' : 𝕜'}
 
 theorem HasDerivAt.div_const (hc : HasDerivAt c c' x) (d : 𝕜') :
     HasDerivAt (fun x => c x / d) (c' / d) x := by
@@ -341,7 +341,7 @@ section ClmCompApply
 
 open ContinuousLinearMap
 
-variable {G : Type _} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {c : 𝕜 → F →L[𝕜] G} {c' : F →L[𝕜] G}
+variable {G : Type*} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {c : 𝕜 → F →L[𝕜] G} {c' : F →L[𝕜] G}
   {d : 𝕜 → E →L[𝕜] F} {d' : E →L[𝕜] F} {u : 𝕜 → F} {u' : F}
 
 theorem HasStrictDerivAt.clm_comp (hc : HasStrictDerivAt c c' x) (hd : HasStrictDerivAt d d' x) :

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,16 +2,13 @@
 Copyright (c) 2019 Gabriel Ebner. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Gabriel Ebner, Anatole Dedecker, Yury Kudryashov
-
-! This file was ported from Lean 3 source module analysis.calculus.deriv.mul
-! leanprover-community/mathlib commit 3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Calculus.Deriv.Basic
 import Mathlib.Analysis.Calculus.FDeriv.Mul
 import Mathlib.Analysis.Calculus.FDeriv.Add
 
+#align_import analysis.calculus.deriv.mul from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
+
 /-!
 # Derivative of `f x * g x`