File: Mathlib/Analysis/InnerProductSpace/Basic.lean

full_name: Inner
code: /-- Syntactic typeclass for types endowed with an inner product -/
class Inner (𝕜 E : Type*) where
  /-- The inner product function. -/
  inner : E → E → 𝕜
goal: Type (max u_4 u_5)

full_name: Inner.inner
code: /-- Syntactic typeclass for types endowed with an inner product -/
class Inner (𝕜 E : Type*) where
  /-- The inner product function. -/
  inner : E → E → 𝕜
goal: E → E → 𝕜

full_name: «_aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_term⟪_,_⟫___1»
code: /-- The inner product with values in `𝕜`. -/
notation3:max "⟪" x ", " y "⟫_" 𝕜:max => @inner 𝕜 _ _ x y
goal: Lean.Macro

full_name: RealInnerProductSpace.«_aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_RealInnerProductSpace_term⟪_,_⟫_1»
code: /-- The inner product with values in `ℝ`. -/
scoped[RealInnerProductSpace] notation "⟪" x ", " y "⟫" => @inner ℝ _ _ x y
goal: Lean.Macro

full_name: ComplexInnerProductSpace.«_aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_ComplexInnerProductSpace_term⟪_,_⟫_1»
code: /-- The inner product with values in `ℂ`. -/
scoped[ComplexInnerProductSpace] notation "⟪" x ", " y "⟫" => @inner ℂ _ _ x y
goal: Lean.Macro

full_name: InnerProductSpace
code: /-- An inner product space is a vector space with an additional operation called inner product.
The norm could be derived from the inner product, instead we require the existence of a norm and
the fact that `‖x‖^2 = re ⟪x, x⟫` to be able to put instances on `𝕂` or product
spaces.

To construct a norm from an inner product, see `InnerProductSpace.ofCore`.
-/
class InnerProductSpace (𝕜 : Type*) (E : Type*) [RCLike 𝕜] [NormedAddCommGroup E] extends
  NormedSpace 𝕜 E, Inner 𝕜 E where
  /-- The inner product induces the norm. -/
  norm_sq_eq_inner : ∀ x : E, ‖x‖ ^ 2 = re (inner x x)
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: Type (max u_4 u_5)

full_name: InnerProductSpace.smul_left
code: /-- An inner product space is a vector space with an additional operation called inner product.
The norm could be derived from the inner product, instead we require the existence of a norm and
the fact that `‖x‖^2 = re ⟪x, x⟫` to be able to put instances on `𝕂` or product
spaces.

To construct a norm from an inner product, see `InnerProductSpace.ofCore`.
-/
class InnerProductSpace (𝕜 : Type*) (E : Type*) [RCLike 𝕜] [NormedAddCommGroup E] extends
  NormedSpace 𝕜 E, Inner 𝕜 E where
  /-- The inner product induces the norm. -/
  norm_sq_eq_inner : ∀ x : E, ‖x‖ ^ 2 = re (inner x x)
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: ⟪r • x, y⟫_𝕜 = (starRingEnd 𝕜) r * ⟪x, y⟫_𝕜

full_name: InnerProductSpace.norm_sq_eq_inner
code: /-- An inner product space is a vector space with an additional operation called inner product.
The norm could be derived from the inner product, instead we require the existence of a norm and
the fact that `‖x‖^2 = re ⟪x, x⟫` to be able to put instances on `𝕂` or product
spaces.

To construct a norm from an inner product, see `InnerProductSpace.ofCore`.
-/
class InnerProductSpace (𝕜 : Type*) (E : Type*) [RCLike 𝕜] [NormedAddCommGroup E] extends
  NormedSpace 𝕜 E, Inner 𝕜 E where
  /-- The inner product induces the norm. -/
  norm_sq_eq_inner : ∀ x : E, ‖x‖ ^ 2 = re (inner x x)
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: ‖x‖ ^ 2 = RCLike.re ⟪x, x⟫_𝕜

full_name: InnerProductSpace.conj_symm
code: /-- An inner product space is a vector space with an additional operation called inner product.
The norm could be derived from the inner product, instead we require the existence of a norm and
the fact that `‖x‖^2 = re ⟪x, x⟫` to be able to put instances on `𝕂` or product
spaces.

To construct a norm from an inner product, see `InnerProductSpace.ofCore`.
-/
class InnerProductSpace (𝕜 : Type*) (E : Type*) [RCLike 𝕜] [NormedAddCommGroup E] extends
  NormedSpace 𝕜 E, Inner 𝕜 E where
  /-- The inner product induces the norm. -/
  norm_sq_eq_inner : ∀ x : E, ‖x‖ ^ 2 = re (inner x x)
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: (starRingEnd 𝕜) ⟪y, x⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: InnerProductSpace.add_left
code: /-- An inner product space is a vector space with an additional operation called inner product.
The norm could be derived from the inner product, instead we require the existence of a norm and
the fact that `‖x‖^2 = re ⟪x, x⟫` to be able to put instances on `𝕂` or product
spaces.

To construct a norm from an inner product, see `InnerProductSpace.ofCore`.
-/
class InnerProductSpace (𝕜 : Type*) (E : Type*) [RCLike 𝕜] [NormedAddCommGroup E] extends
  NormedSpace 𝕜 E, Inner 𝕜 E where
  /-- The inner product induces the norm. -/
  norm_sq_eq_inner : ∀ x : E, ‖x‖ ^ 2 = re (inner x x)
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: ⟪x + y, z⟫_𝕜 = ⟪x, z⟫_𝕜 + ⟪y, z⟫_𝕜

full_name: InnerProductSpace.Core.smul_left
code: /-- A structure requiring that a scalar product is positive definite and symmetric, from which one
can construct an `InnerProductSpace` instance in `InnerProductSpace.ofCore`. -/
-- @[nolint HasNonemptyInstance] porting note: I don't think we have this linter anymore
structure InnerProductSpace.Core (𝕜 : Type*) (F : Type*) [RCLike 𝕜] [AddCommGroup F]
  [Module 𝕜 F] extends Inner 𝕜 F where
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is positive (semi)definite. -/
  nonneg_re : ∀ x, 0 ≤ re (inner x x)
  /-- The inner product is positive definite. -/
  definite : ∀ x, inner x x = 0 → x = 0
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: ⟪r • x, y⟫_𝕜 = (starRingEnd 𝕜) r * ⟪x, y⟫_𝕜

full_name: InnerProductSpace.Core
code: /-- A structure requiring that a scalar product is positive definite and symmetric, from which one
can construct an `InnerProductSpace` instance in `InnerProductSpace.ofCore`. -/
-- @[nolint HasNonemptyInstance] porting note: I don't think we have this linter anymore
structure InnerProductSpace.Core (𝕜 : Type*) (F : Type*) [RCLike 𝕜] [AddCommGroup F]
  [Module 𝕜 F] extends Inner 𝕜 F where
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is positive (semi)definite. -/
  nonneg_re : ∀ x, 0 ≤ re (inner x x)
  /-- The inner product is positive definite. -/
  definite : ∀ x, inner x x = 0 → x = 0
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: Type (max u_4 u_5)

full_name: InnerProductSpace.Core.add_left
code: /-- A structure requiring that a scalar product is positive definite and symmetric, from which one
can construct an `InnerProductSpace` instance in `InnerProductSpace.ofCore`. -/
-- @[nolint HasNonemptyInstance] porting note: I don't think we have this linter anymore
structure InnerProductSpace.Core (𝕜 : Type*) (F : Type*) [RCLike 𝕜] [AddCommGroup F]
  [Module 𝕜 F] extends Inner 𝕜 F where
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is positive (semi)definite. -/
  nonneg_re : ∀ x, 0 ≤ re (inner x x)
  /-- The inner product is positive definite. -/
  definite : ∀ x, inner x x = 0 → x = 0
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: ⟪x + y, z⟫_𝕜 = ⟪x, z⟫_𝕜 + ⟪y, z⟫_𝕜

full_name: InnerProductSpace.Core.nonneg_re
code: /-- A structure requiring that a scalar product is positive definite and symmetric, from which one
can construct an `InnerProductSpace` instance in `InnerProductSpace.ofCore`. -/
-- @[nolint HasNonemptyInstance] porting note: I don't think we have this linter anymore
structure InnerProductSpace.Core (𝕜 : Type*) (F : Type*) [RCLike 𝕜] [AddCommGroup F]
  [Module 𝕜 F] extends Inner 𝕜 F where
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is positive (semi)definite. -/
  nonneg_re : ∀ x, 0 ≤ re (inner x x)
  /-- The inner product is positive definite. -/
  definite : ∀ x, inner x x = 0 → x = 0
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: 0 ≤ RCLike.re ⟪x, x⟫_𝕜

full_name: InnerProductSpace.Core.definite
code: /-- A structure requiring that a scalar product is positive definite and symmetric, from which one
can construct an `InnerProductSpace` instance in `InnerProductSpace.ofCore`. -/
-- @[nolint HasNonemptyInstance] porting note: I don't think we have this linter anymore
structure InnerProductSpace.Core (𝕜 : Type*) (F : Type*) [RCLike 𝕜] [AddCommGroup F]
  [Module 𝕜 F] extends Inner 𝕜 F where
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is positive (semi)definite. -/
  nonneg_re : ∀ x, 0 ≤ re (inner x x)
  /-- The inner product is positive definite. -/
  definite : ∀ x, inner x x = 0 → x = 0
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: ⟪x, x⟫_𝕜 = 0 → x = 0

full_name: InnerProductSpace.Core.conj_symm
code: /-- A structure requiring that a scalar product is positive definite and symmetric, from which one
can construct an `InnerProductSpace` instance in `InnerProductSpace.ofCore`. -/
-- @[nolint HasNonemptyInstance] porting note: I don't think we have this linter anymore
structure InnerProductSpace.Core (𝕜 : Type*) (F : Type*) [RCLike 𝕜] [AddCommGroup F]
  [Module 𝕜 F] extends Inner 𝕜 F where
  /-- The inner product is *hermitian*, taking the `conj` swaps the arguments. -/
  conj_symm : ∀ x y, conj (inner y x) = inner x y
  /-- The inner product is positive (semi)definite. -/
  nonneg_re : ∀ x, 0 ≤ re (inner x x)
  /-- The inner product is positive definite. -/
  definite : ∀ x, inner x x = 0 → x = 0
  /-- The inner product is additive in the first coordinate. -/
  add_left : ∀ x y z, inner (x + y) z = inner x z + inner y z
  /-- The inner product is conjugate linear in the first coordinate. -/
  smul_left : ∀ x y r, inner (r • x) y = conj r * inner x y
goal: (starRingEnd 𝕜) ⟪y, x⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: InnerProductSpace.toCore
code: /-- Define `InnerProductSpace.Core` from `InnerProductSpace`. Defined to reuse lemmas about
`InnerProductSpace.Core` for `InnerProductSpace`s. Note that the `Norm` instance provided by
`InnerProductSpace.Core.norm` is propositionally but not definitionally equal to the original
norm. -/
def InnerProductSpace.toCore [NormedAddCommGroup E] [c : InnerProductSpace 𝕜 E] :
    InnerProductSpace.Core 𝕜 E 
goal: InnerProductSpace.Core 𝕜 E

full_name: InnerProductSpace.Core.«_aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_InnerProductSpace_Core_term⟪_,_⟫_1»
code: local notation "⟪" x ", " y "⟫" => @inner 𝕜 F _ x y
goal: Lean.Macro

full_name: InnerProductSpace.Core._aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_InnerProductSpace_Core_termNormSqK_1
code: local notation "normSqK" => @RCLike.normSq 𝕜 _
goal: Lean.Macro

full_name: InnerProductSpace.Core._aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_InnerProductSpace_Core_termReK_1
code: local notation "reK" => @RCLike.re 𝕜 _
goal: Lean.Macro

full_name: InnerProductSpace.Core._aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_InnerProductSpace_Core_termExt_iff_1
code: local notation "ext_iff" => @RCLike.ext_iff 𝕜 _
goal: Lean.Macro

full_name: InnerProductSpace.Core.«_aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_InnerProductSpace_Core_term_†_1»
code: local postfix:90 "†" => starRingEnd _
goal: Lean.Macro

full_name: InnerProductSpace.Core.toInner'
code: /-- Inner product defined by the `InnerProductSpace.Core` structure. We can't reuse
`InnerProductSpace.Core.toInner` because it takes `InnerProductSpace.Core` as an explicit
argument. -/
def toInner' : Inner 𝕜 F 
goal: Inner 𝕜 F

full_name: InnerProductSpace.Core.normSq
code: /-- The norm squared function for `InnerProductSpace.Core` structure. -/
def normSq (x : F) 
goal: ℝ

full_name: InnerProductSpace.Core._aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_InnerProductSpace_Core_termNormSqF_1
code: local notation "normSqF" => @normSq 𝕜 F _ _ _ _
goal: Lean.Macro

full_name: InnerProductSpace.Core.inner_conj_symm
code: theorem inner_conj_symm (x y : F) : ⟪y, x⟫† = ⟪x, y⟫ 
goal: (starRingEnd 𝕜) ⟪y, x⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: InnerProductSpace.Core.inner_self_nonneg
code: theorem inner_self_nonneg {x : F} : 0 ≤ re ⟪x, x⟫ 
goal: 0 ≤ RCLike.re ⟪x, x⟫_𝕜

full_name: InnerProductSpace.Core.inner_self_im
code: theorem inner_self_im (x : F) : im ⟪x, x⟫ = 0 
goal: RCLike.im ⟪x, x⟫_𝕜 = 0

full_name: InnerProductSpace.Core.inner_add_left
code: theorem inner_add_left (x y z : F) : ⟪x + y, z⟫ = ⟪x, z⟫ + ⟪y, z⟫ 
goal: ⟪x + y, z⟫_𝕜 = ⟪x, z⟫_𝕜 + ⟪y, z⟫_𝕜

full_name: InnerProductSpace.Core.inner_add_right
code: theorem inner_add_right (x y z : F) : ⟪x, y + z⟫ = ⟪x, y⟫ + ⟪x, z⟫ 
goal: ⟪x, y + z⟫_𝕜 = ⟪x, y⟫_𝕜 + ⟪x, z⟫_𝕜

full_name: InnerProductSpace.Core.ofReal_normSq_eq_inner_self
code: theorem ofReal_normSq_eq_inner_self (x : F) : (normSqF x : 𝕜) = ⟪x, x⟫ 
goal: ↑(InnerProductSpace.Core.normSq x) = ⟪x, x⟫_𝕜

full_name: InnerProductSpace.Core.inner_re_symm
code: theorem inner_re_symm (x y : F) : re ⟪x, y⟫ = re ⟪y, x⟫ 
goal: RCLike.re ⟪x, y⟫_𝕜 = RCLike.re ⟪y, x⟫_𝕜

full_name: InnerProductSpace.Core.inner_im_symm
code: theorem inner_im_symm (x y : F) : im ⟪x, y⟫ = -im ⟪y, x⟫ 
goal: RCLike.im ⟪x, y⟫_𝕜 = -RCLike.im ⟪y, x⟫_𝕜

