File: Mathlib/Analysis/RCLike/Basic.lean

full_name: _aux_Mathlib_Analysis_RCLike_Basic___macroRules_term𝓚_1
code: local notation "𝓚" => algebraMap ℝ _
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_RCLike_Basic___unexpand_algebraMap_1
code: local notation "𝓚" => algebraMap ℝ _
goal: Lean.PrettyPrinter.Unexpander

full_name: RCLike.I_re_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.re RCLike.I = 0

full_name: RCLike.ofReal_im_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.im ((algebraMap ℝ K) r) = 0

full_name: RCLike
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: Type u_1

full_name: RCLike.conj_im_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.im ((starRingEnd K) z) = -RCLike.im z

full_name: RCLike.toPartialOrder
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: PartialOrder K

full_name: RCLike.ofReal_re_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.re ((algebraMap ℝ K) r) = r

full_name: RCLike.conj_I_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: (starRingEnd K) RCLike.I = -RCLike.I

full_name: RCLike.norm_sq_eq_def_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: ‖z‖ ^ 2 = RCLike.re z * RCLike.re z + RCLike.im z * RCLike.im z

full_name: RCLike.re_add_im_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: (algebraMap ℝ K) (RCLike.re z) + (algebraMap ℝ K) (RCLike.im z) * RCLike.I = z

full_name: RCLike.im
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: K →+ ℝ

full_name: RCLike.mul_re_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.re (z * w) = RCLike.re z * RCLike.re w - RCLike.im z * RCLike.im w

full_name: RCLike.conj_re_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.re ((starRingEnd K) z) = RCLike.re z

full_name: RCLike.mul_im_I_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.im z * RCLike.im RCLike.I = RCLike.im z

full_name: RCLike.I_mul_I_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.I = 0 ∨ RCLike.I * RCLike.I = -1

full_name: RCLike.I
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: K

full_name: RCLike.toDecidableEq
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: DecidableEq K

full_name: RCLike.le_iff_re_im
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: z ≤ w ↔ RCLike.re z ≤ RCLike.re w ∧ RCLike.im z = RCLike.im w

full_name: RCLike.mul_im_ax
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: RCLike.im (z * w) = RCLike.re z * RCLike.im w + RCLike.im z * RCLike.re w

full_name: RCLike.re
code: /--
This typeclass captures properties shared by ℝ and ℂ, with an API that closely matches that of ℂ.
-/
class RCLike (K : semiOutParam Type*) extends DenselyNormedField K, StarRing K,
    NormedAlgebra ℝ K, CompleteSpace K where
  re : K →+ ℝ
  im : K →+ ℝ
  /-- Imaginary unit in `K`. Meant to be set to `0` for `K = ℝ`. -/
  I : K
  I_re_ax : re I = 0
  I_mul_I_ax : I = 0 ∨ I * I = -1
  re_add_im_ax : ∀ z : K, 𝓚 (re z) + 𝓚 (im z) * I = z
  ofReal_re_ax : ∀ r : ℝ, re (𝓚 r) = r
  ofReal_im_ax : ∀ r : ℝ, im (𝓚 r) = 0
  mul_re_ax : ∀ z w : K, re (z * w) = re z * re w - im z * im w
  mul_im_ax : ∀ z w : K, im (z * w) = re z * im w + im z * re w
  conj_re_ax : ∀ z : K, re (conj z) = re z
  conj_im_ax : ∀ z : K, im (conj z) = -im z
  conj_I_ax : conj I = -I
  norm_sq_eq_def_ax : ∀ z : K, ‖z‖ ^ 2 = re z * re z + im z * im z
  mul_im_I_ax : ∀ z : K, im z * im I = im z
  /-- only an instance in the `ComplexOrder` locale -/
  [toPartialOrder : PartialOrder K]
  le_iff_re_im {z w : K} : z ≤ w ↔ re z ≤ re w ∧ im z = im w
  -- note we cannot put this in the `extends` clause
  [toDecidableEq : DecidableEq K]
goal: K →+ ℝ

full_name: RCLike.ofReal
code: /-- Coercion from `ℝ` to an `RCLike` field. -/
@[coe] abbrev ofReal : ℝ → K 
goal: ℝ → K

full_name: RCLike.algebraMapCoe
code: noncomputable instance (priority := 900) algebraMapCoe : CoeTC ℝ K 
goal: CoeTC ℝ K

full_name: RCLike.ofReal_alg
code: theorem ofReal_alg (x : ℝ) : (x : K) = x • (1 : K) 
goal: ↑x = x • 1

full_name: RCLike.real_smul_eq_coe_mul
code: theorem real_smul_eq_coe_mul (r : ℝ) (z : K) : r • z = (r : K) * z 
goal: r • z = ↑r * z

full_name: RCLike.real_smul_eq_coe_smul
code: theorem real_smul_eq_coe_smul [AddCommGroup E] [Module K E] [Module ℝ E] [IsScalarTower ℝ K E]
    (r : ℝ) (x : E) : r • x = (r : K) • x 
goal: r • x = ↑r • x

full_name: RCLike.algebraMap_eq_ofReal
code: theorem algebraMap_eq_ofReal : ⇑(algebraMap ℝ K) = ofReal 
goal: ⇑(algebraMap ℝ K) = RCLike.ofReal

full_name: RCLike.re_add_im
code: @[simp, rclike_simps]
theorem re_add_im (z : K) : (re z : K) + im z * I = z 
goal: ↑(RCLike.re z) + ↑(RCLike.im z) * RCLike.I = z

full_name: RCLike.ofReal_re
code: @[simp, norm_cast, rclike_simps]
theorem ofReal_re : ∀ r : ℝ, re (r : K) = r 
goal: RCLike.re ↑r = r

full_name: RCLike.ofReal_im
code: @[simp, norm_cast, rclike_simps]
theorem ofReal_im : ∀ r : ℝ, im (r : K) = 0 
goal: RCLike.im ↑r = 0

full_name: RCLike.mul_re
code: @[simp, rclike_simps]
theorem mul_re : ∀ z w : K, re (z * w) = re z * re w - im z * im w 
goal: RCLike.re (z * w) = RCLike.re z * RCLike.re w - RCLike.im z * RCLike.im w

full_name: RCLike.mul_im
code: @[simp, rclike_simps]
theorem mul_im : ∀ z w : K, im (z * w) = re z * im w + im z * re w 
goal: RCLike.im (z * w) = RCLike.re z * RCLike.im w + RCLike.im z * RCLike.re w

