File: Mathlib/Analysis/Complex/Basic.lean

full_name: Complex.instNorm
code: instance : Norm ℂ 
goal: Norm ℂ

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

full_name: Complex.norm_I
code: lemma norm_I : ‖I‖ = 1 
goal: ‖Complex.I‖ = 1

full_name: Complex.norm_exp_ofReal_mul_I
code: theorem norm_exp_ofReal_mul_I (t : ℝ) : ‖exp (t * I)‖ = 1 
goal: ‖Complex.exp (↑t * Complex.I)‖ = 1

full_name: Complex.instNormedAddCommGroup
code: instance instNormedAddCommGroup : NormedAddCommGroup ℂ 
goal: NormedAddCommGroup ℂ

full_name: Complex.instNormedField
code: instance : NormedField ℂ 
goal: NormedField ℂ

full_name: Complex.instDenselyNormedField
code: instance : DenselyNormedField ℂ 
goal: DenselyNormedField ℂ

full_name: Complex.instNormedAlgebraOfReal
code: instance {R : Type*} [NormedField R] [NormedAlgebra R ℝ] : NormedAlgebra R ℂ 
goal: NormedAlgebra R ℂ

full_name: NormedSpace.complexToReal
code: /-- The module structure from `Module.complexToReal` is a normed space. -/
instance (priority := 900) _root_.NormedSpace.complexToReal : NormedSpace ℝ E 
goal: NormedSpace ℝ E

full_name: NormedAlgebra.complexToReal
code: /-- The algebra structure from `Algebra.complexToReal` is a normed algebra. -/
instance (priority := 900) _root_.NormedAlgebra.complexToReal {A : Type*} [SeminormedRing A]
    [NormedAlgebra ℂ A] : NormedAlgebra ℝ A 
goal: NormedAlgebra ℝ A

full_name: Complex.dist_eq
code: theorem dist_eq (z w : ℂ) : dist z w = abs (z - w) 
goal: dist z w = Complex.abs (z - w)

full_name: Complex.dist_eq_re_im
code: theorem dist_eq_re_im (z w : ℂ) : dist z w = √((z.re - w.re) ^ 2 + (z.im - w.im) ^ 2) 
goal: dist z w = √((z.re - w.re) ^ 2 + (z.im - w.im) ^ 2)

full_name: Complex.dist_mk
code: @[simp]
theorem dist_mk (x₁ y₁ x₂ y₂ : ℝ) :
    dist (mk x₁ y₁) (mk x₂ y₂) = √((x₁ - x₂) ^ 2 + (y₁ - y₂) ^ 2) 
goal: dist { re := x₁, im := y₁ } { re := x₂, im := y₂ } = √((x₁ - x₂) ^ 2 + (y₁ - y₂) ^ 2)

full_name: Complex.dist_of_re_eq
code: theorem dist_of_re_eq {z w : ℂ} (h : z.re = w.re) : dist z w = dist z.im w.im 
goal: dist z w = dist z.im w.im

full_name: Complex.nndist_of_re_eq
code: theorem nndist_of_re_eq {z w : ℂ} (h : z.re = w.re) : nndist z w = nndist z.im w.im 
goal: nndist z w = nndist z.im w.im

full_name: Complex.edist_of_re_eq
code: theorem edist_of_re_eq {z w : ℂ} (h : z.re = w.re) : edist z w = edist z.im w.im 
goal: edist z w = edist z.im w.im

full_name: Complex.dist_of_im_eq
code: theorem dist_of_im_eq {z w : ℂ} (h : z.im = w.im) : dist z w = dist z.re w.re 
goal: dist z w = dist z.re w.re

full_name: Complex.nndist_of_im_eq
code: theorem nndist_of_im_eq {z w : ℂ} (h : z.im = w.im) : nndist z w = nndist z.re w.re 
goal: nndist z w = nndist z.re w.re

full_name: Complex.edist_of_im_eq
code: theorem edist_of_im_eq {z w : ℂ} (h : z.im = w.im) : edist z w = edist z.re w.re 
goal: edist z w = edist z.re w.re

full_name: Complex.dist_conj_self
code: theorem dist_conj_self (z : ℂ) : dist (conj z) z = 2 * |z.im| 
goal: dist ((starRingEnd ℂ) z) z = 2 * |z.im|

full_name: Complex.nndist_conj_self
code: theorem nndist_conj_self (z : ℂ) : nndist (conj z) z = 2 * Real.nnabs z.im 
goal: nndist ((starRingEnd ℂ) z) z = 2 * Real.nnabs z.im

