File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

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

full_name: ContinuousLinearMap.adjointAux
code: /-- The adjoint, as a continuous conjugate-linear map. This is only meant as an auxiliary
definition for the main definition `adjoint`, where this is bundled as a conjugate-linear isometric
equivalence. -/
noncomputable def adjointAux : (E →L[𝕜] F) →L⋆[𝕜] F →L[𝕜] E 
goal: (E →L[𝕜] F) →L⋆[𝕜] F →L[𝕜] E

full_name: ContinuousLinearMap.adjointAux_apply
code: @[simp]
theorem adjointAux_apply (A : E →L[𝕜] F) (x : F) :
    adjointAux A x = ((toDual 𝕜 E).symm : NormedSpace.Dual 𝕜 E → E) ((toSesqForm A) x) 
goal: (ContinuousLinearMap.adjointAux A) x = (InnerProductSpace.toDual 𝕜 E).symm ((ContinuousLinearMap.toSesqForm A) x)

full_name: ContinuousLinearMap.adjointAux_inner_left
code: theorem adjointAux_inner_left (A : E →L[𝕜] F) (x : E) (y : F) : ⟪adjointAux A y, x⟫ = ⟪y, A x⟫ 
goal: ⟪(ContinuousLinearMap.adjointAux A) y, x⟫_𝕜 = ⟪y, A x⟫_𝕜

full_name: ContinuousLinearMap.adjointAux_inner_right
code: theorem adjointAux_inner_right (A : E →L[𝕜] F) (x : E) (y : F) :
    ⟪x, adjointAux A y⟫ = ⟪A x, y⟫ 
goal: ⟪x, (ContinuousLinearMap.adjointAux A) y⟫_𝕜 = ⟪A x, y⟫_𝕜

full_name: ContinuousLinearMap.adjointAux_adjointAux
code: theorem adjointAux_adjointAux (A : E →L[𝕜] F) : adjointAux (adjointAux A) = A 
goal: ContinuousLinearMap.adjointAux (ContinuousLinearMap.adjointAux A) = A

full_name: ContinuousLinearMap.adjointAux_norm
code: @[simp]
theorem adjointAux_norm (A : E →L[𝕜] F) : ‖adjointAux A‖ = ‖A‖ 
goal: ‖ContinuousLinearMap.adjointAux A‖ = ‖A‖

full_name: ContinuousLinearMap.adjoint
code: /-- The adjoint of a bounded operator from Hilbert space `E` to Hilbert space `F`. -/
def adjoint : (E →L[𝕜] F) ≃ₗᵢ⋆[𝕜] F →L[𝕜] E 
goal: (E →L[𝕜] F) ≃ₗᵢ⋆[𝕜] F →L[𝕜] E

full_name: InnerProduct.«_aux_Mathlib_Analysis_InnerProductSpace_Adjoint___macroRules_InnerProduct_term_†_1»
code: scoped[InnerProduct] postfix:1000 "†" => ContinuousLinearMap.adjoint
goal: Lean.Macro

full_name: InnerProduct._aux_Mathlib_Analysis_InnerProductSpace_Adjoint___unexpand_ContinuousLinearMap_adjoint_1
code: scoped[InnerProduct] postfix:1000 "†" => ContinuousLinearMap.adjoint
goal: Lean.PrettyPrinter.Unexpander

full_name: ContinuousLinearMap.adjoint_inner_left
code: /-- The fundamental property of the adjoint. -/
theorem adjoint_inner_left (A : E →L[𝕜] F) (x : E) (y : F) : ⟪(A†) y, x⟫ = ⟪y, A x⟫ 
goal: ⟪(ContinuousLinearMap.adjoint A) y, x⟫_𝕜 = ⟪y, A x⟫_𝕜

full_name: ContinuousLinearMap.adjoint_inner_right
code: /-- The fundamental property of the adjoint. -/
theorem adjoint_inner_right (A : E →L[𝕜] F) (x : E) (y : F) : ⟪x, (A†) y⟫ = ⟪A x, y⟫ 
goal: ⟪x, (ContinuousLinearMap.adjoint A) y⟫_𝕜 = ⟪A x, y⟫_𝕜

