File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

full_name: FiniteDimensional.of_fact_finrank_eq_two
code: lemma FiniteDimensional.of_fact_finrank_eq_two {K V : Type*} [DivisionRing K]
    [AddCommGroup V] [Module K V] [Fact (finrank K V = 2)] : FiniteDimensional K V 
goal: FiniteDimensional K V

full_name: Orientation.areaForm
code: /-- An antisymmetric bilinear form on an oriented real inner product space of dimension 2 (usual
notation `ω`). When evaluated on two vectors, it gives the oriented area of the parallelogram they
span. -/
irreducible_def areaForm : E →ₗ[ℝ] E →ₗ[ℝ] ℝ 
goal: E →ₗ[ℝ] E →ₗ[ℝ] ℝ

full_name: Orientation.definition._@.Mathlib.Analysis.InnerProductSpace.TwoDim._hyg.84
code: /-- An antisymmetric bilinear form on an oriented real inner product space of dimension 2 (usual
notation `ω`). When evaluated on two vectors, it gives the oriented area of the parallelogram they
span. -/
irreducible_def areaForm : E →ₗ[ℝ] E →ₗ[ℝ] ℝ 
goal: E →ₗ[ℝ] E →ₗ[ℝ] ℝ

full_name: Orientation.wrapped._@.Mathlib.Analysis.InnerProductSpace.TwoDim._hyg.84
code: /-- An antisymmetric bilinear form on an oriented real inner product space of dimension 2 (usual
notation `ω`). When evaluated on two vectors, it gives the oriented area of the parallelogram they
span. -/
irreducible_def areaForm : E →ₗ[ℝ] E →ₗ[ℝ] ℝ 
goal: Subtype (Eq @Orientation.definition✝)

full_name: Orientation.areaForm_def
code: /-- An antisymmetric bilinear form on an oriented real inner product space of dimension 2 (usual
notation `ω`). When evaluated on two vectors, it gives the oriented area of the parallelogram they
span. -/
irreducible_def areaForm : E →ₗ[ℝ] E →ₗ[ℝ] ℝ 
goal: o.areaForm =
  let z := AlternatingMap.constLinearEquivOfIsEmpty.symm;
  let y := (LinearMap.llcomp ℝ E (E [⋀^Fin 0]→ₗ[ℝ] ℝ) ℝ) ↑z ∘ₗ AlternatingMap.curryLeftLinearMap;
  y ∘ₗ AlternatingMap.curryLeftLinearMap o.volumeForm

full_name: Orientation._aux_Mathlib_Analysis_InnerProductSpace_TwoDim___macroRules_Orientation_termω_1
code: local notation "ω" => o.areaForm
goal: Lean.Macro

full_name: Orientation.areaForm_to_volumeForm
code: theorem areaForm_to_volumeForm (x y : E) : ω x y = o.volumeForm ![x, y] 
goal: (o.areaForm x) y = o.volumeForm ![x, y]

full_name: Orientation.areaForm_apply_self
code: @[simp]
theorem areaForm_apply_self (x : E) : ω x x = 0 
goal: (o.areaForm x) x = 0

full_name: Orientation.areaForm_swap
code: theorem areaForm_swap (x y : E) : ω x y = -ω y x 
goal: (o.areaForm x) y = -(o.areaForm y) x

full_name: Orientation.areaForm_neg_orientation
code: @[simp]
theorem areaForm_neg_orientation : (-o).areaForm = -o.areaForm 
goal: (-o).areaForm = -o.areaForm

full_name: Orientation.areaForm'
code: /-- Continuous linear map version of `Orientation.areaForm`, useful for calculus. -/
def areaForm' : E →L[ℝ] E →L[ℝ] ℝ 
goal: E →L[ℝ] E →L[ℝ] ℝ

full_name: Orientation.areaForm'_apply
code: @[simp]
theorem areaForm'_apply (x : E) :
    o.areaForm' x = LinearMap.toContinuousLinearMap (o.areaForm x) 
