File: Mathlib/Analysis/Complex/Isometry.lean

full_name: «_aux_Mathlib_Analysis_Complex_Isometry___macroRules_term|_|_1»
code: local notation "|" x "|" => Complex.abs x
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Complex_Isometry___unexpand_Complex_abs_1
code: local notation "|" x "|" => Complex.abs x
goal: Lean.PrettyPrinter.Unexpander

full_name: rotation
code: /-- An element of the unit circle defines a `LinearIsometryEquiv` from `ℂ` to itself, by
rotation. -/
def rotation : circle →* ℂ ≃ₗᵢ[ℝ] ℂ 
goal: ↥circle →* ℂ ≃ₗᵢ[ℝ] ℂ

full_name: rotation_apply
code: @[simp]
theorem rotation_apply (a : circle) (z : ℂ) : rotation a z = a * z 
goal: (rotation a) z = ↑a * z

full_name: rotation_symm
code: @[simp]
theorem rotation_symm (a : circle) : (rotation a).symm = rotation a⁻¹ 
goal: (rotation a).symm = rotation a⁻¹

full_name: rotation_trans
code: @[simp]
theorem rotation_trans (a b : circle) : (rotation a).trans (rotation b) = rotation (b * a) 
goal: (rotation a).trans (rotation b) = rotation (b * a)

full_name: rotation_ne_conjLIE
code: theorem rotation_ne_conjLIE (a : circle) : rotation a ≠ conjLIE 
goal: rotation a ≠ Complex.conjLIE

full_name: rotationOf
code: /-- Takes an element of `ℂ ≃ₗᵢ[ℝ] ℂ` and checks if it is a rotation, returns an element of the
unit circle. -/
@[simps]
def rotationOf (e : ℂ ≃ₗᵢ[ℝ] ℂ) : circle 
goal: ↥circle

full_name: rotationOf_coe
code: /-- Takes an element of `ℂ ≃ₗᵢ[ℝ] ℂ` and checks if it is a rotation, returns an element of the
unit circle. -/
@[simps]
def rotationOf (e : ℂ ≃ₗᵢ[ℝ] ℂ) : circle 
goal: ↑(rotationOf e) = e 1 / ↑(Complex.abs (e 1))

full_name: rotationOf_rotation
code: @[simp]
theorem rotationOf_rotation (a : circle) : rotationOf (rotation a) = a 
goal: rotationOf (rotation a) = a

full_name: rotation_injective
code: theorem rotation_injective : Function.Injective rotation 
goal: Function.Injective ⇑rotation

full_name: LinearIsometry.re_apply_eq_re_of_add_conj_eq
code: theorem LinearIsometry.re_apply_eq_re_of_add_conj_eq (f : ℂ →ₗᵢ[ℝ] ℂ)
    (h₃ : ∀ z, z + conj z = f z + conj (f z)) (z : ℂ) : (f z).re = z.re 
goal: (f z).re = z.re

full_name: LinearIsometry.im_apply_eq_im_or_neg_of_re_apply_eq_re
code: theorem LinearIsometry.im_apply_eq_im_or_neg_of_re_apply_eq_re {f : ℂ →ₗᵢ[ℝ] ℂ}
    (h₂ : ∀ z, (f z).re = z.re) (z : ℂ) : (f z).im = z.im ∨ (f z).im = -z.im 
goal: (f z).im = z.im ∨ (f z).im = -z.im

full_name: LinearIsometry.im_apply_eq_im
code: theorem LinearIsometry.im_apply_eq_im {f : ℂ →ₗᵢ[ℝ] ℂ} (h : f 1 = 1) (z : ℂ) :
    z + conj z = f z + conj (f z) 
goal: z + (starRingEnd ℂ) z = f z + (starRingEnd ℂ) (f z)

full_name: LinearIsometry.re_apply_eq_re
code: theorem LinearIsometry.re_apply_eq_re {f : ℂ →ₗᵢ[ℝ] ℂ} (h : f 1 = 1) (z : ℂ) : (f z).re = z.re 
goal: (f z).re = z.re

full_name: linear_isometry_complex_aux
code: theorem linear_isometry_complex_aux {f : ℂ ≃ₗᵢ[ℝ] ℂ} (h : f 1 = 1) :
    f = LinearIsometryEquiv.refl ℝ ℂ ∨ f = conjLIE 
goal: f = LinearIsometryEquiv.refl ℝ ℂ ∨ f = Complex.conjLIE

full_name: linear_isometry_complex
code: theorem linear_isometry_complex (f : ℂ ≃ₗᵢ[ℝ] ℂ) :
    ∃ a : circle, f = rotation a ∨ f = conjLIE.trans (rotation a) 
goal: ∃ a, f = rotation a ∨ f = Complex.conjLIE.trans (rotation a)

full_name: toMatrix_rotation
code: /-- The matrix representation of `rotation a` is equal to the conformal matrix
`!![re a, -im a; im a, re a]`. -/
theorem toMatrix_rotation (a : circle) :
    LinearMap.toMatrix basisOneI basisOneI (rotation a).toLinearEquiv =
      Matrix.planeConformalMatrix (re a) (im a) (by simp [pow_two, ← normSq_apply]) 
goal: (LinearMap.toMatrix Complex.basisOneI Complex.basisOneI) ↑(rotation a).toLinearEquiv =
  ↑(Matrix.planeConformalMatrix (↑a).re (↑a).im ⋯)

full_name: det_rotation
code: /-- The determinant of `rotation` (as a linear map) is equal to `1`. -/
@[simp]
theorem det_rotation (a : circle) : LinearMap.det ((rotation a).toLinearEquiv : ℂ →ₗ[ℝ] ℂ) = 1 
goal: LinearMap.det ↑(rotation a).toLinearEquiv = 1

full_name: linearEquiv_det_rotation
code: /-- The determinant of `rotation` (as a linear equiv) is equal to `1`. -/
@[simp]
theorem linearEquiv_det_rotation (a : circle) : LinearEquiv.det (rotation a).toLinearEquiv = 1 
goal: LinearEquiv.det (rotation a).toLinearEquiv = 1