full_name: ContinuousLinearMap.adjoint_adjoint
code: /-- The adjoint is involutive. -/
@[simp]
theorem adjoint_adjoint (A : E →L[𝕜] F) : A†† = A 
goal: ContinuousLinearMap.adjoint (ContinuousLinearMap.adjoint A) = A

full_name: ContinuousLinearMap.adjoint_comp
code: /-- The adjoint of the composition of two operators is the composition of the two adjoints
in reverse order. -/
@[simp]
theorem adjoint_comp (A : F →L[𝕜] G) (B : E →L[𝕜] F) : (A ∘L B)† = B† ∘L A† 
goal: ContinuousLinearMap.adjoint (A.comp B) = (ContinuousLinearMap.adjoint B).comp (ContinuousLinearMap.adjoint A)

full_name: ContinuousLinearMap.apply_norm_sq_eq_inner_adjoint_left
code: theorem apply_norm_sq_eq_inner_adjoint_left (A : E →L[𝕜] F) (x : E) :
    ‖A x‖ ^ 2 = re ⟪(A† ∘L A) x, x⟫ 
goal: ‖A x‖ ^ 2 = RCLike.re ⟪((ContinuousLinearMap.adjoint A).comp A) x, x⟫_𝕜

full_name: ContinuousLinearMap.apply_norm_eq_sqrt_inner_adjoint_left
code: theorem apply_norm_eq_sqrt_inner_adjoint_left (A : E →L[𝕜] F) (x : E) :
    ‖A x‖ = √(re ⟪(A† ∘L A) x, x⟫) 
goal: ‖A x‖ = √(RCLike.re ⟪((ContinuousLinearMap.adjoint A).comp A) x, x⟫_𝕜)

full_name: ContinuousLinearMap.apply_norm_sq_eq_inner_adjoint_right
code: theorem apply_norm_sq_eq_inner_adjoint_right (A : E →L[𝕜] F) (x : E) :
    ‖A x‖ ^ 2 = re ⟪x, (A† ∘L A) x⟫ 
goal: ‖A x‖ ^ 2 = RCLike.re ⟪x, ((ContinuousLinearMap.adjoint A).comp A) x⟫_𝕜

full_name: ContinuousLinearMap.apply_norm_eq_sqrt_inner_adjoint_right
code: theorem apply_norm_eq_sqrt_inner_adjoint_right (A : E →L[𝕜] F) (x : E) :
    ‖A x‖ = √(re ⟪x, (A† ∘L A) x⟫) 
goal: ‖A x‖ = √(RCLike.re ⟪x, ((ContinuousLinearMap.adjoint A).comp A) x⟫_𝕜)

full_name: ContinuousLinearMap.eq_adjoint_iff
code: /-- The adjoint is unique: a map `A` is the adjoint of `B` iff it satisfies `⟪A x, y⟫ = ⟪x, B y⟫`
for all `x` and `y`. -/
theorem eq_adjoint_iff (A : E →L[𝕜] F) (B : F →L[𝕜] E) : A = B† ↔ ∀ x y, ⟪A x, y⟫ = ⟪x, B y⟫ 
goal: A = ContinuousLinearMap.adjoint B ↔ ∀ (x : E) (y : F), ⟪A x, y⟫_𝕜 = ⟪x, B y⟫_𝕜

full_name: ContinuousLinearMap.adjoint_id
code: @[simp]
theorem adjoint_id :
    ContinuousLinearMap.adjoint (ContinuousLinearMap.id 𝕜 E) = ContinuousLinearMap.id 𝕜 E 
goal: ContinuousLinearMap.adjoint (ContinuousLinearMap.id 𝕜 E) = ContinuousLinearMap.id 𝕜 E

full_name: Submodule.adjoint_subtypeL
code: theorem _root_.Submodule.adjoint_subtypeL (U : Submodule 𝕜 E) [CompleteSpace U] :
    U.subtypeL† = orthogonalProjection U 
goal: ContinuousLinearMap.adjoint U.subtypeL = orthogonalProjection U

full_name: Submodule.adjoint_orthogonalProjection
code: theorem _root_.Submodule.adjoint_orthogonalProjection (U : Submodule 𝕜 E) [CompleteSpace U] :
    (orthogonalProjection U : E →L[𝕜] U)† = U.subtypeL 
