File: Mathlib/Analysis/InnerProductSpace/Symmetric.lean

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

full_name: LinearMap.IsSymmetric
code: /-- A (not necessarily bounded) operator on an inner product space is symmetric, if for all
`x`, `y`, we have `⟪T x, y⟫ = ⟪x, T y⟫`. -/
def IsSymmetric (T : E →ₗ[𝕜] E) : Prop 
goal: Prop

full_name: LinearMap.isSymmetric_iff_sesqForm
code: /-- An operator `T` on an inner product space is symmetric if and only if it is
`LinearMap.IsSelfAdjoint` with respect to the sesquilinear form given by the inner product. -/
theorem isSymmetric_iff_sesqForm (T : E →ₗ[𝕜] E) :
    T.IsSymmetric ↔ LinearMap.IsSelfAdjoint (R := 𝕜) (M := E) sesqFormOfInner T 
goal: T.IsSymmetric ↔ sesqFormOfInner.IsSelfAdjoint T

full_name: LinearMap.IsSymmetric.conj_inner_sym
code: theorem IsSymmetric.conj_inner_sym {T : E →ₗ[𝕜] E} (hT : IsSymmetric T) (x y : E) :
    conj ⟪T x, y⟫ = ⟪T y, x⟫ 
goal: (starRingEnd 𝕜) ⟪T x, y⟫_𝕜 = ⟪T y, x⟫_𝕜

full_name: LinearMap.IsSymmetric.apply_clm
code: @[simp]
theorem IsSymmetric.apply_clm {T : E →L[𝕜] E} (hT : IsSymmetric (T : E →ₗ[𝕜] E)) (x y : E) :
    ⟪T x, y⟫ = ⟪x, T y⟫ 
goal: ⟪T x, y⟫_𝕜 = ⟪x, T y⟫_𝕜

full_name: LinearMap.isSymmetric_zero
code: theorem isSymmetric_zero : (0 : E →ₗ[𝕜] E).IsSymmetric 
goal: LinearMap.IsSymmetric 0

full_name: LinearMap.isSymmetric_id
code: theorem isSymmetric_id : (LinearMap.id : E →ₗ[𝕜] E).IsSymmetric 
goal: LinearMap.id.IsSymmetric

full_name: LinearMap.IsSymmetric.add
code: theorem IsSymmetric.add {T S : E →ₗ[𝕜] E} (hT : T.IsSymmetric) (hS : S.IsSymmetric) :
    (T + S).IsSymmetric 
goal: (T + S).IsSymmetric

full_name: LinearMap.IsSymmetric.continuous
code: /-- The **Hellinger--Toeplitz theorem**: if a symmetric operator is defined on a complete space,
  then it is automatically continuous. -/
theorem IsSymmetric.continuous [CompleteSpace E] {T : E →ₗ[𝕜] E} (hT : IsSymmetric T) :
    Continuous T 
goal: Continuous ⇑T

full_name: LinearMap.IsSymmetric.coe_reApplyInnerSelf_apply
code: /-- For a symmetric operator `T`, the function `fun x ↦ ⟪T x, x⟫` is real-valued. -/
@[simp]
theorem IsSymmetric.coe_reApplyInnerSelf_apply {T : E →L[𝕜] E} (hT : IsSymmetric (T : E →ₗ[𝕜] E))
    (x : E) : (T.reApplyInnerSelf x : 𝕜) = ⟪T x, x⟫ 
goal: ↑(T.reApplyInnerSelf x) = ⟪T x, x⟫_𝕜

full_name: LinearMap.IsSymmetric.restrict_invariant
code: /-- If a symmetric operator preserves a submodule, its restriction to that submodule is
symmetric. -/
theorem IsSymmetric.restrict_invariant {T : E →ₗ[𝕜] E} (hT : IsSymmetric T) {V : Submodule 𝕜 E}
    (hV : ∀ v ∈ V, T v ∈ V) : IsSymmetric (T.restrict hV) 
goal: (T.restrict hV).IsSymmetric

full_name: LinearMap.IsSymmetric.restrictScalars
code: theorem IsSymmetric.restrictScalars {T : E →ₗ[𝕜] E} (hT : T.IsSymmetric) :
    @LinearMap.IsSymmetric ℝ E _ _ (InnerProductSpace.rclikeToReal 𝕜 E)
      (@LinearMap.restrictScalars ℝ 𝕜 _ _ _ _ _ _ (InnerProductSpace.rclikeToReal 𝕜 E).toModule
        (InnerProductSpace.rclikeToReal 𝕜 E).toModule _ _ _ T) 
goal: (↑ℝ T).IsSymmetric

full_name: LinearMap.isSymmetric_iff_inner_map_self_real
code: /-- A linear operator on a complex inner product space is symmetric precisely when
`⟪T v, v⟫_ℂ` is real for all v. -/
theorem isSymmetric_iff_inner_map_self_real (T : V →ₗ[ℂ] V) :
    IsSymmetric T ↔ ∀ v : V, conj ⟪T v, v⟫_ℂ = ⟪T v, v⟫_ℂ 
goal: T.IsSymmetric ↔ ∀ (v : V), (starRingEnd ℂ) ⟪T v, v⟫_ℂ = ⟪T v, v⟫_ℂ

full_name: LinearMap.IsSymmetric.inner_map_polarization
code: /-- Polarization identity for symmetric linear maps.
See `inner_map_polarization` for the complex version without the symmetric assumption. -/
theorem IsSymmetric.inner_map_polarization {T : E →ₗ[𝕜] E} (hT : T.IsSymmetric) (x y : E) :
    ⟪T x, y⟫ =
      (⟪T (x + y), x + y⟫ - ⟪T (x - y), x - y⟫ - I * ⟪T (x + (I : 𝕜) • y), x + (I : 𝕜) • y⟫ +
          I * ⟪T (x - (I : 𝕜) • y), x - (I : 𝕜) • y⟫) /
        4 
goal: ⟪T x, y⟫_𝕜 =
  (⟪T (x + y), x + y⟫_𝕜 - ⟪T (x - y), x - y⟫_𝕜 - RCLike.I * ⟪T (x + RCLike.I • y), x + RCLike.I • y⟫_𝕜 +
      RCLike.I * ⟪T (x - RCLike.I • y), x - RCLike.I • y⟫_𝕜) /
    4

full_name: LinearMap.IsSymmetric.inner_map_self_eq_zero
code: /-- A symmetric linear map `T` is zero if and only if `⟪T x, x⟫_ℝ = 0` for all `x`.
See `inner_map_self_eq_zero` for the complex version without the symmetric assumption. -/
theorem IsSymmetric.inner_map_self_eq_zero {T : E →ₗ[𝕜] E} (hT : T.IsSymmetric) :
    (∀ x, ⟪T x, x⟫ = 0) ↔ T = 0 
goal: (∀ (x : E), ⟪T x, x⟫_𝕜 = 0) ↔ T = 0