full_name: InnerProductSpace.Core.inner_smul_left
code: theorem inner_smul_left (x y : F) {r : 𝕜} : ⟪r • x, y⟫ = r† * ⟪x, y⟫ 
goal: ⟪r • x, y⟫_𝕜 = (starRingEnd 𝕜) r * ⟪x, y⟫_𝕜

full_name: InnerProductSpace.Core.inner_smul_right
code: theorem inner_smul_right (x y : F) {r : 𝕜} : ⟪x, r • y⟫ = r * ⟪x, y⟫ 
goal: ⟪x, r • y⟫_𝕜 = r * ⟪x, y⟫_𝕜

full_name: InnerProductSpace.Core.inner_zero_left
code: theorem inner_zero_left (x : F) : ⟪0, x⟫ = 0 
goal: ⟪0, x⟫_𝕜 = 0

full_name: InnerProductSpace.Core.inner_zero_right
code: theorem inner_zero_right (x : F) : ⟪x, 0⟫ = 0 
goal: ⟪x, 0⟫_𝕜 = 0

full_name: InnerProductSpace.Core.inner_self_eq_zero
code: theorem inner_self_eq_zero {x : F} : ⟪x, x⟫ = 0 ↔ x = 0 
goal: ⟪x, x⟫_𝕜 = 0 ↔ x = 0

full_name: InnerProductSpace.Core.normSq_eq_zero
code: theorem normSq_eq_zero {x : F} : normSqF x = 0 ↔ x = 0 
goal: InnerProductSpace.Core.normSq x = 0 ↔ x = 0

full_name: InnerProductSpace.Core.inner_self_ne_zero
code: theorem inner_self_ne_zero {x : F} : ⟪x, x⟫ ≠ 0 ↔ x ≠ 0 
goal: ⟪x, x⟫_𝕜 ≠ 0 ↔ x ≠ 0

full_name: InnerProductSpace.Core.inner_self_ofReal_re
code: theorem inner_self_ofReal_re (x : F) : (re ⟪x, x⟫ : 𝕜) = ⟪x, x⟫ 
goal: ↑(RCLike.re ⟪x, x⟫_𝕜) = ⟪x, x⟫_𝕜

full_name: InnerProductSpace.Core.norm_inner_symm
code: theorem norm_inner_symm (x y : F) : ‖⟪x, y⟫‖ = ‖⟪y, x⟫‖ 
goal: ‖⟪x, y⟫_𝕜‖ = ‖⟪y, x⟫_𝕜‖

full_name: InnerProductSpace.Core.inner_neg_left
code: theorem inner_neg_left (x y : F) : ⟪-x, y⟫ = -⟪x, y⟫ 
goal: ⟪-x, y⟫_𝕜 = -⟪x, y⟫_𝕜

full_name: InnerProductSpace.Core.inner_neg_right
code: theorem inner_neg_right (x y : F) : ⟪x, -y⟫ = -⟪x, y⟫ 
goal: ⟪x, -y⟫_𝕜 = -⟪x, y⟫_𝕜

full_name: InnerProductSpace.Core.inner_sub_left
code: theorem inner_sub_left (x y z : F) : ⟪x - y, z⟫ = ⟪x, z⟫ - ⟪y, z⟫ 
goal: ⟪x - y, z⟫_𝕜 = ⟪x, z⟫_𝕜 - ⟪y, z⟫_𝕜

full_name: InnerProductSpace.Core.inner_sub_right
code: theorem inner_sub_right (x y z : F) : ⟪x, y - z⟫ = ⟪x, y⟫ - ⟪x, z⟫ 
goal: ⟪x, y - z⟫_𝕜 = ⟪x, y⟫_𝕜 - ⟪x, z⟫_𝕜

full_name: InnerProductSpace.Core.inner_mul_symm_re_eq_norm
code: theorem inner_mul_symm_re_eq_norm (x y : F) : re (⟪x, y⟫ * ⟪y, x⟫) = ‖⟪x, y⟫ * ⟪y, x⟫‖ 
goal: RCLike.re (⟪x, y⟫_𝕜 * ⟪y, x⟫_𝕜) = ‖⟪x, y⟫_𝕜 * ⟪y, x⟫_𝕜‖

full_name: InnerProductSpace.Core.inner_add_add_self
code: /-- Expand `inner (x + y) (x + y)` -/
theorem inner_add_add_self (x y : F) : ⟪x + y, x + y⟫ = ⟪x, x⟫ + ⟪x, y⟫ + ⟪y, x⟫ + ⟪y, y⟫ 
goal: ⟪x + y, x + y⟫_𝕜 = ⟪x, x⟫_𝕜 + ⟪x, y⟫_𝕜 + ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜

full_name: InnerProductSpace.Core.inner_sub_sub_self
code: theorem inner_sub_sub_self (x y : F) : ⟪x - y, x - y⟫ = ⟪x, x⟫ - ⟪x, y⟫ - ⟪y, x⟫ + ⟪y, y⟫ 
goal: ⟪x - y, x - y⟫_𝕜 = ⟪x, x⟫_𝕜 - ⟪x, y⟫_𝕜 - ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜

full_name: InnerProductSpace.Core.cauchy_schwarz_aux
code: /-- An auxiliary equality useful to prove the **Cauchy–Schwarz inequality**: the square of the norm
of `⟪x, y⟫ • x - ⟪x, x⟫ • y` is equal to `‖x‖ ^ 2 * (‖x‖ ^ 2 * ‖y‖ ^ 2 - ‖⟪x, y⟫‖ ^ 2)`. We use
`InnerProductSpace.ofCore.normSq x` etc (defeq to `is_R_or_C.re ⟪x, x⟫`) instead of `‖x‖ ^ 2`
etc to avoid extra rewrites when applying it to an `InnerProductSpace`. -/
theorem cauchy_schwarz_aux (x y : F) :
    normSqF (⟪x, y⟫ • x - ⟪x, x⟫ • y) = normSqF x * (normSqF x * normSqF y - ‖⟪x, y⟫‖ ^ 2) 
goal: InnerProductSpace.Core.normSq (⟪x, y⟫_𝕜 • x - ⟪x, x⟫_𝕜 • y) =
  InnerProductSpace.Core.normSq x * (InnerProductSpace.Core.normSq x * InnerProductSpace.Core.normSq y - ‖⟪x, y⟫_𝕜‖ ^ 2)

full_name: InnerProductSpace.Core.inner_mul_inner_self_le
code: /-- **Cauchy–Schwarz inequality**.
We need this for the `Core` structure to prove the triangle inequality below when
showing the core is a normed group.
-/
theorem inner_mul_inner_self_le (x y : F) : ‖⟪x, y⟫‖ * ‖⟪y, x⟫‖ ≤ re ⟪x, x⟫ * re ⟪y, y⟫ 
goal: ‖⟪x, y⟫_𝕜‖ * ‖⟪y, x⟫_𝕜‖ ≤ RCLike.re ⟪x, x⟫_𝕜 * RCLike.re ⟪y, y⟫_𝕜

full_name: InnerProductSpace.Core.toNorm
code: /-- Norm constructed from an `InnerProductSpace.Core` structure, defined to be the square root
of the scalar product. -/
def toNorm : Norm F 
goal: Norm F

full_name: InnerProductSpace.Core.norm_eq_sqrt_inner
code: theorem norm_eq_sqrt_inner (x : F) : ‖x‖ = √(re ⟪x, x⟫) 
goal: ‖x‖ = √(RCLike.re ⟪x, x⟫_𝕜)

full_name: InnerProductSpace.Core.inner_self_eq_norm_mul_norm
code: theorem inner_self_eq_norm_mul_norm (x : F) : re ⟪x, x⟫ = ‖x‖ * ‖x‖ 
goal: RCLike.re ⟪x, x⟫_𝕜 = ‖x‖ * ‖x‖

full_name: InnerProductSpace.Core.sqrt_normSq_eq_norm
code: theorem sqrt_normSq_eq_norm (x : F) : √(normSqF x) = ‖x‖ 
goal: √(InnerProductSpace.Core.normSq x) = ‖x‖

full_name: InnerProductSpace.Core.norm_inner_le_norm
code: /-- Cauchy–Schwarz inequality with norm -/
theorem norm_inner_le_norm (x y : F) : ‖⟪x, y⟫‖ ≤ ‖x‖ * ‖y‖ 
goal: ‖⟪x, y⟫_𝕜‖ ≤ ‖x‖ * ‖y‖

full_name: InnerProductSpace.Core.toNormedAddCommGroup
code: /-- Normed group structure constructed from an `InnerProductSpace.Core` structure -/
def toNormedAddCommGroup : NormedAddCommGroup F 
goal: NormedAddCommGroup F

full_name: InnerProductSpace.Core.toNormedSpace
code: /-- Normed space structure constructed from an `InnerProductSpace.Core` structure -/
def toNormedSpace : NormedSpace 𝕜 F 
goal: NormedSpace 𝕜 F

full_name: InnerProductSpace.ofCore
code: /-- Given an `InnerProductSpace.Core` structure on a space, one can use it to turn
the space into an inner product space. The `NormedAddCommGroup` structure is expected
to already be defined with `InnerProductSpace.ofCore.toNormedAddCommGroup`. -/
def InnerProductSpace.ofCore [AddCommGroup F] [Module 𝕜 F] (c : InnerProductSpace.Core 𝕜 F) :
    InnerProductSpace 𝕜 F 
goal: InnerProductSpace 𝕜 F

full_name: «_aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_term⟪_,_⟫_1»
code: local notation "⟪" x ", " y "⟫" => @inner 𝕜 _ _ x y
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_termIK_1
code: local notation "IK" => @RCLike.I 𝕜 _
goal: Lean.Macro

full_name: «_aux_Mathlib_Analysis_InnerProductSpace_Basic___macroRules_term_†_1»
code: local postfix:90 "†" => starRingEnd _
goal: Lean.Macro

full_name: inner_conj_symm
code: @[simp]
theorem inner_conj_symm (x y : E) : ⟪y, x⟫† = ⟪x, y⟫ 
goal: (starRingEnd 𝕜) ⟪y, x⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: real_inner_comm
code: theorem real_inner_comm (x y : F) : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ 
goal: ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ

full_name: inner_eq_zero_symm
code: theorem inner_eq_zero_symm {x y : E} : ⟪x, y⟫ = 0 ↔ ⟪y, x⟫ = 0 
goal: ⟪x, y⟫_𝕜 = 0 ↔ ⟪y, x⟫_𝕜 = 0

full_name: inner_self_im
code: @[simp]
theorem inner_self_im (x : E) : im ⟪x, x⟫ = 0 
goal: RCLike.im ⟪x, x⟫_𝕜 = 0

full_name: inner_add_left
code: theorem inner_add_left (x y z : E) : ⟪x + y, z⟫ = ⟪x, z⟫ + ⟪y, z⟫ 
goal: ⟪x + y, z⟫_𝕜 = ⟪x, z⟫_𝕜 + ⟪y, z⟫_𝕜

full_name: inner_add_right
code: theorem inner_add_right (x y z : E) : ⟪x, y + z⟫ = ⟪x, y⟫ + ⟪x, z⟫ 
goal: ⟪x, y + z⟫_𝕜 = ⟪x, y⟫_𝕜 + ⟪x, z⟫_𝕜

full_name: inner_re_symm
code: theorem inner_re_symm (x y : E) : re ⟪x, y⟫ = re ⟪y, x⟫ 
goal: RCLike.re ⟪x, y⟫_𝕜 = RCLike.re ⟪y, x⟫_𝕜

full_name: inner_im_symm
code: theorem inner_im_symm (x y : E) : im ⟪x, y⟫ = -im ⟪y, x⟫ 
goal: RCLike.im ⟪x, y⟫_𝕜 = -RCLike.im ⟪y, x⟫_𝕜

full_name: inner_smul_left
code: theorem inner_smul_left (x y : E) (r : 𝕜) : ⟪r • x, y⟫ = r† * ⟪x, y⟫ 
goal: ⟪r • x, y⟫_𝕜 = (starRingEnd 𝕜) r * ⟪x, y⟫_𝕜

full_name: real_inner_smul_left
code: theorem real_inner_smul_left (x y : F) (r : ℝ) : ⟪r • x, y⟫_ℝ = r * ⟪x, y⟫_ℝ 
goal: ⟪r • x, y⟫_ℝ = r * ⟪x, y⟫_ℝ

full_name: inner_smul_real_left
code: theorem inner_smul_real_left (x y : E) (r : ℝ) : ⟪(r : 𝕜) • x, y⟫ = r • ⟪x, y⟫ 
goal: ⟪↑r • x, y⟫_𝕜 = r • ⟪x, y⟫_𝕜

full_name: inner_smul_right
code: theorem inner_smul_right (x y : E) (r : 𝕜) : ⟪x, r • y⟫ = r * ⟪x, y⟫ 
goal: ⟪x, r • y⟫_𝕜 = r * ⟪x, y⟫_𝕜

full_name: real_inner_smul_right
code: theorem real_inner_smul_right (x y : F) (r : ℝ) : ⟪x, r • y⟫_ℝ = r * ⟪x, y⟫_ℝ 
goal: ⟪x, r • y⟫_ℝ = r * ⟪x, y⟫_ℝ

full_name: inner_smul_real_right
code: theorem inner_smul_real_right (x y : E) (r : ℝ) : ⟪x, (r : 𝕜) • y⟫ = r • ⟪x, y⟫ 
goal: ⟪x, ↑r • y⟫_𝕜 = r • ⟪x, y⟫_𝕜

full_name: sesqFormOfInner
code: /-- The inner product as a sesquilinear form.

Note that in the case `𝕜 = ℝ` this is a bilinear form. -/
@[simps!]
def sesqFormOfInner : E →ₗ[𝕜] E →ₗ⋆[𝕜] 𝕜 
goal: E →ₗ[𝕜] E →ₗ⋆[𝕜] 𝕜

full_name: sesqFormOfInner_apply_apply
code: /-- The inner product as a sesquilinear form.

Note that in the case `𝕜 = ℝ` this is a bilinear form. -/
@[simps!]
def sesqFormOfInner : E →ₗ[𝕜] E →ₗ⋆[𝕜] 𝕜 
goal: (sesqFormOfInner m) y = ⟪y, m⟫_𝕜

full_name: bilinFormOfRealInner
code: /-- The real inner product as a bilinear form.

Note that unlike `sesqFormOfInner`, this does not reverse the order of the arguments. -/
@[simps!]
def bilinFormOfRealInner : BilinForm ℝ F 
goal: LinearMap.BilinForm ℝ F

full_name: bilinFormOfRealInner_apply_apply
code: /-- The real inner product as a bilinear form.

Note that unlike `sesqFormOfInner`, this does not reverse the order of the arguments. -/
@[simps!]
def bilinFormOfRealInner : BilinForm ℝ F 
goal: ∀ (m_1 : F), (bilinFormOfRealInner m) m_1 = ⟪m, m_1⟫_ℝ

full_name: sum_inner
code: /-- An inner product with a sum on the left. -/
theorem sum_inner {ι : Type*} (s : Finset ι) (f : ι → E) (x : E) :
    ⟪∑ i ∈ s, f i, x⟫ = ∑ i ∈ s, ⟪f i, x⟫ 
goal: ⟪∑ i ∈ s, f i, x⟫_𝕜 = ∑ i ∈ s, ⟪f i, x⟫_𝕜