goal: ContinuousLinearMap.adjoint (orthogonalProjection U) = U.subtypeL

full_name: ContinuousLinearMap.instStarId
code: /-- `E →L[𝕜] E` is a star algebra with the adjoint as the star operation. -/
instance : Star (E →L[𝕜] E) 
goal: Star (E →L[𝕜] E)

full_name: ContinuousLinearMap.instInvolutiveStarId
code: instance : InvolutiveStar (E →L[𝕜] E) 
goal: InvolutiveStar (E →L[𝕜] E)

full_name: ContinuousLinearMap.instStarMulId
code: instance : StarMul (E →L[𝕜] E) 
goal: StarMul (E →L[𝕜] E)

full_name: ContinuousLinearMap.instStarRingId
code: instance : StarRing (E →L[𝕜] E) 
goal: StarRing (E →L[𝕜] E)

full_name: ContinuousLinearMap.instStarModuleId
code: instance : StarModule 𝕜 (E →L[𝕜] E) 
goal: StarModule 𝕜 (E →L[𝕜] E)

full_name: ContinuousLinearMap.star_eq_adjoint
code: theorem star_eq_adjoint (A : E →L[𝕜] E) : star A = A† 
goal: star A = ContinuousLinearMap.adjoint A

full_name: ContinuousLinearMap.isSelfAdjoint_iff'
code: /-- A continuous linear operator is self-adjoint iff it is equal to its adjoint. -/
theorem isSelfAdjoint_iff' {A : E →L[𝕜] E} : IsSelfAdjoint A ↔ ContinuousLinearMap.adjoint A = A 
goal: IsSelfAdjoint A ↔ ContinuousLinearMap.adjoint A = A

full_name: ContinuousLinearMap.norm_adjoint_comp_self
code: theorem norm_adjoint_comp_self (A : E →L[𝕜] F) :
    ‖ContinuousLinearMap.adjoint A ∘L A‖ = ‖A‖ * ‖A‖ 
goal: ‖(ContinuousLinearMap.adjoint A).comp A‖ = ‖A‖ * ‖A‖

full_name: ContinuousLinearMap.instCstarRingId
code: instance : CstarRing (E →L[𝕜] E) 
goal: CstarRing (E →L[𝕜] E)

full_name: ContinuousLinearMap.isAdjointPair_inner
code: theorem isAdjointPair_inner (A : E →L[𝕜] F) :
    LinearMap.IsAdjointPair (sesqFormOfInner : E →ₗ[𝕜] E →ₗ⋆[𝕜] 𝕜)
      (sesqFormOfInner : F →ₗ[𝕜] F →ₗ⋆[𝕜] 𝕜) A (A†) 
goal: sesqFormOfInner.IsAdjointPair sesqFormOfInner ↑A ↑(ContinuousLinearMap.adjoint A)

full_name: IsSelfAdjoint.adjoint_eq
code: theorem adjoint_eq {A : E →L[𝕜] E} (hA : IsSelfAdjoint A) : ContinuousLinearMap.adjoint A = A 
goal: ContinuousLinearMap.adjoint A = A

full_name: IsSelfAdjoint.isSymmetric
code: /-- Every self-adjoint operator on an inner product space is symmetric. -/
theorem isSymmetric {A : E →L[𝕜] E} (hA : IsSelfAdjoint A) : (A : E →ₗ[𝕜] E).IsSymmetric 
goal: (↑A).IsSymmetric

full_name: IsSelfAdjoint.conj_adjoint
code: /-- Conjugating preserves self-adjointness. -/
theorem conj_adjoint {T : E →L[𝕜] E} (hT : IsSelfAdjoint T) (S : E →L[𝕜] F) :
    IsSelfAdjoint (S ∘L T ∘L ContinuousLinearMap.adjoint S) 
goal: IsSelfAdjoint (S.comp (T.comp (ContinuousLinearMap.adjoint S)))

