ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- DFinsupp.sum_sum_index
@[to_additive]
theorem prod_sum_index {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [∀ i₁, Zero (β₁ i₁)]
    [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)]
    [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] {f : Π₀ i₁, β₁ i₁}
    {g : ∀ i₁, β₁ i₁ → Π₀ i, β i} {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) :
    (f.sum g).prod h = f.prod fun i b => (g i b).prod h 
Arguments: {ι : Type u} {γ : Type w} {β : ι → Type v} [DecidableEq ι] {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [(i₁ : ι₁) → Zero (β₁ i₁)] [(i : ι₁) → (x : β₁ i) → Decidable (x ≠ 0)] [(i : ι) → AddCommMonoid (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] [AddCommMonoid γ] {f : Π₀ (i₁ : ι₁), β₁ i₁} {g : (i₁ : ι₁) → β₁ i₁ → Π₀ (i : ι), β i} {h : (i : ι) → β i → γ} (h_zero : ∀ (i : ι), h i 0 = 0) (h_add : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ + b₂) = h i b₁ + h i b₂)
Goal: (f.sum g).sum h = f.sum fun i b => (g i b).sum h
-- DFinsupp.prod_sum_index
@[to_additive]
theorem prod_sum_index {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [∀ i₁, Zero (β₁ i₁)]
    [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)]
    [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] {f : Π₀ i₁, β₁ i₁}
    {g : ∀ i₁, β₁ i₁ → Π₀ i, β i} {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) :
    (f.sum g).prod h = f.prod fun i b => (g i b).prod h 
Arguments: {ι : Type u} {γ : Type w} {β : ι → Type v} [DecidableEq ι] {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [(i₁ : ι₁) → Zero (β₁ i₁)] [(i : ι₁) → (x : β₁ i) → Decidable (x ≠ 0)] [(i : ι) → AddCommMonoid (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] [CommMonoid γ] {f : Π₀ (i₁ : ι₁), β₁ i₁} {g : (i₁ : ι₁) → β₁ i₁ → Π₀ (i : ι), β i} {h : (i : ι) → β i → γ} (h_zero : ∀ (i : ι), h i 0 = 1) (h_add : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ + b₂) = h i b₁ * h i b₂)
Goal: (f.sum g).prod h = f.prod fun i b => (g i b).prod h
-- DFinsupp.sum_single
@[simp]
theorem sum_single [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] {f : Π₀ i, β i} :
    f.sum single = f 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] [(i : ι) → AddCommMonoid (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] {f : Π₀ (i : ι), β i}
Goal: f.sum DFinsupp.single = f
-- DFinsupp.prod_subtypeDomain_index
@[to_additive]
theorem prod_subtypeDomain_index [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {v : Π₀ i, β i} {p : ι → Prop} [DecidablePred p] {h : ∀ i, β i → γ}
    (hp : ∀ x ∈ v.support, p x) : (v.subtypeDomain p).prod (fun i b => h i b) = v.prod h 
Arguments: {ι : Type u} {γ : Type w} {β : ι → Type v} [DecidableEq ι] [(i : ι) → Zero (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] [CommMonoid γ] {v : Π₀ (i : ι), β i} {p : ι → Prop} [DecidablePred p] {h : (i : ι) → β i → γ} (hp : ∀ x ∈ v.support, p x)
Goal: ((DFinsupp.subtypeDomain p v).prod fun i b => h (↑i) b) = v.prod h
-- DFinsupp.sum_subtypeDomain_index
@[to_additive]
theorem prod_subtypeDomain_index [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {v : Π₀ i, β i} {p : ι → Prop} [DecidablePred p] {h : ∀ i, β i → γ}
    (hp : ∀ x ∈ v.support, p x) : (v.subtypeDomain p).prod (fun i b => h i b) = v.prod h 
Arguments: {ι : Type u} {γ : Type w} {β : ι → Type v} [DecidableEq ι] [(i : ι) → Zero (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] [AddCommMonoid γ] {v : Π₀ (i : ι), β i} {p : ι → Prop} [DecidablePred p] {h : (i : ι) → β i → γ} (hp : ∀ x ∈ v.support, p x)
Goal: ((DFinsupp.subtypeDomain p v).sum fun i b => h (↑i) b) = v.sum h
-- DFinsupp.subtypeDomain_sum
theorem subtypeDomain_sum [∀ i, AddCommMonoid (β i)] {s : Finset γ} {h : γ → Π₀ i, β i}
    {p : ι → Prop} [DecidablePred p] :
    (∑ c ∈ s, h c).subtypeDomain p = ∑ c ∈ s, (h c).subtypeDomain p 
Arguments: {ι : Type u} {γ : Type w} {β : ι → Type v} [(i : ι) → AddCommMonoid (β i)] {s : Finset γ} {h : γ → Π₀ (i : ι), β i} {p : ι → Prop} [DecidablePred p]
Goal: DFinsupp.subtypeDomain p (∑ c ∈ s, h c) = ∑ c ∈ s, DFinsupp.subtypeDomain p (h c)
-- DFinsupp.subtypeDomain_finsupp_sum
theorem subtypeDomain_finsupp_sum {δ : γ → Type x} [DecidableEq γ] [∀ c, Zero (δ c)]
    [∀ (c) (x : δ c), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)] {p : ι → Prop} [DecidablePred p]
    {s : Π₀ c, δ c} {h : ∀ c, δ c → Π₀ i, β i} :
    (s.sum h).subtypeDomain p = s.sum fun c d => (h c d).subtypeDomain p 
Arguments: {ι : Type u} {γ : Type w} {β : ι → Type v} {δ : γ → Type x} [DecidableEq γ] [(c : γ) → Zero (δ c)] [(c : γ) → (x : δ c) → Decidable (x ≠ 0)] [(i : ι) → AddCommMonoid (β i)] {p : ι → Prop} [DecidablePred p] {s : Π₀ (c : γ), δ c} {h : (c : γ) → δ c → Π₀ (i : ι), β i}
Goal: DFinsupp.subtypeDomain p (s.sum h) = s.sum fun c d => DFinsupp.subtypeDomain p (h c d)
-- DFinsupp.mapRange_add
theorem mapRange_add (f : ∀ i, β₁ i → β₂ i) (hf : ∀ i, f i 0 = 0)
    (hf' : ∀ i x y, f i (x + y) = f i x + f i y) (g₁ g₂ : Π₀ i, β₁ i) :
    mapRange f hf (g₁ + g₂) = mapRange f hf g₁ + mapRange f hf g₂ 
Arguments: {ι : Type u} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [(i : ι) → AddZeroClass (β₁ i)] [(i : ι) → AddZeroClass (β₂ i)] (f : (i : ι) → β₁ i → β₂ i) (hf : ∀ (i : ι), f i 0 = 0) (hf' : ∀ (i : ι) (x y : β₁ i), f i (x + y) = f i x + f i y) (g₁ g₂ : Π₀ (i : ι), β₁ i)
Goal: DFinsupp.mapRange f hf (g₁ + g₂) = DFinsupp.mapRange f hf g₁ + DFinsupp.mapRange f hf g₂
-- DFinsupp.mapRange.addMonoidHom_apply
@[simps apply]
def mapRange.addMonoidHom (f : ∀ i, β₁ i →+ β₂ i) : (Π₀ i, β₁ i) →+ Π₀ i, β₂ i 
Arguments: {ι : Type u} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [(i : ι) → AddZeroClass (β₁ i)] [(i : ι) → AddZeroClass (β₂ i)] (f : (i : ι) → β₁ i →+ β₂ i) (x : Π₀ (i : ι), β₁ i)
Goal: (DFinsupp.mapRange.addMonoidHom f) x = DFinsupp.mapRange (fun i x => (f i) x) ⋯ x
-- DFinsupp.mapRange.addMonoidHom_id
@[simp]
theorem mapRange.addMonoidHom_id :
    (mapRange.addMonoidHom fun i => AddMonoidHom.id (β₂ i)) = AddMonoidHom.id _ 
Arguments: {ι : Type u} {β₂ : ι → Type v₂} [(i : ι) → AddZeroClass (β₂ i)]
Goal: (DFinsupp.mapRange.addMonoidHom fun i => AddMonoidHom.id (β₂ i)) = AddMonoidHom.id (Π₀ (i : ι), β₂ i)
-- DFinsupp.mapRange.addMonoidHom_comp
theorem mapRange.addMonoidHom_comp (f : ∀ i, β₁ i →+ β₂ i) (f₂ : ∀ i, β i →+ β₁ i) :
    (mapRange.addMonoidHom fun i => (f i).comp (f₂ i)) =
      (mapRange.addMonoidHom f).comp (mapRange.addMonoidHom f₂) 
Arguments: {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [(i : ι) → AddZeroClass (β i)] [(i : ι) → AddZeroClass (β₁ i)] [(i : ι) → AddZeroClass (β₂ i)] (f : (i : ι) → β₁ i →+ β₂ i) (f₂ : (i : ι) → β i →+ β₁ i)
Goal: (DFinsupp.mapRange.addMonoidHom fun i => (f i).comp (f₂ i)) =
  (DFinsupp.mapRange.addMonoidHom f).comp (DFinsupp.mapRange.addMonoidHom f₂)
-- DFinsupp.mapRange.addEquiv_apply
@[simps apply]
def mapRange.addEquiv (e : ∀ i, β₁ i ≃+ β₂ i) : (Π₀ i, β₁ i) ≃+ Π₀ i, β₂ i 
Arguments: {ι : Type u} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [(i : ι) → AddZeroClass (β₁ i)] [(i : ι) → AddZeroClass (β₂ i)] (e : (i : ι) → β₁ i ≃+ β₂ i) (x : Π₀ (i : ι), β₁ i)
Goal: (DFinsupp.mapRange.addEquiv e) x = DFinsupp.mapRange (fun i x => (e i) x) ⋯ x
-- DFinsupp.mapRange.addEquiv_refl
@[simp]
theorem mapRange.addEquiv_refl :
    (mapRange.addEquiv fun i => AddEquiv.refl (β₁ i)) = AddEquiv.refl _ 
Arguments: {ι : Type u} {β₁ : ι → Type v₁} [(i : ι) → AddZeroClass (β₁ i)]
Goal: (DFinsupp.mapRange.addEquiv fun i => AddEquiv.refl (β₁ i)) = AddEquiv.refl (Π₀ (i : ι), β₁ i)
-- DFinsupp.mapRange.addEquiv_trans
theorem mapRange.addEquiv_trans (f : ∀ i, β i ≃+ β₁ i) (f₂ : ∀ i, β₁ i ≃+ β₂ i) :
    (mapRange.addEquiv fun i => (f i).trans (f₂ i)) =
      (mapRange.addEquiv f).trans (mapRange.addEquiv f₂) 
Arguments: {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [(i : ι) → AddZeroClass (β i)] [(i : ι) → AddZeroClass (β₁ i)] [(i : ι) → AddZeroClass (β₂ i)] (f : (i : ι) → β i ≃+ β₁ i) (f₂ : (i : ι) → β₁ i ≃+ β₂ i)
Goal: (DFinsupp.mapRange.addEquiv fun i => (f i).trans (f₂ i)) =
  (DFinsupp.mapRange.addEquiv f).trans (DFinsupp.mapRange.addEquiv f₂)
-- DFinsupp.mapRange.addEquiv_symm
@[simp]
theorem mapRange.addEquiv_symm (e : ∀ i, β₁ i ≃+ β₂ i) :
    (mapRange.addEquiv e).symm = mapRange.addEquiv fun i => (e i).symm 
Arguments: {ι : Type u} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [(i : ι) → AddZeroClass (β₁ i)] [(i : ι) → AddZeroClass (β₂ i)] (e : (i : ι) → β₁ i ≃+ β₂ i)
Goal: (DFinsupp.mapRange.addEquiv e).symm = DFinsupp.mapRange.addEquiv fun i => (e i).symm
-- AddMonoidHom.coe_dfinsupp_sum
@[to_additive (attr := simp, norm_cast)]
theorem coe_dfinsupp_prod [Monoid R] [CommMonoid S] (f : Π₀ i, β i) (g : ∀ i, β i → R →* S) :
    ⇑(f.prod g) = f.prod fun a b => ⇑(g a b) 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [(i : ι) → Zero (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] [AddMonoid R] [AddCommMonoid S] (f : Π₀ (i : ι), β i) (g : (i : ι) → β i → R →+ S)
Goal: ⇑(f.sum g) = f.sum fun a b => ⇑(g a b)
-- MonoidHom.coe_dfinsupp_prod
@[to_additive (attr := simp, norm_cast)]
theorem coe_dfinsupp_prod [Monoid R] [CommMonoid S] (f : Π₀ i, β i) (g : ∀ i, β i → R →* S) :
    ⇑(f.prod g) = f.prod fun a b => ⇑(g a b) 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [(i : ι) → Zero (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] [Monoid R] [CommMonoid S] (f : Π₀ (i : ι), β i) (g : (i : ι) → β i → R →* S)
Goal: ⇑(f.prod g) = f.prod fun a b => ⇑(g a b)
-- AddMonoidHom.dfinsupp_sum_apply
@[to_additive]
theorem dfinsupp_prod_apply [Monoid R] [CommMonoid S] (f : Π₀ i, β i) (g : ∀ i, β i → R →* S)
    (r : R) : (f.prod g) r = f.prod fun a b => (g a b) r 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [(i : ι) → Zero (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] [AddMonoid R] [AddCommMonoid S] (f : Π₀ (i : ι), β i) (g : (i : ι) → β i → R →+ S) (r : R)
Goal: (f.sum g) r = f.sum fun a b => (g a b) r
-- MonoidHom.dfinsupp_prod_apply
@[to_additive]
theorem dfinsupp_prod_apply [Monoid R] [CommMonoid S] (f : Π₀ i, β i) (g : ∀ i, β i → R →* S)
    (r : R) : (f.prod g) r = f.prod fun a b => (g a b) r 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [(i : ι) → Zero (β i)] [(i : ι) → (x : β i) → Decidable (x ≠ 0)] [Monoid R] [CommMonoid S] (f : Π₀ (i : ι), β i) (g : (i : ι) → β i → R →* S) (r : R)
Goal: (f.prod g) r = f.prod fun a b => (g a b) r
-- AddMonoidHom.map_dfinsupp_sumAddHom
@[simp]
theorem map_dfinsupp_sumAddHom [AddCommMonoid R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (h : R →+ S) (f : Π₀ i, β i) (g : ∀ i, β i →+ R) :
    h (sumAddHom g f) = sumAddHom (fun i => h.comp (g i)) f 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [AddCommMonoid R] [AddCommMonoid S] [(i : ι) → AddZeroClass (β i)] (h : R →+ S) (f : Π₀ (i : ι), β i) (g : (i : ι) → β i →+ R)
Goal: h ((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => h.comp (g i)) f
-- AddMonoidHom.dfinsupp_sumAddHom_apply
theorem dfinsupp_sumAddHom_apply [AddZeroClass R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (f : Π₀ i, β i) (g : ∀ i, β i →+ R →+ S) (r : R) :
    (sumAddHom g f) r = sumAddHom (fun i => (eval r).comp (g i)) f 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [AddZeroClass R] [AddCommMonoid S] [(i : ι) → AddZeroClass (β i)] (f : Π₀ (i : ι), β i) (g : (i : ι) → β i →+ R →+ S) (r : R)
Goal: ((DFinsupp.sumAddHom g) f) r = (DFinsupp.sumAddHom fun i => (AddMonoidHom.eval r).comp (g i)) f
-- AddMonoidHom.coe_dfinsupp_sumAddHom
@[simp, norm_cast]
theorem coe_dfinsupp_sumAddHom [AddZeroClass R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (f : Π₀ i, β i) (g : ∀ i, β i →+ R →+ S) :
    ⇑(sumAddHom g f) = sumAddHom (fun i => (coeFn R S).comp (g i)) f 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [AddZeroClass R] [AddCommMonoid S] [(i : ι) → AddZeroClass (β i)] (f : Π₀ (i : ι), β i) (g : (i : ι) → β i →+ R →+ S)
Goal: ⇑((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => (AddMonoidHom.coeFn R S).comp (g i)) f
-- RingHom.map_dfinsupp_sumAddHom
@[simp]
theorem map_dfinsupp_sumAddHom [NonAssocSemiring R] [NonAssocSemiring S] [∀ i, AddZeroClass (β i)]
    (h : R →+* S) (f : Π₀ i, β i) (g : ∀ i, β i →+ R) :
    h (sumAddHom g f) = sumAddHom (fun i => h.toAddMonoidHom.comp (g i)) f 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [NonAssocSemiring R] [NonAssocSemiring S] [(i : ι) → AddZeroClass (β i)] (h : R →+* S) (f : Π₀ (i : ι), β i) (g : (i : ι) → β i →+ R)
Goal: h ((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => h.toAddMonoidHom.comp (g i)) f
-- AddEquiv.map_dfinsupp_sumAddHom
@[simp]
theorem map_dfinsupp_sumAddHom [AddCommMonoid R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (h : R ≃+ S) (f : Π₀ i, β i) (g : ∀ i, β i →+ R) :
    h (sumAddHom g f) = sumAddHom (fun i => h.toAddMonoidHom.comp (g i)) f 
Arguments: {ι : Type u} {β : ι → Type v} [DecidableEq ι] {R : Type u_1} {S : Type u_2} [AddCommMonoid R] [AddCommMonoid S] [(i : ι) → AddZeroClass (β i)] (h : R ≃+ S) (f : Π₀ (i : ι), β i) (g : (i : ι) → β i →+ R)
Goal: h ((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => h.toAddMonoidHom.comp (g i)) f
-- DFinsupp.infinite_of_exists_right
theorem DFinsupp.infinite_of_exists_right {ι : Sort _} {π : ι → Sort _} (i : ι) [Infinite (π i)]
    [∀ i, Zero (π i)] : Infinite (Π₀ i, π i) 
Arguments: {ι : Type u_1} {π : ι → Type u_2} (i : ι) [Infinite (π i)] [(i : ι) → Zero (π i)]
Goal: Infinite (Π₀ (i : ι), π i)
-- Complex.isCauSeq_abs_exp
theorem isCauSeq_abs_exp (z : ℂ) :
    IsCauSeq _root_.abs fun n => ∑ m ∈ range n, abs (z ^ m / m.factorial) 
Arguments: (z : ℂ)
Goal: IsCauSeq abs fun n => ∑ m ∈ Finset.range n, Complex.abs (z ^ m / ↑m.factorial)
-- Complex.isCauSeq_exp
theorem isCauSeq_exp (z : ℂ) : IsCauSeq abs fun n => ∑ m ∈ range n, z ^ m / m.factorial 
Arguments: (z : ℂ)
Goal: IsCauSeq ⇑Complex.abs fun n => ∑ m ∈ Finset.range n, z ^ m / ↑m.factorial
-- Complex.exp_zero
@[simp]
theorem exp_zero : exp 0 = 1 
Goal: Complex.exp 0 = 1
-- Complex.exp_add
theorem exp_add : exp (x + y) = exp x * exp y 
Arguments: (x y : ℂ)
Goal: Complex.exp (x + y) = Complex.exp x * Complex.exp y
-- Complex.exp_list_sum
theorem exp_list_sum (l : List ℂ) : exp l.sum = (l.map exp).prod 
Arguments: (l : List ℂ)
Goal: Complex.exp l.sum = (List.map Complex.exp l).prod
-- Complex.exp_multiset_sum
theorem exp_multiset_sum (s : Multiset ℂ) : exp s.sum = (s.map exp).prod 
Arguments: (s : Multiset ℂ)
Goal: Complex.exp s.sum = (Multiset.map Complex.exp s).prod
-- Complex.exp_sum
theorem exp_sum {α : Type*} (s : Finset α) (f : α → ℂ) :
    exp (∑ x ∈ s, f x) = ∏ x ∈ s, exp (f x) 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℂ)
Goal: Complex.exp (∑ x ∈ s, f x) = ∏ x ∈ s, Complex.exp (f x)
-- Complex.exp_nsmul
lemma exp_nsmul (x : ℂ) (n : ℕ) : exp (n • x) = exp x ^ n 
Arguments: (x : ℂ) (n : ℕ)
Goal: Complex.exp (n • x) = Complex.exp x ^ n
-- Complex.exp_nat_mul
theorem exp_nat_mul (x : ℂ) : ∀ n : ℕ, exp (n * x) = exp x ^ n
  
Arguments: (x : ℂ) (n : ℕ)
Goal: Complex.exp (↑n * x) = Complex.exp x ^ n
-- Complex.exp_ne_zero
@[simp]
theorem exp_ne_zero : exp x ≠ 0 
Arguments: (x : ℂ)
Goal: Complex.exp x ≠ 0
-- Complex.exp_neg
theorem exp_neg : exp (-x) = (exp x)⁻¹ 
Arguments: (x : ℂ)
Goal: Complex.exp (-x) = (Complex.exp x)⁻¹
-- Complex.exp_sub
theorem exp_sub : exp (x - y) = exp x / exp y 
Arguments: (x y : ℂ)
Goal: Complex.exp (x - y) = Complex.exp x / Complex.exp y
-- Complex.exp_int_mul
theorem exp_int_mul (z : ℂ) (n : ℤ) : Complex.exp (n * z) = Complex.exp z ^ n 
Arguments: (z : ℂ) (n : ℤ)
Goal: Complex.exp (↑n * z) = Complex.exp z ^ n
-- Complex.exp_conj
@[simp]
theorem exp_conj : exp (conj x) = conj (exp x) 
Arguments: (x : ℂ)
Goal: Complex.exp ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.exp x)
-- Complex.ofReal_exp_ofReal_re
@[simp]
theorem ofReal_exp_ofReal_re (x : ℝ) : ((exp x).re : ℂ) = exp x 
Arguments: (x : ℝ)
Goal: ↑(Complex.exp ↑x).re = Complex.exp ↑x
-- Complex.ofReal_exp
@[simp, norm_cast]
theorem ofReal_exp (x : ℝ) : (Real.exp x : ℂ) = exp x 
Arguments: (x : ℝ)
Goal: ↑(Real.exp x) = Complex.exp ↑x
-- Complex.exp_ofReal_im
@[simp]
theorem exp_ofReal_im (x : ℝ) : (exp x).im = 0 
Arguments: (x : ℝ)
Goal: (Complex.exp ↑x).im = 0
-- Complex.exp_ofReal_re
theorem exp_ofReal_re (x : ℝ) : (exp x).re = Real.exp x 
Arguments: (x : ℝ)
Goal: (Complex.exp ↑x).re = Real.exp x
-- Complex.two_sinh
theorem two_sinh : 2 * sinh x = exp x - exp (-x) 
Arguments: (x : ℂ)
Goal: 2 * Complex.sinh x = Complex.exp x - Complex.exp (-x)
-- Complex.two_cosh
theorem two_cosh : 2 * cosh x = exp x + exp (-x) 
Arguments: (x : ℂ)
Goal: 2 * Complex.cosh x = Complex.exp x + Complex.exp (-x)
-- Complex.sinh_zero
@[simp]
theorem sinh_zero : sinh 0 = 0 
Goal: Complex.sinh 0 = 0
-- Complex.sinh_neg
@[simp]
theorem sinh_neg : sinh (-x) = -sinh x 
Arguments: (x : ℂ)
Goal: Complex.sinh (-x) = -Complex.sinh x
-- _private.Mathlib.Data.Complex.Exponential.0.Complex.sinh_add_aux
private theorem sinh_add_aux {a b c d : ℂ} :
    (a - b) * (c + d) + (a + b) * (c - d) = 2 * (a * c - b * d) 
Arguments: {a b c d : ℂ}
Goal: (a - b) * (c + d) + (a + b) * (c - d) = 2 * (a * c - b * d)
-- Complex.sinh_add
theorem sinh_add : sinh (x + y) = sinh x * cosh y + cosh x * sinh y 
Arguments: (x y : ℂ)
Goal: Complex.sinh (x + y) = Complex.sinh x * Complex.cosh y + Complex.cosh x * Complex.sinh y
-- Complex.cosh_zero
@[simp]
theorem cosh_zero : cosh 0 = 1 
Goal: Complex.cosh 0 = 1
-- Complex.cosh_neg
@[simp]
theorem cosh_neg : cosh (-x) = cosh x 
Arguments: (x : ℂ)
Goal: Complex.cosh (-x) = Complex.cosh x
-- _private.Mathlib.Data.Complex.Exponential.0.Complex.cosh_add_aux
private theorem cosh_add_aux {a b c d : ℂ} :
    (a + b) * (c + d) + (a - b) * (c - d) = 2 * (a * c + b * d) 
Arguments: {a b c d : ℂ}
Goal: (a + b) * (c + d) + (a - b) * (c - d) = 2 * (a * c + b * d)
-- Complex.cosh_add
theorem cosh_add : cosh (x + y) = cosh x * cosh y + sinh x * sinh y 
Arguments: (x y : ℂ)
Goal: Complex.cosh (x + y) = Complex.cosh x * Complex.cosh y + Complex.sinh x * Complex.sinh y
-- Complex.sinh_sub
theorem sinh_sub : sinh (x - y) = sinh x * cosh y - cosh x * sinh y 
Arguments: (x y : ℂ)
Goal: Complex.sinh (x - y) = Complex.sinh x * Complex.cosh y - Complex.cosh x * Complex.sinh y
-- Complex.cosh_sub
theorem cosh_sub : cosh (x - y) = cosh x * cosh y - sinh x * sinh y 
Arguments: (x y : ℂ)
Goal: Complex.cosh (x - y) = Complex.cosh x * Complex.cosh y - Complex.sinh x * Complex.sinh y
-- Complex.sinh_conj
theorem sinh_conj : sinh (conj x) = conj (sinh x) 
Arguments: (x : ℂ)
Goal: Complex.sinh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.sinh x)
-- Complex.ofReal_sinh_ofReal_re
@[simp]
theorem ofReal_sinh_ofReal_re (x : ℝ) : ((sinh x).re : ℂ) = sinh x 
Arguments: (x : ℝ)
Goal: ↑(Complex.sinh ↑x).re = Complex.sinh ↑x
-- Complex.ofReal_sinh
@[simp, norm_cast]
theorem ofReal_sinh (x : ℝ) : (Real.sinh x : ℂ) = sinh x 
Arguments: (x : ℝ)
Goal: ↑(Real.sinh x) = Complex.sinh ↑x
-- Complex.sinh_ofReal_im
@[simp]
theorem sinh_ofReal_im (x : ℝ) : (sinh x).im = 0 
Arguments: (x : ℝ)
Goal: (Complex.sinh ↑x).im = 0
-- Complex.sinh_ofReal_re
theorem sinh_ofReal_re (x : ℝ) : (sinh x).re = Real.sinh x 
Arguments: (x : ℝ)
Goal: (Complex.sinh ↑x).re = Real.sinh x
-- Complex.cosh_conj
theorem cosh_conj : cosh (conj x) = conj (cosh x) 
Arguments: (x : ℂ)
Goal: Complex.cosh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.cosh x)
-- Complex.ofReal_cosh_ofReal_re
theorem ofReal_cosh_ofReal_re (x : ℝ) : ((cosh x).re : ℂ) = cosh x 
Arguments: (x : ℝ)
Goal: ↑(Complex.cosh ↑x).re = Complex.cosh ↑x
-- Complex.ofReal_cosh
@[simp, norm_cast]
theorem ofReal_cosh (x : ℝ) : (Real.cosh x : ℂ) = cosh x 
Arguments: (x : ℝ)
Goal: ↑(Real.cosh x) = Complex.cosh ↑x
-- Complex.cosh_ofReal_im
@[simp]
theorem cosh_ofReal_im (x : ℝ) : (cosh x).im = 0 
Arguments: (x : ℝ)
Goal: (Complex.cosh ↑x).im = 0
-- Complex.cosh_ofReal_re
@[simp]
theorem cosh_ofReal_re (x : ℝ) : (cosh x).re = Real.cosh x 
Arguments: (x : ℝ)
Goal: (Complex.cosh ↑x).re = Real.cosh x
-- Complex.tanh_eq_sinh_div_cosh
theorem tanh_eq_sinh_div_cosh : tanh x = sinh x / cosh x 
Arguments: (x : ℂ)
Goal: Complex.tanh x = Complex.sinh x / Complex.cosh x
-- Complex.tanh_zero
@[simp]
theorem tanh_zero : tanh 0 = 0 
Goal: Complex.tanh 0 = 0
-- Complex.tanh_neg
@[simp]
theorem tanh_neg : tanh (-x) = -tanh x 
Arguments: (x : ℂ)
Goal: Complex.tanh (-x) = -Complex.tanh x
-- Complex.tanh_conj
theorem tanh_conj : tanh (conj x) = conj (tanh x) 
Arguments: (x : ℂ)
Goal: Complex.tanh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.tanh x)
-- Complex.ofReal_tanh_ofReal_re
@[simp]
theorem ofReal_tanh_ofReal_re (x : ℝ) : ((tanh x).re : ℂ) = tanh x 
Arguments: (x : ℝ)
Goal: ↑(Complex.tanh ↑x).re = Complex.tanh ↑x
-- Complex.ofReal_tanh
@[simp, norm_cast]
theorem ofReal_tanh (x : ℝ) : (Real.tanh x : ℂ) = tanh x 
Arguments: (x : ℝ)
Goal: ↑(Real.tanh x) = Complex.tanh ↑x
-- Complex.tanh_ofReal_im
@[simp]
theorem tanh_ofReal_im (x : ℝ) : (tanh x).im = 0 
Arguments: (x : ℝ)
Goal: (Complex.tanh ↑x).im = 0
-- Complex.tanh_ofReal_re
theorem tanh_ofReal_re (x : ℝ) : (tanh x).re = Real.tanh x 
Arguments: (x : ℝ)
Goal: (Complex.tanh ↑x).re = Real.tanh x
-- Complex.cosh_add_sinh
@[simp]
theorem cosh_add_sinh : cosh x + sinh x = exp x 
Arguments: (x : ℂ)
Goal: Complex.cosh x + Complex.sinh x = Complex.exp x
-- Complex.sinh_add_cosh
@[simp]
theorem sinh_add_cosh : sinh x + cosh x = exp x 
Arguments: (x : ℂ)
Goal: Complex.sinh x + Complex.cosh x = Complex.exp x
-- Complex.exp_sub_cosh
@[simp]
theorem exp_sub_cosh : exp x - cosh x = sinh x 
Arguments: (x : ℂ)
Goal: Complex.exp x - Complex.cosh x = Complex.sinh x
-- Complex.exp_sub_sinh
@[simp]
theorem exp_sub_sinh : exp x - sinh x = cosh x 
Arguments: (x : ℂ)
Goal: Complex.exp x - Complex.sinh x = Complex.cosh x
-- Complex.cosh_sub_sinh
@[simp]
theorem cosh_sub_sinh : cosh x - sinh x = exp (-x) 
Arguments: (x : ℂ)
Goal: Complex.cosh x - Complex.sinh x = Complex.exp (-x)
-- Complex.sinh_sub_cosh
@[simp]
theorem sinh_sub_cosh : sinh x - cosh x = -exp (-x) 
Arguments: (x : ℂ)
Goal: Complex.sinh x - Complex.cosh x = -Complex.exp (-x)
-- Complex.cosh_sq_sub_sinh_sq
@[simp]
theorem cosh_sq_sub_sinh_sq : cosh x ^ 2 - sinh x ^ 2 = 1 
Arguments: (x : ℂ)
Goal: Complex.cosh x ^ 2 - Complex.sinh x ^ 2 = 1
-- Complex.cosh_sq
theorem cosh_sq : cosh x ^ 2 = sinh x ^ 2 + 1 
Arguments: (x : ℂ)
Goal: Complex.cosh x ^ 2 = Complex.sinh x ^ 2 + 1
-- Complex.sinh_sq
theorem sinh_sq : sinh x ^ 2 = cosh x ^ 2 - 1 
Arguments: (x : ℂ)
Goal: Complex.sinh x ^ 2 = Complex.cosh x ^ 2 - 1
-- Complex.cosh_two_mul
theorem cosh_two_mul : cosh (2 * x) = cosh x ^ 2 + sinh x ^ 2 
Arguments: (x : ℂ)
Goal: Complex.cosh (2 * x) = Complex.cosh x ^ 2 + Complex.sinh x ^ 2
-- Complex.sinh_two_mul
theorem sinh_two_mul : sinh (2 * x) = 2 * sinh x * cosh x 
Arguments: (x : ℂ)
Goal: Complex.sinh (2 * x) = 2 * Complex.sinh x * Complex.cosh x
-- Complex.cosh_three_mul
theorem cosh_three_mul : cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x 
Arguments: (x : ℂ)
Goal: Complex.cosh (3 * x) = 4 * Complex.cosh x ^ 3 - 3 * Complex.cosh x
-- Complex.sinh_three_mul
theorem sinh_three_mul : sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x 
Arguments: (x : ℂ)
Goal: Complex.sinh (3 * x) = 4 * Complex.sinh x ^ 3 + 3 * Complex.sinh x
-- Complex.sin_zero
@[simp]
theorem sin_zero : sin 0 = 0 
Goal: Complex.sin 0 = 0
-- Complex.sin_neg
@[simp]
theorem sin_neg : sin (-x) = -sin x 
Arguments: (x : ℂ)
Goal: Complex.sin (-x) = -Complex.sin x
-- Complex.two_sin
theorem two_sin : 2 * sin x = (exp (-x * I) - exp (x * I)) * I 
Arguments: (x : ℂ)
Goal: 2 * Complex.sin x = (Complex.exp (-x * Complex.I) - Complex.exp (x * Complex.I)) * Complex.I
-- Complex.two_cos
theorem two_cos : 2 * cos x = exp (x * I) + exp (-x * I) 
Arguments: (x : ℂ)
Goal: 2 * Complex.cos x = Complex.exp (x * Complex.I) + Complex.exp (-x * Complex.I)
-- Complex.sinh_mul_I
theorem sinh_mul_I : sinh (x * I) = sin x * I 
Arguments: (x : ℂ)
Goal: Complex.sinh (x * Complex.I) = Complex.sin x * Complex.I
-- Complex.cosh_mul_I
theorem cosh_mul_I : cosh (x * I) = cos x 
Arguments: (x : ℂ)
Goal: Complex.cosh (x * Complex.I) = Complex.cos x