full_name: inner_sum
code: /-- An inner product with a sum on the right. -/
theorem inner_sum {ι : Type*} (s : Finset ι) (f : ι → E) (x : E) :
    ⟪x, ∑ i ∈ s, f i⟫ = ∑ i ∈ s, ⟪x, f i⟫ 
goal: ⟪x, ∑ i ∈ s, f i⟫_𝕜 = ∑ i ∈ s, ⟪x, f i⟫_𝕜

full_name: Finsupp.sum_inner
code: /-- An inner product with a sum on the left, `Finsupp` version. -/
theorem Finsupp.sum_inner {ι : Type*} (l : ι →₀ 𝕜) (v : ι → E) (x : E) :
    ⟪l.sum fun (i : ι) (a : 𝕜) => a • v i, x⟫ = l.sum fun (i : ι) (a : 𝕜) => conj a • ⟪v i, x⟫ 
goal: ⟪l.sum fun i a => a • v i, x⟫_𝕜 = l.sum fun i a => (starRingEnd 𝕜) a • ⟪v i, x⟫_𝕜

full_name: Finsupp.inner_sum
code: /-- An inner product with a sum on the right, `Finsupp` version. -/
theorem Finsupp.inner_sum {ι : Type*} (l : ι →₀ 𝕜) (v : ι → E) (x : E) :
    ⟪x, l.sum fun (i : ι) (a : 𝕜) => a • v i⟫ = l.sum fun (i : ι) (a : 𝕜) => a • ⟪x, v i⟫ 
goal: ⟪x, l.sum fun i a => a • v i⟫_𝕜 = l.sum fun i a => a • ⟪x, v i⟫_𝕜

full_name: DFinsupp.sum_inner
code: theorem DFinsupp.sum_inner {ι : Type*} [DecidableEq ι] {α : ι → Type*}
    [∀ i, AddZeroClass (α i)] [∀ (i) (x : α i), Decidable (x ≠ 0)] (f : ∀ i, α i → E)
    (l : Π₀ i, α i) (x : E) : ⟪l.sum f, x⟫ = l.sum fun i a => ⟪f i a, x⟫ 
goal: ⟪l.sum f, x⟫_𝕜 = l.sum fun i a => ⟪f i a, x⟫_𝕜

full_name: DFinsupp.inner_sum
code: theorem DFinsupp.inner_sum {ι : Type*} [DecidableEq ι] {α : ι → Type*}
    [∀ i, AddZeroClass (α i)] [∀ (i) (x : α i), Decidable (x ≠ 0)] (f : ∀ i, α i → E)
    (l : Π₀ i, α i) (x : E) : ⟪x, l.sum f⟫ = l.sum fun i a => ⟪x, f i a⟫ 
goal: ⟪x, l.sum f⟫_𝕜 = l.sum fun i a => ⟪x, f i a⟫_𝕜

full_name: inner_zero_left
code: @[simp]
theorem inner_zero_left (x : E) : ⟪0, x⟫ = 0 
goal: ⟪0, x⟫_𝕜 = 0

full_name: inner_re_zero_left
code: theorem inner_re_zero_left (x : E) : re ⟪0, x⟫ = 0 
goal: RCLike.re ⟪0, x⟫_𝕜 = 0

full_name: inner_zero_right
code: @[simp]
theorem inner_zero_right (x : E) : ⟪x, 0⟫ = 0 
goal: ⟪x, 0⟫_𝕜 = 0

full_name: inner_re_zero_right
code: theorem inner_re_zero_right (x : E) : re ⟪x, 0⟫ = 0 
goal: RCLike.re ⟪x, 0⟫_𝕜 = 0

full_name: inner_self_nonneg
code: theorem inner_self_nonneg {x : E} : 0 ≤ re ⟪x, x⟫ 
goal: 0 ≤ RCLike.re ⟪x, x⟫_𝕜

full_name: real_inner_self_nonneg
code: theorem real_inner_self_nonneg {x : F} : 0 ≤ ⟪x, x⟫_ℝ 
goal: 0 ≤ ⟪x, x⟫_ℝ

full_name: inner_self_ofReal_re
code: @[simp]
theorem inner_self_ofReal_re (x : E) : (re ⟪x, x⟫ : 𝕜) = ⟪x, x⟫ 
goal: ↑(RCLike.re ⟪x, x⟫_𝕜) = ⟪x, x⟫_𝕜

full_name: inner_self_eq_norm_sq_to_K
code: theorem inner_self_eq_norm_sq_to_K (x : E) : ⟪x, x⟫ = (‖x‖ : 𝕜) ^ 2 
goal: ⟪x, x⟫_𝕜 = ↑‖x‖ ^ 2

full_name: inner_self_re_eq_norm
code: theorem inner_self_re_eq_norm (x : E) : re ⟪x, x⟫ = ‖⟪x, x⟫‖ 
goal: RCLike.re ⟪x, x⟫_𝕜 = ‖⟪x, x⟫_𝕜‖

full_name: inner_self_ofReal_norm
code: theorem inner_self_ofReal_norm (x : E) : (‖⟪x, x⟫‖ : 𝕜) = ⟪x, x⟫ 
goal: ↑‖⟪x, x⟫_𝕜‖ = ⟪x, x⟫_𝕜

full_name: real_inner_self_abs
code: theorem real_inner_self_abs (x : F) : |⟪x, x⟫_ℝ| = ⟪x, x⟫_ℝ 
goal: |⟪x, x⟫_ℝ| = ⟪x, x⟫_ℝ

full_name: inner_self_eq_zero
code: @[simp]
theorem inner_self_eq_zero {x : E} : ⟪x, x⟫ = 0 ↔ x = 0 
goal: ⟪x, x⟫_𝕜 = 0 ↔ x = 0

full_name: inner_self_ne_zero
code: theorem inner_self_ne_zero {x : E} : ⟪x, x⟫ ≠ 0 ↔ x ≠ 0 
goal: ⟪x, x⟫_𝕜 ≠ 0 ↔ x ≠ 0

full_name: inner_self_nonpos
code: @[simp]
theorem inner_self_nonpos {x : E} : re ⟪x, x⟫ ≤ 0 ↔ x = 0 
goal: RCLike.re ⟪x, x⟫_𝕜 ≤ 0 ↔ x = 0

full_name: real_inner_self_nonpos
code: theorem real_inner_self_nonpos {x : F} : ⟪x, x⟫_ℝ ≤ 0 ↔ x = 0 
goal: ⟪x, x⟫_ℝ ≤ 0 ↔ x = 0

full_name: norm_inner_symm
code: theorem norm_inner_symm (x y : E) : ‖⟪x, y⟫‖ = ‖⟪y, x⟫‖ 
goal: ‖⟪x, y⟫_𝕜‖ = ‖⟪y, x⟫_𝕜‖

full_name: inner_neg_left
code: @[simp]
theorem inner_neg_left (x y : E) : ⟪-x, y⟫ = -⟪x, y⟫ 
goal: ⟪-x, y⟫_𝕜 = -⟪x, y⟫_𝕜

full_name: inner_neg_right
code: @[simp]
theorem inner_neg_right (x y : E) : ⟪x, -y⟫ = -⟪x, y⟫ 
goal: ⟪x, -y⟫_𝕜 = -⟪x, y⟫_𝕜

full_name: inner_neg_neg
code: theorem inner_neg_neg (x y : E) : ⟪-x, -y⟫ = ⟪x, y⟫ 
goal: ⟪-x, -y⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: inner_self_conj
code: theorem inner_self_conj (x : E) : ⟪x, x⟫† = ⟪x, x⟫ 
goal: (starRingEnd 𝕜) ⟪x, x⟫_𝕜 = ⟪x, x⟫_𝕜

full_name: inner_sub_left
code: theorem inner_sub_left (x y z : E) : ⟪x - y, z⟫ = ⟪x, z⟫ - ⟪y, z⟫ 
goal: ⟪x - y, z⟫_𝕜 = ⟪x, z⟫_𝕜 - ⟪y, z⟫_𝕜

full_name: inner_sub_right
code: theorem inner_sub_right (x y z : E) : ⟪x, y - z⟫ = ⟪x, y⟫ - ⟪x, z⟫ 
goal: ⟪x, y - z⟫_𝕜 = ⟪x, y⟫_𝕜 - ⟪x, z⟫_𝕜

full_name: inner_mul_symm_re_eq_norm
code: theorem inner_mul_symm_re_eq_norm (x y : E) : re (⟪x, y⟫ * ⟪y, x⟫) = ‖⟪x, y⟫ * ⟪y, x⟫‖ 
goal: RCLike.re (⟪x, y⟫_𝕜 * ⟪y, x⟫_𝕜) = ‖⟪x, y⟫_𝕜 * ⟪y, x⟫_𝕜‖

full_name: inner_add_add_self
code: /-- Expand `⟪x + y, x + y⟫` -/
theorem inner_add_add_self (x y : E) : ⟪x + y, x + y⟫ = ⟪x, x⟫ + ⟪x, y⟫ + ⟪y, x⟫ + ⟪y, y⟫ 
goal: ⟪x + y, x + y⟫_𝕜 = ⟪x, x⟫_𝕜 + ⟪x, y⟫_𝕜 + ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜

full_name: real_inner_add_add_self
code: /-- Expand `⟪x + y, x + y⟫_ℝ` -/
theorem real_inner_add_add_self (x y : F) :
    ⟪x + y, x + y⟫_ℝ = ⟪x, x⟫_ℝ + 2 * ⟪x, y⟫_ℝ + ⟪y, y⟫_ℝ 
goal: ⟪x + y, x + y⟫_ℝ = ⟪x, x⟫_ℝ + 2 * ⟪x, y⟫_ℝ + ⟪y, y⟫_ℝ

full_name: inner_sub_sub_self
code: theorem inner_sub_sub_self (x y : E) : ⟪x - y, x - y⟫ = ⟪x, x⟫ - ⟪x, y⟫ - ⟪y, x⟫ + ⟪y, y⟫ 
goal: ⟪x - y, x - y⟫_𝕜 = ⟪x, x⟫_𝕜 - ⟪x, y⟫_𝕜 - ⟪y, x⟫_𝕜 + ⟪y, y⟫_𝕜

full_name: real_inner_sub_sub_self
code: /-- Expand `⟪x - y, x - y⟫_ℝ` -/
theorem real_inner_sub_sub_self (x y : F) :
    ⟪x - y, x - y⟫_ℝ = ⟪x, x⟫_ℝ - 2 * ⟪x, y⟫_ℝ + ⟪y, y⟫_ℝ 
goal: ⟪x - y, x - y⟫_ℝ = ⟪x, x⟫_ℝ - 2 * ⟪x, y⟫_ℝ + ⟪y, y⟫_ℝ

full_name: ext_inner_left
code: theorem ext_inner_left {x y : E} (h : ∀ v, ⟪v, x⟫ = ⟪v, y⟫) : x = y 
goal: x = y

full_name: ext_inner_right
code: theorem ext_inner_right {x y : E} (h : ∀ v, ⟪x, v⟫ = ⟪y, v⟫) : x = y 
goal: x = y

full_name: parallelogram_law
code: /-- Parallelogram law -/
theorem parallelogram_law {x y : E} : ⟪x + y, x + y⟫ + ⟪x - y, x - y⟫ = 2 * (⟪x, x⟫ + ⟪y, y⟫) 
goal: ⟪x + y, x + y⟫_𝕜 + ⟪x - y, x - y⟫_𝕜 = 2 * (⟪x, x⟫_𝕜 + ⟪y, y⟫_𝕜)

full_name: inner_mul_inner_self_le
code: /-- **Cauchy–Schwarz inequality**. -/
theorem inner_mul_inner_self_le (x y : E) : ‖⟪x, y⟫‖ * ‖⟪y, x⟫‖ ≤ re ⟪x, x⟫ * re ⟪y, y⟫ 
goal: ‖⟪x, y⟫_𝕜‖ * ‖⟪y, x⟫_𝕜‖ ≤ RCLike.re ⟪x, x⟫_𝕜 * RCLike.re ⟪y, y⟫_𝕜

full_name: real_inner_mul_inner_self_le
code: /-- Cauchy–Schwarz inequality for real inner products. -/
theorem real_inner_mul_inner_self_le (x y : F) : ⟪x, y⟫_ℝ * ⟪x, y⟫_ℝ ≤ ⟪x, x⟫_ℝ * ⟪y, y⟫_ℝ 
goal: ⟪x, y⟫_ℝ * ⟪x, y⟫_ℝ ≤ ⟪x, x⟫_ℝ * ⟪y, y⟫_ℝ

full_name: linearIndependent_of_ne_zero_of_inner_eq_zero
code: /-- A family of vectors is linearly independent if they are nonzero
and orthogonal. -/
theorem linearIndependent_of_ne_zero_of_inner_eq_zero {ι : Type*} {v : ι → E} (hz : ∀ i, v i ≠ 0)
    (ho : Pairwise fun i j => ⟪v i, v j⟫ = 0) : LinearIndependent 𝕜 v 
goal: LinearIndependent 𝕜 v

full_name: Orthonormal
code: /-- An orthonormal set of vectors in an `InnerProductSpace` -/
def Orthonormal (v : ι → E) : Prop 
goal: Prop

full_name: orthonormal_iff_ite
code: /-- `if ... then ... else` characterization of an indexed set of vectors being orthonormal.  (Inner
product equals Kronecker delta.) -/
theorem orthonormal_iff_ite [DecidableEq ι] {v : ι → E} :
    Orthonormal 𝕜 v ↔ ∀ i j, ⟪v i, v j⟫ = if i = j then (1 : 𝕜) else (0 : 𝕜) 
goal: Orthonormal 𝕜 v ↔ ∀ (i j : ι), ⟪v i, v j⟫_𝕜 = if i = j then 1 else 0

full_name: orthonormal_subtype_iff_ite
code: /-- `if ... then ... else` characterization of a set of vectors being orthonormal.  (Inner product
equals Kronecker delta.) -/
theorem orthonormal_subtype_iff_ite [DecidableEq E] {s : Set E} :
    Orthonormal 𝕜 (Subtype.val : s → E) ↔ ∀ v ∈ s, ∀ w ∈ s, ⟪v, w⟫ = if v = w then 1 else 0 
goal: Orthonormal 𝕜 Subtype.val ↔ ∀ v ∈ s, ∀ w ∈ s, ⟪v, w⟫_𝕜 = if v = w then 1 else 0

full_name: Orthonormal.inner_right_finsupp
code: /-- The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector. -/
theorem Orthonormal.inner_right_finsupp {v : ι → E} (hv : Orthonormal 𝕜 v) (l : ι →₀ 𝕜) (i : ι) :
    ⟪v i, Finsupp.total ι E 𝕜 v l⟫ = l i 
goal: ⟪v i, (Finsupp.total ι E 𝕜 v) l⟫_𝕜 = l i

full_name: Orthonormal.inner_right_sum
code: /-- The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector. -/
theorem Orthonormal.inner_right_sum {v : ι → E} (hv : Orthonormal 𝕜 v) (l : ι → 𝕜) {s : Finset ι}
    {i : ι} (hi : i ∈ s) : ⟪v i, ∑ i ∈ s, l i • v i⟫ = l i 