full_name: IsSelfAdjoint.adjoint_conj
code: /-- Conjugating preserves self-adjointness. -/
theorem adjoint_conj {T : E →L[𝕜] E} (hT : IsSelfAdjoint T) (S : F →L[𝕜] E) :
    IsSelfAdjoint (ContinuousLinearMap.adjoint S ∘L T ∘L S) 
goal: IsSelfAdjoint ((ContinuousLinearMap.adjoint S).comp (T.comp S))

full_name: ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric
code: theorem _root_.ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric {A : E →L[𝕜] E} :
    IsSelfAdjoint A ↔ (A : E →ₗ[𝕜] E).IsSymmetric 
goal: IsSelfAdjoint A ↔ (↑A).IsSymmetric

full_name: LinearMap.IsSymmetric.isSelfAdjoint
code: theorem _root_.LinearMap.IsSymmetric.isSelfAdjoint {A : E →L[𝕜] E}
    (hA : (A : E →ₗ[𝕜] E).IsSymmetric) : IsSelfAdjoint A 
goal: IsSelfAdjoint A

full_name: orthogonalProjection_isSelfAdjoint
code: /-- The orthogonal projection is self-adjoint. -/
theorem _root_.orthogonalProjection_isSelfAdjoint (U : Submodule 𝕜 E) [CompleteSpace U] :
    IsSelfAdjoint (U.subtypeL ∘L orthogonalProjection U) 
goal: IsSelfAdjoint (U.subtypeL.comp (orthogonalProjection U))

full_name: IsSelfAdjoint.conj_orthogonalProjection
code: theorem conj_orthogonalProjection {T : E →L[𝕜] E} (hT : IsSelfAdjoint T) (U : Submodule 𝕜 E)
    [CompleteSpace U] :
    IsSelfAdjoint
      (U.subtypeL ∘L orthogonalProjection U ∘L T ∘L U.subtypeL ∘L orthogonalProjection U) 
goal: IsSelfAdjoint (U.subtypeL.comp ((orthogonalProjection U).comp (T.comp (U.subtypeL.comp (orthogonalProjection U)))))

full_name: LinearMap.IsSymmetric.toSelfAdjoint
code: /-- The **Hellinger--Toeplitz theorem**: Construct a self-adjoint operator from an everywhere
  defined symmetric operator. -/
def IsSymmetric.toSelfAdjoint (hT : IsSymmetric T) : selfAdjoint (E →L[𝕜] E) 
goal: ↥(selfAdjoint (E →L[𝕜] E))

full_name: LinearMap.IsSymmetric.coe_toSelfAdjoint
code: theorem IsSymmetric.coe_toSelfAdjoint (hT : IsSymmetric T) : (hT.toSelfAdjoint : E →ₗ[𝕜] E) = T 
goal: ↑↑hT.toSelfAdjoint = T

full_name: LinearMap.IsSymmetric.toSelfAdjoint_apply
code: theorem IsSymmetric.toSelfAdjoint_apply (hT : IsSymmetric T) {x : E} :
    (hT.toSelfAdjoint : E → E) x = T x 
goal: ↑hT.toSelfAdjoint x = T x

full_name: LinearMap.adjoint
code: /-- The adjoint of an operator from the finite-dimensional inner product space `E` to the
finite-dimensional inner product space `F`. -/
def adjoint : (E →ₗ[𝕜] F) ≃ₗ⋆[𝕜] F →ₗ[𝕜] E 
goal: (E →ₗ[𝕜] F) ≃ₗ⋆[𝕜] F →ₗ[𝕜] E

full_name: LinearMap.adjoint_toContinuousLinearMap
code: theorem adjoint_toContinuousLinearMap (A : E →ₗ[𝕜] F) :
    haveI := FiniteDimensional.complete 𝕜 E
    haveI := FiniteDimensional.complete 𝕜 F
    LinearMap.toContinuousLinearMap (LinearMap.adjoint A) =
      ContinuousLinearMap.adjoint (LinearMap.toContinuousLinearMap A) 
goal: LinearMap.toContinuousLinearMap (LinearMap.adjoint A) = ContinuousLinearMap.adjoint (LinearMap.toContinuousLinearMap A)

