File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

full_name: Complex.hasStrictDerivAt_sin
code: /-- The complex sine function is everywhere strictly differentiable, with the derivative `cos x`. -/
theorem hasStrictDerivAt_sin (x : ℂ) : HasStrictDerivAt sin (cos x) x 
goal: HasStrictDerivAt Complex.sin (Complex.cos x) x

full_name: Complex.hasDerivAt_sin
code: /-- The complex sine function is everywhere differentiable, with the derivative `cos x`. -/
theorem hasDerivAt_sin (x : ℂ) : HasDerivAt sin (cos x) x 
goal: HasDerivAt Complex.sin (Complex.cos x) x

full_name: Complex.contDiff_sin
code: theorem contDiff_sin {n} : ContDiff ℂ n sin 
goal: ContDiff ℂ n Complex.sin

full_name: Complex.differentiable_sin
code: theorem differentiable_sin : Differentiable ℂ sin 
goal: Differentiable ℂ Complex.sin

full_name: Complex.differentiableAt_sin
code: theorem differentiableAt_sin {x : ℂ} : DifferentiableAt ℂ sin x 
goal: DifferentiableAt ℂ Complex.sin x

full_name: Complex.deriv_sin
code: @[simp]
theorem deriv_sin : deriv sin = cos 
goal: deriv Complex.sin = Complex.cos

full_name: Complex.hasStrictDerivAt_cos
code: /-- The complex cosine function is everywhere strictly differentiable, with the derivative
`-sin x`. -/
theorem hasStrictDerivAt_cos (x : ℂ) : HasStrictDerivAt cos (-sin x) x 
goal: HasStrictDerivAt Complex.cos (-Complex.sin x) x

full_name: Complex.hasDerivAt_cos
code: /-- The complex cosine function is everywhere differentiable, with the derivative `-sin x`. -/
theorem hasDerivAt_cos (x : ℂ) : HasDerivAt cos (-sin x) x 
goal: HasDerivAt Complex.cos (-Complex.sin x) x

full_name: Complex.contDiff_cos
code: theorem contDiff_cos {n} : ContDiff ℂ n cos 
goal: ContDiff ℂ n Complex.cos

full_name: Complex.differentiable_cos
code: theorem differentiable_cos : Differentiable ℂ cos 
goal: Differentiable ℂ Complex.cos

full_name: Complex.differentiableAt_cos
code: theorem differentiableAt_cos {x : ℂ} : DifferentiableAt ℂ cos x 
goal: DifferentiableAt ℂ Complex.cos x

full_name: Complex.deriv_cos
code: theorem deriv_cos {x : ℂ} : deriv cos x = -sin x 
goal: deriv Complex.cos x = -Complex.sin x

full_name: Complex.deriv_cos'
code: @[simp]
theorem deriv_cos' : deriv cos = fun x => -sin x 
goal: deriv Complex.cos = fun x => -Complex.sin x

full_name: Complex.hasStrictDerivAt_sinh
code: /-- The complex hyperbolic sine function is everywhere strictly differentiable, with the derivative
`cosh x`. -/
theorem hasStrictDerivAt_sinh (x : ℂ) : HasStrictDerivAt sinh (cosh x) x 
goal: HasStrictDerivAt Complex.sinh (Complex.cosh x) x

full_name: Complex.hasDerivAt_sinh
code: /-- The complex hyperbolic sine function is everywhere differentiable, with the derivative
`cosh x`. -/
theorem hasDerivAt_sinh (x : ℂ) : HasDerivAt sinh (cosh x) x 
goal: HasDerivAt Complex.sinh (Complex.cosh x) x

full_name: Complex.contDiff_sinh
code: theorem contDiff_sinh {n} : ContDiff ℂ n sinh 
goal: ContDiff ℂ n Complex.sinh

full_name: Complex.differentiable_sinh
code: theorem differentiable_sinh : Differentiable ℂ sinh 
goal: Differentiable ℂ Complex.sinh

full_name: Complex.differentiableAt_sinh
code: theorem differentiableAt_sinh {x : ℂ} : DifferentiableAt ℂ sinh x 
goal: DifferentiableAt ℂ Complex.sinh x

full_name: Complex.deriv_sinh
code: @[simp]
theorem deriv_sinh : deriv sinh = cosh 
goal: deriv Complex.sinh = Complex.cosh

full_name: Complex.hasStrictDerivAt_cosh
code: /-- The complex hyperbolic cosine function is everywhere strictly differentiable, with the
derivative `sinh x`. -/
theorem hasStrictDerivAt_cosh (x : ℂ) : HasStrictDerivAt cosh (sinh x) x 
goal: HasStrictDerivAt Complex.cosh (Complex.sinh x) x

full_name: Complex.hasDerivAt_cosh
code: /-- The complex hyperbolic cosine function is everywhere differentiable, with the derivative
`sinh x`. -/
theorem hasDerivAt_cosh (x : ℂ) : HasDerivAt cosh (sinh x) x 
goal: HasDerivAt Complex.cosh (Complex.sinh x) x

full_name: Complex.contDiff_cosh
code: theorem contDiff_cosh {n} : ContDiff ℂ n cosh 
goal: ContDiff ℂ n Complex.cosh

full_name: Complex.differentiable_cosh
code: theorem differentiable_cosh : Differentiable ℂ cosh 
goal: Differentiable ℂ Complex.cosh

full_name: Complex.differentiableAt_cosh
code: theorem differentiableAt_cosh {x : ℂ} : DifferentiableAt ℂ cosh x 
goal: DifferentiableAt ℂ Complex.cosh x

full_name: Complex.deriv_cosh
code: @[simp]
theorem deriv_cosh : deriv cosh = sinh 
goal: deriv Complex.cosh = Complex.sinh