goal: ⟪v i, ∑ i ∈ s, l i • v i⟫_𝕜 = l i

full_name: Orthonormal.inner_right_fintype
code: /-- The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector. -/
theorem Orthonormal.inner_right_fintype [Fintype ι] {v : ι → E} (hv : Orthonormal 𝕜 v) (l : ι → 𝕜)
    (i : ι) : ⟪v i, ∑ i : ι, l i • v i⟫ = l i 
goal: ⟪v i, ∑ i : ι, l i • v i⟫_𝕜 = l i

full_name: Orthonormal.inner_left_finsupp
code: /-- The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector. -/
theorem Orthonormal.inner_left_finsupp {v : ι → E} (hv : Orthonormal 𝕜 v) (l : ι →₀ 𝕜) (i : ι) :
    ⟪Finsupp.total ι E 𝕜 v l, v i⟫ = conj (l i) 
goal: ⟪(Finsupp.total ι E 𝕜 v) l, v i⟫_𝕜 = (starRingEnd 𝕜) (l i)

full_name: Orthonormal.inner_left_sum
code: /-- The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector. -/
theorem Orthonormal.inner_left_sum {v : ι → E} (hv : Orthonormal 𝕜 v) (l : ι → 𝕜) {s : Finset ι}
    {i : ι} (hi : i ∈ s) : ⟪∑ i ∈ s, l i • v i, v i⟫ = conj (l i) 
goal: ⟪∑ i ∈ s, l i • v i, v i⟫_𝕜 = (starRingEnd 𝕜) (l i)

full_name: Orthonormal.inner_left_fintype
code: /-- The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector. -/
theorem Orthonormal.inner_left_fintype [Fintype ι] {v : ι → E} (hv : Orthonormal 𝕜 v) (l : ι → 𝕜)
    (i : ι) : ⟪∑ i : ι, l i • v i, v i⟫ = conj (l i) 
goal: ⟪∑ i : ι, l i • v i, v i⟫_𝕜 = (starRingEnd 𝕜) (l i)

full_name: Orthonormal.inner_finsupp_eq_sum_left
code: /-- The inner product of two linear combinations of a set of orthonormal vectors, expressed as
a sum over the first `Finsupp`. -/
theorem Orthonormal.inner_finsupp_eq_sum_left {v : ι → E} (hv : Orthonormal 𝕜 v) (l₁ l₂ : ι →₀ 𝕜) :
    ⟪Finsupp.total ι E 𝕜 v l₁, Finsupp.total ι E 𝕜 v l₂⟫ = l₁.sum fun i y => conj y * l₂ i 
goal: ⟪(Finsupp.total ι E 𝕜 v) l₁, (Finsupp.total ι E 𝕜 v) l₂⟫_𝕜 = l₁.sum fun i y => (starRingEnd 𝕜) y * l₂ i

full_name: Orthonormal.inner_finsupp_eq_sum_right
code: /-- The inner product of two linear combinations of a set of orthonormal vectors, expressed as
a sum over the second `Finsupp`. -/
theorem Orthonormal.inner_finsupp_eq_sum_right {v : ι → E} (hv : Orthonormal 𝕜 v) (l₁ l₂ : ι →₀ 𝕜) :
    ⟪Finsupp.total ι E 𝕜 v l₁, Finsupp.total ι E 𝕜 v l₂⟫ = l₂.sum fun i y => conj (l₁ i) * y 
goal: ⟪(Finsupp.total ι E 𝕜 v) l₁, (Finsupp.total ι E 𝕜 v) l₂⟫_𝕜 = l₂.sum fun i y => (starRingEnd 𝕜) (l₁ i) * y

full_name: Orthonormal.inner_sum
code: /-- The inner product of two linear combinations of a set of orthonormal vectors, expressed as
a sum. -/
theorem Orthonormal.inner_sum {v : ι → E} (hv : Orthonormal 𝕜 v) (l₁ l₂ : ι → 𝕜) (s : Finset ι) :
    ⟪∑ i ∈ s, l₁ i • v i, ∑ i ∈ s, l₂ i • v i⟫ = ∑ i ∈ s, conj (l₁ i) * l₂ i 
goal: ⟪∑ i ∈ s, l₁ i • v i, ∑ i ∈ s, l₂ i • v i⟫_𝕜 = ∑ i ∈ s, (starRingEnd 𝕜) (l₁ i) * l₂ i

full_name: Orthonormal.inner_left_right_finset
code: /--
The double sum of weighted inner products of pairs of vectors from an orthonormal sequence is the
sum of the weights.
-/
theorem Orthonormal.inner_left_right_finset {s : Finset ι} {v : ι → E} (hv : Orthonormal 𝕜 v)
    {a : ι → ι → 𝕜} : (∑ i ∈ s, ∑ j ∈ s, a i j • ⟪v j, v i⟫) = ∑ k ∈ s, a k k 
goal: ∑ i ∈ s, ∑ j ∈ s, a i j • ⟪v j, v i⟫_𝕜 = ∑ k ∈ s, a k k

full_name: Orthonormal.linearIndependent
code: /-- An orthonormal set is linearly independent. -/
theorem Orthonormal.linearIndependent {v : ι → E} (hv : Orthonormal 𝕜 v) :
    LinearIndependent 𝕜 v 
goal: LinearIndependent 𝕜 v

full_name: Orthonormal.comp
code: /-- A subfamily of an orthonormal family (i.e., a composition with an injective map) is an
orthonormal family. -/
theorem Orthonormal.comp {ι' : Type*} {v : ι → E} (hv : Orthonormal 𝕜 v) (f : ι' → ι)
    (hf : Function.Injective f) : Orthonormal 𝕜 (v ∘ f) 
goal: Orthonormal 𝕜 (v ∘ f)

full_name: orthonormal_subtype_range
code: /-- An injective family `v : ι → E` is orthonormal if and only if `Subtype.val : (range v) → E` is
orthonormal. -/
theorem orthonormal_subtype_range {v : ι → E} (hv : Function.Injective v) :
    Orthonormal 𝕜 (Subtype.val : Set.range v → E) ↔ Orthonormal 𝕜 v 
goal: Orthonormal 𝕜 Subtype.val ↔ Orthonormal 𝕜 v

full_name: Orthonormal.toSubtypeRange
code: /-- If `v : ι → E` is an orthonormal family, then `Subtype.val : (range v) → E` is an orthonormal
family. -/
theorem Orthonormal.toSubtypeRange {v : ι → E} (hv : Orthonormal 𝕜 v) :
    Orthonormal 𝕜 (Subtype.val : Set.range v → E) 
goal: Orthonormal 𝕜 Subtype.val

full_name: Orthonormal.inner_finsupp_eq_zero
code: /-- A linear combination of some subset of an orthonormal set is orthogonal to other members of the
set. -/
theorem Orthonormal.inner_finsupp_eq_zero {v : ι → E} (hv : Orthonormal 𝕜 v) {s : Set ι} {i : ι}
    (hi : i ∉ s) {l : ι →₀ 𝕜} (hl : l ∈ Finsupp.supported 𝕜 𝕜 s) :
    ⟪Finsupp.total ι E 𝕜 v l, v i⟫ = 0 
goal: ⟪(Finsupp.total ι E 𝕜 v) l, v i⟫_𝕜 = 0

full_name: Orthonormal.orthonormal_of_forall_eq_or_eq_neg
code: /-- Given an orthonormal family, a second family of vectors is orthonormal if every vector equals
the corresponding vector in the original family or its negation. -/
theorem Orthonormal.orthonormal_of_forall_eq_or_eq_neg {v w : ι → E} (hv : Orthonormal 𝕜 v)
    (hw : ∀ i, w i = v i ∨ w i = -v i) : Orthonormal 𝕜 w 
goal: Orthonormal 𝕜 w

full_name: orthonormal_empty
code: theorem orthonormal_empty : Orthonormal 𝕜 (fun x => x : (∅ : Set E) → E) 
goal: Orthonormal 𝕜 fun x => ↑x

full_name: orthonormal_iUnion_of_directed
code: theorem orthonormal_iUnion_of_directed {η : Type*} {s : η → Set E} (hs : Directed (· ⊆ ·) s)
    (h : ∀ i, Orthonormal 𝕜 (fun x => x : s i → E)) :
    Orthonormal 𝕜 (fun x => x : (⋃ i, s i) → E) 
goal: Orthonormal 𝕜 fun x => ↑x

full_name: orthonormal_sUnion_of_directed
code: theorem orthonormal_sUnion_of_directed {s : Set (Set E)} (hs : DirectedOn (· ⊆ ·) s)
    (h : ∀ a ∈ s, Orthonormal 𝕜 (fun x => ((x : a) : E))) :
    Orthonormal 𝕜 (fun x => x : ⋃₀ s → E) 
goal: Orthonormal 𝕜 fun x => ↑x

full_name: exists_maximal_orthonormal
code: /-- Given an orthonormal set `v` of vectors in `E`, there exists a maximal orthonormal set
containing it. -/
theorem exists_maximal_orthonormal {s : Set E} (hs : Orthonormal 𝕜 (Subtype.val : s → E)) :
    ∃ w ⊇ s, Orthonormal 𝕜 (Subtype.val : w → E) ∧
      ∀ u ⊇ w, Orthonormal 𝕜 (Subtype.val : u → E) → u = w 
goal: ∃ w ⊇ s, Orthonormal 𝕜 Subtype.val ∧ ∀ u ⊇ w, Orthonormal 𝕜 Subtype.val → u = w

full_name: Orthonormal.ne_zero
code: theorem Orthonormal.ne_zero {v : ι → E} (hv : Orthonormal 𝕜 v) (i : ι) : v i ≠ 0 
goal: v i ≠ 0

full_name: basisOfOrthonormalOfCardEqFinrank
code: /-- A family of orthonormal vectors with the correct cardinality forms a basis. -/
def basisOfOrthonormalOfCardEqFinrank [Fintype ι] [Nonempty ι] {v : ι → E} (hv : Orthonormal 𝕜 v)
    (card_eq : Fintype.card ι = finrank 𝕜 E) : Basis ι 𝕜 E 
goal: Basis ι 𝕜 E

full_name: coe_basisOfOrthonormalOfCardEqFinrank
code: @[simp]
theorem coe_basisOfOrthonormalOfCardEqFinrank [Fintype ι] [Nonempty ι] {v : ι → E}
    (hv : Orthonormal 𝕜 v) (card_eq : Fintype.card ι = finrank 𝕜 E) :
    (basisOfOrthonormalOfCardEqFinrank hv card_eq : ι → E) = v 
goal: ⇑(basisOfOrthonormalOfCardEqFinrank hv card_eq) = v

full_name: norm_eq_sqrt_inner
code: theorem norm_eq_sqrt_inner (x : E) : ‖x‖ = √(re ⟪x, x⟫) 
goal: ‖x‖ = √(RCLike.re ⟪x, x⟫_𝕜)

full_name: norm_eq_sqrt_real_inner
code: theorem norm_eq_sqrt_real_inner (x : F) : ‖x‖ = √⟪x, x⟫_ℝ 
goal: ‖x‖ = √⟪x, x⟫_ℝ

full_name: inner_self_eq_norm_mul_norm
code: theorem inner_self_eq_norm_mul_norm (x : E) : re ⟪x, x⟫ = ‖x‖ * ‖x‖ 
goal: RCLike.re ⟪x, x⟫_𝕜 = ‖x‖ * ‖x‖

full_name: inner_self_eq_norm_sq
code: theorem inner_self_eq_norm_sq (x : E) : re ⟪x, x⟫ = ‖x‖ ^ 2 
goal: RCLike.re ⟪x, x⟫_𝕜 = ‖x‖ ^ 2

full_name: real_inner_self_eq_norm_mul_norm
code: theorem real_inner_self_eq_norm_mul_norm (x : F) : ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖ 
goal: ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖

full_name: real_inner_self_eq_norm_sq
code: theorem real_inner_self_eq_norm_sq (x : F) : ⟪x, x⟫_ℝ = ‖x‖ ^ 2 
goal: ⟪x, x⟫_ℝ = ‖x‖ ^ 2

full_name: norm_add_sq
code: /-- Expand the square -/
theorem norm_add_sq (x y : E) : ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * re ⟪x, y⟫ + ‖y‖ ^ 2 
goal: ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * RCLike.re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2

full_name: norm_add_sq_real
code: /-- Expand the square -/
theorem norm_add_sq_real (x y : F) : ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2 
goal: ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2

full_name: norm_add_mul_self
code: /-- Expand the square -/
theorem norm_add_mul_self (x y : E) :
    ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * re ⟪x, y⟫ + ‖y‖ * ‖y‖ 
goal: ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * RCLike.re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖

full_name: norm_add_mul_self_real
code: /-- Expand the square -/
theorem norm_add_mul_self_real (x y : F) :
    ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖ 
goal: ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖

full_name: norm_sub_sq
code: /-- Expand the square -/
theorem norm_sub_sq (x y : E) : ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * re ⟪x, y⟫ + ‖y‖ ^ 2 
goal: ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * RCLike.re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2

full_name: norm_sub_sq_real
code: /-- Expand the square -/
theorem norm_sub_sq_real (x y : F) : ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2 
goal: ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * ⟪x, y⟫_ℝ + ‖y‖ ^ 2

full_name: norm_sub_mul_self
code: /-- Expand the square -/
theorem norm_sub_mul_self (x y : E) :
    ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ - 2 * re ⟪x, y⟫ + ‖y‖ * ‖y‖ 
goal: ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ - 2 * RCLike.re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖

full_name: norm_sub_mul_self_real
code: /-- Expand the square -/
theorem norm_sub_mul_self_real (x y : F) :
    ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ - 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖ 
goal: ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ - 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖

full_name: norm_inner_le_norm
code: /-- Cauchy–Schwarz inequality with norm -/
theorem norm_inner_le_norm (x y : E) : ‖⟪x, y⟫‖ ≤ ‖x‖ * ‖y‖ 
goal: ‖⟪x, y⟫_𝕜‖ ≤ ‖x‖ * ‖y‖

full_name: nnnorm_inner_le_nnnorm
code: theorem nnnorm_inner_le_nnnorm (x y : E) : ‖⟪x, y⟫‖₊ ≤ ‖x‖₊ * ‖y‖₊ 
goal: ‖⟪x, y⟫_𝕜‖₊ ≤ ‖x‖₊ * ‖y‖₊

full_name: re_inner_le_norm
code: theorem re_inner_le_norm (x y : E) : re ⟪x, y⟫ ≤ ‖x‖ * ‖y‖ 
goal: RCLike.re ⟪x, y⟫_𝕜 ≤ ‖x‖ * ‖y‖

full_name: abs_real_inner_le_norm
code: /-- Cauchy–Schwarz inequality with norm -/
theorem abs_real_inner_le_norm (x y : F) : |⟪x, y⟫_ℝ| ≤ ‖x‖ * ‖y‖ 
goal: |⟪x, y⟫_ℝ| ≤ ‖x‖ * ‖y‖

full_name: real_inner_le_norm
code: /-- Cauchy–Schwarz inequality with norm -/
theorem real_inner_le_norm (x y : F) : ⟪x, y⟫_ℝ ≤ ‖x‖ * ‖y‖ 
goal: ⟪x, y⟫_ℝ ≤ ‖x‖ * ‖y‖