full_name: Complex.dist_self_conj
code: theorem dist_self_conj (z : ℂ) : dist z (conj z) = 2 * |z.im| 
goal: dist z ((starRingEnd ℂ) z) = 2 * |z.im|

full_name: Complex.nndist_self_conj
code: theorem nndist_self_conj (z : ℂ) : nndist z (conj z) = 2 * Real.nnabs z.im 
goal: nndist z ((starRingEnd ℂ) z) = 2 * Real.nnabs z.im

full_name: Complex.comap_abs_nhds_zero
code: @[simp 1100]
theorem comap_abs_nhds_zero : comap abs (𝓝 0) = 𝓝 0 
goal: Filter.comap (⇑Complex.abs) (nhds 0) = nhds 0

full_name: Complex.norm_real
code: theorem norm_real (r : ℝ) : ‖(r : ℂ)‖ = ‖r‖ 
goal: ‖↑r‖ = ‖r‖

full_name: Complex.norm_rat
code: @[simp 1100]
theorem norm_rat (r : ℚ) : ‖(r : ℂ)‖ = |(r : ℝ)| 
goal: ‖↑r‖ = |↑r|

full_name: Complex.norm_nat
code: @[simp 1100]
theorem norm_nat (n : ℕ) : ‖(n : ℂ)‖ = n 
goal: ‖↑n‖ = ↑n

full_name: Complex.norm_int
code: @[simp 1100]
lemma norm_int {n : ℤ} : ‖(n : ℂ)‖ = |(n : ℝ)| 
goal: ‖↑n‖ = |↑n|

full_name: Complex.norm_int_of_nonneg
code: theorem norm_int_of_nonneg {n : ℤ} (hn : 0 ≤ n) : ‖(n : ℂ)‖ = n 
goal: ‖↑n‖ = ↑n

full_name: Complex.normSq_eq_norm_sq
code: lemma normSq_eq_norm_sq (z : ℂ) : normSq z = ‖z‖ ^ 2 
goal: Complex.normSq z = ‖z‖ ^ 2

full_name: Complex.continuous_abs
code: @[continuity]
theorem continuous_abs : Continuous abs 
goal: Continuous ⇑Complex.abs

full_name: Complex.continuous_normSq
code: @[continuity]
theorem continuous_normSq : Continuous normSq 
goal: Continuous ⇑Complex.normSq

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

full_name: Complex.nnnorm_nat
code: @[simp, norm_cast]
theorem nnnorm_nat (n : ℕ) : ‖(n : ℂ)‖₊ = n 
goal: ‖↑n‖₊ = ↑n

full_name: Complex.nnnorm_int
code: @[simp, norm_cast]
theorem nnnorm_int (n : ℤ) : ‖(n : ℂ)‖₊ = ‖n‖₊ 
goal: ‖↑n‖₊ = ‖n‖₊

full_name: Complex.nnnorm_eq_one_of_pow_eq_one
code: theorem nnnorm_eq_one_of_pow_eq_one {ζ : ℂ} {n : ℕ} (h : ζ ^ n = 1) (hn : n ≠ 0) : ‖ζ‖₊ = 1 
goal: ‖ζ‖₊ = 1

full_name: Complex.norm_eq_one_of_pow_eq_one
code: theorem norm_eq_one_of_pow_eq_one {ζ : ℂ} {n : ℕ} (h : ζ ^ n = 1) (hn : n ≠ 0) : ‖ζ‖ = 1 
goal: ‖ζ‖ = 1

full_name: Complex.le_of_eq_sum_of_eq_sum_norm
code: lemma le_of_eq_sum_of_eq_sum_norm {ι : Type*} {a b : ℝ} (f : ι → ℂ) (s : Finset ι) (ha₀ : 0 ≤ a)
    (ha : a = ∑ i ∈ s, f i) (hb : b = ∑ i ∈ s, (‖f i‖ : ℂ)) : a ≤ b 
goal: a ≤ b

full_name: Complex.equivRealProd_apply_le
code: theorem equivRealProd_apply_le (z : ℂ) : ‖equivRealProd z‖ ≤ abs z 
goal: ‖Complex.equivRealProd z‖ ≤ Complex.abs z

full_name: Complex.equivRealProd_apply_le'
code: theorem equivRealProd_apply_le' (z : ℂ) : ‖equivRealProd z‖ ≤ 1 * abs z 
goal: ‖Complex.equivRealProd z‖ ≤ 1 * Complex.abs z

full_name: Complex.lipschitz_equivRealProd
code: theorem lipschitz_equivRealProd : LipschitzWith 1 equivRealProd 
goal: LipschitzWith 1 ⇑Complex.equivRealProd