full_name: RCLike.ext_iff
code: theorem ext_iff {z w : K} : z = w ↔ re z = re w ∧ im z = im w 
goal: z = w ↔ RCLike.re z = RCLike.re w ∧ RCLike.im z = RCLike.im w

full_name: RCLike.ext
code: theorem ext {z w : K} (hre : re z = re w) (him : im z = im w) : z = w 
goal: z = w

full_name: RCLike.ofReal_zero
code: @[norm_cast]
theorem ofReal_zero : ((0 : ℝ) : K) = 0 
goal: ↑0 = 0

full_name: RCLike.zero_re'
code: @[rclike_simps]
theorem zero_re' : re (0 : K) = (0 : ℝ) 
goal: RCLike.re 0 = 0

full_name: RCLike.ofReal_one
code: @[norm_cast]
theorem ofReal_one : ((1 : ℝ) : K) = 1 
goal: ↑1 = 1

full_name: RCLike.one_re
code: @[simp, rclike_simps]
theorem one_re : re (1 : K) = 1 
goal: RCLike.re 1 = 1

full_name: RCLike.one_im
code: @[simp, rclike_simps]
theorem one_im : im (1 : K) = 0 
goal: RCLike.im 1 = 0

full_name: RCLike.ofReal_injective
code: theorem ofReal_injective : Function.Injective ((↑) : ℝ → K) 
goal: Function.Injective RCLike.ofReal

full_name: RCLike.ofReal_inj
code: @[norm_cast]
theorem ofReal_inj {z w : ℝ} : (z : K) = (w : K) ↔ z = w 
goal: ↑z = ↑w ↔ z = w

full_name: RCLike.ofReal_eq_zero
code: theorem ofReal_eq_zero {x : ℝ} : (x : K) = 0 ↔ x = 0 
goal: ↑x = 0 ↔ x = 0

full_name: RCLike.ofReal_ne_zero
code: theorem ofReal_ne_zero {x : ℝ} : (x : K) ≠ 0 ↔ x ≠ 0 
goal: ↑x ≠ 0 ↔ x ≠ 0

full_name: RCLike.ofReal_add
code: @[rclike_simps, norm_cast]
theorem ofReal_add (r s : ℝ) : ((r + s : ℝ) : K) = r + s 
goal: ↑(r + s) = ↑r + ↑s

full_name: RCLike.ofReal_neg
code: @[rclike_simps, norm_cast]
theorem ofReal_neg (r : ℝ) : ((-r : ℝ) : K) = -r 
goal: ↑(-r) = -↑r

full_name: RCLike.ofReal_sub
code: @[rclike_simps, norm_cast]
theorem ofReal_sub (r s : ℝ) : ((r - s : ℝ) : K) = r - s 
goal: ↑(r - s) = ↑r - ↑s

full_name: RCLike.ofReal_sum
code: @[rclike_simps, norm_cast]
theorem ofReal_sum {α : Type*} (s : Finset α) (f : α → ℝ) :
    ((∑ i ∈ s, f i : ℝ) : K) = ∑ i ∈ s, (f i : K) 
goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

full_name: RCLike.ofReal_finsupp_sum
code: @[simp, rclike_simps, norm_cast]
theorem ofReal_finsupp_sum {α M : Type*} [Zero M] (f : α →₀ M) (g : α → M → ℝ) :
    ((f.sum fun a b => g a b : ℝ) : K) = f.sum fun a b => (g a b : K) 
goal: ↑(f.sum fun a b => g a b) = f.sum fun a b => ↑(g a b)

full_name: RCLike.ofReal_mul
code: @[rclike_simps, norm_cast]
theorem ofReal_mul (r s : ℝ) : ((r * s : ℝ) : K) = r * s 
goal: ↑(r * s) = ↑r * ↑s

full_name: RCLike.ofReal_pow
code: @[rclike_simps, norm_cast]
theorem ofReal_pow (r : ℝ) (n : ℕ) : ((r ^ n : ℝ) : K) = (r : K) ^ n 
goal: ↑(r ^ n) = ↑r ^ n

full_name: RCLike.ofReal_prod
code: @[rclike_simps, norm_cast]
theorem ofReal_prod {α : Type*} (s : Finset α) (f : α → ℝ) :
    ((∏ i ∈ s, f i : ℝ) : K) = ∏ i ∈ s, (f i : K) 
goal: ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)

full_name: RCLike.ofReal_finsupp_prod
code: @[simp, rclike_simps, norm_cast]
theorem ofReal_finsupp_prod {α M : Type*} [Zero M] (f : α →₀ M) (g : α → M → ℝ) :
    ((f.prod fun a b => g a b : ℝ) : K) = f.prod fun a b => (g a b : K) 
goal: ↑(f.prod fun a b => g a b) = f.prod fun a b => ↑(g a b)

full_name: RCLike.real_smul_ofReal
code: @[simp, norm_cast, rclike_simps]
theorem real_smul_ofReal (r x : ℝ) : r • (x : K) = (r : K) * (x : K) 
goal: r • ↑x = ↑r * ↑x

full_name: RCLike.re_ofReal_mul
code: @[rclike_simps]
theorem re_ofReal_mul (r : ℝ) (z : K) : re (↑r * z) = r * re z 
goal: RCLike.re (↑r * z) = r * RCLike.re z

full_name: RCLike.im_ofReal_mul
code: @[rclike_simps]
theorem im_ofReal_mul (r : ℝ) (z : K) : im (↑r * z) = r * im z 
goal: RCLike.im (↑r * z) = r * RCLike.im z

full_name: RCLike.smul_re
code: @[rclike_simps]
theorem smul_re (r : ℝ) (z : K) : re (r • z) = r * re z 
goal: RCLike.re (r • z) = r * RCLike.re z

full_name: RCLike.smul_im
code: @[rclike_simps]
theorem smul_im (r : ℝ) (z : K) : im (r • z) = r * im z 
goal: RCLike.im (r • z) = r * RCLike.im z

full_name: RCLike.norm_ofReal
code: @[rclike_simps, norm_cast]
theorem norm_ofReal (r : ℝ) : ‖(r : K)‖ = |r| 
goal: ‖↑r‖ = |r|

full_name: RCLike.charZero_rclike
code: /-- ℝ and ℂ are both of characteristic zero.  -/
instance (priority := 100) charZero_rclike : CharZero K 
goal: CharZero K

full_name: RCLike.I_re
code: /-- The imaginary unit. -/
@[simp, rclike_simps]
theorem I_re : re (I : K) = 0 
goal: RCLike.re RCLike.I = 0

