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

full_name: ContinuousSMul.of_nhds_zero
code: theorem ContinuousSMul.of_nhds_zero [TopologicalRing R] [TopologicalAddGroup M]
    (hmul : Tendsto (fun p : R × M => p.1 • p.2) (𝓝 0 ×ˢ 𝓝 0) (𝓝 0))
    (hmulleft : ∀ m : M, Tendsto (fun a : R => a • m) (𝓝 0) (𝓝 0))
    (hmulright : ∀ a : R, Tendsto (fun m : M => a • m) (𝓝 0) (𝓝 0)) : ContinuousSMul R M 
goal: ContinuousSMul R M

full_name: Submodule.eq_top_of_nonempty_interior'
code: /-- If `M` is a topological module over `R` and `0` is a limit of invertible elements of `R`, then
`⊤` is the only submodule of `M` with a nonempty interior.
This is the case, e.g., if `R` is a nontrivially normed field. -/
theorem Submodule.eq_top_of_nonempty_interior' [NeBot (𝓝[{ x : R | IsUnit x }] 0)]
    (s : Submodule R M) (hs : (interior (s : Set M)).Nonempty) : s = ⊤ 
goal: s = ⊤

full_name: Module.punctured_nhds_neBot
code: /-- Let `R` be a topological ring such that zero is not an isolated point (e.g., a nontrivially
normed field, see `NormedField.punctured_nhds_neBot`). Let `M` be a nontrivial module over `R`
such that `c • x = 0` implies `c = 0 ∨ x = 0`. Then `M` has no isolated points. We formulate this
using `NeBot (𝓝[≠] x)`.

This lemma is not an instance because Lean would need to find `[ContinuousSMul ?m_1 M]` with
unknown `?m_1`. We register this as an instance for `R = ℝ` in `Real.punctured_nhds_module_neBot`.
One can also use `haveI := Module.punctured_nhds_neBot R M` in a proof.
-/
theorem Module.punctured_nhds_neBot [Nontrivial M] [NeBot (𝓝[≠] (0 : R))] [NoZeroSMulDivisors R M]
    (x : M) : NeBot (𝓝[≠] x) 
goal: (𝓝[≠] x).NeBot

full_name: continuousSMul_induced
code: theorem continuousSMul_induced : @ContinuousSMul R M₁ _ u (t.induced f) 
goal: ContinuousSMul R M₁

full_name: TopologicalSpace.IsSeparable.span
code: /-- The span of a separable subset with respect to a separable scalar ring is again separable. -/
lemma TopologicalSpace.IsSeparable.span {R M : Type*} [AddCommMonoid M] [Semiring R] [Module R M]
    [TopologicalSpace M] [TopologicalSpace R] [SeparableSpace R]
    [ContinuousAdd M] [ContinuousSMul R M] {s : Set M} (hs : IsSeparable s) :
    IsSeparable (Submodule.span R s : Set M) 
goal: TopologicalSpace.IsSeparable ↑(Submodule.span R s)

full_name: Submodule.topologicalAddGroup
code: instance topologicalAddGroup [Ring α] [AddCommGroup β] [Module α β] [TopologicalAddGroup β]
    (S : Submodule α β) : TopologicalAddGroup S 
goal: TopologicalAddGroup ↥S

full_name: Submodule.mapsTo_smul_closure
code: theorem Submodule.mapsTo_smul_closure (s : Submodule R M) (c : R) :
    Set.MapsTo (c • ·) (closure s : Set M) (closure s) 
goal: Set.MapsTo (fun x => c • x) (closure ↑s) (closure ↑s)

full_name: Submodule.smul_closure_subset
code: theorem Submodule.smul_closure_subset (s : Submodule R M) (c : R) :
    c • closure (s : Set M) ⊆ closure (s : Set M) 
goal: c • closure ↑s ⊆ closure ↑s

full_name: Submodule.topologicalClosure
code: /-- The (topological-space) closure of a submodule of a topological `R`-module `M` is itself
a submodule. -/
def Submodule.topologicalClosure (s : Submodule R M) : Submodule R M 
goal: Submodule R M

full_name: Submodule.topologicalClosure_coe
code: @[simp]
theorem Submodule.topologicalClosure_coe (s : Submodule R M) :
    (s.topologicalClosure : Set M) = closure (s : Set M) 
goal: ↑s.topologicalClosure = closure ↑s

full_name: Submodule.le_topologicalClosure
code: theorem Submodule.le_topologicalClosure (s : Submodule R M) : s ≤ s.topologicalClosure 
goal: s ≤ s.topologicalClosure

full_name: Submodule.closure_subset_topologicalClosure_span
code: theorem Submodule.closure_subset_topologicalClosure_span (s : Set M) :
    closure s ⊆ (span R s).topologicalClosure 
goal: closure s ⊆ ↑(Submodule.span R s).topologicalClosure

full_name: Submodule.isClosed_topologicalClosure
code: theorem Submodule.isClosed_topologicalClosure (s : Submodule R M) :
    IsClosed (s.topologicalClosure : Set M) 
goal: IsClosed ↑s.topologicalClosure

full_name: Submodule.topologicalClosure_minimal
code: theorem Submodule.topologicalClosure_minimal (s : Submodule R M) {t : Submodule R M} (h : s ≤ t)
    (ht : IsClosed (t : Set M)) : s.topologicalClosure ≤ t 
goal: s.topologicalClosure ≤ t

full_name: Submodule.topologicalClosure_mono
code: theorem Submodule.topologicalClosure_mono {s : Submodule R M} {t : Submodule R M} (h : s ≤ t) :
    s.topologicalClosure ≤ t.topologicalClosure 
goal: s.topologicalClosure ≤ t.topologicalClosure

full_name: IsClosed.submodule_topologicalClosure_eq
code: /-- The topological closure of a closed submodule `s` is equal to `s`. -/
theorem IsClosed.submodule_topologicalClosure_eq {s : Submodule R M} (hs : IsClosed (s : Set M)) :
    s.topologicalClosure = s 
goal: s.topologicalClosure = s

full_name: Submodule.dense_iff_topologicalClosure_eq_top
code: /-- A subspace is dense iff its topological closure is the entire space. -/
theorem Submodule.dense_iff_topologicalClosure_eq_top {s : Submodule R M} :
    Dense (s : Set M) ↔ s.topologicalClosure = ⊤ 
goal: Dense ↑s ↔ s.topologicalClosure = ⊤

