l3lab/ntp-mathlib huggingface dataset:
theorem exp_add : exp (x + y) = exp x * exp y := by
  have hj : ∀ j : ℕ, (∑ m in range j, (x + y) ^ m / m.factorial) =
        ∑ i in range j, ∑ k in range (i + 1), x ^ k / k.factorial *
          (y ^ (i - k) / (i - k).factorial) := by
    intro j
    refine' Finset.sum_congr rfl fun m _ => _
    rw [add_pow, div_eq_mul_inv, sum_mul]
    refine' Finset.sum_congr rfl fun I hi => _
    have h₁ : (m.choose I : ℂ) ≠ 0 :=
      Nat.cast_ne_zero.2 (pos_iff_ne_zero.1 (Nat.choose_pos (Nat.le_of_lt_succ (mem_range.1 hi))))
    have h₂ := Nat.choose_mul_factorial_mul_factorial (Nat.le_of_lt_succ <| Finset.mem_range.1 hi)
    rw [← h₂, Nat.cast_mul, Nat.cast_mul, mul_inv, mul_inv]
    simp only [mul_left_comm (m.choose I : ℂ), mul_assoc, mul_left_comm (m.choose I : ℂ)⁻¹,
      mul_comm (m.choose I : ℂ)]
    rw [inv_mul_cancel h₁]
    simp [div_eq_mul_inv, mul_comm, mul_assoc, mul_left_comm]
  simp_rw [exp, exp', lim_mul_lim]
  apply (lim_eq_lim_of_equiv _).symm
  simp only [hj]
  

Proof state:
x y : ℂ
hj :
  ∀ (j : ℕ),
    ∑ m in range j, (x + y) ^ m / ↑(Nat.factorial m) =
      ∑ i in range j, ∑ k in range (i + 1), x ^ k / ↑(Nat.factorial k) * (y ^ (i - k) / ↑(Nat.factorial (i - k)))
⊢ { val := fun n => ∑ m in range n, x ^ m / ↑(Nat.factorial m),
        property := (_ : IsCauSeq ⇑abs fun n => ∑ m in range n, x ^ m / ↑(Nat.factorial m)) } *
      { val := fun n => ∑ m in range n, y ^ m / ↑(Nat.factorial m),
        property := (_ : IsCauSeq ⇑abs fun n => ∑ m in range n, y ^ m / ↑(Nat.factorial m)) } ≈
    {
      val := fun n =>
        ∑ i in range n, ∑ k in range (i + 1), x ^ k / ↑(Nat.factorial k) * (y ^ (i - k) / ↑(Nat.factorial (i - k))),
      property :=
        (_ :
          (fun f => IsCauSeq (⇑abs) f) fun n =>
            ∑ i in range n,
              ∑ k in range (i + 1), x ^ k / ↑(Nat.factorial k) * (y ^ (i - k) / ↑(Nat.factorial (i - k)))) }

Next tactic:
exact cauchy_product (isCauSeq_abs_exp x) (isCauSeq_exp y)
/-- the exponential function as a monoid hom from `Multiplicative ℂ` to `ℂ` -/
noncomputable def expMonoidHom : MonoidHom (Multiplicative ℂ) ℂ :=
  { toFun := fun z => exp (Multiplicative.toAdd z),
    map_one' := by 

Proof state:
x y : ℂ
⊢ (fun z => cexp (Multiplicative.toAdd z)) 1 = 1

Next tactic:
simp
/-- the exponential function as a monoid hom from `Multiplicative ℂ` to `ℂ` -/
noncomputable def expMonoidHom : MonoidHom (Multiplicative ℂ) ℂ :=
  { toFun := fun z => exp (Multiplicative.toAdd z),
    map_one' := by simp,
    map_mul' := by 

Proof state:
x y : ℂ
⊢ ∀ (x y : Multiplicative ℂ),
    OneHom.toFun { toFun := fun z => cexp (Multiplicative.toAdd z), map_one' := (_ : cexp 0 = 1) } (x * y) =
      OneHom.toFun { toFun := fun z => cexp (Multiplicative.toAdd z), map_one' := (_ : cexp 0 = 1) } x *
        OneHom.toFun { toFun := fun z => cexp (Multiplicative.toAdd z), map_one' := (_ : cexp 0 = 1) } y

Next tactic:
simp [exp_add]
theorem exp_nat_mul (x : ℂ) : ∀ n : ℕ, exp (n * x) = exp x ^ n
  | 0 => by 

Proof state:
x✝ y x : ℂ
⊢ cexp (↑0 * x) = cexp x ^ 0

Next tactic:
rw [Nat.cast_zero, zero_mul, exp_zero, pow_zero]
theorem exp_nat_mul (x : ℂ) : ∀ n : ℕ, exp (n * x) = exp x ^ n
  | 0 => by rw [Nat.cast_zero, zero_mul, exp_zero, pow_zero]
  | Nat.succ n => by 

Proof state:
x✝ y x : ℂ
n : ℕ
⊢ cexp (↑(Nat.succ n) * x) = cexp x ^ Nat.succ n

Next tactic:
rw [pow_succ', Nat.cast_add_one, add_mul, exp_add, ← exp_nat_mul _ n, one_mul]
theorem exp_ne_zero : exp x ≠ 0 := fun h =>
  zero_ne_one <| by 

Proof state:
x y : ℂ
h : cexp x = 0
⊢ 0 = 1

Next tactic:
rw [← exp_zero, ← add_neg_self x, exp_add, h]
theorem exp_ne_zero : exp x ≠ 0 := fun h =>
  zero_ne_one <| by rw [← exp_zero, ← add_neg_self x, exp_add, h]; 

Proof state:
x y : ℂ
h : cexp x = 0
⊢ x + -x = 0 * cexp (-x)

Next tactic:
simp
theorem exp_neg : exp (-x) = (exp x)⁻¹ := by
  

Proof state:
x y : ℂ
⊢ cexp (-x) = (cexp x)⁻¹

Next tactic:
rw [← mul_right_inj' (exp_ne_zero x), ← exp_add]
theorem exp_neg : exp (-x) = (exp x)⁻¹ := by
  rw [← mul_right_inj' (exp_ne_zero x), ← exp_add]; 

Proof state:
x y : ℂ
⊢ cexp (x + -x) = cexp x * (cexp x)⁻¹

Next tactic:
simp [mul_inv_cancel (exp_ne_zero x)]
theorem exp_sub : exp (x - y) = exp x / exp y := by
  

Proof state:
x y : ℂ
⊢ cexp (x - y) = cexp x / cexp y

Next tactic:
simp [sub_eq_add_neg, exp_add, exp_neg, div_eq_mul_inv]
theorem exp_int_mul (z : ℂ) (n : ℤ) : Complex.exp (n * z) = Complex.exp z ^ n := by
  

Proof state:
x y z : ℂ
n : ℤ
⊢ cexp (↑n * z) = cexp z ^ n

Next tactic:
cases n
theorem exp_int_mul (z : ℂ) (n : ℤ) : Complex.exp (n * z) = Complex.exp z ^ n := by
  cases n
  · 

Proof state:
case ofNat
x y z : ℂ
a✝ : ℕ
⊢ cexp (↑(Int.ofNat a✝) * z) = cexp z ^ Int.ofNat a✝

Next tactic:
simp [exp_nat_mul]
theorem exp_int_mul (z : ℂ) (n : ℤ) : Complex.exp (n * z) = Complex.exp z ^ n := by
  cases n
  · simp [exp_nat_mul]
  · 

Proof state:
case negSucc
x y z : ℂ
a✝ : ℕ
⊢ cexp (↑(Int.negSucc a✝) * z) = cexp z ^ Int.negSucc a✝

Next tactic:
simp [exp_add, add_mul, pow_add, exp_neg, exp_nat_mul]
@[simp]
theorem exp_conj : exp (conj x) = conj (exp x) := by
  

Proof state:
x y : ℂ
⊢ cexp ((starRingEnd ℂ) x) = (starRingEnd ℂ) (cexp x)

Next tactic:
dsimp [exp]
@[simp]
theorem exp_conj : exp (conj x) = conj (exp x) := by
  dsimp [exp]
  

Proof state:
x y : ℂ
⊢ CauSeq.lim (exp' ((starRingEnd ℂ) x)) = (starRingEnd ℂ) (CauSeq.lim (exp' x))

Next tactic:
rw [← lim_conj]
@[simp]
theorem exp_conj : exp (conj x) = conj (exp x) := by
  dsimp [exp]
  rw [← lim_conj]
  

Proof state:
x y : ℂ
⊢ CauSeq.lim (exp' ((starRingEnd ℂ) x)) = CauSeq.lim (cauSeqConj (exp' x))

Next tactic:
refine' congr_arg CauSeq.lim (CauSeq.ext fun _ => _)
@[simp]
theorem exp_conj : exp (conj x) = conj (exp x) := by
  dsimp [exp]
  rw [← lim_conj]
  refine' congr_arg CauSeq.lim (CauSeq.ext fun _ => _)
  

Proof state:
x y : ℂ
x✝ : ℕ
⊢ ↑(exp' ((starRingEnd ℂ) x)) x✝ = ↑(cauSeqConj (exp' x)) x✝

Next tactic:
dsimp [exp', Function.comp_def, isCauSeq_conj, cauSeqConj]
@[simp]
theorem exp_conj : exp (conj x) = conj (exp x) := by
  dsimp [exp]
  rw [← lim_conj]
  refine' congr_arg CauSeq.lim (CauSeq.ext fun _ => _)
  dsimp [exp', Function.comp_def, isCauSeq_conj, cauSeqConj]
  

Proof state:
x y : ℂ
x✝ : ℕ
⊢ ∑ m in range x✝, (starRingEnd ℂ) x ^ m / ↑(Nat.factorial m) =
    (starRingEnd ℂ) (∑ m in range x✝, x ^ m / ↑(Nat.factorial m))

Next tactic:
rw [(starRingEnd _).map_sum]
@[simp]
theorem exp_conj : exp (conj x) = conj (exp x) := by
  dsimp [exp]
  rw [← lim_conj]
  refine' congr_arg CauSeq.lim (CauSeq.ext fun _ => _)
  dsimp [exp', Function.comp_def, isCauSeq_conj, cauSeqConj]
  rw [(starRingEnd _).map_sum]
  

Proof state:
x y : ℂ
x✝ : ℕ
⊢ ∑ m in range x✝, (starRingEnd ℂ) x ^ m / ↑(Nat.factorial m) =
    ∑ x_1 in range x✝, (starRingEnd ℂ) (x ^ x_1 / ↑(Nat.factorial x_1))

Next tactic:
refine' sum_congr rfl fun n _ => _
@[simp]
theorem exp_conj : exp (conj x) = conj (exp x) := by
  dsimp [exp]
  rw [← lim_conj]
  refine' congr_arg CauSeq.lim (CauSeq.ext fun _ => _)
  dsimp [exp', Function.comp_def, isCauSeq_conj, cauSeqConj]
  rw [(starRingEnd _).map_sum]
  refine' sum_congr rfl fun n _ => _
  

Proof state:
x y : ℂ
x✝¹ n : ℕ
x✝ : n ∈ range x✝¹
⊢ (starRingEnd ℂ) x ^ n / ↑(Nat.factorial n) = (starRingEnd ℂ) (x ^ n / ↑(Nat.factorial n))

Next tactic:
rw [map_div₀, map_pow, ← ofReal_nat_cast, conj_ofReal]
@[simp]
theorem ofReal_exp_ofReal_re (x : ℝ) : ((exp x).re : ℂ) = exp x :=
  conj_eq_iff_re.1 <| by 

Proof state:
x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (cexp ↑x) = cexp ↑x

Next tactic:
rw [← exp_conj, conj_ofReal]
@[simp]
theorem exp_ofReal_im (x : ℝ) : (exp x).im = 0 := by 

Proof state:
x✝ y : ℂ
x : ℝ
⊢ (cexp ↑x).im = 0

Next tactic:
rw [← ofReal_exp_ofReal_re, ofReal_im]
@[simp]
theorem sinh_zero : sinh 0 = 0 := by 

Proof state:
x y : ℂ
⊢ sinh 0 = 0

Next tactic:
simp [sinh]
@[simp]
theorem sinh_neg : sinh (-x) = -sinh x := by 

Proof state:
x y : ℂ
⊢ sinh (-x) = -sinh x

Next tactic:
simp [sinh, exp_neg, (neg_div _ _).symm, add_mul]
private theorem sinh_add_aux {a b c d : ℂ} :
    (a - b) * (c + d) + (a + b) * (c - d) = 2 * (a * c - b * d) := by 

Proof state:
x y a b c d : ℂ
⊢ (a - b) * (c + d) + (a + b) * (c - d) = 2 * (a * c - b * d)

Next tactic:
ring
theorem sinh_add : sinh (x + y) = sinh x * cosh y + cosh x * sinh y := by
  

Proof state:
x y : ℂ
⊢ sinh (x + y) = sinh x * cosh y + cosh x * sinh y

Next tactic:
rw [← mul_right_inj' (two_ne_zero' ℂ), two_sinh, exp_add, neg_add, exp_add, eq_comm, mul_add, ←
    mul_assoc, two_sinh, mul_left_comm, two_sinh, ← mul_right_inj' (two_ne_zero' ℂ), mul_add,
    mul_left_comm, two_cosh, ← mul_assoc, two_cosh]
theorem sinh_add : sinh (x + y) = sinh x * cosh y + cosh x * sinh y := by
  rw [← mul_right_inj' (two_ne_zero' ℂ), two_sinh, exp_add, neg_add, exp_add, eq_comm, mul_add, ←
    mul_assoc, two_sinh, mul_left_comm, two_sinh, ← mul_right_inj' (two_ne_zero' ℂ), mul_add,
    mul_left_comm, two_cosh, ← mul_assoc, two_cosh]
  

Proof state:
x y : ℂ
⊢ (cexp x - cexp (-x)) * (cexp y + cexp (-y)) + (cexp x + cexp (-x)) * (cexp y - cexp (-y)) =
    2 * (cexp x * cexp y - cexp (-x) * cexp (-y))

Next tactic:
exact sinh_add_aux
@[simp]
theorem cosh_zero : cosh 0 = 1 := by 

Proof state:
x y : ℂ
⊢ cosh 0 = 1

Next tactic:
simp [cosh]
@[simp]
theorem cosh_neg : cosh (-x) = cosh x := by 

Proof state:
x y : ℂ
⊢ cosh (-x) = cosh x

Next tactic:
simp [add_comm, cosh, exp_neg]
private theorem cosh_add_aux {a b c d : ℂ} :
    (a + b) * (c + d) + (a - b) * (c - d) = 2 * (a * c + b * d) := by 

Proof state:
x y a b c d : ℂ
⊢ (a + b) * (c + d) + (a - b) * (c - d) = 2 * (a * c + b * d)

Next tactic:
ring
theorem cosh_add : cosh (x + y) = cosh x * cosh y + sinh x * sinh y := by
  

Proof state:
x y : ℂ
⊢ cosh (x + y) = cosh x * cosh y + sinh x * sinh y

Next tactic:
rw [← mul_right_inj' (two_ne_zero' ℂ), two_cosh, exp_add, neg_add, exp_add, eq_comm, mul_add, ←
    mul_assoc, two_cosh, ← mul_assoc, two_sinh, ← mul_right_inj' (two_ne_zero' ℂ), mul_add,
    mul_left_comm, two_cosh, mul_left_comm, two_sinh]
theorem cosh_add : cosh (x + y) = cosh x * cosh y + sinh x * sinh y := by
  rw [← mul_right_inj' (two_ne_zero' ℂ), two_cosh, exp_add, neg_add, exp_add, eq_comm, mul_add, ←
    mul_assoc, two_cosh, ← mul_assoc, two_sinh, ← mul_right_inj' (two_ne_zero' ℂ), mul_add,
    mul_left_comm, two_cosh, mul_left_comm, two_sinh]
  

Proof state:
x y : ℂ
⊢ (cexp x + cexp (-x)) * (cexp y + cexp (-y)) + (cexp x - cexp (-x)) * (cexp y - cexp (-y)) =
    2 * (cexp x * cexp y + cexp (-x) * cexp (-y))

Next tactic:
exact cosh_add_aux
theorem sinh_sub : sinh (x - y) = sinh x * cosh y - cosh x * sinh y := by
  

Proof state:
x y : ℂ
⊢ sinh (x - y) = sinh x * cosh y - cosh x * sinh y

Next tactic:
simp [sub_eq_add_neg, sinh_add, sinh_neg, cosh_neg]
theorem cosh_sub : cosh (x - y) = cosh x * cosh y - sinh x * sinh y := by
  

Proof state:
x y : ℂ
⊢ cosh (x - y) = cosh x * cosh y - sinh x * sinh y

Next tactic:
simp [sub_eq_add_neg, cosh_add, sinh_neg, cosh_neg]
theorem sinh_conj : sinh (conj x) = conj (sinh x) := by
  

Proof state:
x y : ℂ
⊢ sinh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (sinh x)

Next tactic:
rw [sinh, ← RingHom.map_neg, exp_conj, exp_conj, ← RingHom.map_sub, sinh, map_div₀]
theorem sinh_conj : sinh (conj x) = conj (sinh x) := by
  rw [sinh, ← RingHom.map_neg, exp_conj, exp_conj, ← RingHom.map_sub, sinh, map_div₀]
  --Porting note: not nice
  

Proof state:
x y : ℂ
⊢ (starRingEnd ℂ) (cexp x - cexp (-x)) / 2 = (starRingEnd ℂ) (cexp x - cexp (-x)) / (starRingEnd ℂ) 2

Next tactic:
simp [← one_add_one_eq_two]
@[simp]
theorem ofReal_sinh_ofReal_re (x : ℝ) : ((sinh x).re : ℂ) = sinh x :=
  conj_eq_iff_re.1 <| by 

Proof state:
x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (sinh ↑x) = sinh ↑x

Next tactic:
rw [← sinh_conj, conj_ofReal]
@[simp]
theorem sinh_ofReal_im (x : ℝ) : (sinh x).im = 0 := by 

Proof state:
x✝ y : ℂ
x : ℝ
⊢ (sinh ↑x).im = 0

Next tactic:
rw [← ofReal_sinh_ofReal_re, ofReal_im]
theorem cosh_conj : cosh (conj x) = conj (cosh x) := by
  

Proof state:
x y : ℂ
⊢ cosh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (cosh x)

Next tactic:
rw [cosh, ← RingHom.map_neg, exp_conj, exp_conj, ← RingHom.map_add, cosh, map_div₀]
theorem cosh_conj : cosh (conj x) = conj (cosh x) := by
  rw [cosh, ← RingHom.map_neg, exp_conj, exp_conj, ← RingHom.map_add, cosh, map_div₀]
  --Porting note: not nice
  

Proof state:
x y : ℂ
⊢ (starRingEnd ℂ) (cexp x + cexp (-x)) / 2 = (starRingEnd ℂ) (cexp x + cexp (-x)) / (starRingEnd ℂ) 2

Next tactic:
simp [← one_add_one_eq_two]
theorem ofReal_cosh_ofReal_re (x : ℝ) : ((cosh x).re : ℂ) = cosh x :=
  conj_eq_iff_re.1 <| by 

Proof state:
x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (cosh ↑x) = cosh ↑x

Next tactic:
rw [← cosh_conj, conj_ofReal]
@[simp]
theorem cosh_ofReal_im (x : ℝ) : (cosh x).im = 0 := by 

Proof state:
x✝ y : ℂ
x : ℝ
⊢ (cosh ↑x).im = 0

Next tactic:
rw [← ofReal_cosh_ofReal_re, ofReal_im]
@[simp]
theorem tanh_zero : tanh 0 = 0 := by 

Proof state:
x y : ℂ
⊢ tanh 0 = 0

Next tactic:
simp [tanh]
@[simp]
theorem tanh_neg : tanh (-x) = -tanh x := by 

Proof state:
x y : ℂ
⊢ tanh (-x) = -tanh x

Next tactic:
simp [tanh, neg_div]
theorem tanh_conj : tanh (conj x) = conj (tanh x) := by
  

Proof state:
x y : ℂ
⊢ tanh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (tanh x)

Next tactic:
rw [tanh, sinh_conj, cosh_conj, ← map_div₀, tanh]
@[simp]
theorem ofReal_tanh_ofReal_re (x : ℝ) : ((tanh x).re : ℂ) = tanh x :=
  conj_eq_iff_re.1 <| by 

Proof state:
x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (tanh ↑x) = tanh ↑x

Next tactic:
rw [← tanh_conj, conj_ofReal]
@[simp]
theorem tanh_ofReal_im (x : ℝ) : (tanh x).im = 0 := by 

Proof state:
x✝ y : ℂ
x : ℝ
⊢ (tanh ↑x).im = 0

Next tactic:
rw [← ofReal_tanh_ofReal_re, ofReal_im]
@[simp]
theorem cosh_add_sinh : cosh x + sinh x = exp x := by
  

Proof state:
x y : ℂ
⊢ cosh x + sinh x = cexp x

Next tactic:
rw [← mul_right_inj' (two_ne_zero' ℂ), mul_add, two_cosh, two_sinh, add_add_sub_cancel, two_mul]
@[simp]
theorem sinh_add_cosh : sinh x + cosh x = exp x := by 

Proof state:
x y : ℂ
⊢ sinh x + cosh x = cexp x

Next tactic:
rw [add_comm, cosh_add_sinh]
@[simp]
theorem cosh_sub_sinh : cosh x - sinh x = exp (-x) := by
  

Proof state:
x y : ℂ
⊢ cosh x - sinh x = cexp (-x)

Next tactic:
rw [← mul_right_inj' (two_ne_zero' ℂ), mul_sub, two_cosh, two_sinh, add_sub_sub_cancel, two_mul]
@[simp]
theorem sinh_sub_cosh : sinh x - cosh x = -exp (-x) := by 

