File: Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean

full_name: ContinuousLinearMapWOT
code: /-- The type copy of `E →L[𝕜] F` endowed with the weak operator topology, denoted as
`E →WOT[𝕜] F`. -/
@[irreducible]
def ContinuousLinearMapWOT (𝕜 : Type*) (E : Type*) (F : Type*) [Semiring 𝕜] [AddCommGroup E]
    [TopologicalSpace E] [Module 𝕜 E] [AddCommGroup F] [TopologicalSpace F] [Module 𝕜 F] 
goal: Type (max u_2 u_3)

full_name: «_aux_Mathlib_Analysis_Normed_Operator_WeakOperatorTopology___macroRules_term_→WOT[_]__1»
code: @[inherit_doc]
notation:25 E " →WOT[" 𝕜 "]" F => ContinuousLinearMapWOT 𝕜 E F
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Normed_Operator_WeakOperatorTopology___unexpand_ContinuousLinearMapWOT_1
code: @[inherit_doc]
notation:25 E " →WOT[" 𝕜 "]" F => ContinuousLinearMapWOT 𝕜 E F
goal: Lean.PrettyPrinter.Unexpander

full_name: ContinuousLinearMapWOT.«_aux_Mathlib_Analysis_Normed_Operator_WeakOperatorTopology___macroRules_ContinuousLinearMapWOT_term_⋆_1»
code: local postfix:max "⋆" => NormedSpace.Dual 𝕜
goal: Lean.Macro