goal: o.areaForm' x = LinearMap.toContinuousLinearMap (o.areaForm x)

full_name: Orientation.abs_areaForm_le
code: theorem abs_areaForm_le (x y : E) : |ω x y| ≤ ‖x‖ * ‖y‖ 
goal: |(o.areaForm x) y| ≤ ‖x‖ * ‖y‖

full_name: Orientation.areaForm_le
code: theorem areaForm_le (x y : E) : ω x y ≤ ‖x‖ * ‖y‖ 
goal: (o.areaForm x) y ≤ ‖x‖ * ‖y‖

full_name: Orientation.abs_areaForm_of_orthogonal
code: theorem abs_areaForm_of_orthogonal {x y : E} (h : ⟪x, y⟫ = 0) : |ω x y| = ‖x‖ * ‖y‖ 
goal: |(o.areaForm x) y| = ‖x‖ * ‖y‖

full_name: Orientation.areaForm_map
code: theorem areaForm_map {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
    [hF : Fact (finrank ℝ F = 2)] (φ : E ≃ₗᵢ[ℝ] F) (x y : F) :
    (Orientation.map (Fin 2) φ.toLinearEquiv o).areaForm x y =
    o.areaForm (φ.symm x) (φ.symm y) 
goal: (((Orientation.map (Fin 2) φ.toLinearEquiv) o).areaForm x) y = (o.areaForm (φ.symm x)) (φ.symm y)

full_name: Orientation.areaForm_comp_linearIsometryEquiv
code: /-- The area form is invariant under pullback by a positively-oriented isometric automorphism. -/
theorem areaForm_comp_linearIsometryEquiv (φ : E ≃ₗᵢ[ℝ] E)
    (hφ : 0 < LinearMap.det (φ.toLinearEquiv : E →ₗ[ℝ] E)) (x y : E) :
    o.areaForm (φ x) (φ y) = o.areaForm x y 
goal: (o.areaForm (φ x)) (φ y) = (o.areaForm x) y

full_name: Orientation.wrapped._@.Mathlib.Analysis.InnerProductSpace.TwoDim._hyg.2394
code: /-- Auxiliary construction for `Orientation.rightAngleRotation`, rotation by 90 degrees in an
oriented real inner product space of dimension 2. -/
irreducible_def rightAngleRotationAux₁ : E →ₗ[ℝ] E 
goal: Subtype (Eq @Orientation.definition✝)

full_name: Orientation.rightAngleRotationAux₁_def
code: /-- Auxiliary construction for `Orientation.rightAngleRotation`, rotation by 90 degrees in an
oriented real inner product space of dimension 2. -/
irreducible_def rightAngleRotationAux₁ : E →ₗ[ℝ] E 
goal: o.rightAngleRotationAux₁ =
  let to_dual := (InnerProductSpace.toDual ℝ E).toLinearEquiv ≪≫ₗ LinearMap.toContinuousLinearMap.symm;
  ↑to_dual.symm ∘ₗ o.areaForm

full_name: Orientation.rightAngleRotationAux₁
code: /-- Auxiliary construction for `Orientation.rightAngleRotation`, rotation by 90 degrees in an
oriented real inner product space of dimension 2. -/
irreducible_def rightAngleRotationAux₁ : E →ₗ[ℝ] E 
goal: E →ₗ[ℝ] E

full_name: Orientation.definition._@.Mathlib.Analysis.InnerProductSpace.TwoDim._hyg.2394
code: /-- Auxiliary construction for `Orientation.rightAngleRotation`, rotation by 90 degrees in an
oriented real inner product space of dimension 2. -/
irreducible_def rightAngleRotationAux₁ : E →ₗ[ℝ] E 
goal: E →ₗ[ℝ] E

full_name: Orientation.inner_rightAngleRotationAux₁_left
code: @[simp]
theorem inner_rightAngleRotationAux₁_left (x y : E) : ⟪o.rightAngleRotationAux₁ x, y⟫ = ω x y 
goal: ⟪o.rightAngleRotationAux₁ x, y⟫_ℝ = (o.areaForm x) y

full_name: Orientation.inner_rightAngleRotationAux₁_right
code: @[simp]
theorem inner_rightAngleRotationAux₁_right (x y : E) :
    ⟪x, o.rightAngleRotationAux₁ y⟫ = -ω x y 
goal: ⟪x, o.rightAngleRotationAux₁ y⟫_ℝ = -(o.areaForm x) y

full_name: Orientation.rightAngleRotationAux₂
code: /-- Auxiliary construction for `Orientation.rightAngleRotation`, rotation by 90 degrees in an
oriented real inner product space of dimension 2. -/
def rightAngleRotationAux₂ : E →ₗᵢ[ℝ] E 
goal: E →ₗᵢ[ℝ] E

full_name: Orientation.rightAngleRotationAux₁_rightAngleRotationAux₁
code: @[simp]
theorem rightAngleRotationAux₁_rightAngleRotationAux₁ (x : E) :
    o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x) = -x 
