File: Mathlib/Data/Complex/Abs.lean

full_name: Complex.AbsTheory._aux_Mathlib_Data_Complex_Abs___macroRules_Complex_AbsTheory_termAbs__1
code: local notation "abs" z => Real.sqrt (normSq z)
goal: Lean.Macro

full_name: Complex.AbsTheory._aux_Mathlib_Data_Complex_Abs___unexpand_Real_sqrt_1
code: local notation "abs" z => Real.sqrt (normSq z)
goal: Lean.PrettyPrinter.Unexpander

full_name: _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.mul_self_abs
code: private theorem mul_self_abs (z : ℂ) : ((abs z) * abs z) = normSq z 
goal: √(Complex.normSq z) * √(Complex.normSq z) = Complex.normSq z

full_name: _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_nonneg'
code: private theorem abs_nonneg' (z : ℂ) : 0 ≤ abs z 
goal: 0 ≤ √(Complex.normSq z)

full_name: Complex.AbsTheory.abs_conj
code: theorem abs_conj (z : ℂ) : (abs conj z) = abs z 
goal: √(Complex.normSq ((starRingEnd ℂ) z)) = √(Complex.normSq z)

full_name: _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_re_le_abs
code: private theorem abs_re_le_abs (z : ℂ) : |z.re| ≤ abs z 
goal: |z.re| ≤ √(Complex.normSq z)

full_name: _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.re_le_abs
code: private theorem re_le_abs (z : ℂ) : z.re ≤ abs z 
goal: z.re ≤ √(Complex.normSq z)

full_name: _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_mul
code: private theorem abs_mul (z w : ℂ) : (abs z * w) = (abs z) * abs w 
goal: √(Complex.normSq (z * w)) = √(Complex.normSq z) * √(Complex.normSq w)

full_name: _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_add
code: private theorem abs_add (z w : ℂ) : (abs z + w) ≤ (abs z) + abs w 
goal: √(Complex.normSq (z + w)) ≤ √(Complex.normSq z) + √(Complex.normSq w)

full_name: Complex.abs
code: /-- The complex absolute value function, defined as the square root of the norm squared. -/
noncomputable def _root_.Complex.abs : AbsoluteValue ℂ ℝ 
goal: AbsoluteValue ℂ ℝ

full_name: Complex.abs_def
code: theorem abs_def : (Complex.abs : ℂ → ℝ) = fun z => (normSq z).sqrt 
goal: ⇑Complex.abs = fun z => √(Complex.normSq z)

full_name: Complex.abs_apply
code: theorem abs_apply {z : ℂ} : Complex.abs z = (normSq z).sqrt 
goal: Complex.abs z = √(Complex.normSq z)

full_name: Complex.abs_ofReal
code: @[simp, norm_cast]
theorem abs_ofReal (r : ℝ) : Complex.abs r = |r| 
goal: Complex.abs ↑r = |r|

full_name: Complex.abs_of_nonneg
code: nonrec theorem abs_of_nonneg {r : ℝ} (h : 0 ≤ r) : Complex.abs r = r 
goal: Complex.abs ↑r = r

full_name: Complex.abs_natCast
code: @[simp]
theorem abs_natCast (n : ℕ) : Complex.abs n = n 
goal: Complex.abs ↑n = ↑n

full_name: Complex.abs_ofNat
code: @[simp]
theorem abs_ofNat (n : ℕ) [n.AtLeastTwo] :
    Complex.abs (no_index (OfNat.ofNat n : ℂ)) = OfNat.ofNat n 
goal: Complex.abs (OfNat.ofNat n) = OfNat.ofNat n

full_name: Complex.mul_self_abs
code: theorem mul_self_abs (z : ℂ) : Complex.abs z * Complex.abs z = normSq z 
goal: Complex.abs z * Complex.abs z = Complex.normSq z

full_name: Complex.sq_abs
code: theorem sq_abs (z : ℂ) : Complex.abs z ^ 2 = normSq z 
goal: Complex.abs z ^ 2 = Complex.normSq z