full_name: LinearMap.adjoint_eq_toCLM_adjoint
code: theorem adjoint_eq_toCLM_adjoint (A : E →ₗ[𝕜] F) :
    haveI := FiniteDimensional.complete 𝕜 E
    haveI := FiniteDimensional.complete 𝕜 F
    LinearMap.adjoint A = ContinuousLinearMap.adjoint (LinearMap.toContinuousLinearMap A) 
goal: LinearMap.adjoint A = ↑(ContinuousLinearMap.adjoint (LinearMap.toContinuousLinearMap A))

full_name: LinearMap.adjoint_inner_left
code: /-- The fundamental property of the adjoint. -/
theorem adjoint_inner_left (A : E →ₗ[𝕜] F) (x : E) (y : F) : ⟪adjoint A y, x⟫ = ⟪y, A x⟫ 
goal: ⟪(LinearMap.adjoint A) y, x⟫_𝕜 = ⟪y, A x⟫_𝕜

full_name: LinearMap.adjoint_inner_right
code: /-- The fundamental property of the adjoint. -/
theorem adjoint_inner_right (A : E →ₗ[𝕜] F) (x : E) (y : F) : ⟪x, adjoint A y⟫ = ⟪A x, y⟫ 
goal: ⟪x, (LinearMap.adjoint A) y⟫_𝕜 = ⟪A x, y⟫_𝕜

full_name: LinearMap.adjoint_adjoint
code: /-- The adjoint is involutive. -/
@[simp]
theorem adjoint_adjoint (A : E →ₗ[𝕜] F) : LinearMap.adjoint (LinearMap.adjoint A) = A 
goal: LinearMap.adjoint (LinearMap.adjoint A) = A

full_name: LinearMap.adjoint_comp
code: /-- The adjoint of the composition of two operators is the composition of the two adjoints
in reverse order. -/
@[simp]
theorem adjoint_comp (A : F →ₗ[𝕜] G) (B : E →ₗ[𝕜] F) :
    LinearMap.adjoint (A ∘ₗ B) = LinearMap.adjoint B ∘ₗ LinearMap.adjoint A 
goal: LinearMap.adjoint (A ∘ₗ B) = LinearMap.adjoint B ∘ₗ LinearMap.adjoint A

full_name: LinearMap.eq_adjoint_iff
code: /-- The adjoint is unique: a map `A` is the adjoint of `B` iff it satisfies `⟪A x, y⟫ = ⟪x, B y⟫`
for all `x` and `y`. -/
theorem eq_adjoint_iff (A : E →ₗ[𝕜] F) (B : F →ₗ[𝕜] E) :
    A = LinearMap.adjoint B ↔ ∀ x y, ⟪A x, y⟫ = ⟪x, B y⟫ 
goal: A = LinearMap.adjoint B ↔ ∀ (x : E) (y : F), ⟪A x, y⟫_𝕜 = ⟪x, B y⟫_𝕜

full_name: LinearMap.eq_adjoint_iff_basis
code: /-- The adjoint is unique: a map `A` is the adjoint of `B` iff it satisfies `⟪A x, y⟫ = ⟪x, B y⟫`
for all basis vectors `x` and `y`. -/
theorem eq_adjoint_iff_basis {ι₁ : Type*} {ι₂ : Type*} (b₁ : Basis ι₁ 𝕜 E) (b₂ : Basis ι₂ 𝕜 F)
    (A : E →ₗ[𝕜] F) (B : F →ₗ[𝕜] E) :
    A = LinearMap.adjoint B ↔ ∀ (i₁ : ι₁) (i₂ : ι₂), ⟪A (b₁ i₁), b₂ i₂⟫ = ⟪b₁ i₁, B (b₂ i₂)⟫ 
goal: A = LinearMap.adjoint B ↔ ∀ (i₁ : ι₁) (i₂ : ι₂), ⟪A (b₁ i₁), b₂ i₂⟫_𝕜 = ⟪b₁ i₁, B (b₂ i₂)⟫_𝕜

full_name: LinearMap.eq_adjoint_iff_basis_left
code: theorem eq_adjoint_iff_basis_left {ι : Type*} (b : Basis ι 𝕜 E) (A : E →ₗ[𝕜] F) (B : F →ₗ[𝕜] E) :
    A = LinearMap.adjoint B ↔ ∀ i y, ⟪A (b i), y⟫ = ⟪b i, B y⟫ 