goal: o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x) = -x

full_name: Orientation.wrapped._@.Mathlib.Analysis.InnerProductSpace.TwoDim._hyg.3778
code: /-- An isometric automorphism of an oriented real inner product space of dimension 2 (usual notation
`J`). This automorphism squares to -1. We will define rotations in such a way that this
automorphism is equal to rotation by 90 degrees. -/
irreducible_def rightAngleRotation : E ≃ₗᵢ[ℝ] E 
goal: Subtype (Eq @Orientation.definition✝)

full_name: Orientation.rightAngleRotation_def
code: /-- An isometric automorphism of an oriented real inner product space of dimension 2 (usual notation
`J`). This automorphism squares to -1. We will define rotations in such a way that this
automorphism is equal to rotation by 90 degrees. -/
irreducible_def rightAngleRotation : E ≃ₗᵢ[ℝ] E 
goal: o.rightAngleRotation = LinearIsometryEquiv.ofLinearIsometry o.rightAngleRotationAux₂ (-o.rightAngleRotationAux₁) ⋯ ⋯

full_name: Orientation.rightAngleRotation
code: /-- An isometric automorphism of an oriented real inner product space of dimension 2 (usual notation
`J`). This automorphism squares to -1. We will define rotations in such a way that this
automorphism is equal to rotation by 90 degrees. -/
irreducible_def rightAngleRotation : E ≃ₗᵢ[ℝ] E 
goal: E ≃ₗᵢ[ℝ] E

full_name: Orientation.definition._@.Mathlib.Analysis.InnerProductSpace.TwoDim._hyg.3778
code: /-- An isometric automorphism of an oriented real inner product space of dimension 2 (usual notation
`J`). This automorphism squares to -1. We will define rotations in such a way that this
automorphism is equal to rotation by 90 degrees. -/
irreducible_def rightAngleRotation : E ≃ₗᵢ[ℝ] E 
goal: E ≃ₗᵢ[ℝ] E

full_name: Orientation._aux_Mathlib_Analysis_InnerProductSpace_TwoDim___macroRules_Orientation_termJ_1
code: local notation "J" => o.rightAngleRotation
goal: Lean.Macro

full_name: Orientation.inner_rightAngleRotation_left
code: @[simp]
theorem inner_rightAngleRotation_left (x y : E) : ⟪J x, y⟫ = ω x y 
goal: ⟪o.rightAngleRotation x, y⟫_ℝ = (o.areaForm x) y

full_name: Orientation.inner_rightAngleRotation_right
code: @[simp]
theorem inner_rightAngleRotation_right (x y : E) : ⟪x, J y⟫ = -ω x y 
goal: ⟪x, o.rightAngleRotation y⟫_ℝ = -(o.areaForm x) y

