File: Mathlib/Data/Complex/Exponential.lean

full_name: Complex.isCauSeq_abs_exp
code: theorem isCauSeq_abs_exp (z : ℂ) :
    IsCauSeq _root_.abs fun n => ∑ m ∈ range n, abs (z ^ m / m.factorial) 
goal: IsCauSeq abs fun n => ∑ m ∈ Finset.range n, Complex.abs (z ^ m / ↑m.factorial)

full_name: Complex.isCauSeq_exp
code: theorem isCauSeq_exp (z : ℂ) : IsCauSeq abs fun n => ∑ m ∈ range n, z ^ m / m.factorial 
goal: IsCauSeq ⇑Complex.abs fun n => ∑ m ∈ Finset.range n, z ^ m / ↑m.factorial

full_name: Complex.exp'
code: /-- The Cauchy sequence consisting of partial sums of the Taylor series of
the complex exponential function -/
@[pp_nodot]
def exp' (z : ℂ) : CauSeq ℂ Complex.abs 
goal: CauSeq ℂ ⇑Complex.abs

full_name: Complex.exp
code: /-- The complex exponential function, defined via its Taylor series -/
-- Porting note: removed `irreducible` attribute, so I can prove things
@[pp_nodot]
def exp (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex.sin
code: /-- The complex sine function, defined via `exp` -/
@[pp_nodot]
def sin (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex.cos
code: /-- The complex cosine function, defined via `exp` -/
@[pp_nodot]
def cos (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex.tan
code: /-- The complex tangent function, defined as `sin z / cos z` -/
@[pp_nodot]
def tan (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex.cot
code: /-- The complex cotangent function, defined as `cos z / sin z` -/
def cot (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex.sinh
code: /-- The complex hyperbolic sine function, defined via `exp` -/
@[pp_nodot]
def sinh (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex.cosh
code: /-- The complex hyperbolic cosine function, defined via `exp` -/
@[pp_nodot]
def cosh (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex.tanh
code: /-- The complex hyperbolic tangent function, defined as `sinh z / cosh z` -/
@[pp_nodot]
def tanh (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex._aux_Mathlib_Data_Complex_Exponential___unexpand_Complex_exp_1
code: /-- scoped notation for the complex exponential function -/
scoped notation "cexp" => Complex.exp
goal: Lean.PrettyPrinter.Unexpander

full_name: Complex._aux_Mathlib_Data_Complex_Exponential___macroRules_Complex_termCexp_1
code: /-- scoped notation for the complex exponential function -/
scoped notation "cexp" => Complex.exp
goal: Lean.Macro

full_name: Real.exp
code: /-- The real exponential function, defined as the real part of the complex exponential -/
@[pp_nodot]
nonrec def exp (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.sin
code: /-- The real sine function, defined as the real part of the complex sine -/
@[pp_nodot]
nonrec def sin (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.cos
code: /-- The real cosine function, defined as the real part of the complex cosine -/
@[pp_nodot]
nonrec def cos (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.tan
code: /-- The real tangent function, defined as the real part of the complex tangent -/
@[pp_nodot]
nonrec def tan (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.cot
code: /-- The real cotangent function, defined as the real part of the complex cotangent -/
nonrec def cot (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.sinh
code: /-- The real hypebolic sine function, defined as the real part of the complex hyperbolic sine -/
@[pp_nodot]
nonrec def sinh (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.cosh
code: /-- The real hypebolic cosine function, defined as the real part of the complex hyperbolic cosine -/
@[pp_nodot]
nonrec def cosh (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.tanh
code: /-- The real hypebolic tangent function, defined as the real part of
the complex hyperbolic tangent -/
@[pp_nodot]
nonrec def tanh (x : ℝ) : ℝ 
goal: ℝ

full_name: Real._aux_Mathlib_Data_Complex_Exponential___unexpand_Real_exp_1
code: /-- scoped notation for the real exponential function -/
scoped notation "rexp" => Real.exp
goal: Lean.PrettyPrinter.Unexpander

full_name: Real._aux_Mathlib_Data_Complex_Exponential___macroRules_Real_termRexp_1
code: /-- scoped notation for the real exponential function -/
scoped notation "rexp" => Real.exp
goal: Lean.Macro

full_name: Complex.exp_zero
code: @[simp]
theorem exp_zero : exp 0 = 1 
goal: Complex.exp 0 = 1

full_name: Complex.exp_add
code: theorem exp_add : exp (x + y) = exp x * exp y 
goal: Complex.exp (x + y) = Complex.exp x * Complex.exp y

full_name: Complex.expMonoidHom
code: /-- the exponential function as a monoid hom from `Multiplicative ℂ` to `ℂ` -/
noncomputable def expMonoidHom : MonoidHom (Multiplicative ℂ) ℂ 
goal: Multiplicative ℂ →* ℂ

full_name: Complex.exp_list_sum
code: theorem exp_list_sum (l : List ℂ) : exp l.sum = (l.map exp).prod 
goal: Complex.exp l.sum = (List.map Complex.exp l).prod

full_name: Complex.exp_multiset_sum
code: theorem exp_multiset_sum (s : Multiset ℂ) : exp s.sum = (s.map exp).prod 
goal: Complex.exp s.sum = (Multiset.map Complex.exp s).prod

full_name: Complex.exp_sum
code: theorem exp_sum {α : Type*} (s : Finset α) (f : α → ℂ) :
    exp (∑ x ∈ s, f x) = ∏ x ∈ s, exp (f x) 
goal: Complex.exp (∑ x ∈ s, f x) = ∏ x ∈ s, Complex.exp (f x)

full_name: Complex.exp_nsmul
code: lemma exp_nsmul (x : ℂ) (n : ℕ) : exp (n • x) = exp x ^ n 
goal: Complex.exp (n • x) = Complex.exp x ^ n

full_name: Complex.exp_nat_mul
code: theorem exp_nat_mul (x : ℂ) : ∀ n : ℕ, exp (n * x) = exp x ^ n
  
goal: Complex.exp (↑n * x) = Complex.exp x ^ n

full_name: Complex.exp_ne_zero
code: @[simp]
theorem exp_ne_zero : exp x ≠ 0 
goal: Complex.exp x ≠ 0

full_name: Complex.exp_neg
code: theorem exp_neg : exp (-x) = (exp x)⁻¹ 
goal: Complex.exp (-x) = (Complex.exp x)⁻¹

full_name: Complex.exp_sub
code: theorem exp_sub : exp (x - y) = exp x / exp y 
goal: Complex.exp (x - y) = Complex.exp x / Complex.exp y

full_name: Complex.exp_int_mul
code: theorem exp_int_mul (z : ℂ) (n : ℤ) : Complex.exp (n * z) = Complex.exp z ^ n 
goal: Complex.exp (↑n * z) = Complex.exp z ^ n

full_name: Complex.exp_conj
code: @[simp]
theorem exp_conj : exp (conj x) = conj (exp x) 
goal: Complex.exp ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.exp x)

full_name: Complex.ofReal_exp_ofReal_re
code: @[simp]
theorem ofReal_exp_ofReal_re (x : ℝ) : ((exp x).re : ℂ) = exp x 
goal: ↑(Complex.exp ↑x).re = Complex.exp ↑x

full_name: Complex.ofReal_exp
code: @[simp, norm_cast]
theorem ofReal_exp (x : ℝ) : (Real.exp x : ℂ) = exp x 
goal: ↑(Real.exp x) = Complex.exp ↑x

full_name: Complex.exp_ofReal_im
code: @[simp]
theorem exp_ofReal_im (x : ℝ) : (exp x).im = 0 
goal: (Complex.exp ↑x).im = 0

full_name: Complex.exp_ofReal_re
code: theorem exp_ofReal_re (x : ℝ) : (exp x).re = Real.exp x 
goal: (Complex.exp ↑x).re = Real.exp x

full_name: Complex.two_sinh
code: theorem two_sinh : 2 * sinh x = exp x - exp (-x) 
goal: 2 * Complex.sinh x = Complex.exp x - Complex.exp (-x)

full_name: Complex.two_cosh
code: theorem two_cosh : 2 * cosh x = exp x + exp (-x) 
goal: 2 * Complex.cosh x = Complex.exp x + Complex.exp (-x)

full_name: Complex.sinh_zero
code: @[simp]
theorem sinh_zero : sinh 0 = 0 
goal: Complex.sinh 0 = 0

full_name: Complex.sinh_neg
code: @[simp]
theorem sinh_neg : sinh (-x) = -sinh x 
goal: Complex.sinh (-x) = -Complex.sinh x

full_name: _private.Mathlib.Data.Complex.Exponential.0.Complex.sinh_add_aux
code: private theorem sinh_add_aux {a b c d : ℂ} :
    (a - b) * (c + d) + (a + b) * (c - d) = 2 * (a * c - b * d) 
goal: (a - b) * (c + d) + (a + b) * (c - d) = 2 * (a * c - b * d)

full_name: Complex.sinh_add
code: theorem sinh_add : sinh (x + y) = sinh x * cosh y + cosh x * sinh y 
goal: Complex.sinh (x + y) = Complex.sinh x * Complex.cosh y + Complex.cosh x * Complex.sinh y

full_name: Complex.cosh_zero
code: @[simp]
theorem cosh_zero : cosh 0 = 1 
goal: Complex.cosh 0 = 1

full_name: Complex.cosh_neg
code: @[simp]
theorem cosh_neg : cosh (-x) = cosh x 
goal: Complex.cosh (-x) = Complex.cosh x

full_name: _private.Mathlib.Data.Complex.Exponential.0.Complex.cosh_add_aux
code: private theorem cosh_add_aux {a b c d : ℂ} :
    (a + b) * (c + d) + (a - b) * (c - d) = 2 * (a * c + b * d) 
goal: (a + b) * (c + d) + (a - b) * (c - d) = 2 * (a * c + b * d)

full_name: Complex.cosh_add
code: theorem cosh_add : cosh (x + y) = cosh x * cosh y + sinh x * sinh y 
goal: Complex.cosh (x + y) = Complex.cosh x * Complex.cosh y + Complex.sinh x * Complex.sinh y

full_name: Complex.sinh_sub
code: theorem sinh_sub : sinh (x - y) = sinh x * cosh y - cosh x * sinh y 
goal: Complex.sinh (x - y) = Complex.sinh x * Complex.cosh y - Complex.cosh x * Complex.sinh y

full_name: Complex.cosh_sub
code: theorem cosh_sub : cosh (x - y) = cosh x * cosh y - sinh x * sinh y 
goal: Complex.cosh (x - y) = Complex.cosh x * Complex.cosh y - Complex.sinh x * Complex.sinh y

full_name: Complex.sinh_conj
code: theorem sinh_conj : sinh (conj x) = conj (sinh x) 
goal: Complex.sinh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.sinh x)

full_name: Complex.ofReal_sinh_ofReal_re
code: @[simp]
theorem ofReal_sinh_ofReal_re (x : ℝ) : ((sinh x).re : ℂ) = sinh x 
goal: ↑(Complex.sinh ↑x).re = Complex.sinh ↑x

full_name: Complex.ofReal_sinh
code: @[simp, norm_cast]
theorem ofReal_sinh (x : ℝ) : (Real.sinh x : ℂ) = sinh x 
goal: ↑(Real.sinh x) = Complex.sinh ↑x

full_name: Complex.sinh_ofReal_im
code: @[simp]
theorem sinh_ofReal_im (x : ℝ) : (sinh x).im = 0 
goal: (Complex.sinh ↑x).im = 0

full_name: Complex.sinh_ofReal_re
code: theorem sinh_ofReal_re (x : ℝ) : (sinh x).re = Real.sinh x 
goal: (Complex.sinh ↑x).re = Real.sinh x

full_name: Complex.cosh_conj
code: theorem cosh_conj : cosh (conj x) = conj (cosh x) 
goal: Complex.cosh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.cosh x)

full_name: Complex.ofReal_cosh_ofReal_re
code: theorem ofReal_cosh_ofReal_re (x : ℝ) : ((cosh x).re : ℂ) = cosh x 
goal: ↑(Complex.cosh ↑x).re = Complex.cosh ↑x

full_name: Complex.ofReal_cosh
code: @[simp, norm_cast]
theorem ofReal_cosh (x : ℝ) : (Real.cosh x : ℂ) = cosh x 
goal: ↑(Real.cosh x) = Complex.cosh ↑x

full_name: Complex.cosh_ofReal_im
code: @[simp]
theorem cosh_ofReal_im (x : ℝ) : (cosh x).im = 0 
goal: (Complex.cosh ↑x).im = 0

full_name: Complex.cosh_ofReal_re
code: @[simp]
theorem cosh_ofReal_re (x : ℝ) : (cosh x).re = Real.cosh x 
goal: (Complex.cosh ↑x).re = Real.cosh x

full_name: Complex.tanh_eq_sinh_div_cosh
code: theorem tanh_eq_sinh_div_cosh : tanh x = sinh x / cosh x 
goal: Complex.tanh x = Complex.sinh x / Complex.cosh x

full_name: Complex.tanh_zero
code: @[simp]
theorem tanh_zero : tanh 0 = 0 
goal: Complex.tanh 0 = 0

full_name: Complex.tanh_neg
code: @[simp]
theorem tanh_neg : tanh (-x) = -tanh x 
goal: Complex.tanh (-x) = -Complex.tanh x

full_name: Complex.tanh_conj
code: theorem tanh_conj : tanh (conj x) = conj (tanh x) 
goal: Complex.tanh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.tanh x)

full_name: Complex.ofReal_tanh_ofReal_re
code: @[simp]
theorem ofReal_tanh_ofReal_re (x : ℝ) : ((tanh x).re : ℂ) = tanh x 
goal: ↑(Complex.tanh ↑x).re = Complex.tanh ↑x

full_name: Complex.ofReal_tanh
code: @[simp, norm_cast]
theorem ofReal_tanh (x : ℝ) : (Real.tanh x : ℂ) = tanh x 
goal: ↑(Real.tanh x) = Complex.tanh ↑x

full_name: Complex.tanh_ofReal_im
code: @[simp]
theorem tanh_ofReal_im (x : ℝ) : (tanh x).im = 0 
goal: (Complex.tanh ↑x).im = 0

full_name: Complex.tanh_ofReal_re
code: theorem tanh_ofReal_re (x : ℝ) : (tanh x).re = Real.tanh x 
goal: (Complex.tanh ↑x).re = Real.tanh x

full_name: Complex.cosh_add_sinh
code: @[simp]
theorem cosh_add_sinh : cosh x + sinh x = exp x 
goal: Complex.cosh x + Complex.sinh x = Complex.exp x

full_name: Complex.sinh_add_cosh
code: @[simp]
theorem sinh_add_cosh : sinh x + cosh x = exp x 
goal: Complex.sinh x + Complex.cosh x = Complex.exp x

full_name: Complex.exp_sub_cosh
code: @[simp]
theorem exp_sub_cosh : exp x - cosh x = sinh x 
goal: Complex.exp x - Complex.cosh x = Complex.sinh x

full_name: Complex.exp_sub_sinh
code: @[simp]
theorem exp_sub_sinh : exp x - sinh x = cosh x 
goal: Complex.exp x - Complex.sinh x = Complex.cosh x

full_name: Complex.cosh_sub_sinh
code: @[simp]
theorem cosh_sub_sinh : cosh x - sinh x = exp (-x) 
goal: Complex.cosh x - Complex.sinh x = Complex.exp (-x)

full_name: Complex.sinh_sub_cosh
code: @[simp]
theorem sinh_sub_cosh : sinh x - cosh x = -exp (-x) 
goal: Complex.sinh x - Complex.cosh x = -Complex.exp (-x)

full_name: Complex.cosh_sq_sub_sinh_sq
code: @[simp]
theorem cosh_sq_sub_sinh_sq : cosh x ^ 2 - sinh x ^ 2 = 1 
goal: Complex.cosh x ^ 2 - Complex.sinh x ^ 2 = 1

full_name: Complex.cosh_sq
code: theorem cosh_sq : cosh x ^ 2 = sinh x ^ 2 + 1 
goal: Complex.cosh x ^ 2 = Complex.sinh x ^ 2 + 1

full_name: Complex.sinh_sq
code: theorem sinh_sq : sinh x ^ 2 = cosh x ^ 2 - 1 
goal: Complex.sinh x ^ 2 = Complex.cosh x ^ 2 - 1

full_name: Complex.cosh_two_mul
code: theorem cosh_two_mul : cosh (2 * x) = cosh x ^ 2 + sinh x ^ 2 
goal: Complex.cosh (2 * x) = Complex.cosh x ^ 2 + Complex.sinh x ^ 2

full_name: Complex.sinh_two_mul
code: theorem sinh_two_mul : sinh (2 * x) = 2 * sinh x * cosh x 
goal: Complex.sinh (2 * x) = 2 * Complex.sinh x * Complex.cosh x

full_name: Complex.cosh_three_mul
code: theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x 
goal: Complex.cosh (3 * x) = 4 * Complex.cosh x ^ 3 - 3 * Complex.cosh x

full_name: Complex.sinh_three_mul
code: theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x 
goal: Complex.sinh (3 * x) = 4 * Complex.sinh x ^ 3 + 3 * Complex.sinh x

full_name: Complex.sin_zero
code: @[simp]
theorem sin_zero : sin 0 = 0 
goal: Complex.sin 0 = 0

full_name: Complex.sin_neg
code: @[simp]
theorem sin_neg : sin (-x) = -sin x 
goal: Complex.sin (-x) = -Complex.sin x

full_name: Complex.two_sin
code: theorem two_sin : 2 * sin x = (exp (-x * I) - exp (x * I)) * I 
goal: 2 * Complex.sin x = (Complex.exp (-x * Complex.I) - Complex.exp (x * Complex.I)) * Complex.I

full_name: Complex.two_cos
code: theorem two_cos : 2 * cos x = exp (x * I) + exp (-x * I) 
goal: 2 * Complex.cos x = Complex.exp (x * Complex.I) + Complex.exp (-x * Complex.I)

full_name: Complex.sinh_mul_I
code: theorem sinh_mul_I : sinh (x * I) = sin x * I 
goal: Complex.sinh (x * Complex.I) = Complex.sin x * Complex.I

full_name: Complex.cosh_mul_I
code: theorem cosh_mul_I : cosh (x * I) = cos x 
goal: Complex.cosh (x * Complex.I) = Complex.cos x

full_name: Complex.tanh_mul_I
code: theorem tanh_mul_I : tanh (x * I) = tan x * I 
goal: Complex.tanh (x * Complex.I) = Complex.tan x * Complex.I

full_name: Complex.cos_mul_I
code: theorem cos_mul_I : cos (x * I) = cosh x 
goal: Complex.cos (x * Complex.I) = Complex.cosh x

full_name: Complex.sin_mul_I
code: theorem sin_mul_I : sin (x * I) = sinh x * I 
goal: Complex.sin (x * Complex.I) = Complex.sinh x * Complex.I

full_name: Complex.tan_mul_I
code: theorem tan_mul_I : tan (x * I) = tanh x * I 
goal: Complex.tan (x * Complex.I) = Complex.tanh x * Complex.I

full_name: Complex.sin_add
code: theorem sin_add : sin (x + y) = sin x * cos y + cos x * sin y 
goal: Complex.sin (x + y) = Complex.sin x * Complex.cos y + Complex.cos x * Complex.sin y

full_name: Complex.cos_zero
code: @[simp]
theorem cos_zero : cos 0 = 1 
goal: Complex.cos 0 = 1

full_name: Complex.cos_neg
code: @[simp]
theorem cos_neg : cos (-x) = cos x 
goal: Complex.cos (-x) = Complex.cos x

full_name: _private.Mathlib.Data.Complex.Exponential.0.Complex.cos_add_aux
code: private theorem cos_add_aux {a b c d : ℂ} :
    (a + b) * (c + d) - (b - a) * (d - c) * -1 = 2 * (a * c + b * d) 
goal: (a + b) * (c + d) - (b - a) * (d - c) * -1 = 2 * (a * c + b * d)

full_name: Complex.cos_add
code: theorem cos_add : cos (x + y) = cos x * cos y - sin x * sin y 
goal: Complex.cos (x + y) = Complex.cos x * Complex.cos y - Complex.sin x * Complex.sin y

full_name: Complex.sin_sub
code: theorem sin_sub : sin (x - y) = sin x * cos y - cos x * sin y 
goal: Complex.sin (x - y) = Complex.sin x * Complex.cos y - Complex.cos x * Complex.sin y

full_name: Complex.cos_sub
code: theorem cos_sub : cos (x - y) = cos x * cos y + sin x * sin y 
goal: Complex.cos (x - y) = Complex.cos x * Complex.cos y + Complex.sin x * Complex.sin y

full_name: Complex.sin_add_mul_I
code: theorem sin_add_mul_I (x y : ℂ) : sin (x + y * I) = sin x * cosh y + cos x * sinh y * I 
goal: Complex.sin (x + y * Complex.I) = Complex.sin x * Complex.cosh y + Complex.cos x * Complex.sinh y * Complex.I

full_name: Complex.sin_eq
code: theorem sin_eq (z : ℂ) : sin z = sin z.re * cosh z.im + cos z.re * sinh z.im * I 
goal: Complex.sin z = Complex.sin ↑z.re * Complex.cosh ↑z.im + Complex.cos ↑z.re * Complex.sinh ↑z.im * Complex.I

full_name: Complex.cos_add_mul_I
code: theorem cos_add_mul_I (x y : ℂ) : cos (x + y * I) = cos x * cosh y - sin x * sinh y * I 
goal: Complex.cos (x + y * Complex.I) = Complex.cos x * Complex.cosh y - Complex.sin x * Complex.sinh y * Complex.I

full_name: Complex.cos_eq
code: theorem cos_eq (z : ℂ) : cos z = cos z.re * cosh z.im - sin z.re * sinh z.im * I 
goal: Complex.cos z = Complex.cos ↑z.re * Complex.cosh ↑z.im - Complex.sin ↑z.re * Complex.sinh ↑z.im * Complex.I

full_name: Complex.sin_sub_sin
code: theorem sin_sub_sin : sin x - sin y = 2 * sin ((x - y) / 2) * cos ((x + y) / 2) 
goal: Complex.sin x - Complex.sin y = 2 * Complex.sin ((x - y) / 2) * Complex.cos ((x + y) / 2)

full_name: Complex.cos_sub_cos
code: theorem cos_sub_cos : cos x - cos y = -2 * sin ((x + y) / 2) * sin ((x - y) / 2) 
goal: Complex.cos x - Complex.cos y = -2 * Complex.sin ((x + y) / 2) * Complex.sin ((x - y) / 2)

full_name: Complex.sin_add_sin
code: theorem sin_add_sin : sin x + sin y = 2 * sin ((x + y) / 2) * cos ((x - y) / 2) 
goal: Complex.sin x + Complex.sin y = 2 * Complex.sin ((x + y) / 2) * Complex.cos ((x - y) / 2)

full_name: Complex.cos_add_cos
code: theorem cos_add_cos : cos x + cos y = 2 * cos ((x + y) / 2) * cos ((x - y) / 2) 
goal: Complex.cos x + Complex.cos y = 2 * Complex.cos ((x + y) / 2) * Complex.cos ((x - y) / 2)

full_name: Complex.sin_conj
code: theorem sin_conj : sin (conj x) = conj (sin x) 
goal: Complex.sin ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.sin x)

full_name: Complex.ofReal_sin_ofReal_re
code: @[simp]
theorem ofReal_sin_ofReal_re (x : ℝ) : ((sin x).re : ℂ) = sin x 
goal: ↑(Complex.sin ↑x).re = Complex.sin ↑x

full_name: Complex.ofReal_sin
code: @[simp, norm_cast]
theorem ofReal_sin (x : ℝ) : (Real.sin x : ℂ) = sin x 
goal: ↑(Real.sin x) = Complex.sin ↑x

full_name: Complex.sin_ofReal_im
code: @[simp]
theorem sin_ofReal_im (x : ℝ) : (sin x).im = 0 
goal: (Complex.sin ↑x).im = 0

full_name: Complex.sin_ofReal_re
code: theorem sin_ofReal_re (x : ℝ) : (sin x).re = Real.sin x 
goal: (Complex.sin ↑x).re = Real.sin x

full_name: Complex.cos_conj
code: theorem cos_conj : cos (conj x) = conj (cos x) 
goal: Complex.cos ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.cos x)

full_name: Complex.ofReal_cos_ofReal_re
code: @[simp]
theorem ofReal_cos_ofReal_re (x : ℝ) : ((cos x).re : ℂ) = cos x 
goal: ↑(Complex.cos ↑x).re = Complex.cos ↑x

full_name: Complex.ofReal_cos
code: @[simp, norm_cast]
theorem ofReal_cos (x : ℝ) : (Real.cos x : ℂ) = cos x 
goal: ↑(Real.cos x) = Complex.cos ↑x

full_name: Complex.cos_ofReal_im
code: @[simp]
theorem cos_ofReal_im (x : ℝ) : (cos x).im = 0 
goal: (Complex.cos ↑x).im = 0

full_name: Complex.cos_ofReal_re
code: theorem cos_ofReal_re (x : ℝ) : (cos x).re = Real.cos x 
goal: (Complex.cos ↑x).re = Real.cos x

full_name: Complex.tan_zero
code: @[simp]
theorem tan_zero : tan 0 = 0 
goal: Complex.tan 0 = 0

full_name: Complex.tan_eq_sin_div_cos
code: theorem tan_eq_sin_div_cos : tan x = sin x / cos x 
goal: Complex.tan x = Complex.sin x / Complex.cos x

full_name: Complex.cot_eq_cos_div_sin
code: theorem cot_eq_cos_div_sin : cot x = cos x / sin x 
goal: x.cot = Complex.cos x / Complex.sin x

full_name: Complex.tan_mul_cos
code: theorem tan_mul_cos {x : ℂ} (hx : cos x ≠ 0) : tan x * cos x = sin x 
goal: Complex.tan x * Complex.cos x = Complex.sin x

full_name: Complex.tan_neg
code: @[simp]
theorem tan_neg : tan (-x) = -tan x 
goal: Complex.tan (-x) = -Complex.tan x

full_name: Complex.tan_conj
code: theorem tan_conj : tan (conj x) = conj (tan x) 
goal: Complex.tan ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.tan x)

full_name: Complex.cot_conj
code: theorem cot_conj : cot (conj x) = conj (cot x) 
goal: ((starRingEnd ℂ) x).cot = (starRingEnd ℂ) x.cot

full_name: Complex.ofReal_tan_ofReal_re
code: @[simp]
theorem ofReal_tan_ofReal_re (x : ℝ) : ((tan x).re : ℂ) = tan x 
goal: ↑(Complex.tan ↑x).re = Complex.tan ↑x

full_name: Complex.ofReal_cot_ofReal_re
code: @[simp]
theorem ofReal_cot_ofReal_re (x : ℝ) : ((cot x).re : ℂ) = cot x 
goal: ↑(↑x).cot.re = (↑x).cot

full_name: Complex.ofReal_tan
code: @[simp, norm_cast]
theorem ofReal_tan (x : ℝ) : (Real.tan x : ℂ) = tan x 
goal: ↑(Real.tan x) = Complex.tan ↑x

full_name: Complex.ofReal_cot
code: @[simp, norm_cast]
theorem ofReal_cot (x : ℝ) : (Real.cot x : ℂ) = cot x 
goal: ↑x.cot = (↑x).cot

full_name: Complex.tan_ofReal_im
code: @[simp]
theorem tan_ofReal_im (x : ℝ) : (tan x).im = 0 
goal: (Complex.tan ↑x).im = 0

full_name: Complex.tan_ofReal_re
code: theorem tan_ofReal_re (x : ℝ) : (tan x).re = Real.tan x 
goal: (Complex.tan ↑x).re = Real.tan x

full_name: Complex.cos_add_sin_I
code: theorem cos_add_sin_I : cos x + sin x * I = exp (x * I) 
goal: Complex.cos x + Complex.sin x * Complex.I = Complex.exp (x * Complex.I)

full_name: Complex.cos_sub_sin_I
code: theorem cos_sub_sin_I : cos x - sin x * I = exp (-x * I) 
goal: Complex.cos x - Complex.sin x * Complex.I = Complex.exp (-x * Complex.I)

full_name: Complex.sin_sq_add_cos_sq
code: @[simp]
theorem sin_sq_add_cos_sq : sin x ^ 2 + cos x ^ 2 = 1 
goal: Complex.sin x ^ 2 + Complex.cos x ^ 2 = 1

full_name: Complex.cos_sq_add_sin_sq
code: @[simp]
theorem cos_sq_add_sin_sq : cos x ^ 2 + sin x ^ 2 = 1 
goal: Complex.cos x ^ 2 + Complex.sin x ^ 2 = 1

full_name: Complex.cos_two_mul'
code: theorem cos_two_mul' : cos (2 * x) = cos x ^ 2 - sin x ^ 2 
goal: Complex.cos (2 * x) = Complex.cos x ^ 2 - Complex.sin x ^ 2

full_name: Complex.cos_two_mul
code: theorem cos_two_mul : cos (2 * x) = 2 * cos x ^ 2 - 1 
goal: Complex.cos (2 * x) = 2 * Complex.cos x ^ 2 - 1

full_name: Complex.sin_two_mul
code: theorem sin_two_mul : sin (2 * x) = 2 * sin x * cos x 
goal: Complex.sin (2 * x) = 2 * Complex.sin x * Complex.cos x

full_name: Complex.cos_sq
code: theorem cos_sq : cos x ^ 2 = 1 / 2 + cos (2 * x) / 2 
goal: Complex.cos x ^ 2 = 1 / 2 + Complex.cos (2 * x) / 2

full_name: Complex.cos_sq'
code: theorem cos_sq' : cos x ^ 2 = 1 - sin x ^ 2 
goal: Complex.cos x ^ 2 = 1 - Complex.sin x ^ 2

full_name: Complex.sin_sq
code: theorem sin_sq : sin x ^ 2 = 1 - cos x ^ 2 
goal: Complex.sin x ^ 2 = 1 - Complex.cos x ^ 2

full_name: Complex.inv_one_add_tan_sq
code: theorem inv_one_add_tan_sq {x : ℂ} (hx : cos x ≠ 0) : (1 + tan x ^ 2)⁻¹ = cos x ^ 2 
goal: (1 + Complex.tan x ^ 2)⁻¹ = Complex.cos x ^ 2

full_name: Complex.tan_sq_div_one_add_tan_sq
code: theorem tan_sq_div_one_add_tan_sq {x : ℂ} (hx : cos x ≠ 0) :
    tan x ^ 2 / (1 + tan x ^ 2) = sin x ^ 2 
goal: Complex.tan x ^ 2 / (1 + Complex.tan x ^ 2) = Complex.sin x ^ 2

full_name: Complex.cos_three_mul
code: theorem cos_three_mul : cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x 
goal: Complex.cos (3 * x) = 4 * Complex.cos x ^ 3 - 3 * Complex.cos x

full_name: Complex.sin_three_mul
code: theorem sin_three_mul : sin (3 * x) = 3 * sin x - 4 * sin x ^ 3 
goal: Complex.sin (3 * x) = 3 * Complex.sin x - 4 * Complex.sin x ^ 3

full_name: Complex.exp_mul_I
code: theorem exp_mul_I : exp (x * I) = cos x + sin x * I 
goal: Complex.exp (x * Complex.I) = Complex.cos x + Complex.sin x * Complex.I

full_name: Complex.exp_add_mul_I
code: theorem exp_add_mul_I : exp (x + y * I) = exp x * (cos y + sin y * I) 
goal: Complex.exp (x + y * Complex.I) = Complex.exp x * (Complex.cos y + Complex.sin y * Complex.I)

full_name: Complex.exp_eq_exp_re_mul_sin_add_cos
code: theorem exp_eq_exp_re_mul_sin_add_cos : exp x = exp x.re * (cos x.im + sin x.im * I) 
goal: Complex.exp x = Complex.exp ↑x.re * (Complex.cos ↑x.im + Complex.sin ↑x.im * Complex.I)

full_name: Complex.exp_re
code: theorem exp_re : (exp x).re = Real.exp x.re * Real.cos x.im 
goal: (Complex.exp x).re = Real.exp x.re * Real.cos x.im

full_name: Complex.exp_im
code: theorem exp_im : (exp x).im = Real.exp x.re * Real.sin x.im 
goal: (Complex.exp x).im = Real.exp x.re * Real.sin x.im

full_name: Complex.exp_ofReal_mul_I_re
code: @[simp]
theorem exp_ofReal_mul_I_re (x : ℝ) : (exp (x * I)).re = Real.cos x 
goal: (Complex.exp (↑x * Complex.I)).re = Real.cos x

full_name: Complex.exp_ofReal_mul_I_im
code: @[simp]
theorem exp_ofReal_mul_I_im (x : ℝ) : (exp (x * I)).im = Real.sin x 
goal: (Complex.exp (↑x * Complex.I)).im = Real.sin x

full_name: Complex.cos_add_sin_mul_I_pow
code: /-- **De Moivre's formula** -/
theorem cos_add_sin_mul_I_pow (n : ℕ) (z : ℂ) :
    (cos z + sin z * I) ^ n = cos (↑n * z) + sin (↑n * z) * I 
goal: (Complex.cos z + Complex.sin z * Complex.I) ^ n = Complex.cos (↑n * z) + Complex.sin (↑n * z) * Complex.I

full_name: Real.exp_zero
code: @[simp]
theorem exp_zero : exp 0 = 1 
goal: Real.exp 0 = 1

full_name: Real.exp_add
code: nonrec theorem exp_add : exp (x + y) = exp x * exp y 
goal: Real.exp (x + y) = Real.exp x * Real.exp y

full_name: Real.expMonoidHom
code: /-- the exponential function as a monoid hom from `Multiplicative ℝ` to `ℝ` -/
noncomputable def expMonoidHom : MonoidHom (Multiplicative ℝ) ℝ 
goal: Multiplicative ℝ →* ℝ

full_name: Real.exp_list_sum
code: theorem exp_list_sum (l : List ℝ) : exp l.sum = (l.map exp).prod 
goal: Real.exp l.sum = (List.map Real.exp l).prod

full_name: Real.exp_multiset_sum
code: theorem exp_multiset_sum (s : Multiset ℝ) : exp s.sum = (s.map exp).prod 
goal: Real.exp s.sum = (Multiset.map Real.exp s).prod

full_name: Real.exp_sum
code: theorem exp_sum {α : Type*} (s : Finset α) (f : α → ℝ) :
    exp (∑ x ∈ s, f x) = ∏ x ∈ s, exp (f x) 
goal: Real.exp (∑ x ∈ s, f x) = ∏ x ∈ s, Real.exp (f x)

full_name: Real.exp_nsmul
code: lemma exp_nsmul (x : ℝ) (n : ℕ) : exp (n • x) = exp x ^ n 
goal: Real.exp (n • x) = Real.exp x ^ n

full_name: Real.exp_nat_mul
code: nonrec theorem exp_nat_mul (x : ℝ) (n : ℕ) : exp (n * x) = exp x ^ n 
goal: Real.exp (↑n * x) = Real.exp x ^ n

full_name: Real.exp_ne_zero
code: @[simp]
nonrec theorem exp_ne_zero : exp x ≠ 0 
goal: Real.exp x ≠ 0

full_name: Real.exp_neg
code: nonrec theorem exp_neg : exp (-x) = (exp x)⁻¹ 
goal: Real.exp (-x) = (Real.exp x)⁻¹

full_name: Real.exp_sub
code: theorem exp_sub : exp (x - y) = exp x / exp y 
goal: Real.exp (x - y) = Real.exp x / Real.exp y

full_name: Real.sin_zero
code: @[simp]
theorem sin_zero : sin 0 = 0 
goal: Real.sin 0 = 0

full_name: Real.sin_neg
code: @[simp]
theorem sin_neg : sin (-x) = -sin x 
goal: Real.sin (-x) = -Real.sin x

full_name: Real.sin_add
code: nonrec theorem sin_add : sin (x + y) = sin x * cos y + cos x * sin y 
goal: Real.sin (x + y) = Real.sin x * Real.cos y + Real.cos x * Real.sin y

full_name: Real.cos_zero
code: @[simp]
theorem cos_zero : cos 0 = 1 
goal: Real.cos 0 = 1

full_name: Real.cos_neg
code: @[simp]
theorem cos_neg : cos (-x) = cos x 
goal: Real.cos (-x) = Real.cos x

full_name: Real.cos_abs
code: @[simp]
theorem cos_abs : cos |x| = cos x 
goal: Real.cos |x| = Real.cos x

full_name: Real.cos_add
code: nonrec theorem cos_add : cos (x + y) = cos x * cos y - sin x * sin y 
goal: Real.cos (x + y) = Real.cos x * Real.cos y - Real.sin x * Real.sin y

full_name: Real.sin_sub
code: theorem sin_sub : sin (x - y) = sin x * cos y - cos x * sin y 
goal: Real.sin (x - y) = Real.sin x * Real.cos y - Real.cos x * Real.sin y

full_name: Real.cos_sub
code: theorem cos_sub : cos (x - y) = cos x * cos y + sin x * sin y 
goal: Real.cos (x - y) = Real.cos x * Real.cos y + Real.sin x * Real.sin y

full_name: Real.sin_sub_sin
code: nonrec theorem sin_sub_sin : sin x - sin y = 2 * sin ((x - y) / 2) * cos ((x + y) / 2) 
goal: Real.sin x - Real.sin y = 2 * Real.sin ((x - y) / 2) * Real.cos ((x + y) / 2)

full_name: Real.cos_sub_cos
code: nonrec theorem cos_sub_cos : cos x - cos y = -2 * sin ((x + y) / 2) * sin ((x - y) / 2) 
goal: Real.cos x - Real.cos y = -2 * Real.sin ((x + y) / 2) * Real.sin ((x - y) / 2)

full_name: Real.cos_add_cos
code: nonrec theorem cos_add_cos : cos x + cos y = 2 * cos ((x + y) / 2) * cos ((x - y) / 2) 
goal: Real.cos x + Real.cos y = 2 * Real.cos ((x + y) / 2) * Real.cos ((x - y) / 2)

full_name: Real.tan_eq_sin_div_cos
code: nonrec theorem tan_eq_sin_div_cos : tan x = sin x / cos x 
goal: Real.tan x = Real.sin x / Real.cos x

full_name: Real.cot_eq_cos_div_sin
code: nonrec theorem cot_eq_cos_div_sin : cot x = cos x / sin x 
goal: x.cot = Real.cos x / Real.sin x

full_name: Real.tan_mul_cos
code: theorem tan_mul_cos {x : ℝ} (hx : cos x ≠ 0) : tan x * cos x = sin x 
goal: Real.tan x * Real.cos x = Real.sin x

full_name: Real.tan_zero
code: @[simp]
theorem tan_zero : tan 0 = 0 
goal: Real.tan 0 = 0

full_name: Real.tan_neg
code: @[simp]
theorem tan_neg : tan (-x) = -tan x 
goal: Real.tan (-x) = -Real.tan x

full_name: Real.sin_sq_add_cos_sq
code: @[simp]
nonrec theorem sin_sq_add_cos_sq : sin x ^ 2 + cos x ^ 2 = 1 
goal: Real.sin x ^ 2 + Real.cos x ^ 2 = 1

full_name: Real.cos_sq_add_sin_sq
code: @[simp]
theorem cos_sq_add_sin_sq : cos x ^ 2 + sin x ^ 2 = 1 
goal: Real.cos x ^ 2 + Real.sin x ^ 2 = 1

full_name: Real.sin_sq_le_one
code: theorem sin_sq_le_one : sin x ^ 2 ≤ 1 
goal: Real.sin x ^ 2 ≤ 1

full_name: Real.cos_sq_le_one
code: theorem cos_sq_le_one : cos x ^ 2 ≤ 1 
goal: Real.cos x ^ 2 ≤ 1

full_name: Real.abs_sin_le_one
code: theorem abs_sin_le_one : |sin x| ≤ 1 
goal: |Real.sin x| ≤ 1

full_name: Real.abs_cos_le_one
code: theorem abs_cos_le_one : |cos x| ≤ 1 
goal: |Real.cos x| ≤ 1

full_name: Real.sin_le_one
code: theorem sin_le_one : sin x ≤ 1 
goal: Real.sin x ≤ 1

full_name: Real.cos_le_one
code: theorem cos_le_one : cos x ≤ 1 
goal: Real.cos x ≤ 1

full_name: Real.neg_one_le_sin
code: theorem neg_one_le_sin : -1 ≤ sin x 
goal: -1 ≤ Real.sin x

full_name: Real.neg_one_le_cos
code: theorem neg_one_le_cos : -1 ≤ cos x 
goal: -1 ≤ Real.cos x

full_name: Real.cos_two_mul
code: nonrec theorem cos_two_mul : cos (2 * x) = 2 * cos x ^ 2 - 1 
goal: Real.cos (2 * x) = 2 * Real.cos x ^ 2 - 1

full_name: Real.cos_two_mul'
code: nonrec theorem cos_two_mul' : cos (2 * x) = cos x ^ 2 - sin x ^ 2 
goal: Real.cos (2 * x) = Real.cos x ^ 2 - Real.sin x ^ 2

full_name: Real.sin_two_mul
code: nonrec theorem sin_two_mul : sin (2 * x) = 2 * sin x * cos x 
goal: Real.sin (2 * x) = 2 * Real.sin x * Real.cos x

full_name: Real.cos_sq
code: nonrec theorem cos_sq : cos x ^ 2 = 1 / 2 + cos (2 * x) / 2 
goal: Real.cos x ^ 2 = 1 / 2 + Real.cos (2 * x) / 2

full_name: Real.cos_sq'
code: theorem cos_sq' : cos x ^ 2 = 1 - sin x ^ 2 
goal: Real.cos x ^ 2 = 1 - Real.sin x ^ 2

full_name: Real.sin_sq
code: theorem sin_sq : sin x ^ 2 = 1 - cos x ^ 2 
goal: Real.sin x ^ 2 = 1 - Real.cos x ^ 2

full_name: Real.sin_sq_eq_half_sub
code: lemma sin_sq_eq_half_sub : sin x ^ 2 = 1 / 2 - cos (2 * x) / 2 
goal: Real.sin x ^ 2 = 1 / 2 - Real.cos (2 * x) / 2

full_name: Real.abs_sin_eq_sqrt_one_sub_cos_sq
code: theorem abs_sin_eq_sqrt_one_sub_cos_sq (x : ℝ) : |sin x| = √(1 - cos x ^ 2) 
goal: |Real.sin x| = √(1 - Real.cos x ^ 2)

full_name: Real.abs_cos_eq_sqrt_one_sub_sin_sq
code: theorem abs_cos_eq_sqrt_one_sub_sin_sq (x : ℝ) : |cos x| = √(1 - sin x ^ 2) 
goal: |Real.cos x| = √(1 - Real.sin x ^ 2)

full_name: Real.inv_one_add_tan_sq
code: theorem inv_one_add_tan_sq {x : ℝ} (hx : cos x ≠ 0) : (1 + tan x ^ 2)⁻¹ = cos x ^ 2 
goal: (1 + Real.tan x ^ 2)⁻¹ = Real.cos x ^ 2

full_name: Real.tan_sq_div_one_add_tan_sq
code: theorem tan_sq_div_one_add_tan_sq {x : ℝ} (hx : cos x ≠ 0) :
    tan x ^ 2 / (1 + tan x ^ 2) = sin x ^ 2 
goal: Real.tan x ^ 2 / (1 + Real.tan x ^ 2) = Real.sin x ^ 2

full_name: Real.inv_sqrt_one_add_tan_sq
code: theorem inv_sqrt_one_add_tan_sq {x : ℝ} (hx : 0 < cos x) : (√(1 + tan x ^ 2))⁻¹ = cos x 
goal: (√(1 + Real.tan x ^ 2))⁻¹ = Real.cos x

full_name: Real.tan_div_sqrt_one_add_tan_sq
code: theorem tan_div_sqrt_one_add_tan_sq {x : ℝ} (hx : 0 < cos x) :
    tan x / √(1 + tan x ^ 2) = sin x 
goal: Real.tan x / √(1 + Real.tan x ^ 2) = Real.sin x

full_name: Real.cos_three_mul
code: nonrec theorem cos_three_mul : cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x 
goal: Real.cos (3 * x) = 4 * Real.cos x ^ 3 - 3 * Real.cos x

full_name: Real.sin_three_mul
code: nonrec theorem sin_three_mul : sin (3 * x) = 3 * sin x - 4 * sin x ^ 3 
goal: Real.sin (3 * x) = 3 * Real.sin x - 4 * Real.sin x ^ 3

full_name: Real.sinh_eq
code: /-- The definition of `sinh` in terms of `exp`. -/
nonrec theorem sinh_eq (x : ℝ) : sinh x = (exp x - exp (-x)) / 2 
goal: Real.sinh x = (Real.exp x - Real.exp (-x)) / 2

full_name: Real.sinh_zero
code: @[simp]
theorem sinh_zero : sinh 0 = 0 
goal: Real.sinh 0 = 0

full_name: Real.sinh_neg
code: @[simp]
theorem sinh_neg : sinh (-x) = -sinh x 
goal: Real.sinh (-x) = -Real.sinh x

full_name: Real.sinh_add
code: nonrec theorem sinh_add : sinh (x + y) = sinh x * cosh y + cosh x * sinh y 
goal: Real.sinh (x + y) = Real.sinh x * Real.cosh y + Real.cosh x * Real.sinh y

full_name: Real.cosh_eq
code: /-- The definition of `cosh` in terms of `exp`. -/
theorem cosh_eq (x : ℝ) : cosh x = (exp x + exp (-x)) / 2 
goal: Real.cosh x = (Real.exp x + Real.exp (-x)) / 2

full_name: Real.cosh_zero
code: @[simp]
theorem cosh_zero : cosh 0 = 1 
goal: Real.cosh 0 = 1

full_name: Real.cosh_neg
code: @[simp]
theorem cosh_neg : cosh (-x) = cosh x 
goal: Real.cosh (-x) = Real.cosh x

full_name: Real.cosh_abs
code: @[simp]
theorem cosh_abs : cosh |x| = cosh x 
goal: Real.cosh |x| = Real.cosh x

full_name: Real.cosh_add
code: nonrec theorem cosh_add : cosh (x + y) = cosh x * cosh y + sinh x * sinh y 
goal: Real.cosh (x + y) = Real.cosh x * Real.cosh y + Real.sinh x * Real.sinh y

full_name: Real.sinh_sub
code: theorem sinh_sub : sinh (x - y) = sinh x * cosh y - cosh x * sinh y 
goal: Real.sinh (x - y) = Real.sinh x * Real.cosh y - Real.cosh x * Real.sinh y

full_name: Real.cosh_sub
code: theorem cosh_sub : cosh (x - y) = cosh x * cosh y - sinh x * sinh y 
goal: Real.cosh (x - y) = Real.cosh x * Real.cosh y - Real.sinh x * Real.sinh y

full_name: Real.tanh_eq_sinh_div_cosh
code: nonrec theorem tanh_eq_sinh_div_cosh : tanh x = sinh x / cosh x 
goal: Real.tanh x = Real.sinh x / Real.cosh x

full_name: Real.tanh_zero
code: @[simp]
theorem tanh_zero : tanh 0 = 0 
goal: Real.tanh 0 = 0

full_name: Real.tanh_neg
code: @[simp]
theorem tanh_neg : tanh (-x) = -tanh x 
goal: Real.tanh (-x) = -Real.tanh x

full_name: Real.cosh_add_sinh
code: @[simp]
theorem cosh_add_sinh : cosh x + sinh x = exp x 
goal: Real.cosh x + Real.sinh x = Real.exp x

full_name: Real.sinh_add_cosh
code: @[simp]
theorem sinh_add_cosh : sinh x + cosh x = exp x 
goal: Real.sinh x + Real.cosh x = Real.exp x

full_name: Real.exp_sub_cosh
code: @[simp]
theorem exp_sub_cosh : exp x - cosh x = sinh x 
goal: Real.exp x - Real.cosh x = Real.sinh x

full_name: Real.exp_sub_sinh
code: @[simp]
theorem exp_sub_sinh : exp x - sinh x = cosh x 
goal: Real.exp x - Real.sinh x = Real.cosh x

full_name: Real.cosh_sub_sinh
code: @[simp]
theorem cosh_sub_sinh : cosh x - sinh x = exp (-x) 
goal: Real.cosh x - Real.sinh x = Real.exp (-x)

full_name: Real.sinh_sub_cosh
code: @[simp]
theorem sinh_sub_cosh : sinh x - cosh x = -exp (-x) 
goal: Real.sinh x - Real.cosh x = -Real.exp (-x)

full_name: Real.cosh_sq_sub_sinh_sq
code: @[simp]
theorem cosh_sq_sub_sinh_sq (x : ℝ) : cosh x ^ 2 - sinh x ^ 2 = 1 
goal: Real.cosh x ^ 2 - Real.sinh x ^ 2 = 1

full_name: Real.cosh_sq
code: nonrec theorem cosh_sq : cosh x ^ 2 = sinh x ^ 2 + 1 
goal: Real.cosh x ^ 2 = Real.sinh x ^ 2 + 1

full_name: Real.cosh_sq'
code: theorem cosh_sq' : cosh x ^ 2 = 1 + sinh x ^ 2 
goal: Real.cosh x ^ 2 = 1 + Real.sinh x ^ 2

full_name: Real.sinh_sq
code: nonrec theorem sinh_sq : sinh x ^ 2 = cosh x ^ 2 - 1 
goal: Real.sinh x ^ 2 = Real.cosh x ^ 2 - 1

full_name: Real.cosh_two_mul
code: nonrec theorem cosh_two_mul : cosh (2 * x) = cosh x ^ 2 + sinh x ^ 2 
goal: Real.cosh (2 * x) = Real.cosh x ^ 2 + Real.sinh x ^ 2

full_name: Real.sinh_two_mul
code: nonrec theorem sinh_two_mul : sinh (2 * x) = 2 * sinh x * cosh x 
goal: Real.sinh (2 * x) = 2 * Real.sinh x * Real.cosh x

full_name: Real.cosh_three_mul
code: nonrec theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x 
goal: Real.cosh (3 * x) = 4 * Real.cosh x ^ 3 - 3 * Real.cosh x

full_name: Real.sinh_three_mul
code: nonrec theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x 
goal: Real.sinh (3 * x) = 4 * Real.sinh x ^ 3 + 3 * Real.sinh x

full_name: Real.sum_le_exp_of_nonneg
code: theorem sum_le_exp_of_nonneg {x : ℝ} (hx : 0 ≤ x) (n : ℕ) : ∑ i ∈ range n, x ^ i / i ! ≤ exp x 
goal: ∑ i ∈ Finset.range n, x ^ i / ↑i.factorial ≤ Real.exp x

full_name: Real.pow_div_factorial_le_exp
code: lemma pow_div_factorial_le_exp (hx : 0 ≤ x) (n : ℕ) : x ^ n / n ! ≤ exp x 
goal: x ^ n / ↑n.factorial ≤ Real.exp x

full_name: Real.quadratic_le_exp_of_nonneg
code: theorem quadratic_le_exp_of_nonneg {x : ℝ} (hx : 0 ≤ x) : 1 + x + x ^ 2 / 2 ≤ exp x 
goal: 1 + x + x ^ 2 / 2 ≤ Real.exp x

full_name: _private.Mathlib.Data.Complex.Exponential.0.Real.add_one_lt_exp_of_pos
code: private theorem add_one_lt_exp_of_pos {x : ℝ} (hx : 0 < x) : x + 1 < exp x 
goal: x + 1 < Real.exp x

full_name: _private.Mathlib.Data.Complex.Exponential.0.Real.add_one_le_exp_of_nonneg
code: private theorem add_one_le_exp_of_nonneg {x : ℝ} (hx : 0 ≤ x) : x + 1 ≤ exp x 
goal: x + 1 ≤ Real.exp x

full_name: Real.one_le_exp
code: theorem one_le_exp {x : ℝ} (hx : 0 ≤ x) : 1 ≤ exp x 
goal: 1 ≤ Real.exp x

full_name: Real.exp_pos
code: theorem exp_pos (x : ℝ) : 0 < exp x 
goal: 0 < Real.exp x

full_name: Real.exp_nonneg
code: lemma exp_nonneg (x : ℝ) : 0 ≤ exp x 
goal: 0 ≤ Real.exp x

full_name: Real.abs_exp
code: @[simp]
theorem abs_exp (x : ℝ) : |exp x| = exp x 
goal: |Real.exp x| = Real.exp x

full_name: Real.exp_abs_le
code: lemma exp_abs_le (x : ℝ) : exp |x| ≤ exp x + exp (-x) 
goal: Real.exp |x| ≤ Real.exp x + Real.exp (-x)

full_name: Real.exp_strictMono
code: @[mono]
theorem exp_strictMono : StrictMono exp 
goal: StrictMono Real.exp

full_name: Real.exp_lt_exp_of_lt
code: @[gcongr]
theorem exp_lt_exp_of_lt {x y : ℝ} (h : x < y) : exp x < exp y 
goal: Real.exp x < Real.exp y

full_name: Real.exp_monotone
code: @[mono]
theorem exp_monotone : Monotone exp 
goal: Monotone Real.exp

full_name: Real.exp_le_exp_of_le
code: @[gcongr]
theorem exp_le_exp_of_le {x y : ℝ} (h : x ≤ y) : exp x ≤ exp y 
goal: Real.exp x ≤ Real.exp y

full_name: Real.exp_lt_exp
code: @[simp]
theorem exp_lt_exp {x y : ℝ} : exp x < exp y ↔ x < y 
goal: Real.exp x < Real.exp y ↔ x < y

full_name: Real.exp_le_exp
code: @[simp]
theorem exp_le_exp {x y : ℝ} : exp x ≤ exp y ↔ x ≤ y 
goal: Real.exp x ≤ Real.exp y ↔ x ≤ y

full_name: Real.exp_injective
code: theorem exp_injective : Function.Injective exp 
goal: Function.Injective Real.exp

full_name: Real.exp_eq_exp
code: @[simp]
theorem exp_eq_exp {x y : ℝ} : exp x = exp y ↔ x = y 
goal: Real.exp x = Real.exp y ↔ x = y

full_name: Real.exp_eq_one_iff
code: @[simp]
theorem exp_eq_one_iff : exp x = 1 ↔ x = 0 
goal: Real.exp x = 1 ↔ x = 0

full_name: Real.one_lt_exp_iff
code: @[simp]
theorem one_lt_exp_iff {x : ℝ} : 1 < exp x ↔ 0 < x 
goal: 1 < Real.exp x ↔ 0 < x

full_name: Real.exp_lt_one_iff
code: @[simp]
theorem exp_lt_one_iff {x : ℝ} : exp x < 1 ↔ x < 0 
goal: Real.exp x < 1 ↔ x < 0

full_name: Real.exp_le_one_iff
code: @[simp]
theorem exp_le_one_iff {x : ℝ} : exp x ≤ 1 ↔ x ≤ 0 
goal: Real.exp x ≤ 1 ↔ x ≤ 0

full_name: Real.one_le_exp_iff
code: @[simp]
theorem one_le_exp_iff {x : ℝ} : 1 ≤ exp x ↔ 0 ≤ x 
goal: 1 ≤ Real.exp x ↔ 0 ≤ x

full_name: Real.cosh_pos
code: /-- `Real.cosh` is always positive -/
theorem cosh_pos (x : ℝ) : 0 < Real.cosh x 
goal: 0 < Real.cosh x

full_name: Real.sinh_lt_cosh
code: theorem sinh_lt_cosh : sinh x < cosh x 
goal: Real.sinh x < Real.cosh x

full_name: Complex.sum_div_factorial_le
code: theorem sum_div_factorial_le {α : Type*} [LinearOrderedField α] (n j : ℕ) (hn : 0 < n) :
    (∑ m ∈ filter (fun k => n ≤ k) (range j),
      (1 / m.factorial : α)) ≤ n.succ / (n.factorial * n) 
goal: ∑ m ∈ Finset.filter (fun k => n ≤ k) (Finset.range j), 1 / ↑m.factorial ≤ ↑n.succ / (↑n.factorial * ↑n)

full_name: Complex.exp_bound
code: theorem exp_bound {x : ℂ} (hx : abs x ≤ 1) {n : ℕ} (hn : 0 < n) :
    abs (exp x - ∑ m ∈ range n, x ^ m / m.factorial) ≤
      abs x ^ n * ((n.succ : ℝ) * (n.factorial * n : ℝ)⁻¹) 
goal: Complex.abs (Complex.exp x - ∑ m ∈ Finset.range n, x ^ m / ↑m.factorial) ≤
  Complex.abs x ^ n * (↑n.succ * (↑n.factorial * ↑n)⁻¹)

full_name: Complex.exp_bound'
code: theorem exp_bound' {x : ℂ} {n : ℕ} (hx : abs x / n.succ ≤ 1 / 2) :
    abs (exp x - ∑ m ∈ range n, x ^ m / m.factorial) ≤ abs x ^ n / n.factorial * 2 
goal: Complex.abs (Complex.exp x - ∑ m ∈ Finset.range n, x ^ m / ↑m.factorial) ≤ Complex.abs x ^ n / ↑n.factorial * 2

full_name: Complex.abs_exp_sub_one_le
code: theorem abs_exp_sub_one_le {x : ℂ} (hx : abs x ≤ 1) : abs (exp x - 1) ≤ 2 * abs x 
goal: Complex.abs (Complex.exp x - 1) ≤ 2 * Complex.abs x

full_name: Complex.abs_exp_sub_one_sub_id_le
code: theorem abs_exp_sub_one_sub_id_le {x : ℂ} (hx : abs x ≤ 1) : abs (exp x - 1 - x) ≤ abs x ^ 2 
goal: Complex.abs (Complex.exp x - 1 - x) ≤ Complex.abs x ^ 2

full_name: Real.exp_bound
code: nonrec theorem exp_bound {x : ℝ} (hx : |x| ≤ 1) {n : ℕ} (hn : 0 < n) :
    |exp x - ∑ m ∈ range n, x ^ m / m.factorial| ≤ |x| ^ n * (n.succ / (n.factorial * n)) 
goal: |Real.exp x - ∑ m ∈ Finset.range n, x ^ m / ↑m.factorial| ≤ |x| ^ n * (↑n.succ / (↑n.factorial * ↑n))

full_name: Real.exp_bound'
code: theorem exp_bound' {x : ℝ} (h1 : 0 ≤ x) (h2 : x ≤ 1) {n : ℕ} (hn : 0 < n) :
    Real.exp x ≤ (∑ m ∈ Finset.range n, x ^ m / m.factorial) +
      x ^ n * (n + 1) / (n.factorial * n) 
goal: Real.exp x ≤ ∑ m ∈ Finset.range n, x ^ m / ↑m.factorial + x ^ n * (↑n + 1) / (↑n.factorial * ↑n)

full_name: Real.abs_exp_sub_one_le
code: theorem abs_exp_sub_one_le {x : ℝ} (hx : |x| ≤ 1) : |exp x - 1| ≤ 2 * |x| 
goal: |Real.exp x - 1| ≤ 2 * |x|

full_name: Real.abs_exp_sub_one_sub_id_le
code: theorem abs_exp_sub_one_sub_id_le {x : ℝ} (hx : |x| ≤ 1) : |exp x - 1 - x| ≤ x ^ 2 
goal: |Real.exp x - 1 - x| ≤ x ^ 2

full_name: Real.expNear
code: /-- A finite initial segment of the exponential series, followed by an arbitrary tail.
For fixed `n` this is just a linear map wrt `r`, and each map is a simple linear function
of the previous (see `expNear_succ`), with `expNear n x r ⟶ exp x` as `n ⟶ ∞`,
for any `r`. -/
noncomputable def expNear (n : ℕ) (x r : ℝ) : ℝ 
goal: ℝ

full_name: Real.expNear_zero
code: @[simp]
theorem expNear_zero (x r) : expNear 0 x r = r 
goal: Real.expNear 0 x r = r

full_name: Real.expNear_succ
code: @[simp]
theorem expNear_succ (n x r) : expNear (n + 1) x r = expNear n x (1 + x / (n + 1) * r) 
goal: Real.expNear (n + 1) x r = Real.expNear n x (1 + x / (↑n + 1) * r)

full_name: Real.expNear_sub
code: theorem expNear_sub (n x r₁ r₂) : expNear n x r₁ -
    expNear n x r₂ = x ^ n / n.factorial * (r₁ - r₂) 
goal: Real.expNear n x r₁ - Real.expNear n x r₂ = x ^ n / ↑n.factorial * (r₁ - r₂)

full_name: Real.exp_approx_end
code: theorem exp_approx_end (n m : ℕ) (x : ℝ) (e₁ : n + 1 = m) (h : |x| ≤ 1) :
    |exp x - expNear m x 0| ≤ |x| ^ m / m.factorial * ((m + 1) / m) 
goal: |Real.exp x - Real.expNear m x 0| ≤ |x| ^ m / ↑m.factorial * ((↑m + 1) / ↑m)

full_name: Real.exp_approx_succ
code: theorem exp_approx_succ {n} {x a₁ b₁ : ℝ} (m : ℕ) (e₁ : n + 1 = m) (a₂ b₂ : ℝ)
    (e : |1 + x / m * a₂ - a₁| ≤ b₁ - |x| / m * b₂)
    (h : |exp x - expNear m x a₂| ≤ |x| ^ m / m.factorial * b₂) :
    |exp x - expNear n x a₁| ≤ |x| ^ n / n.factorial * b₁ 
goal: |Real.exp x - Real.expNear n x a₁| ≤ |x| ^ n / ↑n.factorial * b₁

full_name: Real.exp_approx_end'
code: theorem exp_approx_end' {n} {x a b : ℝ} (m : ℕ) (e₁ : n + 1 = m) (rm : ℝ) (er : ↑m = rm)
    (h : |x| ≤ 1) (e : |1 - a| ≤ b - |x| / rm * ((rm + 1) / rm)) :
    |exp x - expNear n x a| ≤ |x| ^ n / n.factorial * b 
goal: |Real.exp x - Real.expNear n x a| ≤ |x| ^ n / ↑n.factorial * b

full_name: Real.exp_1_approx_succ_eq
code: theorem exp_1_approx_succ_eq {n} {a₁ b₁ : ℝ} {m : ℕ} (en : n + 1 = m) {rm : ℝ} (er : ↑m = rm)
    (h : |exp 1 - expNear m 1 ((a₁ - 1) * rm)| ≤ |1| ^ m / m.factorial * (b₁ * rm)) :
    |exp 1 - expNear n 1 a₁| ≤ |1| ^ n / n.factorial * b₁ 
goal: |Real.exp 1 - Real.expNear n 1 a₁| ≤ |1| ^ n / ↑n.factorial * b₁

full_name: Real.exp_approx_start
code: theorem exp_approx_start (x a b : ℝ) (h : |exp x - expNear 0 x a| ≤ |x| ^ 0 / Nat.factorial 0 * b) :
    |exp x - a| ≤ b 
goal: |Real.exp x - a| ≤ b

full_name: Real.cos_bound
code: theorem cos_bound {x : ℝ} (hx : |x| ≤ 1) : |cos x - (1 - x ^ 2 / 2)| ≤ |x| ^ 4 * (5 / 96) 
goal: |Real.cos x - (1 - x ^ 2 / 2)| ≤ |x| ^ 4 * (5 / 96)

full_name: Real.sin_bound
code: theorem sin_bound {x : ℝ} (hx : |x| ≤ 1) : |sin x - (x - x ^ 3 / 6)| ≤ |x| ^ 4 * (5 / 96) 
goal: |Real.sin x - (x - x ^ 3 / 6)| ≤ |x| ^ 4 * (5 / 96)

full_name: Real.cos_pos_of_le_one
code: theorem cos_pos_of_le_one {x : ℝ} (hx : |x| ≤ 1) : 0 < cos x 
goal: 0 < Real.cos x

full_name: Real.sin_pos_of_pos_of_le_one
code: theorem sin_pos_of_pos_of_le_one {x : ℝ} (hx0 : 0 < x) (hx : x ≤ 1) : 0 < sin x 
goal: 0 < Real.sin x

full_name: Real.sin_pos_of_pos_of_le_two
code: theorem sin_pos_of_pos_of_le_two {x : ℝ} (hx0 : 0 < x) (hx : x ≤ 2) : 0 < sin x 
goal: 0 < Real.sin x

full_name: Real.cos_one_le
code: theorem cos_one_le : cos 1 ≤ 2 / 3 
goal: Real.cos 1 ≤ 2 / 3

full_name: Real.cos_one_pos
code: theorem cos_one_pos : 0 < cos 1 
goal: 0 < Real.cos 1

full_name: Real.cos_two_neg
code: theorem cos_two_neg : cos 2 < 0 
goal: Real.cos 2 < 0

full_name: Real.exp_bound_div_one_sub_of_interval'
code: theorem exp_bound_div_one_sub_of_interval' {x : ℝ} (h1 : 0 < x) (h2 : x < 1) :
    Real.exp x < 1 / (1 - x) 
goal: Real.exp x < 1 / (1 - x)

full_name: Real.exp_bound_div_one_sub_of_interval
code: theorem exp_bound_div_one_sub_of_interval {x : ℝ} (h1 : 0 ≤ x) (h2 : x < 1) :
    Real.exp x ≤ 1 / (1 - x) 
goal: Real.exp x ≤ 1 / (1 - x)

full_name: Real.add_one_lt_exp
code: theorem add_one_lt_exp {x : ℝ} (hx : x ≠ 0) : x + 1 < Real.exp x 
goal: x + 1 < Real.exp x

full_name: Real.add_one_le_exp
code: theorem add_one_le_exp (x : ℝ) : x + 1 ≤ Real.exp x 
goal: x + 1 ≤ Real.exp x

full_name: Real.one_sub_lt_exp_neg
code: lemma one_sub_lt_exp_neg {x : ℝ} (hx : x ≠ 0) : 1 - x < exp (-x) 
goal: 1 - x < Real.exp (-x)

full_name: Real.one_sub_le_exp_neg
code: lemma one_sub_le_exp_neg (x : ℝ) : 1 - x ≤ exp (-x) 
goal: 1 - x ≤ Real.exp (-x)

full_name: Real.one_sub_div_pow_le_exp_neg
code: theorem one_sub_div_pow_le_exp_neg {n : ℕ} {t : ℝ} (ht' : t ≤ n) : (1 - t / n) ^ n ≤ exp (-t) 
goal: (1 - t / ↑n) ^ n ≤ Real.exp (-t)

full_name: Mathlib.Meta.Positivity.evalExp
code: /-- Extension for the `positivity` tactic: `Real.exp` is always positive. -/
@[positivity Real.exp _]
def evalExp : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalCosh
code: /-- Extension for the `positivity` tactic: `Real.cosh` is always positive. -/
@[positivity Real.cosh _]
def evalCosh : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Complex.abs_cos_add_sin_mul_I
code: @[simp]
theorem abs_cos_add_sin_mul_I (x : ℝ) : abs (cos x + sin x * I) = 1 
goal: Complex.abs (Complex.cos ↑x + Complex.sin ↑x * Complex.I) = 1

full_name: Complex.abs_exp_ofReal
code: @[simp]
theorem abs_exp_ofReal (x : ℝ) : abs (exp x) = Real.exp x 
goal: Complex.abs (Complex.exp ↑x) = Real.exp x

full_name: Complex.abs_exp_ofReal_mul_I
code: @[simp]
theorem abs_exp_ofReal_mul_I (x : ℝ) : abs (exp (x * I)) = 1 
goal: Complex.abs (Complex.exp (↑x * Complex.I)) = 1

full_name: Complex.abs_exp
code: theorem abs_exp (z : ℂ) : abs (exp z) = Real.exp z.re 
goal: Complex.abs (Complex.exp z) = Real.exp z.re

full_name: Complex.abs_exp_eq_iff_re_eq
code: theorem abs_exp_eq_iff_re_eq {x y : ℂ} : abs (exp x) = abs (exp y) ↔ x.re = y.re 
goal: Complex.abs (Complex.exp x) = Complex.abs (Complex.exp y) ↔ x.re = y.re