goal: A = LinearMap.adjoint B ↔ ∀ (i : ι) (y : F), ⟪A (b i), y⟫_𝕜 = ⟪b i, B y⟫_𝕜

full_name: LinearMap.eq_adjoint_iff_basis_right
code: theorem eq_adjoint_iff_basis_right {ι : Type*} (b : Basis ι 𝕜 F) (A : E →ₗ[𝕜] F) (B : F →ₗ[𝕜] E) :
    A = LinearMap.adjoint B ↔ ∀ i x, ⟪A x, b i⟫ = ⟪x, B (b i)⟫ 
goal: A = LinearMap.adjoint B ↔ ∀ (i : ι) (x : E), ⟪A x, b i⟫_𝕜 = ⟪x, B (b i)⟫_𝕜

full_name: LinearMap.instStarId
code: /-- `E →ₗ[𝕜] E` is a star algebra with the adjoint as the star operation. -/
instance : Star (E →ₗ[𝕜] E) 
goal: Star (E →ₗ[𝕜] E)

full_name: LinearMap.instInvolutiveStarId
code: instance : InvolutiveStar (E →ₗ[𝕜] E) 
goal: InvolutiveStar (E →ₗ[𝕜] E)

full_name: LinearMap.instStarMulId
code: instance : StarMul (E →ₗ[𝕜] E) 
goal: StarMul (E →ₗ[𝕜] E)

full_name: LinearMap.instStarRingId
code: instance : StarRing (E →ₗ[𝕜] E) 
goal: StarRing (E →ₗ[𝕜] E)

full_name: LinearMap.instStarModuleId
code: instance : StarModule 𝕜 (E →ₗ[𝕜] E) 
goal: StarModule 𝕜 (E →ₗ[𝕜] E)

full_name: LinearMap.star_eq_adjoint
code: theorem star_eq_adjoint (A : E →ₗ[𝕜] E) : star A = LinearMap.adjoint A 
goal: star A = LinearMap.adjoint A

full_name: LinearMap.isSelfAdjoint_iff'
code: /-- A continuous linear operator is self-adjoint iff it is equal to its adjoint. -/
theorem isSelfAdjoint_iff' {A : E →ₗ[𝕜] E} : IsSelfAdjoint A ↔ LinearMap.adjoint A = A 
goal: IsSelfAdjoint A ↔ LinearMap.adjoint A = A

full_name: LinearMap.isSymmetric_iff_isSelfAdjoint
code: theorem isSymmetric_iff_isSelfAdjoint (A : E →ₗ[𝕜] E) : IsSymmetric A ↔ IsSelfAdjoint A 
goal: A.IsSymmetric ↔ IsSelfAdjoint A

full_name: LinearMap.isAdjointPair_inner
code: theorem isAdjointPair_inner (A : E →ₗ[𝕜] F) :
    IsAdjointPair (sesqFormOfInner : E →ₗ[𝕜] E →ₗ⋆[𝕜] 𝕜) (sesqFormOfInner : F →ₗ[𝕜] F →ₗ⋆[𝕜] 𝕜) A
      (LinearMap.adjoint A) 
goal: sesqFormOfInner.IsAdjointPair sesqFormOfInner A (LinearMap.adjoint A)

full_name: LinearMap.isSymmetric_adjoint_mul_self
code: /-- The Gram operator T†T is symmetric. -/
theorem isSymmetric_adjoint_mul_self (T : E →ₗ[𝕜] E) : IsSymmetric (LinearMap.adjoint T * T) 
goal: (LinearMap.adjoint T * T).IsSymmetric

full_name: LinearMap.re_inner_adjoint_mul_self_nonneg
code: /-- The Gram operator T†T is a positive operator. -/
theorem re_inner_adjoint_mul_self_nonneg (T : E →ₗ[𝕜] E) (x : E) :
    0 ≤ re ⟪x, (LinearMap.adjoint T * T) x⟫ 
goal: 0 ≤ RCLike.re ⟪x, (LinearMap.adjoint T * T) x⟫_𝕜