full_name: Orientation.rightAngleRotation_rightAngleRotation
code: @[simp]
theorem rightAngleRotation_rightAngleRotation (x : E) : J (J x) = -x 
goal: o.rightAngleRotation (o.rightAngleRotation x) = -x

full_name: Orientation.rightAngleRotation_symm
code: @[simp]
theorem rightAngleRotation_symm :
    LinearIsometryEquiv.symm J = LinearIsometryEquiv.trans J (LinearIsometryEquiv.neg ℝ) 
goal: o.rightAngleRotation.symm = o.rightAngleRotation.trans (LinearIsometryEquiv.neg ℝ)

full_name: Orientation.inner_rightAngleRotation_self
code: theorem inner_rightAngleRotation_self (x : E) : ⟪J x, x⟫ = 0 
goal: ⟪o.rightAngleRotation x, x⟫_ℝ = 0

full_name: Orientation.inner_rightAngleRotation_swap
code: theorem inner_rightAngleRotation_swap (x y : E) : ⟪x, J y⟫ = -⟪J x, y⟫ 
goal: ⟪x, o.rightAngleRotation y⟫_ℝ = -⟪o.rightAngleRotation x, y⟫_ℝ

full_name: Orientation.inner_rightAngleRotation_swap'
code: theorem inner_rightAngleRotation_swap' (x y : E) : ⟪J x, y⟫ = -⟪x, J y⟫ 
goal: ⟪o.rightAngleRotation x, y⟫_ℝ = -⟪x, o.rightAngleRotation y⟫_ℝ

full_name: Orientation.inner_comp_rightAngleRotation
code: theorem inner_comp_rightAngleRotation (x y : E) : ⟪J x, J y⟫ = ⟪x, y⟫ 
goal: ⟪o.rightAngleRotation x, o.rightAngleRotation y⟫_ℝ = ⟪x, y⟫_ℝ

full_name: Orientation.areaForm_rightAngleRotation_left
code: @[simp]
theorem areaForm_rightAngleRotation_left (x y : E) : ω (J x) y = -⟪x, y⟫ 
goal: (o.areaForm (o.rightAngleRotation x)) y = -⟪x, y⟫_ℝ

full_name: Orientation.areaForm_rightAngleRotation_right
code: @[simp]
theorem areaForm_rightAngleRotation_right (x y : E) : ω x (J y) = ⟪x, y⟫ 
goal: (o.areaForm x) (o.rightAngleRotation y) = ⟪x, y⟫_ℝ

full_name: Orientation.areaForm_comp_rightAngleRotation
code: theorem areaForm_comp_rightAngleRotation (x y : E) : ω (J x) (J y) = ω x y 
goal: (o.areaForm (o.rightAngleRotation x)) (o.rightAngleRotation y) = (o.areaForm x) y

full_name: Orientation.rightAngleRotation_trans_rightAngleRotation
code: @[simp]
theorem rightAngleRotation_trans_rightAngleRotation :
    LinearIsometryEquiv.trans J J = LinearIsometryEquiv.neg ℝ 
goal: o.rightAngleRotation.trans o.rightAngleRotation = LinearIsometryEquiv.neg ℝ

full_name: Orientation.rightAngleRotation_neg_orientation
code: theorem rightAngleRotation_neg_orientation (x : E) :
    (-o).rightAngleRotation x = -o.rightAngleRotation x 
goal: (-o).rightAngleRotation x = -o.rightAngleRotation x

full_name: Orientation.rightAngleRotation_trans_neg_orientation
code: @[simp]
theorem rightAngleRotation_trans_neg_orientation :
    (-o).rightAngleRotation = o.rightAngleRotation.trans (LinearIsometryEquiv.neg ℝ) 
goal: (-o).rightAngleRotation = o.rightAngleRotation.trans (LinearIsometryEquiv.neg ℝ)

