File: Mathlib/Topology/Algebra/Module/WeakDual.lean

full_name: WeakBilin
code: /-- The space `E` equipped with the weak topology induced by the bilinear form `B`. -/
@[nolint unusedArguments]
def WeakBilin [CommSemiring 𝕜] [AddCommMonoid E] [Module 𝕜 E] [AddCommMonoid F] [Module 𝕜 F]
    (_ : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) 
goal: (E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) → Type u_5

full_name: WeakBilin.instAddCommMonoid
code: instance instAddCommMonoid [CommSemiring 𝕜] [a : AddCommMonoid E] [Module 𝕜 E] [AddCommMonoid F]
    [Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) : AddCommMonoid (WeakBilin B) 
goal: AddCommMonoid (WeakBilin B)

full_name: WeakBilin.instModule
code: instance instModule [CommSemiring 𝕜] [AddCommMonoid E] [m : Module 𝕜 E] [AddCommMonoid F]
    [Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) : Module 𝕜 (WeakBilin B) 
goal: Module 𝕜 (WeakBilin B)

full_name: WeakBilin.instAddCommGroup
code: instance instAddCommGroup [CommSemiring 𝕜] [a : AddCommGroup E] [Module 𝕜 E] [AddCommMonoid F]
    [Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) : AddCommGroup (WeakBilin B) 
goal: AddCommGroup (WeakBilin B)

full_name: WeakBilin.instModule'
code: instance (priority := 100) instModule' [CommSemiring 𝕜] [CommSemiring 𝕝] [AddCommGroup E]
    [Module 𝕜 E] [AddCommGroup F] [Module 𝕜 F] [m : Module 𝕝 E] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) :
    Module 𝕝 (WeakBilin B) 
goal: Module 𝕝 (WeakBilin B)

full_name: WeakBilin.instIsScalarTower
code: instance instIsScalarTower [CommSemiring 𝕜] [CommSemiring 𝕝] [AddCommGroup E] [Module 𝕜 E]
    [AddCommGroup F] [Module 𝕜 F] [SMul 𝕝 𝕜] [Module 𝕝 E] [s : IsScalarTower 𝕝 𝕜 E]
    (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) : IsScalarTower 𝕝 𝕜 (WeakBilin B) 
goal: IsScalarTower 𝕝 𝕜 (WeakBilin B)

full_name: WeakBilin.instTopologicalSpace
code: instance instTopologicalSpace : TopologicalSpace (WeakBilin B) 
goal: TopologicalSpace (WeakBilin B)

full_name: WeakBilin.coeFn_continuous
code: /-- The coercion `(fun x y => B x y) : E → (F → 𝕜)` is continuous. -/
theorem coeFn_continuous : Continuous fun (x : WeakBilin B) y => B x y 
goal: Continuous fun x y => (B x) y

full_name: WeakBilin.eval_continuous
code: theorem eval_continuous (y : F) : Continuous fun x : WeakBilin B => B x y 
goal: Continuous fun x => (B x) y

full_name: WeakBilin.continuous_of_continuous_eval
code: theorem continuous_of_continuous_eval [TopologicalSpace α] {g : α → WeakBilin B}
    (h : ∀ y, Continuous fun a => B (g a) y) : Continuous g 
goal: Continuous g

full_name: WeakBilin.embedding
code: /-- The coercion `(fun x y => B x y) : E → (F → 𝕜)` is an embedding. -/
theorem embedding {B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜} (hB : Function.Injective B) :
    Embedding fun (x : WeakBilin B) y => B x y 
goal: Embedding fun x y => (B x) y

full_name: WeakBilin.tendsto_iff_forall_eval_tendsto
code: theorem tendsto_iff_forall_eval_tendsto {l : Filter α} {f : α → WeakBilin B} {x : WeakBilin B}
    (hB : Function.Injective B) :
    Tendsto f l (𝓝 x) ↔ ∀ y, Tendsto (fun i => B (f i) y) l (𝓝 (B x y)) 
goal: Filter.Tendsto f l (𝓝 x) ↔ ∀ (y : F), Filter.Tendsto (fun i => (B (f i)) y) l (𝓝 ((B x) y))