Proof state:
x y : ℂ
⊢ sinh x - cosh x = -cexp (-x)

Next tactic:
rw [← neg_sub, cosh_sub_sinh]
@[simp]
theorem cosh_sq_sub_sinh_sq : cosh x ^ 2 - sinh x ^ 2 = 1 := by
  

Proof state:
x y : ℂ
⊢ cosh x ^ 2 - sinh x ^ 2 = 1

Next tactic:
rw [sq_sub_sq, cosh_add_sinh, cosh_sub_sinh, ← exp_add, add_neg_self, exp_zero]
theorem cosh_sq : cosh x ^ 2 = sinh x ^ 2 + 1 := by
  

Proof state:
x y : ℂ
⊢ cosh x ^ 2 = sinh x ^ 2 + 1

Next tactic:
rw [← cosh_sq_sub_sinh_sq x]
theorem cosh_sq : cosh x ^ 2 = sinh x ^ 2 + 1 := by
  rw [← cosh_sq_sub_sinh_sq x]
  

Proof state:
x y : ℂ
⊢ cosh x ^ 2 = sinh x ^ 2 + (cosh x ^ 2 - sinh x ^ 2)

Next tactic:
ring
theorem sinh_sq : sinh x ^ 2 = cosh x ^ 2 - 1 := by
  