full_name: Complex.antilipschitz_equivRealProd
code: theorem antilipschitz_equivRealProd : AntilipschitzWith (NNReal.sqrt 2) equivRealProd 
goal: AntilipschitzWith (NNReal.sqrt 2) ⇑Complex.equivRealProd

full_name: Complex.uniformEmbedding_equivRealProd
code: theorem uniformEmbedding_equivRealProd : UniformEmbedding equivRealProd 
goal: UniformEmbedding ⇑Complex.equivRealProd

full_name: Complex.instCompleteSpace
code: instance : CompleteSpace ℂ 
goal: CompleteSpace ℂ

full_name: Complex.instT2Space
code: instance instT2Space : T2Space ℂ 
goal: T2Space ℂ

full_name: Complex.equivRealProdCLM_symm_apply_im
code: /-- The natural `ContinuousLinearEquiv` from `ℂ` to `ℝ × ℝ`. -/
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdCLM : ℂ ≃L[ℝ] ℝ × ℝ 
goal: ∀ (a : ℝ × ℝ), (Complex.equivRealProdCLM.symm a).im = a.2

full_name: Complex.equivRealProdCLM_apply
code: /-- The natural `ContinuousLinearEquiv` from `ℂ` to `ℝ × ℝ`. -/
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdCLM : ℂ ≃L[ℝ] ℝ × ℝ 
goal: ∀ (a : ℂ), Complex.equivRealProdCLM a = (a.re, a.im)

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

full_name: Complex.equivRealProdCLM_symm_apply_re
code: /-- The natural `ContinuousLinearEquiv` from `ℂ` to `ℝ × ℝ`. -/
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdCLM : ℂ ≃L[ℝ] ℝ × ℝ 
goal: ∀ (a : ℝ × ℝ), (Complex.equivRealProdCLM.symm a).re = a.1

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

full_name: Complex.instProperSpace
code: instance : ProperSpace ℂ 
goal: ProperSpace ℂ

full_name: Complex.tendsto_abs_cocompact_atTop
code: /-- The `abs` function on `ℂ` is proper. -/
theorem tendsto_abs_cocompact_atTop : Tendsto abs (cocompact ℂ) atTop 
goal: Filter.Tendsto (⇑Complex.abs) (Filter.cocompact ℂ) Filter.atTop

full_name: Complex.tendsto_normSq_cocompact_atTop
code: /-- The `normSq` function on `ℂ` is proper. -/
theorem tendsto_normSq_cocompact_atTop : Tendsto normSq (cocompact ℂ) atTop 
goal: Filter.Tendsto (⇑Complex.normSq) (Filter.cocompact ℂ) Filter.atTop

full_name: Complex.reCLM
code: /-- Continuous linear map version of the real part function, from `ℂ` to `ℝ`. -/
def reCLM : ℂ →L[ℝ] ℝ 
goal: ℂ →L[ℝ] ℝ

full_name: Complex.continuous_re
code: @[continuity, fun_prop]
theorem continuous_re : Continuous re 
goal: Continuous Complex.re

full_name: Complex.reCLM_coe
code: @[simp]
theorem reCLM_coe : (reCLM : ℂ →ₗ[ℝ] ℝ) = reLm 
goal: ↑Complex.reCLM = Complex.reLm

full_name: Complex.reCLM_apply
code: @[simp]
theorem reCLM_apply (z : ℂ) : (reCLM : ℂ → ℝ) z = z.re 
goal: Complex.reCLM z = z.re

full_name: Complex.imCLM
code: /-- Continuous linear map version of the imaginary part function, from `ℂ` to `ℝ`. -/
def imCLM : ℂ →L[ℝ] ℝ 
goal: ℂ →L[ℝ] ℝ

full_name: Complex.continuous_im
code: @[continuity, fun_prop]
theorem continuous_im : Continuous im 
goal: Continuous Complex.im

full_name: Complex.imCLM_coe
code: @[simp]
theorem imCLM_coe : (imCLM : ℂ →ₗ[ℝ] ℝ) = imLm 
goal: ↑Complex.imCLM = Complex.imLm

full_name: Complex.imCLM_apply
code: @[simp]
theorem imCLM_apply (z : ℂ) : (imCLM : ℂ → ℝ) z = z.im 
goal: Complex.imCLM z = z.im

full_name: Complex.restrictScalars_one_smulRight'
code: theorem restrictScalars_one_smulRight' (x : E) :
    ContinuousLinearMap.restrictScalars ℝ ((1 : ℂ →L[ℂ] ℂ).smulRight x : ℂ →L[ℂ] E) =
      reCLM.smulRight x + I • imCLM.smulRight x 
