File: Mathlib/LinearAlgebra/LinearPMap.lean

full_name: LinearPMap.toFun
code: /-- A `LinearPMap R E F` or `E →ₗ.[R] F` is a linear map from a submodule of `E` to `F`. -/
structure LinearPMap (R : Type u) [Ring R] (E : Type v) [AddCommGroup E] [Module R E] (F : Type w)
  [AddCommGroup F] [Module R F] where
  domain : Submodule R E
  toFun : domain →ₗ[R] F
goal: ↥self.domain →ₗ[R] F

full_name: LinearPMap
code: /-- A `LinearPMap R E F` or `E →ₗ.[R] F` is a linear map from a submodule of `E` to `F`. -/
structure LinearPMap (R : Type u) [Ring R] (E : Type v) [AddCommGroup E] [Module R E] (F : Type w)
  [AddCommGroup F] [Module R F] where
  domain : Submodule R E
  toFun : domain →ₗ[R] F
goal: Type (max v w)

full_name: LinearPMap.domain
code: /-- A `LinearPMap R E F` or `E →ₗ.[R] F` is a linear map from a submodule of `E` to `F`. -/
structure LinearPMap (R : Type u) [Ring R] (E : Type v) [AddCommGroup E] [Module R E] (F : Type w)
  [AddCommGroup F] [Module R F] where
  domain : Submodule R E
  toFun : domain →ₗ[R] F
goal: Submodule R E

full_name: _aux_Mathlib_LinearAlgebra_LinearPMap___unexpand_LinearPMap_1
code: @[inherit_doc] notation:25 E " →ₗ.[" R:25 "] " F:0 => LinearPMap R E F
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_LinearAlgebra_LinearPMap___macroRules_term_→ₗ.[_]__1»
code: @[inherit_doc] notation:25 E " →ₗ.[" R:25 "] " F:0 => LinearPMap R E F
goal: Lean.Macro

full_name: LinearPMap.toFun'
code: @[coe]
def toFun' (f : E →ₗ.[R] F) : f.domain → F 
goal: ↥f.domain → F

full_name: LinearPMap.instCoeFunForallSubtypeMemSubmoduleDomain
code: instance : CoeFun (E →ₗ.[R] F) fun f : E →ₗ.[R] F => f.domain → F 
goal: CoeFun (E →ₗ.[R] F) fun f => ↥f.domain → F

full_name: LinearPMap.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe (f : E →ₗ.[R] F) (x : f.domain) : f.toFun x = f x 
goal: f.toFun x = ↑f x