Proof state:
x y : ℂ
⊢ sinh x ^ 2 = cosh x ^ 2 - 1

Next tactic:
rw [← cosh_sq_sub_sinh_sq x]
theorem sinh_sq : sinh x ^ 2 = cosh x ^ 2 - 1 := by
  rw [← cosh_sq_sub_sinh_sq x]
  

Proof state:
x y : ℂ
⊢ sinh x ^ 2 = cosh x ^ 2 - (cosh x ^ 2 - sinh x ^ 2)

Next tactic:
ring
theorem cosh_two_mul : cosh (2 * x) = cosh x ^ 2 + sinh x ^ 2 := by 

Proof state:
x y : ℂ
⊢ cosh (2 * x) = cosh x ^ 2 + sinh x ^ 2

Next tactic:
rw [two_mul, cosh_add, sq, sq]
theorem sinh_two_mul : sinh (2 * x) = 2 * sinh x * cosh x := by
  

Proof state:
x y : ℂ
⊢ sinh (2 * x) = 2 * sinh x * cosh x

Next tactic:
rw [two_mul, sinh_add]
theorem sinh_two_mul : sinh (2 * x) = 2 * sinh x * cosh x := by
  rw [two_mul, sinh_add]
  

Proof state:
x y : ℂ
⊢ sinh x * cosh x + cosh x * sinh x = 2 * sinh x * cosh x