full_name: WeakBilin.instContinuousAdd
code: /-- Addition in `WeakBilin B` is continuous. -/
instance instContinuousAdd [ContinuousAdd 𝕜] : ContinuousAdd (WeakBilin B) 
goal: ContinuousAdd (WeakBilin B)

full_name: WeakBilin.instContinuousSMul
code: /-- Scalar multiplication by `𝕜` on `WeakBilin B` is continuous. -/
instance instContinuousSMul [ContinuousSMul 𝕜 𝕜] : ContinuousSMul 𝕜 (WeakBilin B) 
goal: ContinuousSMul 𝕜 (WeakBilin B)

full_name: WeakBilin.instTopologicalAddGroup
code: /-- `WeakBilin B` is a `TopologicalAddGroup`, meaning that addition and negation are
continuous. -/
instance instTopologicalAddGroup [ContinuousAdd 𝕜] : TopologicalAddGroup (WeakBilin B) 
goal: TopologicalAddGroup (WeakBilin B)

full_name: topDualPairing
code: /-- The canonical pairing of a vector space and its topological dual. -/
def topDualPairing (𝕜 E) [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜] [AddCommMonoid E]
    [Module 𝕜 E] [TopologicalSpace E] [ContinuousConstSMul 𝕜 𝕜] : (E →L[𝕜] 𝕜) →ₗ[𝕜] E →ₗ[𝕜] 𝕜 
goal: (E →L[𝕜] 𝕜) →ₗ[𝕜] E →ₗ[𝕜] 𝕜

full_name: topDualPairing_apply
code: theorem topDualPairing_apply (v : E →L[𝕜] 𝕜) (x : E) : topDualPairing 𝕜 E v x = v x 
goal: ((topDualPairing 𝕜 E) v) x = v x

full_name: WeakDual
code: /-- The weak star topology is the topology coarsest topology on `E →L[𝕜] 𝕜` such that all
functionals `fun v => v x` are continuous. -/
def WeakDual (𝕜 E : Type*) [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜]
    [ContinuousConstSMul 𝕜 𝕜] [AddCommMonoid E] [Module 𝕜 E] [TopologicalSpace E] 
goal: Type (max u_8 u_9)

full_name: WeakDual.instAddCommMonoid
code: instance instAddCommMonoid : AddCommMonoid (WeakDual 𝕜 E) 
goal: AddCommMonoid (WeakDual 𝕜 E)

full_name: WeakDual.instModule
code: instance instModule : Module 𝕜 (WeakDual 𝕜 E) 
goal: Module 𝕜 (WeakDual 𝕜 E)

full_name: WeakDual.instTopologicalSpace
code: instance instTopologicalSpace : TopologicalSpace (WeakDual 𝕜 E) 
goal: TopologicalSpace (WeakDual 𝕜 E)

full_name: WeakDual.instContinuousAdd
code: instance instContinuousAdd : ContinuousAdd (WeakDual 𝕜 E) 
goal: ContinuousAdd (WeakDual 𝕜 E)

full_name: WeakDual.instInhabited
code: instance instInhabited : Inhabited (WeakDual 𝕜 E) 
goal: Inhabited (WeakDual 𝕜 E)

full_name: WeakDual.instFunLike
code: instance instFunLike : FunLike (WeakDual 𝕜 E) E 𝕜 
goal: FunLike (WeakDual 𝕜 E) E 𝕜

full_name: WeakDual.instContinuousLinearMapClass
code: instance instContinuousLinearMapClass : ContinuousLinearMapClass (WeakDual 𝕜 E) 𝕜 E 𝕜 
goal: ContinuousLinearMapClass (WeakDual 𝕜 E) 𝕜 E 𝕜

full_name: WeakDual.instCoeFunForall
code: /-- Helper instance for when there's too many metavariables to apply `DFunLike.hasCoeToFun`
directly. -/
instance : CoeFun (WeakDual 𝕜 E) fun _ => E → 𝕜 
goal: CoeFun (WeakDual 𝕜 E) fun x => E → 𝕜