full_name: Complex.sq_abs_sub_sq_re
code: @[simp]
theorem sq_abs_sub_sq_re (z : ℂ) : Complex.abs z ^ 2 - z.re ^ 2 = z.im ^ 2 
goal: Complex.abs z ^ 2 - z.re ^ 2 = z.im ^ 2

full_name: Complex.sq_abs_sub_sq_im
code: @[simp]
theorem sq_abs_sub_sq_im (z : ℂ) : Complex.abs z ^ 2 - z.im ^ 2 = z.re ^ 2 
goal: Complex.abs z ^ 2 - z.im ^ 2 = z.re ^ 2

full_name: Complex.abs_add_mul_I
code: lemma abs_add_mul_I (x y : ℝ) : abs (x + y * I) = (x ^ 2 + y ^ 2).sqrt 
goal: Complex.abs (↑x + ↑y * Complex.I) = √(x ^ 2 + y ^ 2)

full_name: Complex.abs_eq_sqrt_sq_add_sq
code: lemma abs_eq_sqrt_sq_add_sq (z : ℂ) : abs z = (z.re ^ 2 + z.im ^ 2).sqrt 
goal: Complex.abs z = √(z.re ^ 2 + z.im ^ 2)

full_name: Complex.abs_I
code: @[simp]
theorem abs_I : Complex.abs I = 1 
goal: Complex.abs Complex.I = 1

full_name: Complex.abs_two
code: theorem abs_two : Complex.abs 2 = 2 
goal: Complex.abs 2 = 2

full_name: Complex.range_abs
code: @[simp]
theorem range_abs : range Complex.abs = Ici 0 
goal: Set.range ⇑Complex.abs = Set.Ici 0

full_name: Complex.abs_conj
code: @[simp]
theorem abs_conj (z : ℂ) : Complex.abs (conj z) = Complex.abs z 
goal: Complex.abs ((starRingEnd ℂ) z) = Complex.abs z

full_name: Complex.abs_prod
code: theorem abs_prod {ι : Type*} (s : Finset ι) (f : ι → ℂ) :
    Complex.abs (s.prod f) = s.prod fun I => Complex.abs (f I) 
goal: Complex.abs (s.prod f) = ∏ I ∈ s, Complex.abs (f I)

full_name: Complex.abs_pow
code: theorem abs_pow (z : ℂ) (n : ℕ) : Complex.abs (z ^ n) = Complex.abs z ^ n 
goal: Complex.abs (z ^ n) = Complex.abs z ^ n

full_name: Complex.abs_zpow
code: theorem abs_zpow (z : ℂ) (n : ℤ) : Complex.abs (z ^ n) = Complex.abs z ^ n 
goal: Complex.abs (z ^ n) = Complex.abs z ^ n

full_name: Complex.abs_re_le_abs
code: theorem abs_re_le_abs (z : ℂ) : |z.re| ≤ Complex.abs z 
goal: |z.re| ≤ Complex.abs z

full_name: Complex.abs_im_le_abs
code: theorem abs_im_le_abs (z : ℂ) : |z.im| ≤ Complex.abs z 
goal: |z.im| ≤ Complex.abs z

full_name: Complex.re_le_abs
code: theorem re_le_abs (z : ℂ) : z.re ≤ Complex.abs z 
goal: z.re ≤ Complex.abs z

full_name: Complex.im_le_abs
code: theorem im_le_abs (z : ℂ) : z.im ≤ Complex.abs z 
goal: z.im ≤ Complex.abs z

full_name: Complex.abs_re_lt_abs
code: @[simp]
theorem abs_re_lt_abs {z : ℂ} : |z.re| < Complex.abs z ↔ z.im ≠ 0 
goal: |z.re| < Complex.abs z ↔ z.im ≠ 0