Next tactic:
ring
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x := by
  

Proof state:
x y : ℂ
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x

Next tactic:
have h1 : x + 2 * x = 3 * x := by ring
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x := by
  have h1 : x + 2 * x = 3 * x := by 

Proof state:
x y : ℂ
⊢ x + 2 * x = 3 * x

Next tactic:
ring
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x

Next tactic:
rw [← h1, cosh_add x (2 * x)]
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, cosh_add x (2 * x)]
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * cosh (2 * x) + sinh x * sinh (2 * x) = 4 * cosh x ^ 3 - 3 * cosh x

Next tactic:
simp only [cosh_two_mul, sinh_two_mul]
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, cosh_add x (2 * x)]
  simp only [cosh_two_mul, sinh_two_mul]
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x

Next tactic:
have h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2 := by ring
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, cosh_add x (2 * x)]
  simp only [cosh_two_mul, sinh_two_mul]
  have h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2 := by 

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2

Next tactic:
ring
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, cosh_add x (2 * x)]
  simp only [cosh_two_mul, sinh_two_mul]
  have h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2 := by ring
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x

Next tactic:
rw [h2, sinh_sq]
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, cosh_add x (2 * x)]
  simp only [cosh_two_mul, sinh_two_mul]
  have h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2 := by ring
  rw [h2, sinh_sq]
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + (cosh x ^ 2 - 1)) + 2 * cosh x * (cosh x ^ 2 - 1) = 4 * cosh x ^ 3 - 3 * cosh x

