analysis.special_functions.trigonometric.deriv ⟷ Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv

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

@@ -996,7 +996,7 @@ theorem abs_sinh (x : ℝ) : |sinh x| = sinh |x| := by
 #print Real.cosh_strictMonoOn /-
 theorem cosh_strictMonoOn : StrictMonoOn cosh (Ici 0) :=
   (convex_Ici _).strictMonoOn_of_deriv_pos continuous_cosh.ContinuousOn fun x hx => by
-    rw [interior_Ici, mem_Ioi] at hx ; rwa [deriv_cosh, sinh_pos_iff]
+    rw [interior_Ici, mem_Ioi] at hx; rwa [deriv_cosh, sinh_pos_iff]
 #align real.cosh_strict_mono_on Real.cosh_strictMonoOn
 -/
 
@@ -1034,7 +1034,7 @@ theorem sinh_sub_id_strictMono : StrictMono fun x => sinh x - x :=
   refine' strictMono_of_odd_strictMonoOn_nonneg (fun x => by simp) _
   refine' (convex_Ici _).strictMonoOn_of_deriv_pos _ fun x hx => _
   · exact (continuous_sinh.sub continuous_id).ContinuousOn
-  · rw [interior_Ici, mem_Ioi] at hx 
+  · rw [interior_Ici, mem_Ioi] at hx
     rw [deriv_sub, deriv_sinh, deriv_id'', sub_pos, one_lt_cosh]
     exacts [hx.ne', differentiable_at_sinh, differentiableAt_id]
 #align real.sinh_sub_id_strict_mono Real.sinh_sub_id_strictMono

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

@@ -3,9 +3,9 @@ Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Abhimanyu Pallavi Sudhir, Jean Lo, Calle Sönne, Benjamin Davidson
 -/
-import Mathbin.Order.Monotone.Odd
-import Mathbin.Analysis.SpecialFunctions.ExpDeriv
-import Mathbin.Analysis.SpecialFunctions.Trigonometric.Basic
+import Order.Monotone.Odd
+import Analysis.SpecialFunctions.ExpDeriv
+import Analysis.SpecialFunctions.Trigonometric.Basic
 
 #align_import analysis.special_functions.trigonometric.deriv from "leanprover-community/mathlib"@"36938f775671ff28bea1c0310f1608e4afbb22e0"
 

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

@@ -2,16 +2,13 @@
 Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Abhimanyu Pallavi Sudhir, Jean Lo, Calle Sönne, Benjamin Davidson
-
-! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.deriv
-! leanprover-community/mathlib commit 36938f775671ff28bea1c0310f1608e4afbb22e0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Monotone.Odd
 import Mathbin.Analysis.SpecialFunctions.ExpDeriv
 import Mathbin.Analysis.SpecialFunctions.Trigonometric.Basic
 
+#align_import analysis.special_functions.trigonometric.deriv from "leanprover-community/mathlib"@"36938f775671ff28bea1c0310f1608e4afbb22e0"
+
 /-!
 # Differentiability of trigonometric functions
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9240e8be927a0955b9a82c6c85ef499ee3a626b8

@@ -991,7 +991,7 @@ theorem sinh_nonneg_iff : 0 ≤ sinh x ↔ 0 ≤ x := by simpa only [sinh_zero]
 -/
 
 #print Real.abs_sinh /-
-theorem abs_sinh (x : ℝ) : |sinh x| = sinh (|x|) := by
+theorem abs_sinh (x : ℝ) : |sinh x| = sinh |x| := by
   cases le_total x 0 <;> simp [abs_of_nonneg, abs_of_nonpos, *]
 #align real.abs_sinh Real.abs_sinh
 -/

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

@@ -37,6 +37,7 @@ open Set Filter
 
 namespace Complex
 
+#print Complex.hasStrictDerivAt_sin /-
 /-- The complex sine function is everywhere strictly differentiable, with the derivative `cos x`. -/
 theorem hasStrictDerivAt_sin (x : ℂ) : HasStrictDerivAt sin (cos x) x :=
   by
@@ -50,30 +51,42 @@ theorem hasStrictDerivAt_sin (x : ℂ) : HasStrictDerivAt sin (cos x) x :=
   rw [sub_mul, mul_assoc, mul_assoc, I_mul_I, neg_one_mul, neg_neg, mul_one, one_mul, mul_assoc,
     I_mul_I, mul_neg_one, sub_neg_eq_add, add_comm]
 #align complex.has_strict_deriv_at_sin Complex.hasStrictDerivAt_sin
+-/
 
+#print Complex.hasDerivAt_sin /-
 /-- The complex sine function is everywhere differentiable, with the derivative `cos x`. -/
 theorem hasDerivAt_sin (x : ℂ) : HasDerivAt sin (cos x) x :=
   (hasStrictDerivAt_sin x).HasDerivAt
 #align complex.has_deriv_at_sin Complex.hasDerivAt_sin
+-/
 
+#print Complex.contDiff_sin /-
 theorem contDiff_sin {n} : ContDiff ℂ n sin :=
   (((contDiff_neg.mul contDiff_const).cexp.sub (contDiff_id.mul contDiff_const).cexp).mul
         contDiff_const).div_const
     _
 #align complex.cont_diff_sin Complex.contDiff_sin
+-/
 
+#print Complex.differentiable_sin /-
 theorem differentiable_sin : Differentiable ℂ sin := fun x => (hasDerivAt_sin x).DifferentiableAt
 #align complex.differentiable_sin Complex.differentiable_sin
+-/
 
+#print Complex.differentiableAt_sin /-
 theorem differentiableAt_sin {x : ℂ} : DifferentiableAt ℂ sin x :=
   differentiable_sin x
 #align complex.differentiable_at_sin Complex.differentiableAt_sin
+-/
 
+#print Complex.deriv_sin /-
 @[simp]
 theorem deriv_sin : deriv sin = cos :=
   funext fun x => (hasDerivAt_sin x).deriv
 #align complex.deriv_sin Complex.deriv_sin
+-/
 
+#print Complex.hasStrictDerivAt_cos /-
 /-- The complex cosine function is everywhere strictly differentiable, with the derivative
 `-sin x`. -/
 theorem hasStrictDerivAt_cos (x : ℂ) : HasStrictDerivAt cos (-sin x) x :=
@@ -86,32 +99,46 @@ theorem hasStrictDerivAt_cos (x : ℂ) : HasStrictDerivAt cos (-sin x) x :=
   simp only [Function.comp, id]
   ring
 #align complex.has_strict_deriv_at_cos Complex.hasStrictDerivAt_cos
+-/
 
+#print Complex.hasDerivAt_cos /-
 /-- The complex cosine function is everywhere differentiable, with the derivative `-sin x`. -/
 theorem hasDerivAt_cos (x : ℂ) : HasDerivAt cos (-sin x) x :=
   (hasStrictDerivAt_cos x).HasDerivAt
 #align complex.has_deriv_at_cos Complex.hasDerivAt_cos
+-/
 
+#print Complex.contDiff_cos /-
 theorem contDiff_cos {n} : ContDiff ℂ n cos :=
   ((contDiff_id.mul contDiff_const).cexp.add (contDiff_neg.mul contDiff_const).cexp).div_const _
 #align complex.cont_diff_cos Complex.contDiff_cos
+-/
 
+#print Complex.differentiable_cos /-
 theorem differentiable_cos : Differentiable ℂ cos := fun x => (hasDerivAt_cos x).DifferentiableAt
 #align complex.differentiable_cos Complex.differentiable_cos
+-/
 
+#print Complex.differentiableAt_cos /-
 theorem differentiableAt_cos {x : ℂ} : DifferentiableAt ℂ cos x :=
   differentiable_cos x
 #align complex.differentiable_at_cos Complex.differentiableAt_cos
+-/
 
+#print Complex.deriv_cos /-
 theorem deriv_cos {x : ℂ} : deriv cos x = -sin x :=
   (hasDerivAt_cos x).deriv
 #align complex.deriv_cos Complex.deriv_cos
+-/
 
+#print Complex.deriv_cos' /-
 @[simp]
 theorem deriv_cos' : deriv cos = fun x => -sin x :=
   funext fun x => deriv_cos
 #align complex.deriv_cos' Complex.deriv_cos'
+-/
 
+#print Complex.hasStrictDerivAt_sinh /-
 /-- The complex hyperbolic sine function is everywhere strictly differentiable, with the derivative
 `cosh x`. -/
 theorem hasStrictDerivAt_sinh (x : ℂ) : HasStrictDerivAt sinh (cosh x) x :=
@@ -120,29 +147,41 @@ theorem hasStrictDerivAt_sinh (x : ℂ) : HasStrictDerivAt sinh (cosh x) x :=
   convert ((hasStrictDerivAt_exp x).sub (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
   rw [id, mul_neg_one, sub_eq_add_neg, neg_neg]
 #align complex.has_strict_deriv_at_sinh Complex.hasStrictDerivAt_sinh
+-/
 
+#print Complex.hasDerivAt_sinh /-
 /-- The complex hyperbolic sine function is everywhere differentiable, with the derivative
 `cosh x`. -/
 theorem hasDerivAt_sinh (x : ℂ) : HasDerivAt sinh (cosh x) x :=
   (hasStrictDerivAt_sinh x).HasDerivAt
 #align complex.has_deriv_at_sinh Complex.hasDerivAt_sinh
+-/
 
+#print Complex.contDiff_sinh /-
 theorem contDiff_sinh {n} : ContDiff ℂ n sinh :=
   (contDiff_exp.sub contDiff_neg.cexp).div_const _
 #align complex.cont_diff_sinh Complex.contDiff_sinh
+-/
 
+#print Complex.differentiable_sinh /-
 theorem differentiable_sinh : Differentiable ℂ sinh := fun x => (hasDerivAt_sinh x).DifferentiableAt
 #align complex.differentiable_sinh Complex.differentiable_sinh
+-/
 
+#print Complex.differentiableAt_sinh /-
 theorem differentiableAt_sinh {x : ℂ} : DifferentiableAt ℂ sinh x :=
   differentiable_sinh x
 #align complex.differentiable_at_sinh Complex.differentiableAt_sinh
+-/
 
+#print Complex.deriv_sinh /-
 @[simp]
 theorem deriv_sinh : deriv sinh = cosh :=
   funext fun x => (hasDerivAt_sinh x).deriv
 #align complex.deriv_sinh Complex.deriv_sinh
+-/
 
+#print Complex.hasStrictDerivAt_cosh /-
 /-- The complex hyperbolic cosine function is everywhere strictly differentiable, with the
 derivative `sinh x`. -/
 theorem hasStrictDerivAt_cosh (x : ℂ) : HasStrictDerivAt cosh (sinh x) x :=
@@ -151,28 +190,39 @@ theorem hasStrictDerivAt_cosh (x : ℂ) : HasStrictDerivAt cosh (sinh x) x :=
   convert ((hasStrictDerivAt_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
   rw [id, mul_neg_one, sub_eq_add_neg]
 #align complex.has_strict_deriv_at_cosh Complex.hasStrictDerivAt_cosh
+-/
 
+#print Complex.hasDerivAt_cosh /-
 /-- The complex hyperbolic cosine function is everywhere differentiable, with the derivative
 `sinh x`. -/
 theorem hasDerivAt_cosh (x : ℂ) : HasDerivAt cosh (sinh x) x :=
   (hasStrictDerivAt_cosh x).HasDerivAt
 #align complex.has_deriv_at_cosh Complex.hasDerivAt_cosh
+-/
 
+#print Complex.contDiff_cosh /-
 theorem contDiff_cosh {n} : ContDiff ℂ n cosh :=
   (contDiff_exp.add contDiff_neg.cexp).div_const _
 #align complex.cont_diff_cosh Complex.contDiff_cosh
+-/
 
+#print Complex.differentiable_cosh /-
 theorem differentiable_cosh : Differentiable ℂ cosh := fun x => (hasDerivAt_cosh x).DifferentiableAt
 #align complex.differentiable_cosh Complex.differentiable_cosh
+-/
 
+#print Complex.differentiableAt_cosh /-
 theorem differentiableAt_cosh {x : ℂ} : DifferentiableAt ℂ cosh x :=
   differentiable_cosh x
 #align complex.differentiable_at_cosh Complex.differentiableAt_cosh
+-/
 
+#print Complex.deriv_cosh /-
 @[simp]
 theorem deriv_cosh : deriv cosh = sinh :=
   funext fun x => (hasDerivAt_cosh x).deriv
 #align complex.deriv_cosh Complex.deriv_cosh
+-/
 
 end Complex
 
@@ -186,118 +236,158 @@ variable {f : ℂ → ℂ} {f' x : ℂ} {s : Set ℂ}
 /-! #### `complex.cos` -/
 
 
+#print HasStrictDerivAt.ccos /-
 theorem HasStrictDerivAt.ccos (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x :=
   (Complex.hasStrictDerivAt_cos (f x)).comp x hf
 #align has_strict_deriv_at.ccos HasStrictDerivAt.ccos
+-/
 
+#print HasDerivAt.ccos /-
 theorem HasDerivAt.ccos (hf : HasDerivAt f f' x) :
     HasDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x :=
   (Complex.hasDerivAt_cos (f x)).comp x hf
 #align has_deriv_at.ccos HasDerivAt.ccos
+-/
 
+#print HasDerivWithinAt.ccos /-
 theorem HasDerivWithinAt.ccos (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') s x :=
   (Complex.hasDerivAt_cos (f x)).comp_hasDerivWithinAt x hf
 #align has_deriv_within_at.ccos HasDerivWithinAt.ccos
+-/
 
+#print derivWithin_ccos /-
 theorem derivWithin_ccos (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     derivWithin (fun x => Complex.cos (f x)) s x = -Complex.sin (f x) * derivWithin f s x :=
   hf.HasDerivWithinAt.ccos.derivWithin hxs
 #align deriv_within_ccos derivWithin_ccos
+-/
 
+#print deriv_ccos /-
 @[simp]
 theorem deriv_ccos (hc : DifferentiableAt ℂ f x) :
     deriv (fun x => Complex.cos (f x)) x = -Complex.sin (f x) * deriv f x :=
   hc.HasDerivAt.ccos.deriv
 #align deriv_ccos deriv_ccos
+-/
 
 /-! #### `complex.sin` -/
 
 
+#print HasStrictDerivAt.csin /-
 theorem HasStrictDerivAt.csin (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x :=
   (Complex.hasStrictDerivAt_sin (f x)).comp x hf
 #align has_strict_deriv_at.csin HasStrictDerivAt.csin
+-/
 
+#print HasDerivAt.csin /-
 theorem HasDerivAt.csin (hf : HasDerivAt f f' x) :
     HasDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x :=
   (Complex.hasDerivAt_sin (f x)).comp x hf
 #align has_deriv_at.csin HasDerivAt.csin
+-/
 
+#print HasDerivWithinAt.csin /-
 theorem HasDerivWithinAt.csin (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') s x :=
   (Complex.hasDerivAt_sin (f x)).comp_hasDerivWithinAt x hf
 #align has_deriv_within_at.csin HasDerivWithinAt.csin
+-/
 
+#print derivWithin_csin /-
 theorem derivWithin_csin (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     derivWithin (fun x => Complex.sin (f x)) s x = Complex.cos (f x) * derivWithin f s x :=
   hf.HasDerivWithinAt.csin.derivWithin hxs
 #align deriv_within_csin derivWithin_csin
+-/
 
+#print deriv_csin /-
 @[simp]
 theorem deriv_csin (hc : DifferentiableAt ℂ f x) :
     deriv (fun x => Complex.sin (f x)) x = Complex.cos (f x) * deriv f x :=
   hc.HasDerivAt.csin.deriv
 #align deriv_csin deriv_csin
+-/
 
 /-! #### `complex.cosh` -/
 
 
+#print HasStrictDerivAt.ccosh /-
 theorem HasStrictDerivAt.ccosh (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') x :=
   (Complex.hasStrictDerivAt_cosh (f x)).comp x hf
 #align has_strict_deriv_at.ccosh HasStrictDerivAt.ccosh
+-/
 
+#print HasDerivAt.ccosh /-
 theorem HasDerivAt.ccosh (hf : HasDerivAt f f' x) :
     HasDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') x :=
   (Complex.hasDerivAt_cosh (f x)).comp x hf
 #align has_deriv_at.ccosh HasDerivAt.ccosh
+-/
 
+#print HasDerivWithinAt.ccosh /-
 theorem HasDerivWithinAt.ccosh (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') s x :=
   (Complex.hasDerivAt_cosh (f x)).comp_hasDerivWithinAt x hf
 #align has_deriv_within_at.ccosh HasDerivWithinAt.ccosh
+-/
 
+#print derivWithin_ccosh /-
 theorem derivWithin_ccosh (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     derivWithin (fun x => Complex.cosh (f x)) s x = Complex.sinh (f x) * derivWithin f s x :=
   hf.HasDerivWithinAt.ccosh.derivWithin hxs
 #align deriv_within_ccosh derivWithin_ccosh
+-/
 
+#print deriv_ccosh /-
 @[simp]
 theorem deriv_ccosh (hc : DifferentiableAt ℂ f x) :
     deriv (fun x => Complex.cosh (f x)) x = Complex.sinh (f x) * deriv f x :=
   hc.HasDerivAt.ccosh.deriv
 #align deriv_ccosh deriv_ccosh
+-/
 
 /-! #### `complex.sinh` -/
 
 
+#print HasStrictDerivAt.csinh /-
 theorem HasStrictDerivAt.csinh (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') x :=
   (Complex.hasStrictDerivAt_sinh (f x)).comp x hf
 #align has_strict_deriv_at.csinh HasStrictDerivAt.csinh
+-/
 
+#print HasDerivAt.csinh /-
 theorem HasDerivAt.csinh (hf : HasDerivAt f f' x) :
     HasDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') x :=
   (Complex.hasDerivAt_sinh (f x)).comp x hf
 #align has_deriv_at.csinh HasDerivAt.csinh
+-/
 
+#print HasDerivWithinAt.csinh /-
 theorem HasDerivWithinAt.csinh (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') s x :=
   (Complex.hasDerivAt_sinh (f x)).comp_hasDerivWithinAt x hf
 #align has_deriv_within_at.csinh HasDerivWithinAt.csinh
+-/
 
+#print derivWithin_csinh /-
 theorem derivWithin_csinh (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     derivWithin (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) * derivWithin f s x :=
   hf.HasDerivWithinAt.csinh.derivWithin hxs
 #align deriv_within_csinh derivWithin_csinh
+-/
 
+#print deriv_csinh /-
 @[simp]
 theorem deriv_csinh (hc : DifferentiableAt ℂ f x) :
     deriv (fun x => Complex.sinh (f x)) x = Complex.cosh (f x) * deriv f x :=
   hc.HasDerivAt.csinh.deriv
 #align deriv_csinh deriv_csinh
+-/
 
 end
 
@@ -312,274 +402,378 @@ variable {E : Type _} [NormedAddCommGroup E] [NormedSpace ℂ E] {f : E → ℂ}
 /-! #### `complex.cos` -/
 
 
+#print HasStrictFDerivAt.ccos /-
 theorem HasStrictFDerivAt.ccos (hf : HasStrictFDerivAt f f' x) :
     HasStrictFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x :=
   (Complex.hasStrictDerivAt_cos (f x)).comp_hasStrictFDerivAt x hf
 #align has_strict_fderiv_at.ccos HasStrictFDerivAt.ccos
+-/
 
+#print HasFDerivAt.ccos /-
 theorem HasFDerivAt.ccos (hf : HasFDerivAt f f' x) :
     HasFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x :=
   (Complex.hasDerivAt_cos (f x)).comp_hasFDerivAt x hf
 #align has_fderiv_at.ccos HasFDerivAt.ccos
+-/
 
+#print HasFDerivWithinAt.ccos /-
 theorem HasFDerivWithinAt.ccos (hf : HasFDerivWithinAt f f' s x) :
     HasFDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') s x :=
   (Complex.hasDerivAt_cos (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.ccos HasFDerivWithinAt.ccos
+-/
 
+#print DifferentiableWithinAt.ccos /-
 theorem DifferentiableWithinAt.ccos (hf : DifferentiableWithinAt ℂ f s x) :
     DifferentiableWithinAt ℂ (fun x => Complex.cos (f x)) s x :=
   hf.HasFDerivWithinAt.ccos.DifferentiableWithinAt
 #align differentiable_within_at.ccos DifferentiableWithinAt.ccos
+-/
 
+#print DifferentiableAt.ccos /-
 @[simp]
 theorem DifferentiableAt.ccos (hc : DifferentiableAt ℂ f x) :
     DifferentiableAt ℂ (fun x => Complex.cos (f x)) x :=
   hc.HasFDerivAt.ccos.DifferentiableAt
 #align differentiable_at.ccos DifferentiableAt.ccos
+-/
 
+#print DifferentiableOn.ccos /-
 theorem DifferentiableOn.ccos (hc : DifferentiableOn ℂ f s) :
     DifferentiableOn ℂ (fun x => Complex.cos (f x)) s := fun x h => (hc x h).ccos
 #align differentiable_on.ccos DifferentiableOn.ccos
+-/
 
+#print Differentiable.ccos /-
 @[simp]
 theorem Differentiable.ccos (hc : Differentiable ℂ f) :
     Differentiable ℂ fun x => Complex.cos (f x) := fun x => (hc x).ccos
 #align differentiable.ccos Differentiable.ccos
+-/
 
+#print fderivWithin_ccos /-
 theorem fderivWithin_ccos (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     fderivWithin ℂ (fun x => Complex.cos (f x)) s x = -Complex.sin (f x) • fderivWithin ℂ f s x :=
   hf.HasFDerivWithinAt.ccos.fderivWithin hxs
 #align fderiv_within_ccos fderivWithin_ccos
+-/
 
+#print fderiv_ccos /-
 @[simp]
 theorem fderiv_ccos (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.cos (f x)) x = -Complex.sin (f x) • fderiv ℂ f x :=
   hc.HasFDerivAt.ccos.fderiv
 #align fderiv_ccos fderiv_ccos
+-/
 
+#print ContDiff.ccos /-
 theorem ContDiff.ccos {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.cos (f x) :=
   Complex.contDiff_cos.comp h
 #align cont_diff.ccos ContDiff.ccos
+-/
 
+#print ContDiffAt.ccos /-
 theorem ContDiffAt.ccos {n} (hf : ContDiffAt ℂ n f x) :
     ContDiffAt ℂ n (fun x => Complex.cos (f x)) x :=
   Complex.contDiff_cos.ContDiffAt.comp x hf
 #align cont_diff_at.ccos ContDiffAt.ccos
+-/
 
+#print ContDiffOn.ccos /-
 theorem ContDiffOn.ccos {n} (hf : ContDiffOn ℂ n f s) :
     ContDiffOn ℂ n (fun x => Complex.cos (f x)) s :=
   Complex.contDiff_cos.comp_contDiffOn hf
 #align cont_diff_on.ccos ContDiffOn.ccos
+-/
 
+#print ContDiffWithinAt.ccos /-
 theorem ContDiffWithinAt.ccos {n} (hf : ContDiffWithinAt ℂ n f s x) :
     ContDiffWithinAt ℂ n (fun x => Complex.cos (f x)) s x :=
   Complex.contDiff_cos.ContDiffAt.comp_contDiffWithinAt x hf
 #align cont_diff_within_at.ccos ContDiffWithinAt.ccos
+-/
 
 /-! #### `complex.sin` -/
 
 
+#print HasStrictFDerivAt.csin /-
 theorem HasStrictFDerivAt.csin (hf : HasStrictFDerivAt f f' x) :
     HasStrictFDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x :=
   (Complex.hasStrictDerivAt_sin (f x)).comp_hasStrictFDerivAt x hf
 #align has_strict_fderiv_at.csin HasStrictFDerivAt.csin
+-/
 
+#print HasFDerivAt.csin /-
 theorem HasFDerivAt.csin (hf : HasFDerivAt f f' x) :
     HasFDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x :=
   (Complex.hasDerivAt_sin (f x)).comp_hasFDerivAt x hf
 #align has_fderiv_at.csin HasFDerivAt.csin
+-/
 
+#print HasFDerivWithinAt.csin /-
 theorem HasFDerivWithinAt.csin (hf : HasFDerivWithinAt f f' s x) :
     HasFDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') s x :=
   (Complex.hasDerivAt_sin (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.csin HasFDerivWithinAt.csin
+-/
 
+#print DifferentiableWithinAt.csin /-
 theorem DifferentiableWithinAt.csin (hf : DifferentiableWithinAt ℂ f s x) :
     DifferentiableWithinAt ℂ (fun x => Complex.sin (f x)) s x :=
   hf.HasFDerivWithinAt.csin.DifferentiableWithinAt
 #align differentiable_within_at.csin DifferentiableWithinAt.csin
+-/
 
+#print DifferentiableAt.csin /-
 @[simp]
 theorem DifferentiableAt.csin (hc : DifferentiableAt ℂ f x) :
     DifferentiableAt ℂ (fun x => Complex.sin (f x)) x :=
   hc.HasFDerivAt.csin.DifferentiableAt
 #align differentiable_at.csin DifferentiableAt.csin
+-/
 
+#print DifferentiableOn.csin /-
 theorem DifferentiableOn.csin (hc : DifferentiableOn ℂ f s) :
     DifferentiableOn ℂ (fun x => Complex.sin (f x)) s := fun x h => (hc x h).csin
 #align differentiable_on.csin DifferentiableOn.csin
+-/
 
+#print Differentiable.csin /-
 @[simp]
 theorem Differentiable.csin (hc : Differentiable ℂ f) :
     Differentiable ℂ fun x => Complex.sin (f x) := fun x => (hc x).csin
 #align differentiable.csin Differentiable.csin
+-/
 
+#print fderivWithin_csin /-
 theorem fderivWithin_csin (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     fderivWithin ℂ (fun x => Complex.sin (f x)) s x = Complex.cos (f x) • fderivWithin ℂ f s x :=
   hf.HasFDerivWithinAt.csin.fderivWithin hxs
 #align fderiv_within_csin fderivWithin_csin
+-/
 
+#print fderiv_csin /-
 @[simp]
 theorem fderiv_csin (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.sin (f x)) x = Complex.cos (f x) • fderiv ℂ f x :=
   hc.HasFDerivAt.csin.fderiv
 #align fderiv_csin fderiv_csin
+-/
 
+#print ContDiff.csin /-
 theorem ContDiff.csin {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.sin (f x) :=
   Complex.contDiff_sin.comp h
 #align cont_diff.csin ContDiff.csin
+-/
 
+#print ContDiffAt.csin /-
 theorem ContDiffAt.csin {n} (hf : ContDiffAt ℂ n f x) :
     ContDiffAt ℂ n (fun x => Complex.sin (f x)) x :=
   Complex.contDiff_sin.ContDiffAt.comp x hf
 #align cont_diff_at.csin ContDiffAt.csin
+-/
 
+#print ContDiffOn.csin /-
 theorem ContDiffOn.csin {n} (hf : ContDiffOn ℂ n f s) :
     ContDiffOn ℂ n (fun x => Complex.sin (f x)) s :=
   Complex.contDiff_sin.comp_contDiffOn hf
 #align cont_diff_on.csin ContDiffOn.csin
+-/
 
+#print ContDiffWithinAt.csin /-
 theorem ContDiffWithinAt.csin {n} (hf : ContDiffWithinAt ℂ n f s x) :
     ContDiffWithinAt ℂ n (fun x => Complex.sin (f x)) s x :=
   Complex.contDiff_sin.ContDiffAt.comp_contDiffWithinAt x hf
 #align cont_diff_within_at.csin ContDiffWithinAt.csin
+-/
 
 /-! #### `complex.cosh` -/
 
 
+#print HasStrictFDerivAt.ccosh /-
 theorem HasStrictFDerivAt.ccosh (hf : HasStrictFDerivAt f f' x) :
     HasStrictFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x :=
   (Complex.hasStrictDerivAt_cosh (f x)).comp_hasStrictFDerivAt x hf
 #align has_strict_fderiv_at.ccosh HasStrictFDerivAt.ccosh
+-/
 
+#print HasFDerivAt.ccosh /-
 theorem HasFDerivAt.ccosh (hf : HasFDerivAt f f' x) :
     HasFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x :=
   (Complex.hasDerivAt_cosh (f x)).comp_hasFDerivAt x hf
 #align has_fderiv_at.ccosh HasFDerivAt.ccosh
+-/
 
+#print HasFDerivWithinAt.ccosh /-
 theorem HasFDerivWithinAt.ccosh (hf : HasFDerivWithinAt f f' s x) :
     HasFDerivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') s x :=
   (Complex.hasDerivAt_cosh (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.ccosh HasFDerivWithinAt.ccosh
+-/
 
+#print DifferentiableWithinAt.ccosh /-
 theorem DifferentiableWithinAt.ccosh (hf : DifferentiableWithinAt ℂ f s x) :
     DifferentiableWithinAt ℂ (fun x => Complex.cosh (f x)) s x :=
   hf.HasFDerivWithinAt.ccosh.DifferentiableWithinAt
 #align differentiable_within_at.ccosh DifferentiableWithinAt.ccosh
+-/
 
+#print DifferentiableAt.ccosh /-
 @[simp]
 theorem DifferentiableAt.ccosh (hc : DifferentiableAt ℂ f x) :
     DifferentiableAt ℂ (fun x => Complex.cosh (f x)) x :=
   hc.HasFDerivAt.ccosh.DifferentiableAt
 #align differentiable_at.ccosh DifferentiableAt.ccosh
+-/
 
+#print DifferentiableOn.ccosh /-
 theorem DifferentiableOn.ccosh (hc : DifferentiableOn ℂ f s) :
     DifferentiableOn ℂ (fun x => Complex.cosh (f x)) s := fun x h => (hc x h).ccosh
 #align differentiable_on.ccosh DifferentiableOn.ccosh
+-/
 
+#print Differentiable.ccosh /-
 @[simp]
 theorem Differentiable.ccosh (hc : Differentiable ℂ f) :
     Differentiable ℂ fun x => Complex.cosh (f x) := fun x => (hc x).ccosh
 #align differentiable.ccosh Differentiable.ccosh
+-/
 
+#print fderivWithin_ccosh /-
 theorem fderivWithin_ccosh (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     fderivWithin ℂ (fun x => Complex.cosh (f x)) s x = Complex.sinh (f x) • fderivWithin ℂ f s x :=
   hf.HasFDerivWithinAt.ccosh.fderivWithin hxs
 #align fderiv_within_ccosh fderivWithin_ccosh
+-/
 
+#print fderiv_ccosh /-
 @[simp]
 theorem fderiv_ccosh (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.cosh (f x)) x = Complex.sinh (f x) • fderiv ℂ f x :=
   hc.HasFDerivAt.ccosh.fderiv
 #align fderiv_ccosh fderiv_ccosh
+-/
 
+#print ContDiff.ccosh /-
 theorem ContDiff.ccosh {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.cosh (f x) :=
   Complex.contDiff_cosh.comp h
 #align cont_diff.ccosh ContDiff.ccosh
+-/
 
+#print ContDiffAt.ccosh /-
 theorem ContDiffAt.ccosh {n} (hf : ContDiffAt ℂ n f x) :
     ContDiffAt ℂ n (fun x => Complex.cosh (f x)) x :=
   Complex.contDiff_cosh.ContDiffAt.comp x hf
 #align cont_diff_at.ccosh ContDiffAt.ccosh
+-/
 
+#print ContDiffOn.ccosh /-
 theorem ContDiffOn.ccosh {n} (hf : ContDiffOn ℂ n f s) :
     ContDiffOn ℂ n (fun x => Complex.cosh (f x)) s :=
   Complex.contDiff_cosh.comp_contDiffOn hf
 #align cont_diff_on.ccosh ContDiffOn.ccosh
+-/
 
+#print ContDiffWithinAt.ccosh /-
 theorem ContDiffWithinAt.ccosh {n} (hf : ContDiffWithinAt ℂ n f s x) :
     ContDiffWithinAt ℂ n (fun x => Complex.cosh (f x)) s x :=
   Complex.contDiff_cosh.ContDiffAt.comp_contDiffWithinAt x hf
 #align cont_diff_within_at.ccosh ContDiffWithinAt.ccosh
+-/
 
 /-! #### `complex.sinh` -/
 
 
+#print HasStrictFDerivAt.csinh /-
 theorem HasStrictFDerivAt.csinh (hf : HasStrictFDerivAt f f' x) :
     HasStrictFDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x :=
   (Complex.hasStrictDerivAt_sinh (f x)).comp_hasStrictFDerivAt x hf
 #align has_strict_fderiv_at.csinh HasStrictFDerivAt.csinh
+-/
 
+#print HasFDerivAt.csinh /-
 theorem HasFDerivAt.csinh (hf : HasFDerivAt f f' x) :
     HasFDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x :=
   (Complex.hasDerivAt_sinh (f x)).comp_hasFDerivAt x hf
 #align has_fderiv_at.csinh HasFDerivAt.csinh
+-/
 
+#print HasFDerivWithinAt.csinh /-
 theorem HasFDerivWithinAt.csinh (hf : HasFDerivWithinAt f f' s x) :
     HasFDerivWithinAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') s x :=
   (Complex.hasDerivAt_sinh (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.csinh HasFDerivWithinAt.csinh
+-/
 
+#print DifferentiableWithinAt.csinh /-
 theorem DifferentiableWithinAt.csinh (hf : DifferentiableWithinAt ℂ f s x) :
     DifferentiableWithinAt ℂ (fun x => Complex.sinh (f x)) s x :=
   hf.HasFDerivWithinAt.csinh.DifferentiableWithinAt
 #align differentiable_within_at.csinh DifferentiableWithinAt.csinh
+-/
 
+#print DifferentiableAt.csinh /-
 @[simp]
 theorem DifferentiableAt.csinh (hc : DifferentiableAt ℂ f x) :
     DifferentiableAt ℂ (fun x => Complex.sinh (f x)) x :=
   hc.HasFDerivAt.csinh.DifferentiableAt
 #align differentiable_at.csinh DifferentiableAt.csinh
+-/
 
+#print DifferentiableOn.csinh /-
 theorem DifferentiableOn.csinh (hc : DifferentiableOn ℂ f s) :
     DifferentiableOn ℂ (fun x => Complex.sinh (f x)) s := fun x h => (hc x h).csinh
 #align differentiable_on.csinh DifferentiableOn.csinh
+-/
 
+#print Differentiable.csinh /-
 @[simp]
 theorem Differentiable.csinh (hc : Differentiable ℂ f) :
     Differentiable ℂ fun x => Complex.sinh (f x) := fun x => (hc x).csinh
 #align differentiable.csinh Differentiable.csinh
+-/
 
+#print fderivWithin_csinh /-
 theorem fderivWithin_csinh (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     fderivWithin ℂ (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) • fderivWithin ℂ f s x :=
   hf.HasFDerivWithinAt.csinh.fderivWithin hxs
 #align fderiv_within_csinh fderivWithin_csinh
+-/
 
+#print fderiv_csinh /-
 @[simp]
 theorem fderiv_csinh (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.sinh (f x)) x = Complex.cosh (f x) • fderiv ℂ f x :=
   hc.HasFDerivAt.csinh.fderiv
 #align fderiv_csinh fderiv_csinh
+-/
 
+#print ContDiff.csinh /-
 theorem ContDiff.csinh {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.sinh (f x) :=
   Complex.contDiff_sinh.comp h
 #align cont_diff.csinh ContDiff.csinh
+-/
 
+#print ContDiffAt.csinh /-
 theorem ContDiffAt.csinh {n} (hf : ContDiffAt ℂ n f x) :
     ContDiffAt ℂ n (fun x => Complex.sinh (f x)) x :=
   Complex.contDiff_sinh.ContDiffAt.comp x hf
 #align cont_diff_at.csinh ContDiffAt.csinh
+-/
 
+#print ContDiffOn.csinh /-
 theorem ContDiffOn.csinh {n} (hf : ContDiffOn ℂ n f s) :
     ContDiffOn ℂ n (fun x => Complex.sinh (f x)) s :=
   Complex.contDiff_sinh.comp_contDiffOn hf
 #align cont_diff_on.csinh ContDiffOn.csinh
+-/
 
+#print ContDiffWithinAt.csinh /-
 theorem ContDiffWithinAt.csinh {n} (hf : ContDiffWithinAt ℂ n f s x) :
     ContDiffWithinAt ℂ n (fun x => Complex.sinh (f x)) s x :=
   Complex.contDiff_sinh.ContDiffAt.comp_contDiffWithinAt x hf
 #align cont_diff_within_at.csinh ContDiffWithinAt.csinh
+-/
 
 end
 
@@ -623,13 +817,17 @@ theorem deriv_sin : deriv sin = cos :=
 #align real.deriv_sin Real.deriv_sin
 -/
 
+#print Real.hasStrictDerivAt_cos /-
 theorem hasStrictDerivAt_cos (x : ℝ) : HasStrictDerivAt cos (-sin x) x :=
   (Complex.hasStrictDerivAt_cos x).real_of_complex
 #align real.has_strict_deriv_at_cos Real.hasStrictDerivAt_cos
+-/
 
+#print Real.hasDerivAt_cos /-
 theorem hasDerivAt_cos (x : ℝ) : HasDerivAt cos (-sin x) x :=
   (Complex.hasDerivAt_cos x).real_of_complex
 #align real.has_deriv_at_cos Real.hasDerivAt_cos
+-/
 
 #print Real.contDiff_cos /-
 theorem contDiff_cos {n} : ContDiff ℝ n cos :=
@@ -648,14 +846,18 @@ theorem differentiableAt_cos : DifferentiableAt ℝ cos x :=
 #align real.differentiable_at_cos Real.differentiableAt_cos
 -/
 
+#print Real.deriv_cos /-
 theorem deriv_cos : deriv cos x = -sin x :=
   (hasDerivAt_cos x).deriv
 #align real.deriv_cos Real.deriv_cos
+-/
 
+#print Real.deriv_cos' /-
 @[simp]
 theorem deriv_cos' : deriv cos = fun x => -sin x :=
   funext fun _ => deriv_cos
 #align real.deriv_cos' Real.deriv_cos'
+-/
 
 #print Real.hasStrictDerivAt_sinh /-
 theorem hasStrictDerivAt_sinh (x : ℝ) : HasStrictDerivAt sinh (cosh x) x :=
@@ -750,61 +952,86 @@ theorem sinh_inj : sinh x = sinh y ↔ x = y :=
 #align real.sinh_inj Real.sinh_inj
 -/
 
+#print Real.sinh_le_sinh /-
 @[simp]
 theorem sinh_le_sinh : sinh x ≤ sinh y ↔ x ≤ y :=
   sinh_strictMono.le_iff_le
 #align real.sinh_le_sinh Real.sinh_le_sinh
+-/
 
+#print Real.sinh_lt_sinh /-
 @[simp]
 theorem sinh_lt_sinh : sinh x < sinh y ↔ x < y :=
   sinh_strictMono.lt_iff_lt
 #align real.sinh_lt_sinh Real.sinh_lt_sinh
+-/
 
+#print Real.sinh_pos_iff /-
 @[simp]
 theorem sinh_pos_iff : 0 < sinh x ↔ 0 < x := by simpa only [sinh_zero] using @sinh_lt_sinh 0 x
 #align real.sinh_pos_iff Real.sinh_pos_iff
+-/
 
+#print Real.sinh_nonpos_iff /-
 @[simp]
 theorem sinh_nonpos_iff : sinh x ≤ 0 ↔ x ≤ 0 := by simpa only [sinh_zero] using @sinh_le_sinh x 0
 #align real.sinh_nonpos_iff Real.sinh_nonpos_iff
+-/
 
+#print Real.sinh_neg_iff /-
 @[simp]
 theorem sinh_neg_iff : sinh x < 0 ↔ x < 0 := by simpa only [sinh_zero] using @sinh_lt_sinh x 0
 #align real.sinh_neg_iff Real.sinh_neg_iff
+-/
 
+#print Real.sinh_nonneg_iff /-
 @[simp]
 theorem sinh_nonneg_iff : 0 ≤ sinh x ↔ 0 ≤ x := by simpa only [sinh_zero] using @sinh_le_sinh 0 x
 #align real.sinh_nonneg_iff Real.sinh_nonneg_iff
+-/
 
+#print Real.abs_sinh /-
 theorem abs_sinh (x : ℝ) : |sinh x| = sinh (|x|) := by
   cases le_total x 0 <;> simp [abs_of_nonneg, abs_of_nonpos, *]
 #align real.abs_sinh Real.abs_sinh
+-/
 
+#print Real.cosh_strictMonoOn /-
 theorem cosh_strictMonoOn : StrictMonoOn cosh (Ici 0) :=
   (convex_Ici _).strictMonoOn_of_deriv_pos continuous_cosh.ContinuousOn fun x hx => by
     rw [interior_Ici, mem_Ioi] at hx ; rwa [deriv_cosh, sinh_pos_iff]
 #align real.cosh_strict_mono_on Real.cosh_strictMonoOn
+-/
 
+#print Real.cosh_le_cosh /-
 @[simp]
 theorem cosh_le_cosh : cosh x ≤ cosh y ↔ |x| ≤ |y| :=
   cosh_abs x ▸ cosh_abs y ▸ cosh_strictMonoOn.le_iff_le (abs_nonneg x) (abs_nonneg y)
 #align real.cosh_le_cosh Real.cosh_le_cosh
+-/
 
+#print Real.cosh_lt_cosh /-
 @[simp]
 theorem cosh_lt_cosh : cosh x < cosh y ↔ |x| < |y| :=
   lt_iff_lt_of_le_iff_le cosh_le_cosh
 #align real.cosh_lt_cosh Real.cosh_lt_cosh
+-/
 
+#print Real.one_le_cosh /-
 @[simp]
 theorem one_le_cosh (x : ℝ) : 1 ≤ cosh x :=
   cosh_zero ▸ cosh_le_cosh.2 (by simp only [_root_.abs_zero, _root_.abs_nonneg])
 #align real.one_le_cosh Real.one_le_cosh
+-/
 
+#print Real.one_lt_cosh /-
 @[simp]
 theorem one_lt_cosh : 1 < cosh x ↔ x ≠ 0 :=
   cosh_zero ▸ cosh_lt_cosh.trans (by simp only [_root_.abs_zero, abs_pos])
 #align real.one_lt_cosh Real.one_lt_cosh
+-/
 
+#print Real.sinh_sub_id_strictMono /-
 theorem sinh_sub_id_strictMono : StrictMono fun x => sinh x - x :=
   by
   refine' strictMono_of_odd_strictMonoOn_nonneg (fun x => by simp) _
@@ -814,30 +1041,39 @@ theorem sinh_sub_id_strictMono : StrictMono fun x => sinh x - x :=
     rw [deriv_sub, deriv_sinh, deriv_id'', sub_pos, one_lt_cosh]
     exacts [hx.ne', differentiable_at_sinh, differentiableAt_id]
 #align real.sinh_sub_id_strict_mono Real.sinh_sub_id_strictMono
+-/
 
+#print Real.self_le_sinh_iff /-
 @[simp]
 theorem self_le_sinh_iff : x ≤ sinh x ↔ 0 ≤ x :=
   calc
     x ≤ sinh x ↔ sinh 0 - 0 ≤ sinh x - x := by simp
     _ ↔ 0 ≤ x := sinh_sub_id_strictMono.le_iff_le
 #align real.self_le_sinh_iff Real.self_le_sinh_iff
+-/
 
+#print Real.sinh_le_self_iff /-
 @[simp]
 theorem sinh_le_self_iff : sinh x ≤ x ↔ x ≤ 0 :=
   calc
     sinh x ≤ x ↔ sinh x - x ≤ sinh 0 - 0 := by simp
     _ ↔ x ≤ 0 := sinh_sub_id_strictMono.le_iff_le
 #align real.sinh_le_self_iff Real.sinh_le_self_iff
+-/
 
+#print Real.self_lt_sinh_iff /-
 @[simp]
 theorem self_lt_sinh_iff : x < sinh x ↔ 0 < x :=
   lt_iff_lt_of_le_iff_le sinh_le_self_iff
 #align real.self_lt_sinh_iff Real.self_lt_sinh_iff
+-/
 
+#print Real.sinh_lt_self_iff /-
 @[simp]
 theorem sinh_lt_self_iff : sinh x < x ↔ x < 0 :=
   lt_iff_lt_of_le_iff_le self_le_sinh_iff
 #align real.sinh_lt_self_iff Real.sinh_lt_self_iff
+-/
 
 end Real
 
@@ -851,118 +1087,158 @@ variable {f : ℝ → ℝ} {f' x : ℝ} {s : Set ℝ}
 /-! #### `real.cos` -/
 
 
+#print HasStrictDerivAt.cos /-
 theorem HasStrictDerivAt.cos (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') x :=
   (Real.hasStrictDerivAt_cos (f x)).comp x hf
 #align has_strict_deriv_at.cos HasStrictDerivAt.cos
+-/
 
+#print HasDerivAt.cos /-
 theorem HasDerivAt.cos (hf : HasDerivAt f f' x) :
     HasDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') x :=
   (Real.hasDerivAt_cos (f x)).comp x hf
 #align has_deriv_at.cos HasDerivAt.cos
+-/
 
+#print HasDerivWithinAt.cos /-
 theorem HasDerivWithinAt.cos (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') s x :=
   (Real.hasDerivAt_cos (f x)).comp_hasDerivWithinAt x hf
 #align has_deriv_within_at.cos HasDerivWithinAt.cos
+-/
 
+#print derivWithin_cos /-
 theorem derivWithin_cos (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     derivWithin (fun x => Real.cos (f x)) s x = -Real.sin (f x) * derivWithin f s x :=
   hf.HasDerivWithinAt.cos.derivWithin hxs
 #align deriv_within_cos derivWithin_cos
+-/
 
+#print deriv_cos /-
 @[simp]
 theorem deriv_cos (hc : DifferentiableAt ℝ f x) :
     deriv (fun x => Real.cos (f x)) x = -Real.sin (f x) * deriv f x :=
   hc.HasDerivAt.cos.deriv
 #align deriv_cos deriv_cos
+-/
 
 /-! #### `real.sin` -/
 
 
+#print HasStrictDerivAt.sin /-
 theorem HasStrictDerivAt.sin (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') x :=
   (Real.hasStrictDerivAt_sin (f x)).comp x hf
 #align has_strict_deriv_at.sin HasStrictDerivAt.sin
+-/
 
+#print HasDerivAt.sin /-
 theorem HasDerivAt.sin (hf : HasDerivAt f f' x) :
     HasDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') x :=
   (Real.hasDerivAt_sin (f x)).comp x hf
 #align has_deriv_at.sin HasDerivAt.sin
+-/
 
+#print HasDerivWithinAt.sin /-
 theorem HasDerivWithinAt.sin (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') s x :=
   (Real.hasDerivAt_sin (f x)).comp_hasDerivWithinAt x hf
 #align has_deriv_within_at.sin HasDerivWithinAt.sin
+-/
 
+#print derivWithin_sin /-
 theorem derivWithin_sin (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     derivWithin (fun x => Real.sin (f x)) s x = Real.cos (f x) * derivWithin f s x :=
   hf.HasDerivWithinAt.sin.derivWithin hxs
 #align deriv_within_sin derivWithin_sin
+-/
 
+#print deriv_sin /-
 @[simp]
 theorem deriv_sin (hc : DifferentiableAt ℝ f x) :
     deriv (fun x => Real.sin (f x)) x = Real.cos (f x) * deriv f x :=
   hc.HasDerivAt.sin.deriv
 #align deriv_sin deriv_sin
+-/
 
 /-! #### `real.cosh` -/
 
 
+#print HasStrictDerivAt.cosh /-
 theorem HasStrictDerivAt.cosh (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') x :=
   (Real.hasStrictDerivAt_cosh (f x)).comp x hf
 #align has_strict_deriv_at.cosh HasStrictDerivAt.cosh
+-/
 
+#print HasDerivAt.cosh /-
 theorem HasDerivAt.cosh (hf : HasDerivAt f f' x) :
     HasDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') x :=
   (Real.hasDerivAt_cosh (f x)).comp x hf
 #align has_deriv_at.cosh HasDerivAt.cosh
+-/
 
+#print HasDerivWithinAt.cosh /-
 theorem HasDerivWithinAt.cosh (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') s x :=
   (Real.hasDerivAt_cosh (f x)).comp_hasDerivWithinAt x hf
 #align has_deriv_within_at.cosh HasDerivWithinAt.cosh
+-/
 
+#print derivWithin_cosh /-
 theorem derivWithin_cosh (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     derivWithin (fun x => Real.cosh (f x)) s x = Real.sinh (f x) * derivWithin f s x :=
   hf.HasDerivWithinAt.cosh.derivWithin hxs
 #align deriv_within_cosh derivWithin_cosh
+-/
 
+#print deriv_cosh /-
 @[simp]
 theorem deriv_cosh (hc : DifferentiableAt ℝ f x) :
     deriv (fun x => Real.cosh (f x)) x = Real.sinh (f x) * deriv f x :=
   hc.HasDerivAt.cosh.deriv
 #align deriv_cosh deriv_cosh
+-/
 
 /-! #### `real.sinh` -/
 
 
+#print HasStrictDerivAt.sinh /-
 theorem HasStrictDerivAt.sinh (hf : HasStrictDerivAt f f' x) :
     HasStrictDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x :=
   (Real.hasStrictDerivAt_sinh (f x)).comp x hf
 #align has_strict_deriv_at.sinh HasStrictDerivAt.sinh
+-/
 
+#print HasDerivAt.sinh /-
 theorem HasDerivAt.sinh (hf : HasDerivAt f f' x) :
     HasDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x :=
   (Real.hasDerivAt_sinh (f x)).comp x hf
 #align has_deriv_at.sinh HasDerivAt.sinh
+-/
 
+#print HasDerivWithinAt.sinh /-
 theorem HasDerivWithinAt.sinh (hf : HasDerivWithinAt f f' s x) :
     HasDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') s x :=
   (Real.hasDerivAt_sinh (f x)).comp_hasDerivWithinAt x hf
 #align has_deriv_within_at.sinh HasDerivWithinAt.sinh
+-/
 
+#print derivWithin_sinh /-
 theorem derivWithin_sinh (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     derivWithin (fun x => Real.sinh (f x)) s x = Real.cosh (f x) * derivWithin f s x :=
   hf.HasDerivWithinAt.sinh.derivWithin hxs
 #align deriv_within_sinh derivWithin_sinh
+-/
 
+#print deriv_sinh /-
 @[simp]
 theorem deriv_sinh (hc : DifferentiableAt ℝ f x) :
     deriv (fun x => Real.sinh (f x)) x = Real.cosh (f x) * deriv f x :=
   hc.HasDerivAt.sinh.deriv
 #align deriv_sinh deriv_sinh
+-/
 
 end
 
@@ -977,20 +1253,26 @@ variable {E : Type _} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ}
 /-! #### `real.cos` -/
 
 
+#print HasStrictFDerivAt.cos /-
 theorem HasStrictFDerivAt.cos (hf : HasStrictFDerivAt f f' x) :
     HasStrictFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x :=
   (Real.hasStrictDerivAt_cos (f x)).comp_hasStrictFDerivAt x hf
 #align has_strict_fderiv_at.cos HasStrictFDerivAt.cos
+-/
 
+#print HasFDerivAt.cos /-
 theorem HasFDerivAt.cos (hf : HasFDerivAt f f' x) :
     HasFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x :=
   (Real.hasDerivAt_cos (f x)).comp_hasFDerivAt x hf
 #align has_fderiv_at.cos HasFDerivAt.cos
+-/
 
+#print HasFDerivWithinAt.cos /-
 theorem HasFDerivWithinAt.cos (hf : HasFDerivWithinAt f f' s x) :
     HasFDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') s x :=
   (Real.hasDerivAt_cos (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.cos HasFDerivWithinAt.cos
+-/
 
 #print DifferentiableWithinAt.cos /-
 theorem DifferentiableWithinAt.cos (hf : DifferentiableWithinAt ℝ f s x) :
@@ -1020,16 +1302,20 @@ theorem Differentiable.cos (hc : Differentiable ℝ f) : Differentiable ℝ fun
 #align differentiable.cos Differentiable.cos
 -/
 
+#print fderivWithin_cos /-
 theorem fderivWithin_cos (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.cos (f x)) s x = -Real.sin (f x) • fderivWithin ℝ f s x :=
   hf.HasFDerivWithinAt.cos.fderivWithin hxs
 #align fderiv_within_cos fderivWithin_cos
+-/
 
+#print fderiv_cos /-
 @[simp]
 theorem fderiv_cos (hc : DifferentiableAt ℝ f x) :
     fderiv ℝ (fun x => Real.cos (f x)) x = -Real.sin (f x) • fderiv ℝ f x :=
   hc.HasFDerivAt.cos.fderiv
 #align fderiv_cos fderiv_cos
+-/
 
 #print ContDiff.cos /-
 theorem ContDiff.cos {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.cos (f x) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -820,7 +820,6 @@ theorem self_le_sinh_iff : x ≤ sinh x ↔ 0 ≤ x :=
   calc
     x ≤ sinh x ↔ sinh 0 - 0 ≤ sinh x - x := by simp
     _ ↔ 0 ≤ x := sinh_sub_id_strictMono.le_iff_le
-    
 #align real.self_le_sinh_iff Real.self_le_sinh_iff
 
 @[simp]
@@ -828,7 +827,6 @@ theorem sinh_le_self_iff : sinh x ≤ x ↔ x ≤ 0 :=
   calc
     sinh x ≤ x ↔ sinh x - x ≤ sinh 0 - 0 := by simp
     _ ↔ x ≤ 0 := sinh_sub_id_strictMono.le_iff_le
-    
 #align real.sinh_le_self_iff Real.sinh_le_self_iff
 
 @[simp]

mathlib commit https://github.com/leanprover-community/mathlib/commit/58a272265b5e05f258161260dd2c5d247213cbd3

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Abhimanyu Pallavi Sudhir, Jean Lo, Calle Sönne, Benjamin Davidson
 
 ! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.deriv
-! leanprover-community/mathlib commit 2c1d8ca2812b64f88992a5294ea3dba144755cd1
+! leanprover-community/mathlib commit 36938f775671ff28bea1c0310f1608e4afbb22e0
 ! 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.SpecialFunctions.Trigonometric.Basic
 /-!
 # Differentiability of trigonometric functions
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 ## Main statements
 
 The differentiability of the usual trigonometric functions is proved, and their derivatives are

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

@@ -114,7 +114,7 @@ theorem deriv_cos' : deriv cos = fun x => -sin x :=
 theorem hasStrictDerivAt_sinh (x : ℂ) : HasStrictDerivAt sinh (cosh x) x :=
   by
   simp only [cosh, div_eq_mul_inv]
-  convert ((has_strict_deriv_at_exp x).sub (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
+  convert ((hasStrictDerivAt_exp x).sub (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
   rw [id, mul_neg_one, sub_eq_add_neg, neg_neg]
 #align complex.has_strict_deriv_at_sinh Complex.hasStrictDerivAt_sinh
 
@@ -145,7 +145,7 @@ derivative `sinh x`. -/
 theorem hasStrictDerivAt_cosh (x : ℂ) : HasStrictDerivAt cosh (sinh x) x :=
   by
   simp only [sinh, div_eq_mul_inv]
-  convert ((has_strict_deriv_at_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
+  convert ((hasStrictDerivAt_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
   rw [id, mul_neg_one, sub_eq_add_neg]
 #align complex.has_strict_deriv_at_cosh Complex.hasStrictDerivAt_cosh
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/13361559d66b84f80b6d5a1c4a26aa5054766725

@@ -584,29 +584,41 @@ namespace Real
 
 variable {x y z : ℝ}
 
+#print Real.hasStrictDerivAt_sin /-
 theorem hasStrictDerivAt_sin (x : ℝ) : HasStrictDerivAt sin (cos x) x :=
   (Complex.hasStrictDerivAt_sin x).real_of_complex
 #align real.has_strict_deriv_at_sin Real.hasStrictDerivAt_sin
+-/
 
+#print Real.hasDerivAt_sin /-
 theorem hasDerivAt_sin (x : ℝ) : HasDerivAt sin (cos x) x :=
   (hasStrictDerivAt_sin x).HasDerivAt
 #align real.has_deriv_at_sin Real.hasDerivAt_sin
+-/
 
+#print Real.contDiff_sin /-
 theorem contDiff_sin {n} : ContDiff ℝ n sin :=
   Complex.contDiff_sin.real_of_complex
 #align real.cont_diff_sin Real.contDiff_sin
+-/
 
+#print Real.differentiable_sin /-
 theorem differentiable_sin : Differentiable ℝ sin := fun x => (hasDerivAt_sin x).DifferentiableAt
 #align real.differentiable_sin Real.differentiable_sin
+-/
 
+#print Real.differentiableAt_sin /-
 theorem differentiableAt_sin : DifferentiableAt ℝ sin x :=
   differentiable_sin x
 #align real.differentiable_at_sin Real.differentiableAt_sin
+-/
 
+#print Real.deriv_sin /-
 @[simp]
 theorem deriv_sin : deriv sin = cos :=
   funext fun x => (hasDerivAt_sin x).deriv
 #align real.deriv_sin Real.deriv_sin
+-/
 
 theorem hasStrictDerivAt_cos (x : ℝ) : HasStrictDerivAt cos (-sin x) x :=
   (Complex.hasStrictDerivAt_cos x).real_of_complex
@@ -616,16 +628,22 @@ theorem hasDerivAt_cos (x : ℝ) : HasDerivAt cos (-sin x) x :=
   (Complex.hasDerivAt_cos x).real_of_complex
 #align real.has_deriv_at_cos Real.hasDerivAt_cos
 
+#print Real.contDiff_cos /-
 theorem contDiff_cos {n} : ContDiff ℝ n cos :=
   Complex.contDiff_cos.real_of_complex
 #align real.cont_diff_cos Real.contDiff_cos
+-/
 
+#print Real.differentiable_cos /-
 theorem differentiable_cos : Differentiable ℝ cos := fun x => (hasDerivAt_cos x).DifferentiableAt
 #align real.differentiable_cos Real.differentiable_cos
+-/
 
+#print Real.differentiableAt_cos /-
 theorem differentiableAt_cos : DifferentiableAt ℝ cos x :=
   differentiable_cos x
 #align real.differentiable_at_cos Real.differentiableAt_cos
+-/
 
 theorem deriv_cos : deriv cos x = -sin x :=
   (hasDerivAt_cos x).deriv
@@ -636,68 +654,98 @@ theorem deriv_cos' : deriv cos = fun x => -sin x :=
   funext fun _ => deriv_cos
 #align real.deriv_cos' Real.deriv_cos'
 
+#print Real.hasStrictDerivAt_sinh /-
 theorem hasStrictDerivAt_sinh (x : ℝ) : HasStrictDerivAt sinh (cosh x) x :=
   (Complex.hasStrictDerivAt_sinh x).real_of_complex
 #align real.has_strict_deriv_at_sinh Real.hasStrictDerivAt_sinh
+-/
 
+#print Real.hasDerivAt_sinh /-
 theorem hasDerivAt_sinh (x : ℝ) : HasDerivAt sinh (cosh x) x :=
   (Complex.hasDerivAt_sinh x).real_of_complex
 #align real.has_deriv_at_sinh Real.hasDerivAt_sinh
+-/
 
+#print Real.contDiff_sinh /-
 theorem contDiff_sinh {n} : ContDiff ℝ n sinh :=
   Complex.contDiff_sinh.real_of_complex
 #align real.cont_diff_sinh Real.contDiff_sinh
+-/
 
+#print Real.differentiable_sinh /-
 theorem differentiable_sinh : Differentiable ℝ sinh := fun x => (hasDerivAt_sinh x).DifferentiableAt
 #align real.differentiable_sinh Real.differentiable_sinh
+-/
 
+#print Real.differentiableAt_sinh /-
 theorem differentiableAt_sinh : DifferentiableAt ℝ sinh x :=
   differentiable_sinh x
 #align real.differentiable_at_sinh Real.differentiableAt_sinh
+-/
 
+#print Real.deriv_sinh /-
 @[simp]
 theorem deriv_sinh : deriv sinh = cosh :=
   funext fun x => (hasDerivAt_sinh x).deriv
 #align real.deriv_sinh Real.deriv_sinh
+-/
 
+#print Real.hasStrictDerivAt_cosh /-
 theorem hasStrictDerivAt_cosh (x : ℝ) : HasStrictDerivAt cosh (sinh x) x :=
   (Complex.hasStrictDerivAt_cosh x).real_of_complex
 #align real.has_strict_deriv_at_cosh Real.hasStrictDerivAt_cosh
+-/
 
+#print Real.hasDerivAt_cosh /-
 theorem hasDerivAt_cosh (x : ℝ) : HasDerivAt cosh (sinh x) x :=
   (Complex.hasDerivAt_cosh x).real_of_complex
 #align real.has_deriv_at_cosh Real.hasDerivAt_cosh
+-/
 
+#print Real.contDiff_cosh /-
 theorem contDiff_cosh {n} : ContDiff ℝ n cosh :=
   Complex.contDiff_cosh.real_of_complex
 #align real.cont_diff_cosh Real.contDiff_cosh
+-/
 
+#print Real.differentiable_cosh /-
 theorem differentiable_cosh : Differentiable ℝ cosh := fun x => (hasDerivAt_cosh x).DifferentiableAt
 #align real.differentiable_cosh Real.differentiable_cosh
+-/
 
+#print Real.differentiableAt_cosh /-
 theorem differentiableAt_cosh : DifferentiableAt ℝ cosh x :=
   differentiable_cosh x
 #align real.differentiable_at_cosh Real.differentiableAt_cosh
+-/
 
+#print Real.deriv_cosh /-
 @[simp]
 theorem deriv_cosh : deriv cosh = sinh :=
   funext fun x => (hasDerivAt_cosh x).deriv
 #align real.deriv_cosh Real.deriv_cosh
+-/
 
+#print Real.sinh_strictMono /-
 /-- `sinh` is strictly monotone. -/
 theorem sinh_strictMono : StrictMono sinh :=
   strictMono_of_deriv_pos <| by rw [Real.deriv_sinh]; exact cosh_pos
 #align real.sinh_strict_mono Real.sinh_strictMono
+-/
 
+#print Real.sinh_injective /-
 /-- `sinh` is injective, `∀ a b, sinh a = sinh b → a = b`. -/
 theorem sinh_injective : Function.Injective sinh :=
   sinh_strictMono.Injective
 #align real.sinh_injective Real.sinh_injective
+-/
 
+#print Real.sinh_inj /-
 @[simp]
 theorem sinh_inj : sinh x = sinh y ↔ x = y :=
   sinh_injective.eq_iff
 #align real.sinh_inj Real.sinh_inj
+-/
 
 @[simp]
 theorem sinh_le_sinh : sinh x ≤ sinh y ↔ x ≤ y :=
@@ -943,25 +991,33 @@ theorem HasFDerivWithinAt.cos (hf : HasFDerivWithinAt f f' s x) :
   (Real.hasDerivAt_cos (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.cos HasFDerivWithinAt.cos
 
+#print DifferentiableWithinAt.cos /-
 theorem DifferentiableWithinAt.cos (hf : DifferentiableWithinAt ℝ f s x) :
     DifferentiableWithinAt ℝ (fun x => Real.cos (f x)) s x :=
   hf.HasFDerivWithinAt.cos.DifferentiableWithinAt
 #align differentiable_within_at.cos DifferentiableWithinAt.cos
+-/
 
+#print DifferentiableAt.cos /-
 @[simp]
 theorem DifferentiableAt.cos (hc : DifferentiableAt ℝ f x) :
     DifferentiableAt ℝ (fun x => Real.cos (f x)) x :=
   hc.HasFDerivAt.cos.DifferentiableAt
 #align differentiable_at.cos DifferentiableAt.cos
+-/
 
+#print DifferentiableOn.cos /-
 theorem DifferentiableOn.cos (hc : DifferentiableOn ℝ f s) :
     DifferentiableOn ℝ (fun x => Real.cos (f x)) s := fun x h => (hc x h).cos
 #align differentiable_on.cos DifferentiableOn.cos
+-/
 
+#print Differentiable.cos /-
 @[simp]
 theorem Differentiable.cos (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.cos (f x) :=
   fun x => (hc x).cos
 #align differentiable.cos Differentiable.cos
+-/
 
 theorem fderivWithin_cos (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.cos (f x)) s x = -Real.sin (f x) • fderivWithin ℝ f s x :=
@@ -974,224 +1030,310 @@ theorem fderiv_cos (hc : DifferentiableAt ℝ f x) :
   hc.HasFDerivAt.cos.fderiv
 #align fderiv_cos fderiv_cos
 
+#print ContDiff.cos /-
 theorem ContDiff.cos {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.cos (f x) :=
   Real.contDiff_cos.comp h
 #align cont_diff.cos ContDiff.cos
+-/
 
+#print ContDiffAt.cos /-
 theorem ContDiffAt.cos {n} (hf : ContDiffAt ℝ n f x) : ContDiffAt ℝ n (fun x => Real.cos (f x)) x :=
   Real.contDiff_cos.ContDiffAt.comp x hf
 #align cont_diff_at.cos ContDiffAt.cos
+-/
 
+#print ContDiffOn.cos /-
 theorem ContDiffOn.cos {n} (hf : ContDiffOn ℝ n f s) : ContDiffOn ℝ n (fun x => Real.cos (f x)) s :=
   Real.contDiff_cos.comp_contDiffOn hf
 #align cont_diff_on.cos ContDiffOn.cos
+-/
 
+#print ContDiffWithinAt.cos /-
 theorem ContDiffWithinAt.cos {n} (hf : ContDiffWithinAt ℝ n f s x) :
     ContDiffWithinAt ℝ n (fun x => Real.cos (f x)) s x :=
   Real.contDiff_cos.ContDiffAt.comp_contDiffWithinAt x hf
 #align cont_diff_within_at.cos ContDiffWithinAt.cos
+-/
 
 /-! #### `real.sin` -/
 
 
+#print HasStrictFDerivAt.sin /-
 theorem HasStrictFDerivAt.sin (hf : HasStrictFDerivAt f f' x) :
     HasStrictFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x :=
   (Real.hasStrictDerivAt_sin (f x)).comp_hasStrictFDerivAt x hf
 #align has_strict_fderiv_at.sin HasStrictFDerivAt.sin
+-/
 
+#print HasFDerivAt.sin /-
 theorem HasFDerivAt.sin (hf : HasFDerivAt f f' x) :
     HasFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x :=
   (Real.hasDerivAt_sin (f x)).comp_hasFDerivAt x hf
 #align has_fderiv_at.sin HasFDerivAt.sin
+-/
 
+#print HasFDerivWithinAt.sin /-
 theorem HasFDerivWithinAt.sin (hf : HasFDerivWithinAt f f' s x) :
     HasFDerivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') s x :=
   (Real.hasDerivAt_sin (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.sin HasFDerivWithinAt.sin
+-/
 
+#print DifferentiableWithinAt.sin /-
 theorem DifferentiableWithinAt.sin (hf : DifferentiableWithinAt ℝ f s x) :
     DifferentiableWithinAt ℝ (fun x => Real.sin (f x)) s x :=
   hf.HasFDerivWithinAt.sin.DifferentiableWithinAt
 #align differentiable_within_at.sin DifferentiableWithinAt.sin
+-/
 
+#print DifferentiableAt.sin /-
 @[simp]
 theorem DifferentiableAt.sin (hc : DifferentiableAt ℝ f x) :
     DifferentiableAt ℝ (fun x => Real.sin (f x)) x :=
   hc.HasFDerivAt.sin.DifferentiableAt
 #align differentiable_at.sin DifferentiableAt.sin
+-/
 
+#print DifferentiableOn.sin /-
 theorem DifferentiableOn.sin (hc : DifferentiableOn ℝ f s) :
     DifferentiableOn ℝ (fun x => Real.sin (f x)) s := fun x h => (hc x h).sin
 #align differentiable_on.sin DifferentiableOn.sin
+-/
 
+#print Differentiable.sin /-
 @[simp]
 theorem Differentiable.sin (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.sin (f x) :=
   fun x => (hc x).sin
 #align differentiable.sin Differentiable.sin
+-/
 
+#print fderivWithin_sin /-
 theorem fderivWithin_sin (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.sin (f x)) s x = Real.cos (f x) • fderivWithin ℝ f s x :=
   hf.HasFDerivWithinAt.sin.fderivWithin hxs
 #align fderiv_within_sin fderivWithin_sin
+-/
 
+#print fderiv_sin /-
 @[simp]
 theorem fderiv_sin (hc : DifferentiableAt ℝ f x) :
     fderiv ℝ (fun x => Real.sin (f x)) x = Real.cos (f x) • fderiv ℝ f x :=
   hc.HasFDerivAt.sin.fderiv
 #align fderiv_sin fderiv_sin
+-/
 
+#print ContDiff.sin /-
 theorem ContDiff.sin {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.sin (f x) :=
   Real.contDiff_sin.comp h
 #align cont_diff.sin ContDiff.sin
+-/
 
+#print ContDiffAt.sin /-
 theorem ContDiffAt.sin {n} (hf : ContDiffAt ℝ n f x) : ContDiffAt ℝ n (fun x => Real.sin (f x)) x :=
   Real.contDiff_sin.ContDiffAt.comp x hf
 #align cont_diff_at.sin ContDiffAt.sin
+-/
 
+#print ContDiffOn.sin /-
 theorem ContDiffOn.sin {n} (hf : ContDiffOn ℝ n f s) : ContDiffOn ℝ n (fun x => Real.sin (f x)) s :=
   Real.contDiff_sin.comp_contDiffOn hf
 #align cont_diff_on.sin ContDiffOn.sin
+-/
 
+#print ContDiffWithinAt.sin /-
 theorem ContDiffWithinAt.sin {n} (hf : ContDiffWithinAt ℝ n f s x) :
     ContDiffWithinAt ℝ n (fun x => Real.sin (f x)) s x :=
   Real.contDiff_sin.ContDiffAt.comp_contDiffWithinAt x hf
 #align cont_diff_within_at.sin ContDiffWithinAt.sin
+-/
 
 /-! #### `real.cosh` -/
 
 
+#print HasStrictFDerivAt.cosh /-
 theorem HasStrictFDerivAt.cosh (hf : HasStrictFDerivAt f f' x) :
     HasStrictFDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x :=
   (Real.hasStrictDerivAt_cosh (f x)).comp_hasStrictFDerivAt x hf
 #align has_strict_fderiv_at.cosh HasStrictFDerivAt.cosh
+-/
 
+#print HasFDerivAt.cosh /-
 theorem HasFDerivAt.cosh (hf : HasFDerivAt f f' x) :
     HasFDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x :=
   (Real.hasDerivAt_cosh (f x)).comp_hasFDerivAt x hf
 #align has_fderiv_at.cosh HasFDerivAt.cosh
+-/
 
+#print HasFDerivWithinAt.cosh /-
 theorem HasFDerivWithinAt.cosh (hf : HasFDerivWithinAt f f' s x) :
     HasFDerivWithinAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') s x :=
   (Real.hasDerivAt_cosh (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.cosh HasFDerivWithinAt.cosh
+-/
 
+#print DifferentiableWithinAt.cosh /-
 theorem DifferentiableWithinAt.cosh (hf : DifferentiableWithinAt ℝ f s x) :
     DifferentiableWithinAt ℝ (fun x => Real.cosh (f x)) s x :=
   hf.HasFDerivWithinAt.cosh.DifferentiableWithinAt
 #align differentiable_within_at.cosh DifferentiableWithinAt.cosh
+-/
 
+#print DifferentiableAt.cosh /-
 @[simp]
 theorem DifferentiableAt.cosh (hc : DifferentiableAt ℝ f x) :
     DifferentiableAt ℝ (fun x => Real.cosh (f x)) x :=
   hc.HasFDerivAt.cosh.DifferentiableAt
 #align differentiable_at.cosh DifferentiableAt.cosh
+-/
 
+#print DifferentiableOn.cosh /-
 theorem DifferentiableOn.cosh (hc : DifferentiableOn ℝ f s) :
     DifferentiableOn ℝ (fun x => Real.cosh (f x)) s := fun x h => (hc x h).cosh
 #align differentiable_on.cosh DifferentiableOn.cosh
+-/
 
+#print Differentiable.cosh /-
 @[simp]
 theorem Differentiable.cosh (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.cosh (f x) :=
   fun x => (hc x).cosh
 #align differentiable.cosh Differentiable.cosh
+-/
 
+#print fderivWithin_cosh /-
 theorem fderivWithin_cosh (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.cosh (f x)) s x = Real.sinh (f x) • fderivWithin ℝ f s x :=
   hf.HasFDerivWithinAt.cosh.fderivWithin hxs
 #align fderiv_within_cosh fderivWithin_cosh
+-/
 
+#print fderiv_cosh /-
 @[simp]
 theorem fderiv_cosh (hc : DifferentiableAt ℝ f x) :
     fderiv ℝ (fun x => Real.cosh (f x)) x = Real.sinh (f x) • fderiv ℝ f x :=
   hc.HasFDerivAt.cosh.fderiv
 #align fderiv_cosh fderiv_cosh
+-/
 
+#print ContDiff.cosh /-
 theorem ContDiff.cosh {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.cosh (f x) :=
   Real.contDiff_cosh.comp h
 #align cont_diff.cosh ContDiff.cosh
+-/
 
+#print ContDiffAt.cosh /-
 theorem ContDiffAt.cosh {n} (hf : ContDiffAt ℝ n f x) :
     ContDiffAt ℝ n (fun x => Real.cosh (f x)) x :=
   Real.contDiff_cosh.ContDiffAt.comp x hf
 #align cont_diff_at.cosh ContDiffAt.cosh
+-/
 
+#print ContDiffOn.cosh /-
 theorem ContDiffOn.cosh {n} (hf : ContDiffOn ℝ n f s) :
     ContDiffOn ℝ n (fun x => Real.cosh (f x)) s :=
   Real.contDiff_cosh.comp_contDiffOn hf
 #align cont_diff_on.cosh ContDiffOn.cosh
+-/
 
+#print ContDiffWithinAt.cosh /-
 theorem ContDiffWithinAt.cosh {n} (hf : ContDiffWithinAt ℝ n f s x) :
     ContDiffWithinAt ℝ n (fun x => Real.cosh (f x)) s x :=
   Real.contDiff_cosh.ContDiffAt.comp_contDiffWithinAt x hf
 #align cont_diff_within_at.cosh ContDiffWithinAt.cosh
+-/
 
 /-! #### `real.sinh` -/
 
 
+#print HasStrictFDerivAt.sinh /-
 theorem HasStrictFDerivAt.sinh (hf : HasStrictFDerivAt f f' x) :
     HasStrictFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x :=
   (Real.hasStrictDerivAt_sinh (f x)).comp_hasStrictFDerivAt x hf
 #align has_strict_fderiv_at.sinh HasStrictFDerivAt.sinh
+-/
 
+#print HasFDerivAt.sinh /-
 theorem HasFDerivAt.sinh (hf : HasFDerivAt f f' x) :
     HasFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x :=
   (Real.hasDerivAt_sinh (f x)).comp_hasFDerivAt x hf
 #align has_fderiv_at.sinh HasFDerivAt.sinh
+-/
 
+#print HasFDerivWithinAt.sinh /-
 theorem HasFDerivWithinAt.sinh (hf : HasFDerivWithinAt f f' s x) :
     HasFDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') s x :=
   (Real.hasDerivAt_sinh (f x)).comp_hasFDerivWithinAt x hf
 #align has_fderiv_within_at.sinh HasFDerivWithinAt.sinh
+-/
 
+#print DifferentiableWithinAt.sinh /-
 theorem DifferentiableWithinAt.sinh (hf : DifferentiableWithinAt ℝ f s x) :
     DifferentiableWithinAt ℝ (fun x => Real.sinh (f x)) s x :=
   hf.HasFDerivWithinAt.sinh.DifferentiableWithinAt
 #align differentiable_within_at.sinh DifferentiableWithinAt.sinh
+-/
 
+#print DifferentiableAt.sinh /-
 @[simp]
 theorem DifferentiableAt.sinh (hc : DifferentiableAt ℝ f x) :
     DifferentiableAt ℝ (fun x => Real.sinh (f x)) x :=
   hc.HasFDerivAt.sinh.DifferentiableAt
 #align differentiable_at.sinh DifferentiableAt.sinh
+-/
 
+#print DifferentiableOn.sinh /-
 theorem DifferentiableOn.sinh (hc : DifferentiableOn ℝ f s) :
     DifferentiableOn ℝ (fun x => Real.sinh (f x)) s := fun x h => (hc x h).sinh
 #align differentiable_on.sinh DifferentiableOn.sinh
+-/
 
+#print Differentiable.sinh /-
 @[simp]
 theorem Differentiable.sinh (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.sinh (f x) :=
   fun x => (hc x).sinh
 #align differentiable.sinh Differentiable.sinh
+-/
 
+#print fderivWithin_sinh /-
 theorem fderivWithin_sinh (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.sinh (f x)) s x = Real.cosh (f x) • fderivWithin ℝ f s x :=
   hf.HasFDerivWithinAt.sinh.fderivWithin hxs
 #align fderiv_within_sinh fderivWithin_sinh
+-/
 
+#print fderiv_sinh /-
 @[simp]
 theorem fderiv_sinh (hc : DifferentiableAt ℝ f x) :
     fderiv ℝ (fun x => Real.sinh (f x)) x = Real.cosh (f x) • fderiv ℝ f x :=
   hc.HasFDerivAt.sinh.fderiv
 #align fderiv_sinh fderiv_sinh
+-/
 
+#print ContDiff.sinh /-
 theorem ContDiff.sinh {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.sinh (f x) :=
   Real.contDiff_sinh.comp h
 #align cont_diff.sinh ContDiff.sinh
+-/
 
+#print ContDiffAt.sinh /-
 theorem ContDiffAt.sinh {n} (hf : ContDiffAt ℝ n f x) :
     ContDiffAt ℝ n (fun x => Real.sinh (f x)) x :=
   Real.contDiff_sinh.ContDiffAt.comp x hf
 #align cont_diff_at.sinh ContDiffAt.sinh
+-/
 
+#print ContDiffOn.sinh /-
 theorem ContDiffOn.sinh {n} (hf : ContDiffOn ℝ n f s) :
     ContDiffOn ℝ n (fun x => Real.sinh (f x)) s :=
   Real.contDiff_sinh.comp_contDiffOn hf
 #align cont_diff_on.sinh ContDiffOn.sinh
+-/
 
+#print ContDiffWithinAt.sinh /-
 theorem ContDiffWithinAt.sinh {n} (hf : ContDiffWithinAt ℝ n f s x) :
     ContDiffWithinAt ℝ n (fun x => Real.sinh (f x)) s x :=
   Real.contDiff_sinh.ContDiffAt.comp_contDiffWithinAt x hf
 #align cont_diff_within_at.sinh ContDiffWithinAt.sinh
+-/
 
 end
 

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

@@ -38,7 +38,8 @@ namespace Complex
 theorem hasStrictDerivAt_sin (x : ℂ) : HasStrictDerivAt sin (cos x) x :=
   by
   simp only [cos, div_eq_mul_inv]
-  convert((((hasStrictDerivAt_id x).neg.mul_const I).cexp.sub
+  convert
+    ((((hasStrictDerivAt_id x).neg.mul_const I).cexp.sub
               ((hasStrictDerivAt_id x).mul_const I).cexp).mul_const
           I).mul_const
       (2 : ℂ)⁻¹
@@ -75,7 +76,8 @@ theorem deriv_sin : deriv sin = cos :=
 theorem hasStrictDerivAt_cos (x : ℂ) : HasStrictDerivAt cos (-sin x) x :=
   by
   simp only [sin, div_eq_mul_inv, neg_mul_eq_neg_mul]
-  convert(((hasStrictDerivAt_id x).mul_const I).cexp.add
+  convert
+    (((hasStrictDerivAt_id x).mul_const I).cexp.add
           ((hasStrictDerivAt_id x).neg.mul_const I).cexp).mul_const
       (2 : ℂ)⁻¹
   simp only [Function.comp, id]
@@ -112,7 +114,7 @@ theorem deriv_cos' : deriv cos = fun x => -sin x :=
 theorem hasStrictDerivAt_sinh (x : ℂ) : HasStrictDerivAt sinh (cosh x) x :=
   by
   simp only [cosh, div_eq_mul_inv]
-  convert((has_strict_deriv_at_exp x).sub (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
+  convert ((has_strict_deriv_at_exp x).sub (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
   rw [id, mul_neg_one, sub_eq_add_neg, neg_neg]
 #align complex.has_strict_deriv_at_sinh Complex.hasStrictDerivAt_sinh
 
@@ -143,7 +145,7 @@ derivative `sinh x`. -/
 theorem hasStrictDerivAt_cosh (x : ℂ) : HasStrictDerivAt cosh (sinh x) x :=
   by
   simp only [sinh, div_eq_mul_inv]
-  convert((has_strict_deriv_at_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
+  convert ((has_strict_deriv_at_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
   rw [id, mul_neg_one, sub_eq_add_neg]
 #align complex.has_strict_deriv_at_cosh Complex.hasStrictDerivAt_cosh
 

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

@@ -729,7 +729,7 @@ theorem abs_sinh (x : ℝ) : |sinh x| = sinh (|x|) := by
 
 theorem cosh_strictMonoOn : StrictMonoOn cosh (Ici 0) :=
   (convex_Ici _).strictMonoOn_of_deriv_pos continuous_cosh.ContinuousOn fun x hx => by
-    rw [interior_Ici, mem_Ioi] at hx; rwa [deriv_cosh, sinh_pos_iff]
+    rw [interior_Ici, mem_Ioi] at hx ; rwa [deriv_cosh, sinh_pos_iff]
 #align real.cosh_strict_mono_on Real.cosh_strictMonoOn
 
 @[simp]
@@ -757,9 +757,9 @@ theorem sinh_sub_id_strictMono : StrictMono fun x => sinh x - x :=
   refine' strictMono_of_odd_strictMonoOn_nonneg (fun x => by simp) _
   refine' (convex_Ici _).strictMonoOn_of_deriv_pos _ fun x hx => _
   · exact (continuous_sinh.sub continuous_id).ContinuousOn
-  · rw [interior_Ici, mem_Ioi] at hx
+  · rw [interior_Ici, mem_Ioi] at hx 
     rw [deriv_sub, deriv_sinh, deriv_id'', sub_pos, one_lt_cosh]
-    exacts[hx.ne', differentiable_at_sinh, differentiableAt_id]
+    exacts [hx.ne', differentiable_at_sinh, differentiableAt_id]
 #align real.sinh_sub_id_strict_mono Real.sinh_sub_id_strictMono
 
 @[simp]

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

@@ -28,7 +28,7 @@ sin, cos, tan, angle
 
 noncomputable section
 
-open Classical Topology Filter
+open scoped Classical Topology Filter
 
 open Set Filter
 

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

@@ -684,9 +684,7 @@ theorem deriv_cosh : deriv cosh = sinh :=
 
 /-- `sinh` is strictly monotone. -/
 theorem sinh_strictMono : StrictMono sinh :=
-  strictMono_of_deriv_pos <| by
-    rw [Real.deriv_sinh]
-    exact cosh_pos
+  strictMono_of_deriv_pos <| by rw [Real.deriv_sinh]; exact cosh_pos
 #align real.sinh_strict_mono Real.sinh_strictMono
 
 /-- `sinh` is injective, `∀ a b, sinh a = sinh b → a = b`. -/
@@ -730,10 +728,8 @@ theorem abs_sinh (x : ℝ) : |sinh x| = sinh (|x|) := by
 #align real.abs_sinh Real.abs_sinh
 
 theorem cosh_strictMonoOn : StrictMonoOn cosh (Ici 0) :=
-  (convex_Ici _).strictMonoOn_of_deriv_pos continuous_cosh.ContinuousOn fun x hx =>
-    by
-    rw [interior_Ici, mem_Ioi] at hx
-    rwa [deriv_cosh, sinh_pos_iff]
+  (convex_Ici _).strictMonoOn_of_deriv_pos continuous_cosh.ContinuousOn fun x hx => by
+    rw [interior_Ici, mem_Ioi] at hx; rwa [deriv_cosh, sinh_pos_iff]
 #align real.cosh_strict_mono_on Real.cosh_strictMonoOn
 
 @[simp]

mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952

@@ -307,30 +307,30 @@ variable {E : Type _} [NormedAddCommGroup E] [NormedSpace ℂ E] {f : E → ℂ}
 /-! #### `complex.cos` -/
 
 
-theorem HasStrictFderivAt.ccos (hf : HasStrictFderivAt f f' x) :
-    HasStrictFderivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x :=
-  (Complex.hasStrictDerivAt_cos (f x)).comp_hasStrictFderivAt x hf
-#align has_strict_fderiv_at.ccos HasStrictFderivAt.ccos
+theorem HasStrictFDerivAt.ccos (hf : HasStrictFDerivAt f f' x) :
+    HasStrictFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x :=
+  (Complex.hasStrictDerivAt_cos (f x)).comp_hasStrictFDerivAt x hf
+#align has_strict_fderiv_at.ccos HasStrictFDerivAt.ccos
 
-theorem HasFderivAt.ccos (hf : HasFderivAt f f' x) :
-    HasFderivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x :=
-  (Complex.hasDerivAt_cos (f x)).comp_hasFderivAt x hf
-#align has_fderiv_at.ccos HasFderivAt.ccos
+theorem HasFDerivAt.ccos (hf : HasFDerivAt f f' x) :
+    HasFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x :=
+  (Complex.hasDerivAt_cos (f x)).comp_hasFDerivAt x hf
+#align has_fderiv_at.ccos HasFDerivAt.ccos
 
-theorem HasFderivWithinAt.ccos (hf : HasFderivWithinAt f f' s x) :
-    HasFderivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') s x :=
-  (Complex.hasDerivAt_cos (f x)).comp_hasFderivWithinAt x hf
-#align has_fderiv_within_at.ccos HasFderivWithinAt.ccos
+theorem HasFDerivWithinAt.ccos (hf : HasFDerivWithinAt f f' s x) :
+    HasFDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') s x :=
+  (Complex.hasDerivAt_cos (f x)).comp_hasFDerivWithinAt x hf
+#align has_fderiv_within_at.ccos HasFDerivWithinAt.ccos
 
 theorem DifferentiableWithinAt.ccos (hf : DifferentiableWithinAt ℂ f s x) :
     DifferentiableWithinAt ℂ (fun x => Complex.cos (f x)) s x :=
-  hf.HasFderivWithinAt.ccos.DifferentiableWithinAt
+  hf.HasFDerivWithinAt.ccos.DifferentiableWithinAt
 #align differentiable_within_at.ccos DifferentiableWithinAt.ccos
 
 @[simp]
 theorem DifferentiableAt.ccos (hc : DifferentiableAt ℂ f x) :
     DifferentiableAt ℂ (fun x => Complex.cos (f x)) x :=
-  hc.HasFderivAt.ccos.DifferentiableAt
+  hc.HasFDerivAt.ccos.DifferentiableAt
 #align differentiable_at.ccos DifferentiableAt.ccos
 
 theorem DifferentiableOn.ccos (hc : DifferentiableOn ℂ f s) :
@@ -344,13 +344,13 @@ theorem Differentiable.ccos (hc : Differentiable ℂ f) :
 
 theorem fderivWithin_ccos (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     fderivWithin ℂ (fun x => Complex.cos (f x)) s x = -Complex.sin (f x) • fderivWithin ℂ f s x :=
-  hf.HasFderivWithinAt.ccos.fderivWithin hxs
+  hf.HasFDerivWithinAt.ccos.fderivWithin hxs
 #align fderiv_within_ccos fderivWithin_ccos
 
 @[simp]
 theorem fderiv_ccos (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.cos (f x)) x = -Complex.sin (f x) • fderiv ℂ f x :=
-  hc.HasFderivAt.ccos.fderiv
+  hc.HasFDerivAt.ccos.fderiv
 #align fderiv_ccos fderiv_ccos
 
 theorem ContDiff.ccos {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.cos (f x) :=
@@ -375,30 +375,30 @@ theorem ContDiffWithinAt.ccos {n} (hf : ContDiffWithinAt ℂ n f s x) :
 /-! #### `complex.sin` -/
 
 
-theorem HasStrictFderivAt.csin (hf : HasStrictFderivAt f f' x) :
-    HasStrictFderivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x :=
-  (Complex.hasStrictDerivAt_sin (f x)).comp_hasStrictFderivAt x hf
-#align has_strict_fderiv_at.csin HasStrictFderivAt.csin
+theorem HasStrictFDerivAt.csin (hf : HasStrictFDerivAt f f' x) :
+    HasStrictFDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x :=
+  (Complex.hasStrictDerivAt_sin (f x)).comp_hasStrictFDerivAt x hf
+#align has_strict_fderiv_at.csin HasStrictFDerivAt.csin
 
-theorem HasFderivAt.csin (hf : HasFderivAt f f' x) :
-    HasFderivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x :=
-  (Complex.hasDerivAt_sin (f x)).comp_hasFderivAt x hf
-#align has_fderiv_at.csin HasFderivAt.csin
+theorem HasFDerivAt.csin (hf : HasFDerivAt f f' x) :
+    HasFDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x :=
+  (Complex.hasDerivAt_sin (f x)).comp_hasFDerivAt x hf
+#align has_fderiv_at.csin HasFDerivAt.csin
 
-theorem HasFderivWithinAt.csin (hf : HasFderivWithinAt f f' s x) :
-    HasFderivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') s x :=
-  (Complex.hasDerivAt_sin (f x)).comp_hasFderivWithinAt x hf
-#align has_fderiv_within_at.csin HasFderivWithinAt.csin
+theorem HasFDerivWithinAt.csin (hf : HasFDerivWithinAt f f' s x) :
+    HasFDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') s x :=
+  (Complex.hasDerivAt_sin (f x)).comp_hasFDerivWithinAt x hf
+#align has_fderiv_within_at.csin HasFDerivWithinAt.csin
 
 theorem DifferentiableWithinAt.csin (hf : DifferentiableWithinAt ℂ f s x) :
     DifferentiableWithinAt ℂ (fun x => Complex.sin (f x)) s x :=
-  hf.HasFderivWithinAt.csin.DifferentiableWithinAt
+  hf.HasFDerivWithinAt.csin.DifferentiableWithinAt
 #align differentiable_within_at.csin DifferentiableWithinAt.csin
 
 @[simp]
 theorem DifferentiableAt.csin (hc : DifferentiableAt ℂ f x) :
     DifferentiableAt ℂ (fun x => Complex.sin (f x)) x :=
-  hc.HasFderivAt.csin.DifferentiableAt
+  hc.HasFDerivAt.csin.DifferentiableAt
 #align differentiable_at.csin DifferentiableAt.csin
 
 theorem DifferentiableOn.csin (hc : DifferentiableOn ℂ f s) :
@@ -412,13 +412,13 @@ theorem Differentiable.csin (hc : Differentiable ℂ f) :
 
 theorem fderivWithin_csin (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     fderivWithin ℂ (fun x => Complex.sin (f x)) s x = Complex.cos (f x) • fderivWithin ℂ f s x :=
-  hf.HasFderivWithinAt.csin.fderivWithin hxs
+  hf.HasFDerivWithinAt.csin.fderivWithin hxs
 #align fderiv_within_csin fderivWithin_csin
 
 @[simp]
 theorem fderiv_csin (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.sin (f x)) x = Complex.cos (f x) • fderiv ℂ f x :=
-  hc.HasFderivAt.csin.fderiv
+  hc.HasFDerivAt.csin.fderiv
 #align fderiv_csin fderiv_csin
 
 theorem ContDiff.csin {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.sin (f x) :=
@@ -443,30 +443,30 @@ theorem ContDiffWithinAt.csin {n} (hf : ContDiffWithinAt ℂ n f s x) :
 /-! #### `complex.cosh` -/
 
 
-theorem HasStrictFderivAt.ccosh (hf : HasStrictFderivAt f f' x) :
-    HasStrictFderivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x :=
-  (Complex.hasStrictDerivAt_cosh (f x)).comp_hasStrictFderivAt x hf
-#align has_strict_fderiv_at.ccosh HasStrictFderivAt.ccosh
+theorem HasStrictFDerivAt.ccosh (hf : HasStrictFDerivAt f f' x) :
+    HasStrictFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x :=
+  (Complex.hasStrictDerivAt_cosh (f x)).comp_hasStrictFDerivAt x hf
+#align has_strict_fderiv_at.ccosh HasStrictFDerivAt.ccosh
 
-theorem HasFderivAt.ccosh (hf : HasFderivAt f f' x) :
-    HasFderivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x :=
-  (Complex.hasDerivAt_cosh (f x)).comp_hasFderivAt x hf
-#align has_fderiv_at.ccosh HasFderivAt.ccosh
+theorem HasFDerivAt.ccosh (hf : HasFDerivAt f f' x) :
+    HasFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x :=
+  (Complex.hasDerivAt_cosh (f x)).comp_hasFDerivAt x hf
+#align has_fderiv_at.ccosh HasFDerivAt.ccosh
 
-theorem HasFderivWithinAt.ccosh (hf : HasFderivWithinAt f f' s x) :
-    HasFderivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') s x :=
-  (Complex.hasDerivAt_cosh (f x)).comp_hasFderivWithinAt x hf
-#align has_fderiv_within_at.ccosh HasFderivWithinAt.ccosh
+theorem HasFDerivWithinAt.ccosh (hf : HasFDerivWithinAt f f' s x) :
+    HasFDerivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') s x :=
+  (Complex.hasDerivAt_cosh (f x)).comp_hasFDerivWithinAt x hf
+#align has_fderiv_within_at.ccosh HasFDerivWithinAt.ccosh
 
 theorem DifferentiableWithinAt.ccosh (hf : DifferentiableWithinAt ℂ f s x) :
     DifferentiableWithinAt ℂ (fun x => Complex.cosh (f x)) s x :=
-  hf.HasFderivWithinAt.ccosh.DifferentiableWithinAt
+  hf.HasFDerivWithinAt.ccosh.DifferentiableWithinAt
 #align differentiable_within_at.ccosh DifferentiableWithinAt.ccosh
 
 @[simp]
 theorem DifferentiableAt.ccosh (hc : DifferentiableAt ℂ f x) :
     DifferentiableAt ℂ (fun x => Complex.cosh (f x)) x :=
-  hc.HasFderivAt.ccosh.DifferentiableAt
+  hc.HasFDerivAt.ccosh.DifferentiableAt
 #align differentiable_at.ccosh DifferentiableAt.ccosh
 
 theorem DifferentiableOn.ccosh (hc : DifferentiableOn ℂ f s) :
@@ -480,13 +480,13 @@ theorem Differentiable.ccosh (hc : Differentiable ℂ f) :
 
 theorem fderivWithin_ccosh (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     fderivWithin ℂ (fun x => Complex.cosh (f x)) s x = Complex.sinh (f x) • fderivWithin ℂ f s x :=
-  hf.HasFderivWithinAt.ccosh.fderivWithin hxs
+  hf.HasFDerivWithinAt.ccosh.fderivWithin hxs
 #align fderiv_within_ccosh fderivWithin_ccosh
 
 @[simp]
 theorem fderiv_ccosh (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.cosh (f x)) x = Complex.sinh (f x) • fderiv ℂ f x :=
-  hc.HasFderivAt.ccosh.fderiv
+  hc.HasFDerivAt.ccosh.fderiv
 #align fderiv_ccosh fderiv_ccosh
 
 theorem ContDiff.ccosh {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.cosh (f x) :=
@@ -511,30 +511,30 @@ theorem ContDiffWithinAt.ccosh {n} (hf : ContDiffWithinAt ℂ n f s x) :
 /-! #### `complex.sinh` -/
 
 
-theorem HasStrictFderivAt.csinh (hf : HasStrictFderivAt f f' x) :
-    HasStrictFderivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x :=
-  (Complex.hasStrictDerivAt_sinh (f x)).comp_hasStrictFderivAt x hf
-#align has_strict_fderiv_at.csinh HasStrictFderivAt.csinh
+theorem HasStrictFDerivAt.csinh (hf : HasStrictFDerivAt f f' x) :
+    HasStrictFDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x :=
+  (Complex.hasStrictDerivAt_sinh (f x)).comp_hasStrictFDerivAt x hf
+#align has_strict_fderiv_at.csinh HasStrictFDerivAt.csinh
 
-theorem HasFderivAt.csinh (hf : HasFderivAt f f' x) :
-    HasFderivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x :=
-  (Complex.hasDerivAt_sinh (f x)).comp_hasFderivAt x hf
-#align has_fderiv_at.csinh HasFderivAt.csinh
+theorem HasFDerivAt.csinh (hf : HasFDerivAt f f' x) :
+    HasFDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x :=
+  (Complex.hasDerivAt_sinh (f x)).comp_hasFDerivAt x hf
+#align has_fderiv_at.csinh HasFDerivAt.csinh
 
-theorem HasFderivWithinAt.csinh (hf : HasFderivWithinAt f f' s x) :
-    HasFderivWithinAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') s x :=
-  (Complex.hasDerivAt_sinh (f x)).comp_hasFderivWithinAt x hf
-#align has_fderiv_within_at.csinh HasFderivWithinAt.csinh
+theorem HasFDerivWithinAt.csinh (hf : HasFDerivWithinAt f f' s x) :
+    HasFDerivWithinAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') s x :=
+  (Complex.hasDerivAt_sinh (f x)).comp_hasFDerivWithinAt x hf
+#align has_fderiv_within_at.csinh HasFDerivWithinAt.csinh
 
 theorem DifferentiableWithinAt.csinh (hf : DifferentiableWithinAt ℂ f s x) :
     DifferentiableWithinAt ℂ (fun x => Complex.sinh (f x)) s x :=
-  hf.HasFderivWithinAt.csinh.DifferentiableWithinAt
+  hf.HasFDerivWithinAt.csinh.DifferentiableWithinAt
 #align differentiable_within_at.csinh DifferentiableWithinAt.csinh
 
 @[simp]
 theorem DifferentiableAt.csinh (hc : DifferentiableAt ℂ f x) :
     DifferentiableAt ℂ (fun x => Complex.sinh (f x)) x :=
-  hc.HasFderivAt.csinh.DifferentiableAt
+  hc.HasFDerivAt.csinh.DifferentiableAt
 #align differentiable_at.csinh DifferentiableAt.csinh
 
 theorem DifferentiableOn.csinh (hc : DifferentiableOn ℂ f s) :
@@ -548,13 +548,13 @@ theorem Differentiable.csinh (hc : Differentiable ℂ f) :
 
 theorem fderivWithin_csinh (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
     fderivWithin ℂ (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) • fderivWithin ℂ f s x :=
-  hf.HasFderivWithinAt.csinh.fderivWithin hxs
+  hf.HasFDerivWithinAt.csinh.fderivWithin hxs
 #align fderiv_within_csinh fderivWithin_csinh
 
 @[simp]
 theorem fderiv_csinh (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.sinh (f x)) x = Complex.cosh (f x) • fderiv ℂ f x :=
-  hc.HasFderivAt.csinh.fderiv
+  hc.HasFDerivAt.csinh.fderiv
 #align fderiv_csinh fderiv_csinh
 
 theorem ContDiff.csinh {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.sinh (f x) :=
@@ -930,30 +930,30 @@ variable {E : Type _} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ}
 /-! #### `real.cos` -/
 
 
-theorem HasStrictFderivAt.cos (hf : HasStrictFderivAt f f' x) :
-    HasStrictFderivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x :=
-  (Real.hasStrictDerivAt_cos (f x)).comp_hasStrictFderivAt x hf
-#align has_strict_fderiv_at.cos HasStrictFderivAt.cos
+theorem HasStrictFDerivAt.cos (hf : HasStrictFDerivAt f f' x) :
+    HasStrictFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x :=
+  (Real.hasStrictDerivAt_cos (f x)).comp_hasStrictFDerivAt x hf
+#align has_strict_fderiv_at.cos HasStrictFDerivAt.cos
 
-theorem HasFderivAt.cos (hf : HasFderivAt f f' x) :
-    HasFderivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x :=
-  (Real.hasDerivAt_cos (f x)).comp_hasFderivAt x hf
-#align has_fderiv_at.cos HasFderivAt.cos
+theorem HasFDerivAt.cos (hf : HasFDerivAt f f' x) :
+    HasFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x :=
+  (Real.hasDerivAt_cos (f x)).comp_hasFDerivAt x hf
+#align has_fderiv_at.cos HasFDerivAt.cos
 
-theorem HasFderivWithinAt.cos (hf : HasFderivWithinAt f f' s x) :
-    HasFderivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') s x :=
-  (Real.hasDerivAt_cos (f x)).comp_hasFderivWithinAt x hf
-#align has_fderiv_within_at.cos HasFderivWithinAt.cos
+theorem HasFDerivWithinAt.cos (hf : HasFDerivWithinAt f f' s x) :
+    HasFDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') s x :=
+  (Real.hasDerivAt_cos (f x)).comp_hasFDerivWithinAt x hf
+#align has_fderiv_within_at.cos HasFDerivWithinAt.cos
 
 theorem DifferentiableWithinAt.cos (hf : DifferentiableWithinAt ℝ f s x) :
     DifferentiableWithinAt ℝ (fun x => Real.cos (f x)) s x :=
-  hf.HasFderivWithinAt.cos.DifferentiableWithinAt
+  hf.HasFDerivWithinAt.cos.DifferentiableWithinAt
 #align differentiable_within_at.cos DifferentiableWithinAt.cos
 
 @[simp]
 theorem DifferentiableAt.cos (hc : DifferentiableAt ℝ f x) :
     DifferentiableAt ℝ (fun x => Real.cos (f x)) x :=
-  hc.HasFderivAt.cos.DifferentiableAt
+  hc.HasFDerivAt.cos.DifferentiableAt
 #align differentiable_at.cos DifferentiableAt.cos
 
 theorem DifferentiableOn.cos (hc : DifferentiableOn ℝ f s) :
@@ -967,13 +967,13 @@ theorem Differentiable.cos (hc : Differentiable ℝ f) : Differentiable ℝ fun
 
 theorem fderivWithin_cos (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.cos (f x)) s x = -Real.sin (f x) • fderivWithin ℝ f s x :=
-  hf.HasFderivWithinAt.cos.fderivWithin hxs
+  hf.HasFDerivWithinAt.cos.fderivWithin hxs
 #align fderiv_within_cos fderivWithin_cos
 
 @[simp]
 theorem fderiv_cos (hc : DifferentiableAt ℝ f x) :
     fderiv ℝ (fun x => Real.cos (f x)) x = -Real.sin (f x) • fderiv ℝ f x :=
-  hc.HasFderivAt.cos.fderiv
+  hc.HasFDerivAt.cos.fderiv
 #align fderiv_cos fderiv_cos
 
 theorem ContDiff.cos {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.cos (f x) :=
@@ -996,30 +996,30 @@ theorem ContDiffWithinAt.cos {n} (hf : ContDiffWithinAt ℝ n f s x) :
 /-! #### `real.sin` -/
 
 
-theorem HasStrictFderivAt.sin (hf : HasStrictFderivAt f f' x) :
-    HasStrictFderivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x :=
-  (Real.hasStrictDerivAt_sin (f x)).comp_hasStrictFderivAt x hf
-#align has_strict_fderiv_at.sin HasStrictFderivAt.sin
+theorem HasStrictFDerivAt.sin (hf : HasStrictFDerivAt f f' x) :
+    HasStrictFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x :=
+  (Real.hasStrictDerivAt_sin (f x)).comp_hasStrictFDerivAt x hf
+#align has_strict_fderiv_at.sin HasStrictFDerivAt.sin
 
-theorem HasFderivAt.sin (hf : HasFderivAt f f' x) :
-    HasFderivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x :=
-  (Real.hasDerivAt_sin (f x)).comp_hasFderivAt x hf
-#align has_fderiv_at.sin HasFderivAt.sin
+theorem HasFDerivAt.sin (hf : HasFDerivAt f f' x) :
+    HasFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x :=
+  (Real.hasDerivAt_sin (f x)).comp_hasFDerivAt x hf
+#align has_fderiv_at.sin HasFDerivAt.sin
 
-theorem HasFderivWithinAt.sin (hf : HasFderivWithinAt f f' s x) :
-    HasFderivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') s x :=
-  (Real.hasDerivAt_sin (f x)).comp_hasFderivWithinAt x hf
-#align has_fderiv_within_at.sin HasFderivWithinAt.sin
+theorem HasFDerivWithinAt.sin (hf : HasFDerivWithinAt f f' s x) :
+    HasFDerivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') s x :=
+  (Real.hasDerivAt_sin (f x)).comp_hasFDerivWithinAt x hf
+#align has_fderiv_within_at.sin HasFDerivWithinAt.sin
 
 theorem DifferentiableWithinAt.sin (hf : DifferentiableWithinAt ℝ f s x) :
     DifferentiableWithinAt ℝ (fun x => Real.sin (f x)) s x :=
-  hf.HasFderivWithinAt.sin.DifferentiableWithinAt
+  hf.HasFDerivWithinAt.sin.DifferentiableWithinAt
 #align differentiable_within_at.sin DifferentiableWithinAt.sin
 
 @[simp]
 theorem DifferentiableAt.sin (hc : DifferentiableAt ℝ f x) :
     DifferentiableAt ℝ (fun x => Real.sin (f x)) x :=
-  hc.HasFderivAt.sin.DifferentiableAt
+  hc.HasFDerivAt.sin.DifferentiableAt
 #align differentiable_at.sin DifferentiableAt.sin
 
 theorem DifferentiableOn.sin (hc : DifferentiableOn ℝ f s) :
@@ -1033,13 +1033,13 @@ theorem Differentiable.sin (hc : Differentiable ℝ f) : Differentiable ℝ fun
 
 theorem fderivWithin_sin (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.sin (f x)) s x = Real.cos (f x) • fderivWithin ℝ f s x :=
-  hf.HasFderivWithinAt.sin.fderivWithin hxs
+  hf.HasFDerivWithinAt.sin.fderivWithin hxs
 #align fderiv_within_sin fderivWithin_sin
 
 @[simp]
 theorem fderiv_sin (hc : DifferentiableAt ℝ f x) :
     fderiv ℝ (fun x => Real.sin (f x)) x = Real.cos (f x) • fderiv ℝ f x :=
-  hc.HasFderivAt.sin.fderiv
+  hc.HasFDerivAt.sin.fderiv
 #align fderiv_sin fderiv_sin
 
 theorem ContDiff.sin {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.sin (f x) :=
@@ -1062,30 +1062,30 @@ theorem ContDiffWithinAt.sin {n} (hf : ContDiffWithinAt ℝ n f s x) :
 /-! #### `real.cosh` -/
 
 
-theorem HasStrictFderivAt.cosh (hf : HasStrictFderivAt f f' x) :
-    HasStrictFderivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x :=
-  (Real.hasStrictDerivAt_cosh (f x)).comp_hasStrictFderivAt x hf
-#align has_strict_fderiv_at.cosh HasStrictFderivAt.cosh
+theorem HasStrictFDerivAt.cosh (hf : HasStrictFDerivAt f f' x) :
+    HasStrictFDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x :=
+  (Real.hasStrictDerivAt_cosh (f x)).comp_hasStrictFDerivAt x hf
+#align has_strict_fderiv_at.cosh HasStrictFDerivAt.cosh
 
-theorem HasFderivAt.cosh (hf : HasFderivAt f f' x) :
-    HasFderivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x :=
-  (Real.hasDerivAt_cosh (f x)).comp_hasFderivAt x hf
-#align has_fderiv_at.cosh HasFderivAt.cosh
+theorem HasFDerivAt.cosh (hf : HasFDerivAt f f' x) :
+    HasFDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x :=
+  (Real.hasDerivAt_cosh (f x)).comp_hasFDerivAt x hf
+#align has_fderiv_at.cosh HasFDerivAt.cosh
 
-theorem HasFderivWithinAt.cosh (hf : HasFderivWithinAt f f' s x) :
-    HasFderivWithinAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') s x :=
-  (Real.hasDerivAt_cosh (f x)).comp_hasFderivWithinAt x hf
-#align has_fderiv_within_at.cosh HasFderivWithinAt.cosh
+theorem HasFDerivWithinAt.cosh (hf : HasFDerivWithinAt f f' s x) :
+    HasFDerivWithinAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') s x :=
+  (Real.hasDerivAt_cosh (f x)).comp_hasFDerivWithinAt x hf
+#align has_fderiv_within_at.cosh HasFDerivWithinAt.cosh
 
 theorem DifferentiableWithinAt.cosh (hf : DifferentiableWithinAt ℝ f s x) :
     DifferentiableWithinAt ℝ (fun x => Real.cosh (f x)) s x :=
-  hf.HasFderivWithinAt.cosh.DifferentiableWithinAt
+  hf.HasFDerivWithinAt.cosh.DifferentiableWithinAt
 #align differentiable_within_at.cosh DifferentiableWithinAt.cosh
 
 @[simp]
 theorem DifferentiableAt.cosh (hc : DifferentiableAt ℝ f x) :
     DifferentiableAt ℝ (fun x => Real.cosh (f x)) x :=
-  hc.HasFderivAt.cosh.DifferentiableAt
+  hc.HasFDerivAt.cosh.DifferentiableAt
 #align differentiable_at.cosh DifferentiableAt.cosh
 
 theorem DifferentiableOn.cosh (hc : DifferentiableOn ℝ f s) :
@@ -1099,13 +1099,13 @@ theorem Differentiable.cosh (hc : Differentiable ℝ f) : Differentiable ℝ fun
 
 theorem fderivWithin_cosh (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.cosh (f x)) s x = Real.sinh (f x) • fderivWithin ℝ f s x :=
-  hf.HasFderivWithinAt.cosh.fderivWithin hxs
+  hf.HasFDerivWithinAt.cosh.fderivWithin hxs
 #align fderiv_within_cosh fderivWithin_cosh
 
 @[simp]
 theorem fderiv_cosh (hc : DifferentiableAt ℝ f x) :
     fderiv ℝ (fun x => Real.cosh (f x)) x = Real.sinh (f x) • fderiv ℝ f x :=
-  hc.HasFderivAt.cosh.fderiv
+  hc.HasFDerivAt.cosh.fderiv
 #align fderiv_cosh fderiv_cosh
 
 theorem ContDiff.cosh {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.cosh (f x) :=
@@ -1130,30 +1130,30 @@ theorem ContDiffWithinAt.cosh {n} (hf : ContDiffWithinAt ℝ n f s x) :
 /-! #### `real.sinh` -/
 
 
-theorem HasStrictFderivAt.sinh (hf : HasStrictFderivAt f f' x) :
-    HasStrictFderivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x :=
-  (Real.hasStrictDerivAt_sinh (f x)).comp_hasStrictFderivAt x hf
-#align has_strict_fderiv_at.sinh HasStrictFderivAt.sinh
+theorem HasStrictFDerivAt.sinh (hf : HasStrictFDerivAt f f' x) :
+    HasStrictFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x :=
+  (Real.hasStrictDerivAt_sinh (f x)).comp_hasStrictFDerivAt x hf
+#align has_strict_fderiv_at.sinh HasStrictFDerivAt.sinh
 
-theorem HasFderivAt.sinh (hf : HasFderivAt f f' x) :
-    HasFderivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x :=
-  (Real.hasDerivAt_sinh (f x)).comp_hasFderivAt x hf
-#align has_fderiv_at.sinh HasFderivAt.sinh
+theorem HasFDerivAt.sinh (hf : HasFDerivAt f f' x) :
+    HasFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x :=
+  (Real.hasDerivAt_sinh (f x)).comp_hasFDerivAt x hf
+#align has_fderiv_at.sinh HasFDerivAt.sinh
 
-theorem HasFderivWithinAt.sinh (hf : HasFderivWithinAt f f' s x) :
-    HasFderivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') s x :=
-  (Real.hasDerivAt_sinh (f x)).comp_hasFderivWithinAt x hf
-#align has_fderiv_within_at.sinh HasFderivWithinAt.sinh
+theorem HasFDerivWithinAt.sinh (hf : HasFDerivWithinAt f f' s x) :
+    HasFDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') s x :=
+  (Real.hasDerivAt_sinh (f x)).comp_hasFDerivWithinAt x hf
+#align has_fderiv_within_at.sinh HasFDerivWithinAt.sinh
 
 theorem DifferentiableWithinAt.sinh (hf : DifferentiableWithinAt ℝ f s x) :
     DifferentiableWithinAt ℝ (fun x => Real.sinh (f x)) s x :=
-  hf.HasFderivWithinAt.sinh.DifferentiableWithinAt
+  hf.HasFDerivWithinAt.sinh.DifferentiableWithinAt
 #align differentiable_within_at.sinh DifferentiableWithinAt.sinh
 
 @[simp]
 theorem DifferentiableAt.sinh (hc : DifferentiableAt ℝ f x) :
     DifferentiableAt ℝ (fun x => Real.sinh (f x)) x :=
-  hc.HasFderivAt.sinh.DifferentiableAt
+  hc.HasFDerivAt.sinh.DifferentiableAt
 #align differentiable_at.sinh DifferentiableAt.sinh
 
 theorem DifferentiableOn.sinh (hc : DifferentiableOn ℝ f s) :
@@ -1167,13 +1167,13 @@ theorem Differentiable.sinh (hc : Differentiable ℝ f) : Differentiable ℝ fun
 
 theorem fderivWithin_sinh (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
     fderivWithin ℝ (fun x => Real.sinh (f x)) s x = Real.cosh (f x) • fderivWithin ℝ f s x :=
-  hf.HasFderivWithinAt.sinh.fderivWithin hxs
+  hf.HasFDerivWithinAt.sinh.fderivWithin hxs
 #align fderiv_within_sinh fderivWithin_sinh
 
 @[simp]
 theorem fderiv_sinh (hc : DifferentiableAt ℝ f x) :
     fderiv ℝ (fun x => Real.sinh (f x)) x = Real.cosh (f x) • fderiv ℝ f x :=
-  hc.HasFderivAt.sinh.fderiv
+  hc.HasFDerivAt.sinh.fderiv
 #align fderiv_sinh fderiv_sinh
 
 theorem ContDiff.sinh {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.sinh (f x) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/36b8aa61ea7c05727161f96a0532897bd72aedab

@@ -4,14 +4,13 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Abhimanyu Pallavi Sudhir, Jean Lo, Calle Sönne, Benjamin Davidson
 
 ! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.deriv
-! leanprover-community/mathlib commit 8c8c544bf24ced19b1e76c34bb3262bdae620f82
+! leanprover-community/mathlib commit 2c1d8ca2812b64f88992a5294ea3dba144755cd1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
 import Mathbin.Order.Monotone.Odd
 import Mathbin.Analysis.SpecialFunctions.ExpDeriv
 import Mathbin.Analysis.SpecialFunctions.Trigonometric.Basic
-import Mathbin.Data.Set.Intervals.Monotone
 
 /-!
 # Differentiability of trigonometric functions

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

@@ -39,8 +39,7 @@ namespace Complex
 theorem hasStrictDerivAt_sin (x : ℂ) : HasStrictDerivAt sin (cos x) x :=
   by
   simp only [cos, div_eq_mul_inv]
-  convert
-    ((((hasStrictDerivAt_id x).neg.mul_const I).cexp.sub
+  convert((((hasStrictDerivAt_id x).neg.mul_const I).cexp.sub
               ((hasStrictDerivAt_id x).mul_const I).cexp).mul_const
           I).mul_const
       (2 : ℂ)⁻¹
@@ -77,8 +76,7 @@ theorem deriv_sin : deriv sin = cos :=
 theorem hasStrictDerivAt_cos (x : ℂ) : HasStrictDerivAt cos (-sin x) x :=
   by
   simp only [sin, div_eq_mul_inv, neg_mul_eq_neg_mul]
-  convert
-    (((hasStrictDerivAt_id x).mul_const I).cexp.add
+  convert(((hasStrictDerivAt_id x).mul_const I).cexp.add
           ((hasStrictDerivAt_id x).neg.mul_const I).cexp).mul_const
       (2 : ℂ)⁻¹
   simp only [Function.comp, id]
@@ -115,7 +113,7 @@ theorem deriv_cos' : deriv cos = fun x => -sin x :=
 theorem hasStrictDerivAt_sinh (x : ℂ) : HasStrictDerivAt sinh (cosh x) x :=
   by
   simp only [cosh, div_eq_mul_inv]
-  convert ((has_strict_deriv_at_exp x).sub (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
+  convert((has_strict_deriv_at_exp x).sub (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
   rw [id, mul_neg_one, sub_eq_add_neg, neg_neg]
 #align complex.has_strict_deriv_at_sinh Complex.hasStrictDerivAt_sinh
 
@@ -146,7 +144,7 @@ derivative `sinh x`. -/
 theorem hasStrictDerivAt_cosh (x : ℂ) : HasStrictDerivAt cosh (sinh x) x :=
   by
   simp only [sinh, div_eq_mul_inv]
-  convert ((has_strict_deriv_at_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
+  convert((has_strict_deriv_at_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
   rw [id, mul_neg_one, sub_eq_add_neg]
 #align complex.has_strict_deriv_at_cosh Complex.hasStrictDerivAt_cosh
 

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

We want to avoid making Lean unfold smul during unification. A separate instance does helps at the cost of some elaboration failures.

@@ -338,7 +338,8 @@ theorem fderivWithin_ccos (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueD
   hf.hasFDerivWithinAt.ccos.fderivWithin hxs
 #align fderiv_within_ccos fderivWithin_ccos
 
-@[simp]
+@[simp, nolint simpNF] -- `simp` times out trying to find `Module ℂ (E →L[ℂ] ℂ)`
+-- with all of `Mathlib` opened -- no idea why
 theorem fderiv_ccos (hc : DifferentiableAt ℂ f x) :
     fderiv ℂ (fun x => Complex.cos (f x)) x = -Complex.sin (f x) • fderiv ℂ f x :=
   hc.hasFDerivAt.ccos.fderiv

This PR provides variants of deriv lemmas stated in terms of HasDerivAt

From LeanAPAP

@@ -723,7 +723,7 @@ theorem abs_sinh (x : ℝ) : |sinh x| = sinh |x| := by
 #align real.abs_sinh Real.abs_sinh
 
 theorem cosh_strictMonoOn : StrictMonoOn cosh (Ici 0) :=
-  (convex_Ici _).strictMonoOn_of_deriv_pos continuous_cosh.continuousOn fun x hx => by
+  strictMonoOn_of_deriv_pos (convex_Ici _) continuous_cosh.continuousOn fun x hx => by
     rw [interior_Ici, mem_Ioi] at hx; rwa [deriv_cosh, sinh_pos_iff]
 #align real.cosh_strict_mono_on Real.cosh_strictMonoOn
 
@@ -750,7 +750,7 @@ theorem one_lt_cosh : 1 < cosh x ↔ x ≠ 0 :=
 theorem sinh_sub_id_strictMono : StrictMono fun x => sinh x - x := by
   -- Porting note: `by simp; abel` was just `by simp` in mathlib3.
   refine' strictMono_of_odd_strictMonoOn_nonneg (fun x => by simp; abel) _
-  refine' (convex_Ici _).strictMonoOn_of_deriv_pos _ fun x hx => _
+  refine' strictMonoOn_of_deriv_pos (convex_Ici _) _ fun x hx => _
   · exact (continuous_sinh.sub continuous_id).continuousOn
   · rw [interior_Ici, mem_Ioi] at hx
     rw [deriv_sub, deriv_sinh, deriv_id'', sub_pos, one_lt_cosh]

Mathlib is now using v4.6.0-rc1, which includes the fix in leanprover/lean4#3060

@@ -1201,17 +1201,15 @@ is. -/
 def evalSinh : PositivityExt where eval {u α} _ _ e := do
   let zα : Q(Zero ℝ) := q(inferInstance)
   let pα : Q(PartialOrder ℝ) := q(inferInstance)
-  if let 0 := u then -- lean4#3060 means we can't combine this with the match below
-    match α, e with
-    | ~q(ℝ), ~q(Real.sinh $a) =>
-      assumeInstancesCommute
-      match ← core zα pα a with
-      | .positive pa => return .positive q(sinh_pos_of_pos $pa)
-      | .nonnegative pa => return .nonnegative q(sinh_nonneg_of_nonneg $pa)
-      | .nonzero pa => return .nonzero q(sinh_ne_zero_of_ne_zero $pa)
-      | _ => return .none
-    | _, _ => throwError "not Real.sinh"
-  else throwError "not Real.sinh"
+  match u, α, e with
+  | 0, ~q(ℝ), ~q(Real.sinh $a) =>
+    assumeInstancesCommute
+    match ← core zα pα a with
+    | .positive pa => return .positive q(sinh_pos_of_pos $pa)
+    | .nonnegative pa => return .nonnegative q(sinh_nonneg_of_nonneg $pa)
+    | .nonzero pa => return .nonzero q(sinh_ne_zero_of_ne_zero $pa)
+    | _ => return .none
+  | _, _, _ => throwError "not Real.sinh"
 
 example (x : ℝ) (hx : 0 < x) : 0 < x.sinh := by positivity
 example (x : ℝ) (hx : 0 ≤ x) : 0 ≤ x.sinh := by positivity

Also fix the name of Real.Mathlib.Meta.Positivity.evalExp to Mathlib.Meta.Positivity.evalRealPi.

@@ -698,6 +698,10 @@ theorem sinh_lt_sinh : sinh x < sinh y ↔ x < y :=
   sinh_strictMono.lt_iff_lt
 #align real.sinh_lt_sinh Real.sinh_lt_sinh
 
+@[simp] lemma sinh_eq_zero : sinh x = 0 ↔ x = 0 := by rw [← @sinh_inj x, sinh_zero]
+
+lemma sinh_ne_zero : sinh x ≠ 0 ↔ x ≠ 0 := sinh_eq_zero.not
+
 @[simp]
 theorem sinh_pos_iff : 0 < sinh x ↔ 0 < x := by simpa only [sinh_zero] using @sinh_lt_sinh 0 x
 #align real.sinh_pos_iff Real.sinh_pos_iff
@@ -1183,3 +1187,34 @@ theorem ContDiffWithinAt.sinh {n} (hf : ContDiffWithinAt ℝ n f s x) :
 #align cont_diff_within_at.sinh ContDiffWithinAt.sinh
 
 end
+
+namespace Mathlib.Meta.Positivity
+open Lean Meta Qq
+
+private alias ⟨_, sinh_pos_of_pos⟩ := Real.sinh_pos_iff
+private alias ⟨_, sinh_nonneg_of_nonneg⟩ := Real.sinh_nonneg_iff
+private alias ⟨_, sinh_ne_zero_of_ne_zero⟩ := Real.sinh_ne_zero
+
+/-- Extension for the `positivity` tactic: `Real.sinh` is positive/nonnegative/nonzero if its input
+is. -/
+@[positivity Real.sinh _]
+def evalSinh : PositivityExt where eval {u α} _ _ e := do
+  let zα : Q(Zero ℝ) := q(inferInstance)
+  let pα : Q(PartialOrder ℝ) := q(inferInstance)
+  if let 0 := u then -- lean4#3060 means we can't combine this with the match below
+    match α, e with
+    | ~q(ℝ), ~q(Real.sinh $a) =>
+      assumeInstancesCommute
+      match ← core zα pα a with
+      | .positive pa => return .positive q(sinh_pos_of_pos $pa)
+      | .nonnegative pa => return .nonnegative q(sinh_nonneg_of_nonneg $pa)
+      | .nonzero pa => return .nonzero q(sinh_ne_zero_of_ne_zero $pa)
+      | _ => return .none
+    | _, _ => throwError "not Real.sinh"
+  else throwError "not Real.sinh"
+
+example (x : ℝ) (hx : 0 < x) : 0 < x.sinh := by positivity
+example (x : ℝ) (hx : 0 ≤ x) : 0 ≤ x.sinh := by positivity
+example (x : ℝ) (hx : x ≠ 0) : x.sinh ≠ 0 := by positivity
+
+end Mathlib.Meta.Positivity

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

This has nice performance benefits.

@@ -292,7 +292,7 @@ section
 /-! ### Simp lemmas for derivatives of `fun x => Complex.cos (f x)` etc., `f : E → ℂ` -/
 
 
-variable {E : Type _} [NormedAddCommGroup E] [NormedSpace ℂ E] {f : E → ℂ} {f' : E →L[ℂ] ℂ} {x : E}
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] {f : E → ℂ} {f' : E →L[ℂ] ℂ} {x : E}
   {s : Set E}
 
 /-! #### `Complex.cos` -/
@@ -911,7 +911,7 @@ section
 /-! ### Simp lemmas for derivatives of `fun x => Real.cos (f x)` etc., `f : E → ℝ` -/
 
 
-variable {E : Type _} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {f' : E →L[ℝ] ℝ} {x : E}
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {f' : E →L[ℝ] ℝ} {x : E}
   {s : Set E}
 
 /-! #### `Real.cos` -/

• 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) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Abhimanyu Pallavi Sudhir, Jean Lo, Calle Sönne, Benjamin Davidson
-
-! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.deriv
-! leanprover-community/mathlib commit 2c1d8ca2812b64f88992a5294ea3dba144755cd1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Monotone.Odd
 import Mathlib.Analysis.SpecialFunctions.ExpDeriv
 import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
 
+#align_import analysis.special_functions.trigonometric.deriv from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
+
 /-!
 # Differentiability of trigonometric functions
 

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

@@ -723,7 +723,7 @@ theorem abs_sinh (x : ℝ) : |sinh x| = sinh |x| := by
 
 theorem cosh_strictMonoOn : StrictMonoOn cosh (Ici 0) :=
   (convex_Ici _).strictMonoOn_of_deriv_pos continuous_cosh.continuousOn fun x hx => by
-    rw [interior_Ici, mem_Ioi] at hx ; rwa [deriv_cosh, sinh_pos_iff]
+    rw [interior_Ici, mem_Ioi] at hx; rwa [deriv_cosh, sinh_pos_iff]
 #align real.cosh_strict_mono_on Real.cosh_strictMonoOn
 
 @[simp]

@@ -717,7 +717,7 @@ theorem sinh_neg_iff : sinh x < 0 ↔ x < 0 := by simpa only [sinh_zero] using @
 theorem sinh_nonneg_iff : 0 ≤ sinh x ↔ 0 ≤ x := by simpa only [sinh_zero] using @sinh_le_sinh 0 x
 #align real.sinh_nonneg_iff Real.sinh_nonneg_iff
 
-theorem abs_sinh (x : ℝ) : |sinh x| = sinh (|x|) := by
+theorem abs_sinh (x : ℝ) : |sinh x| = sinh |x| := by
   cases le_total x 0 <;> simp [abs_of_nonneg, abs_of_nonpos, *]
 #align real.abs_sinh Real.abs_sinh
 

• depends on: #4651

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com> Co-authored-by: Patrick Massot <patrickmassot@free.fr> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>