full_name: LinearPMap.ext
code: @[ext]
theorem ext {f g : E →ₗ.[R] F} (h : f.domain = g.domain)
    (h' : ∀ ⦃x : f.domain⦄ ⦃y : g.domain⦄ (_h : (x : E) = y), f x = g y) : f = g 
goal: f = g

full_name: LinearPMap.map_zero
code: @[simp]
theorem map_zero (f : E →ₗ.[R] F) : f 0 = 0 
goal: ↑f 0 = 0

full_name: LinearPMap.ext_iff
code: theorem ext_iff {f g : E →ₗ.[R] F} :
    f = g ↔
      ∃ _domain_eq : f.domain = g.domain,
        ∀ ⦃x : f.domain⦄ ⦃y : g.domain⦄ (_h : (x : E) = y), f x = g y 
goal: f = g ↔ ∃ (_ : f.domain = g.domain), ∀ ⦃x : ↥f.domain⦄ ⦃y : ↥g.domain⦄, ↑x = ↑y → ↑f x = ↑g y

full_name: LinearPMap.ext'
code: theorem ext' {s : Submodule R E} {f g : s →ₗ[R] F} (h : f = g) : mk s f = mk s g 
goal: { domain := s, toFun := f } = { domain := s, toFun := g }

full_name: LinearPMap.map_add
code: theorem map_add (f : E →ₗ.[R] F) (x y : f.domain) : f (x + y) = f x + f y 
goal: ↑f (x + y) = ↑f x + ↑f y

full_name: LinearPMap.map_neg
code: theorem map_neg (f : E →ₗ.[R] F) (x : f.domain) : f (-x) = -f x 
goal: ↑f (-x) = -↑f x

full_name: LinearPMap.map_sub
code: theorem map_sub (f : E →ₗ.[R] F) (x y : f.domain) : f (x - y) = f x - f y 
goal: ↑f (x - y) = ↑f x - ↑f y

full_name: LinearPMap.map_smul
code: theorem map_smul (f : E →ₗ.[R] F) (c : R) (x : f.domain) : f (c • x) = c • f x 
goal: ↑f (c • x) = c • ↑f x

full_name: LinearPMap.mk_apply
code: @[simp]
theorem mk_apply (p : Submodule R E) (f : p →ₗ[R] F) (x : p) : mk p f x = f x 
goal: ↑{ domain := p, toFun := f } x = f x

full_name: LinearPMap.mkSpanSingleton'
code: /-- The unique `LinearPMap` on `R ∙ x` that sends `x` to `y`. This version works for modules
over rings, and requires a proof of `∀ c, c • x = 0 → c • y = 0`. -/
noncomputable def mkSpanSingleton' (x : E) (y : F) (H : ∀ c : R, c • x = 0 → c • y = 0) :
    E →ₗ.[R] F 
goal: E →ₗ.[R] F

full_name: LinearPMap.domain_mkSpanSingleton
code: @[simp]
theorem domain_mkSpanSingleton (x : E) (y : F) (H : ∀ c : R, c • x = 0 → c • y = 0) :
    (mkSpanSingleton' x y H).domain = R ∙ x 
goal: (LinearPMap.mkSpanSingleton' x y H).domain = Submodule.span R {x}

full_name: LinearPMap.mkSpanSingleton'_apply
code: @[simp]
theorem mkSpanSingleton'_apply (x : E) (y : F) (H : ∀ c : R, c • x = 0 → c • y = 0) (c : R) (h) :
    mkSpanSingleton' x y H ⟨c • x, h⟩ = c • y 
goal: ↑(LinearPMap.mkSpanSingleton' x y H) ⟨c • x, h⟩ = c • y

full_name: LinearPMap.mkSpanSingleton'_apply_self
code: @[simp]
theorem mkSpanSingleton'_apply_self (x : E) (y : F) (H : ∀ c : R, c • x = 0 → c • y = 0) (h) :
    mkSpanSingleton' x y H ⟨x, h⟩ = y 
goal: ↑(LinearPMap.mkSpanSingleton' x y H) ⟨x, h⟩ = y

full_name: LinearPMap.mkSpanSingleton
code: /-- The unique `LinearPMap` on `span R {x}` that sends a non-zero vector `x` to `y`.
This version works for modules over division rings. -/
noncomputable abbrev mkSpanSingleton {K E F : Type*} [DivisionRing K] [AddCommGroup E] [Module K E]
    [AddCommGroup F] [Module K F] (x : E) (y : F) (hx : x ≠ 0) : E →ₗ.[K] F 
goal: E →ₗ.[K] F

full_name: LinearPMap.mkSpanSingleton_apply
code: theorem mkSpanSingleton_apply (K : Type*) {E F : Type*} [DivisionRing K] [AddCommGroup E]
    [Module K E] [AddCommGroup F] [Module K F] {x : E} (hx : x ≠ 0) (y : F) :
    mkSpanSingleton x y hx ⟨x, (Submodule.mem_span_singleton_self x : x ∈ Submodule.span K {x})⟩ =
      y 
goal: ↑(LinearPMap.mkSpanSingleton x y hx) ⟨x, ⋯⟩ = y

full_name: LinearPMap.fst
code: /-- Projection to the first coordinate as a `LinearPMap` -/
protected def fst (p : Submodule R E) (p' : Submodule R F) : E × F →ₗ.[R] E 
goal: E × F →ₗ.[R] E

full_name: LinearPMap.fst_apply
code: @[simp]
theorem fst_apply (p : Submodule R E) (p' : Submodule R F) (x : p.prod p') :
    LinearPMap.fst p p' x = (x : E × F).1 
goal: ↑(LinearPMap.fst p p') x = (↑x).1

full_name: LinearPMap.snd
code: /-- Projection to the second coordinate as a `LinearPMap` -/
protected def snd (p : Submodule R E) (p' : Submodule R F) : E × F →ₗ.[R] F 
goal: E × F →ₗ.[R] F

full_name: LinearPMap.snd_apply
code: @[simp]
theorem snd_apply (p : Submodule R E) (p' : Submodule R F) (x : p.prod p') :
    LinearPMap.snd p p' x = (x : E × F).2 
goal: ↑(LinearPMap.snd p p') x = (↑x).2

full_name: LinearPMap.le
code: instance le : LE (E →ₗ.[R] F) 
goal: LE (E →ₗ.[R] F)

full_name: LinearPMap.apply_comp_inclusion
code: theorem apply_comp_inclusion {T S : E →ₗ.[R] F} (h : T ≤ S) (x : T.domain) :
    T x = S (Submodule.inclusion h.1 x) 
goal: ↑T x = ↑S ((Submodule.inclusion ⋯) x)

full_name: LinearPMap.exists_of_le
code: theorem exists_of_le {T S : E →ₗ.[R] F} (h : T ≤ S) (x : T.domain) :
    ∃ y : S.domain, (x : E) = y ∧ T x = S y 
goal: ∃ y, ↑x = ↑y ∧ ↑T x = ↑S y

full_name: LinearPMap.eq_of_le_of_domain_eq
code: theorem eq_of_le_of_domain_eq {f g : E →ₗ.[R] F} (hle : f ≤ g) (heq : f.domain = g.domain) :
    f = g 
goal: f = g

full_name: LinearPMap.eqLocus
code: /-- Given two partial linear maps `f`, `g`, the set of points `x` such that
both `f` and `g` are defined at `x` and `f x = g x` form a submodule. -/
def eqLocus (f g : E →ₗ.[R] F) : Submodule R E 
goal: Submodule R E

full_name: LinearPMap.inf
code: instance inf : Inf (E →ₗ.[R] F) 
goal: Inf (E →ₗ.[R] F)

full_name: LinearPMap.bot
code: instance bot : Bot (E →ₗ.[R] F) 
goal: Bot (E →ₗ.[R] F)

full_name: LinearPMap.inhabited
code: instance inhabited : Inhabited (E →ₗ.[R] F) 
goal: Inhabited (E →ₗ.[R] F)

full_name: LinearPMap.semilatticeInf
code: instance semilatticeInf : SemilatticeInf (E →ₗ.[R] F) 
goal: SemilatticeInf (E →ₗ.[R] F)

full_name: LinearPMap.orderBot
code: instance orderBot : OrderBot (E →ₗ.[R] F) 
goal: OrderBot (E →ₗ.[R] F)

full_name: LinearPMap.le_of_eqLocus_ge
code: theorem le_of_eqLocus_ge {f g : E →ₗ.[R] F} (H : f.domain ≤ f.eqLocus g) : f ≤ g 
goal: f ≤ g

full_name: LinearPMap.domain_mono
code: theorem domain_mono : StrictMono (@domain R _ E _ _ F _ _) 
goal: StrictMono LinearPMap.domain

full_name: _private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.sup_aux
code: private theorem sup_aux (f g : E →ₗ.[R] F)
    (h : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y) :
    ∃ fg : ↥(f.domain ⊔ g.domain) →ₗ[R] F,
      ∀ (x : f.domain) (y : g.domain) (z : ↥(f.domain ⊔ g.domain)),
        (x : E) + y = ↑z → fg z = f x + g y 
goal: ∃ fg, ∀ (x : ↥f.domain) (y : ↥g.domain) (z : ↥(f.domain ⊔ g.domain)), ↑x + ↑y = ↑z → fg z = ↑f x + ↑g y

full_name: LinearPMap.sup
code: /-- Given two partial linear maps that agree on the intersection of their domains,
`f.sup g h` is the unique partial linear map on `f.domain ⊔ g.domain` that agrees
with `f` and `g`. -/
protected noncomputable def sup (f g : E →ₗ.[R] F)
    (h : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y) : E →ₗ.[R] F 
goal: E →ₗ.[R] F

full_name: LinearPMap.domain_sup
code: @[simp]
theorem domain_sup (f g : E →ₗ.[R] F)
    (h : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y) :
    (f.sup g h).domain = f.domain ⊔ g.domain 
goal: (f.sup g h).domain = f.domain ⊔ g.domain

full_name: LinearPMap.sup_apply
code: theorem sup_apply {f g : E →ₗ.[R] F} (H : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y)
    (x : f.domain) (y : g.domain) (z : ↥(f.domain ⊔ g.domain)) (hz : (↑x : E) + ↑y = ↑z) :
    f.sup g H z = f x + g y 
goal: ↑(f.sup g H) z = ↑f x + ↑g y

full_name: LinearPMap.left_le_sup
code: protected theorem left_le_sup (f g : E →ₗ.[R] F)
    (h : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y) : f ≤ f.sup g h 
goal: f ≤ f.sup g h

full_name: LinearPMap.right_le_sup
code: protected theorem right_le_sup (f g : E →ₗ.[R] F)
    (h : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y) : g ≤ f.sup g h 
goal: g ≤ f.sup g h

full_name: LinearPMap.sup_le
code: protected theorem sup_le {f g h : E →ₗ.[R] F}
    (H : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y) (fh : f ≤ h) (gh : g ≤ h) :
    f.sup g H ≤ h 
goal: f.sup g H ≤ h

full_name: LinearPMap.sup_h_of_disjoint
code: /-- Hypothesis for `LinearPMap.sup` holds, if `f.domain` is disjoint with `g.domain`. -/
theorem sup_h_of_disjoint (f g : E →ₗ.[R] F) (h : Disjoint f.domain g.domain) (x : f.domain)
    (y : g.domain) (hxy : (x : E) = y) : f x = g y 
goal: ↑f x = ↑g y

full_name: LinearPMap.instZero
code: instance instZero : Zero (E →ₗ.[R] F) 
goal: Zero (E →ₗ.[R] F)

full_name: LinearPMap.zero_domain
code: @[simp]
theorem zero_domain : (0 : E →ₗ.[R] F).domain = ⊤ 
goal: LinearPMap.domain 0 = ⊤

full_name: LinearPMap.zero_apply
code: @[simp]
theorem zero_apply (x : (⊤ : Submodule R E)) : (0 : E →ₗ.[R] F) x = 0 
goal: ↑0 x = 0

full_name: LinearPMap.instSMul
code: instance instSMul : SMul M (E →ₗ.[R] F) 
goal: SMul M (E →ₗ.[R] F)

full_name: LinearPMap.smul_domain
code: @[simp]
theorem smul_domain (a : M) (f : E →ₗ.[R] F) : (a • f).domain = f.domain 
goal: (a • f).domain = f.domain

full_name: LinearPMap.smul_apply
code: theorem smul_apply (a : M) (f : E →ₗ.[R] F) (x : (a • f).domain) : (a • f) x = a • f x 
goal: ↑(a • f) x = a • ↑f x

full_name: LinearPMap.coe_smul
code: @[simp]
theorem coe_smul (a : M) (f : E →ₗ.[R] F) : ⇑(a • f) = a • ⇑f 
goal: ↑(a • f) = a • ↑f

full_name: LinearPMap.instSMulCommClass
code: instance instSMulCommClass [SMulCommClass M N F] : SMulCommClass M N (E →ₗ.[R] F) 
goal: SMulCommClass M N (E →ₗ.[R] F)

full_name: LinearPMap.instIsScalarTower
code: instance instIsScalarTower [SMul M N] [IsScalarTower M N F] : IsScalarTower M N (E →ₗ.[R] F) 
goal: IsScalarTower M N (E →ₗ.[R] F)

full_name: LinearPMap.instMulAction
code: instance instMulAction : MulAction M (E →ₗ.[R] F) 
goal: MulAction M (E →ₗ.[R] F)

full_name: LinearPMap.instNeg
code: instance instNeg : Neg (E →ₗ.[R] F) 
goal: Neg (E →ₗ.[R] F)

full_name: LinearPMap.neg_domain
code: @[simp]
theorem neg_domain (f : E →ₗ.[R] F) : (-f).domain = f.domain 
goal: (-f).domain = f.domain

full_name: LinearPMap.neg_apply
code: @[simp]
theorem neg_apply (f : E →ₗ.[R] F) (x) : (-f) x = -f x 
goal: ↑(-f) x = -↑f x

full_name: LinearPMap.instInvolutiveNeg
code: instance instInvolutiveNeg : InvolutiveNeg (E →ₗ.[R] F) 
goal: InvolutiveNeg (E →ₗ.[R] F)

full_name: LinearPMap.instAdd
code: instance instAdd : Add (E →ₗ.[R] F) 
goal: Add (E →ₗ.[R] F)

full_name: LinearPMap.add_domain
code: theorem add_domain (f g : E →ₗ.[R] F) : (f + g).domain = f.domain ⊓ g.domain 
goal: (f + g).domain = f.domain ⊓ g.domain

full_name: LinearPMap.add_apply
code: theorem add_apply (f g : E →ₗ.[R] F) (x : (f.domain ⊓ g.domain : Submodule R E)) :
    (f + g) x = f ⟨x, x.prop.1⟩ + g ⟨x, x.prop.2⟩ 
goal: ↑(f + g) x = ↑f ⟨↑x, ⋯⟩ + ↑g ⟨↑x, ⋯⟩

full_name: LinearPMap.instAddSemigroup
code: instance instAddSemigroup : AddSemigroup (E →ₗ.[R] F) 
goal: AddSemigroup (E →ₗ.[R] F)

full_name: LinearPMap.instAddZeroClass
code: instance instAddZeroClass : AddZeroClass (E →ₗ.[R] F) 
goal: AddZeroClass (E →ₗ.[R] F)

full_name: LinearPMap.instAddMonoid
code: instance instAddMonoid : AddMonoid (E →ₗ.[R] F) 
goal: AddMonoid (E →ₗ.[R] F)

full_name: LinearPMap.instAddCommMonoid
code: instance instAddCommMonoid : AddCommMonoid (E →ₗ.[R] F) 
goal: AddCommMonoid (E →ₗ.[R] F)

full_name: LinearPMap.instVAdd
code: instance instVAdd : VAdd (E →ₗ[R] F) (E →ₗ.[R] F) 
goal: VAdd (E →ₗ[R] F) (E →ₗ.[R] F)

full_name: LinearPMap.vadd_domain
code: @[simp]
theorem vadd_domain (f : E →ₗ[R] F) (g : E →ₗ.[R] F) : (f +ᵥ g).domain = g.domain 
goal: (f +ᵥ g).domain = g.domain

full_name: LinearPMap.vadd_apply
code: theorem vadd_apply (f : E →ₗ[R] F) (g : E →ₗ.[R] F) (x : (f +ᵥ g).domain) :
    (f +ᵥ g) x = f x + g x 
goal: ↑(f +ᵥ g) x = f ↑x + ↑g x

full_name: LinearPMap.coe_vadd
code: @[simp]
theorem coe_vadd (f : E →ₗ[R] F) (g : E →ₗ.[R] F) : ⇑(f +ᵥ g) = ⇑(f.comp g.domain.subtype) + ⇑g 
goal: ↑(f +ᵥ g) = ⇑(f ∘ₗ g.domain.subtype) + ↑g

full_name: LinearPMap.instAddAction
code: instance instAddAction : AddAction (E →ₗ[R] F) (E →ₗ.[R] F) 
goal: AddAction (E →ₗ[R] F) (E →ₗ.[R] F)

full_name: LinearPMap.instSub
code: instance instSub : Sub (E →ₗ.[R] F) 
goal: Sub (E →ₗ.[R] F)

full_name: LinearPMap.sub_domain
code: theorem sub_domain (f g : E →ₗ.[R] F) : (f - g).domain = f.domain ⊓ g.domain 
goal: (f - g).domain = f.domain ⊓ g.domain

full_name: LinearPMap.sub_apply
code: theorem sub_apply (f g : E →ₗ.[R] F) (x : (f.domain ⊓ g.domain : Submodule R E)) :
    (f - g) x = f ⟨x, x.prop.1⟩ - g ⟨x, x.prop.2⟩ 
goal: ↑(f - g) x = ↑f ⟨↑x, ⋯⟩ - ↑g ⟨↑x, ⋯⟩

full_name: LinearPMap.instSubtractionCommMonoid
code: instance instSubtractionCommMonoid : SubtractionCommMonoid (E →ₗ.[R] F) 
goal: SubtractionCommMonoid (E →ₗ.[R] F)

full_name: LinearPMap.supSpanSingleton
code: /-- Extend a `LinearPMap` to `f.domain ⊔ K ∙ x`. -/
noncomputable def supSpanSingleton (f : E →ₗ.[K] F) (x : E) (y : F) (hx : x ∉ f.domain) :
    E →ₗ.[K] F 
goal: E →ₗ.[K] F

full_name: LinearPMap.domain_supSpanSingleton
code: @[simp]
theorem domain_supSpanSingleton (f : E →ₗ.[K] F) (x : E) (y : F) (hx : x ∉ f.domain) :
    (f.supSpanSingleton x y hx).domain = f.domain ⊔ K ∙ x 
goal: (f.supSpanSingleton x y hx).domain = f.domain ⊔ Submodule.span K {x}

full_name: LinearPMap.supSpanSingleton_apply_mk
code: @[simp]
theorem supSpanSingleton_apply_mk (f : E →ₗ.[K] F) (x : E) (y : F) (hx : x ∉ f.domain) (x' : E)
    (hx' : x' ∈ f.domain) (c : K) :
    f.supSpanSingleton x y hx
        ⟨x' + c • x, mem_sup.2 ⟨x', hx', _, mem_span_singleton.2 ⟨c, rfl⟩, rfl⟩⟩ =
      f ⟨x', hx'⟩ + c • y 
goal: ↑(f.supSpanSingleton x y hx) ⟨x' + c • x, ⋯⟩ = ↑f ⟨x', hx'⟩ + c • y

full_name: _private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.sSup_aux
code: private theorem sSup_aux (c : Set (E →ₗ.[R] F)) (hc : DirectedOn (· ≤ ·) c) :
    ∃ f : ↥(sSup (domain '' c)) →ₗ[R] F, (⟨_, f⟩ : E →ₗ.[R] F) ∈ upperBounds c 
goal: ∃ f, { domain := sSup (LinearPMap.domain '' c), toFun := f } ∈ upperBounds c

full_name: LinearPMap.sSup
code: protected noncomputable def sSup (c : Set (E →ₗ.[R] F)) (hc : DirectedOn (· ≤ ·) c) : E →ₗ.[R] F 
goal: E →ₗ.[R] F

full_name: LinearPMap.le_sSup
code: protected theorem le_sSup {c : Set (E →ₗ.[R] F)} (hc : DirectedOn (· ≤ ·) c) {f : E →ₗ.[R] F}
    (hf : f ∈ c) : f ≤ LinearPMap.sSup c hc 
goal: f ≤ LinearPMap.sSup c hc

full_name: LinearPMap.sSup_le
code: protected theorem sSup_le {c : Set (E →ₗ.[R] F)} (hc : DirectedOn (· ≤ ·) c) {g : E →ₗ.[R] F}
    (hg : ∀ f ∈ c, f ≤ g) : LinearPMap.sSup c hc ≤ g 
goal: LinearPMap.sSup c hc ≤ g

full_name: LinearPMap.sSup_apply
code: protected theorem sSup_apply {c : Set (E →ₗ.[R] F)} (hc : DirectedOn (· ≤ ·) c) {l : E →ₗ.[R] F}
    (hl : l ∈ c) (x : l.domain) :
    (LinearPMap.sSup c hc) ⟨x, (LinearPMap.le_sSup hc hl).1 x.2⟩ = l x 
goal: ↑(LinearPMap.sSup c hc) ⟨↑x, ⋯⟩ = ↑l x

full_name: LinearMap.toPMap
code: /-- Restrict a linear map to a submodule, reinterpreting the result as a `LinearPMap`. -/
def toPMap (f : E →ₗ[R] F) (p : Submodule R E) : E →ₗ.[R] F 
goal: E →ₗ.[R] F

full_name: LinearMap.toPMap_apply
code: @[simp]
theorem toPMap_apply (f : E →ₗ[R] F) (p : Submodule R E) (x : p) : f.toPMap p x = f x 
goal: ↑(f.toPMap p) x = f ↑x

full_name: LinearMap.toPMap_domain
code: @[simp]
theorem toPMap_domain (f : E →ₗ[R] F) (p : Submodule R E) : (f.toPMap p).domain = p 
goal: (f.toPMap p).domain = p

full_name: LinearMap.compPMap
code: /-- Compose a linear map with a `LinearPMap` -/
def compPMap (g : F →ₗ[R] G) (f : E →ₗ.[R] F) : E →ₗ.[R] G 
goal: E →ₗ.[R] G

full_name: LinearMap.compPMap_apply
code: @[simp]
theorem compPMap_apply (g : F →ₗ[R] G) (f : E →ₗ.[R] F) (x) : g.compPMap f x = g (f x) 
goal: ↑(g.compPMap f) x = g (↑f x)

full_name: LinearPMap.codRestrict
code: /-- Restrict codomain of a `LinearPMap` -/
def codRestrict (f : E →ₗ.[R] F) (p : Submodule R F) (H : ∀ x, f x ∈ p) : E →ₗ.[R] p 
goal: E →ₗ.[R] ↥p

full_name: LinearPMap.comp
code: /-- Compose two `LinearPMap`s -/
def comp (g : F →ₗ.[R] G) (f : E →ₗ.[R] F) (H : ∀ x : f.domain, f x ∈ g.domain) : E →ₗ.[R] G 
goal: E →ₗ.[R] G

full_name: LinearPMap.coprod
code: /-- `f.coprod g` is the partially defined linear map defined on `f.domain × g.domain`,
and sending `p` to `f p.1 + g p.2`. -/
def coprod (f : E →ₗ.[R] G) (g : F →ₗ.[R] G) : E × F →ₗ.[R] G 
goal: E × F →ₗ.[R] G

full_name: LinearPMap.coprod_apply
code: @[simp]
theorem coprod_apply (f : E →ₗ.[R] G) (g : F →ₗ.[R] G) (x) :
    f.coprod g x = f ⟨(x : E × F).1, x.2.1⟩ + g ⟨(x : E × F).2, x.2.2⟩ 
goal: ↑(f.coprod g) x = ↑f ⟨(↑x).1, ⋯⟩ + ↑g ⟨(↑x).2, ⋯⟩

full_name: LinearPMap.domRestrict
code: /-- Restrict a partially defined linear map to a submodule of `E` contained in `f.domain`. -/
def domRestrict (f : E →ₗ.[R] F) (S : Submodule R E) : E →ₗ.[R] F 
goal: E →ₗ.[R] F

full_name: LinearPMap.domRestrict_domain
code: @[simp]
theorem domRestrict_domain (f : E →ₗ.[R] F) {S : Submodule R E} :
    (f.domRestrict S).domain = S ⊓ f.domain 
goal: (f.domRestrict S).domain = S ⊓ f.domain

full_name: LinearPMap.domRestrict_apply
code: theorem domRestrict_apply {f : E →ₗ.[R] F} {S : Submodule R E} ⦃x : ↥(S ⊓ f.domain)⦄ ⦃y : f.domain⦄
    (h : (x : E) = y) : f.domRestrict S x = f y 
goal: ↑(f.domRestrict S) x = ↑f y

full_name: LinearPMap.domRestrict_le
code: theorem domRestrict_le {f : E →ₗ.[R] F} {S : Submodule R E} : f.domRestrict S ≤ f 
goal: f.domRestrict S ≤ f

full_name: LinearPMap.graph
code: /-- The graph of a `LinearPMap` viewed as a submodule on `E × F`. -/
def graph (f : E →ₗ.[R] F) : Submodule R (E × F) 
goal: Submodule R (E × F)

full_name: LinearPMap.mem_graph_iff'
code: theorem mem_graph_iff' (f : E →ₗ.[R] F) {x : E × F} :
    x ∈ f.graph ↔ ∃ y : f.domain, (↑y, f y) = x 
goal: x ∈ f.graph ↔ ∃ y, (↑y, ↑f y) = x

full_name: LinearPMap.mem_graph_iff
code: @[simp]
theorem mem_graph_iff (f : E →ₗ.[R] F) {x : E × F} :
    x ∈ f.graph ↔ ∃ y : f.domain, (↑y : E) = x.1 ∧ f y = x.2 
goal: x ∈ f.graph ↔ ∃ y, ↑y = x.1 ∧ ↑f y = x.2

full_name: LinearPMap.mem_graph
code: /-- The tuple `(x, f x)` is contained in the graph of `f`. -/
theorem mem_graph (f : E →ₗ.[R] F) (x : domain f) : ((x : E), f x) ∈ f.graph 
goal: (↑x, ↑f x) ∈ f.graph

full_name: LinearPMap.graph_map_fst_eq_domain
code: theorem graph_map_fst_eq_domain (f : E →ₗ.[R] F) :
    f.graph.map (LinearMap.fst R E F) = f.domain 
goal: Submodule.map (LinearMap.fst R E F) f.graph = f.domain

full_name: LinearPMap.graph_map_snd_eq_range
code: theorem graph_map_snd_eq_range (f : E →ₗ.[R] F) :
    f.graph.map (LinearMap.snd R E F) = LinearMap.range f.toFun 
goal: Submodule.map (LinearMap.snd R E F) f.graph = LinearMap.range f.toFun

full_name: LinearPMap.smul_graph
code: /-- The graph of `z • f` as a pushforward. -/
theorem smul_graph (f : E →ₗ.[R] F) (z : M) :
    (z • f).graph =
      f.graph.map ((LinearMap.id : E →ₗ[R] E).prodMap (z • (LinearMap.id : F →ₗ[R] F))) 
goal: (z • f).graph = Submodule.map (LinearMap.id.prodMap (z • LinearMap.id)) f.graph

full_name: LinearPMap.neg_graph
code: /-- The graph of `-f` as a pushforward. -/
theorem neg_graph (f : E →ₗ.[R] F) :
    (-f).graph =
    f.graph.map ((LinearMap.id : E →ₗ[R] E).prodMap (-(LinearMap.id : F →ₗ[R] F))) 
goal: (-f).graph = Submodule.map (LinearMap.id.prodMap (-LinearMap.id)) f.graph

full_name: LinearPMap.mem_graph_snd_inj
code: theorem mem_graph_snd_inj (f : E →ₗ.[R] F) {x y : E} {x' y' : F} (hx : (x, x') ∈ f.graph)
    (hy : (y, y') ∈ f.graph) (hxy : x = y) : x' = y' 
goal: x' = y'

full_name: LinearPMap.mem_graph_snd_inj'
code: theorem mem_graph_snd_inj' (f : E →ₗ.[R] F) {x y : E × F} (hx : x ∈ f.graph) (hy : y ∈ f.graph)
    (hxy : x.1 = y.1) : x.2 = y.2 
goal: x.2 = y.2

full_name: LinearPMap.graph_fst_eq_zero_snd
code: /-- The property that `f 0 = 0` in terms of the graph. -/
theorem graph_fst_eq_zero_snd (f : E →ₗ.[R] F) {x : E} {x' : F} (h : (x, x') ∈ f.graph)
    (hx : x = 0) : x' = 0 
goal: x' = 0

full_name: LinearPMap.mem_domain_iff
code: theorem mem_domain_iff {f : E →ₗ.[R] F} {x : E} : x ∈ f.domain ↔ ∃ y : F, (x, y) ∈ f.graph 
goal: x ∈ f.domain ↔ ∃ y, (x, y) ∈ f.graph

full_name: LinearPMap.mem_domain_of_mem_graph
code: theorem mem_domain_of_mem_graph {f : E →ₗ.[R] F} {x : E} {y : F} (h : (x, y) ∈ f.graph) :
    x ∈ f.domain 
goal: x ∈ f.domain

full_name: LinearPMap.image_iff
code: theorem image_iff {f : E →ₗ.[R] F} {x : E} {y : F} (hx : x ∈ f.domain) :
    y = f ⟨x, hx⟩ ↔ (x, y) ∈ f.graph 
goal: y = ↑f ⟨x, hx⟩ ↔ (x, y) ∈ f.graph

full_name: LinearPMap.mem_range_iff
code: theorem mem_range_iff {f : E →ₗ.[R] F} {y : F} : y ∈ Set.range f ↔ ∃ x : E, (x, y) ∈ f.graph 
goal: y ∈ Set.range ↑f ↔ ∃ x, (x, y) ∈ f.graph

full_name: LinearPMap.mem_domain_iff_of_eq_graph
code: theorem mem_domain_iff_of_eq_graph {f g : E →ₗ.[R] F} (h : f.graph = g.graph) {x : E} :
    x ∈ f.domain ↔ x ∈ g.domain 
goal: x ∈ f.domain ↔ x ∈ g.domain

full_name: LinearPMap.le_of_le_graph
code: theorem le_of_le_graph {f g : E →ₗ.[R] F} (h : f.graph ≤ g.graph) : f ≤ g 
goal: f ≤ g

full_name: LinearPMap.le_graph_of_le
code: theorem le_graph_of_le {f g : E →ₗ.[R] F} (h : f ≤ g) : f.graph ≤ g.graph 
goal: f.graph ≤ g.graph

full_name: LinearPMap.le_graph_iff
code: theorem le_graph_iff {f g : E →ₗ.[R] F} : f.graph ≤ g.graph ↔ f ≤ g 
goal: f.graph ≤ g.graph ↔ f ≤ g

full_name: LinearPMap.eq_of_eq_graph
code: theorem eq_of_eq_graph {f g : E →ₗ.[R] F} (h : f.graph = g.graph) : f = g 
goal: f = g

full_name: Submodule.existsUnique_from_graph
code: theorem existsUnique_from_graph {g : Submodule R (E × F)}
    (hg : ∀ {x : E × F} (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0) {a : E}
    (ha : a ∈ g.map (LinearMap.fst R E F)) : ∃! b : F, (a, b) ∈ g 
goal: ∃! b, (a, b) ∈ g

full_name: Submodule.valFromGraph
code: /-- Auxiliary definition to unfold the existential quantifier. -/
noncomputable def valFromGraph {g : Submodule R (E × F)}
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0) {a : E}
    (ha : a ∈ g.map (LinearMap.fst R E F)) : F 
goal: F

full_name: Submodule.valFromGraph_mem
code: theorem valFromGraph_mem {g : Submodule R (E × F)}
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0) {a : E}
    (ha : a ∈ g.map (LinearMap.fst R E F)) : (a, valFromGraph hg ha) ∈ g 
goal: (a, Submodule.valFromGraph hg ha) ∈ g

full_name: Submodule.toLinearPMapAux
code: /-- Define a `LinearMap` from its graph.

Helper definition for `LinearPMap`. -/
noncomputable def toLinearPMapAux (g : Submodule R (E × F))
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0) :
    g.map (LinearMap.fst R E F) →ₗ[R] F 
goal: ↥(Submodule.map (LinearMap.fst R E F) g) →ₗ[R] F

full_name: Submodule.toLinearPMap
code: /-- Define a `LinearPMap` from its graph.

In the case that the submodule is not a graph of a `LinearPMap` then the underlying linear map
is just the zero map. -/
noncomputable def toLinearPMap (g : Submodule R (E × F)) : E →ₗ.[R] F 
goal: E →ₗ.[R] F

full_name: Submodule.toLinearPMap_domain
code: theorem toLinearPMap_domain (g : Submodule R (E × F)) :
    g.toLinearPMap.domain = g.map (LinearMap.fst R E F) 
goal: g.toLinearPMap.domain = Submodule.map (LinearMap.fst R E F) g

full_name: Submodule.toLinearPMap_apply_aux
code: theorem toLinearPMap_apply_aux {g : Submodule R (E × F)}
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0)
    (x : g.map (LinearMap.fst R E F)) :
    g.toLinearPMap x = valFromGraph hg x.2 
goal: ↑g.toLinearPMap x = Submodule.valFromGraph hg ⋯

full_name: Submodule.mem_graph_toLinearPMap
code: theorem mem_graph_toLinearPMap {g : Submodule R (E × F)}
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0)
    (x : g.map (LinearMap.fst R E F)) : (x.val, g.toLinearPMap x) ∈ g 
goal: (↑x, ↑g.toLinearPMap x) ∈ g

full_name: Submodule.toLinearPMap_graph_eq
code: @[simp]
theorem toLinearPMap_graph_eq (g : Submodule R (E × F))
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0) :
    g.toLinearPMap.graph = g 
goal: g.toLinearPMap.graph = g

full_name: Submodule.toLinearPMap_range
code: theorem toLinearPMap_range (g : Submodule R (E × F))
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0) :
    LinearMap.range g.toLinearPMap.toFun = g.map (LinearMap.snd R E F) 
goal: LinearMap.range g.toLinearPMap.toFun = Submodule.map (LinearMap.snd R E F) g

full_name: LinearPMap.inverse
code: /-- The inverse of a `LinearPMap`. -/
noncomputable def inverse (f : E →ₗ.[R] F) : F →ₗ.[R] E 
goal: F →ₗ.[R] E

full_name: LinearPMap.inverse_domain
code: theorem inverse_domain : (inverse f).domain = LinearMap.range f.toFun 
goal: f.inverse.domain = LinearMap.range f.toFun

full_name: LinearPMap.mem_inverse_graph_snd_eq_zero
code: /-- The graph of the inverse generates a `LinearPMap`. -/
theorem mem_inverse_graph_snd_eq_zero (x : F × E)
    (hv : x ∈ (graph f).map (LinearEquiv.prodComm R E F))
    (hv' : x.fst = 0) : x.snd = 0 
goal: x.2 = 0

full_name: LinearPMap.inverse_graph
code: theorem inverse_graph : (inverse f).graph = f.graph.map (LinearEquiv.prodComm R E F) 
goal: f.inverse.graph = Submodule.map (LinearEquiv.prodComm R E F) f.graph

full_name: LinearPMap.inverse_range
code: theorem inverse_range : LinearMap.range (inverse f).toFun = f.domain 
goal: LinearMap.range f.inverse.toFun = f.domain

full_name: LinearPMap.mem_inverse_graph
code: theorem mem_inverse_graph (x : f.domain) : (f x, (x : E)) ∈ (inverse f).graph 
goal: (↑f x, ↑x) ∈ f.inverse.graph

full_name: LinearPMap.inverse_apply_eq
code: theorem inverse_apply_eq {y : (inverse f).domain} {x : f.domain} (hxy : f x = y) :
    (inverse f) y = x 
goal: ↑f.inverse y = ↑x