full_name: Submodule.topologicalClosure.completeSpace
code: instance Submodule.topologicalClosure.completeSpace {M' : Type*} [AddCommMonoid M'] [Module R M']
    [UniformSpace M'] [ContinuousAdd M'] [ContinuousConstSMul R M'] [CompleteSpace M']
    (U : Submodule R M') : CompleteSpace U.topologicalClosure 
goal: CompleteSpace ↥U.topologicalClosure

full_name: Submodule.isClosed_or_dense_of_isCoatom
code: /-- A maximal proper subspace of a topological module (i.e a `Submodule` satisfying `IsCoatom`)
is either closed or dense. -/
theorem Submodule.isClosed_or_dense_of_isCoatom (s : Submodule R M) (hs : IsCoatom s) :
    IsClosed (s : Set M) ∨ Dense (s : Set M) 
goal: IsClosed ↑s ∨ Dense ↑s

full_name: LinearMap.continuous_on_pi
code: theorem LinearMap.continuous_on_pi {ι : Type*} {R : Type*} {M : Type*} [Finite ι] [Semiring R]
    [TopologicalSpace R] [AddCommMonoid M] [Module R M] [TopologicalSpace M] [ContinuousAdd M]
    [ContinuousSMul R M] (f : (ι → R) →ₗ[R] M) : Continuous f 
goal: Continuous ⇑f

full_name: ContinuousLinearMap.cont
code: /-- Continuous linear maps between modules. We only put the type classes that are necessary for the
definition, although in applications `M` and `M₂` will be topological modules over the topological
ring `R`. -/
structure ContinuousLinearMap {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
    (M : Type*) [TopologicalSpace M] [AddCommMonoid M] (M₂ : Type*) [TopologicalSpace M₂]
    [AddCommMonoid M₂] [Module R M] [Module S M₂] extends M →ₛₗ[σ] M₂ where
  cont : Continuous toFun := by continuity
goal: Continuous (↑self).toFun

full_name: ContinuousLinearMap
code: /-- Continuous linear maps between modules. We only put the type classes that are necessary for the
definition, although in applications `M` and `M₂` will be topological modules over the topological
ring `R`. -/
structure ContinuousLinearMap {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
    (M : Type*) [TopologicalSpace M] [AddCommMonoid M] (M₂ : Type*) [TopologicalSpace M₂]
    [AddCommMonoid M₂] [Module R M] [Module S M₂] extends M →ₛₗ[σ] M₂ where
  cont : Continuous toFun := by continuity
goal: Type (max u_3 u_4)

full_name: «_aux_Mathlib_Topology_Algebra_Module_Basic___macroRules_term_→SL[_]__1»
code: @[inherit_doc]
notation:25 M " →SL[" σ "] " M₂ => ContinuousLinearMap σ M M₂
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_Algebra_Module_Basic___unexpand_ContinuousLinearMap_1
code: @[inherit_doc]
notation:25 M " →SL[" σ "] " M₂ => ContinuousLinearMap σ M M₂
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Topology_Algebra_Module_Basic___unexpand_ContinuousLinearMap_2
code: @[inherit_doc]
notation:25 M " →L[" R "] " M₂ => ContinuousLinearMap (RingHom.id R) M M₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Topology_Algebra_Module_Basic___macroRules_term_→L[_]__1»
code: @[inherit_doc]
notation:25 M " →L[" R "] " M₂ => ContinuousLinearMap (RingHom.id R) M M₂
goal: Lean.Macro

full_name: ContinuousSemilinearMapClass
code: /-- `ContinuousSemilinearMapClass F σ M M₂` asserts `F` is a type of bundled continuous
`σ`-semilinear maps `M → M₂`.  See also `ContinuousLinearMapClass F R M M₂` for the case where
`σ` is the identity map on `R`.  A map `f` between an `R`-module and an `S`-module over a ring
homomorphism `σ : R →+* S` is semilinear if it satisfies the two properties `f (x + y) = f x + f y`
and `f (c • x) = (σ c) • f x`. -/
class ContinuousSemilinearMapClass (F : Type*) {R S : outParam Type*} [Semiring R] [Semiring S]
    (σ : outParam <| R →+* S) (M : outParam Type*) [TopologicalSpace M] [AddCommMonoid M]
    (M₂ : outParam Type*) [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M]
    [Module S M₂] [FunLike F M M₂]
    extends SemilinearMapClass F σ M M₂, ContinuousMapClass F M M₂ : Prop
goal: Prop

full_name: ContinuousLinearMapClass
code: /-- `ContinuousLinearMapClass F R M M₂` asserts `F` is a type of bundled continuous
`R`-linear maps `M → M₂`.  This is an abbreviation for
`ContinuousSemilinearMapClass F (RingHom.id R) M M₂`.  -/
abbrev ContinuousLinearMapClass (F : Type*) (R : outParam Type*) [Semiring R]
    (M : outParam Type*) [TopologicalSpace M] [AddCommMonoid M] (M₂ : outParam Type*)
    [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M] [Module R M₂] [FunLike F M M₂] 
goal: Prop

full_name: ContinuousLinearEquiv.continuous_invFun
code: /-- Continuous linear equivalences between modules. We only put the type classes that are necessary
for the definition, although in applications `M` and `M₂` will be topological modules over the
topological semiring `R`. -/
-- Porting note (#5171): linter not ported yet; was @[nolint has_nonempty_instance]
structure ContinuousLinearEquiv {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
    {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : Type*) [TopologicalSpace M]
    [AddCommMonoid M] (M₂ : Type*) [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M]
    [Module S M₂] extends M ≃ₛₗ[σ] M₂ where
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Continuous self.invFun

full_name: ContinuousLinearEquiv
code: /-- Continuous linear equivalences between modules. We only put the type classes that are necessary
for the definition, although in applications `M` and `M₂` will be topological modules over the
topological semiring `R`. -/
-- Porting note (#5171): linter not ported yet; was @[nolint has_nonempty_instance]
structure ContinuousLinearEquiv {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
    {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : Type*) [TopologicalSpace M]
    [AddCommMonoid M] (M₂ : Type*) [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M]
    [Module S M₂] extends M ≃ₛₗ[σ] M₂ where
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Type (max u_3 u_4)

full_name: ContinuousLinearEquiv.continuous_toFun
code: /-- Continuous linear equivalences between modules. We only put the type classes that are necessary
for the definition, although in applications `M` and `M₂` will be topological modules over the
topological semiring `R`. -/
-- Porting note (#5171): linter not ported yet; was @[nolint has_nonempty_instance]
structure ContinuousLinearEquiv {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
    {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : Type*) [TopologicalSpace M]
    [AddCommMonoid M] (M₂ : Type*) [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M]
    [Module S M₂] extends M ≃ₛₗ[σ] M₂ where
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Continuous (↑self.toLinearEquiv).toFun

full_name: «_aux_Mathlib_Topology_Algebra_Module_Basic___macroRules_term_≃SL[_]__1»
code: @[inherit_doc]
notation:50 M " ≃SL[" σ "] " M₂ => ContinuousLinearEquiv σ M M₂
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_Algebra_Module_Basic___unexpand_ContinuousLinearEquiv_1
code: @[inherit_doc]
notation:50 M " ≃SL[" σ "] " M₂ => ContinuousLinearEquiv σ M M₂
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Topology_Algebra_Module_Basic___unexpand_ContinuousLinearEquiv_2
code: @[inherit_doc]
notation:50 M " ≃L[" R "] " M₂ => ContinuousLinearEquiv (RingHom.id R) M M₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Topology_Algebra_Module_Basic___macroRules_term_≃L[_]__1»
code: @[inherit_doc]
notation:50 M " ≃L[" R "] " M₂ => ContinuousLinearEquiv (RingHom.id R) M M₂
goal: Lean.Macro

full_name: ContinuousSemilinearEquivClass.map_continuous
code: /-- `ContinuousSemilinearEquivClass F σ M M₂` asserts `F` is a type of bundled continuous
`σ`-semilinear equivs `M → M₂`.  See also `ContinuousLinearEquivClass F R M M₂` for the case
where `σ` is the identity map on `R`.  A map `f` between an `R`-module and an `S`-module over a ring
homomorphism `σ : R →+* S` is semilinear if it satisfies the two properties `f (x + y) = f x + f y`
and `f (c • x) = (σ c) • f x`. -/
class ContinuousSemilinearEquivClass (F : Type*) {R : outParam Type*} {S : outParam Type*}
    [Semiring R] [Semiring S] (σ : outParam <| R →+* S) {σ' : outParam <| S →+* R}
    [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : outParam Type*) [TopologicalSpace M]
    [AddCommMonoid M] (M₂ : outParam Type*) [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M]
    [Module S M₂] [EquivLike F M M₂] extends SemilinearEquivClass F σ M M₂ : Prop where
  map_continuous : ∀ f : F, Continuous f := by continuity
  inv_continuous : ∀ f : F, Continuous (EquivLike.inv f) := by continuity
goal: Continuous ⇑f

full_name: ContinuousSemilinearEquivClass.inv_continuous
code: /-- `ContinuousSemilinearEquivClass F σ M M₂` asserts `F` is a type of bundled continuous
`σ`-semilinear equivs `M → M₂`.  See also `ContinuousLinearEquivClass F R M M₂` for the case
where `σ` is the identity map on `R`.  A map `f` between an `R`-module and an `S`-module over a ring
homomorphism `σ : R →+* S` is semilinear if it satisfies the two properties `f (x + y) = f x + f y`
and `f (c • x) = (σ c) • f x`. -/
class ContinuousSemilinearEquivClass (F : Type*) {R : outParam Type*} {S : outParam Type*}
    [Semiring R] [Semiring S] (σ : outParam <| R →+* S) {σ' : outParam <| S →+* R}
    [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : outParam Type*) [TopologicalSpace M]
    [AddCommMonoid M] (M₂ : outParam Type*) [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M]
    [Module S M₂] [EquivLike F M M₂] extends SemilinearEquivClass F σ M M₂ : Prop where
  map_continuous : ∀ f : F, Continuous f := by continuity
  inv_continuous : ∀ f : F, Continuous (EquivLike.inv f) := by continuity
goal: Continuous (EquivLike.inv f)

full_name: ContinuousSemilinearEquivClass
code: /-- `ContinuousSemilinearEquivClass F σ M M₂` asserts `F` is a type of bundled continuous
`σ`-semilinear equivs `M → M₂`.  See also `ContinuousLinearEquivClass F R M M₂` for the case
where `σ` is the identity map on `R`.  A map `f` between an `R`-module and an `S`-module over a ring
homomorphism `σ : R →+* S` is semilinear if it satisfies the two properties `f (x + y) = f x + f y`
and `f (c • x) = (σ c) • f x`. -/
class ContinuousSemilinearEquivClass (F : Type*) {R : outParam Type*} {S : outParam Type*}
    [Semiring R] [Semiring S] (σ : outParam <| R →+* S) {σ' : outParam <| S →+* R}
    [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : outParam Type*) [TopologicalSpace M]
    [AddCommMonoid M] (M₂ : outParam Type*) [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M]
    [Module S M₂] [EquivLike F M M₂] extends SemilinearEquivClass F σ M M₂ : Prop where
  map_continuous : ∀ f : F, Continuous f := by continuity
  inv_continuous : ∀ f : F, Continuous (EquivLike.inv f) := by continuity
goal: Prop

full_name: ContinuousLinearEquivClass
code: /-- `ContinuousLinearEquivClass F σ M M₂` asserts `F` is a type of bundled continuous
`R`-linear equivs `M → M₂`. This is an abbreviation for
`ContinuousSemilinearEquivClass F (RingHom.id R) M M₂`. -/
abbrev ContinuousLinearEquivClass (F : Type*) (R : outParam Type*) [Semiring R]
    (M : outParam Type*) [TopologicalSpace M] [AddCommMonoid M] (M₂ : outParam Type*)
    [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M] [Module R M₂] [EquivLike F M M₂] 
goal: Prop

full_name: ContinuousSemilinearEquivClass.continuousSemilinearMapClass
code: instance (priority := 100) continuousSemilinearMapClass [EquivLike F M M₂]
    [s : ContinuousSemilinearEquivClass F σ M M₂] : ContinuousSemilinearMapClass F σ M M₂ 
goal: ContinuousSemilinearMapClass F σ M M₂

full_name: linearMapOfMemClosureRangeCoe_apply
code: /-- Constructs a bundled linear map from a function and a proof that this function belongs to the
closure of the set of linear maps. -/
@[simps (config := .asFn)]
def linearMapOfMemClosureRangeCoe (f : M₁ → M₂)
    (hf : f ∈ closure (Set.range ((↑) : (M₁ →ₛₗ[σ] M₂) → M₁ → M₂))) : M₁ →ₛₗ[σ] M₂ 
goal: ⇑(linearMapOfMemClosureRangeCoe f hf) = (↑(addMonoidHomOfMemClosureRangeCoe f hf)).toFun

full_name: linearMapOfMemClosureRangeCoe
code: /-- Constructs a bundled linear map from a function and a proof that this function belongs to the
closure of the set of linear maps. -/
@[simps (config := .asFn)]
def linearMapOfMemClosureRangeCoe (f : M₁ → M₂)
    (hf : f ∈ closure (Set.range ((↑) : (M₁ →ₛₗ[σ] M₂) → M₁ → M₂))) : M₁ →ₛₗ[σ] M₂ 
goal: M₁ →ₛₗ[σ] M₂

full_name: linearMapOfTendsto_apply
code: /-- Construct a bundled linear map from a pointwise limit of linear maps -/
@[simps! (config := .asFn)]
def linearMapOfTendsto (f : M₁ → M₂) (g : α → M₁ →ₛₗ[σ] M₂) [l.NeBot]
    (h : Tendsto (fun a x => g a x) l (𝓝 f)) : M₁ →ₛₗ[σ] M₂ 
goal: ⇑(linearMapOfTendsto f g h) = f

full_name: linearMapOfTendsto
code: /-- Construct a bundled linear map from a pointwise limit of linear maps -/
@[simps! (config := .asFn)]
def linearMapOfTendsto (f : M₁ → M₂) (g : α → M₁ →ₛₗ[σ] M₂) [l.NeBot]
    (h : Tendsto (fun a x => g a x) l (𝓝 f)) : M₁ →ₛₗ[σ] M₂ 
goal: M₁ →ₛₗ[σ] M₂

full_name: LinearMap.isClosed_range_coe
code: theorem LinearMap.isClosed_range_coe : IsClosed (Set.range ((↑) : (M₁ →ₛₗ[σ] M₂) → M₁ → M₂)) 
goal: IsClosed (Set.range DFunLike.coe)

full_name: ContinuousLinearMap.LinearMap.coe
code: /-- Coerce continuous linear maps to linear maps. -/
instance LinearMap.coe : Coe (M₁ →SL[σ₁₂] M₂) (M₁ →ₛₗ[σ₁₂] M₂) 
goal: Coe (M₁ →SL[σ₁₂] M₂) (M₁ →ₛₗ[σ₁₂] M₂)

full_name: ContinuousLinearMap.coe_injective
code: theorem coe_injective : Function.Injective ((↑) : (M₁ →SL[σ₁₂] M₂) → M₁ →ₛₗ[σ₁₂] M₂) 
goal: Function.Injective ContinuousLinearMap.toLinearMap

full_name: ContinuousLinearMap.funLike
code: instance funLike : FunLike (M₁ →SL[σ₁₂] M₂) M₁ M₂ 
goal: FunLike (M₁ →SL[σ₁₂] M₂) M₁ M₂

full_name: ContinuousLinearMap.continuousSemilinearMapClass
code: instance continuousSemilinearMapClass :
    ContinuousSemilinearMapClass (M₁ →SL[σ₁₂] M₂) σ₁₂ M₁ M₂ 
goal: ContinuousSemilinearMapClass (M₁ →SL[σ₁₂] M₂) σ₁₂ M₁ M₂

full_name: ContinuousLinearMap.coe_mk
code: /-- Coerce continuous linear maps to functions. -/
--instance toFun' : CoeFun (M₁ →SL[σ₁₂] M₂) fun _ => M₁ → M₂ := ⟨DFunLike.coe⟩

-- porting note (#10618): was `simp`, now `simp only` proves it
theorem coe_mk (f : M₁ →ₛₗ[σ₁₂] M₂) (h) : (mk f h : M₁ →ₛₗ[σ₁₂] M₂) = f 
goal: ↑{ toLinearMap := f, cont := h } = f

full_name: ContinuousLinearMap.coe_mk'
code: @[simp]
theorem coe_mk' (f : M₁ →ₛₗ[σ₁₂] M₂) (h) : (mk f h : M₁ → M₂) = f 
goal: ⇑{ toLinearMap := f, cont := h } = ⇑f

full_name: ContinuousLinearMap.continuous
code: @[continuity, fun_prop]
protected theorem continuous (f : M₁ →SL[σ₁₂] M₂) : Continuous f 
goal: Continuous ⇑f

full_name: ContinuousLinearMap.uniformContinuous
code: protected theorem uniformContinuous {E₁ E₂ : Type*} [UniformSpace E₁] [UniformSpace E₂]
    [AddCommGroup E₁] [AddCommGroup E₂] [Module R₁ E₁] [Module R₂ E₂] [UniformAddGroup E₁]
    [UniformAddGroup E₂] (f : E₁ →SL[σ₁₂] E₂) : UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: ContinuousLinearMap.coe_inj
code: @[simp, norm_cast]
theorem coe_inj {f g : M₁ →SL[σ₁₂] M₂} : (f : M₁ →ₛₗ[σ₁₂] M₂) = g ↔ f = g 
goal: ↑f = ↑g ↔ f = g

full_name: ContinuousLinearMap.coeFn_injective
code: theorem coeFn_injective : @Function.Injective (M₁ →SL[σ₁₂] M₂) (M₁ → M₂) (↑) 
goal: Function.Injective DFunLike.coe

full_name: ContinuousLinearMap.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (h : M₁ →SL[σ₁₂] M₂) : M₁ → M₂ 
goal: M₁ → M₂

full_name: ContinuousLinearMap.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (h : M₁ →SL[σ₁₂] M₂) : M₁ →ₛₗ[σ₁₂] M₂ 
goal: M₁ →ₛₗ[σ₁₂] M₂

full_name: ContinuousLinearMap.ext
code: @[ext]
theorem ext {f g : M₁ →SL[σ₁₂] M₂} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: ContinuousLinearMap.ext_iff
code: protected theorem ext_iff {f g : M₁ →SL[σ₁₂] M₂} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : M₁), f x = g x

full_name: ContinuousLinearMap.copy
code: /-- Copy of a `ContinuousLinearMap` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. -/
protected def copy (f : M₁ →SL[σ₁₂] M₂) (f' : M₁ → M₂) (h : f' = ⇑f) : M₁ →SL[σ₁₂] M₂ 
goal: M₁ →SL[σ₁₂] M₂

full_name: ContinuousLinearMap.coe_copy
code: @[simp]
theorem coe_copy (f : M₁ →SL[σ₁₂] M₂) (f' : M₁ → M₂) (h : f' = ⇑f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: ContinuousLinearMap.copy_eq
code: theorem copy_eq (f : M₁ →SL[σ₁₂] M₂) (f' : M₁ → M₂) (h : f' = ⇑f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: ContinuousLinearMap.map_zero
code: protected theorem map_zero (f : M₁ →SL[σ₁₂] M₂) : f (0 : M₁) = 0 
goal: f 0 = 0

full_name: ContinuousLinearMap.map_add
code: protected theorem map_add (f : M₁ →SL[σ₁₂] M₂) (x y : M₁) : f (x + y) = f x + f y 
goal: f (x + y) = f x + f y

full_name: ContinuousLinearMap.map_smulₛₗ
code: protected theorem map_smulₛₗ (f : M₁ →SL[σ₁₂] M₂) (c : R₁) (x : M₁) : f (c • x) = σ₁₂ c • f x 
goal: f (c • x) = σ₁₂ c • f x

full_name: ContinuousLinearMap.map_smul
code: protected theorem map_smul [Module R₁ M₂] (f : M₁ →L[R₁] M₂) (c : R₁) (x : M₁) :
    f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: ContinuousLinearMap.map_smul_of_tower
code: @[simp]
theorem map_smul_of_tower {R S : Type*} [Semiring S] [SMul R M₁] [Module S M₁] [SMul R M₂]
    [Module S M₂] [LinearMap.CompatibleSMul M₁ M₂ R S] (f : M₁ →L[S] M₂) (c : R) (x : M₁) :
    f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: ContinuousLinearMap.map_sum
code: @[deprecated _root_.map_sum (since := "2023-09-16")]
protected theorem map_sum {ι : Type*} (f : M₁ →SL[σ₁₂] M₂) (s : Finset ι) (g : ι → M₁) :
    f (∑ i ∈ s, g i) = ∑ i ∈ s, f (g i) 
goal: f (∑ i ∈ s, g i) = ∑ i ∈ s, f (g i)

full_name: ContinuousLinearMap.coe_coe
code: @[simp, norm_cast]
theorem coe_coe (f : M₁ →SL[σ₁₂] M₂) : ⇑(f : M₁ →ₛₗ[σ₁₂] M₂) = f 
goal: ⇑↑f = ⇑f

full_name: ContinuousLinearMap.ext_ring
code: @[ext]
theorem ext_ring [TopologicalSpace R₁] {f g : R₁ →L[R₁] M₁} (h : f 1 = g 1) : f = g 
goal: f = g

full_name: ContinuousLinearMap.ext_ring_iff
code: protected theorem ext_ring_iff [TopologicalSpace R₁] {f g : R₁ →L[R₁] M₁} : f = g ↔ f 1 = g 1 
goal: f = g ↔ f 1 = g 1

full_name: ContinuousLinearMap.eqOn_closure_span
code: /-- If two continuous linear maps are equal on a set `s`, then they are equal on the closure
of the `Submodule.span` of this set. -/
theorem eqOn_closure_span [T2Space M₂] {s : Set M₁} {f g : M₁ →SL[σ₁₂] M₂} (h : Set.EqOn f g s) :
    Set.EqOn f g (closure (Submodule.span R₁ s : Set M₁)) 
goal: Set.EqOn (⇑f) (⇑g) (closure ↑(Submodule.span R₁ s))

full_name: ContinuousLinearMap.ext_on
code: /-- If the submodule generated by a set `s` is dense in the ambient module, then two continuous
linear maps equal on `s` are equal. -/
theorem ext_on [T2Space M₂] {s : Set M₁} (hs : Dense (Submodule.span R₁ s : Set M₁))
    {f g : M₁ →SL[σ₁₂] M₂} (h : Set.EqOn f g s) : f = g 
goal: f = g

full_name: Submodule.topologicalClosure_map
code: /-- Under a continuous linear map, the image of the `TopologicalClosure` of a submodule is
contained in the `TopologicalClosure` of its image. -/
theorem _root_.Submodule.topologicalClosure_map [RingHomSurjective σ₁₂] [TopologicalSpace R₁]
    [TopologicalSpace R₂] [ContinuousSMul R₁ M₁] [ContinuousAdd M₁] [ContinuousSMul R₂ M₂]
    [ContinuousAdd M₂] (f : M₁ →SL[σ₁₂] M₂) (s : Submodule R₁ M₁) :
    s.topologicalClosure.map (f : M₁ →ₛₗ[σ₁₂] M₂) ≤
      (s.map (f : M₁ →ₛₗ[σ₁₂] M₂)).topologicalClosure 
goal: Submodule.map (↑f) s.topologicalClosure ≤ (Submodule.map (↑f) s).topologicalClosure

full_name: DenseRange.topologicalClosure_map_submodule
code: /-- Under a dense continuous linear map, a submodule whose `TopologicalClosure` is `⊤` is sent to
another such submodule.  That is, the image of a dense set under a map with dense range is dense.
-/
theorem _root_.DenseRange.topologicalClosure_map_submodule [RingHomSurjective σ₁₂]
    [TopologicalSpace R₁] [TopologicalSpace R₂] [ContinuousSMul R₁ M₁] [ContinuousAdd M₁]
    [ContinuousSMul R₂ M₂] [ContinuousAdd M₂] {f : M₁ →SL[σ₁₂] M₂} (hf' : DenseRange f)
    {s : Submodule R₁ M₁} (hs : s.topologicalClosure = ⊤) :
    (s.map (f : M₁ →ₛₗ[σ₁₂] M₂)).topologicalClosure = ⊤ 
goal: (Submodule.map (↑f) s).topologicalClosure = ⊤

full_name: ContinuousLinearMap.instSMul
code: instance instSMul : SMul S₂ (M₁ →SL[σ₁₂] M₂) 
goal: SMul S₂ (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.mulAction
code: instance mulAction : MulAction S₂ (M₁ →SL[σ₁₂] M₂) 
goal: MulAction S₂ (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.smul_apply
code: theorem smul_apply (c : S₂) (f : M₁ →SL[σ₁₂] M₂) (x : M₁) : (c • f) x = c • f x 
goal: (c • f) x = c • f x

full_name: ContinuousLinearMap.coe_smul
code: @[simp, norm_cast]
theorem coe_smul (c : S₂) (f : M₁ →SL[σ₁₂] M₂) :
    ↑(c • f) = c • (f : M₁ →ₛₗ[σ₁₂] M₂) 
goal: ↑(c • f) = c • ↑f

full_name: ContinuousLinearMap.coe_smul'
code: @[simp, norm_cast]
theorem coe_smul' (c : S₂) (f : M₁ →SL[σ₁₂] M₂) :
    ↑(c • f) = c • (f : M₁ → M₂) 
goal: ⇑(c • f) = c • ⇑f

full_name: ContinuousLinearMap.isScalarTower
code: instance isScalarTower [SMul S₂ T₂] [IsScalarTower S₂ T₂ M₂] :
    IsScalarTower S₂ T₂ (M₁ →SL[σ₁₂] M₂) 
goal: IsScalarTower S₂ T₂ (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.smulCommClass
code: instance smulCommClass [SMulCommClass S₂ T₂ M₂] : SMulCommClass S₂ T₂ (M₁ →SL[σ₁₂] M₂) 
goal: SMulCommClass S₂ T₂ (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.zero
code: /-- The continuous map that is constantly zero. -/
instance zero : Zero (M₁ →SL[σ₁₂] M₂) 
goal: Zero (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.inhabited
code: instance inhabited : Inhabited (M₁ →SL[σ₁₂] M₂) 
goal: Inhabited (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.default_def
code: @[simp]
theorem default_def : (default : M₁ →SL[σ₁₂] M₂) = 0 
goal: default = 0

full_name: ContinuousLinearMap.zero_apply
code: @[simp]
theorem zero_apply (x : M₁) : (0 : M₁ →SL[σ₁₂] M₂) x = 0 
goal: 0 x = 0

full_name: ContinuousLinearMap.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ((0 : M₁ →SL[σ₁₂] M₂) : M₁ →ₛₗ[σ₁₂] M₂) = 0 
goal: ↑0 = 0

full_name: ContinuousLinearMap.coe_zero'
code: @[norm_cast]
theorem coe_zero' : ⇑(0 : M₁ →SL[σ₁₂] M₂) = 0 
goal: ⇑0 = 0

full_name: ContinuousLinearMap.uniqueOfLeft
code: instance uniqueOfLeft [Subsingleton M₁] : Unique (M₁ →SL[σ₁₂] M₂) 
goal: Unique (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.uniqueOfRight
code: instance uniqueOfRight [Subsingleton M₂] : Unique (M₁ →SL[σ₁₂] M₂) 
goal: Unique (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.exists_ne_zero
code: theorem exists_ne_zero {f : M₁ →SL[σ₁₂] M₂} (hf : f ≠ 0) : ∃ x, f x ≠ 0 
goal: ∃ x, f x ≠ 0

full_name: ContinuousLinearMap.id
code: /-- the identity map as a continuous linear map. -/
def id : M₁ →L[R₁] M₁ 
goal: M₁ →L[R₁] M₁

full_name: ContinuousLinearMap.one
code: instance one : One (M₁ →L[R₁] M₁) 
goal: One (M₁ →L[R₁] M₁)

full_name: ContinuousLinearMap.one_def
code: theorem one_def : (1 : M₁ →L[R₁] M₁) = id R₁ M₁ 
goal: 1 = ContinuousLinearMap.id R₁ M₁

full_name: ContinuousLinearMap.id_apply
code: theorem id_apply (x : M₁) : id R₁ M₁ x = x 
goal: (ContinuousLinearMap.id R₁ M₁) x = x

full_name: ContinuousLinearMap.coe_id
code: @[simp, norm_cast]
theorem coe_id : (id R₁ M₁ : M₁ →ₗ[R₁] M₁) = LinearMap.id 
goal: ↑(ContinuousLinearMap.id R₁ M₁) = LinearMap.id

full_name: ContinuousLinearMap.coe_id'
code: @[simp, norm_cast]
theorem coe_id' : ⇑(id R₁ M₁) = _root_.id 
goal: ⇑(ContinuousLinearMap.id R₁ M₁) = id

full_name: ContinuousLinearMap.coe_eq_id
code: @[simp, norm_cast]
theorem coe_eq_id {f : M₁ →L[R₁] M₁} : (f : M₁ →ₗ[R₁] M₁) = LinearMap.id ↔ f = id _ _ 
goal: ↑f = LinearMap.id ↔ f = ContinuousLinearMap.id R₁ M₁

full_name: ContinuousLinearMap.one_apply
code: @[simp]
theorem one_apply (x : M₁) : (1 : M₁ →L[R₁] M₁) x = x 
goal: 1 x = x

full_name: ContinuousLinearMap.instNontrivialId
code: instance [Nontrivial M₁] : Nontrivial (M₁ →L[R₁] M₁) 
goal: Nontrivial (M₁ →L[R₁] M₁)

full_name: ContinuousLinearMap.add
code: instance add : Add (M₁ →SL[σ₁₂] M₂) 
goal: Add (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.add_apply
code: @[simp]
theorem add_apply (f g : M₁ →SL[σ₁₂] M₂) (x : M₁) : (f + g) x = f x + g x 
goal: (f + g) x = f x + g x

full_name: ContinuousLinearMap.coe_add
code: @[simp, norm_cast]
theorem coe_add (f g : M₁ →SL[σ₁₂] M₂) : (↑(f + g) : M₁ →ₛₗ[σ₁₂] M₂) = f + g 
goal: ↑(f + g) = ↑f + ↑g

full_name: ContinuousLinearMap.coe_add'
code: @[norm_cast]
theorem coe_add' (f g : M₁ →SL[σ₁₂] M₂) : ⇑(f + g) = f + g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: ContinuousLinearMap.addCommMonoid
code: instance addCommMonoid : AddCommMonoid (M₁ →SL[σ₁₂] M₂) 
goal: AddCommMonoid (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.coe_sum
code: @[simp, norm_cast]
theorem coe_sum {ι : Type*} (t : Finset ι) (f : ι → M₁ →SL[σ₁₂] M₂) :
    ↑(∑ d ∈ t, f d) = (∑ d ∈ t, f d : M₁ →ₛₗ[σ₁₂] M₂) 
goal: ↑(∑ d ∈ t, f d) = ∑ d ∈ t, ↑(f d)

full_name: ContinuousLinearMap.coe_sum'
code: @[simp, norm_cast]
theorem coe_sum' {ι : Type*} (t : Finset ι) (f : ι → M₁ →SL[σ₁₂] M₂) :
    ⇑(∑ d ∈ t, f d) = ∑ d ∈ t, ⇑(f d) 
goal: ⇑(∑ d ∈ t, f d) = ∑ d ∈ t, ⇑(f d)

full_name: ContinuousLinearMap.sum_apply
code: theorem sum_apply {ι : Type*} (t : Finset ι) (f : ι → M₁ →SL[σ₁₂] M₂) (b : M₁) :
    (∑ d ∈ t, f d) b = ∑ d ∈ t, f d b 
goal: (∑ d ∈ t, f d) b = ∑ d ∈ t, (f d) b

full_name: ContinuousLinearMap.comp
code: /-- Composition of bounded linear maps. -/
def comp (g : M₂ →SL[σ₂₃] M₃) (f : M₁ →SL[σ₁₂] M₂) : M₁ →SL[σ₁₃] M₃ 
goal: M₁ →SL[σ₁₃] M₃

full_name: ContinuousLinearMap.«_aux_Mathlib_Topology_Algebra_Module_Basic___macroRules_ContinuousLinearMap_term_∘L__1»
code: @[inherit_doc comp]
infixr:80 " ∘L " =>
  @ContinuousLinearMap.comp _ _ _ _ _ _ (RingHom.id _) (RingHom.id _) (RingHom.id _) _ _ _ _ _ _ _ _
    _ _ _ _ RingHomCompTriple.ids
goal: Lean.Macro

full_name: ContinuousLinearMap.coe_comp
code: @[simp, norm_cast]
theorem coe_comp (h : M₂ →SL[σ₂₃] M₃) (f : M₁ →SL[σ₁₂] M₂) :
    (h.comp f : M₁ →ₛₗ[σ₁₃] M₃) = (h : M₂ →ₛₗ[σ₂₃] M₃).comp (f : M₁ →ₛₗ[σ₁₂] M₂) 
goal: ↑(h.comp f) = (↑h).comp ↑f

full_name: ContinuousLinearMap.coe_comp'
code: @[simp, norm_cast]
theorem coe_comp' (h : M₂ →SL[σ₂₃] M₃) (f : M₁ →SL[σ₁₂] M₂) : ⇑(h.comp f) = h ∘ f 
goal: ⇑(h.comp f) = ⇑h ∘ ⇑f

full_name: ContinuousLinearMap.comp_apply
code: theorem comp_apply (g : M₂ →SL[σ₂₃] M₃) (f : M₁ →SL[σ₁₂] M₂) (x : M₁) : (g.comp f) x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: ContinuousLinearMap.comp_id
code: @[simp]
theorem comp_id (f : M₁ →SL[σ₁₂] M₂) : f.comp (id R₁ M₁) = f 
goal: f.comp (ContinuousLinearMap.id R₁ M₁) = f

full_name: ContinuousLinearMap.id_comp
code: @[simp]
theorem id_comp (f : M₁ →SL[σ₁₂] M₂) : (id R₂ M₂).comp f = f 
goal: (ContinuousLinearMap.id R₂ M₂).comp f = f

full_name: ContinuousLinearMap.comp_zero
code: @[simp]
theorem comp_zero (g : M₂ →SL[σ₂₃] M₃) : g.comp (0 : M₁ →SL[σ₁₂] M₂) = 0 
goal: g.comp 0 = 0

full_name: ContinuousLinearMap.zero_comp
code: @[simp]
theorem zero_comp (f : M₁ →SL[σ₁₂] M₂) : (0 : M₂ →SL[σ₂₃] M₃).comp f = 0 
goal: ContinuousLinearMap.comp 0 f = 0

full_name: ContinuousLinearMap.comp_add
code: @[simp]
theorem comp_add [ContinuousAdd M₂] [ContinuousAdd M₃] (g : M₂ →SL[σ₂₃] M₃)
    (f₁ f₂ : M₁ →SL[σ₁₂] M₂) : g.comp (f₁ + f₂) = g.comp f₁ + g.comp f₂ 
goal: g.comp (f₁ + f₂) = g.comp f₁ + g.comp f₂

full_name: ContinuousLinearMap.add_comp
code: @[simp]
theorem add_comp [ContinuousAdd M₃] (g₁ g₂ : M₂ →SL[σ₂₃] M₃) (f : M₁ →SL[σ₁₂] M₂) :
    (g₁ + g₂).comp f = g₁.comp f + g₂.comp f 
goal: (g₁ + g₂).comp f = g₁.comp f + g₂.comp f

full_name: ContinuousLinearMap.comp_assoc
code: theorem comp_assoc {R₄ : Type*} [Semiring R₄] [Module R₄ M₄] {σ₁₄ : R₁ →+* R₄} {σ₂₄ : R₂ →+* R₄}
    {σ₃₄ : R₃ →+* R₄} [RingHomCompTriple σ₁₃ σ₃₄ σ₁₄] [RingHomCompTriple σ₂₃ σ₃₄ σ₂₄]
    [RingHomCompTriple σ₁₂ σ₂₄ σ₁₄] (h : M₃ →SL[σ₃₄] M₄) (g : M₂ →SL[σ₂₃] M₃) (f : M₁ →SL[σ₁₂] M₂) :
    (h.comp g).comp f = h.comp (g.comp f) 
goal: (h.comp g).comp f = h.comp (g.comp f)

full_name: ContinuousLinearMap.instMul
code: instance instMul : Mul (M₁ →L[R₁] M₁) 
goal: Mul (M₁ →L[R₁] M₁)

full_name: ContinuousLinearMap.mul_def
code: theorem mul_def (f g : M₁ →L[R₁] M₁) : f * g = f.comp g 
goal: f * g = f.comp g

full_name: ContinuousLinearMap.coe_mul
code: @[simp]
theorem coe_mul (f g : M₁ →L[R₁] M₁) : ⇑(f * g) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: ContinuousLinearMap.mul_apply
code: theorem mul_apply (f g : M₁ →L[R₁] M₁) (x : M₁) : (f * g) x = f (g x) 
goal: (f * g) x = f (g x)

full_name: ContinuousLinearMap.monoidWithZero
code: instance monoidWithZero : MonoidWithZero (M₁ →L[R₁] M₁) 
goal: MonoidWithZero (M₁ →L[R₁] M₁)

full_name: ContinuousLinearMap.coe_pow
code: theorem coe_pow (f : M₁ →L[R₁] M₁) (n : ℕ) : ⇑(f ^ n) = f^[n] 
goal: ⇑(f ^ n) = (⇑f)^[n]

full_name: ContinuousLinearMap.instNatCast
code: instance instNatCast [ContinuousAdd M₁] : NatCast (M₁ →L[R₁] M₁) 
goal: NatCast (M₁ →L[R₁] M₁)

full_name: ContinuousLinearMap.semiring
code: instance semiring [ContinuousAdd M₁] : Semiring (M₁ →L[R₁] M₁) 
goal: Semiring (M₁ →L[R₁] M₁)

full_name: ContinuousLinearMap.toLinearMapRingHom_apply
code: /-- `ContinuousLinearMap.toLinearMap` as a `RingHom`. -/
@[simps]
def toLinearMapRingHom [ContinuousAdd M₁] : (M₁ →L[R₁] M₁) →+* M₁ →ₗ[R₁] M₁ 
goal: ContinuousLinearMap.toLinearMapRingHom self = ↑self

full_name: ContinuousLinearMap.toLinearMapRingHom
code: /-- `ContinuousLinearMap.toLinearMap` as a `RingHom`. -/
@[simps]
def toLinearMapRingHom [ContinuousAdd M₁] : (M₁ →L[R₁] M₁) →+* M₁ →ₗ[R₁] M₁ 
goal: (M₁ →L[R₁] M₁) →+* M₁ →ₗ[R₁] M₁

full_name: ContinuousLinearMap.natCast_apply
code: @[simp]
theorem natCast_apply [ContinuousAdd M₁] (n : ℕ) (m : M₁) : (↑n : M₁ →L[R₁] M₁) m = n • m 
goal: ↑n m = n • m

full_name: ContinuousLinearMap.ofNat_apply
code: @[simp]
theorem ofNat_apply [ContinuousAdd M₁] (n : ℕ) [n.AtLeastTwo] (m : M₁) :
    ((no_index (OfNat.ofNat n) : M₁ →L[R₁] M₁)) m = OfNat.ofNat n • m 
goal: (OfNat.ofNat n) m = OfNat.ofNat n • m

full_name: ContinuousLinearMap.applyModule
code: /-- The tautological action by `M₁ →L[R₁] M₁` on `M`.

This generalizes `Function.End.applyMulAction`. -/
instance applyModule : Module (M₁ →L[R₁] M₁) M₁ 
goal: Module (M₁ →L[R₁] M₁) M₁

full_name: ContinuousLinearMap.smul_def
code: @[simp]
protected theorem smul_def (f : M₁ →L[R₁] M₁) (a : M₁) : f • a = f a 
goal: f • a = f a

full_name: ContinuousLinearMap.applyFaithfulSMul
code: /-- `ContinuousLinearMap.applyModule` is faithful. -/
instance applyFaithfulSMul : FaithfulSMul (M₁ →L[R₁] M₁) M₁ 
goal: FaithfulSMul (M₁ →L[R₁] M₁) M₁

full_name: ContinuousLinearMap.applySMulCommClass
code: instance applySMulCommClass : SMulCommClass R₁ (M₁ →L[R₁] M₁) M₁ 
goal: SMulCommClass R₁ (M₁ →L[R₁] M₁) M₁

full_name: ContinuousLinearMap.applySMulCommClass'
code: instance applySMulCommClass' : SMulCommClass (M₁ →L[R₁] M₁) R₁ M₁ 
goal: SMulCommClass (M₁ →L[R₁] M₁) R₁ M₁

full_name: ContinuousLinearMap.continuousConstSMul_apply
code: instance continuousConstSMul_apply : ContinuousConstSMul (M₁ →L[R₁] M₁) M₁ 
goal: ContinuousConstSMul (M₁ →L[R₁] M₁) M₁

full_name: ContinuousLinearMap.prod
code: /-- The cartesian product of two bounded linear maps, as a bounded linear map. -/
protected def prod [Module R₁ M₂] [Module R₁ M₃] (f₁ : M₁ →L[R₁] M₂) (f₂ : M₁ →L[R₁] M₃) :
    M₁ →L[R₁] M₂ × M₃ 
goal: M₁ →L[R₁] M₂ × M₃

full_name: ContinuousLinearMap.coe_prod
code: @[simp, norm_cast]
theorem coe_prod [Module R₁ M₂] [Module R₁ M₃] (f₁ : M₁ →L[R₁] M₂) (f₂ : M₁ →L[R₁] M₃) :
    (f₁.prod f₂ : M₁ →ₗ[R₁] M₂ × M₃) = LinearMap.prod f₁ f₂ 
goal: ↑(f₁.prod f₂) = (↑f₁).prod ↑f₂

full_name: ContinuousLinearMap.prod_apply
code: @[simp, norm_cast]
theorem prod_apply [Module R₁ M₂] [Module R₁ M₃] (f₁ : M₁ →L[R₁] M₂) (f₂ : M₁ →L[R₁] M₃) (x : M₁) :
    f₁.prod f₂ x = (f₁ x, f₂ x) 
goal: (f₁.prod f₂) x = (f₁ x, f₂ x)

full_name: ContinuousLinearMap.inl
code: /-- The left injection into a product is a continuous linear map. -/
def inl [Module R₁ M₂] : M₁ →L[R₁] M₁ × M₂ 
goal: M₁ →L[R₁] M₁ × M₂

full_name: ContinuousLinearMap.inr
code: /-- The right injection into a product is a continuous linear map. -/
def inr [Module R₁ M₂] : M₂ →L[R₁] M₁ × M₂ 
goal: M₂ →L[R₁] M₁ × M₂

full_name: ContinuousLinearMap.inl_apply
code: @[simp]
theorem inl_apply [Module R₁ M₂] (x : M₁) : inl R₁ M₁ M₂ x = (x, 0) 
goal: (ContinuousLinearMap.inl R₁ M₁ M₂) x = (x, 0)

full_name: ContinuousLinearMap.inr_apply
code: @[simp]
theorem inr_apply [Module R₁ M₂] (x : M₂) : inr R₁ M₁ M₂ x = (0, x) 
goal: (ContinuousLinearMap.inr R₁ M₁ M₂) x = (0, x)

full_name: ContinuousLinearMap.coe_inl
code: @[simp, norm_cast]
theorem coe_inl [Module R₁ M₂] : (inl R₁ M₁ M₂ : M₁ →ₗ[R₁] M₁ × M₂) = LinearMap.inl R₁ M₁ M₂ 
goal: ↑(ContinuousLinearMap.inl R₁ M₁ M₂) = LinearMap.inl R₁ M₁ M₂

full_name: ContinuousLinearMap.coe_inr
code: @[simp, norm_cast]
theorem coe_inr [Module R₁ M₂] : (inr R₁ M₁ M₂ : M₂ →ₗ[R₁] M₁ × M₂) = LinearMap.inr R₁ M₁ M₂ 
goal: ↑(ContinuousLinearMap.inr R₁ M₁ M₂) = LinearMap.inr R₁ M₁ M₂

full_name: ContinuousLinearMap.isClosed_ker
code: theorem isClosed_ker [T1Space M₂] [FunLike F M₁ M₂] [ContinuousSemilinearMapClass F σ₁₂ M₁ M₂]
    (f : F) :
    IsClosed (ker f : Set M₁) 
goal: IsClosed ↑(LinearMap.ker f)

full_name: ContinuousLinearMap.isComplete_ker
code: theorem isComplete_ker {M' : Type*} [UniformSpace M'] [CompleteSpace M'] [AddCommMonoid M']
    [Module R₁ M'] [T1Space M₂] [FunLike F M' M₂] [ContinuousSemilinearMapClass F σ₁₂ M' M₂]
    (f : F) :
    IsComplete (ker f : Set M') 
goal: IsComplete ↑(LinearMap.ker f)

full_name: ContinuousLinearMap.completeSpace_ker
code: instance completeSpace_ker {M' : Type*} [UniformSpace M'] [CompleteSpace M']
    [AddCommMonoid M'] [Module R₁ M'] [T1Space M₂]
    [FunLike F M' M₂] [ContinuousSemilinearMapClass F σ₁₂ M' M₂]
    (f : F) : CompleteSpace (ker f) 
goal: CompleteSpace ↥(LinearMap.ker f)

full_name: ContinuousLinearMap.completeSpace_eqLocus
code: instance completeSpace_eqLocus {M' : Type*} [UniformSpace M'] [CompleteSpace M']
    [AddCommMonoid M'] [Module R₁ M'] [T2Space M₂]
    [FunLike F M' M₂] [ContinuousSemilinearMapClass F σ₁₂ M' M₂]
    (f g : F) : CompleteSpace (LinearMap.eqLocus f g) 
goal: CompleteSpace ↥(LinearMap.eqLocus f g)

full_name: ContinuousLinearMap.ker_prod
code: @[simp]
theorem ker_prod [Module R₁ M₂] [Module R₁ M₃] (f : M₁ →L[R₁] M₂) (g : M₁ →L[R₁] M₃) :
    ker (f.prod g) = ker f ⊓ ker g 
goal: LinearMap.ker (f.prod g) = LinearMap.ker f ⊓ LinearMap.ker g

full_name: ContinuousLinearMap.codRestrict
code: /-- Restrict codomain of a continuous linear map. -/
def codRestrict (f : M₁ →SL[σ₁₂] M₂) (p : Submodule R₂ M₂) (h : ∀ x, f x ∈ p) :
    M₁ →SL[σ₁₂] p 
goal: M₁ →SL[σ₁₂] ↥p

full_name: ContinuousLinearMap.coe_codRestrict
code: @[norm_cast]
theorem coe_codRestrict (f : M₁ →SL[σ₁₂] M₂) (p : Submodule R₂ M₂) (h : ∀ x, f x ∈ p) :
    (f.codRestrict p h : M₁ →ₛₗ[σ₁₂] p) = (f : M₁ →ₛₗ[σ₁₂] M₂).codRestrict p h 
goal: ↑(f.codRestrict p h) = LinearMap.codRestrict p (↑f) h

full_name: ContinuousLinearMap.coe_codRestrict_apply
code: @[simp]
theorem coe_codRestrict_apply (f : M₁ →SL[σ₁₂] M₂) (p : Submodule R₂ M₂) (h : ∀ x, f x ∈ p) (x) :
    (f.codRestrict p h x : M₂) = f x 
goal: ↑((f.codRestrict p h) x) = f x

full_name: ContinuousLinearMap.ker_codRestrict
code: @[simp]
theorem ker_codRestrict (f : M₁ →SL[σ₁₂] M₂) (p : Submodule R₂ M₂) (h : ∀ x, f x ∈ p) :
    ker (f.codRestrict p h) = ker f 
goal: LinearMap.ker (f.codRestrict p h) = LinearMap.ker f

full_name: ContinuousLinearMap.rangeRestrict
code: /-- Restrict the codomain of a continuous linear map `f` to `f.range`. -/
abbrev rangeRestrict [RingHomSurjective σ₁₂] (f : M₁ →SL[σ₁₂] M₂) 
goal: M₁ →SL[σ₁₂] ↥(LinearMap.range f)

full_name: ContinuousLinearMap.coe_rangeRestrict
code: @[simp]
theorem coe_rangeRestrict [RingHomSurjective σ₁₂] (f : M₁ →SL[σ₁₂] M₂) :
    (f.rangeRestrict : M₁ →ₛₗ[σ₁₂] LinearMap.range f) = (f : M₁ →ₛₗ[σ₁₂] M₂).rangeRestrict 
goal: ↑f.rangeRestrict = (↑f).rangeRestrict

full_name: Submodule.subtypeL
code: /-- `Submodule.subtype` as a `ContinuousLinearMap`. -/
def _root_.Submodule.subtypeL (p : Submodule R₁ M₁) : p →L[R₁] M₁ 
goal: ↥p →L[R₁] M₁

full_name: Submodule.coe_subtypeL
code: @[simp, norm_cast]
theorem _root_.Submodule.coe_subtypeL (p : Submodule R₁ M₁) :
    (p.subtypeL : p →ₗ[R₁] M₁) = p.subtype 
goal: ↑p.subtypeL = p.subtype

full_name: Submodule.coe_subtypeL'
code: @[simp]
theorem _root_.Submodule.coe_subtypeL' (p : Submodule R₁ M₁) : ⇑p.subtypeL = p.subtype 
goal: ⇑p.subtypeL = ⇑p.subtype

full_name: Submodule.subtypeL_apply
code: @[simp] -- @[norm_cast] -- Porting note: A theorem with this can't have a rhs starting with `↑`.
theorem _root_.Submodule.subtypeL_apply (p : Submodule R₁ M₁) (x : p) : p.subtypeL x = x 
goal: p.subtypeL x = ↑x

full_name: Submodule.range_subtypeL
code: @[simp]
theorem _root_.Submodule.range_subtypeL (p : Submodule R₁ M₁) : range p.subtypeL = p 
goal: LinearMap.range p.subtypeL = p

full_name: Submodule.ker_subtypeL
code: @[simp]
theorem _root_.Submodule.ker_subtypeL (p : Submodule R₁ M₁) : ker p.subtypeL = ⊥ 
goal: LinearMap.ker p.subtypeL = ⊥

full_name: ContinuousLinearMap.fst
code: /-- `Prod.fst` as a `ContinuousLinearMap`. -/
def fst [Module R₁ M₂] : M₁ × M₂ →L[R₁] M₁ 
goal: M₁ × M₂ →L[R₁] M₁

full_name: ContinuousLinearMap.snd
code: /-- `Prod.snd` as a `ContinuousLinearMap`. -/
def snd [Module R₁ M₂] : M₁ × M₂ →L[R₁] M₂ 
goal: M₁ × M₂ →L[R₁] M₂

full_name: ContinuousLinearMap.coe_fst
code: @[simp, norm_cast]
theorem coe_fst [Module R₁ M₂] : ↑(fst R₁ M₁ M₂) = LinearMap.fst R₁ M₁ M₂ 
goal: ↑(ContinuousLinearMap.fst R₁ M₁ M₂) = LinearMap.fst R₁ M₁ M₂

full_name: ContinuousLinearMap.coe_fst'
code: @[simp, norm_cast]
theorem coe_fst' [Module R₁ M₂] : ⇑(fst R₁ M₁ M₂) = Prod.fst 
goal: ⇑(ContinuousLinearMap.fst R₁ M₁ M₂) = Prod.fst

full_name: ContinuousLinearMap.coe_snd
code: @[simp, norm_cast]
theorem coe_snd [Module R₁ M₂] : ↑(snd R₁ M₁ M₂) = LinearMap.snd R₁ M₁ M₂ 
goal: ↑(ContinuousLinearMap.snd R₁ M₁ M₂) = LinearMap.snd R₁ M₁ M₂

full_name: ContinuousLinearMap.coe_snd'
code: @[simp, norm_cast]
theorem coe_snd' [Module R₁ M₂] : ⇑(snd R₁ M₁ M₂) = Prod.snd 
goal: ⇑(ContinuousLinearMap.snd R₁ M₁ M₂) = Prod.snd

full_name: ContinuousLinearMap.fst_prod_snd
code: @[simp]
theorem fst_prod_snd [Module R₁ M₂] : (fst R₁ M₁ M₂).prod (snd R₁ M₁ M₂) = id R₁ (M₁ × M₂) 
goal: (ContinuousLinearMap.fst R₁ M₁ M₂).prod (ContinuousLinearMap.snd R₁ M₁ M₂) = ContinuousLinearMap.id R₁ (M₁ × M₂)

full_name: ContinuousLinearMap.fst_comp_prod
code: @[simp]
theorem fst_comp_prod [Module R₁ M₂] [Module R₁ M₃] (f : M₁ →L[R₁] M₂) (g : M₁ →L[R₁] M₃) :
    (fst R₁ M₂ M₃).comp (f.prod g) = f 
goal: (ContinuousLinearMap.fst R₁ M₂ M₃).comp (f.prod g) = f

full_name: ContinuousLinearMap.snd_comp_prod
code: @[simp]
theorem snd_comp_prod [Module R₁ M₂] [Module R₁ M₃] (f : M₁ →L[R₁] M₂) (g : M₁ →L[R₁] M₃) :
    (snd R₁ M₂ M₃).comp (f.prod g) = g 
goal: (ContinuousLinearMap.snd R₁ M₂ M₃).comp (f.prod g) = g

full_name: ContinuousLinearMap.prodMap
code: /-- `Prod.map` of two continuous linear maps. -/
def prodMap [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (f₁ : M₁ →L[R₁] M₂) (f₂ : M₃ →L[R₁] M₄) :
    M₁ × M₃ →L[R₁] M₂ × M₄ 
goal: M₁ × M₃ →L[R₁] M₂ × M₄

full_name: ContinuousLinearMap.coe_prodMap
code: @[simp, norm_cast]
theorem coe_prodMap [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (f₁ : M₁ →L[R₁] M₂)
    (f₂ : M₃ →L[R₁] M₄) : ↑(f₁.prodMap f₂) = (f₁ : M₁ →ₗ[R₁] M₂).prodMap (f₂ : M₃ →ₗ[R₁] M₄) 
goal: ↑(f₁.prodMap f₂) = (↑f₁).prodMap ↑f₂

full_name: ContinuousLinearMap.coe_prodMap'
code: @[simp, norm_cast]
theorem coe_prodMap' [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (f₁ : M₁ →L[R₁] M₂)
    (f₂ : M₃ →L[R₁] M₄) : ⇑(f₁.prodMap f₂) = Prod.map f₁ f₂ 
goal: ⇑(f₁.prodMap f₂) = Prod.map ⇑f₁ ⇑f₂

full_name: ContinuousLinearMap.coprod
code: /-- The continuous linear map given by `(x, y) ↦ f₁ x + f₂ y`. -/
def coprod [Module R₁ M₂] [Module R₁ M₃] [ContinuousAdd M₃] (f₁ : M₁ →L[R₁] M₃)
    (f₂ : M₂ →L[R₁] M₃) : M₁ × M₂ →L[R₁] M₃ 
goal: M₁ × M₂ →L[R₁] M₃

full_name: ContinuousLinearMap.coe_coprod
code: @[norm_cast, simp]
theorem coe_coprod [Module R₁ M₂] [Module R₁ M₃] [ContinuousAdd M₃] (f₁ : M₁ →L[R₁] M₃)
    (f₂ : M₂ →L[R₁] M₃) : (f₁.coprod f₂ : M₁ × M₂ →ₗ[R₁] M₃) = LinearMap.coprod f₁ f₂ 
goal: ↑(f₁.coprod f₂) = (↑f₁).coprod ↑f₂

full_name: ContinuousLinearMap.coprod_apply
code: @[simp]
theorem coprod_apply [Module R₁ M₂] [Module R₁ M₃] [ContinuousAdd M₃] (f₁ : M₁ →L[R₁] M₃)
    (f₂ : M₂ →L[R₁] M₃) (x) : f₁.coprod f₂ x = f₁ x.1 + f₂ x.2 
goal: (f₁.coprod f₂) x = f₁ x.1 + f₂ x.2

full_name: ContinuousLinearMap.range_coprod
code: theorem range_coprod [Module R₁ M₂] [Module R₁ M₃] [ContinuousAdd M₃] (f₁ : M₁ →L[R₁] M₃)
    (f₂ : M₂ →L[R₁] M₃) : range (f₁.coprod f₂) = range f₁ ⊔ range f₂ 
goal: LinearMap.range (f₁.coprod f₂) = LinearMap.range f₁ ⊔ LinearMap.range f₂

full_name: ContinuousLinearMap.comp_fst_add_comp_snd
code: theorem comp_fst_add_comp_snd [Module R₁ M₂] [Module R₁ M₃] [ContinuousAdd M₃] (f : M₁ →L[R₁] M₃)
    (g : M₂ →L[R₁] M₃) :
    f.comp (ContinuousLinearMap.fst R₁ M₁ M₂) + g.comp (ContinuousLinearMap.snd R₁ M₁ M₂) =
      f.coprod g 
goal: f.comp (ContinuousLinearMap.fst R₁ M₁ M₂) + g.comp (ContinuousLinearMap.snd R₁ M₁ M₂) = f.coprod g

full_name: ContinuousLinearMap.coprod_inl_inr
code: theorem coprod_inl_inr [ContinuousAdd M₁] [ContinuousAdd M'₁] :
    (ContinuousLinearMap.inl R₁ M₁ M'₁).coprod (ContinuousLinearMap.inr R₁ M₁ M'₁) =
      ContinuousLinearMap.id R₁ (M₁ × M'₁) 
goal: (ContinuousLinearMap.inl R₁ M₁ M'₁).coprod (ContinuousLinearMap.inr R₁ M₁ M'₁) = ContinuousLinearMap.id R₁ (M₁ × M'₁)

full_name: ContinuousLinearMap.smulRight
code: /-- The linear map `fun x => c x • f`.  Associates to a scalar-valued linear map and an element of
`M₂` the `M₂`-valued linear map obtained by multiplying the two (a.k.a. tensoring by `M₂`).
See also `ContinuousLinearMap.smulRightₗ` and `ContinuousLinearMap.smulRightL`. -/
def smulRight (c : M₁ →L[R] S) (f : M₂) : M₁ →L[R] M₂ 
goal: M₁ →L[R] M₂

full_name: ContinuousLinearMap.smulRight_apply
code: @[simp]
theorem smulRight_apply {c : M₁ →L[R] S} {f : M₂} {x : M₁} :
    (smulRight c f : M₁ → M₂) x = c x • f 
goal: (c.smulRight f) x = c x • f

full_name: ContinuousLinearMap.smulRight_one_one
code: @[simp]
theorem smulRight_one_one (c : R₁ →L[R₁] M₂) : smulRight (1 : R₁ →L[R₁] R₁) (c 1) = c 
goal: ContinuousLinearMap.smulRight 1 (c 1) = c

full_name: ContinuousLinearMap.smulRight_one_eq_iff
code: @[simp]
theorem smulRight_one_eq_iff {f f' : M₂} :
    smulRight (1 : R₁ →L[R₁] R₁) f = smulRight (1 : R₁ →L[R₁] R₁) f' ↔ f = f' 
goal: ContinuousLinearMap.smulRight 1 f = ContinuousLinearMap.smulRight 1 f' ↔ f = f'

full_name: ContinuousLinearMap.smulRight_comp
code: theorem smulRight_comp [ContinuousMul R₁] {x : M₂} {c : R₁} :
    (smulRight (1 : R₁ →L[R₁] R₁) x).comp (smulRight (1 : R₁ →L[R₁] R₁) c) =
      smulRight (1 : R₁ →L[R₁] R₁) (c • x) 
goal: (ContinuousLinearMap.smulRight 1 x).comp (ContinuousLinearMap.smulRight 1 c) = ContinuousLinearMap.smulRight 1 (c • x)

full_name: ContinuousLinearMap.toSpanSingleton
code: /-- Given an element `x` of a topological space `M` over a semiring `R`, the natural continuous
linear map from `R` to `M` by taking multiples of `x`. -/
def toSpanSingleton (x : M₁) : R₁ →L[R₁] M₁ 
goal: R₁ →L[R₁] M₁

full_name: ContinuousLinearMap.toSpanSingleton_apply
code: theorem toSpanSingleton_apply (x : M₁) (r : R₁) : toSpanSingleton R₁ x r = r • x 
goal: (ContinuousLinearMap.toSpanSingleton R₁ x) r = r • x

full_name: ContinuousLinearMap.toSpanSingleton_add
code: theorem toSpanSingleton_add [ContinuousAdd M₁] (x y : M₁) :
    toSpanSingleton R₁ (x + y) = toSpanSingleton R₁ x + toSpanSingleton R₁ y 
goal: ContinuousLinearMap.toSpanSingleton R₁ (x + y) =
  ContinuousLinearMap.toSpanSingleton R₁ x + ContinuousLinearMap.toSpanSingleton R₁ y

full_name: ContinuousLinearMap.toSpanSingleton_smul'
code: theorem toSpanSingleton_smul' {α} [Monoid α] [DistribMulAction α M₁] [ContinuousConstSMul α M₁]
    [SMulCommClass R₁ α M₁] (c : α) (x : M₁) :
    toSpanSingleton R₁ (c • x) = c • toSpanSingleton R₁ x 
goal: ContinuousLinearMap.toSpanSingleton R₁ (c • x) = c • ContinuousLinearMap.toSpanSingleton R₁ x

full_name: ContinuousLinearMap.toSpanSingleton_smul
code: /-- A special case of `to_span_singleton_smul'` for when `R` is commutative. -/
theorem toSpanSingleton_smul (R) {M₁} [CommSemiring R] [AddCommMonoid M₁] [Module R M₁]
    [TopologicalSpace R] [TopologicalSpace M₁] [ContinuousSMul R M₁] (c : R) (x : M₁) :
    toSpanSingleton R (c • x) = c • toSpanSingleton R x 
goal: ContinuousLinearMap.toSpanSingleton R (c • x) = c • ContinuousLinearMap.toSpanSingleton R x

full_name: ContinuousLinearMap.pi
code: /-- `pi` construction for continuous linear functions. From a family of continuous linear functions
it produces a continuous linear function into a family of topological modules. -/
def pi (f : ∀ i, M →L[R] φ i) : M →L[R] ∀ i, φ i 
goal: M →L[R] (i : ι) → φ i

full_name: ContinuousLinearMap.coe_pi'
code: @[simp]
theorem coe_pi' (f : ∀ i, M →L[R] φ i) : ⇑(pi f) = fun c i => f i c 
goal: ⇑(ContinuousLinearMap.pi f) = fun c i => (f i) c

full_name: ContinuousLinearMap.coe_pi
code: @[simp]
theorem coe_pi (f : ∀ i, M →L[R] φ i) : (pi f : M →ₗ[R] ∀ i, φ i) = LinearMap.pi fun i => f i 
goal: ↑(ContinuousLinearMap.pi f) = LinearMap.pi fun i => ↑(f i)

full_name: ContinuousLinearMap.pi_apply
code: theorem pi_apply (f : ∀ i, M →L[R] φ i) (c : M) (i : ι) : pi f c i = f i c 
goal: (ContinuousLinearMap.pi f) c i = (f i) c

full_name: ContinuousLinearMap.pi_eq_zero
code: theorem pi_eq_zero (f : ∀ i, M →L[R] φ i) : pi f = 0 ↔ ∀ i, f i = 0 
goal: ContinuousLinearMap.pi f = 0 ↔ ∀ (i : ι), f i = 0

full_name: ContinuousLinearMap.pi_zero
code: theorem pi_zero : pi (fun _ => 0 : ∀ i, M →L[R] φ i) = 0 
goal: (ContinuousLinearMap.pi fun x => 0) = 0

full_name: ContinuousLinearMap.pi_comp
code: theorem pi_comp (f : ∀ i, M →L[R] φ i) (g : M₂ →L[R] M) :
    (pi f).comp g = pi fun i => (f i).comp g 
goal: (ContinuousLinearMap.pi f).comp g = ContinuousLinearMap.pi fun i => (f i).comp g

full_name: ContinuousLinearMap.proj
code: /-- The projections from a family of topological modules are continuous linear maps. -/
def proj (i : ι) : (∀ i, φ i) →L[R] φ i 
goal: ((i : ι) → φ i) →L[R] φ i

full_name: ContinuousLinearMap.proj_apply
code: @[simp]
theorem proj_apply (i : ι) (b : ∀ i, φ i) : (proj i : (∀ i, φ i) →L[R] φ i) b = b i 
goal: (ContinuousLinearMap.proj i) b = b i

full_name: ContinuousLinearMap.proj_pi
code: theorem proj_pi (f : ∀ i, M₂ →L[R] φ i) (i : ι) : (proj i).comp (pi f) = f i 
goal: (ContinuousLinearMap.proj i).comp (ContinuousLinearMap.pi f) = f i

full_name: ContinuousLinearMap.iInf_ker_proj
code: theorem iInf_ker_proj : (⨅ i, ker (proj i : (∀ i, φ i) →L[R] φ i) : Submodule R (∀ i, φ i)) = ⊥ 
goal: ⨅ i, LinearMap.ker (ContinuousLinearMap.proj i) = ⊥

full_name: Pi.compRightL
code: /-- Given a function `f : α → ι`, it induces a continuous linear function by right composition on
product types. For `f = Subtype.val`, this corresponds to forgetting some set of variables. -/
def _root_.Pi.compRightL {α : Type*} (f : α → ι) : ((i : ι) → φ i) →L[R] ((i : α) → φ (f i)) 
goal: ((i : ι) → φ i) →L[R] (i : α) → φ (f i)

full_name: Pi.compRightL_apply
code: @[simp] lemma _root_.Pi.compRightL_apply {α : Type*} (f : α → ι) (v : (i : ι) → φ i) (i : α) :
    Pi.compRightL R φ f v i = v (f i) 
goal: (Pi.compRightL R φ f) v i = v (f i)

full_name: ContinuousLinearMap.iInfKerProjEquiv
code: /-- If `I` and `J` are complementary index sets, the product of the kernels of the `J`th projections
of `φ` is linearly equivalent to the product over `I`. -/
def iInfKerProjEquiv {I J : Set ι} [DecidablePred fun i => i ∈ I] (hd : Disjoint I J)
    (hu : Set.univ ⊆ I ∪ J) :
    (⨅ i ∈ J, ker (proj i : (∀ i, φ i) →L[R] φ i) :
    Submodule R (∀ i, φ i)) ≃L[R] ∀ i : I, φ i 
goal: ↥(⨅ i ∈ J, LinearMap.ker (ContinuousLinearMap.proj i)) ≃L[R] (i : ↑I) → φ ↑i

full_name: ContinuousLinearMap.map_neg
code: protected theorem map_neg (f : M →SL[σ₁₂] M₂) (x : M) : f (-x) = -f x 
goal: f (-x) = -f x

full_name: ContinuousLinearMap.map_sub
code: protected theorem map_sub (f : M →SL[σ₁₂] M₂) (x y : M) : f (x - y) = f x - f y 
goal: f (x - y) = f x - f y

full_name: ContinuousLinearMap.sub_apply'
code: @[simp]
theorem sub_apply' (f g : M →SL[σ₁₂] M₂) (x : M) : ((f : M →ₛₗ[σ₁₂] M₂) - g) x = f x - g x 
goal: (↑f - ↑g) x = f x - g x

full_name: ContinuousLinearMap.range_prod_eq
code: theorem range_prod_eq {f : M →L[R] M₂} {g : M →L[R] M₃} (h : ker f ⊔ ker g = ⊤) :
    range (f.prod g) = (range f).prod (range g) 
goal: LinearMap.range (f.prod g) = (LinearMap.range f).prod (LinearMap.range g)

full_name: ContinuousLinearMap.ker_prod_ker_le_ker_coprod
code: theorem ker_prod_ker_le_ker_coprod [ContinuousAdd M₃] (f : M →L[R] M₃) (g : M₂ →L[R] M₃) :
    (LinearMap.ker f).prod (LinearMap.ker g) ≤ LinearMap.ker (f.coprod g) 
goal: (LinearMap.ker f).prod (LinearMap.ker g) ≤ LinearMap.ker (f.coprod g)

full_name: ContinuousLinearMap.ker_coprod_of_disjoint_range
code: theorem ker_coprod_of_disjoint_range [ContinuousAdd M₃] (f : M →L[R] M₃) (g : M₂ →L[R] M₃)
    (hd : Disjoint (range f) (range g)) :
    LinearMap.ker (f.coprod g) = (LinearMap.ker f).prod (LinearMap.ker g) 
goal: LinearMap.ker (f.coprod g) = (LinearMap.ker f).prod (LinearMap.ker g)

full_name: ContinuousLinearMap.neg
code: instance neg : Neg (M →SL[σ₁₂] M₂) 
goal: Neg (M →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.neg_apply
code: @[simp]
theorem neg_apply (f : M →SL[σ₁₂] M₂) (x : M) : (-f) x = -f x 
goal: (-f) x = -f x

full_name: ContinuousLinearMap.coe_neg
code: @[simp, norm_cast]
theorem coe_neg (f : M →SL[σ₁₂] M₂) : (↑(-f) : M →ₛₗ[σ₁₂] M₂) = -f 
goal: ↑(-f) = -↑f

full_name: ContinuousLinearMap.coe_neg'
code: @[norm_cast]
theorem coe_neg' (f : M →SL[σ₁₂] M₂) : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: ContinuousLinearMap.sub
code: instance sub : Sub (M →SL[σ₁₂] M₂) 
goal: Sub (M →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.addCommGroup
code: instance addCommGroup : AddCommGroup (M →SL[σ₁₂] M₂) 
goal: AddCommGroup (M →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.sub_apply
code: theorem sub_apply (f g : M →SL[σ₁₂] M₂) (x : M) : (f - g) x = f x - g x 
goal: (f - g) x = f x - g x

full_name: ContinuousLinearMap.coe_sub
code: @[simp, norm_cast]
theorem coe_sub (f g : M →SL[σ₁₂] M₂) : (↑(f - g) : M →ₛₗ[σ₁₂] M₂) = f - g 
goal: ↑(f - g) = ↑f - ↑g

full_name: ContinuousLinearMap.coe_sub'
code: @[simp, norm_cast]
theorem coe_sub' (f g : M →SL[σ₁₂] M₂) : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: ContinuousLinearMap.comp_neg
code: @[simp]
theorem comp_neg [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [TopologicalAddGroup M₂] [TopologicalAddGroup M₃]
    (g : M₂ →SL[σ₂₃] M₃) (f : M →SL[σ₁₂] M₂) : g.comp (-f) = -g.comp f 
goal: g.comp (-f) = -g.comp f

full_name: ContinuousLinearMap.neg_comp
code: @[simp]
theorem neg_comp [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [TopologicalAddGroup M₃] (g : M₂ →SL[σ₂₃] M₃)
    (f : M →SL[σ₁₂] M₂) : (-g).comp f = -g.comp f 
goal: (-g).comp f = -g.comp f

full_name: ContinuousLinearMap.comp_sub
code: @[simp]
theorem comp_sub [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [TopologicalAddGroup M₂] [TopologicalAddGroup M₃]
    (g : M₂ →SL[σ₂₃] M₃) (f₁ f₂ : M →SL[σ₁₂] M₂) : g.comp (f₁ - f₂) = g.comp f₁ - g.comp f₂ 
goal: g.comp (f₁ - f₂) = g.comp f₁ - g.comp f₂

full_name: ContinuousLinearMap.sub_comp
code: @[simp]
theorem sub_comp [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [TopologicalAddGroup M₃] (g₁ g₂ : M₂ →SL[σ₂₃] M₃)
    (f : M →SL[σ₁₂] M₂) : (g₁ - g₂).comp f = g₁.comp f - g₂.comp f 
goal: (g₁ - g₂).comp f = g₁.comp f - g₂.comp f

full_name: ContinuousLinearMap.ring
code: instance ring [TopologicalAddGroup M] : Ring (M →L[R] M) 
goal: Ring (M →L[R] M)

full_name: ContinuousLinearMap.intCast_apply
code: @[simp]
theorem intCast_apply [TopologicalAddGroup M] (z : ℤ) (m : M) : (↑z : M →L[R] M) m = z • m 
goal: ↑z m = z • m

full_name: ContinuousLinearMap.smulRight_one_pow
code: theorem smulRight_one_pow [TopologicalSpace R] [TopologicalRing R] (c : R) (n : ℕ) :
    smulRight (1 : R →L[R] R) c ^ n = smulRight (1 : R →L[R] R) (c ^ n) 
goal: ContinuousLinearMap.smulRight 1 c ^ n = ContinuousLinearMap.smulRight 1 (c ^ n)

full_name: ContinuousLinearMap.projKerOfRightInverse
code: /-- Given a right inverse `f₂ : M₂ →L[R] M` to `f₁ : M →L[R] M₂`,
`projKerOfRightInverse f₁ f₂ h` is the projection `M →L[R] LinearMap.ker f₁` along
`LinearMap.range f₂`. -/
def projKerOfRightInverse [TopologicalAddGroup M] (f₁ : M →SL[σ₁₂] M₂) (f₂ : M₂ →SL[σ₂₁] M)
    (h : Function.RightInverse f₂ f₁) : M →L[R] LinearMap.ker f₁ 
goal: M →L[R] ↥(LinearMap.ker f₁)

full_name: ContinuousLinearMap.coe_projKerOfRightInverse_apply
code: @[simp]
theorem coe_projKerOfRightInverse_apply [TopologicalAddGroup M] (f₁ : M →SL[σ₁₂] M₂)
    (f₂ : M₂ →SL[σ₂₁] M) (h : Function.RightInverse f₂ f₁) (x : M) :
    (f₁.projKerOfRightInverse f₂ h x : M) = x - f₂ (f₁ x) 
goal: ↑((f₁.projKerOfRightInverse f₂ h) x) = x - f₂ (f₁ x)

full_name: ContinuousLinearMap.projKerOfRightInverse_apply_idem
code: @[simp]
theorem projKerOfRightInverse_apply_idem [TopologicalAddGroup M] (f₁ : M →SL[σ₁₂] M₂)
    (f₂ : M₂ →SL[σ₂₁] M) (h : Function.RightInverse f₂ f₁) (x : LinearMap.ker f₁) :
    f₁.projKerOfRightInverse f₂ h x = x 
goal: (f₁.projKerOfRightInverse f₂ h) ↑x = x

full_name: ContinuousLinearMap.projKerOfRightInverse_comp_inv
code: @[simp]
theorem projKerOfRightInverse_comp_inv [TopologicalAddGroup M] (f₁ : M →SL[σ₁₂] M₂)
    (f₂ : M₂ →SL[σ₂₁] M) (h : Function.RightInverse f₂ f₁) (y : M₂) :
    f₁.projKerOfRightInverse f₂ h (f₂ y) = 0 
goal: (f₁.projKerOfRightInverse f₂ h) (f₂ y) = 0

full_name: ContinuousLinearMap.isOpenMap_of_ne_zero
code: /-- A nonzero continuous linear functional is open. -/
protected theorem isOpenMap_of_ne_zero [TopologicalSpace R] [DivisionRing R] [ContinuousSub R]
    [AddCommGroup M] [TopologicalSpace M] [ContinuousAdd M] [Module R M] [ContinuousSMul R M]
    (f : M →L[R] R) (hf : f ≠ 0) : IsOpenMap f 
goal: IsOpenMap ⇑f

full_name: ContinuousLinearMap.smul_comp
code: @[simp]
theorem smul_comp (c : S₃) (h : M₂ →SL[σ₂₃] M₃) (f : M →SL[σ₁₂] M₂) :
    (c • h).comp f = c • h.comp f 
goal: (c • h).comp f = c • h.comp f

full_name: ContinuousLinearMap.comp_smul
code: @[simp]
theorem comp_smul [LinearMap.CompatibleSMul N₂ N₃ S R] (hₗ : N₂ →L[R] N₃) (c : S)
    (fₗ : M →L[R] N₂) : hₗ.comp (c • fₗ) = c • hₗ.comp fₗ 
goal: hₗ.comp (c • fₗ) = c • hₗ.comp fₗ

full_name: ContinuousLinearMap.comp_smulₛₗ
code: @[simp]
theorem comp_smulₛₗ [SMulCommClass R₂ R₂ M₂] [SMulCommClass R₃ R₃ M₃] [ContinuousConstSMul R₂ M₂]
    [ContinuousConstSMul R₃ M₃] (h : M₂ →SL[σ₂₃] M₃) (c : R₂) (f : M →SL[σ₁₂] M₂) :
    h.comp (c • f) = σ₂₃ c • h.comp f 
goal: h.comp (c • f) = σ₂₃ c • h.comp f

full_name: ContinuousLinearMap.distribMulAction
code: instance distribMulAction [ContinuousAdd M₂] : DistribMulAction S₃ (M →SL[σ₁₂] M₂) 
goal: DistribMulAction S₃ (M →SL[σ₁₂] M₂)

full_name: ContinuousLinearMap.prodEquiv
code: /-- `ContinuousLinearMap.prod` as an `Equiv`. -/
@[simps apply]
def prodEquiv : (M →L[R] N₂) × (M →L[R] N₃) ≃ (M →L[R] N₂ × N₃) 
goal: (M →L[R] N₂) × (M →L[R] N₃) ≃ (M →L[R] N₂ × N₃)

full_name: ContinuousLinearMap.prodEquiv_apply
code: /-- `ContinuousLinearMap.prod` as an `Equiv`. -/
@[simps apply]
def prodEquiv : (M →L[R] N₂) × (M →L[R] N₃) ≃ (M →L[R] N₂ × N₃) 
goal: ContinuousLinearMap.prodEquiv f = f.1.prod f.2

full_name: ContinuousLinearMap.prod_ext_iff
code: theorem prod_ext_iff {f g : M × N₂ →L[R] N₃} :
    f = g ↔ f.comp (inl _ _ _) = g.comp (inl _ _ _) ∧ f.comp (inr _ _ _) = g.comp (inr _ _ _) 
goal: f = g ↔
  f.comp (ContinuousLinearMap.inl R M N₂) = g.comp (ContinuousLinearMap.inl R M N₂) ∧
    f.comp (ContinuousLinearMap.inr R M N₂) = g.comp (ContinuousLinearMap.inr R M N₂)

full_name: ContinuousLinearMap.prod_ext
code: @[ext]
theorem prod_ext {f g : M × N₂ →L[R] N₃} (hl : f.comp (inl _ _ _) = g.comp (inl _ _ _))
    (hr : f.comp (inr _ _ _) = g.comp (inr _ _ _)) : f = g 
goal: f = g

full_name: ContinuousLinearMap.module
code: instance module : Module S₃ (M →SL[σ₁₃] M₃) 
goal: Module S₃ (M →SL[σ₁₃] M₃)

full_name: ContinuousLinearMap.isCentralScalar
code: instance isCentralScalar [Module S₃ᵐᵒᵖ M₃] [IsCentralScalar S₃ M₃] :
    IsCentralScalar S₃ (M →SL[σ₁₃] M₃) 
goal: IsCentralScalar S₃ (M →SL[σ₁₃] M₃)

full_name: ContinuousLinearMap.prodₗ_apply
code: /-- `ContinuousLinearMap.prod` as a `LinearEquiv`. -/
@[simps apply]
def prodₗ : ((M →L[R] N₂) × (M →L[R] N₃)) ≃ₗ[S] M →L[R] N₂ × N₃ 
goal: ∀ (a : (M →L[R] N₂) × (M →L[R] N₃)), (ContinuousLinearMap.prodₗ S) a = ContinuousLinearMap.prodEquiv.toFun a

full_name: ContinuousLinearMap.prodₗ
code: /-- `ContinuousLinearMap.prod` as a `LinearEquiv`. -/
@[simps apply]
def prodₗ : ((M →L[R] N₂) × (M →L[R] N₃)) ≃ₗ[S] M →L[R] N₂ × N₃ 
goal: ((M →L[R] N₂) × (M →L[R] N₃)) ≃ₗ[S] M →L[R] N₂ × N₃

full_name: ContinuousLinearMap.coeLM_apply
code: /-- The coercion from `M →L[R] M₂` to `M →ₗ[R] M₂`, as a linear map. -/
@[simps]
def coeLM : (M →L[R] N₃) →ₗ[S] M →ₗ[R] N₃ 
goal: (ContinuousLinearMap.coeLM S) self = ↑self

full_name: ContinuousLinearMap.coeLM
code: /-- The coercion from `M →L[R] M₂` to `M →ₗ[R] M₂`, as a linear map. -/
@[simps]
def coeLM : (M →L[R] N₃) →ₗ[S] M →ₗ[R] N₃ 
goal: (M →L[R] N₃) →ₗ[S] M →ₗ[R] N₃

full_name: ContinuousLinearMap.coeLMₛₗ
code: /-- The coercion from `M →SL[σ] M₂` to `M →ₛₗ[σ] M₂`, as a linear map. -/
@[simps]
def coeLMₛₗ : (M →SL[σ₁₃] M₃) →ₗ[S₃] M →ₛₗ[σ₁₃] M₃ 
goal: (M →SL[σ₁₃] M₃) →ₗ[S₃] M →ₛₗ[σ₁₃] M₃

full_name: ContinuousLinearMap.coeLMₛₗ_apply
code: /-- The coercion from `M →SL[σ] M₂` to `M →ₛₗ[σ] M₂`, as a linear map. -/
@[simps]
def coeLMₛₗ : (M →SL[σ₁₃] M₃) →ₗ[S₃] M →ₛₗ[σ₁₃] M₃ 
goal: (ContinuousLinearMap.coeLMₛₗ σ₁₃) self = ↑self

full_name: ContinuousLinearMap.smulRightₗ
code: /-- Given `c : E →L[𝕜] 𝕜`, `c.smulRightₗ` is the linear map from `F` to `E →L[𝕜] F`
sending `f` to `fun e => c e • f`. See also `ContinuousLinearMap.smulRightL`. -/
def smulRightₗ (c : M →L[R] S) : M₂ →ₗ[T] M →L[R] M₂ 
goal: M₂ →ₗ[T] M →L[R] M₂

full_name: ContinuousLinearMap.coe_smulRightₗ
code: @[simp]
theorem coe_smulRightₗ (c : M →L[R] S) : ⇑(smulRightₗ c : M₂ →ₗ[T] M →L[R] M₂) = c.smulRight 
goal: ⇑c.smulRightₗ = c.smulRight

full_name: ContinuousLinearMap.algebra
code: instance algebra : Algebra R (M₂ →L[R] M₂) 
goal: Algebra R (M₂ →L[R] M₂)

full_name: ContinuousLinearMap.algebraMap_apply
code: @[simp] theorem algebraMap_apply (r : R) (m : M₂) : algebraMap R (M₂ →L[R] M₂) r m = r • m 
goal: ((algebraMap R (M₂ →L[R] M₂)) r) m = r • m

full_name: ContinuousLinearMap.restrictScalars
code: /-- If `A` is an `R`-algebra, then a continuous `A`-linear map can be interpreted as a continuous
`R`-linear map. We assume `LinearMap.CompatibleSMul M M₂ R A` to match assumptions of
`LinearMap.map_smul_of_tower`. -/
def restrictScalars (f : M →L[A] M₂) : M →L[R] M₂ 
goal: M →L[R] M₂

full_name: ContinuousLinearMap.coe_restrictScalars
code: @[simp] -- @[norm_cast] -- Porting note: This theorem can't be a `norm_cast` theorem.
theorem coe_restrictScalars (f : M →L[A] M₂) :
    (f.restrictScalars R : M →ₗ[R] M₂) = (f : M →ₗ[A] M₂).restrictScalars R 
goal: ↑(ContinuousLinearMap.restrictScalars R f) = ↑R ↑f

full_name: ContinuousLinearMap.coe_restrictScalars'
code: @[simp]
theorem coe_restrictScalars' (f : M →L[A] M₂) : ⇑(f.restrictScalars R) = f 
goal: ⇑(ContinuousLinearMap.restrictScalars R f) = ⇑f

full_name: ContinuousLinearMap.restrictScalars_zero
code: @[simp]
theorem restrictScalars_zero : (0 : M →L[A] M₂).restrictScalars R = 0 
goal: ContinuousLinearMap.restrictScalars R 0 = 0

full_name: ContinuousLinearMap.restrictScalars_add
code: @[simp]
theorem restrictScalars_add (f g : M →L[A] M₂) :
    (f + g).restrictScalars R = f.restrictScalars R + g.restrictScalars R 
goal: ContinuousLinearMap.restrictScalars R (f + g) =
  ContinuousLinearMap.restrictScalars R f + ContinuousLinearMap.restrictScalars R g

full_name: ContinuousLinearMap.restrictScalars_neg
code: @[simp]
theorem restrictScalars_neg (f : M →L[A] M₂) : (-f).restrictScalars R = -f.restrictScalars R 
goal: ContinuousLinearMap.restrictScalars R (-f) = -ContinuousLinearMap.restrictScalars R f

full_name: ContinuousLinearMap.restrictScalars_smul
code: @[simp]
theorem restrictScalars_smul (c : S) (f : M →L[A] M₂) :
    (c • f).restrictScalars R = c • f.restrictScalars R 
goal: ContinuousLinearMap.restrictScalars R (c • f) = c • ContinuousLinearMap.restrictScalars R f

full_name: ContinuousLinearMap.restrictScalarsₗ
code: /-- `ContinuousLinearMap.restrictScalars` as a `LinearMap`. See also
`ContinuousLinearMap.restrictScalarsL`. -/
def restrictScalarsₗ : (M →L[A] M₂) →ₗ[S] M →L[R] M₂ 
goal: (M →L[A] M₂) →ₗ[S] M →L[R] M₂

full_name: ContinuousLinearMap.coe_restrictScalarsₗ
code: @[simp]
theorem coe_restrictScalarsₗ : ⇑(restrictScalarsₗ A M M₂ R S) = restrictScalars R 
goal: ⇑(ContinuousLinearMap.restrictScalarsₗ A M M₂ R S) = ContinuousLinearMap.restrictScalars R

full_name: ContinuousLinearEquiv.toContinuousLinearMap
code: /-- A continuous linear equivalence induces a continuous linear map. -/
@[coe]
def toContinuousLinearMap (e : M₁ ≃SL[σ₁₂] M₂) : M₁ →SL[σ₁₂] M₂ 
goal: M₁ →SL[σ₁₂] M₂

full_name: ContinuousLinearEquiv.ContinuousLinearMap.coe
code: /-- Coerce continuous linear equivs to continuous linear maps. -/
instance ContinuousLinearMap.coe : Coe (M₁ ≃SL[σ₁₂] M₂) (M₁ →SL[σ₁₂] M₂) 
goal: Coe (M₁ ≃SL[σ₁₂] M₂) (M₁ →SL[σ₁₂] M₂)

full_name: ContinuousLinearEquiv.equivLike
code: instance equivLike :
    EquivLike (M₁ ≃SL[σ₁₂] M₂) M₁ M₂ 
goal: EquivLike (M₁ ≃SL[σ₁₂] M₂) M₁ M₂

full_name: ContinuousLinearEquiv.continuousSemilinearEquivClass
code: instance continuousSemilinearEquivClass :
    ContinuousSemilinearEquivClass (M₁ ≃SL[σ₁₂] M₂) σ₁₂ M₁ M₂ 
goal: ContinuousSemilinearEquivClass (M₁ ≃SL[σ₁₂] M₂) σ₁₂ M₁ M₂

full_name: ContinuousLinearEquiv.coe_apply
code: theorem coe_apply (e : M₁ ≃SL[σ₁₂] M₂) (b : M₁) : (e : M₁ →SL[σ₁₂] M₂) b = e b 
goal: ↑e b = e b

full_name: ContinuousLinearEquiv.coe_toLinearEquiv
code: @[simp]
theorem coe_toLinearEquiv (f : M₁ ≃SL[σ₁₂] M₂) : ⇑f.toLinearEquiv = f 
goal: ⇑f.toLinearEquiv = ⇑f

full_name: ContinuousLinearEquiv.coe_coe
code: @[simp, norm_cast]
theorem coe_coe (e : M₁ ≃SL[σ₁₂] M₂) : ⇑(e : M₁ →SL[σ₁₂] M₂) = e 
goal: ⇑↑e = ⇑e

full_name: ContinuousLinearEquiv.toLinearEquiv_injective
code: theorem toLinearEquiv_injective :
    Function.Injective (toLinearEquiv : (M₁ ≃SL[σ₁₂] M₂) → M₁ ≃ₛₗ[σ₁₂] M₂) 
goal: Function.Injective ContinuousLinearEquiv.toLinearEquiv

full_name: ContinuousLinearEquiv.ext
code: @[ext]
theorem ext {f g : M₁ ≃SL[σ₁₂] M₂} (h : (f : M₁ → M₂) = g) : f = g 
goal: f = g

full_name: ContinuousLinearEquiv.coe_injective
code: theorem coe_injective : Function.Injective ((↑) : (M₁ ≃SL[σ₁₂] M₂) → M₁ →SL[σ₁₂] M₂) 
goal: Function.Injective ContinuousLinearEquiv.toContinuousLinearMap

full_name: ContinuousLinearEquiv.coe_inj
code: @[simp, norm_cast]
theorem coe_inj {e e' : M₁ ≃SL[σ₁₂] M₂} : (e : M₁ →SL[σ₁₂] M₂) = e' ↔ e = e' 
goal: ↑e = ↑e' ↔ e = e'

full_name: ContinuousLinearEquiv.toHomeomorph
code: /-- A continuous linear equivalence induces a homeomorphism. -/
def toHomeomorph (e : M₁ ≃SL[σ₁₂] M₂) : M₁ ≃ₜ M₂ 
goal: M₁ ≃ₜ M₂

full_name: ContinuousLinearEquiv.coe_toHomeomorph
code: @[simp]
theorem coe_toHomeomorph (e : M₁ ≃SL[σ₁₂] M₂) : ⇑e.toHomeomorph = e 
goal: ⇑e.toHomeomorph = ⇑e

full_name: ContinuousLinearEquiv.isOpenMap
code: theorem isOpenMap (e : M₁ ≃SL[σ₁₂] M₂) : IsOpenMap e 
goal: IsOpenMap ⇑e

full_name: ContinuousLinearEquiv.image_closure
code: theorem image_closure (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁) : e '' closure s = closure (e '' s) 
goal: ⇑e '' closure s = closure (⇑e '' s)

full_name: ContinuousLinearEquiv.preimage_closure
code: theorem preimage_closure (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) : e ⁻¹' closure s = closure (e ⁻¹' s) 
goal: ⇑e ⁻¹' closure s = closure (⇑e ⁻¹' s)

full_name: ContinuousLinearEquiv.isClosed_image
code: @[simp]
theorem isClosed_image (e : M₁ ≃SL[σ₁₂] M₂) {s : Set M₁} : IsClosed (e '' s) ↔ IsClosed s 
goal: IsClosed (⇑e '' s) ↔ IsClosed s

full_name: ContinuousLinearEquiv.map_nhds_eq
code: theorem map_nhds_eq (e : M₁ ≃SL[σ₁₂] M₂) (x : M₁) : map e (𝓝 x) = 𝓝 (e x) 
goal: Filter.map (⇑e) (𝓝 x) = 𝓝 (e x)

full_name: ContinuousLinearEquiv.map_zero
code: theorem map_zero (e : M₁ ≃SL[σ₁₂] M₂) : e (0 : M₁) = 0 
goal: e 0 = 0

full_name: ContinuousLinearEquiv.map_add
code: theorem map_add (e : M₁ ≃SL[σ₁₂] M₂) (x y : M₁) : e (x + y) = e x + e y 
goal: e (x + y) = e x + e y

full_name: ContinuousLinearEquiv.map_smulₛₗ
code: theorem map_smulₛₗ (e : M₁ ≃SL[σ₁₂] M₂) (c : R₁) (x : M₁) : e (c • x) = σ₁₂ c • e x 
goal: e (c • x) = σ₁₂ c • e x

full_name: ContinuousLinearEquiv.map_smul
code: theorem map_smul [Module R₁ M₂] (e : M₁ ≃L[R₁] M₂) (c : R₁) (x : M₁) : e (c • x) = c • e x 
goal: e (c • x) = c • e x

full_name: ContinuousLinearEquiv.map_eq_zero_iff
code: theorem map_eq_zero_iff (e : M₁ ≃SL[σ₁₂] M₂) {x : M₁} : e x = 0 ↔ x = 0 
goal: e x = 0 ↔ x = 0

full_name: ContinuousLinearEquiv.continuous
code: @[continuity]
protected theorem continuous (e : M₁ ≃SL[σ₁₂] M₂) : Continuous (e : M₁ → M₂) 
goal: Continuous ⇑e

full_name: ContinuousLinearEquiv.continuousOn
code: protected theorem continuousOn (e : M₁ ≃SL[σ₁₂] M₂) {s : Set M₁} : ContinuousOn (e : M₁ → M₂) s 
goal: ContinuousOn (⇑e) s

full_name: ContinuousLinearEquiv.continuousAt
code: protected theorem continuousAt (e : M₁ ≃SL[σ₁₂] M₂) {x : M₁} : ContinuousAt (e : M₁ → M₂) x 
goal: ContinuousAt (⇑e) x

full_name: ContinuousLinearEquiv.continuousWithinAt
code: protected theorem continuousWithinAt (e : M₁ ≃SL[σ₁₂] M₂) {s : Set M₁} {x : M₁} :
    ContinuousWithinAt (e : M₁ → M₂) s x 
goal: ContinuousWithinAt (⇑e) s x

full_name: ContinuousLinearEquiv.comp_continuousOn_iff
code: theorem comp_continuousOn_iff {α : Type*} [TopologicalSpace α] (e : M₁ ≃SL[σ₁₂] M₂) {f : α → M₁}
    {s : Set α} : ContinuousOn (e ∘ f) s ↔ ContinuousOn f s 
goal: ContinuousOn (⇑e ∘ f) s ↔ ContinuousOn f s

full_name: ContinuousLinearEquiv.comp_continuous_iff
code: theorem comp_continuous_iff {α : Type*} [TopologicalSpace α] (e : M₁ ≃SL[σ₁₂] M₂) {f : α → M₁} :
    Continuous (e ∘ f) ↔ Continuous f 
goal: Continuous (⇑e ∘ f) ↔ Continuous f

full_name: ContinuousLinearEquiv.ext₁
code: /-- An extensionality lemma for `R ≃L[R] M`. -/
theorem ext₁ [TopologicalSpace R₁] {f g : R₁ ≃L[R₁] M₁} (h : f 1 = g 1) : f = g 
goal: f = g

full_name: ContinuousLinearEquiv.refl
code: /-- The identity map as a continuous linear equivalence. -/
@[refl]
protected def refl : M₁ ≃L[R₁] M₁ 
goal: M₁ ≃L[R₁] M₁

full_name: ContinuousLinearEquiv.coe_refl
code: @[simp, norm_cast]
theorem coe_refl : ↑(ContinuousLinearEquiv.refl R₁ M₁) = ContinuousLinearMap.id R₁ M₁ 
goal: ↑(ContinuousLinearEquiv.refl R₁ M₁) = ContinuousLinearMap.id R₁ M₁

full_name: ContinuousLinearEquiv.coe_refl'
code: @[simp, norm_cast]
theorem coe_refl' : ⇑(ContinuousLinearEquiv.refl R₁ M₁) = id 
goal: ⇑(ContinuousLinearEquiv.refl R₁ M₁) = id

full_name: ContinuousLinearEquiv.symm
code: /-- The inverse of a continuous linear equivalence as a continuous linear equivalence-/
@[symm]
protected def symm (e : M₁ ≃SL[σ₁₂] M₂) : M₂ ≃SL[σ₂₁] M₁ 
goal: M₂ ≃SL[σ₂₁] M₁

full_name: ContinuousLinearEquiv.symm_toLinearEquiv
code: @[simp]
theorem symm_toLinearEquiv (e : M₁ ≃SL[σ₁₂] M₂) : e.symm.toLinearEquiv = e.toLinearEquiv.symm 
goal: e.symm.toLinearEquiv = e.symm

full_name: ContinuousLinearEquiv.symm_toHomeomorph
code: @[simp]
theorem symm_toHomeomorph (e : M₁ ≃SL[σ₁₂] M₂) : e.toHomeomorph.symm = e.symm.toHomeomorph 
goal: e.toHomeomorph.symm = e.symm.toHomeomorph

full_name: ContinuousLinearEquiv.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (h : M₁ ≃SL[σ₁₂] M₂) : M₁ → M₂ 
goal: M₁ → M₂

full_name: ContinuousLinearEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (h : M₁ ≃SL[σ₁₂] M₂) : M₂ → M₁ 
goal: M₂ → M₁

full_name: ContinuousLinearEquiv.symm_map_nhds_eq
code: theorem symm_map_nhds_eq (e : M₁ ≃SL[σ₁₂] M₂) (x : M₁) : map e.symm (𝓝 (e x)) = 𝓝 x 
goal: Filter.map (⇑e.symm) (𝓝 (e x)) = 𝓝 x

full_name: ContinuousLinearEquiv.trans
code: /-- The composition of two continuous linear equivalences as a continuous linear equivalence. -/
@[trans]
protected def trans (e₁ : M₁ ≃SL[σ₁₂] M₂) (e₂ : M₂ ≃SL[σ₂₃] M₃) : M₁ ≃SL[σ₁₃] M₃ 
goal: M₁ ≃SL[σ₁₃] M₃

full_name: ContinuousLinearEquiv.trans_toLinearEquiv
code: @[simp]
theorem trans_toLinearEquiv (e₁ : M₁ ≃SL[σ₁₂] M₂) (e₂ : M₂ ≃SL[σ₂₃] M₃) :
    (e₁.trans e₂).toLinearEquiv = e₁.toLinearEquiv.trans e₂.toLinearEquiv 
goal: (e₁.trans e₂).toLinearEquiv = e₁.trans e₂.toLinearEquiv

full_name: ContinuousLinearEquiv.prod
code: /-- Product of two continuous linear equivalences. The map comes from `Equiv.prodCongr`. -/
def prod [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (e : M₁ ≃L[R₁] M₂) (e' : M₃ ≃L[R₁] M₄) :
    (M₁ × M₃) ≃L[R₁] M₂ × M₄ 
goal: (M₁ × M₃) ≃L[R₁] M₂ × M₄

full_name: ContinuousLinearEquiv.prod_apply
code: @[simp, norm_cast]
theorem prod_apply [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (e : M₁ ≃L[R₁] M₂)
    (e' : M₃ ≃L[R₁] M₄) (x) : e.prod e' x = (e x.1, e' x.2) 
goal: (e.prod e') x = (e x.1, e' x.2)

full_name: ContinuousLinearEquiv.coe_prod
code: @[simp, norm_cast]
theorem coe_prod [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (e : M₁ ≃L[R₁] M₂)
    (e' : M₃ ≃L[R₁] M₄) :
    (e.prod e' : M₁ × M₃ →L[R₁] M₂ × M₄) = (e : M₁ →L[R₁] M₂).prodMap (e' : M₃ →L[R₁] M₄) 
goal: ↑(e.prod e') = (↑e).prodMap ↑e'

full_name: ContinuousLinearEquiv.prod_symm
code: theorem prod_symm [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (e : M₁ ≃L[R₁] M₂)
    (e' : M₃ ≃L[R₁] M₄) : (e.prod e').symm = e.symm.prod e'.symm 
goal: (e.prod e').symm = e.symm.prod e'.symm

full_name: ContinuousLinearEquiv.prodComm_toLinearEquiv
code: /-- Product of modules is commutative up to continuous linear isomorphism. -/
@[simps! apply toLinearEquiv]
def prodComm [Module R₁ M₂] : (M₁ × M₂) ≃L[R₁] M₂ × M₁ 
goal: (ContinuousLinearEquiv.prodComm R₁ M₁ M₂).toLinearEquiv = LinearEquiv.prodComm R₁ M₁ M₂

full_name: ContinuousLinearEquiv.prodComm_apply
code: /-- Product of modules is commutative up to continuous linear isomorphism. -/
@[simps! apply toLinearEquiv]
def prodComm [Module R₁ M₂] : (M₁ × M₂) ≃L[R₁] M₂ × M₁ 
goal: ∀ (a : M₁ × M₂), (ContinuousLinearEquiv.prodComm R₁ M₁ M₂) a = a.swap

full_name: ContinuousLinearEquiv.prodComm
code: /-- Product of modules is commutative up to continuous linear isomorphism. -/
@[simps! apply toLinearEquiv]
def prodComm [Module R₁ M₂] : (M₁ × M₂) ≃L[R₁] M₂ × M₁ 
goal: (M₁ × M₂) ≃L[R₁] M₂ × M₁

full_name: ContinuousLinearEquiv.prodComm_symm
code: @[simp] lemma prodComm_symm [Module R₁ M₂] : (prodComm R₁ M₁ M₂).symm = prodComm R₁ M₂ M₁ 
goal: (ContinuousLinearEquiv.prodComm R₁ M₁ M₂).symm = ContinuousLinearEquiv.prodComm R₁ M₂ M₁

full_name: ContinuousLinearEquiv.bijective
code: protected theorem bijective (e : M₁ ≃SL[σ₁₂] M₂) : Function.Bijective e 
goal: Function.Bijective ⇑e

full_name: ContinuousLinearEquiv.injective
code: protected theorem injective (e : M₁ ≃SL[σ₁₂] M₂) : Function.Injective e 
goal: Function.Injective ⇑e

full_name: ContinuousLinearEquiv.surjective
code: protected theorem surjective (e : M₁ ≃SL[σ₁₂] M₂) : Function.Surjective e 
goal: Function.Surjective ⇑e

full_name: ContinuousLinearEquiv.trans_apply
code: @[simp]
theorem trans_apply (e₁ : M₁ ≃SL[σ₁₂] M₂) (e₂ : M₂ ≃SL[σ₂₃] M₃) (c : M₁) :
    (e₁.trans e₂) c = e₂ (e₁ c) 
goal: (e₁.trans e₂) c = e₂ (e₁ c)

full_name: ContinuousLinearEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : M₁ ≃SL[σ₁₂] M₂) (c : M₂) : e (e.symm c) = c 
goal: e (e.symm c) = c

full_name: ContinuousLinearEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : M₁ ≃SL[σ₁₂] M₂) (b : M₁) : e.symm (e b) = b 
goal: e.symm (e b) = b

full_name: ContinuousLinearEquiv.symm_trans_apply
code: @[simp]
theorem symm_trans_apply (e₁ : M₂ ≃SL[σ₂₁] M₁) (e₂ : M₃ ≃SL[σ₃₂] M₂) (c : M₁) :
    (e₂.trans e₁).symm c = e₂.symm (e₁.symm c) 
goal: (e₂.trans e₁).symm c = e₂.symm (e₁.symm c)

full_name: ContinuousLinearEquiv.symm_image_image
code: @[simp]
theorem symm_image_image (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁) : e.symm '' (e '' s) = s 
goal: ⇑e.symm '' (⇑e '' s) = s

full_name: ContinuousLinearEquiv.image_symm_image
code: @[simp]
theorem image_symm_image (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) : e '' (e.symm '' s) = s 
goal: ⇑e '' (⇑e.symm '' s) = s

full_name: ContinuousLinearEquiv.comp_coe
code: @[simp, norm_cast]
theorem comp_coe (f : M₁ ≃SL[σ₁₂] M₂) (f' : M₂ ≃SL[σ₂₃] M₃) :
    (f' : M₂ →SL[σ₂₃] M₃).comp (f : M₁ →SL[σ₁₂] M₂) = (f.trans f' : M₁ →SL[σ₁₃] M₃) 
goal: (↑f').comp ↑f = ↑(f.trans f')

full_name: ContinuousLinearEquiv.coe_comp_coe_symm
code: @[simp high]
theorem coe_comp_coe_symm (e : M₁ ≃SL[σ₁₂] M₂) :
    (e : M₁ →SL[σ₁₂] M₂).comp (e.symm : M₂ →SL[σ₂₁] M₁) = ContinuousLinearMap.id R₂ M₂ 
goal: (↑e).comp ↑e.symm = ContinuousLinearMap.id R₂ M₂

full_name: ContinuousLinearEquiv.coe_symm_comp_coe
code: @[simp high]
theorem coe_symm_comp_coe (e : M₁ ≃SL[σ₁₂] M₂) :
    (e.symm : M₂ →SL[σ₂₁] M₁).comp (e : M₁ →SL[σ₁₂] M₂) = ContinuousLinearMap.id R₁ M₁ 
goal: (↑e.symm).comp ↑e = ContinuousLinearMap.id R₁ M₁

full_name: ContinuousLinearEquiv.symm_comp_self
code: @[simp]
theorem symm_comp_self (e : M₁ ≃SL[σ₁₂] M₂) : (e.symm : M₂ → M₁) ∘ (e : M₁ → M₂) = id 
goal: ⇑e.symm ∘ ⇑e = id

full_name: ContinuousLinearEquiv.self_comp_symm
code: @[simp]
theorem self_comp_symm (e : M₁ ≃SL[σ₁₂] M₂) : (e : M₁ → M₂) ∘ (e.symm : M₂ → M₁) = id 
goal: ⇑e ∘ ⇑e.symm = id

full_name: ContinuousLinearEquiv.symm_symm
code: @[simp]
theorem symm_symm (e : M₁ ≃SL[σ₁₂] M₂) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: ContinuousLinearEquiv.refl_symm
code: @[simp]
theorem refl_symm : (ContinuousLinearEquiv.refl R₁ M₁).symm = ContinuousLinearEquiv.refl R₁ M₁ 
goal: (ContinuousLinearEquiv.refl R₁ M₁).symm = ContinuousLinearEquiv.refl R₁ M₁

full_name: ContinuousLinearEquiv.symm_symm_apply
code: theorem symm_symm_apply (e : M₁ ≃SL[σ₁₂] M₂) (x : M₁) : e.symm.symm x = e x 
goal: e.symm.symm x = e x

full_name: ContinuousLinearEquiv.symm_apply_eq
code: theorem symm_apply_eq (e : M₁ ≃SL[σ₁₂] M₂) {x y} : e.symm x = y ↔ x = e y 
goal: e.symm x = y ↔ x = e y

full_name: ContinuousLinearEquiv.eq_symm_apply
code: theorem eq_symm_apply (e : M₁ ≃SL[σ₁₂] M₂) {x y} : y = e.symm x ↔ e y = x 
goal: y = e.symm x ↔ e y = x

full_name: ContinuousLinearEquiv.image_eq_preimage
code: protected theorem image_eq_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁) : e '' s = e.symm ⁻¹' s 
goal: ⇑e '' s = ⇑e.symm ⁻¹' s

full_name: ContinuousLinearEquiv.image_symm_eq_preimage
code: protected theorem image_symm_eq_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) :
    e.symm '' s = e ⁻¹' s 
goal: ⇑e.symm '' s = ⇑e ⁻¹' s

full_name: ContinuousLinearEquiv.symm_preimage_preimage
code: @[simp]
protected theorem symm_preimage_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) :
    e.symm ⁻¹' (e ⁻¹' s) = s 
goal: ⇑e.symm ⁻¹' (⇑e ⁻¹' s) = s

full_name: ContinuousLinearEquiv.preimage_symm_preimage
code: @[simp]
protected theorem preimage_symm_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁) :
    e ⁻¹' (e.symm ⁻¹' s) = s 
goal: ⇑e ⁻¹' (⇑e.symm ⁻¹' s) = s

full_name: ContinuousLinearEquiv.uniformEmbedding
code: protected theorem uniformEmbedding {E₁ E₂ : Type*} [UniformSpace E₁] [UniformSpace E₂]
    [AddCommGroup E₁] [AddCommGroup E₂] [Module R₁ E₁] [Module R₂ E₂] [UniformAddGroup E₁]
    [UniformAddGroup E₂] (e : E₁ ≃SL[σ₁₂] E₂) : UniformEmbedding e 
goal: UniformEmbedding ⇑e

full_name: LinearEquiv.uniformEmbedding
code: protected theorem _root_.LinearEquiv.uniformEmbedding {E₁ E₂ : Type*} [UniformSpace E₁]
    [UniformSpace E₂] [AddCommGroup E₁] [AddCommGroup E₂] [Module R₁ E₁] [Module R₂ E₂]
    [UniformAddGroup E₁] [UniformAddGroup E₂] (e : E₁ ≃ₛₗ[σ₁₂] E₂)
    (h₁ : Continuous e) (h₂ : Continuous e.symm) : UniformEmbedding e 
goal: UniformEmbedding ⇑e

full_name: ContinuousLinearEquiv.equivOfInverse
code: /-- Create a `ContinuousLinearEquiv` from two `ContinuousLinearMap`s that are
inverse of each other. -/
def equivOfInverse (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ : M₂ →SL[σ₂₁] M₁) (h₁ : Function.LeftInverse f₂ f₁)
    (h₂ : Function.RightInverse f₂ f₁) : M₁ ≃SL[σ₁₂] M₂ 
goal: M₁ ≃SL[σ₁₂] M₂

full_name: ContinuousLinearEquiv.equivOfInverse_apply
code: @[simp]
theorem equivOfInverse_apply (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ h₁ h₂ x) :
    equivOfInverse f₁ f₂ h₁ h₂ x = f₁ x 
goal: (ContinuousLinearEquiv.equivOfInverse f₁ f₂ h₁ h₂) x = f₁ x

full_name: ContinuousLinearEquiv.symm_equivOfInverse
code: @[simp]
theorem symm_equivOfInverse (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ h₁ h₂) :
    (equivOfInverse f₁ f₂ h₁ h₂).symm = equivOfInverse f₂ f₁ h₂ h₁ 
goal: (ContinuousLinearEquiv.equivOfInverse f₁ f₂ h₁ h₂).symm = ContinuousLinearEquiv.equivOfInverse f₂ f₁ h₂ h₁

full_name: ContinuousLinearEquiv.automorphismGroup
code: /-- The continuous linear equivalences from `M` to itself form a group under composition. -/
instance automorphismGroup : Group (M₁ ≃L[R₁] M₁) 
goal: Group (M₁ ≃L[R₁] M₁)

full_name: ContinuousLinearEquiv.ulift
code: /-- The continuous linear equivalence between `ULift M₁` and `M₁`.

This is a continuous version of `ULift.moduleEquiv`. -/
def ulift : ULift M₁ ≃L[R₁] M₁ 
goal: ULift.{u_10, u_4} M₁ ≃L[R₁] M₁

full_name: ContinuousLinearEquiv.arrowCongrEquiv
code: /-- A pair of continuous (semi)linear equivalences generates an equivalence between the spaces of
continuous linear maps. See also `ContinuousLinearEquiv.arrowCongr`. -/
@[simps]
def arrowCongrEquiv (e₁₂ : M₁ ≃SL[σ₁₂] M₂) (e₄₃ : M₄ ≃SL[σ₄₃] M₃) :
    (M₁ →SL[σ₁₄] M₄) ≃ (M₂ →SL[σ₂₃] M₃) 
goal: (M₁ →SL[σ₁₄] M₄) ≃ (M₂ →SL[σ₂₃] M₃)

full_name: ContinuousLinearEquiv.arrowCongrEquiv_symm_apply
code: /-- A pair of continuous (semi)linear equivalences generates an equivalence between the spaces of
continuous linear maps. See also `ContinuousLinearEquiv.arrowCongr`. -/
@[simps]
def arrowCongrEquiv (e₁₂ : M₁ ≃SL[σ₁₂] M₂) (e₄₃ : M₄ ≃SL[σ₄₃] M₃) :
    (M₁ →SL[σ₁₄] M₄) ≃ (M₂ →SL[σ₂₃] M₃) 
goal: (e₁₂.arrowCongrEquiv e₄₃).symm f = (↑e₄₃.symm).comp (f.comp ↑e₁₂)

full_name: ContinuousLinearEquiv.arrowCongrEquiv_apply
code: /-- A pair of continuous (semi)linear equivalences generates an equivalence between the spaces of
continuous linear maps. See also `ContinuousLinearEquiv.arrowCongr`. -/
@[simps]
def arrowCongrEquiv (e₁₂ : M₁ ≃SL[σ₁₂] M₂) (e₄₃ : M₄ ≃SL[σ₄₃] M₃) :
    (M₁ →SL[σ₁₄] M₄) ≃ (M₂ →SL[σ₂₃] M₃) 
goal: (e₁₂.arrowCongrEquiv e₄₃) f = (↑e₄₃).comp (f.comp ↑e₁₂.symm)

full_name: ContinuousLinearEquiv.skewProd
code: /-- Equivalence given by a block lower diagonal matrix. `e` and `e'` are diagonal square blocks,
  and `f` is a rectangular block below the diagonal. -/
def skewProd (e : M ≃L[R] M₂) (e' : M₃ ≃L[R] M₄) (f : M →L[R] M₄) : (M × M₃) ≃L[R] M₂ × M₄ 
goal: (M × M₃) ≃L[R] M₂ × M₄

full_name: ContinuousLinearEquiv.skewProd_apply
code: @[simp]
theorem skewProd_apply (e : M ≃L[R] M₂) (e' : M₃ ≃L[R] M₄) (f : M →L[R] M₄) (x) :
    e.skewProd e' f x = (e x.1, e' x.2 + f x.1) 
goal: (e.skewProd e' f) x = (e x.1, e' x.2 + f x.1)

full_name: ContinuousLinearEquiv.skewProd_symm_apply
code: @[simp]
theorem skewProd_symm_apply (e : M ≃L[R] M₂) (e' : M₃ ≃L[R] M₄) (f : M →L[R] M₄) (x) :
    (e.skewProd e' f).symm x = (e.symm x.1, e'.symm (x.2 - f (e.symm x.1))) 
goal: (e.skewProd e' f).symm x = (e.symm x.1, e'.symm (x.2 - f (e.symm x.1)))

full_name: ContinuousLinearEquiv.map_sub
code: theorem map_sub (e : M ≃SL[σ₁₂] M₂) (x y : M) : e (x - y) = e x - e y 
goal: e (x - y) = e x - e y

full_name: ContinuousLinearEquiv.map_neg
code: theorem map_neg (e : M ≃SL[σ₁₂] M₂) (x : M) : e (-x) = -e x 
goal: e (-x) = -e x

full_name: ContinuousLinearEquiv.ofUnit
code: /-- An invertible continuous linear map `f` determines a continuous equivalence from `M` to itself.
-/
def ofUnit (f : (M →L[R] M)ˣ) : M ≃L[R] M 
goal: M ≃L[R] M

full_name: ContinuousLinearEquiv.toUnit
code: /-- A continuous equivalence from `M` to itself determines an invertible continuous linear map. -/
def toUnit (f : M ≃L[R] M) : (M →L[R] M)ˣ 
goal: (M →L[R] M)ˣ

full_name: ContinuousLinearEquiv.unitsEquiv
code: /-- The units of the algebra of continuous `R`-linear endomorphisms of `M` is multiplicatively
equivalent to the type of continuous linear equivalences between `M` and itself. -/
def unitsEquiv : (M →L[R] M)ˣ ≃* M ≃L[R] M 
goal: (M →L[R] M)ˣ ≃* M ≃L[R] M

full_name: ContinuousLinearEquiv.unitsEquiv_apply
code: @[simp]
theorem unitsEquiv_apply (f : (M →L[R] M)ˣ) (x : M) : unitsEquiv R M f x = (f : M →L[R] M) x 
goal: ((ContinuousLinearEquiv.unitsEquiv R M) f) x = ↑f x

full_name: ContinuousLinearEquiv.unitsEquivAut
code: /-- Continuous linear equivalences `R ≃L[R] R` are enumerated by `Rˣ`. -/
def unitsEquivAut : Rˣ ≃ R ≃L[R] R 
goal: Rˣ ≃ R ≃L[R] R

full_name: ContinuousLinearEquiv.unitsEquivAut_apply
code: @[simp]
theorem unitsEquivAut_apply (u : Rˣ) (x : R) : unitsEquivAut R u x = x * u 
goal: ((ContinuousLinearEquiv.unitsEquivAut R) u) x = x * ↑u

full_name: ContinuousLinearEquiv.unitsEquivAut_apply_symm
code: @[simp]
theorem unitsEquivAut_apply_symm (u : Rˣ) (x : R) : (unitsEquivAut R u).symm x = x * ↑u⁻¹ 
goal: ((ContinuousLinearEquiv.unitsEquivAut R) u).symm x = x * ↑u⁻¹

full_name: ContinuousLinearEquiv.unitsEquivAut_symm_apply
code: @[simp]
theorem unitsEquivAut_symm_apply (e : R ≃L[R] R) : ↑((unitsEquivAut R).symm e) = e 1 
goal: ↑((ContinuousLinearEquiv.unitsEquivAut R).symm e) = e 1

full_name: ContinuousLinearEquiv.equivOfRightInverse
code: /-- A pair of continuous linear maps such that `f₁ ∘ f₂ = id` generates a continuous
linear equivalence `e` between `M` and `M₂ × f₁.ker` such that `(e x).2 = x` for `x ∈ f₁.ker`,
`(e x).1 = f₁ x`, and `(e (f₂ y)).2 = 0`. The map is given by `e x = (f₁ x, x - f₂ (f₁ x))`. -/
def equivOfRightInverse (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M) (h : Function.RightInverse f₂ f₁) :
    M ≃L[R] M₂ × ker f₁ 
goal: M ≃L[R] M₂ × ↥(LinearMap.ker f₁)

full_name: ContinuousLinearEquiv.fst_equivOfRightInverse
code: @[simp]
theorem fst_equivOfRightInverse (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M)
    (h : Function.RightInverse f₂ f₁) (x : M) : (equivOfRightInverse f₁ f₂ h x).1 = f₁ x 
goal: ((ContinuousLinearEquiv.equivOfRightInverse f₁ f₂ h) x).1 = f₁ x

full_name: ContinuousLinearEquiv.snd_equivOfRightInverse
code: @[simp]
theorem snd_equivOfRightInverse (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M)
    (h : Function.RightInverse f₂ f₁) (x : M) :
    ((equivOfRightInverse f₁ f₂ h x).2 : M) = x - f₂ (f₁ x) 
goal: ↑((ContinuousLinearEquiv.equivOfRightInverse f₁ f₂ h) x).2 = x - f₂ (f₁ x)

full_name: ContinuousLinearEquiv.equivOfRightInverse_symm_apply
code: @[simp]
theorem equivOfRightInverse_symm_apply (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M)
    (h : Function.RightInverse f₂ f₁) (y : M₂ × ker f₁) :
    (equivOfRightInverse f₁ f₂ h).symm y = f₂ y.1 + y.2 
goal: (ContinuousLinearEquiv.equivOfRightInverse f₁ f₂ h).symm y = f₂ y.1 + ↑y.2

full_name: ContinuousLinearEquiv.funUnique
code: /-- If `ι` has a unique element, then `ι → M` is continuously linear equivalent to `M`. -/
def funUnique : (ι → M) ≃L[R] M 
goal: (ι → M) ≃L[R] M

full_name: ContinuousLinearEquiv.coe_funUnique
code: @[simp]
theorem coe_funUnique : ⇑(funUnique ι R M) = Function.eval default 
goal: ⇑(ContinuousLinearEquiv.funUnique ι R M) = Function.eval default

full_name: ContinuousLinearEquiv.coe_funUnique_symm
code: @[simp]
theorem coe_funUnique_symm : ⇑(funUnique ι R M).symm = Function.const ι 
goal: ⇑(ContinuousLinearEquiv.funUnique ι R M).symm = Function.const ι

full_name: ContinuousLinearEquiv.piFinTwo_symm_apply
code: /-- Continuous linear equivalence between dependent functions `(i : Fin 2) → M i` and `M 0 × M 1`.
-/
@[simps! (config := .asFn) apply symm_apply]
def piFinTwo (M : Fin 2 → Type*) [∀ i, AddCommMonoid (M i)] [∀ i, Module R (M i)]
    [∀ i, TopologicalSpace (M i)] : ((i : _) → M i) ≃L[R] M 0 × M 1 
goal: ⇑(ContinuousLinearEquiv.piFinTwo R M).symm = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)

full_name: ContinuousLinearEquiv.piFinTwo_apply
code: /-- Continuous linear equivalence between dependent functions `(i : Fin 2) → M i` and `M 0 × M 1`.
-/
@[simps! (config := .asFn) apply symm_apply]
def piFinTwo (M : Fin 2 → Type*) [∀ i, AddCommMonoid (M i)] [∀ i, Module R (M i)]
    [∀ i, TopologicalSpace (M i)] : ((i : _) → M i) ≃L[R] M 0 × M 1 
goal: ⇑(ContinuousLinearEquiv.piFinTwo R M) = fun f => (f 0, f 1)

full_name: ContinuousLinearEquiv.piFinTwo
code: /-- Continuous linear equivalence between dependent functions `(i : Fin 2) → M i` and `M 0 × M 1`.
-/
@[simps! (config := .asFn) apply symm_apply]
def piFinTwo (M : Fin 2 → Type*) [∀ i, AddCommMonoid (M i)] [∀ i, Module R (M i)]
    [∀ i, TopologicalSpace (M i)] : ((i : _) → M i) ≃L[R] M 0 × M 1 
goal: ((i : Fin 2) → M i) ≃L[R] M 0 × M 1

full_name: ContinuousLinearEquiv.finTwoArrow_apply
code: /-- Continuous linear equivalence between vectors in `M² = Fin 2 → M` and `M × M`. -/
@[simps! (config := .asFn) apply symm_apply]
def finTwoArrow : (Fin 2 → M) ≃L[R] M × M 
goal: ⇑(ContinuousLinearEquiv.finTwoArrow R M) = fun f => (f 0, f 1)

full_name: ContinuousLinearEquiv.finTwoArrow_symm_apply
code: /-- Continuous linear equivalence between vectors in `M² = Fin 2 → M` and `M × M`. -/
@[simps! (config := .asFn) apply symm_apply]
def finTwoArrow : (Fin 2 → M) ≃L[R] M × M 
goal: ⇑(ContinuousLinearEquiv.finTwoArrow R M).symm = fun x => ![x.1, x.2]

full_name: ContinuousLinearEquiv.finTwoArrow
code: /-- Continuous linear equivalence between vectors in `M² = Fin 2 → M` and `M × M`. -/
@[simps! (config := .asFn) apply symm_apply]
def finTwoArrow : (Fin 2 → M) ≃L[R] M × M 
goal: (Fin 2 → M) ≃L[R] M × M

full_name: ContinuousLinearMap.inverse
code: /-- Introduce a function `inverse` from `M →L[R] M₂` to `M₂ →L[R] M`, which sends `f` to `f.symm` if
`f` is a continuous linear equivalence and to `0` otherwise.  This definition is somewhat ad hoc,
but one needs a fully (rather than partially) defined inverse function for some purposes, including
for calculus. -/
noncomputable def inverse : (M →L[R] M₂) → M₂ →L[R] M 
goal: (M →L[R] M₂) → M₂ →L[R] M

full_name: ContinuousLinearMap.inverse_equiv
code: /-- By definition, if `f` is invertible then `inverse f = f.symm`. -/
@[simp]
theorem inverse_equiv (e : M ≃L[R] M₂) : inverse (e : M →L[R] M₂) = e.symm 
goal: (↑e).inverse = ↑e.symm

full_name: ContinuousLinearMap.inverse_non_equiv
code: /-- By definition, if `f` is not invertible then `inverse f = 0`. -/
@[simp]
theorem inverse_non_equiv (f : M →L[R] M₂) (h : ¬∃ e' : M ≃L[R] M₂, ↑e' = f) : inverse f = 0 
goal: f.inverse = 0

full_name: ContinuousLinearMap.ring_inverse_equiv
code: @[simp]
theorem ring_inverse_equiv (e : M ≃L[R] M) : Ring.inverse ↑e = inverse (e : M →L[R] M) 
goal: Ring.inverse ↑e = (↑e).inverse

full_name: ContinuousLinearMap.to_ring_inverse
code: /-- The function `ContinuousLinearEquiv.inverse` can be written in terms of `Ring.inverse` for the
ring of self-maps of the domain. -/
theorem to_ring_inverse (e : M ≃L[R] M₂) (f : M →L[R] M₂) :
    inverse f = Ring.inverse ((e.symm : M₂ →L[R] M).comp f) ∘L e.symm 
goal: f.inverse = (Ring.inverse ((↑e.symm).comp f)).comp ↑e.symm

full_name: ContinuousLinearMap.ring_inverse_eq_map_inverse
code: theorem ring_inverse_eq_map_inverse : Ring.inverse = @inverse R M M _ _ _ _ _ _ _ 
goal: Ring.inverse = ContinuousLinearMap.inverse

full_name: Submodule.ClosedComplemented
code: /-- A submodule `p` is called *complemented* if there exists a continuous projection `M →ₗ[R] p`. -/
def ClosedComplemented (p : Submodule R M) : Prop 
goal: Prop

full_name: Submodule.ClosedComplemented.exists_isClosed_isCompl
code: theorem ClosedComplemented.exists_isClosed_isCompl {p : Submodule R M} [T1Space p]
    (h : ClosedComplemented p) :
    ∃ q : Submodule R M, IsClosed (q : Set M) ∧ IsCompl p q 
goal: ∃ q, IsClosed ↑q ∧ IsCompl p q

full_name: Submodule.ClosedComplemented.isClosed
code: protected theorem ClosedComplemented.isClosed [TopologicalAddGroup M] [T1Space M]
    {p : Submodule R M} (h : ClosedComplemented p) : IsClosed (p : Set M) 
goal: IsClosed ↑p

full_name: Submodule.closedComplemented_bot
code: @[simp]
theorem closedComplemented_bot : ClosedComplemented (⊥ : Submodule R M) 
goal: ⊥.ClosedComplemented

full_name: Submodule.closedComplemented_top
code: @[simp]
theorem closedComplemented_top : ClosedComplemented (⊤ : Submodule R M) 
goal: ⊤.ClosedComplemented

full_name: Submodule.ClosedComplemented.exists_submodule_equiv_prod
code: /-- If `p` is a closed complemented submodule,
then there exists a submodule `q` and a continuous linear equivalence `M ≃L[R] (p × q)` such that
`e (x : p) = (x, 0)`, `e (y : q) = (0, y)`, and `e.symm x = x.1 + x.2`.

In fact, the properties of `e` imply the properties of `e.symm` and vice versa,
but we provide both for convenience. -/
lemma ClosedComplemented.exists_submodule_equiv_prod [TopologicalAddGroup M]
    {p : Submodule R M} (hp : p.ClosedComplemented) :
    ∃ (q : Submodule R M) (e : M ≃L[R] (p × q)),
      (∀ x : p, e x = (x, 0)) ∧ (∀ y : q, e y = (0, y)) ∧ (∀ x, e.symm x = x.1 + x.2) 
goal: ∃ q e, (∀ (x : ↥p), e ↑x = (x, 0)) ∧ (∀ (y : ↥q), e ↑y = (0, y)) ∧ ∀ (x : ↥p × ↥q), e.symm x = ↑x.1 + ↑x.2

full_name: ContinuousLinearMap.closedComplemented_ker_of_rightInverse
code: theorem ContinuousLinearMap.closedComplemented_ker_of_rightInverse {R : Type*} [Ring R]
    {M : Type*} [TopologicalSpace M] [AddCommGroup M] {M₂ : Type*} [TopologicalSpace M₂]
    [AddCommGroup M₂] [Module R M] [Module R M₂] [TopologicalAddGroup M] (f₁ : M →L[R] M₂)
    (f₂ : M₂ →L[R] M) (h : Function.RightInverse f₂ f₁) : (ker f₁).ClosedComplemented 
goal: (LinearMap.ker f₁).ClosedComplemented

full_name: QuotientModule.Quotient.topologicalSpace
code: instance _root_.QuotientModule.Quotient.topologicalSpace : TopologicalSpace (M ⧸ S) 
goal: TopologicalSpace (M ⧸ S)

full_name: Submodule.isOpenMap_mkQ
code: theorem isOpenMap_mkQ [TopologicalAddGroup M] : IsOpenMap S.mkQ 
goal: IsOpenMap ⇑S.mkQ

full_name: Submodule.topologicalAddGroup_quotient
code: instance topologicalAddGroup_quotient [TopologicalAddGroup M] : TopologicalAddGroup (M ⧸ S) 
goal: TopologicalAddGroup (M ⧸ S)

full_name: Submodule.continuousSMul_quotient
code: instance continuousSMul_quotient [TopologicalSpace R] [TopologicalAddGroup M] [ContinuousSMul R M] :
    ContinuousSMul R (M ⧸ S) 
goal: ContinuousSMul R (M ⧸ S)

full_name: Submodule.t3_quotient_of_isClosed
code: instance t3_quotient_of_isClosed [TopologicalAddGroup M] [IsClosed (S : Set M)] :
    T3Space (M ⧸ S) 
goal: T3Space (M ⧸ S)