Next tactic:
ring
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x := by
  

Proof state:
x y : ℂ
⊢ sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x

Next tactic:
have h1 : x + 2 * x = 3 * x := by ring
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x := by
  have h1 : x + 2 * x = 3 * x := by 

Proof state:
x y : ℂ
⊢ x + 2 * x = 3 * x

Next tactic:
ring
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x

Next tactic:
rw [← h1, sinh_add x (2 * x)]
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, sinh_add x (2 * x)]
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sinh x * cosh (2 * x) + cosh x * sinh (2 * x) = 4 * sinh x ^ 3 + 3 * sinh x

Next tactic:
simp only [cosh_two_mul, sinh_two_mul]
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, sinh_add x (2 * x)]
  simp only [cosh_two_mul, sinh_two_mul]
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sinh x * (cosh x ^ 2 + sinh x ^ 2) + cosh x * (2 * sinh x * cosh x) = 4 * sinh x ^ 3 + 3 * sinh x

Next tactic:
have h2 : cosh x * (2 * sinh x * cosh x) = 2 * sinh x * cosh x ^ 2 := by ring
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, sinh_add x (2 * x)]
  simp only [cosh_two_mul, sinh_two_mul]
  have h2 : cosh x * (2 * sinh x * cosh x) = 2 * sinh x * cosh x ^ 2 := by 

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * (2 * sinh x * cosh x) = 2 * sinh x * cosh x ^ 2

