File: Mathlib/Data/Complex/Basic.lean

full_name: Complex.im
code: /-- Complex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`. -/
structure Complex : Type where
  /-- The real part of a complex number. -/
  re : ℝ
  /-- The imaginary part of a complex number. -/
  im : ℝ
goal: ℝ

full_name: Complex
code: /-- Complex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`. -/
structure Complex : Type where
  /-- The real part of a complex number. -/
  re : ℝ
  /-- The imaginary part of a complex number. -/
  im : ℝ
goal: Type

full_name: Complex.re
code: /-- Complex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`. -/
structure Complex : Type where
  /-- The real part of a complex number. -/
  re : ℝ
  /-- The imaginary part of a complex number. -/
  im : ℝ
goal: ℝ

full_name: _aux_Mathlib_Data_Complex_Basic___macroRules_termℂ_1
code: @[inherit_doc] notation "ℂ" => Complex
goal: Lean.Macro

full_name: _aux_Mathlib_Data_Complex_Basic___unexpand_Complex_1
code: @[inherit_doc] notation "ℂ" => Complex
goal: Lean.PrettyPrinter.Unexpander

full_name: Complex.instDecidableEq
code: noncomputable instance : DecidableEq ℂ 
goal: DecidableEq ℂ

full_name: Complex.equivRealProd
code: /-- The equivalence between the complex numbers and `ℝ × ℝ`. -/
@[simps apply]
def equivRealProd : ℂ ≃ ℝ × ℝ 
goal: ℂ ≃ ℝ × ℝ

full_name: Complex.equivRealProd_apply
code: /-- The equivalence between the complex numbers and `ℝ × ℝ`. -/
@[simps apply]
def equivRealProd : ℂ ≃ ℝ × ℝ 
goal: Complex.equivRealProd z = (z.re, z.im)

full_name: Complex.eta
code: @[simp]
theorem eta : ∀ z : ℂ, Complex.mk z.re z.im = z
  
goal: { re := z.re, im := z.im } = z

full_name: Complex.ext
code: theorem ext : ∀ {z w : ℂ}, z.re = w.re → z.im = w.im → z = w
  
goal: z.re = w.re → z.im = w.im → z = w

full_name: Complex.ext_iff
code: protected theorem ext_iff {z w : ℂ} : z = w ↔ z.re = w.re ∧ z.im = w.im 
goal: z = w ↔ z.re = w.re ∧ z.im = w.im

full_name: Complex.re_surjective
code: theorem re_surjective : Surjective re 
goal: Function.Surjective Complex.re

full_name: Complex.im_surjective
code: theorem im_surjective : Surjective im 
goal: Function.Surjective Complex.im

full_name: Complex.range_re
code: @[simp]
theorem range_re : range re = univ 
goal: Set.range Complex.re = Set.univ

full_name: Complex.range_im
code: @[simp]
theorem range_im : range im = univ 
goal: Set.range Complex.im = Set.univ

full_name: Complex.ofReal'
code: /-- The natural inclusion of the real numbers into the complex numbers.
The name `Complex.ofReal` is reserved for the bundled homomorphism. -/
@[coe]
def ofReal' (r : ℝ) : ℂ 
goal: ℂ

full_name: Complex.instCoeReal
code: instance : Coe ℝ ℂ 
goal: Coe ℝ ℂ

full_name: Complex.ofReal_re
code: @[simp, norm_cast]
theorem ofReal_re (r : ℝ) : Complex.re (r : ℂ) = r 
goal: (↑r).re = r

full_name: Complex.ofReal_im
code: @[simp, norm_cast]
theorem ofReal_im (r : ℝ) : (r : ℂ).im = 0 
goal: (↑r).im = 0

full_name: Complex.ofReal_def
code: theorem ofReal_def (r : ℝ) : (r : ℂ) = ⟨r, 0⟩ 
goal: ↑r = { re := r, im := 0 }

full_name: Complex.ofReal_inj
code: @[simp, norm_cast]
theorem ofReal_inj {z w : ℝ} : (z : ℂ) = w ↔ z = w 
goal: ↑z = ↑w ↔ z = w

full_name: Complex.ofReal_injective
code: theorem ofReal_injective : Function.Injective ((↑) : ℝ → ℂ) 
goal: Function.Injective Complex.ofReal'

full_name: Complex.canLift
code: instance canLift : CanLift ℂ ℝ (↑) fun z => z.im = 0 
goal: CanLift ℂ ℝ Complex.ofReal' fun z => z.im = 0

full_name: Complex.Set.reProdIm
code: /-- The product of a set on the real axis and a set on the imaginary axis of the complex plane,
denoted by `s ×ℂ t`. -/
def Set.reProdIm (s t : Set ℝ) : Set ℂ 
goal: Set ℂ

full_name: Complex.«_aux_Mathlib_Data_Complex_Basic___macroRules_Complex_term_×ℂ__1»
code: @[inherit_doc]
infixl:72 " ×ℂ " => Set.reProdIm
goal: Lean.Macro

full_name: Complex._aux_Mathlib_Data_Complex_Basic___unexpand_Complex_Set_reProdIm_1
code: @[inherit_doc]
infixl:72 " ×ℂ " => Set.reProdIm
goal: Lean.PrettyPrinter.Unexpander

full_name: Complex.mem_reProdIm
code: theorem mem_reProdIm {z : ℂ} {s t : Set ℝ} : z ∈ s ×ℂ t ↔ z.re ∈ s ∧ z.im ∈ t 
goal: z ∈ s ×ℂ t ↔ z.re ∈ s ∧ z.im ∈ t

full_name: Complex.instZero
code: instance : Zero ℂ 
goal: Zero ℂ

full_name: Complex.instInhabited
code: instance : Inhabited ℂ 
goal: Inhabited ℂ

full_name: Complex.zero_re
code: @[simp]
theorem zero_re : (0 : ℂ).re = 0 
goal: Complex.re 0 = 0

full_name: Complex.zero_im
code: @[simp]
theorem zero_im : (0 : ℂ).im = 0 
goal: Complex.im 0 = 0

full_name: Complex.ofReal_zero
code: @[simp, norm_cast]
theorem ofReal_zero : ((0 : ℝ) : ℂ) = 0 
goal: ↑0 = 0

full_name: Complex.ofReal_eq_zero
code: @[simp]
theorem ofReal_eq_zero {z : ℝ} : (z : ℂ) = 0 ↔ z = 0 
goal: ↑z = 0 ↔ z = 0

full_name: Complex.ofReal_ne_zero
code: theorem ofReal_ne_zero {z : ℝ} : (z : ℂ) ≠ 0 ↔ z ≠ 0 
goal: ↑z ≠ 0 ↔ z ≠ 0

full_name: Complex.instOne
code: instance : One ℂ 
goal: One ℂ

full_name: Complex.one_re
code: @[simp]
theorem one_re : (1 : ℂ).re = 1 
goal: Complex.re 1 = 1

full_name: Complex.one_im
code: @[simp]
theorem one_im : (1 : ℂ).im = 0 
goal: Complex.im 1 = 0

full_name: Complex.ofReal_one
code: @[simp, norm_cast]
theorem ofReal_one : ((1 : ℝ) : ℂ) = 1 
goal: ↑1 = 1

full_name: Complex.ofReal_eq_one
code: @[simp]
theorem ofReal_eq_one {z : ℝ} : (z : ℂ) = 1 ↔ z = 1 
goal: ↑z = 1 ↔ z = 1

full_name: Complex.ofReal_ne_one
code: theorem ofReal_ne_one {z : ℝ} : (z : ℂ) ≠ 1 ↔ z ≠ 1 
goal: ↑z ≠ 1 ↔ z ≠ 1

full_name: Complex.instAdd
code: instance : Add ℂ 
goal: Add ℂ

full_name: Complex.add_re
code: @[simp]
theorem add_re (z w : ℂ) : (z + w).re = z.re + w.re 
goal: (z + w).re = z.re + w.re

full_name: Complex.add_im
code: @[simp]
theorem add_im (z w : ℂ) : (z + w).im = z.im + w.im 
goal: (z + w).im = z.im + w.im

full_name: Complex.ofReal_add
code: @[simp, norm_cast]
theorem ofReal_add (r s : ℝ) : ((r + s : ℝ) : ℂ) = r + s 
goal: ↑(r + s) = ↑r + ↑s

full_name: Complex.instNeg
code: instance : Neg ℂ 
goal: Neg ℂ

full_name: Complex.neg_re
code: @[simp]
theorem neg_re (z : ℂ) : (-z).re = -z.re 
goal: (-z).re = -z.re

full_name: Complex.neg_im
code: @[simp]
theorem neg_im (z : ℂ) : (-z).im = -z.im 
goal: (-z).im = -z.im

full_name: Complex.ofReal_neg
code: @[simp, norm_cast]
theorem ofReal_neg (r : ℝ) : ((-r : ℝ) : ℂ) = -r 
goal: ↑(-r) = -↑r

full_name: Complex.instSub
code: instance : Sub ℂ 
goal: Sub ℂ

full_name: Complex.instMul
code: instance : Mul ℂ 
goal: Mul ℂ

full_name: Complex.mul_re
code: @[simp]
theorem mul_re (z w : ℂ) : (z * w).re = z.re * w.re - z.im * w.im 
goal: (z * w).re = z.re * w.re - z.im * w.im

full_name: Complex.mul_im
code: @[simp]
theorem mul_im (z w : ℂ) : (z * w).im = z.re * w.im + z.im * w.re 
goal: (z * w).im = z.re * w.im + z.im * w.re

full_name: Complex.ofReal_mul
code: @[simp, norm_cast]
theorem ofReal_mul (r s : ℝ) : ((r * s : ℝ) : ℂ) = r * s 
goal: ↑(r * s) = ↑r * ↑s

full_name: Complex.re_ofReal_mul
code: theorem re_ofReal_mul (r : ℝ) (z : ℂ) : (r * z).re = r * z.re 
goal: (↑r * z).re = r * z.re

full_name: Complex.im_ofReal_mul
code: theorem im_ofReal_mul (r : ℝ) (z : ℂ) : (r * z).im = r * z.im 
goal: (↑r * z).im = r * z.im

full_name: Complex.re_mul_ofReal
code: lemma re_mul_ofReal (z : ℂ) (r : ℝ) : (z * r).re = z.re *  r 
goal: (z * ↑r).re = z.re * r

full_name: Complex.im_mul_ofReal
code: lemma im_mul_ofReal (z : ℂ) (r : ℝ) : (z * r).im = z.im *  r 
goal: (z * ↑r).im = z.im * r

full_name: Complex.ofReal_mul'
code: theorem ofReal_mul' (r : ℝ) (z : ℂ) : ↑r * z = ⟨r * z.re, r * z.im⟩ 
goal: ↑r * z = { re := r * z.re, im := r * z.im }

full_name: Complex.I
code: /-- The imaginary unit. -/
def I : ℂ 
goal: ℂ

full_name: Complex.I_re
code: @[simp]
theorem I_re : I.re = 0 
goal: Complex.I.re = 0

full_name: Complex.I_im
code: @[simp]
theorem I_im : I.im = 1 
goal: Complex.I.im = 1

full_name: Complex.I_mul_I
code: @[simp]
theorem I_mul_I : I * I = -1 
goal: Complex.I * Complex.I = -1

full_name: Complex.I_mul
code: theorem I_mul (z : ℂ) : I * z = ⟨-z.im, z.re⟩ 
goal: Complex.I * z = { re := -z.im, im := z.re }

full_name: Complex.I_ne_zero
code: @[simp] lemma I_ne_zero : (I : ℂ) ≠ 0 
goal: Complex.I ≠ 0

full_name: Complex.mk_eq_add_mul_I
code: theorem mk_eq_add_mul_I (a b : ℝ) : Complex.mk a b = a + b * I 
goal: { re := a, im := b } = ↑a + ↑b * Complex.I

full_name: Complex.re_add_im
code: @[simp]
theorem re_add_im (z : ℂ) : (z.re : ℂ) + z.im * I = z 
goal: ↑z.re + ↑z.im * Complex.I = z

full_name: Complex.mul_I_re
code: theorem mul_I_re (z : ℂ) : (z * I).re = -z.im 
goal: (z * Complex.I).re = -z.im

full_name: Complex.mul_I_im
code: theorem mul_I_im (z : ℂ) : (z * I).im = z.re 
goal: (z * Complex.I).im = z.re

full_name: Complex.I_mul_re
code: theorem I_mul_re (z : ℂ) : (I * z).re = -z.im 
goal: (Complex.I * z).re = -z.im

full_name: Complex.I_mul_im
code: theorem I_mul_im (z : ℂ) : (I * z).im = z.re 
goal: (Complex.I * z).im = z.re

full_name: Complex.equivRealProd_symm_apply
code: @[simp]
theorem equivRealProd_symm_apply (p : ℝ × ℝ) : equivRealProd.symm p = p.1 + p.2 * I 
goal: Complex.equivRealProd.symm p = ↑p.1 + ↑p.2 * Complex.I

full_name: Complex.equivRealProdAddHom
code: /-- The natural `AddEquiv` from `ℂ` to `ℝ × ℝ`. -/
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdAddHom : ℂ ≃+ ℝ × ℝ 
goal: ℂ ≃+ ℝ × ℝ

full_name: Complex.equivRealProdAddHom_symm_apply_re
code: /-- The natural `AddEquiv` from `ℂ` to `ℝ × ℝ`. -/
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdAddHom : ℂ ≃+ ℝ × ℝ 
goal: (Complex.equivRealProdAddHom.symm p).re = p.1

full_name: Complex.equivRealProdAddHom_apply
code: /-- The natural `AddEquiv` from `ℂ` to `ℝ × ℝ`. -/
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdAddHom : ℂ ≃+ ℝ × ℝ 
goal: Complex.equivRealProdAddHom z = (z.re, z.im)

full_name: Complex.equivRealProdAddHom_symm_apply_im
code: /-- The natural `AddEquiv` from `ℂ` to `ℝ × ℝ`. -/
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdAddHom : ℂ ≃+ ℝ × ℝ 
goal: (Complex.equivRealProdAddHom.symm p).im = p.2

full_name: Complex.equivRealProdAddHom_symm_apply
code: theorem equivRealProdAddHom_symm_apply (p : ℝ × ℝ) :
    equivRealProdAddHom.symm p = p.1 + p.2 * I 
goal: Complex.equivRealProdAddHom.symm p = ↑p.1 + ↑p.2 * Complex.I

full_name: Complex.instNontrivial
code: instance : Nontrivial ℂ 
goal: Nontrivial ℂ

full_name: Complex.SMul.instSMulRealComplex
code: /-- Scalar multiplication by `R` on `ℝ` extends to `ℂ`. This is used here and in
`Matlib.Data.Complex.Module` to transfer instances from `ℝ` to `ℂ`, but is not
needed outside, so we make it scoped. -/
scoped instance instSMulRealComplex {R : Type*} [SMul R ℝ] : SMul R ℂ 
goal: SMul R ℂ

full_name: Complex.smul_re
code: theorem smul_re (r : R) (z : ℂ) : (r • z).re = r • z.re 
goal: (r • z).re = r • z.re

full_name: Complex.smul_im
code: theorem smul_im (r : R) (z : ℂ) : (r • z).im = r • z.im 
goal: (r • z).im = r • z.im

full_name: Complex.real_smul
code: @[simp]
theorem real_smul {x : ℝ} {z : ℂ} : x • z = x * z 
goal: x • z = ↑x * z

full_name: Complex.addCommGroup
code: instance addCommGroup : AddCommGroup ℂ 
goal: AddCommGroup ℂ

full_name: Complex.addGroupWithOne
code: instance addGroupWithOne : AddGroupWithOne ℂ 
goal: AddGroupWithOne ℂ

full_name: Complex.commRing
code: instance commRing : CommRing ℂ 
goal: CommRing ℂ

full_name: Complex.instRing
code: /-- This shortcut instance ensures we do not find `Ring` via the noncomputable `Complex.field`
instance. -/
instance : Ring ℂ 
goal: Ring ℂ

full_name: Complex.instCommSemiring
code: /-- This shortcut instance ensures we do not find `CommSemiring` via the noncomputable
`Complex.field` instance. -/
instance : CommSemiring ℂ 
goal: CommSemiring ℂ

full_name: Complex.instSemiring
code: /-- This shortcut instance ensures we do not find `Semiring` via the noncomputable
`Complex.field` instance. -/
instance : Semiring ℂ 
goal: Semiring ℂ

full_name: Complex.reAddGroupHom
code: /-- The "real part" map, considered as an additive group homomorphism. -/
def reAddGroupHom : ℂ →+ ℝ 
goal: ℂ →+ ℝ

full_name: Complex.coe_reAddGroupHom
code: @[simp]
theorem coe_reAddGroupHom : (reAddGroupHom : ℂ → ℝ) = re 
goal: ⇑Complex.reAddGroupHom = Complex.re

full_name: Complex.imAddGroupHom
code: /-- The "imaginary part" map, considered as an additive group homomorphism. -/
def imAddGroupHom : ℂ →+ ℝ 
goal: ℂ →+ ℝ

full_name: Complex.coe_imAddGroupHom
code: @[simp]
theorem coe_imAddGroupHom : (imAddGroupHom : ℂ → ℝ) = im 
goal: ⇑Complex.imAddGroupHom = Complex.im

full_name: Complex.instNNRatCast
code: noncomputable instance instNNRatCast : NNRatCast ℂ 
goal: NNRatCast ℂ

full_name: Complex.instRatCast
code: noncomputable instance instRatCast : RatCast ℂ 
goal: RatCast ℂ

full_name: Complex.ofReal_ofNat
code: @[simp, norm_cast] lemma ofReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ofReal' (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: Complex.ofReal_natCast
code: @[simp, norm_cast] lemma ofReal_natCast (n : ℕ) : ofReal' n = n 
goal: ↑↑n = ↑n

full_name: Complex.ofReal_intCast
code: @[simp, norm_cast] lemma ofReal_intCast (n : ℤ) : ofReal' n = n 
goal: ↑↑n = ↑n

full_name: Complex.ofReal_nnratCast
code: @[simp, norm_cast] lemma ofReal_nnratCast (q : ℚ≥0) : ofReal' q = q 
goal: ↑↑q = ↑q

full_name: Complex.ofReal_ratCast
code: @[simp, norm_cast] lemma ofReal_ratCast (q : ℚ) : ofReal' q = q 
goal: ↑↑q = ↑q

full_name: Complex.re_ofNat
code: @[simp]
lemma re_ofNat (n : ℕ) [n.AtLeastTwo] : (no_index (OfNat.ofNat n) : ℂ).re = OfNat.ofNat n 
goal: (OfNat.ofNat n).re = OfNat.ofNat n

full_name: Complex.im_ofNat
code: @[simp] lemma im_ofNat (n : ℕ) [n.AtLeastTwo] : (no_index (OfNat.ofNat n) : ℂ).im = 0 
goal: (OfNat.ofNat n).im = 0

full_name: Complex.natCast_re
code: @[simp, norm_cast] lemma natCast_re (n : ℕ) : (n : ℂ).re = n 
goal: (↑n).re = ↑n

full_name: Complex.natCast_im
code: @[simp, norm_cast] lemma natCast_im (n : ℕ) : (n : ℂ).im = 0 
goal: (↑n).im = 0

full_name: Complex.intCast_re
code: @[simp, norm_cast] lemma intCast_re (n : ℤ) : (n : ℂ).re = n 
goal: (↑n).re = ↑n

full_name: Complex.intCast_im
code: @[simp, norm_cast] lemma intCast_im (n : ℤ) : (n : ℂ).im = 0 
goal: (↑n).im = 0

full_name: Complex.re_nnratCast
code: @[simp, norm_cast] lemma re_nnratCast (q : ℚ≥0) : (q : ℂ).re = q 
goal: (↑q).re = ↑q

full_name: Complex.im_nnratCast
code: @[simp, norm_cast] lemma im_nnratCast (q : ℚ≥0) : (q : ℂ).im = 0 
goal: (↑q).im = 0

full_name: Complex.ratCast_re
code: @[simp, norm_cast] lemma ratCast_re (q : ℚ) : (q : ℂ).re = q 
goal: (↑q).re = ↑q

full_name: Complex.ratCast_im
code: @[simp, norm_cast] lemma ratCast_im (q : ℚ) : (q : ℂ).im = 0 
goal: (↑q).im = 0

full_name: Complex.ofReal_nsmul
code: @[norm_cast] lemma ofReal_nsmul (n : ℕ) (r : ℝ) : ↑(n • r) = n • (r : ℂ) 
goal: ↑(n • r) = n • ↑r

full_name: Complex.ofReal_zsmul
code: @[norm_cast] lemma ofReal_zsmul (n : ℤ) (r : ℝ) : ↑(n • r) = n • (r : ℂ) 
goal: ↑(n • r) = n • ↑r

full_name: Complex.instStarRing
code: /-- This defines the complex conjugate as the `star` operation of the `StarRing ℂ`. It
is recommended to use the ring endomorphism version `starRingEnd`, available under the
notation `conj` in the locale `ComplexConjugate`. -/
instance : StarRing ℂ 
goal: StarRing ℂ

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

full_name: Complex.conj_im
code: @[simp]
theorem conj_im (z : ℂ) : (conj z).im = -z.im 
goal: ((starRingEnd ℂ) z).im = -z.im

full_name: Complex.conj_ofReal
code: @[simp]
theorem conj_ofReal (r : ℝ) : conj (r : ℂ) = r 
goal: (starRingEnd ℂ) ↑r = ↑r

full_name: Complex.conj_I
code: @[simp]
theorem conj_I : conj I = -I 
goal: (starRingEnd ℂ) Complex.I = -Complex.I

full_name: Complex.conj_natCast
code: theorem conj_natCast (n : ℕ) : conj (n : ℂ) = n 
goal: (starRingEnd ℂ) ↑n = ↑n

full_name: Complex.conj_ofNat
code: theorem conj_ofNat (n : ℕ) [n.AtLeastTwo] : conj (no_index (OfNat.ofNat n : ℂ)) = OfNat.ofNat n 
goal: (starRingEnd ℂ) (OfNat.ofNat n) = OfNat.ofNat n

full_name: Complex.conj_neg_I
code: theorem conj_neg_I : conj (-I) = I 
goal: (starRingEnd ℂ) (-Complex.I) = Complex.I

full_name: Complex.conj_eq_iff_real
code: theorem conj_eq_iff_real {z : ℂ} : conj z = z ↔ ∃ r : ℝ, z = r 
goal: (starRingEnd ℂ) z = z ↔ ∃ r, z = ↑r

full_name: Complex.conj_eq_iff_re
code: theorem conj_eq_iff_re {z : ℂ} : conj z = z ↔ (z.re : ℂ) = z 
goal: (starRingEnd ℂ) z = z ↔ ↑z.re = z

full_name: Complex.conj_eq_iff_im
code: theorem conj_eq_iff_im {z : ℂ} : conj z = z ↔ z.im = 0 
goal: (starRingEnd ℂ) z = z ↔ z.im = 0

full_name: Complex.star_def
code: @[simp]
theorem star_def : (Star.star : ℂ → ℂ) = conj 
goal: star = ⇑(starRingEnd ℂ)

full_name: Complex.normSq
code: /-- The norm squared function. -/
@[pp_nodot]
def normSq : ℂ →*₀ ℝ 
goal: ℂ →*₀ ℝ

full_name: Complex.normSq_apply
code: theorem normSq_apply (z : ℂ) : normSq z = z.re * z.re + z.im * z.im 
goal: Complex.normSq z = z.re * z.re + z.im * z.im

full_name: Complex.normSq_ofReal
code: @[simp]
theorem normSq_ofReal (r : ℝ) : normSq r = r * r 
goal: Complex.normSq ↑r = r * r

full_name: Complex.normSq_natCast
code: @[simp]
theorem normSq_natCast (n : ℕ) : normSq n = n * n 
goal: Complex.normSq ↑n = ↑n * ↑n

full_name: Complex.normSq_intCast
code: @[simp]
theorem normSq_intCast (z : ℤ) : normSq z = z * z 
goal: Complex.normSq ↑z = ↑z * ↑z

full_name: Complex.normSq_ratCast
code: @[simp]
theorem normSq_ratCast (q : ℚ) : normSq q = q * q 
goal: Complex.normSq ↑q = ↑q * ↑q

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

full_name: Complex.normSq_mk
code: @[simp]
theorem normSq_mk (x y : ℝ) : normSq ⟨x, y⟩ = x * x + y * y 
goal: Complex.normSq { re := x, im := y } = x * x + y * y

full_name: Complex.normSq_add_mul_I
code: theorem normSq_add_mul_I (x y : ℝ) : normSq (x + y * I) = x ^ 2 + y ^ 2 
goal: Complex.normSq (↑x + ↑y * Complex.I) = x ^ 2 + y ^ 2

full_name: Complex.normSq_eq_conj_mul_self
code: theorem normSq_eq_conj_mul_self {z : ℂ} : (normSq z : ℂ) = conj z * z 
goal: ↑(Complex.normSq z) = (starRingEnd ℂ) z * z

full_name: Complex.normSq_zero
code: theorem normSq_zero : normSq 0 = 0 
goal: Complex.normSq 0 = 0

full_name: Complex.normSq_one
code: theorem normSq_one : normSq 1 = 1 
goal: Complex.normSq 1 = 1

full_name: Complex.normSq_I
code: @[simp]
theorem normSq_I : normSq I = 1 
goal: Complex.normSq Complex.I = 1

full_name: Complex.normSq_nonneg
code: theorem normSq_nonneg (z : ℂ) : 0 ≤ normSq z 
goal: 0 ≤ Complex.normSq z

full_name: Complex.normSq_eq_zero
code: theorem normSq_eq_zero {z : ℂ} : normSq z = 0 ↔ z = 0 
goal: Complex.normSq z = 0 ↔ z = 0

full_name: Complex.normSq_pos
code: @[simp]
theorem normSq_pos {z : ℂ} : 0 < normSq z ↔ z ≠ 0 
goal: 0 < Complex.normSq z ↔ z ≠ 0

full_name: Complex.normSq_neg
code: @[simp]
theorem normSq_neg (z : ℂ) : normSq (-z) = normSq z 
goal: Complex.normSq (-z) = Complex.normSq z

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

full_name: Complex.normSq_mul
code: theorem normSq_mul (z w : ℂ) : normSq (z * w) = normSq z * normSq w 
goal: Complex.normSq (z * w) = Complex.normSq z * Complex.normSq w

full_name: Complex.normSq_add
code: theorem normSq_add (z w : ℂ) : normSq (z + w) = normSq z + normSq w + 2 * (z * conj w).re 
goal: Complex.normSq (z + w) = Complex.normSq z + Complex.normSq w + 2 * (z * (starRingEnd ℂ) w).re

full_name: Complex.re_sq_le_normSq
code: theorem re_sq_le_normSq (z : ℂ) : z.re * z.re ≤ normSq z 
goal: z.re * z.re ≤ Complex.normSq z

full_name: Complex.im_sq_le_normSq
code: theorem im_sq_le_normSq (z : ℂ) : z.im * z.im ≤ normSq z 
goal: z.im * z.im ≤ Complex.normSq z

full_name: Complex.mul_conj
code: theorem mul_conj (z : ℂ) : z * conj z = normSq z 
goal: z * (starRingEnd ℂ) z = ↑(Complex.normSq z)

full_name: Complex.add_conj
code: theorem add_conj (z : ℂ) : z + conj z = (2 * z.re : ℝ) 
goal: z + (starRingEnd ℂ) z = ↑(2 * z.re)

full_name: Complex.ofReal
code: /-- The coercion `ℝ → ℂ` as a `RingHom`. -/
def ofReal : ℝ →+* ℂ 
goal: ℝ →+* ℂ

full_name: Complex.ofReal_eq_coe
code: @[simp]
theorem ofReal_eq_coe (r : ℝ) : ofReal r = r 
goal: Complex.ofReal r = ↑r

full_name: Complex.I_sq
code: @[simp]
theorem I_sq : I ^ 2 = -1 
goal: Complex.I ^ 2 = -1

full_name: Complex.I_pow_four
code: @[simp]
theorem I_pow_four : I ^ 4 = 1 
goal: Complex.I ^ 4 = 1

full_name: Complex.sub_re
code: @[simp]
theorem sub_re (z w : ℂ) : (z - w).re = z.re - w.re 
goal: (z - w).re = z.re - w.re

full_name: Complex.sub_im
code: @[simp]
theorem sub_im (z w : ℂ) : (z - w).im = z.im - w.im 
goal: (z - w).im = z.im - w.im

full_name: Complex.ofReal_sub
code: @[simp, norm_cast]
theorem ofReal_sub (r s : ℝ) : ((r - s : ℝ) : ℂ) = r - s 
goal: ↑(r - s) = ↑r - ↑s

full_name: Complex.ofReal_pow
code: @[simp, norm_cast]
theorem ofReal_pow (r : ℝ) (n : ℕ) : ((r ^ n : ℝ) : ℂ) = (r : ℂ) ^ n 
goal: ↑(r ^ n) = ↑r ^ n

full_name: Complex.sub_conj
code: theorem sub_conj (z : ℂ) : z - conj z = (2 * z.im : ℝ) * I 
goal: z - (starRingEnd ℂ) z = ↑(2 * z.im) * Complex.I

full_name: Complex.normSq_sub
code: theorem normSq_sub (z w : ℂ) : normSq (z - w) = normSq z + normSq w - 2 * (z * conj w).re 
goal: Complex.normSq (z - w) = Complex.normSq z + Complex.normSq w - 2 * (z * (starRingEnd ℂ) w).re

full_name: Complex.instInv
code: noncomputable instance : Inv ℂ 
goal: Inv ℂ

full_name: Complex.inv_def
code: theorem inv_def (z : ℂ) : z⁻¹ = conj z * ((normSq z)⁻¹ : ℝ) 
goal: z⁻¹ = (starRingEnd ℂ) z * ↑(Complex.normSq z)⁻¹

full_name: Complex.inv_re
code: @[simp]
theorem inv_re (z : ℂ) : z⁻¹.re = z.re / normSq z 
goal: z⁻¹.re = z.re / Complex.normSq z

full_name: Complex.inv_im
code: @[simp]
theorem inv_im (z : ℂ) : z⁻¹.im = -z.im / normSq z 
goal: z⁻¹.im = -z.im / Complex.normSq z

full_name: Complex.ofReal_inv
code: @[simp, norm_cast]
theorem ofReal_inv (r : ℝ) : ((r⁻¹ : ℝ) : ℂ) = (r : ℂ)⁻¹ 
goal: ↑r⁻¹ = (↑r)⁻¹

full_name: Complex.inv_zero
code: protected theorem inv_zero : (0⁻¹ : ℂ) = 0 
goal: 0⁻¹ = 0

full_name: Complex.mul_inv_cancel
code: protected theorem mul_inv_cancel {z : ℂ} (h : z ≠ 0) : z * z⁻¹ = 1 
goal: z * z⁻¹ = 1

full_name: Complex.instDivInvMonoid
code: noncomputable instance instDivInvMonoid : DivInvMonoid ℂ 
goal: DivInvMonoid ℂ

full_name: Complex.div_re
code: lemma div_re (z w : ℂ) : (z / w).re = z.re * w.re / normSq w + z.im * w.im / normSq w 
goal: (z / w).re = z.re * w.re / Complex.normSq w + z.im * w.im / Complex.normSq w

full_name: Complex.div_im
code: lemma div_im (z w : ℂ) : (z / w).im = z.im * w.re / normSq w - z.re * w.im / normSq w 
goal: (z / w).im = z.im * w.re / Complex.normSq w - z.re * w.im / Complex.normSq w

full_name: Complex.instField
code: noncomputable instance instField : Field ℂ 
goal: Field ℂ

full_name: Complex.ofReal_nnqsmul
code: @[simp, norm_cast]
lemma ofReal_nnqsmul (q : ℚ≥0) (r : ℝ) : ofReal' (q • r) = q • r 
goal: ↑(q • r) = q • ↑r

full_name: Complex.ofReal_qsmul
code: @[simp, norm_cast]
lemma ofReal_qsmul (q : ℚ) (r : ℝ) : ofReal' (q • r) = q • r 
goal: ↑(q • r) = q • ↑r

full_name: Complex.conj_inv
code: theorem conj_inv (x : ℂ) : conj x⁻¹ = (conj x)⁻¹ 
goal: (starRingEnd ℂ) x⁻¹ = ((starRingEnd ℂ) x)⁻¹

full_name: Complex.ofReal_div
code: @[simp, norm_cast]
theorem ofReal_div (r s : ℝ) : ((r / s : ℝ) : ℂ) = r / s 
goal: ↑(r / s) = ↑r / ↑s

full_name: Complex.ofReal_zpow
code: @[simp, norm_cast]
theorem ofReal_zpow (r : ℝ) (n : ℤ) : ((r ^ n : ℝ) : ℂ) = (r : ℂ) ^ n 
goal: ↑(r ^ n) = ↑r ^ n

full_name: Complex.div_I
code: @[simp]
theorem div_I (z : ℂ) : z / I = -(z * I) 
goal: z / Complex.I = -(z * Complex.I)

full_name: Complex.inv_I
code: @[simp]
theorem inv_I : I⁻¹ = -I 
goal: Complex.I⁻¹ = -Complex.I

full_name: Complex.normSq_inv
code: theorem normSq_inv (z : ℂ) : normSq z⁻¹ = (normSq z)⁻¹ 
goal: Complex.normSq z⁻¹ = (Complex.normSq z)⁻¹

full_name: Complex.normSq_div
code: theorem normSq_div (z w : ℂ) : normSq (z / w) = normSq z / normSq w 
goal: Complex.normSq (z / w) = Complex.normSq z / Complex.normSq w

full_name: Complex.div_ofReal
code: lemma div_ofReal (z : ℂ) (x : ℝ) : z / x = ⟨z.re / x, z.im / x⟩ 
goal: z / ↑x = { re := z.re / x, im := z.im / x }

full_name: Complex.div_natCast
code: lemma div_natCast (z : ℂ) (n : ℕ) : z / n = ⟨z.re / n, z.im / n⟩ 
goal: z / ↑n = { re := z.re / ↑n, im := z.im / ↑n }

full_name: Complex.div_intCast
code: lemma div_intCast (z : ℂ) (n : ℤ) : z / n = ⟨z.re / n, z.im / n⟩ 
goal: z / ↑n = { re := z.re / ↑n, im := z.im / ↑n }

full_name: Complex.div_ratCast
code: lemma div_ratCast (z : ℂ) (x : ℚ) : z / x = ⟨z.re / x, z.im / x⟩ 
goal: z / ↑x = { re := z.re / ↑x, im := z.im / ↑x }

full_name: Complex.div_ofNat
code: lemma div_ofNat (z : ℂ) (n : ℕ) [n.AtLeastTwo] :
    z / OfNat.ofNat n = ⟨z.re / OfNat.ofNat n, z.im / OfNat.ofNat n⟩ 
goal: z / OfNat.ofNat n = { re := z.re / OfNat.ofNat n, im := z.im / OfNat.ofNat n }

full_name: Complex.div_ofReal_re
code: @[simp] lemma div_ofReal_re (z : ℂ) (x : ℝ) : (z / x).re = z.re / x 
goal: (z / ↑x).re = z.re / x

full_name: Complex.div_ofReal_im
code: @[simp] lemma div_ofReal_im (z : ℂ) (x : ℝ) : (z / x).im = z.im / x 
goal: (z / ↑x).im = z.im / x

full_name: Complex.div_natCast_re
code: @[simp] lemma div_natCast_re (z : ℂ) (n : ℕ) : (z / n).re = z.re / n 
goal: (z / ↑n).re = z.re / ↑n

full_name: Complex.div_natCast_im
code: @[simp] lemma div_natCast_im (z : ℂ) (n : ℕ) : (z / n).im = z.im / n 
goal: (z / ↑n).im = z.im / ↑n

full_name: Complex.div_intCast_re
code: @[simp] lemma div_intCast_re (z : ℂ) (n : ℤ) : (z / n).re = z.re / n 
goal: (z / ↑n).re = z.re / ↑n

full_name: Complex.div_intCast_im
code: @[simp] lemma div_intCast_im (z : ℂ) (n : ℤ) : (z / n).im = z.im / n 
goal: (z / ↑n).im = z.im / ↑n

full_name: Complex.div_ratCast_re
code: @[simp] lemma div_ratCast_re (z : ℂ) (x : ℚ) : (z / x).re = z.re / x 
goal: (z / ↑x).re = z.re / ↑x

full_name: Complex.div_ratCast_im
code: @[simp] lemma div_ratCast_im (z : ℂ) (x : ℚ) : (z / x).im = z.im / x 
goal: (z / ↑x).im = z.im / ↑x

full_name: Complex.div_ofNat_re
code: @[simp]
lemma div_ofNat_re (z : ℂ) (n : ℕ) [n.AtLeastTwo] :
    (z / no_index (OfNat.ofNat n)).re = z.re / OfNat.ofNat n 
goal: (z / OfNat.ofNat n).re = z.re / OfNat.ofNat n

full_name: Complex.div_ofNat_im
code: @[simp]
lemma div_ofNat_im (z : ℂ) (n : ℕ) [n.AtLeastTwo] :
    (z / no_index (OfNat.ofNat n)).im = z.im / OfNat.ofNat n 
goal: (z / OfNat.ofNat n).im = z.im / OfNat.ofNat n

full_name: Complex.instCharZero
code: instance instCharZero : CharZero ℂ 
goal: CharZero ℂ

full_name: Complex.re_eq_add_conj
code: /-- A complex number `z` plus its conjugate `conj z` is `2` times its real part. -/
theorem re_eq_add_conj (z : ℂ) : (z.re : ℂ) = (z + conj z) / 2 
goal: ↑z.re = (z + (starRingEnd ℂ) z) / 2

full_name: Complex.im_eq_sub_conj
code: /-- A complex number `z` minus its conjugate `conj z` is `2i` times its imaginary part. -/
theorem im_eq_sub_conj (z : ℂ) : (z.im : ℂ) = (z - conj z) / (2 * I) 
goal: ↑z.im = (z - (starRingEnd ℂ) z) / (2 * Complex.I)

full_name: Complex.instRepr
code: /-- Show the imaginary number ⟨x, y⟩ as an "x + y*I" string

Note that the Real numbers used for x and y will show as cauchy sequences due to the way Real
numbers are represented.
-/
unsafe instance instRepr : Repr ℂ 
goal: Repr ℂ