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

full_name: instFiniteDimensionalContinuousLinearMapId
code: /-- The space of continuous linear maps between finite-dimensional spaces is finite-dimensional. -/
instance [FiniteDimensional 𝕜 E] [FiniteDimensional 𝕜 F] : FiniteDimensional 𝕜 (E →L[𝕜] F) 
goal: FiniteDimensional 𝕜 (E →L[𝕜] F)

full_name: unique_topology_of_t2
code: /-- If `𝕜` is a nontrivially normed field, any T2 topology on `𝕜` which makes it a topological
vector space over itself (with the norm topology) is *equal* to the norm topology. -/
theorem unique_topology_of_t2 {t : TopologicalSpace 𝕜} (h₁ : @TopologicalAddGroup 𝕜 t _)
    (h₂ : @ContinuousSMul 𝕜 𝕜 _ hnorm.toUniformSpace.toTopologicalSpace t) (h₃ : @T2Space 𝕜 t) :
    t = hnorm.toUniformSpace.toTopologicalSpace 
goal: t = UniformSpace.toTopologicalSpace

full_name: LinearMap.continuous_of_isClosed_ker
code: /-- Any linear form on a topological vector space over a nontrivially normed field is continuous if
    its kernel is closed. -/
theorem LinearMap.continuous_of_isClosed_ker (l : E →ₗ[𝕜] 𝕜)
    (hl : IsClosed (LinearMap.ker l : Set E)) :
    Continuous l 
goal: Continuous ⇑l

full_name: LinearMap.continuous_iff_isClosed_ker
code: /-- Any linear form on a topological vector space over a nontrivially normed field is continuous if
    and only if its kernel is closed. -/
theorem LinearMap.continuous_iff_isClosed_ker (l : E →ₗ[𝕜] 𝕜) :
    Continuous l ↔ IsClosed (LinearMap.ker l : Set E) 
goal: Continuous ⇑l ↔ IsClosed ↑(LinearMap.ker l)

full_name: LinearMap.continuous_of_nonzero_on_open
code: /-- Over a nontrivially normed field, any linear form which is nonzero on a nonempty open set is
    automatically continuous. -/
theorem LinearMap.continuous_of_nonzero_on_open (l : E →ₗ[𝕜] 𝕜) (s : Set E) (hs₁ : IsOpen s)
    (hs₂ : s.Nonempty) (hs₃ : ∀ x ∈ s, l x ≠ 0) : Continuous l 
goal: Continuous ⇑l

full_name: _private.Mathlib.Topology.Algebra.Module.FiniteDimension.0.continuous_equivFun_basis_aux
code: /-- This version imposes `ι` and `E` to live in the same universe, so you should instead use
`continuous_equivFun_basis` which gives the same result without universe restrictions. -/
private theorem continuous_equivFun_basis_aux [T2Space E] {ι : Type v} [Fintype ι]
    (ξ : Basis ι 𝕜 E) : Continuous ξ.equivFun 
goal: Continuous ⇑ξ.equivFun