full_name: LinearMap.im_inner_adjoint_mul_self_eq_zero
code: @[simp]
theorem im_inner_adjoint_mul_self_eq_zero (T : E →ₗ[𝕜] E) (x : E) :
    im ⟪x, LinearMap.adjoint T (T x)⟫ = 0 
goal: RCLike.im ⟪x, (LinearMap.adjoint T) (T x)⟫_𝕜 = 0

full_name: ContinuousLinearMap.inner_map_map_iff_adjoint_comp_self
code: theorem inner_map_map_iff_adjoint_comp_self (u : H →L[𝕜] K) :
    (∀ x y : H, ⟪u x, u y⟫_𝕜 = ⟪x, y⟫_𝕜) ↔ adjoint u ∘L u = 1 
goal: (∀ (x y : H), ⟪u x, u y⟫_𝕜 = ⟪x, y⟫_𝕜) ↔ (ContinuousLinearMap.adjoint u).comp u = 1

full_name: ContinuousLinearMap.norm_map_iff_adjoint_comp_self
code: theorem norm_map_iff_adjoint_comp_self (u : H →L[𝕜] K) :
    (∀ x : H, ‖u x‖ = ‖x‖) ↔ adjoint u ∘L u = 1 
goal: (∀ (x : H), ‖u x‖ = ‖x‖) ↔ (ContinuousLinearMap.adjoint u).comp u = 1

full_name: LinearIsometryEquiv.adjoint_eq_symm
code: @[simp]
lemma _root_.LinearIsometryEquiv.adjoint_eq_symm (e : H ≃ₗᵢ[𝕜] K) :
    adjoint (e : H →L[𝕜] K) = e.symm 
goal: ContinuousLinearMap.adjoint ↑{ toLinearEquiv := e.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ } =
  ↑{ toLinearEquiv := e.symm.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }

full_name: LinearIsometryEquiv.star_eq_symm
code: @[simp]
lemma _root_.LinearIsometryEquiv.star_eq_symm (e : H ≃ₗᵢ[𝕜] H) :
    star (e : H →L[𝕜] H) = e.symm 
goal: star ↑{ toLinearEquiv := e.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ } =
  ↑{ toLinearEquiv := e.symm.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }

full_name: ContinuousLinearMap.norm_map_of_mem_unitary
code: theorem norm_map_of_mem_unitary {u : H →L[𝕜] H} (hu : u ∈ unitary (H →L[𝕜] H)) (x : H) :
    ‖u x‖ = ‖x‖ 
goal: ‖u x‖ = ‖x‖

full_name: ContinuousLinearMap.inner_map_map_of_mem_unitary
code: theorem inner_map_map_of_mem_unitary {u : H →L[𝕜] H} (hu : u ∈ unitary (H →L[𝕜] H)) (x y : H) :
    ⟪u x, u y⟫_𝕜 = ⟪x, y⟫_𝕜 
goal: ⟪u x, u y⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: unitary.norm_map
code: theorem norm_map (u : unitary (H →L[𝕜] H)) (x : H) : ‖(u : H →L[𝕜] H) x‖ = ‖x‖ 
goal: ‖↑u x‖ = ‖x‖

full_name: unitary.inner_map_map
code: theorem inner_map_map (u : unitary (H →L[𝕜] H)) (x y : H) :
    ⟪(u : H →L[𝕜] H) x, (u : H →L[𝕜] H) y⟫_𝕜 = ⟪x, y⟫_𝕜 
goal: ⟪↑u x, ↑u y⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: unitary.linearIsometryEquiv
code: /-- The unitary elements of continuous linear maps on a Hilbert space coincide with the linear
isometric equivalences on that Hilbert space. -/
noncomputable def linearIsometryEquiv : unitary (H →L[𝕜] H) ≃* (H ≃ₗᵢ[𝕜] H) 
goal: ↥(unitary (H →L[𝕜] H)) ≃* (H ≃ₗᵢ[𝕜] H)

full_name: unitary.linearIsometryEquiv_coe_apply
code: @[simp]
lemma linearIsometryEquiv_coe_apply (u : unitary (H →L[𝕜] H)) :
    linearIsometryEquiv u = (u : H →L[𝕜] H) 