Next tactic:
ring
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, sinh_add x (2 * x)]
  simp only [cosh_two_mul, sinh_two_mul]
  have h2 : cosh x * (2 * sinh x * cosh x) = 2 * sinh x * cosh x ^ 2 := by ring
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : cosh x * (2 * sinh x * cosh x) = 2 * sinh x * cosh x ^ 2
⊢ sinh x * (cosh x ^ 2 + sinh x ^ 2) + cosh x * (2 * sinh x * cosh x) = 4 * sinh x ^ 3 + 3 * sinh x

Next tactic:
rw [h2, cosh_sq]
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x := by
  have h1 : x + 2 * x = 3 * x := by ring
  rw [← h1, sinh_add x (2 * x)]
  simp only [cosh_two_mul, sinh_two_mul]
  have h2 : cosh x * (2 * sinh x * cosh x) = 2 * sinh x * cosh x ^ 2 := by ring
  rw [h2, cosh_sq]
  

Proof state:
x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : cosh x * (2 * sinh x * cosh x) = 2 * sinh x * cosh x ^ 2
⊢ sinh x * (sinh x ^ 2 + 1 + sinh x ^ 2) + 2 * sinh x * (sinh x ^ 2 + 1) = 4 * sinh x ^ 3 + 3 * sinh x