full_name: parallelogram_law_with_norm
code: theorem parallelogram_law_with_norm (x y : E) :
    ‖x + y‖ * ‖x + y‖ + ‖x - y‖ * ‖x - y‖ = 2 * (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) 
goal: ‖x + y‖ * ‖x + y‖ + ‖x - y‖ * ‖x - y‖ = 2 * (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖)

full_name: parallelogram_law_with_nnnorm
code: theorem parallelogram_law_with_nnnorm (x y : E) :
    ‖x + y‖₊ * ‖x + y‖₊ + ‖x - y‖₊ * ‖x - y‖₊ = 2 * (‖x‖₊ * ‖x‖₊ + ‖y‖₊ * ‖y‖₊) 
goal: ‖x + y‖₊ * ‖x + y‖₊ + ‖x - y‖₊ * ‖x - y‖₊ = 2 * (‖x‖₊ * ‖x‖₊ + ‖y‖₊ * ‖y‖₊)

full_name: re_inner_eq_norm_add_mul_self_sub_norm_mul_self_sub_norm_mul_self_div_two
code: /-- Polarization identity: The real part of the inner product, in terms of the norm. -/
theorem re_inner_eq_norm_add_mul_self_sub_norm_mul_self_sub_norm_mul_self_div_two (x y : E) :
    re ⟪x, y⟫ = (‖x + y‖ * ‖x + y‖ - ‖x‖ * ‖x‖ - ‖y‖ * ‖y‖) / 2 
goal: RCLike.re ⟪x, y⟫_𝕜 = (‖x + y‖ * ‖x + y‖ - ‖x‖ * ‖x‖ - ‖y‖ * ‖y‖) / 2

full_name: re_inner_eq_norm_mul_self_add_norm_mul_self_sub_norm_sub_mul_self_div_two
code: /-- Polarization identity: The real part of the inner product, in terms of the norm. -/
theorem re_inner_eq_norm_mul_self_add_norm_mul_self_sub_norm_sub_mul_self_div_two (x y : E) :
    re ⟪x, y⟫ = (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ - ‖x - y‖ * ‖x - y‖) / 2 
goal: RCLike.re ⟪x, y⟫_𝕜 = (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ - ‖x - y‖ * ‖x - y‖) / 2

full_name: re_inner_eq_norm_add_mul_self_sub_norm_sub_mul_self_div_four
code: /-- Polarization identity: The real part of the inner product, in terms of the norm. -/
theorem re_inner_eq_norm_add_mul_self_sub_norm_sub_mul_self_div_four (x y : E) :
    re ⟪x, y⟫ = (‖x + y‖ * ‖x + y‖ - ‖x - y‖ * ‖x - y‖) / 4 
goal: RCLike.re ⟪x, y⟫_𝕜 = (‖x + y‖ * ‖x + y‖ - ‖x - y‖ * ‖x - y‖) / 4

full_name: im_inner_eq_norm_sub_i_smul_mul_self_sub_norm_add_i_smul_mul_self_div_four
code: /-- Polarization identity: The imaginary part of the inner product, in terms of the norm. -/
theorem im_inner_eq_norm_sub_i_smul_mul_self_sub_norm_add_i_smul_mul_self_div_four (x y : E) :
    im ⟪x, y⟫ = (‖x - IK • y‖ * ‖x - IK • y‖ - ‖x + IK • y‖ * ‖x + IK • y‖) / 4 
goal: RCLike.im ⟪x, y⟫_𝕜 = (‖x - RCLike.I • y‖ * ‖x - RCLike.I • y‖ - ‖x + RCLike.I • y‖ * ‖x + RCLike.I • y‖) / 4

full_name: inner_eq_sum_norm_sq_div_four
code: /-- Polarization identity: The inner product, in terms of the norm. -/
theorem inner_eq_sum_norm_sq_div_four (x y : E) :
    ⟪x, y⟫ = ((‖x + y‖ : 𝕜) ^ 2 - (‖x - y‖ : 𝕜) ^ 2 +
              ((‖x - IK • y‖ : 𝕜) ^ 2 - (‖x + IK • y‖ : 𝕜) ^ 2) * IK) / 4 
goal: ⟪x, y⟫_𝕜 = (↑‖x + y‖ ^ 2 - ↑‖x - y‖ ^ 2 + (↑‖x - RCLike.I • y‖ ^ 2 - ↑‖x + RCLike.I • y‖ ^ 2) * RCLike.I) / 4

full_name: dist_div_norm_sq_smul
code: /-- Formula for the distance between the images of two nonzero points under an inversion with center
zero. See also `EuclideanGeometry.dist_inversion_inversion` for inversions around a general
point. -/
theorem dist_div_norm_sq_smul {x y : F} (hx : x ≠ 0) (hy : y ≠ 0) (R : ℝ) :
    dist ((R / ‖x‖) ^ 2 • x) ((R / ‖y‖) ^ 2 • y) = R ^ 2 / (‖x‖ * ‖y‖) * dist x y 
goal: dist ((R / ‖x‖) ^ 2 • x) ((R / ‖y‖) ^ 2 • y) = R ^ 2 / (‖x‖ * ‖y‖) * dist x y

full_name: InnerProductSpace.toUniformConvexSpace
code: instance (priority := 100) InnerProductSpace.toUniformConvexSpace : UniformConvexSpace F 
goal: UniformConvexSpace F

full_name: inner_map_polarization
code: /-- A complex polarization identity, with a linear map
-/
theorem inner_map_polarization (T : V →ₗ[ℂ] V) (x y : V) :
    ⟪T y, x⟫_ℂ =
      (⟪T (x + y), x + y⟫_ℂ - ⟪T (x - y), x - y⟫_ℂ +
            Complex.I * ⟪T (x + Complex.I • y), x + Complex.I • y⟫_ℂ -
          Complex.I * ⟪T (x - Complex.I • y), x - Complex.I • y⟫_ℂ) /
        4 
goal: ⟪T y, x⟫_ℂ =
  (⟪T (x + y), x + y⟫_ℂ - ⟪T (x - y), x - y⟫_ℂ + Complex.I * ⟪T (x + Complex.I • y), x + Complex.I • y⟫_ℂ -
      Complex.I * ⟪T (x - Complex.I • y), x - Complex.I • y⟫_ℂ) /
    4

full_name: inner_map_polarization'
code: theorem inner_map_polarization' (T : V →ₗ[ℂ] V) (x y : V) :
    ⟪T x, y⟫_ℂ =
      (⟪T (x + y), x + y⟫_ℂ - ⟪T (x - y), x - y⟫_ℂ -
            Complex.I * ⟪T (x + Complex.I • y), x + Complex.I • y⟫_ℂ +
          Complex.I * ⟪T (x - Complex.I • y), x - Complex.I • y⟫_ℂ) /
        4 
goal: ⟪T x, y⟫_ℂ =
  (⟪T (x + y), x + y⟫_ℂ - ⟪T (x - y), x - y⟫_ℂ - Complex.I * ⟪T (x + Complex.I • y), x + Complex.I • y⟫_ℂ +
      Complex.I * ⟪T (x - Complex.I • y), x - Complex.I • y⟫_ℂ) /
    4

full_name: inner_map_self_eq_zero
code: /-- A linear map `T` is zero, if and only if the identity `⟪T x, x⟫_ℂ = 0` holds for all `x`.
-/
theorem inner_map_self_eq_zero (T : V →ₗ[ℂ] V) : (∀ x : V, ⟪T x, x⟫_ℂ = 0) ↔ T = 0 
goal: (∀ (x : V), ⟪T x, x⟫_ℂ = 0) ↔ T = 0

full_name: ext_inner_map
code: /--
Two linear maps `S` and `T` are equal, if and only if the identity `⟪S x, x⟫_ℂ = ⟪T x, x⟫_ℂ` holds
for all `x`.
-/
theorem ext_inner_map (S T : V →ₗ[ℂ] V) : (∀ x : V, ⟪S x, x⟫_ℂ = ⟪T x, x⟫_ℂ) ↔ S = T 
goal: (∀ (x : V), ⟪S x, x⟫_ℂ = ⟪T x, x⟫_ℂ) ↔ S = T