full_name: LinearMap.continuous_of_finiteDimensional
code: /-- Any linear map on a finite dimensional space over a complete field is continuous. -/
theorem LinearMap.continuous_of_finiteDimensional [T2Space E] [FiniteDimensional 𝕜 E]
    (f : E →ₗ[𝕜] F') : Continuous f 
goal: Continuous ⇑f

full_name: LinearMap.continuousLinearMapClassOfFiniteDimensional
code: instance LinearMap.continuousLinearMapClassOfFiniteDimensional [T2Space E] [FiniteDimensional 𝕜 E] :
    ContinuousLinearMapClass (E →ₗ[𝕜] F') 𝕜 E F' 
goal: ContinuousLinearMapClass (E →ₗ[𝕜] F') 𝕜 E F'

full_name: continuous_equivFun_basis
code: /-- In finite dimensions over a non-discrete complete normed field, the canonical identification
(in terms of a basis) with `𝕜^n` (endowed with the product topology) is continuous.
This is the key fact which makes all linear maps from a T2 finite dimensional TVS over such a field
continuous (see `LinearMap.continuous_of_finiteDimensional`), which in turn implies that all
norms are equivalent in finite dimensions. -/
theorem continuous_equivFun_basis [T2Space E] {ι : Type*} [Finite ι] (ξ : Basis ι 𝕜 E) :
    Continuous ξ.equivFun 
goal: Continuous ⇑ξ.equivFun

full_name: LinearMap.toContinuousLinearMap
code: /-- The continuous linear map induced by a linear map on a finite dimensional space -/
def toContinuousLinearMap : (E →ₗ[𝕜] F') ≃ₗ[𝕜] E →L[𝕜] F' 
goal: (E →ₗ[𝕜] F') ≃ₗ[𝕜] E →L[𝕜] F'

full_name: Module.End.toContinuousLinearMap
code: /-- Algebra equivalence between the linear maps and continuous linear maps on a finite dimensional
    space. -/
def _root_.Module.End.toContinuousLinearMap (E : Type v) [NormedAddCommGroup E]
    [NormedSpace 𝕜 E] [FiniteDimensional 𝕜 E] : (E →ₗ[𝕜] E) ≃ₐ[𝕜] (E →L[𝕜] E) 
goal: (E →ₗ[𝕜] E) ≃ₐ[𝕜] E →L[𝕜] E

full_name: LinearMap.coe_toContinuousLinearMap'
code: @[simp]
theorem coe_toContinuousLinearMap' (f : E →ₗ[𝕜] F') : ⇑(LinearMap.toContinuousLinearMap f) = f 
goal: ⇑(LinearMap.toContinuousLinearMap f) = ⇑f

full_name: LinearMap.coe_toContinuousLinearMap
code: @[simp]
theorem coe_toContinuousLinearMap (f : E →ₗ[𝕜] F') :
    ((LinearMap.toContinuousLinearMap f) : E →ₗ[𝕜] F') = f 
goal: ↑(LinearMap.toContinuousLinearMap f) = f

full_name: LinearMap.coe_toContinuousLinearMap_symm
code: @[simp]
theorem coe_toContinuousLinearMap_symm :
    ⇑(toContinuousLinearMap : (E →ₗ[𝕜] F') ≃ₗ[𝕜] E →L[𝕜] F').symm =
      ((↑) : (E →L[𝕜] F') → E →ₗ[𝕜] F') 
goal: ⇑LinearMap.toContinuousLinearMap.symm = ContinuousLinearMap.toLinearMap

full_name: LinearMap.det_toContinuousLinearMap
code: @[simp]
theorem det_toContinuousLinearMap (f : E →ₗ[𝕜] E) :
    (LinearMap.toContinuousLinearMap f).det = LinearMap.det f 
goal: (LinearMap.toContinuousLinearMap f).det = LinearMap.det f

full_name: LinearMap.ker_toContinuousLinearMap
code: @[simp]
theorem ker_toContinuousLinearMap (f : E →ₗ[𝕜] F') :
    ker (LinearMap.toContinuousLinearMap f) = ker f 
goal: LinearMap.ker (LinearMap.toContinuousLinearMap f) = LinearMap.ker f

full_name: LinearMap.range_toContinuousLinearMap
code: @[simp]
theorem range_toContinuousLinearMap (f : E →ₗ[𝕜] F') :
    range (LinearMap.toContinuousLinearMap f) = range f 
goal: LinearMap.range (LinearMap.toContinuousLinearMap f) = LinearMap.range f

full_name: LinearMap.isOpenMap_of_finiteDimensional
code: /-- A surjective linear map `f` with finite dimensional codomain is an open map. -/
theorem isOpenMap_of_finiteDimensional (f : F →ₗ[𝕜] E) (hf : Function.Surjective f) :
    IsOpenMap f 
goal: IsOpenMap ⇑f

full_name: LinearMap.canLiftContinuousLinearMap
code: instance canLiftContinuousLinearMap : CanLift (E →ₗ[𝕜] F) (E →L[𝕜] F) (↑) fun _ => True 
goal: CanLift (E →ₗ[𝕜] F) (E →L[𝕜] F) ContinuousLinearMap.toLinearMap fun x => True

full_name: LinearEquiv.toContinuousLinearEquiv
code: /-- The continuous linear equivalence induced by a linear equivalence on a finite dimensional
space. -/
def toContinuousLinearEquiv (e : E ≃ₗ[𝕜] F) : E ≃L[𝕜] F 
goal: E ≃L[𝕜] F

full_name: LinearEquiv.coe_toContinuousLinearEquiv
code: @[simp]
theorem coe_toContinuousLinearEquiv (e : E ≃ₗ[𝕜] F) : (e.toContinuousLinearEquiv : E →ₗ[𝕜] F) = e 
goal: ↑↑e.toContinuousLinearEquiv = ↑e

full_name: LinearEquiv.coe_toContinuousLinearEquiv'
code: @[simp]
theorem coe_toContinuousLinearEquiv' (e : E ≃ₗ[𝕜] F) : (e.toContinuousLinearEquiv : E → F) = e 
goal: ⇑e.toContinuousLinearEquiv = ⇑e

full_name: LinearEquiv.coe_toContinuousLinearEquiv_symm
code: @[simp]
theorem coe_toContinuousLinearEquiv_symm (e : E ≃ₗ[𝕜] F) :
    (e.toContinuousLinearEquiv.symm : F →ₗ[𝕜] E) = e.symm 
goal: ↑↑e.toContinuousLinearEquiv.symm = ↑e.symm

full_name: LinearEquiv.coe_toContinuousLinearEquiv_symm'
code: @[simp]
theorem coe_toContinuousLinearEquiv_symm' (e : E ≃ₗ[𝕜] F) :
    (e.toContinuousLinearEquiv.symm : F → E) = e.symm 
goal: ⇑e.toContinuousLinearEquiv.symm = ⇑e.symm

full_name: LinearEquiv.toLinearEquiv_toContinuousLinearEquiv
code: @[simp]
theorem toLinearEquiv_toContinuousLinearEquiv (e : E ≃ₗ[𝕜] F) :
    e.toContinuousLinearEquiv.toLinearEquiv = e 
goal: e.toContinuousLinearEquiv.toLinearEquiv = e

full_name: LinearEquiv.toLinearEquiv_toContinuousLinearEquiv_symm
code: theorem toLinearEquiv_toContinuousLinearEquiv_symm (e : E ≃ₗ[𝕜] F) :
    e.toContinuousLinearEquiv.symm.toLinearEquiv = e.symm 
goal: e.toContinuousLinearEquiv.symm.toLinearEquiv = e.symm

full_name: LinearEquiv.canLiftContinuousLinearEquiv
code: instance canLiftContinuousLinearEquiv :
    CanLift (E ≃ₗ[𝕜] F) (E ≃L[𝕜] F) ContinuousLinearEquiv.toLinearEquiv fun _ => True 
goal: CanLift (E ≃ₗ[𝕜] F) (E ≃L[𝕜] F) ContinuousLinearEquiv.toLinearEquiv fun x => True

full_name: FiniteDimensional.nonempty_continuousLinearEquiv_of_finrank_eq
code: /-- Two finite-dimensional topological vector spaces over a complete normed field are continuously
linearly equivalent if they have the same (finite) dimension. -/
theorem FiniteDimensional.nonempty_continuousLinearEquiv_of_finrank_eq
    (cond : finrank 𝕜 E = finrank 𝕜 F) : Nonempty (E ≃L[𝕜] F) 
goal: Nonempty (E ≃L[𝕜] F)

full_name: FiniteDimensional.nonempty_continuousLinearEquiv_iff_finrank_eq
code: /-- Two finite-dimensional topological vector spaces over a complete normed field are continuously
linearly equivalent if and only if they have the same (finite) dimension. -/
theorem FiniteDimensional.nonempty_continuousLinearEquiv_iff_finrank_eq :
    Nonempty (E ≃L[𝕜] F) ↔ finrank 𝕜 E = finrank 𝕜 F 
goal: Nonempty (E ≃L[𝕜] F) ↔ FiniteDimensional.finrank 𝕜 E = FiniteDimensional.finrank 𝕜 F

full_name: ContinuousLinearEquiv.ofFinrankEq
code: /-- A continuous linear equivalence between two finite-dimensional topological vector spaces over a
complete normed field of the same (finite) dimension. -/
def ContinuousLinearEquiv.ofFinrankEq (cond : finrank 𝕜 E = finrank 𝕜 F) : E ≃L[𝕜] F 
goal: E ≃L[𝕜] F

full_name: Basis.constrL
code: /-- Construct a continuous linear map given the value at a finite basis. -/
def constrL (v : Basis ι 𝕜 E) (f : ι → F) : E →L[𝕜] F 
goal: E →L[𝕜] F

full_name: Basis.coe_constrL
code: @[simp] -- Porting note: removed `norm_cast`
theorem coe_constrL (v : Basis ι 𝕜 E) (f : ι → F) : (v.constrL f : E →ₗ[𝕜] F) = v.constr 𝕜 f 
goal: ↑(v.constrL f) = (v.constr 𝕜) f

full_name: Basis.equivFunL
code: /-- The continuous linear equivalence between a vector space over `𝕜` with a finite basis and
functions from its basis indexing type to `𝕜`. -/
@[simps! apply]
def equivFunL (v : Basis ι 𝕜 E) : E ≃L[𝕜] ι → 𝕜 
goal: E ≃L[𝕜] ι → 𝕜

full_name: Basis.equivFunL_apply
code: /-- The continuous linear equivalence between a vector space over `𝕜` with a finite basis and
functions from its basis indexing type to `𝕜`. -/
@[simps! apply]
def equivFunL (v : Basis ι 𝕜 E) : E ≃L[𝕜] ι → 𝕜 
goal: ∀ (a : E) (a_1 : ι), v.equivFunL a a_1 = (v.repr a) a_1

full_name: Basis.equivFunL_symm_apply_repr
code: @[simp]
lemma equivFunL_symm_apply_repr (v : Basis ι 𝕜 E) (x : E) :
    v.equivFunL.symm (v.repr x) = x 
goal: v.equivFunL.symm ⇑(v.repr x) = x

full_name: Basis.constrL_apply
code: @[simp]
theorem constrL_apply {ι : Type*} [Fintype ι] (v : Basis ι 𝕜 E) (f : ι → F) (e : E) :
    v.constrL f e = ∑ i, v.equivFun e i • f i 
goal: (v.constrL f) e = ∑ i : ι, v.equivFun e i • f i

full_name: Basis.constrL_basis
code: @[simp 1100]
theorem constrL_basis (v : Basis ι 𝕜 E) (f : ι → F) (i : ι) : v.constrL f (v i) = f i 
goal: (v.constrL f) (v i) = f i

full_name: ContinuousLinearMap.toContinuousLinearEquivOfDetNeZero
code: /-- Builds a continuous linear equivalence from a continuous linear map on a finite-dimensional
vector space whose determinant is nonzero. -/
def toContinuousLinearEquivOfDetNeZero (f : E →L[𝕜] E) (hf : f.det ≠ 0) : E ≃L[𝕜] E 
goal: E ≃L[𝕜] E

full_name: ContinuousLinearMap.coe_toContinuousLinearEquivOfDetNeZero
code: @[simp]
theorem coe_toContinuousLinearEquivOfDetNeZero (f : E →L[𝕜] E) (hf : f.det ≠ 0) :
    (f.toContinuousLinearEquivOfDetNeZero hf : E →L[𝕜] E) = f 
goal: ↑(f.toContinuousLinearEquivOfDetNeZero hf) = f

full_name: ContinuousLinearMap.toContinuousLinearEquivOfDetNeZero_apply
code: @[simp]
theorem toContinuousLinearEquivOfDetNeZero_apply (f : E →L[𝕜] E) (hf : f.det ≠ 0) (x : E) :
    f.toContinuousLinearEquivOfDetNeZero hf x = f x 
goal: (f.toContinuousLinearEquivOfDetNeZero hf) x = f x

full_name: Matrix.toLin_finTwoProd_toContinuousLinearMap
code: theorem _root_.Matrix.toLin_finTwoProd_toContinuousLinearMap (a b c d : 𝕜) :
    LinearMap.toContinuousLinearMap
      (Matrix.toLin (Basis.finTwoProd 𝕜) (Basis.finTwoProd 𝕜) !![a, b; c, d]) =
      (a • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + b • ContinuousLinearMap.snd 𝕜 𝕜 𝕜).prod
        (c • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + d • ContinuousLinearMap.snd 𝕜 𝕜 𝕜) 
goal: LinearMap.toContinuousLinearMap ((Matrix.toLin (Basis.finTwoProd 𝕜) (Basis.finTwoProd 𝕜)) !![a, b; c, d]) =
  (a • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + b • ContinuousLinearMap.snd 𝕜 𝕜 𝕜).prod
    (c • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + d • ContinuousLinearMap.snd 𝕜 𝕜 𝕜)

full_name: FiniteDimensional.complete
code: theorem FiniteDimensional.complete : CompleteSpace E 
goal: CompleteSpace E

full_name: Submodule.complete_of_finiteDimensional
code: /-- A finite-dimensional subspace is complete. -/
theorem Submodule.complete_of_finiteDimensional (s : Submodule 𝕜 E) [FiniteDimensional 𝕜 s] :
    IsComplete (s : Set E) 
goal: IsComplete ↑s

full_name: Submodule.closed_of_finiteDimensional
code: /-- A finite-dimensional subspace is closed. -/
theorem Submodule.closed_of_finiteDimensional (s : Submodule 𝕜 E) [FiniteDimensional 𝕜 s] :
    IsClosed (s : Set E) 
goal: IsClosed ↑s

full_name: LinearMap.closedEmbedding_of_injective
code: /-- An injective linear map with finite-dimensional domain is a closed embedding. -/
theorem LinearMap.closedEmbedding_of_injective [FiniteDimensional 𝕜 E] {f : E →ₗ[𝕜] F}
    (hf : LinearMap.ker f = ⊥) : ClosedEmbedding f 
goal: ClosedEmbedding ⇑f

full_name: closedEmbedding_smul_left
code: theorem closedEmbedding_smul_left {c : E} (hc : c ≠ 0) : ClosedEmbedding fun x : 𝕜 => x • c 
goal: ClosedEmbedding fun x => x • c

full_name: isClosedMap_smul_left
code: theorem isClosedMap_smul_left (c : E) : IsClosedMap fun x : 𝕜 => x • c 
goal: IsClosedMap fun x => x • c

full_name: ContinuousLinearMap.exists_right_inverse_of_surjective
code: theorem ContinuousLinearMap.exists_right_inverse_of_surjective [FiniteDimensional 𝕜 F]
    (f : E →L[𝕜] F) (hf : LinearMap.range f = ⊤) :
    ∃ g : F →L[𝕜] E, f.comp g = ContinuousLinearMap.id 𝕜 F 
goal: ∃ g, f.comp g = ContinuousLinearMap.id 𝕜 F