full_name: RCLike.I_im
code: @[simp, rclike_simps]
theorem I_im (z : K) : im z * im (I : K) = im z 
goal: RCLike.im z * RCLike.im RCLike.I = RCLike.im z

full_name: RCLike.I_im'
code: @[simp, rclike_simps]
theorem I_im' (z : K) : im (I : K) * im z = im z 
goal: RCLike.im RCLike.I * RCLike.im z = RCLike.im z

full_name: RCLike.I_mul_re
code: @[rclike_simps] -- porting note (#10618): was `simp`
theorem I_mul_re (z : K) : re (I * z) = -im z 
goal: RCLike.re (RCLike.I * z) = -RCLike.im z

full_name: RCLike.I_mul_I
code: theorem I_mul_I : (I : K) = 0 ∨ (I : K) * I = -1 
goal: RCLike.I = 0 ∨ RCLike.I * RCLike.I = -1

full_name: RCLike.I_eq_zero_or_im_I_eq_one
code: lemma I_eq_zero_or_im_I_eq_one : (I : K) = 0 ∨ im (I : K) = 1 
goal: RCLike.I = 0 ∨ RCLike.im RCLike.I = 1

full_name: RCLike.conj_re
code: @[simp, rclike_simps]
theorem conj_re (z : K) : re (conj z) = re z 
goal: RCLike.re ((starRingEnd K) z) = RCLike.re z

full_name: RCLike.conj_im
code: @[simp, rclike_simps]
theorem conj_im (z : K) : im (conj z) = -im z 
goal: RCLike.im ((starRingEnd K) z) = -RCLike.im z

full_name: RCLike.conj_I
code: @[simp, rclike_simps]
theorem conj_I : conj (I : K) = -I 
goal: (starRingEnd K) RCLike.I = -RCLike.I

full_name: RCLike.conj_ofReal
code: @[simp, rclike_simps]
theorem conj_ofReal (r : ℝ) : conj (r : K) = (r : K) 
goal: (starRingEnd K) ↑r = ↑r

full_name: RCLike.conj_nat_cast
code: theorem conj_nat_cast (n : ℕ) : conj (n : K) = n 
goal: (starRingEnd K) ↑n = ↑n

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

full_name: RCLike.conj_neg_I
code: @[rclike_simps] -- Porting note (#10618): was a `simp` but `simp` can prove it
theorem conj_neg_I : conj (-I) = (I : K) 
goal: (starRingEnd K) (-RCLike.I) = RCLike.I

full_name: RCLike.conj_eq_re_sub_im
code: theorem conj_eq_re_sub_im (z : K) : conj z = re z - im z * I 
goal: (starRingEnd K) z = ↑(RCLike.re z) - ↑(RCLike.im z) * RCLike.I

full_name: RCLike.sub_conj
code: theorem sub_conj (z : K) : z - conj z = 2 * im z * I 
goal: z - (starRingEnd K) z = 2 * ↑(RCLike.im z) * RCLike.I

full_name: RCLike.conj_smul
code: @[rclike_simps]
theorem conj_smul (r : ℝ) (z : K) : conj (r • z) = r • conj z 
goal: (starRingEnd K) (r • z) = r • (starRingEnd K) z

full_name: RCLike.add_conj
code: theorem add_conj (z : K) : z + conj z = 2 * re z 
goal: z + (starRingEnd K) z = 2 * ↑(RCLike.re z)

full_name: RCLike.re_eq_add_conj
code: theorem re_eq_add_conj (z : K) : ↑(re z) = (z + conj z) / 2 
goal: ↑(RCLike.re z) = (z + (starRingEnd K) z) / 2

full_name: RCLike.im_eq_conj_sub
code: theorem im_eq_conj_sub (z : K) : ↑(im z) = I * (conj z - z) / 2 
goal: ↑(RCLike.im z) = RCLike.I * ((starRingEnd K) z - z) / 2

full_name: RCLike.is_real_TFAE
code: /-- There are several equivalent ways to say that a number `z` is in fact a real number. -/
theorem is_real_TFAE (z : K) : TFAE [conj z = z, ∃ r : ℝ, (r : K) = z, ↑(re z) = z, im z = 0] 
goal: [(starRingEnd K) z = z, ∃ r, ↑r = z, ↑(RCLike.re z) = z, RCLike.im z = 0].TFAE

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

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

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

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

full_name: RCLike.conjToRingEquiv
code: /-- Conjugation as a ring equivalence. This is used to convert the inner product into a
sesquilinear product. -/
abbrev conjToRingEquiv : K ≃+* Kᵐᵒᵖ 
goal: K ≃+* Kᵐᵒᵖ

full_name: RCLike.normSq
code: /-- The norm squared function. -/
def normSq : K →*₀ ℝ 
goal: K →*₀ ℝ

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

full_name: RCLike.norm_sq_eq_def
code: theorem norm_sq_eq_def {z : K} : ‖z‖ ^ 2 = re z * re z + im z * im z 
goal: ‖z‖ ^ 2 = RCLike.re z * RCLike.re z + RCLike.im z * RCLike.im z

full_name: RCLike.normSq_eq_def'
code: theorem normSq_eq_def' (z : K) : normSq z = ‖z‖ ^ 2 
goal: RCLike.normSq z = ‖z‖ ^ 2

full_name: RCLike.normSq_zero
code: @[rclike_simps]
theorem normSq_zero : normSq (0 : K) = 0 
goal: RCLike.normSq 0 = 0

full_name: RCLike.normSq_one
code: @[rclike_simps]
theorem normSq_one : normSq (1 : K) = 1 
goal: RCLike.normSq 1 = 1

full_name: RCLike.normSq_nonneg
code: theorem normSq_nonneg (z : K) : 0 ≤ normSq z 
goal: 0 ≤ RCLike.normSq z

full_name: RCLike.normSq_eq_zero
code: @[rclike_simps] -- porting note (#10618): was `simp`
theorem normSq_eq_zero {z : K} : normSq z = 0 ↔ z = 0 
goal: RCLike.normSq z = 0 ↔ z = 0

full_name: RCLike.normSq_pos
code: @[simp, rclike_simps]
theorem normSq_pos {z : K} : 0 < normSq z ↔ z ≠ 0 
goal: 0 < RCLike.normSq z ↔ z ≠ 0

full_name: RCLike.normSq_neg
code: @[simp, rclike_simps]
theorem normSq_neg (z : K) : normSq (-z) = normSq z 
goal: RCLike.normSq (-z) = RCLike.normSq z

full_name: RCLike.normSq_conj
code: @[simp, rclike_simps]
theorem normSq_conj (z : K) : normSq (conj z) = normSq z 
goal: RCLike.normSq ((starRingEnd K) z) = RCLike.normSq z

full_name: RCLike.normSq_mul
code: @[rclike_simps] -- porting note (#10618): was `simp`
theorem normSq_mul (z w : K) : normSq (z * w) = normSq z * normSq w 
goal: RCLike.normSq (z * w) = RCLike.normSq z * RCLike.normSq w

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

full_name: RCLike.re_sq_le_normSq
code: theorem re_sq_le_normSq (z : K) : re z * re z ≤ normSq z 
goal: RCLike.re z * RCLike.re z ≤ RCLike.normSq z

full_name: RCLike.im_sq_le_normSq
code: theorem im_sq_le_normSq (z : K) : im z * im z ≤ normSq z 
goal: RCLike.im z * RCLike.im z ≤ RCLike.normSq z

full_name: RCLike.mul_conj
code: theorem mul_conj (z : K) : z * conj z = ‖z‖ ^ 2 
goal: z * (starRingEnd K) z = ↑‖z‖ ^ 2

full_name: RCLike.conj_mul
code: theorem conj_mul (z : K) : conj z * z = ‖z‖ ^ 2 
goal: (starRingEnd K) z * z = ↑‖z‖ ^ 2

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

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

full_name: RCLike.sqrt_normSq_eq_norm
code: theorem sqrt_normSq_eq_norm {z : K} : √(normSq z) = ‖z‖ 
goal: √(RCLike.normSq z) = ‖z‖

full_name: RCLike.ofReal_inv
code: @[rclike_simps, norm_cast]
theorem ofReal_inv (r : ℝ) : ((r⁻¹ : ℝ) : K) = (r : K)⁻¹ 
goal: ↑r⁻¹ = (↑r)⁻¹

full_name: RCLike.inv_def
code: theorem inv_def (z : K) : z⁻¹ = conj z * ((‖z‖ ^ 2)⁻¹ : ℝ) 
goal: z⁻¹ = (starRingEnd K) z * ↑(‖z‖ ^ 2)⁻¹

full_name: RCLike.inv_re
code: @[simp, rclike_simps]
theorem inv_re (z : K) : re z⁻¹ = re z / normSq z 
goal: RCLike.re z⁻¹ = RCLike.re z / RCLike.normSq z

full_name: RCLike.inv_im
code: @[simp, rclike_simps]
theorem inv_im (z : K) : im z⁻¹ = -im z / normSq z 
goal: RCLike.im z⁻¹ = -RCLike.im z / RCLike.normSq z

full_name: RCLike.div_re
code: theorem div_re (z w : K) : re (z / w) = re z * re w / normSq w + im z * im w / normSq w 
goal: RCLike.re (z / w) = RCLike.re z * RCLike.re w / RCLike.normSq w + RCLike.im z * RCLike.im w / RCLike.normSq w

full_name: RCLike.div_im
code: theorem div_im (z w : K) : im (z / w) = im z * re w / normSq w - re z * im w / normSq w 
goal: RCLike.im (z / w) = RCLike.im z * RCLike.re w / RCLike.normSq w - RCLike.re z * RCLike.im w / RCLike.normSq w

full_name: RCLike.conj_inv
code: @[rclike_simps] -- porting note (#10618): was `simp`
theorem conj_inv (x : K) : conj x⁻¹ = (conj x)⁻¹ 
goal: (starRingEnd K) x⁻¹ = ((starRingEnd K) x)⁻¹

full_name: RCLike.conj_div
code: lemma conj_div (x y : K) : conj (x / y) = conj x / conj y 
goal: (starRingEnd K) (x / y) = (starRingEnd K) x / (starRingEnd K) y

full_name: RCLike.exists_norm_eq_mul_self
code: lemma exists_norm_eq_mul_self (x : K) : ∃ c, ‖c‖ = 1 ∧ ↑‖x‖ = c * x 
goal: ∃ c, ‖c‖ = 1 ∧ ↑‖x‖ = c * x

full_name: RCLike.exists_norm_mul_eq_self
code: lemma exists_norm_mul_eq_self (x : K) : ∃ c, ‖c‖ = 1 ∧ c * ‖x‖ = x 
goal: ∃ c, ‖c‖ = 1 ∧ c * ↑‖x‖ = x

full_name: RCLike.ofReal_div
code: @[rclike_simps, norm_cast]
theorem ofReal_div (r s : ℝ) : ((r / s : ℝ) : K) = r / s 
goal: ↑(r / s) = ↑r / ↑s

full_name: RCLike.div_re_ofReal
code: theorem div_re_ofReal {z : K} {r : ℝ} : re (z / r) = re z / r 
goal: RCLike.re (z / ↑r) = RCLike.re z / r

full_name: RCLike.ofReal_zpow
code: @[rclike_simps, norm_cast]
theorem ofReal_zpow (r : ℝ) (n : ℤ) : ((r ^ n : ℝ) : K) = (r : K) ^ n 
goal: ↑(r ^ n) = ↑r ^ n

full_name: RCLike.I_mul_I_of_nonzero
code: theorem I_mul_I_of_nonzero : (I : K) ≠ 0 → (I : K) * I = -1 
goal: RCLike.I ≠ 0 → RCLike.I * RCLike.I = -1

full_name: RCLike.inv_I
code: @[simp, rclike_simps]
theorem inv_I : (I : K)⁻¹ = -I 
goal: RCLike.I⁻¹ = -RCLike.I

full_name: RCLike.div_I
code: @[simp, rclike_simps]
theorem div_I (z : K) : z / I = -(z * I) 
goal: z / RCLike.I = -(z * RCLike.I)

full_name: RCLike.normSq_inv
code: @[rclike_simps] -- porting note (#10618): was `simp`
theorem normSq_inv (z : K) : normSq z⁻¹ = (normSq z)⁻¹ 
goal: RCLike.normSq z⁻¹ = (RCLike.normSq z)⁻¹

full_name: RCLike.normSq_div
code: @[rclike_simps] -- porting note (#10618): was `simp`
theorem normSq_div (z w : K) : normSq (z / w) = normSq z / normSq w 
goal: RCLike.normSq (z / w) = RCLike.normSq z / RCLike.normSq w

full_name: RCLike.norm_conj
code: @[rclike_simps] -- porting note (#10618): was `simp`
theorem norm_conj {z : K} : ‖conj z‖ = ‖z‖ 
goal: ‖(starRingEnd K) z‖ = ‖z‖

full_name: RCLike.instCstarRing
code: instance (priority := 100) : CstarRing K 
goal: CstarRing K

full_name: RCLike.ofReal_natCast
code: @[rclike_simps, norm_cast]
theorem ofReal_natCast (n : ℕ) : ((n : ℝ) : K) = n 
goal: ↑↑n = ↑n

full_name: RCLike.natCast_re
code: @[simp, rclike_simps] -- Porting note: removed `norm_cast`
theorem natCast_re (n : ℕ) : re (n : K) = n 
goal: RCLike.re ↑n = ↑n

full_name: RCLike.natCast_im
code: @[simp, rclike_simps, norm_cast]
theorem natCast_im (n : ℕ) : im (n : K) = 0 
goal: RCLike.im ↑n = 0

full_name: RCLike.ofNat_re
code: @[simp, rclike_simps]
theorem ofNat_re (n : ℕ) [n.AtLeastTwo] : re (no_index (OfNat.ofNat n) : K) = OfNat.ofNat n 
goal: RCLike.re (OfNat.ofNat n) = OfNat.ofNat n

full_name: RCLike.ofNat_im
code: @[simp, rclike_simps]
theorem ofNat_im (n : ℕ) [n.AtLeastTwo] : im (no_index (OfNat.ofNat n) : K) = 0 
goal: RCLike.im (OfNat.ofNat n) = 0

full_name: RCLike.ofReal_ofNat
code: @[rclike_simps, norm_cast]
theorem ofReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n) : ℝ) : K) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: RCLike.ofNat_mul_re
code: theorem ofNat_mul_re (n : ℕ) [n.AtLeastTwo] (z : K) :
    re (OfNat.ofNat n * z) = OfNat.ofNat n * re z 
goal: RCLike.re (OfNat.ofNat n * z) = OfNat.ofNat n * RCLike.re z

full_name: RCLike.ofNat_mul_im
code: theorem ofNat_mul_im (n : ℕ) [n.AtLeastTwo] (z : K) :
    im (OfNat.ofNat n * z) = OfNat.ofNat n * im z 
goal: RCLike.im (OfNat.ofNat n * z) = OfNat.ofNat n * RCLike.im z

full_name: RCLike.ofReal_intCast
code: @[rclike_simps, norm_cast]
theorem ofReal_intCast (n : ℤ) : ((n : ℝ) : K) = n 
goal: ↑↑n = ↑n

full_name: RCLike.intCast_re
code: @[simp, rclike_simps] -- Porting note: removed `norm_cast`
theorem intCast_re (n : ℤ) : re (n : K) = n 
goal: RCLike.re ↑n = ↑n

full_name: RCLike.intCast_im
code: @[simp, rclike_simps, norm_cast]
theorem intCast_im (n : ℤ) : im (n : K) = 0 
goal: RCLike.im ↑n = 0

full_name: RCLike.ofReal_ratCast
code: @[rclike_simps, norm_cast]
theorem ofReal_ratCast (n : ℚ) : ((n : ℝ) : K) = n 
goal: ↑↑n = ↑n

full_name: RCLike.ratCast_re
code: @[simp, rclike_simps] -- Porting note: removed `norm_cast`
theorem ratCast_re (q : ℚ) : re (q : K) = q 
goal: RCLike.re ↑q = ↑q

full_name: RCLike.ratCast_im
code: @[simp, rclike_simps, norm_cast]
theorem ratCast_im (q : ℚ) : im (q : K) = 0 
goal: RCLike.im ↑q = 0

full_name: RCLike.norm_of_nonneg
code: theorem norm_of_nonneg {r : ℝ} (h : 0 ≤ r) : ‖(r : K)‖ = r 
goal: ‖↑r‖ = r

full_name: RCLike.norm_natCast
code: @[simp, rclike_simps, norm_cast]
theorem norm_natCast (n : ℕ) : ‖(n : K)‖ = n 
goal: ‖↑n‖ = ↑n

full_name: RCLike.norm_ofNat
code: @[simp, rclike_simps]
theorem norm_ofNat (n : ℕ) [n.AtLeastTwo] : ‖(no_index (OfNat.ofNat n) : K)‖ = OfNat.ofNat n 
goal: ‖OfNat.ofNat n‖ = OfNat.ofNat n

full_name: RCLike.norm_nsmul
code: lemma norm_nsmul [NormedAddCommGroup E] [NormedSpace K E] (n : ℕ) (x : E) : ‖n • x‖ = n • ‖x‖ 
goal: ‖n • x‖ = n • ‖x‖

full_name: RCLike.mul_self_norm
code: theorem mul_self_norm (z : K) : ‖z‖ * ‖z‖ = normSq z 
goal: ‖z‖ * ‖z‖ = RCLike.normSq z

full_name: RCLike.norm_two
code: theorem norm_two : ‖(2 : K)‖ = 2 
goal: ‖2‖ = 2

full_name: RCLike.abs_re_le_norm
code: theorem abs_re_le_norm (z : K) : |re z| ≤ ‖z‖ 
goal: |RCLike.re z| ≤ ‖z‖

full_name: RCLike.abs_im_le_norm
code: theorem abs_im_le_norm (z : K) : |im z| ≤ ‖z‖ 
goal: |RCLike.im z| ≤ ‖z‖

full_name: RCLike.norm_re_le_norm
code: theorem norm_re_le_norm (z : K) : ‖re z‖ ≤ ‖z‖ 
goal: ‖RCLike.re z‖ ≤ ‖z‖

full_name: RCLike.norm_im_le_norm
code: theorem norm_im_le_norm (z : K) : ‖im z‖ ≤ ‖z‖ 
goal: ‖RCLike.im z‖ ≤ ‖z‖

full_name: RCLike.re_le_norm
code: theorem re_le_norm (z : K) : re z ≤ ‖z‖ 
goal: RCLike.re z ≤ ‖z‖

full_name: RCLike.im_le_norm
code: theorem im_le_norm (z : K) : im z ≤ ‖z‖ 
goal: RCLike.im z ≤ ‖z‖

full_name: RCLike.im_eq_zero_of_le
code: theorem im_eq_zero_of_le {a : K} (h : ‖a‖ ≤ re a) : im a = 0 
goal: RCLike.im a = 0

full_name: RCLike.re_eq_self_of_le
code: theorem re_eq_self_of_le {a : K} (h : ‖a‖ ≤ re a) : (re a : K) = a 
goal: ↑(RCLike.re a) = a

full_name: RCLike.abs_re_div_norm_le_one
code: theorem abs_re_div_norm_le_one (z : K) : |re z / ‖z‖| ≤ 1 
goal: |RCLike.re z / ‖z‖| ≤ 1

full_name: RCLike.abs_im_div_norm_le_one
code: theorem abs_im_div_norm_le_one (z : K) : |im z / ‖z‖| ≤ 1 
goal: |RCLike.im z / ‖z‖| ≤ 1

full_name: RCLike.norm_I_of_ne_zero
code: theorem norm_I_of_ne_zero (hI : (I : K) ≠ 0) : ‖(I : K)‖ = 1 
goal: ‖RCLike.I‖ = 1

full_name: RCLike.re_eq_norm_of_mul_conj
code: theorem re_eq_norm_of_mul_conj (x : K) : re (x * conj x) = ‖x * conj x‖ 
goal: RCLike.re (x * (starRingEnd K) x) = ‖x * (starRingEnd K) x‖

full_name: RCLike.norm_sq_re_add_conj
code: theorem norm_sq_re_add_conj (x : K) : ‖x + conj x‖ ^ 2 = re (x + conj x) ^ 2 
goal: ‖x + (starRingEnd K) x‖ ^ 2 = RCLike.re (x + (starRingEnd K) x) ^ 2

full_name: RCLike.norm_sq_re_conj_add
code: theorem norm_sq_re_conj_add (x : K) : ‖conj x + x‖ ^ 2 = re (conj x + x) ^ 2 
goal: ‖(starRingEnd K) x + x‖ ^ 2 = RCLike.re ((starRingEnd K) x + x) ^ 2

full_name: RCLike.isCauSeq_re
code: theorem isCauSeq_re (f : CauSeq K norm) : IsCauSeq abs fun n => re (f n) 
goal: IsCauSeq abs fun n => RCLike.re (↑f n)

full_name: RCLike.isCauSeq_im
code: theorem isCauSeq_im (f : CauSeq K norm) : IsCauSeq abs fun n => im (f n) 
goal: IsCauSeq abs fun n => RCLike.im (↑f n)

full_name: RCLike.cauSeqRe
code: /-- The real part of a K Cauchy sequence, as a real Cauchy sequence. -/
noncomputable def cauSeqRe (f : CauSeq K norm) : CauSeq ℝ abs 
goal: CauSeq ℝ abs

full_name: RCLike.cauSeqIm
code: /-- The imaginary part of a K Cauchy sequence, as a real Cauchy sequence. -/
noncomputable def cauSeqIm (f : CauSeq K norm) : CauSeq ℝ abs 
goal: CauSeq ℝ abs

full_name: RCLike.isCauSeq_norm
code: theorem isCauSeq_norm {f : ℕ → K} (hf : IsCauSeq norm f) : IsCauSeq abs (norm ∘ f) 
goal: IsCauSeq abs (norm ∘ f)

full_name: Real.RCLike
code: noncomputable instance Real.RCLike : RCLike ℝ 
goal: RCLike ℝ

full_name: RCLike.lt_iff_re_im
code: theorem lt_iff_re_im : z < w ↔ re z < re w ∧ im z = im w 
goal: z < w ↔ RCLike.re z < RCLike.re w ∧ RCLike.im z = RCLike.im w

full_name: RCLike.nonneg_iff
code: theorem nonneg_iff : 0 ≤ z ↔ 0 ≤ re z ∧ im z = 0 
goal: 0 ≤ z ↔ 0 ≤ RCLike.re z ∧ RCLike.im z = 0

full_name: RCLike.pos_iff
code: theorem pos_iff : 0 < z ↔ 0 < re z ∧ im z = 0 
goal: 0 < z ↔ 0 < RCLike.re z ∧ RCLike.im z = 0

full_name: RCLike.nonpos_iff
code: theorem nonpos_iff : z ≤ 0 ↔ re z ≤ 0 ∧ im z = 0 
goal: z ≤ 0 ↔ RCLike.re z ≤ 0 ∧ RCLike.im z = 0

full_name: RCLike.neg_iff
code: theorem neg_iff : z < 0 ↔ re z < 0 ∧ im z = 0 
goal: z < 0 ↔ RCLike.re z < 0 ∧ RCLike.im z = 0

full_name: RCLike.nonneg_iff_exists_ofReal
code: lemma nonneg_iff_exists_ofReal : 0 ≤ z ↔ ∃ x ≥ (0 : ℝ), x = z 
goal: 0 ≤ z ↔ ∃ x ≥ 0, ↑x = z

full_name: RCLike.pos_iff_exists_ofReal
code: lemma pos_iff_exists_ofReal : 0 < z ↔ ∃ x > (0 : ℝ), x = z 
goal: 0 < z ↔ ∃ x > 0, ↑x = z

full_name: RCLike.nonpos_iff_exists_ofReal
code: lemma nonpos_iff_exists_ofReal : z ≤ 0 ↔ ∃ x ≤ (0 : ℝ), x = z 
goal: z ≤ 0 ↔ ∃ x ≤ 0, ↑x = z

full_name: RCLike.neg_iff_exists_ofReal
code: lemma neg_iff_exists_ofReal : z < 0 ↔ ∃ x < (0 : ℝ), x = z 
goal: z < 0 ↔ ∃ x < 0, ↑x = z

full_name: RCLike.ofReal_le_ofReal
code: @[simp, norm_cast]
lemma ofReal_le_ofReal {x y : ℝ} : (x : K) ≤ (y : K) ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: RCLike.ofReal_lt_ofReal
code: @[simp, norm_cast]
lemma ofReal_lt_ofReal {x y : ℝ} : (x : K) < (y : K) ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: RCLike.ofReal_nonneg
code: @[simp, norm_cast]
lemma ofReal_nonneg {x : ℝ} : 0 ≤ (x : K) ↔ 0 ≤ x 
goal: 0 ≤ ↑x ↔ 0 ≤ x

full_name: RCLike.ofReal_nonpos
code: @[simp, norm_cast]
lemma ofReal_nonpos {x : ℝ} : (x : K) ≤ 0 ↔ x ≤ 0 
goal: ↑x ≤ 0 ↔ x ≤ 0

full_name: RCLike.ofReal_pos
code: @[simp, norm_cast]
lemma ofReal_pos {x : ℝ} : 0 < (x : K) ↔ 0 < x 
goal: 0 < ↑x ↔ 0 < x

full_name: RCLike.ofReal_lt_zero
code: @[simp, norm_cast]
lemma ofReal_lt_zero {x : ℝ} : (x : K) < 0 ↔ x < 0 
goal: ↑x < 0 ↔ x < 0

full_name: RCLike.inv_pos_of_pos
code: protected lemma inv_pos_of_pos (hz : 0 < z) : 0 < z⁻¹ 
goal: 0 < z⁻¹

full_name: RCLike.inv_pos
code: protected lemma inv_pos : 0 < z⁻¹ ↔ 0 < z 
goal: 0 < z⁻¹ ↔ 0 < z

full_name: RCLike.toStarOrderedRing
code: /-- With `z ≤ w` iff `w - z` is real and nonnegative, `ℝ` and `ℂ` are star ordered rings.
(That is, a star ring in which the nonnegative elements are those of the form `star z * z`.)

Note this is only an instance with `open scoped ComplexOrder`. -/
lemma toStarOrderedRing : StarOrderedRing K 
goal: StarOrderedRing K

full_name: RCLike.toStrictOrderedCommRing
code: /-- With `z ≤ w` iff `w - z` is real and nonnegative, `ℝ` and `ℂ` are strictly ordered rings.

Note this is only an instance with `open scoped ComplexOrder`. -/
def toStrictOrderedCommRing : StrictOrderedCommRing K 
goal: StrictOrderedCommRing K

full_name: RCLike.toOrderedSMul
code: theorem toOrderedSMul : OrderedSMul ℝ K 
goal: OrderedSMul ℝ K

full_name: StarModule.instOrderedSMul
code: /-- A star algebra over `K` has a scalar multiplication that respects the order.  -/
lemma _root_.StarModule.instOrderedSMul {A : Type*} [NonUnitalRing A] [StarRing A] [PartialOrder A]
    [StarOrderedRing A] [Module K A] [StarModule K A] [IsScalarTower K A A] [SMulCommClass K A A] :
    OrderedSMul K A 
goal: OrderedSMul K A

full_name: RCLike._aux_Mathlib_Analysis_RCLike_Basic___macroRules_RCLike_termReR_1
code: local notation "reR" => @RCLike.re ℝ _
goal: Lean.Macro

full_name: RCLike._aux_Mathlib_Analysis_RCLike_Basic___macroRules_RCLike_termImR_1
code: local notation "imR" => @RCLike.im ℝ _
goal: Lean.Macro

full_name: RCLike._aux_Mathlib_Analysis_RCLike_Basic___macroRules_RCLike_termIR_1
code: local notation "IR" => @RCLike.I ℝ _
goal: Lean.Macro

full_name: RCLike._aux_Mathlib_Analysis_RCLike_Basic___macroRules_RCLike_termNormSqR_1
code: local notation "normSqR" => @RCLike.normSq ℝ _
goal: Lean.Macro

full_name: RCLike.re_to_real
code: @[simp, rclike_simps]
theorem re_to_real {x : ℝ} : reR x = x 
goal: RCLike.re x = x

full_name: RCLike.im_to_real
code: @[simp, rclike_simps]
theorem im_to_real {x : ℝ} : imR x = 0 
goal: RCLike.im x = 0

full_name: RCLike.conj_to_real
code: @[rclike_simps]
theorem conj_to_real {x : ℝ} : conj x = x 
goal: (starRingEnd ℝ) x = x

full_name: RCLike.I_to_real
code: @[simp, rclike_simps]
theorem I_to_real : IR = 0 
goal: RCLike.I = 0

full_name: RCLike.normSq_to_real
code: @[simp, rclike_simps]
theorem normSq_to_real {x : ℝ} : normSq x = x * x 
goal: RCLike.normSq x = x * x

full_name: RCLike.ofReal_real_eq_id
code: @[simp]
theorem ofReal_real_eq_id : @ofReal ℝ _ = id 
goal: RCLike.ofReal = id

full_name: RCLike.reLm
code: /-- The real part in an `RCLike` field, as a linear map. -/
def reLm : K →ₗ[ℝ] ℝ 
goal: K →ₗ[ℝ] ℝ

full_name: RCLike.reLm_coe
code: @[simp, rclike_simps]
theorem reLm_coe : (reLm : K → ℝ) = re 
goal: ⇑RCLike.reLm = ⇑RCLike.re

full_name: RCLike.reCLM
code: /-- The real part in an `RCLike` field, as a continuous linear map. -/
noncomputable def reCLM : K →L[ℝ] ℝ 
goal: K →L[ℝ] ℝ

full_name: RCLike.reCLM_coe
code: @[simp, rclike_simps, norm_cast]
theorem reCLM_coe : ((reCLM : K →L[ℝ] ℝ) : K →ₗ[ℝ] ℝ) = reLm 
goal: ↑RCLike.reCLM = RCLike.reLm

full_name: RCLike.reCLM_apply
code: @[simp, rclike_simps]
theorem reCLM_apply : ((reCLM : K →L[ℝ] ℝ) : K → ℝ) = re 
goal: ⇑RCLike.reCLM = ⇑RCLike.re

full_name: RCLike.continuous_re
code: @[continuity, fun_prop]
theorem continuous_re : Continuous (re : K → ℝ) 
goal: Continuous ⇑RCLike.re

full_name: RCLike.imLm
code: /-- The imaginary part in an `RCLike` field, as a linear map. -/
def imLm : K →ₗ[ℝ] ℝ 
goal: K →ₗ[ℝ] ℝ

full_name: RCLike.imLm_coe
code: @[simp, rclike_simps]
theorem imLm_coe : (imLm : K → ℝ) = im 
goal: ⇑RCLike.imLm = ⇑RCLike.im

full_name: RCLike.imCLM
code: /-- The imaginary part in an `RCLike` field, as a continuous linear map. -/
noncomputable def imCLM : K →L[ℝ] ℝ 
goal: K →L[ℝ] ℝ

full_name: RCLike.imCLM_coe
code: @[simp, rclike_simps, norm_cast]
theorem imCLM_coe : ((imCLM : K →L[ℝ] ℝ) : K →ₗ[ℝ] ℝ) = imLm 
goal: ↑RCLike.imCLM = RCLike.imLm

full_name: RCLike.imCLM_apply
code: @[simp, rclike_simps]
theorem imCLM_apply : ((imCLM : K →L[ℝ] ℝ) : K → ℝ) = im 
goal: ⇑RCLike.imCLM = ⇑RCLike.im

full_name: RCLike.continuous_im
code: @[continuity, fun_prop]
theorem continuous_im : Continuous (im : K → ℝ) 
goal: Continuous ⇑RCLike.im

full_name: RCLike.conjAe
code: /-- Conjugate as an `ℝ`-algebra equivalence -/
def conjAe : K ≃ₐ[ℝ] K 
goal: K ≃ₐ[ℝ] K

full_name: RCLike.conjAe_coe
code: @[simp, rclike_simps]
theorem conjAe_coe : (conjAe : K → K) = conj 
goal: ⇑RCLike.conjAe = ⇑(starRingEnd K)

full_name: RCLike.conjLIE
code: /-- Conjugate as a linear isometry -/
noncomputable def conjLIE : K ≃ₗᵢ[ℝ] K 
goal: K ≃ₗᵢ[ℝ] K

full_name: RCLike.conjLIE_apply
code: @[simp, rclike_simps]
theorem conjLIE_apply : (conjLIE : K → K) = conj 
goal: ⇑RCLike.conjLIE = ⇑(starRingEnd K)

full_name: RCLike.conjCLE
code: /-- Conjugate as a continuous linear equivalence -/
noncomputable def conjCLE : K ≃L[ℝ] K 
goal: K ≃L[ℝ] K

full_name: RCLike.conjCLE_coe
code: @[simp, rclike_simps]
theorem conjCLE_coe : (@conjCLE K _).toLinearEquiv = conjAe.toLinearEquiv 
goal: RCLike.conjCLE.toLinearEquiv = RCLike.conjAe.toLinearEquiv

full_name: RCLike.conjCLE_apply
code: @[simp, rclike_simps]
theorem conjCLE_apply : (conjCLE : K → K) = conj 
goal: ⇑RCLike.conjCLE = ⇑(starRingEnd K)

full_name: RCLike.instContinuousStar
code: instance (priority := 100) : ContinuousStar K 
goal: ContinuousStar K

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

full_name: RCLike.ofRealAm
code: /-- The `ℝ → K` coercion, as a linear map -/
noncomputable def ofRealAm : ℝ →ₐ[ℝ] K 
goal: ℝ →ₐ[ℝ] K

full_name: RCLike.ofRealAm_coe
code: @[simp, rclike_simps]
theorem ofRealAm_coe : (ofRealAm : ℝ → K) = ofReal 
goal: ⇑RCLike.ofRealAm = RCLike.ofReal

full_name: RCLike.ofRealLI
code: /-- The ℝ → K coercion, as a linear isometry -/
noncomputable def ofRealLI : ℝ →ₗᵢ[ℝ] K 
goal: ℝ →ₗᵢ[ℝ] K

full_name: RCLike.ofRealLI_apply
code: @[simp, rclike_simps]
theorem ofRealLI_apply : (ofRealLI : ℝ → K) = ofReal 
goal: ⇑RCLike.ofRealLI = RCLike.ofReal

full_name: RCLike.ofRealCLM
code: /-- The `ℝ → K` coercion, as a continuous linear map -/
noncomputable def ofRealCLM : ℝ →L[ℝ] K 
goal: ℝ →L[ℝ] K

full_name: RCLike.ofRealCLM_coe
code: @[simp, rclike_simps]
theorem ofRealCLM_coe : (@ofRealCLM K _ : ℝ →ₗ[ℝ] K) = ofRealAm.toLinearMap 
goal: ↑RCLike.ofRealCLM = RCLike.ofRealAm.toLinearMap

full_name: RCLike.ofRealCLM_apply
code: @[simp, rclike_simps]
theorem ofRealCLM_apply : (ofRealCLM : ℝ → K) = ofReal 
goal: ⇑RCLike.ofRealCLM = RCLike.ofReal

full_name: RCLike.continuous_ofReal
code: @[continuity, fun_prop]
theorem continuous_ofReal : Continuous (ofReal : ℝ → K) 
goal: Continuous RCLike.ofReal

full_name: RCLike.continuous_normSq
code: @[continuity]
theorem continuous_normSq : Continuous (normSq : K → ℝ) 
goal: Continuous ⇑RCLike.normSq

full_name: RCLike.im_eq_zero
code: lemma im_eq_zero (h : I = (0 : K)) (z : K) : im z = 0 
goal: RCLike.im z = 0

full_name: RCLike.realRingEquiv
code: /-- The natural isomorphism between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when `RCLike.I = 0`. -/
@[simps]
def realRingEquiv (h : I = (0 : K)) : K ≃+* ℝ 
goal: K ≃+* ℝ

full_name: RCLike.realRingEquiv_symm_apply
code: /-- The natural isomorphism between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when `RCLike.I = 0`. -/
@[simps]
def realRingEquiv (h : I = (0 : K)) : K ≃+* ℝ 
goal: ∀ (a : ℝ), (RCLike.realRingEquiv h).symm a = ↑a

full_name: RCLike.realRingEquiv_apply
code: /-- The natural isomorphism between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when `RCLike.I = 0`. -/
@[simps]
def realRingEquiv (h : I = (0 : K)) : K ≃+* ℝ 
goal: (RCLike.realRingEquiv h) a = RCLike.re a

full_name: RCLike.realLinearIsometryEquiv_apply
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when
`RCLike.I = 0`. -/
@[simps]
noncomputable def realLinearIsometryEquiv (h : I = (0 : K)) : K ≃ₗᵢ[ℝ] ℝ 
goal: ∀ (a : K), (RCLike.realLinearIsometryEquiv h) a = (RCLike.realRingEquiv h).toFun a

full_name: RCLike.realLinearIsometryEquiv
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when
`RCLike.I = 0`. -/
@[simps]
noncomputable def realLinearIsometryEquiv (h : I = (0 : K)) : K ≃ₗᵢ[ℝ] ℝ 
goal: K ≃ₗᵢ[ℝ] ℝ

full_name: RCLike.realLinearIsometryEquiv_toFun
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when
`RCLike.I = 0`. -/
@[simps]
noncomputable def realLinearIsometryEquiv (h : I = (0 : K)) : K ≃ₗᵢ[ℝ] ℝ 
goal: ∀ (a : K), (RCLike.realLinearIsometryEquiv h) a = (RCLike.realRingEquiv h).toFun a

full_name: RCLike.realLinearIsometryEquiv_invFun
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when
`RCLike.I = 0`. -/
@[simps]
noncomputable def realLinearIsometryEquiv (h : I = (0 : K)) : K ≃ₗᵢ[ℝ] ℝ 
goal: ∀ (a : ℝ), (RCLike.realLinearIsometryEquiv h).invFun a = (RCLike.realRingEquiv h).invFun a

full_name: RCLike.realLinearIsometryEquiv_symm_apply
code: /-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when
`RCLike.I = 0`. -/
@[simps]
noncomputable def realLinearIsometryEquiv (h : I = (0 : K)) : K ≃ₗᵢ[ℝ] ℝ 
goal: ∀ (a : ℝ), (RCLike.realLinearIsometryEquiv h).symm a = (RCLike.realRingEquiv h).invFun a