full_name: Complex.abs_im_lt_abs
code: @[simp]
theorem abs_im_lt_abs {z : ℂ} : |z.im| < Complex.abs z ↔ z.re ≠ 0 
goal: |z.im| < Complex.abs z ↔ z.re ≠ 0

full_name: Complex.abs_re_eq_abs
code: @[simp]
lemma abs_re_eq_abs {z : ℂ} : |z.re| = abs z ↔ z.im = 0 
goal: |z.re| = Complex.abs z ↔ z.im = 0

full_name: Complex.abs_im_eq_abs
code: @[simp]
lemma abs_im_eq_abs {z : ℂ} : |z.im| = abs z ↔ z.re = 0 
goal: |z.im| = Complex.abs z ↔ z.re = 0

full_name: Complex.abs_abs
code: @[simp]
theorem abs_abs (z : ℂ) : |Complex.abs z| = Complex.abs z 
goal: |Complex.abs z| = Complex.abs z

full_name: Complex.abs_le_abs_re_add_abs_im
code: theorem abs_le_abs_re_add_abs_im (z : ℂ) : Complex.abs z ≤ |z.re| + |z.im| 
goal: Complex.abs z ≤ |z.re| + |z.im|

full_name: Complex.instNeZeroRealOfNat
code: instance : NeZero (1 : ℝ) 
goal: NeZero 1

full_name: Complex.abs_le_sqrt_two_mul_max
code: theorem abs_le_sqrt_two_mul_max (z : ℂ) : Complex.abs z ≤ Real.sqrt 2 * max |z.re| |z.im| 
goal: Complex.abs z ≤ √2 * max |z.re| |z.im|

full_name: Complex.abs_re_div_abs_le_one
code: theorem abs_re_div_abs_le_one (z : ℂ) : |z.re / Complex.abs z| ≤ 1 
goal: |z.re / Complex.abs z| ≤ 1

full_name: Complex.abs_im_div_abs_le_one
code: theorem abs_im_div_abs_le_one (z : ℂ) : |z.im / Complex.abs z| ≤ 1 
goal: |z.im / Complex.abs z| ≤ 1

full_name: Complex.abs_intCast
code: @[simp, norm_cast] lemma abs_intCast (n : ℤ) : abs n = |↑n| 
goal: Complex.abs ↑n = |↑n|

full_name: Complex.int_cast_abs
code: @[deprecated (since := "2024-02-14")]
lemma int_cast_abs (n : ℤ) : |↑n| = Complex.abs n 
goal: |↑n| = Complex.abs ↑n

full_name: Complex.normSq_eq_abs
code: theorem normSq_eq_abs (x : ℂ) : normSq x = (Complex.abs x) ^ 2 
goal: Complex.normSq x = Complex.abs x ^ 2

full_name: Complex.range_normSq
code: @[simp]
theorem range_normSq : range normSq = Ici 0 
goal: Set.range ⇑Complex.normSq = Set.Ici 0

full_name: Complex._aux_Mathlib_Data_Complex_Abs___macroRules_Complex_termAbs'_1
code: local notation "abs'" => _root_.abs
goal: Lean.Macro

full_name: Complex._aux_Mathlib_Data_Complex_Abs___unexpand_abs_1
code: local notation "abs'" => _root_.abs
goal: Lean.PrettyPrinter.Unexpander

full_name: Complex.isCauSeq_re
code: theorem isCauSeq_re (f : CauSeq ℂ Complex.abs) : IsCauSeq abs' fun n => (f n).re 
goal: IsCauSeq abs fun n => (↑f n).re

full_name: Complex.isCauSeq_im
code: theorem isCauSeq_im (f : CauSeq ℂ Complex.abs) : IsCauSeq abs' fun n => (f n).im 
goal: IsCauSeq abs fun n => (↑f n).im

full_name: Complex.cauSeqRe
code: /-- The real part of a complex Cauchy sequence, as a real Cauchy sequence. -/
noncomputable def cauSeqRe (f : CauSeq ℂ Complex.abs) : CauSeq ℝ abs' 
goal: CauSeq ℝ abs