full_name: HasStrictDerivAt.ccos
code: theorem HasStrictDerivAt.ccos (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x 
goal: HasStrictDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x

full_name: HasDerivAt.ccos
code: theorem HasDerivAt.ccos (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x 
goal: HasDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x

full_name: HasDerivWithinAt.ccos
code: theorem HasDerivWithinAt.ccos (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') s x 
goal: HasDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') s x

full_name: derivWithin_ccos
code: 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 
goal: derivWithin (fun x => Complex.cos (f x)) s x = -Complex.sin (f x) * derivWithin f s x

full_name: deriv_ccos
code: @[simp]
theorem deriv_ccos (hc : DifferentiableAt ℂ f x) :
    deriv (fun x => Complex.cos (f x)) x = -Complex.sin (f x) * deriv f x 
goal: deriv (fun x => Complex.cos (f x)) x = -Complex.sin (f x) * deriv f x

full_name: HasStrictDerivAt.csin
code: theorem HasStrictDerivAt.csin (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x 
goal: HasStrictDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x

full_name: HasDerivAt.csin
code: theorem HasDerivAt.csin (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x 
goal: HasDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x

full_name: HasDerivWithinAt.csin
code: theorem HasDerivWithinAt.csin (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') s x 
goal: HasDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') s x

full_name: derivWithin_csin
code: 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 
goal: derivWithin (fun x => Complex.sin (f x)) s x = Complex.cos (f x) * derivWithin f s x

full_name: deriv_csin
code: @[simp]
theorem deriv_csin (hc : DifferentiableAt ℂ f x) :
    deriv (fun x => Complex.sin (f x)) x = Complex.cos (f x) * deriv f x 
goal: deriv (fun x => Complex.sin (f x)) x = Complex.cos (f x) * deriv f x

full_name: HasStrictDerivAt.ccosh
code: theorem HasStrictDerivAt.ccosh (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') x 
goal: HasStrictDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') x

full_name: HasDerivAt.ccosh
code: theorem HasDerivAt.ccosh (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') x 
goal: HasDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') x

full_name: HasDerivWithinAt.ccosh
code: theorem HasDerivWithinAt.ccosh (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') s x 
goal: HasDerivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) * f') s x

full_name: derivWithin_ccosh
code: 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 
goal: derivWithin (fun x => Complex.cosh (f x)) s x = Complex.sinh (f x) * derivWithin f s x

full_name: deriv_ccosh
code: @[simp]
theorem deriv_ccosh (hc : DifferentiableAt ℂ f x) :
    deriv (fun x => Complex.cosh (f x)) x = Complex.sinh (f x) * deriv f x 
goal: deriv (fun x => Complex.cosh (f x)) x = Complex.sinh (f x) * deriv f x

full_name: HasStrictDerivAt.csinh
code: theorem HasStrictDerivAt.csinh (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') x 
goal: HasStrictDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') x

full_name: HasDerivAt.csinh
code: theorem HasDerivAt.csinh (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') x 
goal: HasDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') x

full_name: HasDerivWithinAt.csinh
code: theorem HasDerivWithinAt.csinh (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') s x 
goal: HasDerivWithinAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') s x

full_name: derivWithin_csinh
code: 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 
goal: derivWithin (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) * derivWithin f s x

full_name: deriv_csinh
code: @[simp]
theorem deriv_csinh (hc : DifferentiableAt ℂ f x) :
    deriv (fun x => Complex.sinh (f x)) x = Complex.cosh (f x) * deriv f x 
goal: deriv (fun x => Complex.sinh (f x)) x = Complex.cosh (f x) * deriv f x

full_name: HasStrictFDerivAt.ccos
code: theorem HasStrictFDerivAt.ccos (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x 
goal: HasStrictFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x

full_name: HasFDerivAt.ccos
code: theorem HasFDerivAt.ccos (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x 
goal: HasFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x

full_name: HasFDerivWithinAt.ccos
code: theorem HasFDerivWithinAt.ccos (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') s x 
goal: HasFDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') s x

full_name: DifferentiableWithinAt.ccos
code: theorem DifferentiableWithinAt.ccos (hf : DifferentiableWithinAt ℂ f s x) :
    DifferentiableWithinAt ℂ (fun x => Complex.cos (f x)) s x 
goal: DifferentiableWithinAt ℂ (fun x => Complex.cos (f x)) s x

full_name: DifferentiableAt.ccos
code: @[simp]
theorem DifferentiableAt.ccos (hc : DifferentiableAt ℂ f x) :
    DifferentiableAt ℂ (fun x => Complex.cos (f x)) x 
goal: DifferentiableAt ℂ (fun x => Complex.cos (f x)) x

full_name: DifferentiableOn.ccos
code: theorem DifferentiableOn.ccos (hc : DifferentiableOn ℂ f s) :
    DifferentiableOn ℂ (fun x => Complex.cos (f x)) s 
goal: DifferentiableOn ℂ (fun x => Complex.cos (f x)) s

full_name: Differentiable.ccos
code: @[simp]
theorem Differentiable.ccos (hc : Differentiable ℂ f) :
    Differentiable ℂ fun x => Complex.cos (f x) 
goal: Differentiable ℂ fun x => Complex.cos (f x)

full_name: fderivWithin_ccos
code: 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 
goal: fderivWithin ℂ (fun x => Complex.cos (f x)) s x = -Complex.sin (f x) • fderivWithin ℂ f s x

full_name: fderiv_ccos
code: @[simp]
theorem fderiv_ccos (hc : DifferentiableAt ℂ f x) :
    fderiv ℂ (fun x => Complex.cos (f x)) x = -Complex.sin (f x) • fderiv ℂ f x 
goal: fderiv ℂ (fun x => Complex.cos (f x)) x = -Complex.sin (f x) • fderiv ℂ f x

full_name: ContDiff.ccos
code: theorem ContDiff.ccos {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.cos (f x) 
goal: ContDiff ℂ n fun x => Complex.cos (f x)

full_name: ContDiffAt.ccos
code: theorem ContDiffAt.ccos {n} (hf : ContDiffAt ℂ n f x) :
    ContDiffAt ℂ n (fun x => Complex.cos (f x)) x 
goal: ContDiffAt ℂ n (fun x => Complex.cos (f x)) x

full_name: ContDiffOn.ccos
code: theorem ContDiffOn.ccos {n} (hf : ContDiffOn ℂ n f s) :
    ContDiffOn ℂ n (fun x => Complex.cos (f x)) s 
goal: ContDiffOn ℂ n (fun x => Complex.cos (f x)) s

full_name: ContDiffWithinAt.ccos
code: theorem ContDiffWithinAt.ccos {n} (hf : ContDiffWithinAt ℂ n f s x) :
    ContDiffWithinAt ℂ n (fun x => Complex.cos (f x)) s x 
goal: ContDiffWithinAt ℂ n (fun x => Complex.cos (f x)) s x

full_name: HasStrictFDerivAt.csin
code: theorem HasStrictFDerivAt.csin (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x 
goal: HasStrictFDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x

full_name: HasFDerivAt.csin
code: theorem HasFDerivAt.csin (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x 
goal: HasFDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') x

full_name: HasFDerivWithinAt.csin
code: theorem HasFDerivWithinAt.csin (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') s x 
goal: HasFDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) • f') s x

full_name: DifferentiableWithinAt.csin
code: theorem DifferentiableWithinAt.csin (hf : DifferentiableWithinAt ℂ f s x) :
    DifferentiableWithinAt ℂ (fun x => Complex.sin (f x)) s x 
goal: DifferentiableWithinAt ℂ (fun x => Complex.sin (f x)) s x

full_name: DifferentiableAt.csin
code: @[simp]
theorem DifferentiableAt.csin (hc : DifferentiableAt ℂ f x) :
    DifferentiableAt ℂ (fun x => Complex.sin (f x)) x 
goal: DifferentiableAt ℂ (fun x => Complex.sin (f x)) x

full_name: DifferentiableOn.csin
code: theorem DifferentiableOn.csin (hc : DifferentiableOn ℂ f s) :
    DifferentiableOn ℂ (fun x => Complex.sin (f x)) s 
goal: DifferentiableOn ℂ (fun x => Complex.sin (f x)) s

full_name: Differentiable.csin
code: @[simp]
theorem Differentiable.csin (hc : Differentiable ℂ f) :
    Differentiable ℂ fun x => Complex.sin (f x) 
goal: Differentiable ℂ fun x => Complex.sin (f x)

full_name: fderivWithin_csin
code: 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 
goal: fderivWithin ℂ (fun x => Complex.sin (f x)) s x = Complex.cos (f x) • fderivWithin ℂ f s x

full_name: fderiv_csin
code: @[simp]
theorem fderiv_csin (hc : DifferentiableAt ℂ f x) :
    fderiv ℂ (fun x => Complex.sin (f x)) x = Complex.cos (f x) • fderiv ℂ f x 
goal: fderiv ℂ (fun x => Complex.sin (f x)) x = Complex.cos (f x) • fderiv ℂ f x

full_name: ContDiff.csin
code: theorem ContDiff.csin {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.sin (f x) 
goal: ContDiff ℂ n fun x => Complex.sin (f x)

full_name: ContDiffAt.csin
code: theorem ContDiffAt.csin {n} (hf : ContDiffAt ℂ n f x) :
    ContDiffAt ℂ n (fun x => Complex.sin (f x)) x 
goal: ContDiffAt ℂ n (fun x => Complex.sin (f x)) x

full_name: ContDiffOn.csin
code: theorem ContDiffOn.csin {n} (hf : ContDiffOn ℂ n f s) :
    ContDiffOn ℂ n (fun x => Complex.sin (f x)) s 
goal: ContDiffOn ℂ n (fun x => Complex.sin (f x)) s

full_name: ContDiffWithinAt.csin
code: theorem ContDiffWithinAt.csin {n} (hf : ContDiffWithinAt ℂ n f s x) :
    ContDiffWithinAt ℂ n (fun x => Complex.sin (f x)) s x 
goal: ContDiffWithinAt ℂ n (fun x => Complex.sin (f x)) s x

full_name: HasStrictFDerivAt.ccosh
code: theorem HasStrictFDerivAt.ccosh (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x 
goal: HasStrictFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x

full_name: HasFDerivAt.ccosh
code: theorem HasFDerivAt.ccosh (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x 
goal: HasFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x

full_name: HasFDerivWithinAt.ccosh
code: theorem HasFDerivWithinAt.ccosh (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') s x 
goal: HasFDerivWithinAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') s x

full_name: DifferentiableWithinAt.ccosh
code: theorem DifferentiableWithinAt.ccosh (hf : DifferentiableWithinAt ℂ f s x) :
    DifferentiableWithinAt ℂ (fun x => Complex.cosh (f x)) s x 
goal: DifferentiableWithinAt ℂ (fun x => Complex.cosh (f x)) s x

full_name: DifferentiableAt.ccosh
code: @[simp]
theorem DifferentiableAt.ccosh (hc : DifferentiableAt ℂ f x) :
    DifferentiableAt ℂ (fun x => Complex.cosh (f x)) x 
goal: DifferentiableAt ℂ (fun x => Complex.cosh (f x)) x

full_name: DifferentiableOn.ccosh
code: theorem DifferentiableOn.ccosh (hc : DifferentiableOn ℂ f s) :
    DifferentiableOn ℂ (fun x => Complex.cosh (f x)) s 
goal: DifferentiableOn ℂ (fun x => Complex.cosh (f x)) s

full_name: Differentiable.ccosh
code: @[simp]
theorem Differentiable.ccosh (hc : Differentiable ℂ f) :
    Differentiable ℂ fun x => Complex.cosh (f x) 
goal: Differentiable ℂ fun x => Complex.cosh (f x)

full_name: fderivWithin_ccosh
code: 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 
goal: fderivWithin ℂ (fun x => Complex.cosh (f x)) s x = Complex.sinh (f x) • fderivWithin ℂ f s x

full_name: fderiv_ccosh
code: @[simp]
theorem fderiv_ccosh (hc : DifferentiableAt ℂ f x) :
    fderiv ℂ (fun x => Complex.cosh (f x)) x = Complex.sinh (f x) • fderiv ℂ f x 
goal: fderiv ℂ (fun x => Complex.cosh (f x)) x = Complex.sinh (f x) • fderiv ℂ f x

full_name: ContDiff.ccosh
code: theorem ContDiff.ccosh {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.cosh (f x) 
goal: ContDiff ℂ n fun x => Complex.cosh (f x)

full_name: ContDiffAt.ccosh
code: theorem ContDiffAt.ccosh {n} (hf : ContDiffAt ℂ n f x) :
    ContDiffAt ℂ n (fun x => Complex.cosh (f x)) x 
goal: ContDiffAt ℂ n (fun x => Complex.cosh (f x)) x

full_name: ContDiffOn.ccosh
code: theorem ContDiffOn.ccosh {n} (hf : ContDiffOn ℂ n f s) :
    ContDiffOn ℂ n (fun x => Complex.cosh (f x)) s 
goal: ContDiffOn ℂ n (fun x => Complex.cosh (f x)) s

full_name: ContDiffWithinAt.ccosh
code: theorem ContDiffWithinAt.ccosh {n} (hf : ContDiffWithinAt ℂ n f s x) :
    ContDiffWithinAt ℂ n (fun x => Complex.cosh (f x)) s x 
goal: ContDiffWithinAt ℂ n (fun x => Complex.cosh (f x)) s x

full_name: HasStrictFDerivAt.csinh
code: theorem HasStrictFDerivAt.csinh (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x 
goal: HasStrictFDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x

full_name: HasFDerivAt.csinh
code: theorem HasFDerivAt.csinh (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x 
goal: HasFDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') x

full_name: HasFDerivWithinAt.csinh
code: theorem HasFDerivWithinAt.csinh (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') s x 
goal: HasFDerivWithinAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) • f') s x

full_name: DifferentiableWithinAt.csinh
code: theorem DifferentiableWithinAt.csinh (hf : DifferentiableWithinAt ℂ f s x) :
    DifferentiableWithinAt ℂ (fun x => Complex.sinh (f x)) s x 
goal: DifferentiableWithinAt ℂ (fun x => Complex.sinh (f x)) s x

full_name: DifferentiableAt.csinh
code: @[simp]
theorem DifferentiableAt.csinh (hc : DifferentiableAt ℂ f x) :
    DifferentiableAt ℂ (fun x => Complex.sinh (f x)) x 
goal: DifferentiableAt ℂ (fun x => Complex.sinh (f x)) x

full_name: DifferentiableOn.csinh
code: theorem DifferentiableOn.csinh (hc : DifferentiableOn ℂ f s) :
    DifferentiableOn ℂ (fun x => Complex.sinh (f x)) s 
goal: DifferentiableOn ℂ (fun x => Complex.sinh (f x)) s

full_name: Differentiable.csinh
code: @[simp]
theorem Differentiable.csinh (hc : Differentiable ℂ f) :
    Differentiable ℂ fun x => Complex.sinh (f x) 
goal: Differentiable ℂ fun x => Complex.sinh (f x)

full_name: fderivWithin_csinh
code: 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 
goal: fderivWithin ℂ (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) • fderivWithin ℂ f s x

full_name: fderiv_csinh
code: @[simp]
theorem fderiv_csinh (hc : DifferentiableAt ℂ f x) :
    fderiv ℂ (fun x => Complex.sinh (f x)) x = Complex.cosh (f x) • fderiv ℂ f x 
goal: fderiv ℂ (fun x => Complex.sinh (f x)) x = Complex.cosh (f x) • fderiv ℂ f x

full_name: ContDiff.csinh
code: theorem ContDiff.csinh {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.sinh (f x) 
goal: ContDiff ℂ n fun x => Complex.sinh (f x)

full_name: ContDiffAt.csinh
code: theorem ContDiffAt.csinh {n} (hf : ContDiffAt ℂ n f x) :
    ContDiffAt ℂ n (fun x => Complex.sinh (f x)) x 
goal: ContDiffAt ℂ n (fun x => Complex.sinh (f x)) x

full_name: ContDiffOn.csinh
code: theorem ContDiffOn.csinh {n} (hf : ContDiffOn ℂ n f s) :
    ContDiffOn ℂ n (fun x => Complex.sinh (f x)) s 
goal: ContDiffOn ℂ n (fun x => Complex.sinh (f x)) s

full_name: ContDiffWithinAt.csinh
code: theorem ContDiffWithinAt.csinh {n} (hf : ContDiffWithinAt ℂ n f s x) :
    ContDiffWithinAt ℂ n (fun x => Complex.sinh (f x)) s x 
goal: ContDiffWithinAt ℂ n (fun x => Complex.sinh (f x)) s x

full_name: Real.hasStrictDerivAt_sin
code: theorem hasStrictDerivAt_sin (x : ℝ) : HasStrictDerivAt sin (cos x) x 
goal: HasStrictDerivAt Real.sin (Real.cos x) x

full_name: Real.hasDerivAt_sin
code: theorem hasDerivAt_sin (x : ℝ) : HasDerivAt sin (cos x) x 
goal: HasDerivAt Real.sin (Real.cos x) x

full_name: Real.contDiff_sin
code: theorem contDiff_sin {n} : ContDiff ℝ n sin 
goal: ContDiff ℝ n Real.sin

full_name: Real.differentiable_sin
code: theorem differentiable_sin : Differentiable ℝ sin 
goal: Differentiable ℝ Real.sin

full_name: Real.differentiableAt_sin
code: theorem differentiableAt_sin : DifferentiableAt ℝ sin x 
goal: DifferentiableAt ℝ Real.sin x

full_name: Real.deriv_sin
code: @[simp]
theorem deriv_sin : deriv sin = cos 
goal: deriv Real.sin = Real.cos

full_name: Real.hasStrictDerivAt_cos
code: theorem hasStrictDerivAt_cos (x : ℝ) : HasStrictDerivAt cos (-sin x) x 
goal: HasStrictDerivAt Real.cos (-Real.sin x) x

full_name: Real.hasDerivAt_cos
code: theorem hasDerivAt_cos (x : ℝ) : HasDerivAt cos (-sin x) x 
goal: HasDerivAt Real.cos (-Real.sin x) x

full_name: Real.contDiff_cos
code: theorem contDiff_cos {n} : ContDiff ℝ n cos 
goal: ContDiff ℝ n Real.cos

full_name: Real.differentiable_cos
code: theorem differentiable_cos : Differentiable ℝ cos 
goal: Differentiable ℝ Real.cos

full_name: Real.differentiableAt_cos
code: theorem differentiableAt_cos : DifferentiableAt ℝ cos x 
goal: DifferentiableAt ℝ Real.cos x

full_name: Real.deriv_cos
code: theorem deriv_cos : deriv cos x = -sin x 
goal: deriv Real.cos x = -Real.sin x

full_name: Real.deriv_cos'
code: @[simp]
theorem deriv_cos' : deriv cos = fun x => -sin x 
goal: deriv Real.cos = fun x => -Real.sin x

full_name: Real.hasStrictDerivAt_sinh
code: theorem hasStrictDerivAt_sinh (x : ℝ) : HasStrictDerivAt sinh (cosh x) x 
goal: HasStrictDerivAt Real.sinh (Real.cosh x) x

full_name: Real.hasDerivAt_sinh
code: theorem hasDerivAt_sinh (x : ℝ) : HasDerivAt sinh (cosh x) x 
goal: HasDerivAt Real.sinh (Real.cosh x) x

full_name: Real.contDiff_sinh
code: theorem contDiff_sinh {n} : ContDiff ℝ n sinh 
goal: ContDiff ℝ n Real.sinh

full_name: Real.differentiable_sinh
code: theorem differentiable_sinh : Differentiable ℝ sinh 
goal: Differentiable ℝ Real.sinh

full_name: Real.differentiableAt_sinh
code: theorem differentiableAt_sinh : DifferentiableAt ℝ sinh x 
goal: DifferentiableAt ℝ Real.sinh x

full_name: Real.deriv_sinh
code: @[simp]
theorem deriv_sinh : deriv sinh = cosh 
goal: deriv Real.sinh = Real.cosh

full_name: Real.hasStrictDerivAt_cosh
code: theorem hasStrictDerivAt_cosh (x : ℝ) : HasStrictDerivAt cosh (sinh x) x 
goal: HasStrictDerivAt Real.cosh (Real.sinh x) x

full_name: Real.hasDerivAt_cosh
code: theorem hasDerivAt_cosh (x : ℝ) : HasDerivAt cosh (sinh x) x 
goal: HasDerivAt Real.cosh (Real.sinh x) x

full_name: Real.contDiff_cosh
code: theorem contDiff_cosh {n} : ContDiff ℝ n cosh 
goal: ContDiff ℝ n Real.cosh

full_name: Real.differentiable_cosh
code: theorem differentiable_cosh : Differentiable ℝ cosh 
goal: Differentiable ℝ Real.cosh

full_name: Real.differentiableAt_cosh
code: theorem differentiableAt_cosh : DifferentiableAt ℝ cosh x 
goal: DifferentiableAt ℝ Real.cosh x

full_name: Real.deriv_cosh
code: @[simp]
theorem deriv_cosh : deriv cosh = sinh 
goal: deriv Real.cosh = Real.sinh

full_name: Real.sinh_strictMono
code: /-- `sinh` is strictly monotone. -/
theorem sinh_strictMono : StrictMono sinh 
goal: StrictMono Real.sinh

full_name: Real.sinh_injective
code: /-- `sinh` is injective, `∀ a b, sinh a = sinh b → a = b`. -/
theorem sinh_injective : Function.Injective sinh 
goal: Function.Injective Real.sinh

full_name: Real.sinh_inj
code: @[simp]
theorem sinh_inj : sinh x = sinh y ↔ x = y 
goal: Real.sinh x = Real.sinh y ↔ x = y

full_name: Real.sinh_le_sinh
code: @[simp]
theorem sinh_le_sinh : sinh x ≤ sinh y ↔ x ≤ y 
goal: Real.sinh x ≤ Real.sinh y ↔ x ≤ y

full_name: Real.sinh_lt_sinh
code: @[simp]
theorem sinh_lt_sinh : sinh x < sinh y ↔ x < y 
goal: Real.sinh x < Real.sinh y ↔ x < y

full_name: Real.sinh_eq_zero
code: @[simp] lemma sinh_eq_zero : sinh x = 0 ↔ x = 0 
goal: Real.sinh x = 0 ↔ x = 0

full_name: Real.sinh_ne_zero
code: lemma sinh_ne_zero : sinh x ≠ 0 ↔ x ≠ 0 
goal: Real.sinh x ≠ 0 ↔ x ≠ 0

full_name: Real.sinh_pos_iff
code: @[simp]
theorem sinh_pos_iff : 0 < sinh x ↔ 0 < x 
goal: 0 < Real.sinh x ↔ 0 < x

full_name: Real.sinh_nonpos_iff
code: @[simp]
theorem sinh_nonpos_iff : sinh x ≤ 0 ↔ x ≤ 0 
goal: Real.sinh x ≤ 0 ↔ x ≤ 0

full_name: Real.sinh_neg_iff
code: @[simp]
theorem sinh_neg_iff : sinh x < 0 ↔ x < 0 
goal: Real.sinh x < 0 ↔ x < 0

full_name: Real.sinh_nonneg_iff
code: @[simp]
theorem sinh_nonneg_iff : 0 ≤ sinh x ↔ 0 ≤ x 
goal: 0 ≤ Real.sinh x ↔ 0 ≤ x

full_name: Real.abs_sinh
code: theorem abs_sinh (x : ℝ) : |sinh x| = sinh |x| 
goal: |Real.sinh x| = Real.sinh |x|

full_name: Real.cosh_strictMonoOn
code: theorem cosh_strictMonoOn : StrictMonoOn cosh (Ici 0) 
goal: StrictMonoOn Real.cosh (Set.Ici 0)

full_name: Real.cosh_le_cosh
code: @[simp]
theorem cosh_le_cosh : cosh x ≤ cosh y ↔ |x| ≤ |y| 
goal: Real.cosh x ≤ Real.cosh y ↔ |x| ≤ |y|

full_name: Real.cosh_lt_cosh
code: @[simp]
theorem cosh_lt_cosh : cosh x < cosh y ↔ |x| < |y| 
goal: Real.cosh x < Real.cosh y ↔ |x| < |y|

full_name: Real.one_le_cosh
code: @[simp]
theorem one_le_cosh (x : ℝ) : 1 ≤ cosh x 
goal: 1 ≤ Real.cosh x

full_name: Real.one_lt_cosh
code: @[simp]
theorem one_lt_cosh : 1 < cosh x ↔ x ≠ 0 
goal: 1 < Real.cosh x ↔ x ≠ 0

full_name: Real.sinh_sub_id_strictMono
code: theorem sinh_sub_id_strictMono : StrictMono fun x => sinh x - x 
goal: StrictMono fun x => Real.sinh x - x

full_name: Real.self_le_sinh_iff
code: @[simp]
theorem self_le_sinh_iff : x ≤ sinh x ↔ 0 ≤ x 
goal: x ≤ Real.sinh x ↔ 0 ≤ x

full_name: Real.sinh_le_self_iff
code: @[simp]
theorem sinh_le_self_iff : sinh x ≤ x ↔ x ≤ 0 
goal: Real.sinh x ≤ x ↔ x ≤ 0

full_name: Real.self_lt_sinh_iff
code: @[simp]
theorem self_lt_sinh_iff : x < sinh x ↔ 0 < x 
goal: x < Real.sinh x ↔ 0 < x

full_name: Real.sinh_lt_self_iff
code: @[simp]
theorem sinh_lt_self_iff : sinh x < x ↔ x < 0 
goal: Real.sinh x < x ↔ x < 0

full_name: HasStrictDerivAt.cos
code: theorem HasStrictDerivAt.cos (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') x 
goal: HasStrictDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') x

full_name: HasDerivAt.cos
code: theorem HasDerivAt.cos (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') x 
goal: HasDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') x

full_name: HasDerivWithinAt.cos
code: theorem HasDerivWithinAt.cos (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') s x 
goal: HasDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') s x

full_name: derivWithin_cos
code: 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 
goal: derivWithin (fun x => Real.cos (f x)) s x = -Real.sin (f x) * derivWithin f s x

full_name: deriv_cos
code: @[simp]
theorem deriv_cos (hc : DifferentiableAt ℝ f x) :
    deriv (fun x => Real.cos (f x)) x = -Real.sin (f x) * deriv f x 
goal: deriv (fun x => Real.cos (f x)) x = -Real.sin (f x) * deriv f x

full_name: HasStrictDerivAt.sin
code: theorem HasStrictDerivAt.sin (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') x 
goal: HasStrictDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') x

full_name: HasDerivAt.sin
code: theorem HasDerivAt.sin (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') x 
goal: HasDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') x

full_name: HasDerivWithinAt.sin
code: theorem HasDerivWithinAt.sin (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') s x 
goal: HasDerivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) * f') s x

full_name: derivWithin_sin
code: 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 
goal: derivWithin (fun x => Real.sin (f x)) s x = Real.cos (f x) * derivWithin f s x

full_name: deriv_sin
code: @[simp]
theorem deriv_sin (hc : DifferentiableAt ℝ f x) :
    deriv (fun x => Real.sin (f x)) x = Real.cos (f x) * deriv f x 
goal: deriv (fun x => Real.sin (f x)) x = Real.cos (f x) * deriv f x

full_name: HasStrictDerivAt.cosh
code: theorem HasStrictDerivAt.cosh (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') x 
goal: HasStrictDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') x

full_name: HasDerivAt.cosh
code: theorem HasDerivAt.cosh (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') x 
goal: HasDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') x

full_name: HasDerivWithinAt.cosh
code: theorem HasDerivWithinAt.cosh (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') s x 
goal: HasDerivWithinAt (fun x => Real.cosh (f x)) (Real.sinh (f x) * f') s x

full_name: derivWithin_cosh
code: 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 
goal: derivWithin (fun x => Real.cosh (f x)) s x = Real.sinh (f x) * derivWithin f s x

full_name: deriv_cosh
code: @[simp]
theorem deriv_cosh (hc : DifferentiableAt ℝ f x) :
    deriv (fun x => Real.cosh (f x)) x = Real.sinh (f x) * deriv f x 
goal: deriv (fun x => Real.cosh (f x)) x = Real.sinh (f x) * deriv f x

full_name: HasStrictDerivAt.sinh
code: theorem HasStrictDerivAt.sinh (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x 
goal: HasStrictDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x

full_name: HasDerivAt.sinh
code: theorem HasDerivAt.sinh (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x 
goal: HasDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x

full_name: HasDerivWithinAt.sinh
code: theorem HasDerivWithinAt.sinh (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') s x 
goal: HasDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') s x

full_name: derivWithin_sinh
code: 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 
goal: derivWithin (fun x => Real.sinh (f x)) s x = Real.cosh (f x) * derivWithin f s x

full_name: deriv_sinh
code: @[simp]
theorem deriv_sinh (hc : DifferentiableAt ℝ f x) :
    deriv (fun x => Real.sinh (f x)) x = Real.cosh (f x) * deriv f x 
goal: deriv (fun x => Real.sinh (f x)) x = Real.cosh (f x) * deriv f x

full_name: HasStrictFDerivAt.cos
code: theorem HasStrictFDerivAt.cos (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x 
goal: HasStrictFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x

full_name: HasFDerivAt.cos
code: theorem HasFDerivAt.cos (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x 
goal: HasFDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') x

full_name: HasFDerivWithinAt.cos
code: theorem HasFDerivWithinAt.cos (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') s x 
goal: HasFDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) • f') s x

full_name: DifferentiableWithinAt.cos
code: theorem DifferentiableWithinAt.cos (hf : DifferentiableWithinAt ℝ f s x) :
    DifferentiableWithinAt ℝ (fun x => Real.cos (f x)) s x 
goal: DifferentiableWithinAt ℝ (fun x => Real.cos (f x)) s x

full_name: DifferentiableAt.cos
code: @[simp]
theorem DifferentiableAt.cos (hc : DifferentiableAt ℝ f x) :
    DifferentiableAt ℝ (fun x => Real.cos (f x)) x 
goal: DifferentiableAt ℝ (fun x => Real.cos (f x)) x

full_name: DifferentiableOn.cos
code: theorem DifferentiableOn.cos (hc : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => Real.cos (f x)) s 
goal: DifferentiableOn ℝ (fun x => Real.cos (f x)) s

full_name: Differentiable.cos
code: @[simp]
theorem Differentiable.cos (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.cos (f x) 
goal: Differentiable ℝ fun x => Real.cos (f x)

full_name: fderivWithin_cos
code: 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 
goal: fderivWithin ℝ (fun x => Real.cos (f x)) s x = -Real.sin (f x) • fderivWithin ℝ f s x

full_name: fderiv_cos
code: @[simp]
theorem fderiv_cos (hc : DifferentiableAt ℝ f x) :
    fderiv ℝ (fun x => Real.cos (f x)) x = -Real.sin (f x) • fderiv ℝ f x 
goal: fderiv ℝ (fun x => Real.cos (f x)) x = -Real.sin (f x) • fderiv ℝ f x

full_name: ContDiff.cos
code: theorem ContDiff.cos {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.cos (f x) 
goal: ContDiff ℝ n fun x => Real.cos (f x)

full_name: ContDiffAt.cos
code: theorem ContDiffAt.cos {n} (hf : ContDiffAt ℝ n f x) : ContDiffAt ℝ n (fun x => Real.cos (f x)) x 
goal: ContDiffAt ℝ n (fun x => Real.cos (f x)) x

full_name: ContDiffOn.cos
code: theorem ContDiffOn.cos {n} (hf : ContDiffOn ℝ n f s) : ContDiffOn ℝ n (fun x => Real.cos (f x)) s 
goal: ContDiffOn ℝ n (fun x => Real.cos (f x)) s

full_name: ContDiffWithinAt.cos
code: theorem ContDiffWithinAt.cos {n} (hf : ContDiffWithinAt ℝ n f s x) :
    ContDiffWithinAt ℝ n (fun x => Real.cos (f x)) s x 
goal: ContDiffWithinAt ℝ n (fun x => Real.cos (f x)) s x

full_name: HasStrictFDerivAt.sin
code: theorem HasStrictFDerivAt.sin (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x 
goal: HasStrictFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x

full_name: HasFDerivAt.sin
code: theorem HasFDerivAt.sin (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x 
goal: HasFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x

full_name: HasFDerivWithinAt.sin
code: theorem HasFDerivWithinAt.sin (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') s x 
goal: HasFDerivWithinAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') s x

full_name: DifferentiableWithinAt.sin
code: theorem DifferentiableWithinAt.sin (hf : DifferentiableWithinAt ℝ f s x) :
    DifferentiableWithinAt ℝ (fun x => Real.sin (f x)) s x 
goal: DifferentiableWithinAt ℝ (fun x => Real.sin (f x)) s x

full_name: DifferentiableAt.sin
code: @[simp]
theorem DifferentiableAt.sin (hc : DifferentiableAt ℝ f x) :
    DifferentiableAt ℝ (fun x => Real.sin (f x)) x 
goal: DifferentiableAt ℝ (fun x => Real.sin (f x)) x

full_name: DifferentiableOn.sin
code: theorem DifferentiableOn.sin (hc : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => Real.sin (f x)) s 
goal: DifferentiableOn ℝ (fun x => Real.sin (f x)) s

full_name: Differentiable.sin
code: @[simp]
theorem Differentiable.sin (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.sin (f x) 
goal: Differentiable ℝ fun x => Real.sin (f x)

full_name: fderivWithin_sin
code: 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 
goal: fderivWithin ℝ (fun x => Real.sin (f x)) s x = Real.cos (f x) • fderivWithin ℝ f s x

full_name: fderiv_sin
code: @[simp]
theorem fderiv_sin (hc : DifferentiableAt ℝ f x) :
    fderiv ℝ (fun x => Real.sin (f x)) x = Real.cos (f x) • fderiv ℝ f x 
goal: fderiv ℝ (fun x => Real.sin (f x)) x = Real.cos (f x) • fderiv ℝ f x

full_name: ContDiff.sin
code: theorem ContDiff.sin {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.sin (f x) 
goal: ContDiff ℝ n fun x => Real.sin (f x)

full_name: ContDiffAt.sin
code: theorem ContDiffAt.sin {n} (hf : ContDiffAt ℝ n f x) : ContDiffAt ℝ n (fun x => Real.sin (f x)) x 
goal: ContDiffAt ℝ n (fun x => Real.sin (f x)) x

full_name: ContDiffOn.sin
code: theorem ContDiffOn.sin {n} (hf : ContDiffOn ℝ n f s) : ContDiffOn ℝ n (fun x => Real.sin (f x)) s 
goal: ContDiffOn ℝ n (fun x => Real.sin (f x)) s

full_name: ContDiffWithinAt.sin
code: theorem ContDiffWithinAt.sin {n} (hf : ContDiffWithinAt ℝ n f s x) :
    ContDiffWithinAt ℝ n (fun x => Real.sin (f x)) s x 
goal: ContDiffWithinAt ℝ n (fun x => Real.sin (f x)) s x

full_name: HasStrictFDerivAt.cosh
code: theorem HasStrictFDerivAt.cosh (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x 
goal: HasStrictFDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x

full_name: HasFDerivAt.cosh
code: theorem HasFDerivAt.cosh (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x 
goal: HasFDerivAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') x

full_name: HasFDerivWithinAt.cosh
code: theorem HasFDerivWithinAt.cosh (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') s x 
goal: HasFDerivWithinAt (fun x => Real.cosh (f x)) (Real.sinh (f x) • f') s x

full_name: DifferentiableWithinAt.cosh
code: theorem DifferentiableWithinAt.cosh (hf : DifferentiableWithinAt ℝ f s x) :
    DifferentiableWithinAt ℝ (fun x => Real.cosh (f x)) s x 
goal: DifferentiableWithinAt ℝ (fun x => Real.cosh (f x)) s x

full_name: DifferentiableAt.cosh
code: @[simp]
theorem DifferentiableAt.cosh (hc : DifferentiableAt ℝ f x) :
    DifferentiableAt ℝ (fun x => Real.cosh (f x)) x 
goal: DifferentiableAt ℝ (fun x => Real.cosh (f x)) x

full_name: DifferentiableOn.cosh
code: theorem DifferentiableOn.cosh (hc : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => Real.cosh (f x)) s 
goal: DifferentiableOn ℝ (fun x => Real.cosh (f x)) s

full_name: Differentiable.cosh
code: @[simp]
theorem Differentiable.cosh (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.cosh (f x) 
goal: Differentiable ℝ fun x => Real.cosh (f x)

full_name: fderivWithin_cosh
code: 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 
goal: fderivWithin ℝ (fun x => Real.cosh (f x)) s x = Real.sinh (f x) • fderivWithin ℝ f s x

full_name: fderiv_cosh
code: @[simp]
theorem fderiv_cosh (hc : DifferentiableAt ℝ f x) :
    fderiv ℝ (fun x => Real.cosh (f x)) x = Real.sinh (f x) • fderiv ℝ f x 
goal: fderiv ℝ (fun x => Real.cosh (f x)) x = Real.sinh (f x) • fderiv ℝ f x

full_name: ContDiff.cosh
code: theorem ContDiff.cosh {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.cosh (f x) 
goal: ContDiff ℝ n fun x => Real.cosh (f x)

full_name: ContDiffAt.cosh
code: theorem ContDiffAt.cosh {n} (hf : ContDiffAt ℝ n f x) :
    ContDiffAt ℝ n (fun x => Real.cosh (f x)) x 
goal: ContDiffAt ℝ n (fun x => Real.cosh (f x)) x

full_name: ContDiffOn.cosh
code: theorem ContDiffOn.cosh {n} (hf : ContDiffOn ℝ n f s) :
    ContDiffOn ℝ n (fun x => Real.cosh (f x)) s 
goal: ContDiffOn ℝ n (fun x => Real.cosh (f x)) s

full_name: ContDiffWithinAt.cosh
code: theorem ContDiffWithinAt.cosh {n} (hf : ContDiffWithinAt ℝ n f s x) :
    ContDiffWithinAt ℝ n (fun x => Real.cosh (f x)) s x 
goal: ContDiffWithinAt ℝ n (fun x => Real.cosh (f x)) s x

full_name: HasStrictFDerivAt.sinh
code: theorem HasStrictFDerivAt.sinh (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x 
goal: HasStrictFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x

full_name: HasFDerivAt.sinh
code: theorem HasFDerivAt.sinh (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x 
goal: HasFDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') x

full_name: HasFDerivWithinAt.sinh
code: theorem HasFDerivWithinAt.sinh (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') s x 
goal: HasFDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) • f') s x

full_name: DifferentiableWithinAt.sinh
code: theorem DifferentiableWithinAt.sinh (hf : DifferentiableWithinAt ℝ f s x) :
    DifferentiableWithinAt ℝ (fun x => Real.sinh (f x)) s x 
goal: DifferentiableWithinAt ℝ (fun x => Real.sinh (f x)) s x

full_name: DifferentiableAt.sinh
code: @[simp]
theorem DifferentiableAt.sinh (hc : DifferentiableAt ℝ f x) :
    DifferentiableAt ℝ (fun x => Real.sinh (f x)) x 
goal: DifferentiableAt ℝ (fun x => Real.sinh (f x)) x

full_name: DifferentiableOn.sinh
code: theorem DifferentiableOn.sinh (hc : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => Real.sinh (f x)) s 
goal: DifferentiableOn ℝ (fun x => Real.sinh (f x)) s

full_name: Differentiable.sinh
code: @[simp]
theorem Differentiable.sinh (hc : Differentiable ℝ f) : Differentiable ℝ fun x => Real.sinh (f x) 
goal: Differentiable ℝ fun x => Real.sinh (f x)

full_name: fderivWithin_sinh
code: 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 
goal: fderivWithin ℝ (fun x => Real.sinh (f x)) s x = Real.cosh (f x) • fderivWithin ℝ f s x

full_name: fderiv_sinh
code: @[simp]
theorem fderiv_sinh (hc : DifferentiableAt ℝ f x) :
    fderiv ℝ (fun x => Real.sinh (f x)) x = Real.cosh (f x) • fderiv ℝ f x 
goal: fderiv ℝ (fun x => Real.sinh (f x)) x = Real.cosh (f x) • fderiv ℝ f x

full_name: ContDiff.sinh
code: theorem ContDiff.sinh {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.sinh (f x) 
goal: ContDiff ℝ n fun x => Real.sinh (f x)

full_name: ContDiffAt.sinh
code: theorem ContDiffAt.sinh {n} (hf : ContDiffAt ℝ n f x) :
    ContDiffAt ℝ n (fun x => Real.sinh (f x)) x 
goal: ContDiffAt ℝ n (fun x => Real.sinh (f x)) x

full_name: ContDiffOn.sinh
code: theorem ContDiffOn.sinh {n} (hf : ContDiffOn ℝ n f s) :
    ContDiffOn ℝ n (fun x => Real.sinh (f x)) s 
goal: ContDiffOn ℝ n (fun x => Real.sinh (f x)) s

full_name: ContDiffWithinAt.sinh
code: theorem ContDiffWithinAt.sinh {n} (hf : ContDiffWithinAt ℝ n f s x) :
    ContDiffWithinAt ℝ n (fun x => Real.sinh (f x)) s x 
goal: ContDiffWithinAt ℝ n (fun x => Real.sinh (f x)) s x

full_name: Complex.logDeriv_sin
code: @[simp]
theorem Complex.logDeriv_sin : logDeriv (Complex.sin) = Complex.cot 
goal: logDeriv Complex.sin = Complex.cot

full_name: Real.logDeriv_sin
code: @[simp]
theorem Real.logDeriv_sin : logDeriv (Real.sin) = Real.cot 
goal: logDeriv Real.sin = Real.cot

full_name: Complex.logDeriv_cos
code: @[simp]
theorem Complex.logDeriv_cos : logDeriv (Complex.cos) = -Complex.tan 
goal: logDeriv Complex.cos = -Complex.tan

full_name: Real.logDeriv_cos
code: @[simp]
theorem Real.logDeriv_cos : logDeriv (Real.cos) = -Real.tan 
goal: logDeriv Real.cos = -Real.tan

full_name: Complex.logDeriv_cosh
code: @[simp]
theorem Complex.logDeriv_cosh : logDeriv (Complex.cosh) = Complex.tanh 
goal: logDeriv Complex.cosh = Complex.tanh

full_name: Real.logDeriv_cosh
code: @[simp]
theorem Real.logDeriv_cosh : logDeriv (Real.cosh) = Real.tanh 
goal: logDeriv Real.cosh = Real.tanh

full_name: Complex.LogDeriv_exp
code: @[simp]
theorem Complex.LogDeriv_exp : logDeriv (Complex.exp) = 1 
goal: logDeriv Complex.exp = 1

full_name: Real.LogDeriv_exp
code: @[simp]
theorem Real.LogDeriv_exp : logDeriv (Real.exp) = 1 
goal: logDeriv Real.exp = 1

full_name: Mathlib.Meta.Positivity.evalSinh
code: /-- Extension for the `positivity` tactic: `Real.sinh` is positive/nonnegative/nonzero if its input
is. -/
@[positivity Real.sinh _]
def evalSinh : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt