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

full_name: LinearPMap.IsClosed
code: /-- An unbounded operator is closed iff its graph is closed. -/
def IsClosed (f : E →ₗ.[R] F) : Prop 
goal: Prop

full_name: LinearPMap.IsClosable
code: /-- An unbounded operator is closable iff the closure of its graph is a graph. -/
def IsClosable (f : E →ₗ.[R] F) : Prop 
goal: Prop

full_name: LinearPMap.IsClosed.isClosable
code: /-- A closed operator is trivially closable. -/
theorem IsClosed.isClosable {f : E →ₗ.[R] F} (hf : f.IsClosed) : f.IsClosable 
goal: f.IsClosable

full_name: LinearPMap.IsClosable.leIsClosable
code: /-- If `g` has a closable extension `f`, then `g` itself is closable. -/
theorem IsClosable.leIsClosable {f g : E →ₗ.[R] F} (hf : f.IsClosable) (hfg : g ≤ f) :
    g.IsClosable 
goal: g.IsClosable

full_name: LinearPMap.IsClosable.existsUnique
code: /-- The closure is unique. -/
theorem IsClosable.existsUnique {f : E →ₗ.[R] F} (hf : f.IsClosable) :
    ∃! f' : E →ₗ.[R] F, f.graph.topologicalClosure = f'.graph 
goal: ∃! f', f.graph.topologicalClosure = f'.graph

full_name: LinearPMap.closure
code: /-- If `f` is closable, then `f.closure` is the closure. Otherwise it is defined
as `f.closure = f`. -/
noncomputable def closure (f : E →ₗ.[R] F) : E →ₗ.[R] F 
goal: E →ₗ.[R] F

full_name: LinearPMap.closure_def
code: theorem closure_def {f : E →ₗ.[R] F} (hf : f.IsClosable) : f.closure = hf.choose 
goal: f.closure = Exists.choose hf

full_name: LinearPMap.closure_def'
code: theorem closure_def' {f : E →ₗ.[R] F} (hf : ¬f.IsClosable) : f.closure = f 
goal: f.closure = f

full_name: LinearPMap.IsClosable.graph_closure_eq_closure_graph
code: /-- The closure (as a submodule) of the graph is equal to the graph of the closure
  (as a `LinearPMap`). -/
theorem IsClosable.graph_closure_eq_closure_graph {f : E →ₗ.[R] F} (hf : f.IsClosable) :
    f.graph.topologicalClosure = f.closure.graph 
goal: f.graph.topologicalClosure = f.closure.graph

full_name: LinearPMap.le_closure
code: /-- A `LinearPMap` is contained in its closure. -/
theorem le_closure (f : E →ₗ.[R] F) : f ≤ f.closure 
goal: f ≤ f.closure

full_name: LinearPMap.IsClosable.closure_mono
code: theorem IsClosable.closure_mono {f g : E →ₗ.[R] F} (hg : g.IsClosable) (h : f ≤ g) :
    f.closure ≤ g.closure 
goal: f.closure ≤ g.closure

full_name: LinearPMap.IsClosable.closure_isClosed
code: /-- If `f` is closable, then the closure is closed. -/
theorem IsClosable.closure_isClosed {f : E →ₗ.[R] F} (hf : f.IsClosable) : f.closure.IsClosed 
goal: f.closure.IsClosed

full_name: LinearPMap.IsClosable.closureIsClosable
code: /-- If `f` is closable, then the closure is closable. -/
theorem IsClosable.closureIsClosable {f : E →ₗ.[R] F} (hf : f.IsClosable) : f.closure.IsClosable 
goal: f.closure.IsClosable

full_name: LinearPMap.isClosable_iff_exists_closed_extension
code: theorem isClosable_iff_exists_closed_extension {f : E →ₗ.[R] F} :
    f.IsClosable ↔ ∃ g : E →ₗ.[R] F, g.IsClosed ∧ f ≤ g 
goal: f.IsClosable ↔ ∃ g, g.IsClosed ∧ f ≤ g

full_name: LinearPMap.HasCore
code: /-- A submodule `S` is a core of `f` if the closure of the restriction of `f` to `S` is `f`. -/
structure HasCore (f : E →ₗ.[R] F) (S : Submodule R E) : Prop where
  le_domain : S ≤ f.domain
  closure_eq : (f.domRestrict S).closure = f
goal: Prop

full_name: LinearPMap.HasCore.le_domain
code: /-- A submodule `S` is a core of `f` if the closure of the restriction of `f` to `S` is `f`. -/
structure HasCore (f : E →ₗ.[R] F) (S : Submodule R E) : Prop where
  le_domain : S ≤ f.domain
  closure_eq : (f.domRestrict S).closure = f
goal: S ≤ f.domain

full_name: LinearPMap.HasCore.closure_eq
code: /-- A submodule `S` is a core of `f` if the closure of the restriction of `f` to `S` is `f`. -/
structure HasCore (f : E →ₗ.[R] F) (S : Submodule R E) : Prop where
  le_domain : S ≤ f.domain
  closure_eq : (f.domRestrict S).closure = f
goal: (f.domRestrict S).closure = f

full_name: LinearPMap.hasCore_def
code: theorem hasCore_def {f : E →ₗ.[R] F} {S : Submodule R E} (h : f.HasCore S) :
    (f.domRestrict S).closure = f 
goal: (f.domRestrict S).closure = f

full_name: LinearPMap.closureHasCore
code: /-- For every unbounded operator `f` the submodule `f.domain` is a core of its closure.

Note that we don't require that `f` is closable, due to the definition of the closure. -/
theorem closureHasCore (f : E →ₗ.[R] F) : f.closure.HasCore f.domain 
goal: f.closure.HasCore f.domain

full_name: LinearPMap.closure_inverse_graph
code: /-- If `f` is invertible and closable as well as its closure being invertible, then
the graph of the inverse of the closure is given by the closure of the graph of the inverse. -/
theorem closure_inverse_graph (hf : LinearMap.ker f.toFun = ⊥) (hf' : f.IsClosable)
    (hcf : LinearMap.ker f.closure.toFun = ⊥) :
    f.closure.inverse.graph = f.inverse.graph.topologicalClosure 
goal: f.closure.inverse.graph = f.inverse.graph.topologicalClosure

full_name: LinearPMap.inverse_isClosable_iff
code: /-- Assuming that `f` is invertible and closable, then the closure is invertible if and only
if the inverse of `f` is closable. -/
theorem inverse_isClosable_iff (hf : LinearMap.ker f.toFun = ⊥) (hf' : f.IsClosable) :
    f.inverse.IsClosable ↔ LinearMap.ker f.closure.toFun = ⊥ 
goal: f.inverse.IsClosable ↔ LinearMap.ker f.closure.toFun = ⊥

full_name: LinearPMap.inverse_closure
code: /-- If `f` is invertible and closable, then taking the closure and the inverse commute. -/
theorem inverse_closure (hf : LinearMap.ker f.toFun = ⊥) (hf' : f.IsClosable)
    (hcf : LinearMap.ker f.closure.toFun = ⊥) :
    f.inverse.closure = f.closure.inverse 
goal: f.inverse.closure = f.closure.inverse