full_name: Complex.cauSeqIm
code: /-- The imaginary part of a complex Cauchy sequence, as a real Cauchy sequence. -/
noncomputable def cauSeqIm (f : CauSeq ℂ Complex.abs) : CauSeq ℝ abs' 
goal: CauSeq ℝ abs

full_name: Complex.isCauSeq_abs
code: theorem isCauSeq_abs {f : ℕ → ℂ} (hf : IsCauSeq Complex.abs f) :
    IsCauSeq abs' (Complex.abs ∘ f) 
goal: IsCauSeq abs (⇑Complex.abs ∘ f)

full_name: Complex.limAux
code: /-- The limit of a Cauchy sequence of complex numbers. -/
noncomputable def limAux (f : CauSeq ℂ Complex.abs) : ℂ 
goal: ℂ

full_name: Complex.equiv_limAux
code: theorem equiv_limAux (f : CauSeq ℂ Complex.abs) :
    f ≈ CauSeq.const Complex.abs (limAux f) 
goal: f ≈ CauSeq.const (⇑Complex.abs) (Complex.limAux f)

full_name: Complex.instIsComplete
code: instance instIsComplete : CauSeq.IsComplete ℂ Complex.abs 
goal: CauSeq.IsComplete ℂ ⇑Complex.abs

full_name: Complex.lim_eq_lim_im_add_lim_re
code: theorem lim_eq_lim_im_add_lim_re (f : CauSeq ℂ Complex.abs) :
    lim f = ↑(lim (cauSeqRe f)) + ↑(lim (cauSeqIm f)) * I 
goal: f.lim = ↑(Complex.cauSeqRe f).lim + ↑(Complex.cauSeqIm f).lim * Complex.I

full_name: Complex.lim_re
code: theorem lim_re (f : CauSeq ℂ Complex.abs) : lim (cauSeqRe f) = (lim f).re 
goal: (Complex.cauSeqRe f).lim = f.lim.re

full_name: Complex.lim_im
code: theorem lim_im (f : CauSeq ℂ Complex.abs) : lim (cauSeqIm f) = (lim f).im 
goal: (Complex.cauSeqIm f).lim = f.lim.im

full_name: Complex.isCauSeq_conj
code: theorem isCauSeq_conj (f : CauSeq ℂ Complex.abs) :
    IsCauSeq Complex.abs fun n => conj (f n) 
goal: IsCauSeq ⇑Complex.abs fun n => (starRingEnd ℂ) (↑f n)

full_name: Complex.cauSeqConj
code: /-- The complex conjugate of a complex Cauchy sequence, as a complex Cauchy sequence. -/
noncomputable def cauSeqConj (f : CauSeq ℂ Complex.abs) : CauSeq ℂ Complex.abs 
goal: CauSeq ℂ ⇑Complex.abs

full_name: Complex.lim_conj
code: theorem lim_conj (f : CauSeq ℂ Complex.abs) : lim (cauSeqConj f) = conj (lim f) 
goal: (Complex.cauSeqConj f).lim = (starRingEnd ℂ) f.lim

full_name: Complex.cauSeqAbs
code: /-- The absolute value of a complex Cauchy sequence, as a real Cauchy sequence. -/
noncomputable def cauSeqAbs (f : CauSeq ℂ Complex.abs) : CauSeq ℝ abs' 
goal: CauSeq ℝ abs

full_name: Complex.lim_abs
code: theorem lim_abs (f : CauSeq ℂ Complex.abs) : lim (cauSeqAbs f) = Complex.abs (lim f) 
goal: (Complex.cauSeqAbs f).lim = Complex.abs f.lim

full_name: Complex.ne_zero_of_one_lt_re
code: lemma ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : s ≠ 0 
goal: s ≠ 0

full_name: Complex.re_neg_ne_zero_of_one_lt_re
code: lemma re_neg_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : (-s).re ≠ 0 
goal: (-s).re ≠ 0