File: Mathlib/LinearAlgebra/QuotientPi.lean

full_name: Submodule.piQuotientLift
code: /-- Lift a family of maps to the direct sum of quotients. -/
def piQuotientLift [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i)) (q : Submodule R N)
    (f : ∀ i, Ms i →ₗ[R] N) (hf : ∀ i, p i ≤ q.comap (f i)) : (∀ i, Ms i ⧸ p i) →ₗ[R] N ⧸ q 
goal: ((i : ι) → Ms i ⧸ p i) →ₗ[R] N ⧸ q

full_name: Submodule.piQuotientLift_mk
code: @[simp]
theorem piQuotientLift_mk [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i))
    (q : Submodule R N) (f : ∀ i, Ms i →ₗ[R] N) (hf : ∀ i, p i ≤ q.comap (f i)) (x : ∀ i, Ms i) :
    (piQuotientLift p q f hf fun i => Quotient.mk (x i)) = Quotient.mk (lsum _ _ R f x) 
goal: ((Submodule.piQuotientLift p q f hf) fun i => Submodule.Quotient.mk (x i)) =
  Submodule.Quotient.mk (((LinearMap.lsum R Ms R) f) x)

full_name: Submodule.piQuotientLift_single
code: @[simp]
theorem piQuotientLift_single [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i))
    (q : Submodule R N) (f : ∀ i, Ms i →ₗ[R] N) (hf : ∀ i, p i ≤ q.comap (f i)) (i)
    (x : Ms i ⧸ p i) : piQuotientLift p q f hf (Pi.single i x) = mapQ _ _ (f i) (hf i) x 
goal: (Submodule.piQuotientLift p q f hf) (Pi.single i x) = ((p i).mapQ q (f i) ⋯) x

full_name: Submodule.quotientPiLift
code: /-- Lift a family of maps to a quotient of direct sums. -/
def quotientPiLift (p : ∀ i, Submodule R (Ms i)) (f : ∀ i, Ms i →ₗ[R] Ns i)
    (hf : ∀ i, p i ≤ ker (f i)) : (∀ i, Ms i) ⧸ pi Set.univ p →ₗ[R] ∀ i, Ns i 
goal: ((i : ι) → Ms i) ⧸ Submodule.pi Set.univ p →ₗ[R] (i : ι) → Ns i

full_name: Submodule.quotientPiLift_mk
code: @[simp]
theorem quotientPiLift_mk (p : ∀ i, Submodule R (Ms i)) (f : ∀ i, Ms i →ₗ[R] Ns i)
    (hf : ∀ i, p i ≤ ker (f i)) (x : ∀ i, Ms i) :
    quotientPiLift p f hf (Quotient.mk x) = fun i => f i (x i) 
goal: (Submodule.quotientPiLift p f hf) (Submodule.Quotient.mk x) = fun i => (f i) (x i)

full_name: Submodule.quotientPi_aux.toFun
code: @[simp]
def toFun : ((∀ i, Ms i) ⧸ pi Set.univ p) → ∀ i, Ms i ⧸ p i 
goal: ((i : ι) → Ms i) ⧸ Submodule.pi Set.univ p → (i : ι) → Ms i ⧸ p i

full_name: Submodule.quotientPi_aux.invFun
code: @[simp]
def invFun : (∀ i, Ms i ⧸ p i) → (∀ i, Ms i) ⧸ pi Set.univ p 
goal: ((i : ι) → Ms i ⧸ p i) → ((i : ι) → Ms i) ⧸ Submodule.pi Set.univ p

full_name: Submodule.quotientPi_aux.left_inv
code: theorem left_inv : Function.LeftInverse (invFun p) (toFun p) 
goal: Function.LeftInverse (Submodule.quotientPi_aux.invFun p) (Submodule.quotientPi_aux.toFun p)

full_name: Submodule.quotientPi_aux.right_inv
code: theorem right_inv : Function.RightInverse (invFun p) (toFun p) 
goal: Function.RightInverse (Submodule.quotientPi_aux.invFun p) (Submodule.quotientPi_aux.toFun p)

full_name: Submodule.quotientPi_aux.map_add
code: theorem map_add (x y : ((i : ι) → Ms i) ⧸ pi Set.univ p) :
    toFun p (x + y) = toFun p x + toFun p y 
goal: Submodule.quotientPi_aux.toFun p (x + y) = Submodule.quotientPi_aux.toFun p x + Submodule.quotientPi_aux.toFun p y

full_name: Submodule.quotientPi_aux.map_smul
code: theorem map_smul (r : R) (x : ((i : ι) → Ms i) ⧸ pi Set.univ p) :
    toFun p (r • x) = (RingHom.id R r) • toFun p x 
goal: Submodule.quotientPi_aux.toFun p (r • x) = (RingHom.id R) r • Submodule.quotientPi_aux.toFun p x

full_name: Submodule.quotientPi
code: /-- The quotient of a direct sum is the direct sum of quotients. -/
@[simps!]
def quotientPi [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i)) :
    ((∀ i, Ms i) ⧸ pi Set.univ p) ≃ₗ[R] ∀ i, Ms i ⧸ p i 
goal: (((i : ι) → Ms i) ⧸ Submodule.pi Set.univ p) ≃ₗ[R] (i : ι) → Ms i ⧸ p i

full_name: Submodule.quotientPi_symm_apply
code: /-- The quotient of a direct sum is the direct sum of quotients. -/
@[simps!]
def quotientPi [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i)) :
    ((∀ i, Ms i) ⧸ pi Set.univ p) ≃ₗ[R] ∀ i, Ms i ⧸ p i 
goal: ∀ (a : (i : ι) → Ms i ⧸ p i),
  (Submodule.quotientPi p).symm a = (Submodule.piQuotientLift p (Submodule.pi Set.univ p) LinearMap.single ⋯) a

full_name: Submodule.quotientPi_apply
code: /-- The quotient of a direct sum is the direct sum of quotients. -/
@[simps!]
def quotientPi [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i)) :
    ((∀ i, Ms i) ⧸ pi Set.univ p) ≃ₗ[R] ∀ i, Ms i ⧸ p i 
goal: ∀ (a : ((i : ι) → Ms i) ⧸ Submodule.pi Set.univ p) (i : ι),
  (Submodule.quotientPi p) a i = (Submodule.quotientPiLift p (fun i => (p i).mkQ) ⋯) a i