ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_add
private theorem abs_add (z w : ℂ) : (abs z + w) ≤ (abs z) + abs w 
Arguments: (z w : ℂ)
Goal: √(Complex.normSq (z + w)) ≤ √(Complex.normSq z) + √(Complex.normSq w)
-- Complex.abs_def
theorem abs_def : (Complex.abs : ℂ → ℝ) = fun z => (normSq z).sqrt 
Goal: ⇑Complex.abs = fun z => √(Complex.normSq z)
-- Complex.abs_apply
theorem abs_apply {z : ℂ} : Complex.abs z = (normSq z).sqrt 
Arguments: {z : ℂ}
Goal: Complex.abs z = √(Complex.normSq z)
-- Complex.abs_ofReal
@[simp, norm_cast]
theorem abs_ofReal (r : ℝ) : Complex.abs r = |r| 
Arguments: (r : ℝ)
Goal: Complex.abs ↑r = |r|
-- Complex.abs_of_nonneg
nonrec theorem abs_of_nonneg {r : ℝ} (h : 0 ≤ r) : Complex.abs r = r 
Arguments: {r : ℝ} (h : 0 ≤ r)
Goal: Complex.abs ↑r = r
-- Complex.abs_natCast
@[simp]
theorem abs_natCast (n : ℕ) : Complex.abs n = n 
Arguments: (n : ℕ)
Goal: Complex.abs ↑n = ↑n
-- Complex.abs_ofNat
@[simp]
theorem abs_ofNat (n : ℕ) [n.AtLeastTwo] :
    Complex.abs (no_index (OfNat.ofNat n : ℂ)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: Complex.abs (OfNat.ofNat n) = OfNat.ofNat n
-- Complex.mul_self_abs
theorem mul_self_abs (z : ℂ) : Complex.abs z * Complex.abs z = normSq z 
Arguments: (z : ℂ)
Goal: Complex.abs z * Complex.abs z = Complex.normSq z
-- Complex.sq_abs
theorem sq_abs (z : ℂ) : Complex.abs z ^ 2 = normSq z 
Arguments: (z : ℂ)
Goal: Complex.abs z ^ 2 = Complex.normSq z
-- Complex.sq_abs_sub_sq_re
@[simp]
theorem sq_abs_sub_sq_re (z : ℂ) : Complex.abs z ^ 2 - z.re ^ 2 = z.im ^ 2 
Arguments: (z : ℂ)
Goal: Complex.abs z ^ 2 - z.re ^ 2 = z.im ^ 2
-- Complex.sq_abs_sub_sq_im
@[simp]
theorem sq_abs_sub_sq_im (z : ℂ) : Complex.abs z ^ 2 - z.im ^ 2 = z.re ^ 2 
Arguments: (z : ℂ)
Goal: Complex.abs z ^ 2 - z.im ^ 2 = z.re ^ 2
-- Complex.abs_add_mul_I
lemma abs_add_mul_I (x y : ℝ) : abs (x + y * I) = (x ^ 2 + y ^ 2).sqrt 
Arguments: (x y : ℝ)
Goal: Complex.abs (↑x + ↑y * Complex.I) = √(x ^ 2 + y ^ 2)
-- Complex.abs_eq_sqrt_sq_add_sq
lemma abs_eq_sqrt_sq_add_sq (z : ℂ) : abs z = (z.re ^ 2 + z.im ^ 2).sqrt 
Arguments: (z : ℂ)
Goal: Complex.abs z = √(z.re ^ 2 + z.im ^ 2)
-- Complex.abs_I
@[simp]
theorem abs_I : Complex.abs I = 1 
Goal: Complex.abs Complex.I = 1
-- Complex.abs_two
theorem abs_two : Complex.abs 2 = 2 
Goal: Complex.abs 2 = 2
-- Complex.range_abs
@[simp]
theorem range_abs : range Complex.abs = Ici 0 
Goal: Set.range ⇑Complex.abs = Set.Ici 0
-- Complex.abs_conj
@[simp]
theorem abs_conj (z : ℂ) : Complex.abs (conj z) = Complex.abs z 
Arguments: (z : ℂ)
Goal: Complex.abs ((starRingEnd ℂ) z) = Complex.abs z
-- Complex.abs_prod
theorem abs_prod {ι : Type*} (s : Finset ι) (f : ι → ℂ) :
    Complex.abs (s.prod f) = s.prod fun I => Complex.abs (f I) 
Arguments: {ι : Type u_1} (s : Finset ι) (f : ι → ℂ)
Goal: Complex.abs (s.prod f) = ∏ I ∈ s, Complex.abs (f I)
-- Complex.abs_pow
theorem abs_pow (z : ℂ) (n : ℕ) : Complex.abs (z ^ n) = Complex.abs z ^ n 
Arguments: (z : ℂ) (n : ℕ)
Goal: Complex.abs (z ^ n) = Complex.abs z ^ n
-- Complex.abs_zpow
theorem abs_zpow (z : ℂ) (n : ℤ) : Complex.abs (z ^ n) = Complex.abs z ^ n 
Arguments: (z : ℂ) (n : ℤ)
Goal: Complex.abs (z ^ n) = Complex.abs z ^ n
-- Complex.abs_re_le_abs
theorem abs_re_le_abs (z : ℂ) : |z.re| ≤ Complex.abs z 
Arguments: (z : ℂ)
Goal: |z.re| ≤ Complex.abs z
-- Complex.abs_im_le_abs
theorem abs_im_le_abs (z : ℂ) : |z.im| ≤ Complex.abs z 
Arguments: (z : ℂ)
Goal: |z.im| ≤ Complex.abs z
-- Complex.re_le_abs
theorem re_le_abs (z : ℂ) : z.re ≤ Complex.abs z 
Arguments: (z : ℂ)
Goal: z.re ≤ Complex.abs z
-- Complex.im_le_abs
theorem im_le_abs (z : ℂ) : z.im ≤ Complex.abs z 
Arguments: (z : ℂ)
Goal: z.im ≤ Complex.abs z
-- Complex.abs_re_lt_abs
@[simp]
theorem abs_re_lt_abs {z : ℂ} : |z.re| < Complex.abs z ↔ z.im ≠ 0 
Arguments: {z : ℂ}
Goal: |z.re| < Complex.abs z ↔ z.im ≠ 0
-- Complex.abs_im_lt_abs
@[simp]
theorem abs_im_lt_abs {z : ℂ} : |z.im| < Complex.abs z ↔ z.re ≠ 0 
Arguments: {z : ℂ}
Goal: |z.im| < Complex.abs z ↔ z.re ≠ 0
-- Complex.abs_re_eq_abs
@[simp]
lemma abs_re_eq_abs {z : ℂ} : |z.re| = abs z ↔ z.im = 0 
Arguments: {z : ℂ}
Goal: |z.re| = Complex.abs z ↔ z.im = 0
-- Complex.abs_im_eq_abs
@[simp]
lemma abs_im_eq_abs {z : ℂ} : |z.im| = abs z ↔ z.re = 0 
Arguments: {z : ℂ}
Goal: |z.im| = Complex.abs z ↔ z.re = 0
-- Complex.abs_abs
@[simp]
theorem abs_abs (z : ℂ) : |Complex.abs z| = Complex.abs z 
Arguments: (z : ℂ)
Goal: |Complex.abs z| = Complex.abs z
-- Complex.abs_le_abs_re_add_abs_im
theorem abs_le_abs_re_add_abs_im (z : ℂ) : Complex.abs z ≤ |z.re| + |z.im| 
Arguments: (z : ℂ)
Goal: Complex.abs z ≤ |z.re| + |z.im|
-- Complex.abs_le_sqrt_two_mul_max
theorem abs_le_sqrt_two_mul_max (z : ℂ) : Complex.abs z ≤ Real.sqrt 2 * max |z.re| |z.im| 
Arguments: (z : ℂ)
Goal: Complex.abs z ≤ √2 * max |z.re| |z.im|
-- Complex.abs_re_div_abs_le_one
theorem abs_re_div_abs_le_one (z : ℂ) : |z.re / Complex.abs z| ≤ 1 
Arguments: (z : ℂ)
Goal: |z.re / Complex.abs z| ≤ 1
-- Complex.abs_im_div_abs_le_one
theorem abs_im_div_abs_le_one (z : ℂ) : |z.im / Complex.abs z| ≤ 1 
Arguments: (z : ℂ)
Goal: |z.im / Complex.abs z| ≤ 1
-- Complex.abs_intCast
@[simp, norm_cast] lemma abs_intCast (n : ℤ) : abs n = |↑n| 
Arguments: (n : ℤ)
Goal: Complex.abs ↑n = |↑n|
-- Complex.int_cast_abs
@[deprecated (since := "2024-02-14")]
lemma int_cast_abs (n : ℤ) : |↑n| = Complex.abs n 
Arguments: (n : ℤ)
Goal: |↑n| = Complex.abs ↑n
-- Complex.normSq_eq_abs
theorem normSq_eq_abs (x : ℂ) : normSq x = (Complex.abs x) ^ 2 
Arguments: (x : ℂ)
Goal: Complex.normSq x = Complex.abs x ^ 2
-- Complex.range_normSq
@[simp]
theorem range_normSq : range normSq = Ici 0 
Goal: Set.range ⇑Complex.normSq = Set.Ici 0
-- Complex.isCauSeq_re
theorem isCauSeq_re (f : CauSeq ℂ Complex.abs) : IsCauSeq abs' fun n => (f n).re 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: IsCauSeq abs fun n => (↑f n).re
-- Complex.isCauSeq_im
theorem isCauSeq_im (f : CauSeq ℂ Complex.abs) : IsCauSeq abs' fun n => (f n).im 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: IsCauSeq abs fun n => (↑f n).im
-- Complex.isCauSeq_abs
theorem isCauSeq_abs {f : ℕ → ℂ} (hf : IsCauSeq Complex.abs f) :
    IsCauSeq abs' (Complex.abs ∘ f) 
Arguments: {f : ℕ → ℂ} (hf : IsCauSeq (⇑Complex.abs) f)
Goal: IsCauSeq abs (⇑Complex.abs ∘ f)
-- Complex.equiv_limAux
theorem equiv_limAux (f : CauSeq ℂ Complex.abs) :
    f ≈ CauSeq.const Complex.abs (limAux f) 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: f ≈ CauSeq.const (⇑Complex.abs) (Complex.limAux f)
-- Complex.lim_eq_lim_im_add_lim_re
theorem lim_eq_lim_im_add_lim_re (f : CauSeq ℂ Complex.abs) :
    lim f = ↑(lim (cauSeqRe f)) + ↑(lim (cauSeqIm f)) * I 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: f.lim = ↑(Complex.cauSeqRe f).lim + ↑(Complex.cauSeqIm f).lim * Complex.I
-- Complex.lim_re
theorem lim_re (f : CauSeq ℂ Complex.abs) : lim (cauSeqRe f) = (lim f).re 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: (Complex.cauSeqRe f).lim = f.lim.re
-- Complex.lim_im
theorem lim_im (f : CauSeq ℂ Complex.abs) : lim (cauSeqIm f) = (lim f).im 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: (Complex.cauSeqIm f).lim = f.lim.im
-- Complex.isCauSeq_conj
theorem isCauSeq_conj (f : CauSeq ℂ Complex.abs) :
    IsCauSeq Complex.abs fun n => conj (f n) 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: IsCauSeq ⇑Complex.abs fun n => (starRingEnd ℂ) (↑f n)
-- Complex.lim_conj
theorem lim_conj (f : CauSeq ℂ Complex.abs) : lim (cauSeqConj f) = conj (lim f) 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: (Complex.cauSeqConj f).lim = (starRingEnd ℂ) f.lim
-- Complex.lim_abs
theorem lim_abs (f : CauSeq ℂ Complex.abs) : lim (cauSeqAbs f) = Complex.abs (lim f) 
Arguments: (f : CauSeq ℂ ⇑Complex.abs)
Goal: (Complex.cauSeqAbs f).lim = Complex.abs f.lim
-- Complex.ne_zero_of_one_lt_re
lemma ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : s ≠ 0 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: s ≠ 0
-- Complex.re_neg_ne_zero_of_one_lt_re
lemma re_neg_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : (-s).re ≠ 0 
Arguments: {s : ℂ} (hs : 1 < s.re)
Goal: (-s).re ≠ 0
-- Complex.equivRealProd_apply
@[simps apply]
def equivRealProd : ℂ ≃ ℝ × ℝ 
Arguments: (z : ℂ)
Goal: Complex.equivRealProd z = (z.re, z.im)
-- Complex.eta
@[simp]
theorem eta : ∀ z : ℂ, Complex.mk z.re z.im = z
  
Arguments: (z : ℂ)
Goal: { re := z.re, im := z.im } = z
-- Complex.ext
theorem ext : ∀ {z w : ℂ}, z.re = w.re → z.im = w.im → z = w
  
Arguments: {z w : ℂ}
Goal: z.re = w.re → z.im = w.im → z = w
-- Complex.ext_iff
protected theorem ext_iff {z w : ℂ} : z = w ↔ z.re = w.re ∧ z.im = w.im 
Arguments: {z w : ℂ}
Goal: z = w ↔ z.re = w.re ∧ z.im = w.im
-- Complex.re_surjective
theorem re_surjective : Surjective re 
Goal: Function.Surjective Complex.re
-- Complex.im_surjective
theorem im_surjective : Surjective im 
Goal: Function.Surjective Complex.im
-- Complex.range_re
@[simp]
theorem range_re : range re = univ 
Goal: Set.range Complex.re = Set.univ
-- Complex.range_im
@[simp]
theorem range_im : range im = univ 
Goal: Set.range Complex.im = Set.univ
-- Complex.ofReal_re
@[simp, norm_cast]
theorem ofReal_re (r : ℝ) : Complex.re (r : ℂ) = r 
Arguments: (r : ℝ)
Goal: (↑r).re = r
-- Complex.ofReal_im
@[simp, norm_cast]
theorem ofReal_im (r : ℝ) : (r : ℂ).im = 0 
Arguments: (r : ℝ)
Goal: (↑r).im = 0
-- Complex.ofReal_def
theorem ofReal_def (r : ℝ) : (r : ℂ) = ⟨r, 0⟩ 
Arguments: (r : ℝ)
Goal: ↑r = { re := r, im := 0 }
-- Complex.ofReal_inj
@[simp, norm_cast]
theorem ofReal_inj {z w : ℝ} : (z : ℂ) = w ↔ z = w 
Arguments: {z w : ℝ}
Goal: ↑z = ↑w ↔ z = w
-- Complex.ofReal_injective
theorem ofReal_injective : Function.Injective ((↑) : ℝ → ℂ) 
Goal: Function.Injective Complex.ofReal'
-- Complex.mem_reProdIm
theorem mem_reProdIm {z : ℂ} {s t : Set ℝ} : z ∈ s ×ℂ t ↔ z.re ∈ s ∧ z.im ∈ t 
Arguments: {z : ℂ} {s t : Set ℝ}
Goal: z ∈ s ×ℂ t ↔ z.re ∈ s ∧ z.im ∈ t
-- Complex.zero_re
@[simp]
theorem zero_re : (0 : ℂ).re = 0 
Goal: Complex.re 0 = 0
-- Complex.zero_im
@[simp]
theorem zero_im : (0 : ℂ).im = 0 
Goal: Complex.im 0 = 0
-- Complex.ofReal_zero
@[simp, norm_cast]
theorem ofReal_zero : ((0 : ℝ) : ℂ) = 0 
Goal: ↑0 = 0
-- Complex.ofReal_eq_zero
@[simp]
theorem ofReal_eq_zero {z : ℝ} : (z : ℂ) = 0 ↔ z = 0 
Arguments: {z : ℝ}
Goal: ↑z = 0 ↔ z = 0
-- Complex.ofReal_ne_zero
theorem ofReal_ne_zero {z : ℝ} : (z : ℂ) ≠ 0 ↔ z ≠ 0 
Arguments: {z : ℝ}
Goal: ↑z ≠ 0 ↔ z ≠ 0
-- Complex.one_re
@[simp]
theorem one_re : (1 : ℂ).re = 1 
Goal: Complex.re 1 = 1
-- Complex.one_im
@[simp]
theorem one_im : (1 : ℂ).im = 0 
Goal: Complex.im 1 = 0
-- Complex.ofReal_one
@[simp, norm_cast]
theorem ofReal_one : ((1 : ℝ) : ℂ) = 1 
Goal: ↑1 = 1
-- Complex.ofReal_eq_one
@[simp]
theorem ofReal_eq_one {z : ℝ} : (z : ℂ) = 1 ↔ z = 1 
Arguments: {z : ℝ}
Goal: ↑z = 1 ↔ z = 1
-- Complex.ofReal_ne_one
theorem ofReal_ne_one {z : ℝ} : (z : ℂ) ≠ 1 ↔ z ≠ 1 
Arguments: {z : ℝ}
Goal: ↑z ≠ 1 ↔ z ≠ 1
-- Complex.add_re
@[simp]
theorem add_re (z w : ℂ) : (z + w).re = z.re + w.re 
Arguments: (z w : ℂ)
Goal: (z + w).re = z.re + w.re
-- Complex.add_im
@[simp]
theorem add_im (z w : ℂ) : (z + w).im = z.im + w.im 
Arguments: (z w : ℂ)
Goal: (z + w).im = z.im + w.im
-- Complex.ofReal_add
@[simp, norm_cast]
theorem ofReal_add (r s : ℝ) : ((r + s : ℝ) : ℂ) = r + s 
Arguments: (r s : ℝ)
Goal: ↑(r + s) = ↑r + ↑s
-- Complex.neg_re
@[simp]
theorem neg_re (z : ℂ) : (-z).re = -z.re 
Arguments: (z : ℂ)
Goal: (-z).re = -z.re
-- Complex.neg_im
@[simp]
theorem neg_im (z : ℂ) : (-z).im = -z.im 
Arguments: (z : ℂ)
Goal: (-z).im = -z.im
-- Complex.ofReal_neg
@[simp, norm_cast]
theorem ofReal_neg (r : ℝ) : ((-r : ℝ) : ℂ) = -r 
Arguments: (r : ℝ)
Goal: ↑(-r) = -↑r
-- Complex.mul_re
@[simp]
theorem mul_re (z w : ℂ) : (z * w).re = z.re * w.re - z.im * w.im 
Arguments: (z w : ℂ)
Goal: (z * w).re = z.re * w.re - z.im * w.im
-- Complex.mul_im
@[simp]
theorem mul_im (z w : ℂ) : (z * w).im = z.re * w.im + z.im * w.re 
Arguments: (z w : ℂ)
Goal: (z * w).im = z.re * w.im + z.im * w.re
-- Complex.ofReal_mul
@[simp, norm_cast]
theorem ofReal_mul (r s : ℝ) : ((r * s : ℝ) : ℂ) = r * s 
Arguments: (r s : ℝ)
Goal: ↑(r * s) = ↑r * ↑s
-- Complex.re_ofReal_mul
theorem re_ofReal_mul (r : ℝ) (z : ℂ) : (r * z).re = r * z.re 
Arguments: (r : ℝ) (z : ℂ)
Goal: (↑r * z).re = r * z.re
-- Complex.im_ofReal_mul
theorem im_ofReal_mul (r : ℝ) (z : ℂ) : (r * z).im = r * z.im 
Arguments: (r : ℝ) (z : ℂ)
Goal: (↑r * z).im = r * z.im
-- Complex.re_mul_ofReal
lemma re_mul_ofReal (z : ℂ) (r : ℝ) : (z * r).re = z.re *  r 
Arguments: (z : ℂ) (r : ℝ)
Goal: (z * ↑r).re = z.re * r
-- Complex.im_mul_ofReal
lemma im_mul_ofReal (z : ℂ) (r : ℝ) : (z * r).im = z.im *  r 
Arguments: (z : ℂ) (r : ℝ)
Goal: (z * ↑r).im = z.im * r
-- Complex.ofReal_mul'
theorem ofReal_mul' (r : ℝ) (z : ℂ) : ↑r * z = ⟨r * z.re, r * z.im⟩ 
Arguments: (r : ℝ) (z : ℂ)
Goal: ↑r * z = { re := r * z.re, im := r * z.im }
-- Complex.I_re
@[simp]
theorem I_re : I.re = 0 
Goal: Complex.I.re = 0
-- Complex.I_im
@[simp]
theorem I_im : I.im = 1 
Goal: Complex.I.im = 1
-- Complex.I_mul_I
@[simp]
theorem I_mul_I : I * I = -1 
Goal: Complex.I * Complex.I = -1
-- Complex.I_mul
theorem I_mul (z : ℂ) : I * z = ⟨-z.im, z.re⟩ 
Arguments: (z : ℂ)
Goal: Complex.I * z = { re := -z.im, im := z.re }
-- Complex.I_ne_zero
@[simp] lemma I_ne_zero : (I : ℂ) ≠ 0 
Goal: Complex.I ≠ 0
-- Complex.mk_eq_add_mul_I
theorem mk_eq_add_mul_I (a b : ℝ) : Complex.mk a b = a + b * I 
Arguments: (a b : ℝ)
Goal: { re := a, im := b } = ↑a + ↑b * Complex.I
-- Complex.re_add_im
@[simp]
theorem re_add_im (z : ℂ) : (z.re : ℂ) + z.im * I = z 
Arguments: (z : ℂ)
Goal: ↑z.re + ↑z.im * Complex.I = z
-- Complex.mul_I_re
theorem mul_I_re (z : ℂ) : (z * I).re = -z.im 
Arguments: (z : ℂ)
Goal: (z * Complex.I).re = -z.im
-- Complex.mul_I_im
theorem mul_I_im (z : ℂ) : (z * I).im = z.re 
Arguments: (z : ℂ)
Goal: (z * Complex.I).im = z.re
-- Complex.I_mul_re
theorem I_mul_re (z : ℂ) : (I * z).re = -z.im 
Arguments: (z : ℂ)
Goal: (Complex.I * z).re = -z.im
-- Complex.I_mul_im
theorem I_mul_im (z : ℂ) : (I * z).im = z.re 
Arguments: (z : ℂ)
Goal: (Complex.I * z).im = z.re
-- Complex.equivRealProd_symm_apply
@[simp]
theorem equivRealProd_symm_apply (p : ℝ × ℝ) : equivRealProd.symm p = p.1 + p.2 * I 
Arguments: (p : ℝ × ℝ)
Goal: Complex.equivRealProd.symm p = ↑p.1 + ↑p.2 * Complex.I
-- Complex.equivRealProdAddHom_symm_apply_re
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdAddHom : ℂ ≃+ ℝ × ℝ 
Arguments: (p : ℝ × ℝ)
Goal: (Complex.equivRealProdAddHom.symm p).re = p.1
-- Complex.equivRealProdAddHom_apply
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdAddHom : ℂ ≃+ ℝ × ℝ 
Arguments: (z : ℂ)
Goal: Complex.equivRealProdAddHom z = (z.re, z.im)
-- Complex.equivRealProdAddHom_symm_apply_im
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdAddHom : ℂ ≃+ ℝ × ℝ 
Arguments: (p : ℝ × ℝ)
Goal: (Complex.equivRealProdAddHom.symm p).im = p.2
-- Complex.equivRealProdAddHom_symm_apply
theorem equivRealProdAddHom_symm_apply (p : ℝ × ℝ) :
    equivRealProdAddHom.symm p = p.1 + p.2 * I 
Arguments: (p : ℝ × ℝ)
Goal: Complex.equivRealProdAddHom.symm p = ↑p.1 + ↑p.2 * Complex.I
-- Complex.smul_re
theorem smul_re (r : R) (z : ℂ) : (r • z).re = r • z.re 
Arguments: {R : Type u_1} [SMul R ℝ] (r : R) (z : ℂ)
Goal: (r • z).re = r • z.re
-- Complex.smul_im
theorem smul_im (r : R) (z : ℂ) : (r • z).im = r • z.im 
Arguments: {R : Type u_1} [SMul R ℝ] (r : R) (z : ℂ)
Goal: (r • z).im = r • z.im
-- Complex.real_smul
@[simp]
theorem real_smul {x : ℝ} {z : ℂ} : x • z = x * z 
Arguments: {x : ℝ} {z : ℂ}
Goal: x • z = ↑x * z
-- Complex.coe_reAddGroupHom
@[simp]
theorem coe_reAddGroupHom : (reAddGroupHom : ℂ → ℝ) = re 
Goal: ⇑Complex.reAddGroupHom = Complex.re
-- Complex.coe_imAddGroupHom
@[simp]
theorem coe_imAddGroupHom : (imAddGroupHom : ℂ → ℝ) = im 
Goal: ⇑Complex.imAddGroupHom = Complex.im
-- Complex.ofReal_ofNat
@[simp, norm_cast] lemma ofReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ofReal' (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- Complex.ofReal_natCast
@[simp, norm_cast] lemma ofReal_natCast (n : ℕ) : ofReal' n = n 
Arguments: (n : ℕ)
Goal: ↑↑n = ↑n
-- Complex.ofReal_intCast
@[simp, norm_cast] lemma ofReal_intCast (n : ℤ) : ofReal' n = n 
Arguments: (n : ℤ)
Goal: ↑↑n = ↑n
-- Complex.ofReal_nnratCast
@[simp, norm_cast] lemma ofReal_nnratCast (q : ℚ≥0) : ofReal' q = q 
Arguments: (q : ℚ≥0)
Goal: ↑↑q = ↑q
-- Complex.ofReal_ratCast
@[simp, norm_cast] lemma ofReal_ratCast (q : ℚ) : ofReal' q = q 
Arguments: (q : ℚ)
Goal: ↑↑q = ↑q
-- Complex.re_ofNat
@[simp]
lemma re_ofNat (n : ℕ) [n.AtLeastTwo] : (no_index (OfNat.ofNat n) : ℂ).re = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).re = OfNat.ofNat n
-- Complex.im_ofNat
@[simp] lemma im_ofNat (n : ℕ) [n.AtLeastTwo] : (no_index (OfNat.ofNat n) : ℂ).im = 0 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).im = 0
-- Complex.natCast_re
@[simp, norm_cast] lemma natCast_re (n : ℕ) : (n : ℂ).re = n 
Arguments: (n : ℕ)
Goal: (↑n).re = ↑n
-- Complex.natCast_im
@[simp, norm_cast] lemma natCast_im (n : ℕ) : (n : ℂ).im = 0 
Arguments: (n : ℕ)
Goal: (↑n).im = 0
-- Complex.intCast_re
@[simp, norm_cast] lemma intCast_re (n : ℤ) : (n : ℂ).re = n 
Arguments: (n : ℤ)
Goal: (↑n).re = ↑n
-- Complex.intCast_im
@[simp, norm_cast] lemma intCast_im (n : ℤ) : (n : ℂ).im = 0 
Arguments: (n : ℤ)
Goal: (↑n).im = 0
-- Complex.re_nnratCast
@[simp, norm_cast] lemma re_nnratCast (q : ℚ≥0) : (q : ℂ).re = q 
Arguments: (q : ℚ≥0)
Goal: (↑q).re = ↑q
-- Complex.im_nnratCast
@[simp, norm_cast] lemma im_nnratCast (q : ℚ≥0) : (q : ℂ).im = 0 
Arguments: (q : ℚ≥0)
Goal: (↑q).im = 0
-- Complex.ratCast_re
@[simp, norm_cast] lemma ratCast_re (q : ℚ) : (q : ℂ).re = q 
Arguments: (q : ℚ)
Goal: (↑q).re = ↑q
-- Complex.ratCast_im
@[simp, norm_cast] lemma ratCast_im (q : ℚ) : (q : ℂ).im = 0 
Arguments: (q : ℚ)
Goal: (↑q).im = 0
-- Complex.ofReal_nsmul
@[norm_cast] lemma ofReal_nsmul (n : ℕ) (r : ℝ) : ↑(n • r) = n • (r : ℂ) 
Arguments: (n : ℕ) (r : ℝ)
Goal: ↑(n • r) = n • ↑r
-- Complex.ofReal_zsmul
@[norm_cast] lemma ofReal_zsmul (n : ℤ) (r : ℝ) : ↑(n • r) = n • (r : ℂ) 
Arguments: (n : ℤ) (r : ℝ)
Goal: ↑(n • r) = n • ↑r
-- Complex.conj_re
@[simp]
theorem conj_re (z : ℂ) : (conj z).re = z.re 
Arguments: (z : ℂ)
Goal: ((starRingEnd ℂ) z).re = z.re
-- Complex.conj_im
@[simp]
theorem conj_im (z : ℂ) : (conj z).im = -z.im 
Arguments: (z : ℂ)
Goal: ((starRingEnd ℂ) z).im = -z.im
-- Complex.conj_ofReal
@[simp]
theorem conj_ofReal (r : ℝ) : conj (r : ℂ) = r 
Arguments: (r : ℝ)
Goal: (starRingEnd ℂ) ↑r = ↑r
-- Complex.conj_I
@[simp]
theorem conj_I : conj I = -I 
Goal: (starRingEnd ℂ) Complex.I = -Complex.I
-- Complex.conj_natCast
theorem conj_natCast (n : ℕ) : conj (n : ℂ) = n 
Arguments: (n : ℕ)
Goal: (starRingEnd ℂ) ↑n = ↑n
-- Complex.conj_ofNat
theorem conj_ofNat (n : ℕ) [n.AtLeastTwo] : conj (no_index (OfNat.ofNat n : ℂ)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (starRingEnd ℂ) (OfNat.ofNat n) = OfNat.ofNat n
-- Complex.conj_neg_I
theorem conj_neg_I : conj (-I) = I 
Goal: (starRingEnd ℂ) (-Complex.I) = Complex.I
-- Complex.conj_eq_iff_real
theorem conj_eq_iff_real {z : ℂ} : conj z = z ↔ ∃ r : ℝ, z = r 
Arguments: {z : ℂ}
Goal: (starRingEnd ℂ) z = z ↔ ∃ r, z = ↑r
-- Complex.conj_eq_iff_re
theorem conj_eq_iff_re {z : ℂ} : conj z = z ↔ (z.re : ℂ) = z 
Arguments: {z : ℂ}
Goal: (starRingEnd ℂ) z = z ↔ ↑z.re = z
-- Complex.conj_eq_iff_im
theorem conj_eq_iff_im {z : ℂ} : conj z = z ↔ z.im = 0 
Arguments: {z : ℂ}
Goal: (starRingEnd ℂ) z = z ↔ z.im = 0
-- Complex.star_def
@[simp]
theorem star_def : (Star.star : ℂ → ℂ) = conj 
Goal: star = ⇑(starRingEnd ℂ)
-- Complex.normSq_apply
theorem normSq_apply (z : ℂ) : normSq z = z.re * z.re + z.im * z.im 
Arguments: (z : ℂ)
Goal: Complex.normSq z = z.re * z.re + z.im * z.im
-- Complex.normSq_ofReal
@[simp]
theorem normSq_ofReal (r : ℝ) : normSq r = r * r 
Arguments: (r : ℝ)
Goal: Complex.normSq ↑r = r * r
-- Complex.normSq_natCast
@[simp]
theorem normSq_natCast (n : ℕ) : normSq n = n * n 
Arguments: (n : ℕ)
Goal: Complex.normSq ↑n = ↑n * ↑n
-- Complex.normSq_intCast
@[simp]
theorem normSq_intCast (z : ℤ) : normSq z = z * z 
Arguments: (z : ℤ)
Goal: Complex.normSq ↑z = ↑z * ↑z
-- Complex.normSq_ratCast
@[simp]
theorem normSq_ratCast (q : ℚ) : normSq q = q * q 
Arguments: (q : ℚ)
Goal: Complex.normSq ↑q = ↑q * ↑q
-- Complex.normSq_ofNat
@[simp]
theorem normSq_ofNat (n : ℕ) [n.AtLeastTwo] :
    normSq (no_index (OfNat.ofNat n : ℂ)) = OfNat.ofNat n * OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: Complex.normSq (OfNat.ofNat n) = OfNat.ofNat n * OfNat.ofNat n
-- Complex.normSq_mk
@[simp]
theorem normSq_mk (x y : ℝ) : normSq ⟨x, y⟩ = x * x + y * y 
Arguments: (x y : ℝ)
Goal: Complex.normSq { re := x, im := y } = x * x + y * y
-- Complex.normSq_add_mul_I
theorem normSq_add_mul_I (x y : ℝ) : normSq (x + y * I) = x ^ 2 + y ^ 2 
Arguments: (x y : ℝ)
Goal: Complex.normSq (↑x + ↑y * Complex.I) = x ^ 2 + y ^ 2
-- Complex.normSq_eq_conj_mul_self
theorem normSq_eq_conj_mul_self {z : ℂ} : (normSq z : ℂ) = conj z * z 
Arguments: {z : ℂ}
Goal: ↑(Complex.normSq z) = (starRingEnd ℂ) z * z
-- Complex.normSq_zero
theorem normSq_zero : normSq 0 = 0 
Goal: Complex.normSq 0 = 0
-- Complex.normSq_one
theorem normSq_one : normSq 1 = 1 
Goal: Complex.normSq 1 = 1
-- Complex.normSq_I
@[simp]
theorem normSq_I : normSq I = 1 
Goal: Complex.normSq Complex.I = 1
-- Complex.normSq_nonneg
theorem normSq_nonneg (z : ℂ) : 0 ≤ normSq z 
Arguments: (z : ℂ)
Goal: 0 ≤ Complex.normSq z
-- Complex.normSq_eq_zero
theorem normSq_eq_zero {z : ℂ} : normSq z = 0 ↔ z = 0 
Arguments: {z : ℂ}
Goal: Complex.normSq z = 0 ↔ z = 0
-- Complex.normSq_pos
@[simp]
theorem normSq_pos {z : ℂ} : 0 < normSq z ↔ z ≠ 0 
Arguments: {z : ℂ}
Goal: 0 < Complex.normSq z ↔ z ≠ 0
-- Complex.normSq_neg
@[simp]
theorem normSq_neg (z : ℂ) : normSq (-z) = normSq z 
Arguments: (z : ℂ)
Goal: Complex.normSq (-z) = Complex.normSq z
-- Complex.normSq_conj
@[simp]
theorem normSq_conj (z : ℂ) : normSq (conj z) = normSq z 
Arguments: (z : ℂ)
Goal: Complex.normSq ((starRingEnd ℂ) z) = Complex.normSq z
-- Complex.normSq_mul
theorem normSq_mul (z w : ℂ) : normSq (z * w) = normSq z * normSq w 
Arguments: (z w : ℂ)
Goal: Complex.normSq (z * w) = Complex.normSq z * Complex.normSq w
-- Complex.normSq_add
theorem normSq_add (z w : ℂ) : normSq (z + w) = normSq z + normSq w + 2 * (z * conj w).re 
Arguments: (z w : ℂ)
Goal: Complex.normSq (z + w) = Complex.normSq z + Complex.normSq w + 2 * (z * (starRingEnd ℂ) w).re
-- Complex.re_sq_le_normSq
theorem re_sq_le_normSq (z : ℂ) : z.re * z.re ≤ normSq z 
Arguments: (z : ℂ)
Goal: z.re * z.re ≤ Complex.normSq z
-- Complex.im_sq_le_normSq
theorem im_sq_le_normSq (z : ℂ) : z.im * z.im ≤ normSq z 
Arguments: (z : ℂ)
Goal: z.im * z.im ≤ Complex.normSq z
-- Complex.mul_conj
theorem mul_conj (z : ℂ) : z * conj z = normSq z 
Arguments: (z : ℂ)
Goal: z * (starRingEnd ℂ) z = ↑(Complex.normSq z)
-- Complex.add_conj
theorem add_conj (z : ℂ) : z + conj z = (2 * z.re : ℝ) 
Arguments: (z : ℂ)
Goal: z + (starRingEnd ℂ) z = ↑(2 * z.re)
-- Complex.ofReal_eq_coe
@[simp]
theorem ofReal_eq_coe (r : ℝ) : ofReal r = r 
Arguments: (r : ℝ)
Goal: Complex.ofReal r = ↑r
-- Complex.I_sq
@[simp]
theorem I_sq : I ^ 2 = -1 
Goal: Complex.I ^ 2 = -1
-- Complex.I_pow_four
@[simp]
theorem I_pow_four : I ^ 4 = 1 
Goal: Complex.I ^ 4 = 1
-- Complex.sub_re
@[simp]
theorem sub_re (z w : ℂ) : (z - w).re = z.re - w.re 
Arguments: (z w : ℂ)
Goal: (z - w).re = z.re - w.re
-- Complex.sub_im
@[simp]
theorem sub_im (z w : ℂ) : (z - w).im = z.im - w.im 
Arguments: (z w : ℂ)
Goal: (z - w).im = z.im - w.im
-- Complex.ofReal_sub
@[simp, norm_cast]
theorem ofReal_sub (r s : ℝ) : ((r - s : ℝ) : ℂ) = r - s 
Arguments: (r s : ℝ)
Goal: ↑(r - s) = ↑r - ↑s
-- Complex.ofReal_pow
@[simp, norm_cast]
theorem ofReal_pow (r : ℝ) (n : ℕ) : ((r ^ n : ℝ) : ℂ) = (r : ℂ) ^ n 
Arguments: (r : ℝ) (n : ℕ)
Goal: ↑(r ^ n) = ↑r ^ n
-- Complex.sub_conj
theorem sub_conj (z : ℂ) : z - conj z = (2 * z.im : ℝ) * I 
Arguments: (z : ℂ)
Goal: z - (starRingEnd ℂ) z = ↑(2 * z.im) * Complex.I
-- Complex.normSq_sub
theorem normSq_sub (z w : ℂ) : normSq (z - w) = normSq z + normSq w - 2 * (z * conj w).re 
Arguments: (z w : ℂ)
Goal: Complex.normSq (z - w) = Complex.normSq z + Complex.normSq w - 2 * (z * (starRingEnd ℂ) w).re