full_name: ContinuousLinearMapWOT.instAddCommGroup
code: instance instAddCommGroup : AddCommGroup (E →WOT[𝕜] F) 
goal: AddCommGroup (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.instModule
code: instance instModule : Module 𝕜 (E →WOT[𝕜] F) 
goal: Module 𝕜 (E →WOT[𝕜]F)

full_name: ContinuousLinearMap.toWOT
code: /-- The linear equivalence that sends a continuous linear map to the type copy endowed with the
weak operator topology.  -/
def _root_.ContinuousLinearMap.toWOT : (E →L[𝕜] F) ≃ₗ[𝕜] (E →WOT[𝕜] F) 
goal: (E →L[𝕜] F) ≃ₗ[𝕜] E →WOT[𝕜]F

full_name: ContinuousLinearMapWOT.instFunLike
code: instance instFunLike : FunLike (E →WOT[𝕜] F) E F 
goal: FunLike (E →WOT[𝕜]F) E F

full_name: ContinuousLinearMapWOT.instContinuousLinearMapClass
code: instance instContinuousLinearMapClass : ContinuousLinearMapClass (E →WOT[𝕜] F) 𝕜 E F 
goal: ContinuousLinearMapClass (E →WOT[𝕜]F) 𝕜 E F

full_name: ContinuousLinearMap.toWOT_apply
code: lemma _root_.ContinuousLinearMap.toWOT_apply {A : E →L[𝕜] F} {x : E} :
    ((ContinuousLinearMap.toWOT 𝕜 E F) A) x = A x 
goal: ((ContinuousLinearMap.toWOT 𝕜 E F) A) x = A x

full_name: ContinuousLinearMapWOT.ext
code: lemma ext {A B : E →WOT[𝕜] F} (h : ∀ x, A x = B x) : A = B 
goal: A = B

full_name: ContinuousLinearMapWOT.ext_iff
code: lemma ext_iff {A B : E →WOT[𝕜] F} : A = B ↔ ∀ x, A x = B x 
goal: A = B ↔ ∀ (x : E), A x = B x

full_name: ContinuousLinearMapWOT.ext_dual
code: @[ext 900]
lemma ext_dual {A B : E →WOT[𝕜] F} (h : ∀ x (y : F⋆), y (A x) = y (B x)) : A = B 
goal: A = B

full_name: ContinuousLinearMapWOT.ext_dual_iff
code: lemma ext_dual_iff {A B : E →WOT[𝕜] F} :
    A = B ↔ ∀ x (y : F⋆), y (A x) = y (B x) 
goal: A = B ↔ ∀ (x : E) (y : NormedSpace.Dual 𝕜 F), y (A x) = y (B x)

full_name: ContinuousLinearMapWOT.zero_apply
code: @[simp] lemma zero_apply (x : E) : (0 : E →WOT[𝕜] F) x = 0 
goal: 0 x = 0

full_name: ContinuousLinearMapWOT.add_apply
code: @[simp] lemma add_apply {f g : E →WOT[𝕜] F} (x : E) : (f + g) x = f x + g x 
goal: (f + g) x = f x + g x

full_name: ContinuousLinearMapWOT.sub_apply
code: @[simp] lemma sub_apply {f g : E →WOT[𝕜] F} (x : E) : (f - g) x = f x - g x 
goal: (f - g) x = f x - g x

full_name: ContinuousLinearMapWOT.neg_apply
code: @[simp] lemma neg_apply {f : E →WOT[𝕜] F} (x : E) : (-f) x = -(f x) 
goal: (-f) x = -f x

full_name: ContinuousLinearMapWOT.smul_apply
code: @[simp] lemma smul_apply {f : E →WOT[𝕜] F} (c : 𝕜) (x : E) : (c • f) x = c • (f x) 
goal: (c • f) x = c • f x

full_name: ContinuousLinearMapWOT.inducingFn
code: /-- The function that induces the topology on `E →WOT[𝕜] F`, namely the function that takes
an `A` and maps it to `fun ⟨x, y⟩ => y (A x)` in `E × F⋆ → 𝕜`, bundled as a linear map to make
it easier to prove that it is a TVS. -/
def inducingFn : (E →WOT[𝕜] F) →ₗ[𝕜] (E × F⋆ → 𝕜) 
goal: (E →WOT[𝕜]F) →ₗ[𝕜] E × NormedSpace.Dual 𝕜 F → 𝕜

full_name: ContinuousLinearMapWOT.instTopologicalSpace
code: /-- The weak operator topology is the coarsest topology such that `fun A => y (A x)` is
continuous for all `x, y`. -/
instance instTopologicalSpace : TopologicalSpace (E →WOT[𝕜] F) 
goal: TopologicalSpace (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.continuous_inducingFn
code: @[fun_prop]
lemma continuous_inducingFn : Continuous (inducingFn 𝕜 E F) 
goal: Continuous ⇑(ContinuousLinearMapWOT.inducingFn 𝕜 E F)

full_name: ContinuousLinearMapWOT.continuous_dual_apply
code: lemma continuous_dual_apply (x : E) (y : F⋆) : Continuous fun (A : E →WOT[𝕜] F) => y (A x) 
goal: Continuous fun A => y (A x)

full_name: ContinuousLinearMapWOT.continuous_of_dual_apply_continuous
code: @[fun_prop]
lemma continuous_of_dual_apply_continuous {α : Type*} [TopologicalSpace α] {g : α → E →WOT[𝕜] F}
    (h : ∀ x (y : F⋆), Continuous fun a => y (g a x)) : Continuous g 
goal: Continuous g

full_name: ContinuousLinearMapWOT.embedding_inducingFn
code: lemma embedding_inducingFn : Embedding (inducingFn 𝕜 E F) 
goal: Embedding ⇑(ContinuousLinearMapWOT.inducingFn 𝕜 E F)

full_name: ContinuousLinearMapWOT.tendsto_iff_forall_dual_apply_tendsto
code: /-- The defining property of the weak operator topology: a function `f` tends to
`A : E →WOT[𝕜] F` along filter `l` iff `y (f a x)` tends to `y (A x)` along the same filter. -/
lemma tendsto_iff_forall_dual_apply_tendsto {α : Type*} {l : Filter α} {f : α → E →WOT[𝕜] F}
    {A : E →WOT[𝕜] F} :
    Tendsto f l (𝓝 A) ↔ ∀ x (y : F⋆), Tendsto (fun a => y (f a x)) l (𝓝 (y (A x))) 
goal: Filter.Tendsto f l (𝓝 A) ↔ ∀ (x : E) (y : NormedSpace.Dual 𝕜 F), Filter.Tendsto (fun a => y ((f a) x)) l (𝓝 (y (A x)))

full_name: ContinuousLinearMapWOT.le_nhds_iff_forall_dual_apply_le_nhds
code: lemma le_nhds_iff_forall_dual_apply_le_nhds {l : Filter (E →WOT[𝕜] F)} {A : E →WOT[𝕜] F} :
    l ≤ 𝓝 A ↔ ∀ x (y : F⋆), l.map (fun T => y (T x)) ≤ 𝓝 (y (A x)) 
goal: l ≤ 𝓝 A ↔ ∀ (x : E) (y : NormedSpace.Dual 𝕜 F), Filter.map (fun T => y (T x)) l ≤ 𝓝 (y (A x))

full_name: ContinuousLinearMapWOT.instT3Space
code: instance instT3Space : T3Space (E →WOT[𝕜] F) 
goal: T3Space (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.instContinuousAdd
code: instance instContinuousAdd : ContinuousAdd (E →WOT[𝕜] F) 
goal: ContinuousAdd (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.instContinuousNeg
code: instance instContinuousNeg : ContinuousNeg (E →WOT[𝕜] F) 
goal: ContinuousNeg (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.instContinuousSMul
code: instance instContinuousSMul : ContinuousSMul 𝕜 (E →WOT[𝕜] F) 
goal: ContinuousSMul 𝕜 (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.instTopologicalAddGroup
code: instance instTopologicalAddGroup : TopologicalAddGroup (E →WOT[𝕜] F) 
goal: TopologicalAddGroup (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.instUniformSpace
code: instance instUniformSpace : UniformSpace (E →WOT[𝕜] F) 
goal: UniformSpace (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.instUniformAddGroup
code: instance instUniformAddGroup : UniformAddGroup (E →WOT[𝕜] F) 
goal: UniformAddGroup (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.seminorm
code: /-- The family of seminorms that induce the weak operator topology, namely `‖y (A x)‖` for
all `x` and `y`.  -/
def seminorm (x : E) (y : F⋆) : Seminorm 𝕜 (E →WOT[𝕜] F) 
goal: Seminorm 𝕜 (E →WOT[𝕜]F)

full_name: ContinuousLinearMapWOT.seminormFamily
code: /-- The family of seminorms that induce the weak operator topology, namely `‖y (A x)‖` for
all `x` and `y`.  -/
def seminormFamily : SeminormFamily 𝕜 (E →WOT[𝕜] F) (E × F⋆) 
goal: SeminormFamily 𝕜 (E →WOT[𝕜]F) (E × NormedSpace.Dual 𝕜 F)

full_name: ContinuousLinearMapWOT.hasBasis_seminorms
code: lemma hasBasis_seminorms : (𝓝 (0 : E →WOT[𝕜] F)).HasBasis (seminormFamily 𝕜 E F).basisSets id 
goal: (𝓝 0).HasBasis (ContinuousLinearMapWOT.seminormFamily 𝕜 E F).basisSets id

full_name: ContinuousLinearMapWOT.withSeminorms
code: lemma withSeminorms : WithSeminorms (seminormFamily 𝕜 E F) 
goal: WithSeminorms (ContinuousLinearMapWOT.seminormFamily 𝕜 E F)

full_name: ContinuousLinearMapWOT.instLocallyConvexSpace
code: instance instLocallyConvexSpace [Module ℝ (E →WOT[𝕜] F)] [IsScalarTower ℝ 𝕜 (E →WOT[𝕜] F)] :
    LocallyConvexSpace ℝ (E →WOT[𝕜] F) 
goal: LocallyConvexSpace ℝ (E →WOT[𝕜]F)

full_name: ContinuousLinearMap.continuous_toWOT
code: /-- The weak operator topology is coarser than the norm topology, i.e. the inclusion map is
continuous. -/
@[continuity, fun_prop]
lemma ContinuousLinearMap.continuous_toWOT :
    Continuous (ContinuousLinearMap.toWOT 𝕜 E F) 
goal: Continuous ⇑(ContinuousLinearMap.toWOT 𝕜 E F)

full_name: ContinuousLinearMap.toWOTCLM
code: /-- The inclusion map from `E →[𝕜] F` to `E →WOT[𝕜] F`, bundled as a continuous linear map. -/
def ContinuousLinearMap.toWOTCLM : (E →L[𝕜] F) →L[𝕜] (E →WOT[𝕜] F) 
goal: (E →L[𝕜] F) →L[𝕜] E →WOT[𝕜]F