Next tactic:
ring
@[simp]
theorem sin_zero : sin 0 = 0 := by 

Proof state:
x y : ℂ
⊢ sin 0 = 0

Next tactic:
simp [sin]
@[simp]
theorem sin_neg : sin (-x) = -sin x := by
  

Proof state:
x y : ℂ
⊢ sin (-x) = -sin x

Next tactic:
simp [sin, sub_eq_add_neg, exp_neg, (neg_div _ _).symm, add_mul]
theorem sinh_mul_I : sinh (x * I) = sin x * I := by
  

Proof state:
x y : ℂ
⊢ sinh (x * I) = sin x * I

Next tactic:
rw [← mul_right_inj' (two_ne_zero' ℂ), two_sinh, ← mul_assoc, two_sin, mul_assoc, I_mul_I,
    mul_neg_one, neg_sub, neg_mul_eq_neg_mul]
theorem cosh_mul_I : cosh (x * I) = cos x := by
  

Proof state:
x y : ℂ
⊢ cosh (x * I) = cos x

Next tactic:
rw [← mul_right_inj' (two_ne_zero' ℂ), two_cosh, two_cos, neg_mul_eq_neg_mul]
theorem tanh_mul_I : tanh (x * I) = tan x * I := by
  

Proof state:
x y : ℂ
⊢ tanh (x * I) = tan x * I

