File: Mathlib/Analysis/InnerProductSpace/LinearPMap.lean

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

full_name: LinearPMap.IsFormalAdjoint
code: /-- An operator `T` is a formal adjoint of `S` if for all `x` in the domain of `T` and `y` in the
domain of `S`, we have that `⟪T x, y⟫ = ⟪x, S y⟫`. -/
def IsFormalAdjoint (T : E →ₗ.[𝕜] F) (S : F →ₗ.[𝕜] E) : Prop 
goal: Prop

full_name: LinearPMap.IsFormalAdjoint.symm
code: @[symm]
protected theorem IsFormalAdjoint.symm (h : T.IsFormalAdjoint S) :
    S.IsFormalAdjoint T 
goal: S.IsFormalAdjoint T

full_name: LinearPMap.adjointDomain
code: /-- The domain of the adjoint operator.

This definition is needed to construct the adjoint operator and the preferred version to use is
`T.adjoint.domain` instead of `T.adjointDomain`. -/
def adjointDomain : Submodule 𝕜 F 
goal: Submodule 𝕜 F

full_name: LinearPMap.adjointDomainMkCLM
code: /-- The operator `fun x ↦ ⟪y, T x⟫` considered as a continuous linear operator
from `T.adjointDomain` to `𝕜`. -/
def adjointDomainMkCLM (y : T.adjointDomain) : T.domain →L[𝕜] 𝕜 
goal: ↥T.domain →L[𝕜] 𝕜

full_name: LinearPMap.adjointDomainMkCLM_apply
code: theorem adjointDomainMkCLM_apply (y : T.adjointDomain) (x : T.domain) :
    adjointDomainMkCLM T y x = ⟪(y : F), T x⟫ 
goal: (T.adjointDomainMkCLM y) x = ⟪↑y, ↑T x⟫_𝕜

full_name: LinearPMap.adjointDomainMkCLMExtend
code: /-- The unique continuous extension of the operator `adjointDomainMkCLM` to `E`. -/
def adjointDomainMkCLMExtend (y : T.adjointDomain) : E →L[𝕜] 𝕜 
goal: E →L[𝕜] 𝕜

full_name: LinearPMap.adjointDomainMkCLMExtend_apply
code: @[simp]
theorem adjointDomainMkCLMExtend_apply (y : T.adjointDomain) (x : T.domain) :
    adjointDomainMkCLMExtend hT y (x : E) = ⟪(y : F), T x⟫ 
goal: (LinearPMap.adjointDomainMkCLMExtend hT y) ↑x = ⟪↑y, ↑T x⟫_𝕜

full_name: LinearPMap.adjointAux
code: /-- The adjoint as a linear map from its domain to `E`.

This is an auxiliary definition needed to define the adjoint operator as a `LinearPMap` without
the assumption that `T.domain` is dense. -/
def adjointAux : T.adjointDomain →ₗ[𝕜] E 
goal: ↥T.adjointDomain →ₗ[𝕜] E

full_name: LinearPMap.adjointAux_inner
code: theorem adjointAux_inner (y : T.adjointDomain) (x : T.domain) :
    ⟪adjointAux hT y, x⟫ = ⟪(y : F), T x⟫ 
goal: ⟪(LinearPMap.adjointAux hT) y, ↑x⟫_𝕜 = ⟪↑y, ↑T x⟫_𝕜

full_name: LinearPMap.adjointAux_unique
code: theorem adjointAux_unique (y : T.adjointDomain) {x₀ : E}
    (hx₀ : ∀ x : T.domain, ⟪x₀, x⟫ = ⟪(y : F), T x⟫) : adjointAux hT y = x₀ 
goal: (LinearPMap.adjointAux hT) y = x₀

full_name: LinearPMap.adjoint
code: /-- The adjoint operator as a partially defined linear operator. -/
def adjoint : F →ₗ.[𝕜] E 
goal: F →ₗ.[𝕜] E