goal: ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 x) =
  Complex.reCLM.smulRight x + Complex.I • Complex.imCLM.smulRight x

full_name: Complex.restrictScalars_one_smulRight
code: theorem restrictScalars_one_smulRight (x : ℂ) :
    ContinuousLinearMap.restrictScalars ℝ ((1 : ℂ →L[ℂ] ℂ).smulRight x : ℂ →L[ℂ] ℂ) =
    x • (1 : ℂ →L[ℝ] ℂ) 
goal: ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 x) = x • 1

full_name: Complex.conjLIE
code: /-- The complex-conjugation function from `ℂ` to itself is an isometric linear equivalence. -/
def conjLIE : ℂ ≃ₗᵢ[ℝ] ℂ 
goal: ℂ ≃ₗᵢ[ℝ] ℂ

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

full_name: Complex.conjLIE_symm
code: @[simp]
theorem conjLIE_symm : conjLIE.symm = conjLIE 
goal: Complex.conjLIE.symm = Complex.conjLIE

full_name: Complex.isometry_conj
code: theorem isometry_conj : Isometry (conj : ℂ → ℂ) 
goal: Isometry ⇑(starRingEnd ℂ)

full_name: Complex.dist_conj_conj
code: @[simp]
theorem dist_conj_conj (z w : ℂ) : dist (conj z) (conj w) = dist z w 
goal: dist ((starRingEnd ℂ) z) ((starRingEnd ℂ) w) = dist z w

full_name: Complex.nndist_conj_conj
code: @[simp]
theorem nndist_conj_conj (z w : ℂ) : nndist (conj z) (conj w) = nndist z w 
goal: nndist ((starRingEnd ℂ) z) ((starRingEnd ℂ) w) = nndist z w

full_name: Complex.dist_conj_comm
code: theorem dist_conj_comm (z w : ℂ) : dist (conj z) w = dist z (conj w) 
goal: dist ((starRingEnd ℂ) z) w = dist z ((starRingEnd ℂ) w)

full_name: Complex.nndist_conj_comm
code: theorem nndist_conj_comm (z w : ℂ) : nndist (conj z) w = nndist z (conj w) 
goal: nndist ((starRingEnd ℂ) z) w = nndist z ((starRingEnd ℂ) w)

full_name: Complex.instContinuousStar
code: instance : ContinuousStar ℂ 
goal: ContinuousStar ℂ

full_name: Complex.continuous_conj
code: @[continuity]
theorem continuous_conj : Continuous (conj : ℂ → ℂ) 
goal: Continuous ⇑(starRingEnd ℂ)

full_name: Complex.ringHom_eq_id_or_conj_of_continuous
code: /-- The only continuous ring homomorphisms from `ℂ` to `ℂ` are the identity and the complex
conjugation. -/
theorem ringHom_eq_id_or_conj_of_continuous {f : ℂ →+* ℂ} (hf : Continuous f) :
    f = RingHom.id ℂ ∨ f = conj 
goal: f = RingHom.id ℂ ∨ f = starRingEnd ℂ

full_name: Complex.conjCLE
code: /-- Continuous linear equiv version of the conj function, from `ℂ` to `ℂ`. -/
def conjCLE : ℂ ≃L[ℝ] ℂ 
goal: ℂ ≃L[ℝ] ℂ

full_name: Complex.conjCLE_coe
code: @[simp]
theorem conjCLE_coe : conjCLE.toLinearEquiv = conjAe.toLinearEquiv 
goal: Complex.conjCLE.toLinearEquiv = Complex.conjAe.toLinearEquiv

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

full_name: Complex.ofRealLI
code: /-- Linear isometry version of the canonical embedding of `ℝ` in `ℂ`. -/
def ofRealLI : ℝ →ₗᵢ[ℝ] ℂ 
goal: ℝ →ₗᵢ[ℝ] ℂ

full_name: Complex.isometry_ofReal
code: theorem isometry_ofReal : Isometry ((↑) : ℝ → ℂ) 
goal: Isometry Complex.ofReal'

full_name: Complex.continuous_ofReal
code: @[continuity, fun_prop]
theorem continuous_ofReal : Continuous ((↑) : ℝ → ℂ) 
goal: Continuous Complex.ofReal'

full_name: Filter.Tendsto.ofReal
code: lemma _root_.Filter.Tendsto.ofReal {α : Type*} {l : Filter α} {f : α → ℝ} {x : ℝ}
    (hf : Tendsto f l (𝓝 x)) : Tendsto (fun x ↦ (f x : ℂ)) l (𝓝 (x : ℂ)) 
goal: Filter.Tendsto (fun x => ↑(f x)) l (nhds ↑x)