goal: ↑{ toLinearEquiv := (unitary.linearIsometryEquiv u).toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ } = ↑u

full_name: unitary.linearIsometryEquiv_coe_symm_apply
code: @[simp]
lemma linearIsometryEquiv_coe_symm_apply (e : H ≃ₗᵢ[𝕜] H) :
    linearIsometryEquiv.symm e = (e : H →L[𝕜] H) 
goal: ↑(unitary.linearIsometryEquiv.symm e) =
  ↑{ toLinearEquiv := e.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }

full_name: Matrix.toLin_conjTranspose
code: /-- The linear map associated to the conjugate transpose of a matrix corresponding to two
orthonormal bases is the adjoint of the linear map associated to the matrix. -/
lemma Matrix.toLin_conjTranspose (A : Matrix m n 𝕜) :
    toLin v₂.toBasis v₁.toBasis Aᴴ = adjoint (toLin v₁.toBasis v₂.toBasis A) 
goal: (Matrix.toLin v₂.toBasis v₁.toBasis) A.conjTranspose = LinearMap.adjoint ((Matrix.toLin v₁.toBasis v₂.toBasis) A)

full_name: LinearMap.toMatrix_adjoint
code: /-- The matrix associated to the adjoint of a linear map corresponding to two orthonormal bases
is the conjugate tranpose of the matrix associated to the linear map. -/
lemma LinearMap.toMatrix_adjoint (f : E →ₗ[𝕜] F) :
    toMatrix v₂.toBasis v₁.toBasis (adjoint f) = (toMatrix v₁.toBasis v₂.toBasis f)ᴴ 
goal: (LinearMap.toMatrix v₂.toBasis v₁.toBasis) (LinearMap.adjoint f) =
  ((LinearMap.toMatrix v₁.toBasis v₂.toBasis) f).conjTranspose

full_name: LinearMap.toMatrixOrthonormal_apply
code: /-- The star algebra equivalence between the linear endomorphisms of finite-dimensional inner
product space and square matrices induced by the choice of an orthonormal basis. -/
@[simps]
def LinearMap.toMatrixOrthonormal : (E →ₗ[𝕜] E) ≃⋆ₐ[𝕜] Matrix n n 𝕜 
goal: ∀ (a : E →ₗ[𝕜] E), (LinearMap.toMatrixOrthonormal v₁) a = (↑(LinearMap.toMatrix v₁.toBasis v₁.toBasis)).toFun a

full_name: LinearMap.toMatrixOrthonormal
code: /-- The star algebra equivalence between the linear endomorphisms of finite-dimensional inner
product space and square matrices induced by the choice of an orthonormal basis. -/
@[simps]
def LinearMap.toMatrixOrthonormal : (E →ₗ[𝕜] E) ≃⋆ₐ[𝕜] Matrix n n 𝕜 
goal: (E →ₗ[𝕜] E) ≃⋆ₐ[𝕜] Matrix n n 𝕜

full_name: LinearMap.toMatrixOrthonormal_symm_apply
code: /-- The star algebra equivalence between the linear endomorphisms of finite-dimensional inner
product space and square matrices induced by the choice of an orthonormal basis. -/
@[simps]
def LinearMap.toMatrixOrthonormal : (E →ₗ[𝕜] E) ≃⋆ₐ[𝕜] Matrix n n 𝕜 
goal: ∀ (a : Matrix n n 𝕜), (LinearMap.toMatrixOrthonormal v₁).symm a = (LinearMap.toMatrix v₁.toBasis v₁.toBasis).invFun a

full_name: Matrix.toEuclideanLin_conjTranspose_eq_adjoint
code: /-- The adjoint of the linear map associated to a matrix is the linear map associated to the
conjugate transpose of that matrix. -/
theorem Matrix.toEuclideanLin_conjTranspose_eq_adjoint (A : Matrix m n 𝕜) :
    Matrix.toEuclideanLin A.conjTranspose = LinearMap.adjoint (Matrix.toEuclideanLin A) 
goal: Matrix.toEuclideanLin A.conjTranspose = LinearMap.adjoint (Matrix.toEuclideanLin A)