full_name: LinearPMap._aux_Mathlib_Analysis_InnerProductSpace_LinearPMap___unexpand_LinearPMap_adjoint_1
code: scoped postfix:1024 "†" => LinearPMap.adjoint
goal: Lean.PrettyPrinter.Unexpander

full_name: LinearPMap.«_aux_Mathlib_Analysis_InnerProductSpace_LinearPMap___macroRules_LinearPMap_term_†_1»
code: scoped postfix:1024 "†" => LinearPMap.adjoint
goal: Lean.Macro

full_name: LinearPMap.mem_adjoint_domain_iff
code: theorem mem_adjoint_domain_iff (y : F) : y ∈ T†.domain ↔ Continuous ((innerₛₗ 𝕜 y).comp T.toFun) 
goal: y ∈ T.adjoint.domain ↔ Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)

full_name: LinearPMap.mem_adjoint_domain_of_exists
code: theorem mem_adjoint_domain_of_exists (y : F) (h : ∃ w : E, ∀ x : T.domain, ⟪w, x⟫ = ⟪y, T x⟫) :
    y ∈ T†.domain 
goal: y ∈ T.adjoint.domain

full_name: LinearPMap.adjoint_apply_of_not_dense
code: theorem adjoint_apply_of_not_dense (hT : ¬Dense (T.domain : Set E)) (y : T†.domain) : T† y = 0 
goal: ↑T.adjoint y = 0

full_name: LinearPMap.adjoint_apply_of_dense
code: theorem adjoint_apply_of_dense (y : T†.domain) : T† y = adjointAux hT y 
goal: ↑T.adjoint y = (LinearPMap.adjointAux hT) y

full_name: LinearPMap.adjoint_apply_eq
code: theorem adjoint_apply_eq (y : T†.domain) {x₀ : E} (hx₀ : ∀ x : T.domain, ⟪x₀, x⟫ = ⟪(y : F), T x⟫) :
    T† y = x₀ 
goal: ↑T.adjoint y = x₀

full_name: LinearPMap.adjoint_isFormalAdjoint
code: /-- The fundamental property of the adjoint. -/
theorem adjoint_isFormalAdjoint : T†.IsFormalAdjoint T 
goal: T.adjoint.IsFormalAdjoint T

full_name: LinearPMap.IsFormalAdjoint.le_adjoint
code: /-- The adjoint is maximal in the sense that it contains every formal adjoint. -/
theorem IsFormalAdjoint.le_adjoint (h : T.IsFormalAdjoint S) : S ≤ T† 
goal: S ≤ T.adjoint

full_name: ContinuousLinearMap.toPMap_adjoint_eq_adjoint_toPMap_of_dense
code: /-- Restricting `A` to a dense submodule and taking the `LinearPMap.adjoint` is the same
as taking the `ContinuousLinearMap.adjoint` interpreted as a `LinearPMap`. -/
theorem toPMap_adjoint_eq_adjoint_toPMap_of_dense (hp : Dense (p : Set E)) :
    (A.toPMap p).adjoint = A.adjoint.toPMap ⊤ 
goal: ((↑A).toPMap p).adjoint = (↑(ContinuousLinearMap.adjoint A)).toPMap ⊤

full_name: LinearPMap.instStar
code: instance instStar : Star (E →ₗ.[𝕜] E) 
goal: Star (E →ₗ.[𝕜] E)

full_name: LinearPMap.isSelfAdjoint_def
code: theorem isSelfAdjoint_def : IsSelfAdjoint A ↔ A† = A 
goal: IsSelfAdjoint A ↔ A.adjoint = A

full_name: IsSelfAdjoint.dense_domain
code: /-- Every self-adjoint `LinearPMap` has dense domain.

This is not true by definition since we define the adjoint without the assumption that the
domain is dense, but the choice of the junk value implies that a `LinearPMap` cannot be self-adjoint
if it does not have dense domain. -/
theorem _root_.IsSelfAdjoint.dense_domain (hA : IsSelfAdjoint A) : Dense (A.domain : Set E) 
goal: Dense ↑A.domain