full_name: WeakDual.instMulAction
code: /-- If a monoid `M` distributively continuously acts on `𝕜` and this action commutes with
multiplication on `𝕜`, then it acts on `WeakDual 𝕜 E`. -/
instance instMulAction (M) [Monoid M] [DistribMulAction M 𝕜] [SMulCommClass 𝕜 M 𝕜]
    [ContinuousConstSMul M 𝕜] : MulAction M (WeakDual 𝕜 E) 
goal: MulAction M (WeakDual 𝕜 E)

full_name: WeakDual.instDistribMulAction
code: /-- If a monoid `M` distributively continuously acts on `𝕜` and this action commutes with
multiplication on `𝕜`, then it acts distributively on `WeakDual 𝕜 E`. -/
instance instDistribMulAction (M) [Monoid M] [DistribMulAction M 𝕜] [SMulCommClass 𝕜 M 𝕜]
    [ContinuousConstSMul M 𝕜] : DistribMulAction M (WeakDual 𝕜 E) 
goal: DistribMulAction M (WeakDual 𝕜 E)

full_name: WeakDual.instModule'
code: /-- If `𝕜` is a topological module over a semiring `R` and scalar multiplication commutes with the
multiplication on `𝕜`, then `WeakDual 𝕜 E` is a module over `R`. -/
instance instModule' (R) [Semiring R] [Module R 𝕜] [SMulCommClass 𝕜 R 𝕜] [ContinuousConstSMul R 𝕜] :
    Module R (WeakDual 𝕜 E) 
goal: Module R (WeakDual 𝕜 E)

full_name: WeakDual.instContinuousConstSMul
code: instance instContinuousConstSMul (M) [Monoid M] [DistribMulAction M 𝕜] [SMulCommClass 𝕜 M 𝕜]
    [ContinuousConstSMul M 𝕜] : ContinuousConstSMul M (WeakDual 𝕜 E) 
goal: ContinuousConstSMul M (WeakDual 𝕜 E)

full_name: WeakDual.instContinuousSMul
code: /-- If a monoid `M` distributively continuously acts on `𝕜` and this action commutes with
multiplication on `𝕜`, then it continuously acts on `WeakDual 𝕜 E`. -/
instance instContinuousSMul (M) [Monoid M] [DistribMulAction M 𝕜] [SMulCommClass 𝕜 M 𝕜]
    [TopologicalSpace M] [ContinuousSMul M 𝕜] : ContinuousSMul M (WeakDual 𝕜 E) 
goal: ContinuousSMul M (WeakDual 𝕜 E)

full_name: WeakDual.coeFn_continuous
code: theorem coeFn_continuous : Continuous fun (x : WeakDual 𝕜 E) y => x y 
goal: Continuous fun x y => x y

full_name: WeakDual.eval_continuous
code: theorem eval_continuous (y : E) : Continuous fun x : WeakDual 𝕜 E => x y 
goal: Continuous fun x => x y

full_name: WeakDual.continuous_of_continuous_eval
code: theorem continuous_of_continuous_eval [TopologicalSpace α] {g : α → WeakDual 𝕜 E}
    (h : ∀ y, Continuous fun a => (g a) y) : Continuous g 
goal: Continuous g

full_name: WeakDual.instT2Space
code: instance instT2Space [T2Space 𝕜] : T2Space (WeakDual 𝕜 E) 
goal: T2Space (WeakDual 𝕜 E)

full_name: WeakSpace
code: /-- The weak topology is the topology coarsest topology on `E` such that all functionals
`fun x => v x` are continuous. -/
def WeakSpace (𝕜 E) [CommSemiring 𝕜] [TopologicalSpace 𝕜] [ContinuousAdd 𝕜]
    [ContinuousConstSMul 𝕜 𝕜] [AddCommMonoid E] [Module 𝕜 E] [TopologicalSpace E] 
goal: Type u_9

full_name: WeakSpace.instAddCommMonoid
code: instance instAddCommMonoid : AddCommMonoid (WeakSpace 𝕜 E) 
goal: AddCommMonoid (WeakSpace 𝕜 E)

full_name: WeakSpace.instModule
code: instance instModule : Module 𝕜 (WeakSpace 𝕜 E) 
goal: Module 𝕜 (WeakSpace 𝕜 E)