Next tactic:
rw [tanh_eq_sinh_div_cosh, cosh_mul_I, sinh_mul_I, mul_div_right_comm, tan]
theorem cos_mul_I : cos (x * I) = cosh x := by 

Proof state:
x y : ℂ
⊢ cos (x * I) = cosh x

Next tactic:
rw [← cosh_mul_I]
theorem cos_mul_I : cos (x * I) = cosh x := by rw [← cosh_mul_I]; 

Proof state:
x y : ℂ
⊢ cosh (x * I * I) = cosh x

Next tactic:
ring_nf
theorem cos_mul_I : cos (x * I) = cosh x := by rw [← cosh_mul_I]; ring_nf; 

Proof state:
x y : ℂ
⊢ cosh (x * I ^ 2) = cosh x

Next tactic:
simp
theorem sin_mul_I : sin (x * I) = sinh x * I := by
  

Proof state:
x y : ℂ
⊢ sin (x * I) = sinh x * I

Next tactic:
have h : I * sin (x * I) = -sinh x := by
    rw [mul_comm, ← sinh_mul_I]
    ring_nf
    simp
theorem sin_mul_I : sin (x * I) = sinh x * I := by
  have h : I * sin (x * I) = -sinh x := by
    

Proof state:
x y : ℂ
⊢ I * sin (x * I) = -sinh x

Next tactic:
rw [mul_comm, ← sinh_mul_I]
theorem sin_mul_I : sin (x * I) = sinh x * I := by
  have h : I * sin (x * I) = -sinh x := by
    rw [mul_comm, ← sinh_mul_I]
    

Proof state:
x y : ℂ
⊢ sinh (x * I * I) = -sinh x

Next tactic:
ring_nf
theorem sin_mul_I : sin (x * I) = sinh x * I := by
  have h : I * sin (x * I) = -sinh x := by
    rw [mul_comm, ← sinh_mul_I]
    ring_nf
    

Proof state:
x y : ℂ
⊢ sinh (x * I ^ 2) = -sinh x

Next tactic:
simp
theorem sin_mul_I : sin (x * I) = sinh x * I := by
  have h : I * sin (x * I) = -sinh x := by
    rw [mul_comm, ← sinh_mul_I]
    ring_nf
    simp
  

Proof state:
x y : ℂ
h : I * sin (x * I) = -sinh x
⊢ sin (x * I) = sinh x * I

Next tactic:
rw [← neg_neg (sinh x), ← h]
theorem sin_mul_I : sin (x * I) = sinh x * I := by
  have h : I * sin (x * I) = -sinh x := by
    rw [mul_comm, ← sinh_mul_I]
    ring_nf
    simp
  rw [← neg_neg (sinh x), ← h]
  

Proof state:
x y : ℂ
h : I * sin (x * I) = -sinh x
⊢ sin (x * I) = -(I * sin (x * I)) * I

Next tactic:
apply Complex.ext