full_name: Complex.ringHom_eq_ofReal_of_continuous
code: /-- The only continuous ring homomorphism from `ℝ` to `ℂ` is the identity. -/
theorem ringHom_eq_ofReal_of_continuous {f : ℝ →+* ℂ} (h : Continuous f) : f = Complex.ofReal 
goal: f = Complex.ofReal

full_name: Complex.ofRealCLM
code: /-- Continuous linear map version of the canonical embedding of `ℝ` in `ℂ`. -/
def ofRealCLM : ℝ →L[ℝ] ℂ 
goal: ℝ →L[ℝ] ℂ

full_name: Complex.ofRealCLM_coe
code: @[simp]
theorem ofRealCLM_coe : (ofRealCLM : ℝ →ₗ[ℝ] ℂ) = ofRealAm.toLinearMap 
goal: ↑Complex.ofRealCLM = Complex.ofRealAm.toLinearMap

full_name: Complex.ofRealCLM_apply
code: @[simp]
theorem ofRealCLM_apply (x : ℝ) : ofRealCLM x = x 
goal: Complex.ofRealCLM x = ↑x

full_name: Complex.instRCLike
code: noncomputable instance : RCLike ℂ 
goal: RCLike ℂ

full_name: RCLike.re_eq_complex_re
code: theorem _root_.RCLike.re_eq_complex_re : ⇑(RCLike.re : ℂ →+ ℝ) = Complex.re 
goal: ⇑RCLike.re = Complex.re

full_name: RCLike.im_eq_complex_im
code: theorem _root_.RCLike.im_eq_complex_im : ⇑(RCLike.im : ℂ →+ ℝ) = Complex.im 
goal: ⇑RCLike.im = Complex.im

full_name: Complex.mul_conj'
code: lemma mul_conj' (z : ℂ) : z * conj z = ‖z‖ ^ 2 
goal: z * (starRingEnd ℂ) z = ↑‖z‖ ^ 2

full_name: Complex.conj_mul'
code: lemma conj_mul' (z : ℂ) : conj z * z = ‖z‖ ^ 2 
goal: (starRingEnd ℂ) z * z = ↑‖z‖ ^ 2

full_name: Complex.inv_eq_conj
code: lemma inv_eq_conj (hz : ‖z‖ = 1) : z⁻¹ = conj z 
goal: z⁻¹ = (starRingEnd ℂ) z

full_name: Complex.exists_norm_eq_mul_self
code: lemma exists_norm_eq_mul_self (z : ℂ) : ∃ c, ‖c‖ = 1 ∧ ‖z‖ = c * z 
goal: ∃ c, ‖c‖ = 1 ∧ ↑‖z‖ = c * z

full_name: Complex.exists_norm_mul_eq_self
code: lemma exists_norm_mul_eq_self (z : ℂ) : ∃ c, ‖c‖ = 1 ∧ c * ‖z‖ = z 
goal: ∃ c, ‖c‖ = 1 ∧ c * ↑‖z‖ = z

full_name: RCLike.complexRingEquiv_symm_apply
code: /-- The natural isomorphism between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexRingEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃+* ℂ 
goal: (RCLike.complexRingEquiv h).symm x = ↑x.re + ↑x.im * RCLike.I

full_name: RCLike.complexRingEquiv
code: /-- The natural isomorphism between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexRingEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃+* ℂ 
goal: 𝕜 ≃+* ℂ

full_name: RCLike.complexRingEquiv_apply
code: /-- The natural isomorphism between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexRingEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃+* ℂ 
goal: (RCLike.complexRingEquiv h) x = ↑(RCLike.re x) + ↑(RCLike.im x) * Complex.I

full_name: RCLike.complexLinearIsometryEquiv
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexLinearIsometryEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃ₗᵢ[ℝ] ℂ 
goal: 𝕜 ≃ₗᵢ[ℝ] ℂ

full_name: RCLike.complexLinearIsometryEquiv_toFun
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexLinearIsometryEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃ₗᵢ[ℝ] ℂ 
goal: ∀ (a : 𝕜), (RCLike.complexLinearIsometryEquiv h) a = (RCLike.complexRingEquiv h).toFun a

full_name: RCLike.complexLinearIsometryEquiv_apply
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexLinearIsometryEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃ₗᵢ[ℝ] ℂ 
goal: ∀ (a : 𝕜), (RCLike.complexLinearIsometryEquiv h) a = (RCLike.complexRingEquiv h).toFun a

full_name: RCLike.complexLinearIsometryEquiv_symm_apply
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexLinearIsometryEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃ₗᵢ[ℝ] ℂ 
goal: ∀ (a : ℂ), (RCLike.complexLinearIsometryEquiv h).symm a = (RCLike.complexRingEquiv h).invFun a