full_name: LinearIsometry.inner_map_map
code: /-- A linear isometry preserves the inner product. -/
@[simp]
theorem LinearIsometry.inner_map_map (f : E →ₗᵢ[𝕜] E') (x y : E) : ⟪f x, f y⟫ = ⟪x, y⟫ 
goal: ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: LinearIsometryEquiv.inner_map_map
code: /-- A linear isometric equivalence preserves the inner product. -/
@[simp]
theorem LinearIsometryEquiv.inner_map_map (f : E ≃ₗᵢ[𝕜] E') (x y : E) : ⟪f x, f y⟫ = ⟪x, y⟫ 
goal: ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: LinearIsometryEquiv.inner_map_eq_flip
code: /-- The adjoint of a linear isometric equivalence is its inverse. -/
theorem LinearIsometryEquiv.inner_map_eq_flip (f : E ≃ₗᵢ[𝕜] E') (x : E) (y : E') :
    ⟪f x, y⟫_𝕜 = ⟪x, f.symm y⟫_𝕜 
goal: ⟪f x, y⟫_𝕜 = ⟪x, f.symm y⟫_𝕜

full_name: LinearMap.isometryOfInner
code: /-- A linear map that preserves the inner product is a linear isometry. -/
def LinearMap.isometryOfInner (f : E →ₗ[𝕜] E') (h : ∀ x y, ⟪f x, f y⟫ = ⟪x, y⟫) : E →ₗᵢ[𝕜] E' 
goal: E →ₗᵢ[𝕜] E'

full_name: LinearMap.coe_isometryOfInner
code: @[simp]
theorem LinearMap.coe_isometryOfInner (f : E →ₗ[𝕜] E') (h) : ⇑(f.isometryOfInner h) = f 
goal: ⇑(f.isometryOfInner h) = ⇑f

full_name: LinearMap.isometryOfInner_toLinearMap
code: @[simp]
theorem LinearMap.isometryOfInner_toLinearMap (f : E →ₗ[𝕜] E') (h) :
    (f.isometryOfInner h).toLinearMap = f 
goal: (f.isometryOfInner h).toLinearMap = f

full_name: LinearEquiv.isometryOfInner
code: /-- A linear equivalence that preserves the inner product is a linear isometric equivalence. -/
def LinearEquiv.isometryOfInner (f : E ≃ₗ[𝕜] E') (h : ∀ x y, ⟪f x, f y⟫ = ⟪x, y⟫) : E ≃ₗᵢ[𝕜] E' 
goal: E ≃ₗᵢ[𝕜] E'

full_name: LinearEquiv.coe_isometryOfInner
code: @[simp]
theorem LinearEquiv.coe_isometryOfInner (f : E ≃ₗ[𝕜] E') (h) : ⇑(f.isometryOfInner h) = f 
goal: ⇑(f.isometryOfInner h) = ⇑f

full_name: LinearEquiv.isometryOfInner_toLinearEquiv
code: @[simp]
theorem LinearEquiv.isometryOfInner_toLinearEquiv (f : E ≃ₗ[𝕜] E') (h) :
    (f.isometryOfInner h).toLinearEquiv = f 
goal: (f.isometryOfInner h).toLinearEquiv = f

full_name: LinearMap.norm_map_iff_inner_map_map
code: /-- A linear map is an isometry if and it preserves the inner product. -/
theorem LinearMap.norm_map_iff_inner_map_map {F : Type*} [FunLike F E E'] [LinearMapClass F 𝕜 E E']
    (f : F) : (∀ x, ‖f x‖ = ‖x‖) ↔ (∀ x y, ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜) 
goal: (∀ (x : E), ‖f x‖ = ‖x‖) ↔ ∀ (x y : E), ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: LinearIsometry.orthonormal_comp_iff
code: /-- A linear isometry preserves the property of being orthonormal. -/
theorem LinearIsometry.orthonormal_comp_iff {v : ι → E} (f : E →ₗᵢ[𝕜] E') :
    Orthonormal 𝕜 (f ∘ v) ↔ Orthonormal 𝕜 v 
goal: Orthonormal 𝕜 (⇑f ∘ v) ↔ Orthonormal 𝕜 v

full_name: Orthonormal.comp_linearIsometry
code: /-- A linear isometry preserves the property of being orthonormal. -/
theorem Orthonormal.comp_linearIsometry {v : ι → E} (hv : Orthonormal 𝕜 v) (f : E →ₗᵢ[𝕜] E') :
    Orthonormal 𝕜 (f ∘ v) 
goal: Orthonormal 𝕜 (⇑f ∘ v)

full_name: Orthonormal.comp_linearIsometryEquiv
code: /-- A linear isometric equivalence preserves the property of being orthonormal. -/
theorem Orthonormal.comp_linearIsometryEquiv {v : ι → E} (hv : Orthonormal 𝕜 v) (f : E ≃ₗᵢ[𝕜] E') :
    Orthonormal 𝕜 (f ∘ v) 
goal: Orthonormal 𝕜 (⇑f ∘ v)

full_name: Orthonormal.mapLinearIsometryEquiv
code: /-- A linear isometric equivalence, applied with `Basis.map`, preserves the property of being
orthonormal. -/
theorem Orthonormal.mapLinearIsometryEquiv {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v)
    (f : E ≃ₗᵢ[𝕜] E') : Orthonormal 𝕜 (v.map f.toLinearEquiv) 
goal: Orthonormal 𝕜 ⇑(v.map f.toLinearEquiv)

full_name: LinearMap.isometryOfOrthonormal
code: /-- A linear map that sends an orthonormal basis to orthonormal vectors is a linear isometry. -/
def LinearMap.isometryOfOrthonormal (f : E →ₗ[𝕜] E') {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v)
    (hf : Orthonormal 𝕜 (f ∘ v)) : E →ₗᵢ[𝕜] E' 
goal: E →ₗᵢ[𝕜] E'

full_name: LinearMap.coe_isometryOfOrthonormal
code: @[simp]
theorem LinearMap.coe_isometryOfOrthonormal (f : E →ₗ[𝕜] E') {v : Basis ι 𝕜 E}
    (hv : Orthonormal 𝕜 v) (hf : Orthonormal 𝕜 (f ∘ v)) : ⇑(f.isometryOfOrthonormal hv hf) = f 
goal: ⇑(f.isometryOfOrthonormal hv hf) = ⇑f

full_name: LinearMap.isometryOfOrthonormal_toLinearMap
code: @[simp]
theorem LinearMap.isometryOfOrthonormal_toLinearMap (f : E →ₗ[𝕜] E') {v : Basis ι 𝕜 E}
    (hv : Orthonormal 𝕜 v) (hf : Orthonormal 𝕜 (f ∘ v)) :
    (f.isometryOfOrthonormal hv hf).toLinearMap = f 
goal: (f.isometryOfOrthonormal hv hf).toLinearMap = f

full_name: LinearEquiv.isometryOfOrthonormal
code: /-- A linear equivalence that sends an orthonormal basis to orthonormal vectors is a linear
isometric equivalence. -/
def LinearEquiv.isometryOfOrthonormal (f : E ≃ₗ[𝕜] E') {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v)
    (hf : Orthonormal 𝕜 (f ∘ v)) : E ≃ₗᵢ[𝕜] E' 
goal: E ≃ₗᵢ[𝕜] E'

full_name: LinearEquiv.coe_isometryOfOrthonormal
code: @[simp]
theorem LinearEquiv.coe_isometryOfOrthonormal (f : E ≃ₗ[𝕜] E') {v : Basis ι 𝕜 E}
    (hv : Orthonormal 𝕜 v) (hf : Orthonormal 𝕜 (f ∘ v)) : ⇑(f.isometryOfOrthonormal hv hf) = f 
goal: ⇑(f.isometryOfOrthonormal hv hf) = ⇑f

full_name: LinearEquiv.isometryOfOrthonormal_toLinearEquiv
code: @[simp]
theorem LinearEquiv.isometryOfOrthonormal_toLinearEquiv (f : E ≃ₗ[𝕜] E') {v : Basis ι 𝕜 E}
    (hv : Orthonormal 𝕜 v) (hf : Orthonormal 𝕜 (f ∘ v)) :
    (f.isometryOfOrthonormal hv hf).toLinearEquiv = f 
goal: (f.isometryOfOrthonormal hv hf).toLinearEquiv = f

full_name: Orthonormal.equiv
code: /-- A linear isometric equivalence that sends an orthonormal basis to a given orthonormal basis. -/
def Orthonormal.equiv {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v) {v' : Basis ι' 𝕜 E'}
    (hv' : Orthonormal 𝕜 v') (e : ι ≃ ι') : E ≃ₗᵢ[𝕜] E' 
goal: E ≃ₗᵢ[𝕜] E'

full_name: Orthonormal.equiv_toLinearEquiv
code: @[simp]
theorem Orthonormal.equiv_toLinearEquiv {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v)
    {v' : Basis ι' 𝕜 E'} (hv' : Orthonormal 𝕜 v') (e : ι ≃ ι') :
    (hv.equiv hv' e).toLinearEquiv = v.equiv v' e 
goal: (hv.equiv hv' e).toLinearEquiv = v.equiv v' e

full_name: Orthonormal.equiv_apply
code: @[simp]
theorem Orthonormal.equiv_apply {ι' : Type*} {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v)
    {v' : Basis ι' 𝕜 E'} (hv' : Orthonormal 𝕜 v') (e : ι ≃ ι') (i : ι) :
    hv.equiv hv' e (v i) = v' (e i) 
goal: (hv.equiv hv' e) (v i) = v' (e i)

full_name: Orthonormal.equiv_refl
code: @[simp]
theorem Orthonormal.equiv_refl {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v) :
    hv.equiv hv (Equiv.refl ι) = LinearIsometryEquiv.refl 𝕜 E 
goal: hv.equiv hv (Equiv.refl ι) = LinearIsometryEquiv.refl 𝕜 E

full_name: Orthonormal.equiv_symm
code: @[simp]
theorem Orthonormal.equiv_symm {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v) {v' : Basis ι' 𝕜 E'}
    (hv' : Orthonormal 𝕜 v') (e : ι ≃ ι') : (hv.equiv hv' e).symm = hv'.equiv hv e.symm 
goal: (hv.equiv hv' e).symm = hv'.equiv hv e.symm

full_name: Orthonormal.equiv_trans
code: @[simp]
theorem Orthonormal.equiv_trans {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v) {v' : Basis ι' 𝕜 E'}
    (hv' : Orthonormal 𝕜 v') (e : ι ≃ ι') {v'' : Basis ι'' 𝕜 E''} (hv'' : Orthonormal 𝕜 v'')
    (e' : ι' ≃ ι'') : (hv.equiv hv' e).trans (hv'.equiv hv'' e') = hv.equiv hv'' (e.trans e') 
goal: (hv.equiv hv' e).trans (hv'.equiv hv'' e') = hv.equiv hv'' (e.trans e')

full_name: Orthonormal.map_equiv
code: theorem Orthonormal.map_equiv {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v) {v' : Basis ι' 𝕜 E'}
    (hv' : Orthonormal 𝕜 v') (e : ι ≃ ι') :
    v.map (hv.equiv hv' e).toLinearEquiv = v'.reindex e.symm 
goal: v.map (hv.equiv hv' e).toLinearEquiv = v'.reindex e.symm

full_name: real_inner_eq_norm_add_mul_self_sub_norm_mul_self_sub_norm_mul_self_div_two
code: /-- Polarization identity: The real inner product, in terms of the norm. -/
theorem real_inner_eq_norm_add_mul_self_sub_norm_mul_self_sub_norm_mul_self_div_two (x y : F) :
    ⟪x, y⟫_ℝ = (‖x + y‖ * ‖x + y‖ - ‖x‖ * ‖x‖ - ‖y‖ * ‖y‖) / 2 
goal: ⟪x, y⟫_ℝ = (‖x + y‖ * ‖x + y‖ - ‖x‖ * ‖x‖ - ‖y‖ * ‖y‖) / 2

full_name: real_inner_eq_norm_mul_self_add_norm_mul_self_sub_norm_sub_mul_self_div_two
code: /-- Polarization identity: The real inner product, in terms of the norm. -/
theorem real_inner_eq_norm_mul_self_add_norm_mul_self_sub_norm_sub_mul_self_div_two (x y : F) :
    ⟪x, y⟫_ℝ = (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ - ‖x - y‖ * ‖x - y‖) / 2 
goal: ⟪x, y⟫_ℝ = (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ - ‖x - y‖ * ‖x - y‖) / 2

full_name: norm_add_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero
code: /-- Pythagorean theorem, if-and-only-if vector inner product form. -/
theorem norm_add_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero (x y : F) :
    ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ ⟪x, y⟫_ℝ = 0 
goal: ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ ⟪x, y⟫_ℝ = 0

full_name: norm_add_eq_sqrt_iff_real_inner_eq_zero
code: /-- Pythagorean theorem, if-and-if vector inner product form using square roots. -/
theorem norm_add_eq_sqrt_iff_real_inner_eq_zero {x y : F} :
    ‖x + y‖ = √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) ↔ ⟪x, y⟫_ℝ = 0 
goal: ‖x + y‖ = √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) ↔ ⟪x, y⟫_ℝ = 0

full_name: norm_add_sq_eq_norm_sq_add_norm_sq_of_inner_eq_zero
code: /-- Pythagorean theorem, vector inner product form. -/
theorem norm_add_sq_eq_norm_sq_add_norm_sq_of_inner_eq_zero (x y : E) (h : ⟪x, y⟫ = 0) :
    ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ 
goal: ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

full_name: norm_add_sq_eq_norm_sq_add_norm_sq_real
code: /-- Pythagorean theorem, vector inner product form. -/
theorem norm_add_sq_eq_norm_sq_add_norm_sq_real {x y : F} (h : ⟪x, y⟫_ℝ = 0) :
    ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ 
goal: ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

full_name: norm_sub_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero
code: /-- Pythagorean theorem, subtracting vectors, if-and-only-if vector
inner product form. -/
theorem norm_sub_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero (x y : F) :
    ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ ⟪x, y⟫_ℝ = 0 
goal: ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ ⟪x, y⟫_ℝ = 0

full_name: norm_sub_eq_sqrt_iff_real_inner_eq_zero
code: /-- Pythagorean theorem, subtracting vectors, if-and-if vector inner product form using square
roots. -/
theorem norm_sub_eq_sqrt_iff_real_inner_eq_zero {x y : F} :
    ‖x - y‖ = √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) ↔ ⟪x, y⟫_ℝ = 0 
goal: ‖x - y‖ = √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) ↔ ⟪x, y⟫_ℝ = 0

full_name: norm_sub_sq_eq_norm_sq_add_norm_sq_real
code: /-- Pythagorean theorem, subtracting vectors, vector inner product
form. -/
theorem norm_sub_sq_eq_norm_sq_add_norm_sq_real {x y : F} (h : ⟪x, y⟫_ℝ = 0) :
    ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ 
goal: ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

full_name: real_inner_add_sub_eq_zero_iff
code: /-- The sum and difference of two vectors are orthogonal if and only
if they have the same norm. -/
theorem real_inner_add_sub_eq_zero_iff (x y : F) : ⟪x + y, x - y⟫_ℝ = 0 ↔ ‖x‖ = ‖y‖ 
goal: ⟪x + y, x - y⟫_ℝ = 0 ↔ ‖x‖ = ‖y‖

full_name: norm_sub_eq_norm_add
code: /-- Given two orthogonal vectors, their sum and difference have equal norms. -/
theorem norm_sub_eq_norm_add {v w : E} (h : ⟪v, w⟫ = 0) : ‖w - v‖ = ‖w + v‖ 
goal: ‖w - v‖ = ‖w + v‖

full_name: abs_real_inner_div_norm_mul_norm_le_one
code: /-- The real inner product of two vectors, divided by the product of their
norms, has absolute value at most 1. -/
theorem abs_real_inner_div_norm_mul_norm_le_one (x y : F) : |⟪x, y⟫_ℝ / (‖x‖ * ‖y‖)| ≤ 1 
goal: |⟪x, y⟫_ℝ / (‖x‖ * ‖y‖)| ≤ 1

full_name: real_inner_smul_self_left
code: /-- The inner product of a vector with a multiple of itself. -/
theorem real_inner_smul_self_left (x : F) (r : ℝ) : ⟪r • x, x⟫_ℝ = r * (‖x‖ * ‖x‖) 
goal: ⟪r • x, x⟫_ℝ = r * (‖x‖ * ‖x‖)

full_name: real_inner_smul_self_right
code: /-- The inner product of a vector with a multiple of itself. -/
theorem real_inner_smul_self_right (x : F) (r : ℝ) : ⟪x, r • x⟫_ℝ = r * (‖x‖ * ‖x‖) 
goal: ⟪x, r • x⟫_ℝ = r * (‖x‖ * ‖x‖)

full_name: norm_inner_div_norm_mul_norm_eq_one_of_ne_zero_of_ne_zero_mul
code: /-- The inner product of a nonzero vector with a nonzero multiple of
itself, divided by the product of their norms, has absolute value
1. -/
theorem norm_inner_div_norm_mul_norm_eq_one_of_ne_zero_of_ne_zero_mul {x : E} {r : 𝕜} (hx : x ≠ 0)
    (hr : r ≠ 0) : ‖⟪x, r • x⟫‖ / (‖x‖ * ‖r • x‖) = 1 
goal: ‖⟪x, r • x⟫_𝕜‖ / (‖x‖ * ‖r • x‖) = 1

full_name: abs_real_inner_div_norm_mul_norm_eq_one_of_ne_zero_of_ne_zero_mul
code: /-- The inner product of a nonzero vector with a nonzero multiple of
itself, divided by the product of their norms, has absolute value
1. -/
theorem abs_real_inner_div_norm_mul_norm_eq_one_of_ne_zero_of_ne_zero_mul {x : F} {r : ℝ}
    (hx : x ≠ 0) (hr : r ≠ 0) : |⟪x, r • x⟫_ℝ| / (‖x‖ * ‖r • x‖) = 1 
goal: |⟪x, r • x⟫_ℝ| / (‖x‖ * ‖r • x‖) = 1

full_name: real_inner_div_norm_mul_norm_eq_one_of_ne_zero_of_pos_mul
code: /-- The inner product of a nonzero vector with a positive multiple of
itself, divided by the product of their norms, has value 1. -/
theorem real_inner_div_norm_mul_norm_eq_one_of_ne_zero_of_pos_mul {x : F} {r : ℝ} (hx : x ≠ 0)
    (hr : 0 < r) : ⟪x, r • x⟫_ℝ / (‖x‖ * ‖r • x‖) = 1 
goal: ⟪x, r • x⟫_ℝ / (‖x‖ * ‖r • x‖) = 1

full_name: real_inner_div_norm_mul_norm_eq_neg_one_of_ne_zero_of_neg_mul
code: /-- The inner product of a nonzero vector with a negative multiple of
itself, divided by the product of their norms, has value -1. -/
theorem real_inner_div_norm_mul_norm_eq_neg_one_of_ne_zero_of_neg_mul {x : F} {r : ℝ} (hx : x ≠ 0)
    (hr : r < 0) : ⟪x, r • x⟫_ℝ / (‖x‖ * ‖r • x‖) = -1 
goal: ⟪x, r • x⟫_ℝ / (‖x‖ * ‖r • x‖) = -1

full_name: norm_inner_eq_norm_tfae
code: theorem norm_inner_eq_norm_tfae (x y : E) :
    List.TFAE [‖⟪x, y⟫‖ = ‖x‖ * ‖y‖,
      x = 0 ∨ y = (⟪x, y⟫ / ⟪x, x⟫) • x,
      x = 0 ∨ ∃ r : 𝕜, y = r • x,
      x = 0 ∨ y ∈ 𝕜 ∙ x] 
goal: [‖⟪x, y⟫_𝕜‖ = ‖x‖ * ‖y‖, x = 0 ∨ y = (⟪x, y⟫_𝕜 / ⟪x, x⟫_𝕜) • x, x = 0 ∨ ∃ r, y = r • x,
    x = 0 ∨ y ∈ Submodule.span 𝕜 {x}].TFAE

full_name: norm_inner_eq_norm_iff
code: /-- If the inner product of two vectors is equal to the product of their norms, then the two vectors
are multiples of each other. One form of the equality case for Cauchy-Schwarz.
Compare `inner_eq_norm_mul_iff`, which takes the stronger hypothesis `⟪x, y⟫ = ‖x‖ * ‖y‖`. -/
theorem norm_inner_eq_norm_iff {x y : E} (hx₀ : x ≠ 0) (hy₀ : y ≠ 0) :
    ‖⟪x, y⟫‖ = ‖x‖ * ‖y‖ ↔ ∃ r : 𝕜, r ≠ 0 ∧ y = r • x 
goal: ‖⟪x, y⟫_𝕜‖ = ‖x‖ * ‖y‖ ↔ ∃ r, r ≠ 0 ∧ y = r • x

full_name: norm_inner_div_norm_mul_norm_eq_one_iff
code: /-- The inner product of two vectors, divided by the product of their
norms, has absolute value 1 if and only if they are nonzero and one is
a multiple of the other. One form of equality case for Cauchy-Schwarz. -/
theorem norm_inner_div_norm_mul_norm_eq_one_iff (x y : E) :
    ‖⟪x, y⟫ / (‖x‖ * ‖y‖)‖ = 1 ↔ x ≠ 0 ∧ ∃ r : 𝕜, r ≠ 0 ∧ y = r • x 
goal: ‖⟪x, y⟫_𝕜 / (↑‖x‖ * ↑‖y‖)‖ = 1 ↔ x ≠ 0 ∧ ∃ r, r ≠ 0 ∧ y = r • x

full_name: abs_real_inner_div_norm_mul_norm_eq_one_iff
code: /-- The inner product of two vectors, divided by the product of their
norms, has absolute value 1 if and only if they are nonzero and one is
a multiple of the other. One form of equality case for Cauchy-Schwarz. -/
theorem abs_real_inner_div_norm_mul_norm_eq_one_iff (x y : F) :
    |⟪x, y⟫_ℝ / (‖x‖ * ‖y‖)| = 1 ↔ x ≠ 0 ∧ ∃ r : ℝ, r ≠ 0 ∧ y = r • x 
goal: |⟪x, y⟫_ℝ / (‖x‖ * ‖y‖)| = 1 ↔ x ≠ 0 ∧ ∃ r, r ≠ 0 ∧ y = r • x

full_name: inner_eq_norm_mul_iff_div
code: theorem inner_eq_norm_mul_iff_div {x y : E} (h₀ : x ≠ 0) :
    ⟪x, y⟫ = (‖x‖ : 𝕜) * ‖y‖ ↔ (‖y‖ / ‖x‖ : 𝕜) • x = y 
goal: ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ (↑‖y‖ / ↑‖x‖) • x = y

full_name: inner_eq_norm_mul_iff
code: /-- If the inner product of two vectors is equal to the product of their norms (i.e.,
`⟪x, y⟫ = ‖x‖ * ‖y‖`), then the two vectors are nonnegative real multiples of each other. One form
of the equality case for Cauchy-Schwarz.
Compare `norm_inner_eq_norm_iff`, which takes the weaker hypothesis `abs ⟪x, y⟫ = ‖x‖ * ‖y‖`. -/
theorem inner_eq_norm_mul_iff {x y : E} :
    ⟪x, y⟫ = (‖x‖ : 𝕜) * ‖y‖ ↔ (‖y‖ : 𝕜) • x = (‖x‖ : 𝕜) • y 
goal: ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ ↑‖y‖ • x = ↑‖x‖ • y

full_name: inner_eq_norm_mul_iff_real
code: /-- If the inner product of two vectors is equal to the product of their norms (i.e.,
`⟪x, y⟫ = ‖x‖ * ‖y‖`), then the two vectors are nonnegative real multiples of each other. One form
of the equality case for Cauchy-Schwarz.
Compare `norm_inner_eq_norm_iff`, which takes the weaker hypothesis `abs ⟪x, y⟫ = ‖x‖ * ‖y‖`. -/
theorem inner_eq_norm_mul_iff_real {x y : F} : ⟪x, y⟫_ℝ = ‖x‖ * ‖y‖ ↔ ‖y‖ • x = ‖x‖ • y 
goal: ⟪x, y⟫_ℝ = ‖x‖ * ‖y‖ ↔ ‖y‖ • x = ‖x‖ • y

full_name: real_inner_div_norm_mul_norm_eq_one_iff
code: /-- The inner product of two vectors, divided by the product of their
norms, has value 1 if and only if they are nonzero and one is
a positive multiple of the other. -/
theorem real_inner_div_norm_mul_norm_eq_one_iff (x y : F) :
    ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = 1 ↔ x ≠ 0 ∧ ∃ r : ℝ, 0 < r ∧ y = r • x 
goal: ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = 1 ↔ x ≠ 0 ∧ ∃ r, 0 < r ∧ y = r • x

full_name: real_inner_div_norm_mul_norm_eq_neg_one_iff
code: /-- The inner product of two vectors, divided by the product of their
norms, has value -1 if and only if they are nonzero and one is
a negative multiple of the other. -/
theorem real_inner_div_norm_mul_norm_eq_neg_one_iff (x y : F) :
    ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = -1 ↔ x ≠ 0 ∧ ∃ r : ℝ, r < 0 ∧ y = r • x 
goal: ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = -1 ↔ x ≠ 0 ∧ ∃ r < 0, y = r • x

full_name: inner_eq_one_iff_of_norm_one
code: /-- If the inner product of two unit vectors is `1`, then the two vectors are equal. One form of
the equality case for Cauchy-Schwarz. -/
theorem inner_eq_one_iff_of_norm_one {x y : E} (hx : ‖x‖ = 1) (hy : ‖y‖ = 1) :
    ⟪x, y⟫ = 1 ↔ x = y 
goal: ⟪x, y⟫_𝕜 = 1 ↔ x = y

full_name: inner_lt_norm_mul_iff_real
code: theorem inner_lt_norm_mul_iff_real {x y : F} : ⟪x, y⟫_ℝ < ‖x‖ * ‖y‖ ↔ ‖y‖ • x ≠ ‖x‖ • y 
goal: ⟪x, y⟫_ℝ < ‖x‖ * ‖y‖ ↔ ‖y‖ • x ≠ ‖x‖ • y

full_name: inner_lt_one_iff_real_of_norm_one
code: /-- If the inner product of two unit vectors is strictly less than `1`, then the two vectors are
distinct. One form of the equality case for Cauchy-Schwarz. -/
theorem inner_lt_one_iff_real_of_norm_one {x y : F} (hx : ‖x‖ = 1) (hy : ‖y‖ = 1) :
    ⟪x, y⟫_ℝ < 1 ↔ x ≠ y 
goal: ⟪x, y⟫_ℝ < 1 ↔ x ≠ y

full_name: eq_of_norm_le_re_inner_eq_norm_sq
code: /-- The sphere of radius `r = ‖y‖` is tangent to the plane `⟪x, y⟫ = ‖y‖ ^ 2` at `x = y`. -/
theorem eq_of_norm_le_re_inner_eq_norm_sq {x y : E} (hle : ‖x‖ ≤ ‖y‖) (h : re ⟪x, y⟫ = ‖y‖ ^ 2) :
    x = y 
goal: x = y

full_name: inner_sum_smul_sum_smul_of_sum_eq_zero
code: /-- The inner product of two weighted sums, where the weights in each
sum add to 0, in terms of the norms of pairwise differences. -/
theorem inner_sum_smul_sum_smul_of_sum_eq_zero {ι₁ : Type*} {s₁ : Finset ι₁} {w₁ : ι₁ → ℝ}
    (v₁ : ι₁ → F) (h₁ : ∑ i ∈ s₁, w₁ i = 0) {ι₂ : Type*} {s₂ : Finset ι₂} {w₂ : ι₂ → ℝ}
    (v₂ : ι₂ → F) (h₂ : ∑ i ∈ s₂, w₂ i = 0) :
    ⟪∑ i₁ ∈ s₁, w₁ i₁ • v₁ i₁, ∑ i₂ ∈ s₂, w₂ i₂ • v₂ i₂⟫_ℝ =
      (-∑ i₁ ∈ s₁, ∑ i₂ ∈ s₂, w₁ i₁ * w₂ i₂ * (‖v₁ i₁ - v₂ i₂‖ * ‖v₁ i₁ - v₂ i₂‖)) / 2 
goal: ⟪∑ i₁ ∈ s₁, w₁ i₁ • v₁ i₁, ∑ i₂ ∈ s₂, w₂ i₂ • v₂ i₂⟫_ℝ =
  (-∑ i₁ ∈ s₁, ∑ i₂ ∈ s₂, w₁ i₁ * w₂ i₂ * (‖v₁ i₁ - v₂ i₂‖ * ‖v₁ i₁ - v₂ i₂‖)) / 2

full_name: innerₛₗ
code: /-- The inner product as a sesquilinear map. -/
def innerₛₗ : E →ₗ⋆[𝕜] E →ₗ[𝕜] 𝕜 
goal: E →ₗ⋆[𝕜] E →ₗ[𝕜] 𝕜

full_name: innerₛₗ_apply_coe
code: @[simp]
theorem innerₛₗ_apply_coe (v : E) : ⇑(innerₛₗ 𝕜 v) = fun w => ⟪v, w⟫ 
goal: ⇑((innerₛₗ 𝕜) v) = fun w => ⟪v, w⟫_𝕜

full_name: innerₛₗ_apply
code: @[simp]
theorem innerₛₗ_apply (v w : E) : innerₛₗ 𝕜 v w = ⟪v, w⟫ 
goal: ((innerₛₗ 𝕜) v) w = ⟪v, w⟫_𝕜

full_name: innerₗ
code: /-- The inner product as a bilinear map in the real case. -/
def innerₗ : F →ₗ[ℝ] F →ₗ[ℝ] ℝ 
goal: F →ₗ[ℝ] F →ₗ[ℝ] ℝ

full_name: flip_innerₗ
code: @[simp] lemma flip_innerₗ : (innerₗ F).flip = innerₗ F 
goal: (innerₗ F).flip = innerₗ F

full_name: innerₗ_apply
code: @[simp] lemma innerₗ_apply (v w : F) : innerₗ F v w = ⟪v, w⟫_ℝ 
goal: ((innerₗ F) v) w = ⟪v, w⟫_ℝ

full_name: innerSL
code: /-- The inner product as a continuous sesquilinear map. Note that `toDualMap` (resp. `toDual`)
in `InnerProductSpace.Dual` is a version of this given as a linear isometry (resp. linear
isometric equivalence). -/
def innerSL : E →L⋆[𝕜] E →L[𝕜] 𝕜 
goal: E →L⋆[𝕜] E →L[𝕜] 𝕜

full_name: innerSL_apply_coe
code: @[simp]
theorem innerSL_apply_coe (v : E) : ⇑(innerSL 𝕜 v) = fun w => ⟪v, w⟫ 
goal: ⇑((innerSL 𝕜) v) = fun w => ⟪v, w⟫_𝕜

full_name: innerSL_apply
code: @[simp]
theorem innerSL_apply (v w : E) : innerSL 𝕜 v w = ⟪v, w⟫ 
goal: ((innerSL 𝕜) v) w = ⟪v, w⟫_𝕜

full_name: innerSL_apply_norm
code: /-- `innerSL` is an isometry. Note that the associated `LinearIsometry` is defined in
`InnerProductSpace.Dual` as `toDualMap`.  -/
@[simp]
theorem innerSL_apply_norm (x : E) : ‖innerSL 𝕜 x‖ = ‖x‖ 
goal: ‖(innerSL 𝕜) x‖ = ‖x‖

full_name: norm_innerSL_le
code: lemma norm_innerSL_le : ‖innerSL 𝕜 (E := E)‖ ≤ 1 
goal: ‖innerSL 𝕜‖ ≤ 1

full_name: innerSLFlip
code: /-- The inner product as a continuous sesquilinear map, with the two arguments flipped. -/
def innerSLFlip : E →L[𝕜] E →L⋆[𝕜] 𝕜 
goal: E →L[𝕜] E →L⋆[𝕜] 𝕜

full_name: innerSLFlip_apply
code: @[simp]
theorem innerSLFlip_apply (x y : E) : innerSLFlip 𝕜 x y = ⟪y, x⟫ 
goal: ((innerSLFlip 𝕜) x) y = ⟪y, x⟫_𝕜

full_name: innerSL_real_flip
code: @[simp] lemma innerSL_real_flip : (innerSL ℝ (E := F)).flip = innerSL ℝ 
goal: (innerSL ℝ).flip = innerSL ℝ

full_name: ContinuousLinearMap.toSesqForm
code: /-- Given `f : E →L[𝕜] E'`, construct the continuous sesquilinear form `fun x y ↦ ⟪x, A y⟫`, given
as a continuous linear map. -/
noncomputable def toSesqForm : (E →L[𝕜] E') →L[𝕜] E' →L⋆[𝕜] E →L[𝕜] 𝕜 
goal: (E →L[𝕜] E') →L[𝕜] E' →L⋆[𝕜] E →L[𝕜] 𝕜

full_name: ContinuousLinearMap.toSesqForm_apply_coe
code: @[simp]
theorem toSesqForm_apply_coe (f : E →L[𝕜] E') (x : E') : toSesqForm f x = (innerSL 𝕜 x).comp f 
goal: (ContinuousLinearMap.toSesqForm f) x = ((innerSL 𝕜) x).comp f

full_name: ContinuousLinearMap.toSesqForm_apply_norm_le
code: theorem toSesqForm_apply_norm_le {f : E →L[𝕜] E'} {v : E'} : ‖toSesqForm f v‖ ≤ ‖f‖ * ‖v‖ 
goal: ‖(ContinuousLinearMap.toSesqForm f) v‖ ≤ ‖f‖ * ‖v‖

full_name: isBoundedBilinearMap_inner
code: /-- When an inner product space `E` over `𝕜` is considered as a real normed space, its inner
product satisfies `IsBoundedBilinearMap`.

In order to state these results, we need a `NormedSpace ℝ E` instance. We will later establish
such an instance by restriction-of-scalars, `InnerProductSpace.rclikeToReal 𝕜 E`, but this
instance may be not definitionally equal to some other “natural” instance. So, we assume
`[NormedSpace ℝ E]`.
-/
theorem _root_.isBoundedBilinearMap_inner [NormedSpace ℝ E] :
    IsBoundedBilinearMap ℝ fun p : E × E => ⟪p.1, p.2⟫ 
goal: IsBoundedBilinearMap ℝ fun p => ⟪p.1, p.2⟫_𝕜

full_name: Orthonormal.sum_inner_products_le
code: /-- Bessel's inequality for finite sums. -/
theorem Orthonormal.sum_inner_products_le {s : Finset ι} (hv : Orthonormal 𝕜 v) :
    ∑ i ∈ s, ‖⟪v i, x⟫‖ ^ 2 ≤ ‖x‖ ^ 2 
goal: ∑ i ∈ s, ‖⟪v i, x⟫_𝕜‖ ^ 2 ≤ ‖x‖ ^ 2

full_name: Orthonormal.tsum_inner_products_le
code: /-- Bessel's inequality. -/
theorem Orthonormal.tsum_inner_products_le (hv : Orthonormal 𝕜 v) :
    ∑' i, ‖⟪v i, x⟫‖ ^ 2 ≤ ‖x‖ ^ 2 
goal: ∑' (i : ι), ‖⟪v i, x⟫_𝕜‖ ^ 2 ≤ ‖x‖ ^ 2

full_name: Orthonormal.inner_products_summable
code: /-- The sum defined in Bessel's inequality is summable. -/
theorem Orthonormal.inner_products_summable (hv : Orthonormal 𝕜 v) :
    Summable fun i => ‖⟪v i, x⟫‖ ^ 2 
goal: Summable fun i => ‖⟪v i, x⟫_𝕜‖ ^ 2

full_name: RCLike.innerProductSpace
code: /-- A field `𝕜` satisfying `RCLike` is itself a `𝕜`-inner product space. -/
instance RCLike.innerProductSpace : InnerProductSpace 𝕜 𝕜 
goal: InnerProductSpace 𝕜 𝕜

full_name: RCLike.inner_apply
code: @[simp]
theorem RCLike.inner_apply (x y : 𝕜) : ⟪x, y⟫ = conj x * y 
goal: ⟪x, y⟫_𝕜 = (starRingEnd 𝕜) x * y

full_name: Submodule.innerProductSpace
code: /-- Induced inner product on a submodule. -/
instance Submodule.innerProductSpace (W : Submodule 𝕜 E) : InnerProductSpace 𝕜 W 
goal: InnerProductSpace 𝕜 ↥W

full_name: Submodule.coe_inner
code: /-- The inner product on submodules is the same as on the ambient space. -/
@[simp]
theorem Submodule.coe_inner (W : Submodule 𝕜 E) (x y : W) : ⟪x, y⟫ = ⟪(x : E), ↑y⟫ 
goal: ⟪x, y⟫_𝕜 = ⟪↑x, ↑y⟫_𝕜

full_name: Orthonormal.codRestrict
code: theorem Orthonormal.codRestrict {ι : Type*} {v : ι → E} (hv : Orthonormal 𝕜 v) (s : Submodule 𝕜 E)
    (hvs : ∀ i, v i ∈ s) : @Orthonormal 𝕜 s _ _ _ ι (Set.codRestrict v s hvs) 
goal: Orthonormal 𝕜 (Set.codRestrict v (↑s) hvs)

full_name: orthonormal_span
code: theorem orthonormal_span {ι : Type*} {v : ι → E} (hv : Orthonormal 𝕜 v) :
    @Orthonormal 𝕜 (Submodule.span 𝕜 (Set.range v)) _ _ _ ι fun i : ι =>
      ⟨v i, Submodule.subset_span (Set.mem_range_self i)⟩ 
goal: Orthonormal 𝕜 fun i => ⟨v i, ⋯⟩

full_name: OrthogonalFamily
code: /-- An indexed family of mutually-orthogonal subspaces of an inner product space `E`.

The simple way to express this concept would be as a condition on `V : ι → Submodule 𝕜 E`.  We
instead implement it as a condition on a family of inner product spaces each equipped with an
isometric embedding into `E`, thus making it a property of morphisms rather than subobjects.
The connection to the subobject spelling is shown in `orthogonalFamily_iff_pairwise`.

This definition is less lightweight, but allows for better definitional properties when the inner
product space structure on each of the submodules is important -- for example, when considering
their Hilbert sum (`PiLp V 2`).  For example, given an orthonormal set of vectors `v : ι → E`,
we have an associated orthogonal family of one-dimensional subspaces of `E`, which it is convenient
to be able to discuss using `ι → 𝕜` rather than `Π i : ι, span 𝕜 (v i)`. -/
def OrthogonalFamily (G : ι → Type*) [∀ i, NormedAddCommGroup (G i)]
    [∀ i, InnerProductSpace 𝕜 (G i)] (V : ∀ i, G i →ₗᵢ[𝕜] E) : Prop 
goal: Prop

full_name: Orthonormal.orthogonalFamily
code: theorem Orthonormal.orthogonalFamily {v : ι → E} (hv : Orthonormal 𝕜 v) :
    OrthogonalFamily 𝕜 (fun _i : ι => 𝕜) fun i => LinearIsometry.toSpanSingleton 𝕜 E (hv.1 i) 
goal: OrthogonalFamily 𝕜 (fun _i => 𝕜) fun i => LinearIsometry.toSpanSingleton 𝕜 E ⋯

full_name: OrthogonalFamily.eq_ite
code: theorem OrthogonalFamily.eq_ite [DecidableEq ι] {i j : ι} (v : G i) (w : G j) :
    ⟪V i v, V j w⟫ = ite (i = j) ⟪V i v, V j w⟫ 0 
goal: ⟪(V i) v, (V j) w⟫_𝕜 = if i = j then ⟪(V i) v, (V j) w⟫_𝕜 else 0

full_name: OrthogonalFamily.inner_right_dfinsupp
code: theorem OrthogonalFamily.inner_right_dfinsupp [DecidableEq ι] (l : ⨁ i, G i) (i : ι) (v : G i) :
    ⟪V i v, l.sum fun j => V j⟫ = ⟪v, l i⟫ 
goal: ⟪(V i) v, DFinsupp.sum l fun j => ⇑(V j)⟫_𝕜 = ⟪v, l i⟫_𝕜

full_name: OrthogonalFamily.inner_right_fintype
code: theorem OrthogonalFamily.inner_right_fintype [Fintype ι] (l : ∀ i, G i) (i : ι) (v : G i) :
    ⟪V i v, ∑ j : ι, V j (l j)⟫ = ⟪v, l i⟫ 
goal: ⟪(V i) v, ∑ j : ι, (V j) (l j)⟫_𝕜 = ⟪v, l i⟫_𝕜

full_name: OrthogonalFamily.inner_sum
code: theorem OrthogonalFamily.inner_sum (l₁ l₂ : ∀ i, G i) (s : Finset ι) :
    ⟪∑ i ∈ s, V i (l₁ i), ∑ j ∈ s, V j (l₂ j)⟫ = ∑ i ∈ s, ⟪l₁ i, l₂ i⟫ 
goal: ⟪∑ i ∈ s, (V i) (l₁ i), ∑ j ∈ s, (V j) (l₂ j)⟫_𝕜 = ∑ i ∈ s, ⟪l₁ i, l₂ i⟫_𝕜

full_name: OrthogonalFamily.norm_sum
code: theorem OrthogonalFamily.norm_sum (l : ∀ i, G i) (s : Finset ι) :
    ‖∑ i ∈ s, V i (l i)‖ ^ 2 = ∑ i ∈ s, ‖l i‖ ^ 2 
goal: ‖∑ i ∈ s, (V i) (l i)‖ ^ 2 = ∑ i ∈ s, ‖l i‖ ^ 2

full_name: OrthogonalFamily.comp
code: /-- The composition of an orthogonal family of subspaces with an injective function is also an
orthogonal family. -/
theorem OrthogonalFamily.comp {γ : Type*} {f : γ → ι} (hf : Function.Injective f) :
    OrthogonalFamily 𝕜 (fun g => G (f g)) fun g => V (f g) 
goal: OrthogonalFamily 𝕜 (fun g => G (f g)) fun g => V (f g)

full_name: OrthogonalFamily.orthonormal_sigma_orthonormal
code: theorem OrthogonalFamily.orthonormal_sigma_orthonormal {α : ι → Type*} {v_family : ∀ i, α i → G i}
    (hv_family : ∀ i, Orthonormal 𝕜 (v_family i)) :
    Orthonormal 𝕜 fun a : Σi, α i => V a.1 (v_family a.1 a.2) 
goal: Orthonormal 𝕜 fun a => (V a.fst) (v_family a.fst a.snd)

full_name: OrthogonalFamily.norm_sq_diff_sum
code: theorem OrthogonalFamily.norm_sq_diff_sum [DecidableEq ι] (f : ∀ i, G i) (s₁ s₂ : Finset ι) :
    ‖(∑ i ∈ s₁, V i (f i)) - ∑ i ∈ s₂, V i (f i)‖ ^ 2 =
      (∑ i ∈ s₁ \ s₂, ‖f i‖ ^ 2) + ∑ i ∈ s₂ \ s₁, ‖f i‖ ^ 2 
goal: ‖∑ i ∈ s₁, (V i) (f i) - ∑ i ∈ s₂, (V i) (f i)‖ ^ 2 = ∑ i ∈ s₁ \ s₂, ‖f i‖ ^ 2 + ∑ i ∈ s₂ \ s₁, ‖f i‖ ^ 2

full_name: OrthogonalFamily.summable_iff_norm_sq_summable
code: /-- A family `f` of mutually-orthogonal elements of `E` is summable, if and only if
`(fun i ↦ ‖f i‖ ^ 2)` is summable. -/
theorem OrthogonalFamily.summable_iff_norm_sq_summable [CompleteSpace E] (f : ∀ i, G i) :
    (Summable fun i => V i (f i)) ↔ Summable fun i => ‖f i‖ ^ 2 
goal: (Summable fun i => (V i) (f i)) ↔ Summable fun i => ‖f i‖ ^ 2

full_name: OrthogonalFamily.independent
code: /-- An orthogonal family forms an independent family of subspaces; that is, any collection of
elements each from a different subspace in the family is linearly independent. In particular, the
pairwise intersections of elements of the family are 0. -/
theorem OrthogonalFamily.independent {V : ι → Submodule 𝕜 E}
    (hV : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    CompleteLattice.Independent V 
goal: CompleteLattice.Independent V

full_name: DirectSum.IsInternal.collectedBasis_orthonormal
code: theorem DirectSum.IsInternal.collectedBasis_orthonormal [DecidableEq ι] {V : ι → Submodule 𝕜 E}
    (hV : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ)
    (hV_sum : DirectSum.IsInternal fun i => V i) {α : ι → Type*}
    {v_family : ∀ i, Basis (α i) 𝕜 (V i)} (hv_family : ∀ i, Orthonormal 𝕜 (v_family i)) :
    Orthonormal 𝕜 (hV_sum.collectedBasis v_family) 
goal: Orthonormal 𝕜 ⇑(hV_sum.collectedBasis v_family)

full_name: Inner.rclikeToReal
code: /-- A general inner product implies a real inner product. This is not registered as an instance
since it creates problems with the case `𝕜 = ℝ`. -/
def Inner.rclikeToReal : Inner ℝ E 
goal: Inner ℝ E

full_name: InnerProductSpace.rclikeToReal
code: /-- A general inner product space structure implies a real inner product structure. This is not
registered as an instance since it creates problems with the case `𝕜 = ℝ`, but in can be used in a
proof to obtain a real inner product space structure from a given `𝕜`-inner product space
structure. -/
def InnerProductSpace.rclikeToReal : InnerProductSpace ℝ E 
goal: InnerProductSpace ℝ E

full_name: real_inner_eq_re_inner
code: theorem real_inner_eq_re_inner (x y : E) :
    @Inner.inner ℝ E (Inner.rclikeToReal 𝕜 E) x y = re ⟪x, y⟫ 
goal: ⟪x, y⟫_ℝ = RCLike.re ⟪x, y⟫_𝕜

full_name: real_inner_I_smul_self
code: theorem real_inner_I_smul_self (x : E) :
    @Inner.inner ℝ E (Inner.rclikeToReal 𝕜 E) x ((I : 𝕜) • x) = 0 
goal: ⟪x, RCLike.I • x⟫_ℝ = 0

full_name: InnerProductSpace.complexToReal
code: /-- A complex inner product implies a real inner product. This cannot be an instance since it
creates a diamond with `PiLp.innerProductSpace` because `re (sum i, inner (x i) (y i))` and
`sum i, re (inner (x i) (y i))` are not defeq. -/
def InnerProductSpace.complexToReal [NormedAddCommGroup G] [InnerProductSpace ℂ G] :
    InnerProductSpace ℝ G 
goal: InnerProductSpace ℝ G

full_name: instInnerProductSpaceRealComplex
code: instance : InnerProductSpace ℝ ℂ 
goal: InnerProductSpace ℝ ℂ

full_name: Complex.inner
code: @[simp]
protected theorem Complex.inner (w z : ℂ) : ⟪w, z⟫_ℝ = (conj w * z).re 
goal: ⟪w, z⟫_ℝ = ((starRingEnd ℂ) w * z).re

full_name: inner_map_complex
code: /-- The inner product on an inner product space of dimension 2 can be evaluated in terms
of a complex-number representation of the space. -/
theorem inner_map_complex [NormedAddCommGroup G] [InnerProductSpace ℝ G] (f : G ≃ₗᵢ[ℝ] ℂ)
    (x y : G) : ⟪x, y⟫_ℝ = (conj (f x) * f y).re 
goal: ⟪x, y⟫_ℝ = ((starRingEnd ℂ) (f x) * f y).re

full_name: continuous_inner
code: theorem continuous_inner : Continuous fun p : E × E => ⟪p.1, p.2⟫ 
goal: Continuous fun p => ⟪p.1, p.2⟫_𝕜

full_name: Filter.Tendsto.inner
code: theorem Filter.Tendsto.inner {f g : α → E} {l : Filter α} {x y : E} (hf : Tendsto f l (𝓝 x))
    (hg : Tendsto g l (𝓝 y)) : Tendsto (fun t => ⟪f t, g t⟫) l (𝓝 ⟪x, y⟫) 
goal: Filter.Tendsto (fun t => ⟪f t, g t⟫_𝕜) l (𝓝 ⟪x, y⟫_𝕜)

full_name: ContinuousWithinAt.inner
code: theorem ContinuousWithinAt.inner (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x) :
    ContinuousWithinAt (fun t => ⟪f t, g t⟫) s x 
goal: ContinuousWithinAt (fun t => ⟪f t, g t⟫_𝕜) s x

full_name: ContinuousAt.inner
code: theorem ContinuousAt.inner (hf : ContinuousAt f x) (hg : ContinuousAt g x) :
    ContinuousAt (fun t => ⟪f t, g t⟫) x 
goal: ContinuousAt (fun t => ⟪f t, g t⟫_𝕜) x

full_name: ContinuousOn.inner
code: theorem ContinuousOn.inner (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun t => ⟪f t, g t⟫) s 
goal: ContinuousOn (fun t => ⟪f t, g t⟫_𝕜) s

full_name: Continuous.inner
code: @[continuity]
theorem Continuous.inner (hf : Continuous f) (hg : Continuous g) : Continuous fun t => ⟪f t, g t⟫ 
goal: Continuous fun t => ⟪f t, g t⟫_𝕜

full_name: ContinuousLinearMap.reApplyInnerSelf
code: /-- Extract a real bilinear form from an operator `T`,
by taking the pairing `fun x ↦ re ⟪T x, x⟫`. -/
def ContinuousLinearMap.reApplyInnerSelf (T : E →L[𝕜] E) (x : E) : ℝ 
goal: ℝ

full_name: ContinuousLinearMap.reApplyInnerSelf_apply
code: theorem ContinuousLinearMap.reApplyInnerSelf_apply (T : E →L[𝕜] E) (x : E) :
    T.reApplyInnerSelf x = re ⟪T x, x⟫ 
goal: T.reApplyInnerSelf x = RCLike.re ⟪T x, x⟫_𝕜

full_name: ContinuousLinearMap.reApplyInnerSelf_continuous
code: theorem ContinuousLinearMap.reApplyInnerSelf_continuous (T : E →L[𝕜] E) :
    Continuous T.reApplyInnerSelf 
goal: Continuous T.reApplyInnerSelf

full_name: ContinuousLinearMap.reApplyInnerSelf_smul
code: theorem ContinuousLinearMap.reApplyInnerSelf_smul (T : E →L[𝕜] E) (x : E) {c : 𝕜} :
    T.reApplyInnerSelf (c • x) = ‖c‖ ^ 2 * T.reApplyInnerSelf x 
goal: T.reApplyInnerSelf (c • x) = ‖c‖ ^ 2 * T.reApplyInnerSelf x

full_name: UniformSpace.Completion.toInner
code: instance toInner {𝕜' E' : Type*} [TopologicalSpace 𝕜'] [UniformSpace E'] [Inner 𝕜' E'] :
    Inner 𝕜' (Completion E') 
goal: Inner 𝕜' (UniformSpace.Completion E')

full_name: UniformSpace.Completion.inner_coe
code: @[simp]
theorem inner_coe (a b : E) : inner (a : Completion E) (b : Completion E) = (inner a b : 𝕜) 
goal: ⟪↑E a, ↑E b⟫_𝕜 = ⟪a, b⟫_𝕜

full_name: UniformSpace.Completion.continuous_inner
code: protected theorem continuous_inner :
    Continuous (uncurry inner : Completion E × Completion E → 𝕜) 
goal: Continuous (Function.uncurry inner)

full_name: UniformSpace.Completion.Continuous.inner
code: protected theorem Continuous.inner {α : Type*} [TopologicalSpace α] {f g : α → Completion E}
    (hf : Continuous f) (hg : Continuous g) : Continuous (fun x : α => inner (f x) (g x) : α → 𝕜) 
goal: Continuous fun x => ⟪f x, g x⟫_𝕜

full_name: UniformSpace.Completion.innerProductSpace
code: instance innerProductSpace : InnerProductSpace 𝕜 (Completion E) 
goal: InnerProductSpace 𝕜 (UniformSpace.Completion E)