full_name: WeakSpace.instTopologicalSpace
code: instance instTopologicalSpace : TopologicalSpace (WeakSpace 𝕜 E) 
goal: TopologicalSpace (WeakSpace 𝕜 E)

full_name: WeakSpace.instContinuousAdd
code: instance instContinuousAdd : ContinuousAdd (WeakSpace 𝕜 E) 
goal: ContinuousAdd (WeakSpace 𝕜 E)

full_name: WeakSpace.map
code: /-- A continuous linear map from `E` to `F` is still continuous when `E` and `F` are equipped with
their weak topologies. -/
def map (f : E →L[𝕜] F) : WeakSpace 𝕜 E →L[𝕜] WeakSpace 𝕜 F 
goal: WeakSpace 𝕜 E →L[𝕜] WeakSpace 𝕜 F

full_name: WeakSpace.map_apply
code: theorem map_apply (f : E →L[𝕜] F) (x : E) : WeakSpace.map f x = f x 
goal: (WeakSpace.map f) x = f x

full_name: WeakSpace.coe_map
code: @[simp]
theorem coe_map (f : E →L[𝕜] F) : (WeakSpace.map f : E → F) = f 
goal: ⇑(WeakSpace.map f) = ⇑f

full_name: toWeakSpace
code: /-- There is a canonical map `E → WeakSpace 𝕜 E` (the "identity"
mapping). It is a linear equivalence. -/
def toWeakSpace : E ≃ₗ[𝕜] WeakSpace 𝕜 E 
goal: E ≃ₗ[𝕜] WeakSpace 𝕜 E

full_name: continuousLinearMapToWeakSpace
code: /-- For a topological vector space `E`, "identity mapping" `E → WeakSpace 𝕜 E` is continuous.
This definition implements it as a continuous linear map. -/
def continuousLinearMapToWeakSpace : E →L[𝕜] WeakSpace 𝕜 E 
goal: E →L[𝕜] WeakSpace 𝕜 E

full_name: continuousLinearMapToWeakSpace_eq_toWeakSpace
code: @[simp]
theorem continuousLinearMapToWeakSpace_eq_toWeakSpace (x : E) :
    continuousLinearMapToWeakSpace 𝕜 E x = toWeakSpace 𝕜 E x 
goal: (continuousLinearMapToWeakSpace 𝕜 E) x = (toWeakSpace 𝕜 E) x

full_name: continuousLinearMapToWeakSpace_bijective
code: theorem continuousLinearMapToWeakSpace_bijective :
    Function.Bijective (continuousLinearMapToWeakSpace 𝕜 E) 
goal: Function.Bijective ⇑(continuousLinearMapToWeakSpace 𝕜 E)

full_name: isOpenMap_toWeakSpace_symm
code: /-- The canonical map from `WeakSpace 𝕜 E` to `E` is an open map. -/
theorem isOpenMap_toWeakSpace_symm : IsOpenMap (toWeakSpace 𝕜 E).symm 
goal: IsOpenMap ⇑(toWeakSpace 𝕜 E).symm

full_name: WeakSpace.isOpen_of_isOpen
code: /-- A set in `E` which is open in the weak topology is open. -/
theorem WeakSpace.isOpen_of_isOpen (V : Set E)
    (hV : IsOpen ((continuousLinearMapToWeakSpace 𝕜 E) '' V : Set (WeakSpace 𝕜 E))) : IsOpen V 
goal: IsOpen V

full_name: tendsto_iff_forall_eval_tendsto_topDualPairing
code: theorem tendsto_iff_forall_eval_tendsto_topDualPairing {l : Filter α} {f : α → WeakDual 𝕜 E}
    {x : WeakDual 𝕜 E} :
    Tendsto f l (𝓝 x) ↔
      ∀ y, Tendsto (fun i => topDualPairing 𝕜 E (f i) y) l (𝓝 (topDualPairing 𝕜 E x y)) 
goal: Filter.Tendsto f l (𝓝 x) ↔
  ∀ (y : E), Filter.Tendsto (fun i => ((topDualPairing 𝕜 E) (f i)) y) l (𝓝 (((topDualPairing 𝕜 E) x) y))