full_name: RCLike.complexLinearIsometryEquiv_invFun
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℂ` when
`RCLike.im RCLike.I = 1`. -/
@[simps]
def _root_.RCLike.complexLinearIsometryEquiv {𝕜 : Type*} [RCLike 𝕜]
    (h : RCLike.im (RCLike.I : 𝕜) = 1) : 𝕜 ≃ₗᵢ[ℝ] ℂ 
goal: ∀ (a : ℂ), (RCLike.complexLinearIsometryEquiv h).invFun a = (RCLike.complexRingEquiv h).invFun a

full_name: Complex.eq_coe_norm_of_nonneg
code: theorem eq_coe_norm_of_nonneg {z : ℂ} (hz : 0 ≤ z) : z = ↑‖z‖ 
goal: z = ↑‖z‖

full_name: Complex.orderClosedTopology
code: /-- We show that the partial order and the topology on `ℂ` are compatible.
We turn this into an instance scoped to `ComplexOrder`. -/
lemma orderClosedTopology : OrderClosedTopology ℂ 
goal: OrderClosedTopology ℂ

full_name: RCLike._aux_Mathlib_Analysis_Complex_Basic___macroRules_RCLike_termReC_1
code: local notation "reC" => @RCLike.re ℂ _
goal: Lean.Macro

full_name: RCLike._aux_Mathlib_Analysis_Complex_Basic___macroRules_RCLike_termImC_1
code: local notation "imC" => @RCLike.im ℂ _
goal: Lean.Macro

full_name: RCLike._aux_Mathlib_Analysis_Complex_Basic___macroRules_RCLike_termIC_1
code: local notation "IC" => @RCLike.I ℂ _
goal: Lean.Macro

full_name: RCLike._aux_Mathlib_Analysis_Complex_Basic___macroRules_RCLike_termNorm_sqC_1
code: local notation "norm_sqC" => @RCLike.normSq ℂ _
goal: Lean.Macro

full_name: RCLike.re_to_complex
code: @[simp]
theorem re_to_complex {x : ℂ} : reC x = x.re 
goal: RCLike.re x = x.re

full_name: RCLike.im_to_complex
code: @[simp]
theorem im_to_complex {x : ℂ} : imC x = x.im 
goal: RCLike.im x = x.im

full_name: RCLike.I_to_complex
code: @[simp]
theorem I_to_complex : IC = Complex.I 
goal: RCLike.I = Complex.I

full_name: RCLike.normSq_to_complex
code: @[simp]
theorem normSq_to_complex {x : ℂ} : norm_sqC x = Complex.normSq x 
goal: RCLike.normSq x = Complex.normSq x

full_name: RCLike.hasSum_conj
code: @[simp]
theorem hasSum_conj {f : α → 𝕜} {x : 𝕜} : HasSum (fun x => conj (f x)) x ↔ HasSum f (conj x) 
goal: HasSum (fun x => (starRingEnd 𝕜) (f x)) x ↔ HasSum f ((starRingEnd 𝕜) x)

full_name: RCLike.hasSum_conj'
code: theorem hasSum_conj' {f : α → 𝕜} {x : 𝕜} : HasSum (fun x => conj (f x)) (conj x) ↔ HasSum f x 
goal: HasSum (fun x => (starRingEnd 𝕜) (f x)) ((starRingEnd 𝕜) x) ↔ HasSum f x

full_name: RCLike.summable_conj
code: @[simp]
theorem summable_conj {f : α → 𝕜} : (Summable fun x => conj (f x)) ↔ Summable f 
goal: (Summable fun x => (starRingEnd 𝕜) (f x)) ↔ Summable f

full_name: RCLike.conj_tsum
code: theorem conj_tsum (f : α → 𝕜) : conj (∑' a, f a) = ∑' a, conj (f a) 
goal: (starRingEnd 𝕜) (∑' (a : α), f a) = ∑' (a : α), (starRingEnd 𝕜) (f a)

full_name: RCLike.hasSum_ofReal
code: @[simp, norm_cast]
theorem hasSum_ofReal {f : α → ℝ} {x : ℝ} : HasSum (fun x => (f x : 𝕜)) x ↔ HasSum f x 
goal: HasSum (fun x => ↑(f x)) ↑x ↔ HasSum f x

full_name: RCLike.summable_ofReal
code: @[simp, norm_cast]
theorem summable_ofReal {f : α → ℝ} : (Summable fun x => (f x : 𝕜)) ↔ Summable f 
goal: (Summable fun x => ↑(f x)) ↔ Summable f

full_name: RCLike.ofReal_tsum
code: @[norm_cast]
theorem ofReal_tsum (f : α → ℝ) : (↑(∑' a, f a) : 𝕜) = ∑' a, (f a : 𝕜) 
goal: ↑(∑' (a : α), f a) = ∑' (a : α), ↑(f a)

full_name: RCLike.hasSum_re
code: theorem hasSum_re {f : α → 𝕜} {x : 𝕜} (h : HasSum f x) : HasSum (fun x => re (f x)) (re x) 
goal: HasSum (fun x => RCLike.re (f x)) (RCLike.re x)

full_name: RCLike.hasSum_im
code: theorem hasSum_im {f : α → 𝕜} {x : 𝕜} (h : HasSum f x) : HasSum (fun x => im (f x)) (im x) 
goal: HasSum (fun x => RCLike.im (f x)) (RCLike.im x)

full_name: RCLike.re_tsum
code: theorem re_tsum {f : α → 𝕜} (h : Summable f) : re (∑' a, f a) = ∑' a, re (f a) 
goal: RCLike.re (∑' (a : α), f a) = ∑' (a : α), RCLike.re (f a)

full_name: RCLike.im_tsum
code: theorem im_tsum {f : α → 𝕜} (h : Summable f) : im (∑' a, f a) = ∑' a, im (f a) 
goal: RCLike.im (∑' (a : α), f a) = ∑' (a : α), RCLike.im (f a)

full_name: RCLike.hasSum_iff
code: theorem hasSum_iff (f : α → 𝕜) (c : 𝕜) :
    HasSum f c ↔ HasSum (fun x => re (f x)) (re c) ∧ HasSum (fun x => im (f x)) (im c) 
goal: HasSum f c ↔ HasSum (fun x => RCLike.re (f x)) (RCLike.re c) ∧ HasSum (fun x => RCLike.im (f x)) (RCLike.im c)

full_name: Complex.hasSum_conj
code: theorem hasSum_conj {f : α → ℂ} {x : ℂ} : HasSum (fun x => conj (f x)) x ↔ HasSum f (conj x) 
goal: HasSum (fun x => (starRingEnd ℂ) (f x)) x ↔ HasSum f ((starRingEnd ℂ) x)

full_name: Complex.hasSum_conj'
code: theorem hasSum_conj' {f : α → ℂ} {x : ℂ} : HasSum (fun x => conj (f x)) (conj x) ↔ HasSum f x 
goal: HasSum (fun x => (starRingEnd ℂ) (f x)) ((starRingEnd ℂ) x) ↔ HasSum f x

full_name: Complex.summable_conj
code: theorem summable_conj {f : α → ℂ} : (Summable fun x => conj (f x)) ↔ Summable f 
goal: (Summable fun x => (starRingEnd ℂ) (f x)) ↔ Summable f

full_name: Complex.conj_tsum
code: theorem conj_tsum (f : α → ℂ) : conj (∑' a, f a) = ∑' a, conj (f a) 
goal: (starRingEnd ℂ) (∑' (a : α), f a) = ∑' (a : α), (starRingEnd ℂ) (f a)

full_name: Complex.hasSum_ofReal
code: @[simp, norm_cast]
theorem hasSum_ofReal {f : α → ℝ} {x : ℝ} : HasSum (fun x => (f x : ℂ)) x ↔ HasSum f x 
goal: HasSum (fun x => ↑(f x)) ↑x ↔ HasSum f x

full_name: Complex.summable_ofReal
code: @[simp, norm_cast]
theorem summable_ofReal {f : α → ℝ} : (Summable fun x => (f x : ℂ)) ↔ Summable f 
goal: (Summable fun x => ↑(f x)) ↔ Summable f

full_name: Complex.ofReal_tsum
code: @[norm_cast]
theorem ofReal_tsum (f : α → ℝ) : (↑(∑' a, f a) : ℂ) = ∑' a, ↑(f a) 
goal: ↑(∑' (a : α), f a) = ∑' (a : α), ↑(f a)

full_name: Complex.hasSum_re
code: theorem hasSum_re {f : α → ℂ} {x : ℂ} (h : HasSum f x) : HasSum (fun x => (f x).re) x.re 
goal: HasSum (fun x => (f x).re) x.re

full_name: Complex.hasSum_im
code: theorem hasSum_im {f : α → ℂ} {x : ℂ} (h : HasSum f x) : HasSum (fun x => (f x).im) x.im 
goal: HasSum (fun x => (f x).im) x.im

full_name: Complex.re_tsum
code: theorem re_tsum {f : α → ℂ} (h : Summable f) : (∑' a, f a).re = ∑' a, (f a).re 
goal: (∑' (a : α), f a).re = ∑' (a : α), (f a).re

full_name: Complex.im_tsum
code: theorem im_tsum {f : α → ℂ} (h : Summable f) : (∑' a, f a).im = ∑' a, (f a).im 
goal: (∑' (a : α), f a).im = ∑' (a : α), (f a).im

full_name: Complex.hasSum_iff
code: theorem hasSum_iff (f : α → ℂ) (c : ℂ) :
    HasSum f c ↔ HasSum (fun x => (f x).re) c.re ∧ HasSum (fun x => (f x).im) c.im 
goal: HasSum f c ↔ HasSum (fun x => (f x).re) c.re ∧ HasSum (fun x => (f x).im) c.im

full_name: Complex.slitPlane
code: /-- The *slit plane* is the complex plane with the closed negative real axis removed. -/
def slitPlane : Set ℂ 
goal: Set ℂ

full_name: Complex.mem_slitPlane_iff
code: lemma mem_slitPlane_iff {z : ℂ} : z ∈ slitPlane ↔ 0 < z.re ∨ z.im ≠ 0 
goal: z ∈ Complex.slitPlane ↔ 0 < z.re ∨ z.im ≠ 0

full_name: Complex.slitPlane_eq_union
code: lemma slitPlane_eq_union : slitPlane = {z | 0 < z.re} ∪ {z | z.im ≠ 0} 
goal: Complex.slitPlane = {z | 0 < z.re} ∪ {z | z.im ≠ 0}

full_name: Complex.isOpen_slitPlane
code: lemma isOpen_slitPlane : IsOpen slitPlane 
goal: IsOpen Complex.slitPlane

full_name: Complex.ofReal_mem_slitPlane
code: @[simp]
lemma ofReal_mem_slitPlane {x : ℝ} : ↑x ∈ slitPlane ↔ 0 < x 
goal: ↑x ∈ Complex.slitPlane ↔ 0 < x

full_name: Complex.neg_ofReal_mem_slitPlane
code: @[simp]
lemma neg_ofReal_mem_slitPlane {x : ℝ} : -↑x ∈ slitPlane ↔ x < 0 
goal: -↑x ∈ Complex.slitPlane ↔ x < 0

full_name: Complex.one_mem_slitPlane
code: @[simp] lemma one_mem_slitPlane : 1 ∈ slitPlane 
goal: 1 ∈ Complex.slitPlane

full_name: Complex.zero_not_mem_slitPlane
code: @[simp]
lemma zero_not_mem_slitPlane : 0 ∉ slitPlane 
goal: 0 ∉ Complex.slitPlane

full_name: Complex.natCast_mem_slitPlane
code: @[simp]
lemma natCast_mem_slitPlane {n : ℕ} : ↑n ∈ slitPlane ↔ n ≠ 0 
goal: ↑n ∈ Complex.slitPlane ↔ n ≠ 0

full_name: Complex.ofNat_mem_slitPlane
code: @[simp]
lemma ofNat_mem_slitPlane (n : ℕ) [n.AtLeastTwo] : no_index (OfNat.ofNat n) ∈ slitPlane 
goal: OfNat.ofNat n ∈ Complex.slitPlane

full_name: Complex.mem_slitPlane_iff_not_le_zero
code: lemma mem_slitPlane_iff_not_le_zero {z : ℂ} : z ∈ slitPlane ↔ ¬z ≤ 0 
goal: z ∈ Complex.slitPlane ↔ ¬z ≤ 0

full_name: Complex.compl_Iic_zero
code: protected lemma compl_Iic_zero : (Set.Iic 0)ᶜ = slitPlane 
goal: (Set.Iic 0)ᶜ = Complex.slitPlane

full_name: Complex.slitPlane_ne_zero
code: lemma slitPlane_ne_zero {z : ℂ} (hz : z ∈ slitPlane) : z ≠ 0 
goal: z ≠ 0

full_name: Complex.ball_one_subset_slitPlane
code: /-- The slit plane includes the open unit ball of radius `1` around `1`. -/
lemma ball_one_subset_slitPlane : Metric.ball 1 1 ⊆ slitPlane 
goal: Metric.ball 1 1 ⊆ Complex.slitPlane

full_name: Complex.mem_slitPlane_of_norm_lt_one
code: /-- The slit plane includes the open unit ball of radius `1` around `1`. -/
lemma mem_slitPlane_of_norm_lt_one {z : ℂ} (hz : ‖z‖ < 1) : 1 + z ∈ slitPlane 
goal: 1 + z ∈ Complex.slitPlane