full_name: Orientation.rightAngleRotation_map
code: theorem rightAngleRotation_map {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
    [hF : Fact (finrank ℝ F = 2)] (φ : E ≃ₗᵢ[ℝ] F) (x : F) :
    (Orientation.map (Fin 2) φ.toLinearEquiv o).rightAngleRotation x =
      φ (o.rightAngleRotation (φ.symm x)) 
goal: ((Orientation.map (Fin 2) φ.toLinearEquiv) o).rightAngleRotation x = φ (o.rightAngleRotation (φ.symm x))

full_name: Orientation.linearIsometryEquiv_comp_rightAngleRotation
code: /-- `J` commutes with any positively-oriented isometric automorphism. -/
theorem linearIsometryEquiv_comp_rightAngleRotation (φ : E ≃ₗᵢ[ℝ] E)
    (hφ : 0 < LinearMap.det (φ.toLinearEquiv : E →ₗ[ℝ] E)) (x : E) : φ (J x) = J (φ x) 
goal: φ (o.rightAngleRotation x) = o.rightAngleRotation (φ x)

full_name: Orientation.rightAngleRotation_map'
code: theorem rightAngleRotation_map' {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
    [Fact (finrank ℝ F = 2)] (φ : E ≃ₗᵢ[ℝ] F) :
    (Orientation.map (Fin 2) φ.toLinearEquiv o).rightAngleRotation =
      (φ.symm.trans o.rightAngleRotation).trans φ 
goal: ((Orientation.map (Fin 2) φ.toLinearEquiv) o).rightAngleRotation = (φ.symm.trans o.rightAngleRotation).trans φ

full_name: Orientation.linearIsometryEquiv_comp_rightAngleRotation'
code: /-- `J` commutes with any positively-oriented isometric automorphism. -/
theorem linearIsometryEquiv_comp_rightAngleRotation' (φ : E ≃ₗᵢ[ℝ] E)
    (hφ : 0 < LinearMap.det (φ.toLinearEquiv : E →ₗ[ℝ] E)) :
    LinearIsometryEquiv.trans J φ = φ.trans J 
goal: o.rightAngleRotation.trans φ = φ.trans o.rightAngleRotation

full_name: Orientation.basisRightAngleRotation
code: /-- For a nonzero vector `x` in an oriented two-dimensional real inner product space `E`,
`![x, J x]` forms an (orthogonal) basis for `E`. -/
def basisRightAngleRotation (x : E) (hx : x ≠ 0) : Basis (Fin 2) ℝ E 
goal: Basis (Fin 2) ℝ E

full_name: Orientation.coe_basisRightAngleRotation
code: @[simp]
theorem coe_basisRightAngleRotation (x : E) (hx : x ≠ 0) :
    ⇑(o.basisRightAngleRotation x hx) = ![x, J x] 
goal: ⇑(o.basisRightAngleRotation x hx) = ![x, o.rightAngleRotation x]

full_name: Orientation.inner_mul_inner_add_areaForm_mul_areaForm'
code: /-- For vectors `a x y : E`, the identity `⟪a, x⟫ * ⟪a, y⟫ + ω a x * ω a y = ‖a‖ ^ 2 * ⟪x, y⟫`. (See
`Orientation.inner_mul_inner_add_areaForm_mul_areaForm` for the "applied" form.)-/
theorem inner_mul_inner_add_areaForm_mul_areaForm' (a x : E) :
    ⟪a, x⟫ • innerₛₗ ℝ a + ω a x • ω a = ‖a‖ ^ 2 • innerₛₗ ℝ x 
goal: ⟪a, x⟫_ℝ • (innerₛₗ ℝ) a + (o.areaForm a) x • o.areaForm a = ‖a‖ ^ 2 • (innerₛₗ ℝ) x

full_name: Orientation.inner_mul_inner_add_areaForm_mul_areaForm
code: /-- For vectors `a x y : E`, the identity `⟪a, x⟫ * ⟪a, y⟫ + ω a x * ω a y = ‖a‖ ^ 2 * ⟪x, y⟫`. -/
theorem inner_mul_inner_add_areaForm_mul_areaForm (a x y : E) :
    ⟪a, x⟫ * ⟪a, y⟫ + ω a x * ω a y = ‖a‖ ^ 2 * ⟪x, y⟫ 
goal: ⟪a, x⟫_ℝ * ⟪a, y⟫_ℝ + (o.areaForm a) x * (o.areaForm a) y = ‖a‖ ^ 2 * ⟪x, y⟫_ℝ

full_name: Orientation.inner_sq_add_areaForm_sq
code: theorem inner_sq_add_areaForm_sq (a b : E) : ⟪a, b⟫ ^ 2 + ω a b ^ 2 = ‖a‖ ^ 2 * ‖b‖ ^ 2 
goal: ⟪a, b⟫_ℝ ^ 2 + (o.areaForm a) b ^ 2 = ‖a‖ ^ 2 * ‖b‖ ^ 2

full_name: Orientation.inner_mul_areaForm_sub'
code: /-- For vectors `a x y : E`, the identity `⟪a, x⟫ * ω a y - ω a x * ⟪a, y⟫ = ‖a‖ ^ 2 * ω x y`. (See
`Orientation.inner_mul_areaForm_sub` for the "applied" form.) -/
theorem inner_mul_areaForm_sub' (a x : E) : ⟪a, x⟫ • ω a - ω a x • innerₛₗ ℝ a = ‖a‖ ^ 2 • ω x 
goal: ⟪a, x⟫_ℝ • o.areaForm a - (o.areaForm a) x • (innerₛₗ ℝ) a = ‖a‖ ^ 2 • o.areaForm x

full_name: Orientation.inner_mul_areaForm_sub
code: /-- For vectors `a x y : E`, the identity `⟪a, x⟫ * ω a y - ω a x * ⟪a, y⟫ = ‖a‖ ^ 2 * ω x y`. -/
theorem inner_mul_areaForm_sub (a x y : E) : ⟪a, x⟫ * ω a y - ω a x * ⟪a, y⟫ = ‖a‖ ^ 2 * ω x y 
goal: ⟪a, x⟫_ℝ * (o.areaForm a) y - (o.areaForm a) x * ⟪a, y⟫_ℝ = ‖a‖ ^ 2 * (o.areaForm x) y

full_name: Orientation.nonneg_inner_and_areaForm_eq_zero_iff_sameRay
code: theorem nonneg_inner_and_areaForm_eq_zero_iff_sameRay (x y : E) :
    0 ≤ ⟪x, y⟫ ∧ ω x y = 0 ↔ SameRay ℝ x y 
goal: 0 ≤ ⟪x, y⟫_ℝ ∧ (o.areaForm x) y = 0 ↔ SameRay ℝ x y

full_name: Orientation.kahler
code: /-- A complex-valued real-bilinear map on an oriented real inner product space of dimension 2. Its
real part is the inner product and its imaginary part is `Orientation.areaForm`.

On `ℂ` with the standard orientation, `kahler w z = conj w * z`; see `Complex.kahler`. -/
def kahler : E →ₗ[ℝ] E →ₗ[ℝ] ℂ 
goal: E →ₗ[ℝ] E →ₗ[ℝ] ℂ

full_name: Orientation.kahler_apply_apply
code: theorem kahler_apply_apply (x y : E) : o.kahler x y = ⟪x, y⟫ + ω x y • Complex.I 
goal: (o.kahler x) y = ↑⟪x, y⟫_ℝ + (o.areaForm x) y • Complex.I

full_name: Orientation.kahler_swap
code: theorem kahler_swap (x y : E) : o.kahler x y = conj (o.kahler y x) 
goal: (o.kahler x) y = (starRingEnd ℂ) ((o.kahler y) x)

full_name: Orientation.kahler_apply_self
code: @[simp]
theorem kahler_apply_self (x : E) : o.kahler x x = ‖x‖ ^ 2 
goal: (o.kahler x) x = ↑‖x‖ ^ 2

full_name: Orientation.kahler_rightAngleRotation_left
code: @[simp]
theorem kahler_rightAngleRotation_left (x y : E) :
    o.kahler (J x) y = -Complex.I * o.kahler x y 
goal: (o.kahler (o.rightAngleRotation x)) y = -Complex.I * (o.kahler x) y

full_name: Orientation.kahler_rightAngleRotation_right
code: @[simp]
theorem kahler_rightAngleRotation_right (x y : E) :
    o.kahler x (J y) = Complex.I * o.kahler x y 
goal: (o.kahler x) (o.rightAngleRotation y) = Complex.I * (o.kahler x) y

full_name: Orientation.kahler_comp_rightAngleRotation
code: theorem kahler_comp_rightAngleRotation (x y : E) : o.kahler (J x) (J y) = o.kahler x y 
goal: (o.kahler (o.rightAngleRotation x)) (o.rightAngleRotation y) = (o.kahler x) y

full_name: Orientation.kahler_comp_rightAngleRotation'
code: theorem kahler_comp_rightAngleRotation' (x y : E) :
    -(Complex.I * (Complex.I * o.kahler x y)) = o.kahler x y 
goal: -(Complex.I * (Complex.I * (o.kahler x) y)) = (o.kahler x) y

full_name: Orientation.kahler_neg_orientation
code: @[simp]
theorem kahler_neg_orientation (x y : E) : (-o).kahler x y = conj (o.kahler x y) 
goal: ((-o).kahler x) y = (starRingEnd ℂ) ((o.kahler x) y)

full_name: Orientation.kahler_mul
code: theorem kahler_mul (a x y : E) : o.kahler x a * o.kahler a y = ‖a‖ ^ 2 * o.kahler x y 
goal: (o.kahler x) a * (o.kahler a) y = ↑‖a‖ ^ 2 * (o.kahler x) y

full_name: Orientation.normSq_kahler
code: theorem normSq_kahler (x y : E) : Complex.normSq (o.kahler x y) = ‖x‖ ^ 2 * ‖y‖ ^ 2 
goal: Complex.normSq ((o.kahler x) y) = ‖x‖ ^ 2 * ‖y‖ ^ 2

full_name: Orientation.abs_kahler
code: theorem abs_kahler (x y : E) : Complex.abs (o.kahler x y) = ‖x‖ * ‖y‖ 
goal: Complex.abs ((o.kahler x) y) = ‖x‖ * ‖y‖

full_name: Orientation.norm_kahler
code: theorem norm_kahler (x y : E) : ‖o.kahler x y‖ = ‖x‖ * ‖y‖ 
goal: ‖(o.kahler x) y‖ = ‖x‖ * ‖y‖

full_name: Orientation.eq_zero_or_eq_zero_of_kahler_eq_zero
code: theorem eq_zero_or_eq_zero_of_kahler_eq_zero {x y : E} (hx : o.kahler x y = 0) : x = 0 ∨ y = 0 
goal: x = 0 ∨ y = 0

full_name: Orientation.kahler_eq_zero_iff
code: theorem kahler_eq_zero_iff (x y : E) : o.kahler x y = 0 ↔ x = 0 ∨ y = 0 
goal: (o.kahler x) y = 0 ↔ x = 0 ∨ y = 0

full_name: Orientation.kahler_ne_zero
code: theorem kahler_ne_zero {x y : E} (hx : x ≠ 0) (hy : y ≠ 0) : o.kahler x y ≠ 0 
goal: (o.kahler x) y ≠ 0

full_name: Orientation.kahler_ne_zero_iff
code: theorem kahler_ne_zero_iff (x y : E) : o.kahler x y ≠ 0 ↔ x ≠ 0 ∧ y ≠ 0 
goal: (o.kahler x) y ≠ 0 ↔ x ≠ 0 ∧ y ≠ 0

full_name: Orientation.kahler_map
code: theorem kahler_map {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
    [hF : Fact (finrank ℝ F = 2)] (φ : E ≃ₗᵢ[ℝ] F) (x y : F) :
    (Orientation.map (Fin 2) φ.toLinearEquiv o).kahler x y = o.kahler (φ.symm x) (φ.symm y) 
goal: (((Orientation.map (Fin 2) φ.toLinearEquiv) o).kahler x) y = (o.kahler (φ.symm x)) (φ.symm y)

full_name: Orientation.kahler_comp_linearIsometryEquiv
code: /-- The bilinear map `kahler` is invariant under pullback by a positively-oriented isometric
automorphism. -/
theorem kahler_comp_linearIsometryEquiv (φ : E ≃ₗᵢ[ℝ] E)
    (hφ : 0 < LinearMap.det (φ.toLinearEquiv : E →ₗ[ℝ] E)) (x y : E) :
    o.kahler (φ x) (φ y) = o.kahler x y 
goal: (o.kahler (φ x)) (φ y) = (o.kahler x) y

full_name: Complex.areaForm
code: @[simp]
protected theorem areaForm (w z : ℂ) : Complex.orientation.areaForm w z = (conj w * z).im 
goal: (Complex.orientation.areaForm w) z = ((starRingEnd ℂ) w * z).im

full_name: Complex.rightAngleRotation
code: @[simp]
protected theorem rightAngleRotation (z : ℂ) :
    Complex.orientation.rightAngleRotation z = I * z 
goal: Complex.orientation.rightAngleRotation z = Complex.I * z

full_name: Complex.kahler
code: @[simp]
protected theorem kahler (w z : ℂ) : Complex.orientation.kahler w z = conj w * z 
goal: (Complex.orientation.kahler w) z = (starRingEnd ℂ) w * z

full_name: Orientation._aux_Mathlib_Analysis_InnerProductSpace_TwoDim___macroRules_Orientation_termω_2
code: local notation "ω" => o.areaForm
goal: Lean.Macro

full_name: Orientation._aux_Mathlib_Analysis_InnerProductSpace_TwoDim___macroRules_Orientation_termJ_2
code: local notation "J" => o.rightAngleRotation
goal: Lean.Macro

full_name: Orientation.areaForm_map_complex
code: /-- The area form on an oriented real inner product space of dimension 2 can be evaluated in terms
of a complex-number representation of the space. -/
theorem areaForm_map_complex (f : E ≃ₗᵢ[ℝ] ℂ)
    (hf : Orientation.map (Fin 2) f.toLinearEquiv o = Complex.orientation) (x y : E) :
    ω x y = (conj (f x) * f y).im 
goal: (o.areaForm x) y = ((starRingEnd ℂ) (f x) * f y).im

full_name: Orientation.rightAngleRotation_map_complex
code: /-- The rotation by 90 degrees on an oriented real inner product space of dimension 2 can be
evaluated in terms of a complex-number representation of the space. -/
theorem rightAngleRotation_map_complex (f : E ≃ₗᵢ[ℝ] ℂ)
    (hf : Orientation.map (Fin 2) f.toLinearEquiv o = Complex.orientation) (x : E) :
    f (J x) = I * f x 
goal: f (o.rightAngleRotation x) = Complex.I * f x

full_name: Orientation.kahler_map_complex
code: /-- The Kahler form on an oriented real inner product space of dimension 2 can be evaluated in terms
of a complex-number representation of the space. -/
theorem kahler_map_complex (f : E ≃ₗᵢ[ℝ] ℂ)
    (hf : Orientation.map (Fin 2) f.toLinearEquiv o = Complex.orientation) (x y : E) :
    o.kahler x y = conj (f x) * f y 
goal: (o.kahler x) y = (starRingEnd ℂ) (f x) * f y