File: Mathlib/LinearAlgebra/Quotient.lean

full_name: Submodule.quotientRel
code: /-- The equivalence relation associated to a submodule `p`, defined by `x ≈ y` iff `-x + y ∈ p`.

Note this is equivalent to `y - x ∈ p`, but defined this way to be defeq to the `AddSubgroup`
version, where commutativity can't be assumed. -/
def quotientRel : Setoid M 
goal: Setoid M

full_name: Submodule.quotientRel_r_def
code: theorem quotientRel_r_def {x y : M} : @Setoid.r _ p.quotientRel x y ↔ x - y ∈ p 
goal: Setoid.r x y ↔ x - y ∈ p

full_name: Submodule.hasQuotient
code: /-- The quotient of a module `M` by a submodule `p ⊆ M`. -/
instance hasQuotient : HasQuotient M (Submodule R M) 
goal: HasQuotient M (Submodule R M)

full_name: Submodule.Quotient.mk
code: /-- Map associating to an element of `M` the corresponding element of `M/p`,
when `p` is a submodule of `M`. -/
def mk {p : Submodule R M} : M → M ⧸ p 
goal: M → M ⧸ p

full_name: Submodule.Quotient.mk'_eq_mk'
code: @[simp]
theorem mk'_eq_mk' {p : Submodule R M} (x : M) :
    @Quotient.mk' _ (quotientRel p) x = (mk : M → M ⧸ p) x 
goal: Quotient.mk' x = Submodule.Quotient.mk x

full_name: Submodule.Quotient.mk''_eq_mk
code: @[simp]
theorem mk''_eq_mk {p : Submodule R M} (x : M) : (Quotient.mk'' x : M ⧸ p) = (mk : M → M ⧸ p) x 
goal: Quotient.mk'' x = Submodule.Quotient.mk x

full_name: Submodule.Quotient.quot_mk_eq_mk
code: @[simp]
theorem quot_mk_eq_mk {p : Submodule R M} (x : M) : (Quot.mk _ x : M ⧸ p) = (mk : M → M ⧸ p) x 
goal: Quot.mk Setoid.r x = Submodule.Quotient.mk x

full_name: Submodule.Quotient.eq'
code: protected theorem eq' {x y : M} : (mk x : M ⧸ p) = (mk : M → M ⧸ p) y ↔ -x + y ∈ p 
goal: Submodule.Quotient.mk x = Submodule.Quotient.mk y ↔ -x + y ∈ p

full_name: Submodule.Quotient.eq
code: protected theorem eq {x y : M} : (mk x : M ⧸ p) = (mk y : M ⧸ p) ↔ x - y ∈ p 
goal: Submodule.Quotient.mk x = Submodule.Quotient.mk y ↔ x - y ∈ p

full_name: Submodule.Quotient.instZeroQuotient
code: instance : Zero (M ⧸ p) 
goal: Zero (M ⧸ p)

full_name: Submodule.Quotient.instInhabitedQuotient
code: instance : Inhabited (M ⧸ p) 
goal: Inhabited (M ⧸ p)

full_name: Submodule.Quotient.mk_zero
code: @[simp]
theorem mk_zero : mk 0 = (0 : M ⧸ p) 
goal: Submodule.Quotient.mk 0 = 0

full_name: Submodule.Quotient.mk_eq_zero
code: @[simp]
theorem mk_eq_zero : (mk x : M ⧸ p) = 0 ↔ x ∈ p 
goal: Submodule.Quotient.mk x = 0 ↔ x ∈ p

full_name: Submodule.Quotient.addCommGroup
code: instance addCommGroup : AddCommGroup (M ⧸ p) 
goal: AddCommGroup (M ⧸ p)

full_name: Submodule.Quotient.mk_add
code: @[simp]
theorem mk_add : (mk (x + y) : M ⧸ p) = (mk x : M ⧸ p) + (mk y : M ⧸ p) 
goal: Submodule.Quotient.mk (x + y) = Submodule.Quotient.mk x + Submodule.Quotient.mk y

full_name: Submodule.Quotient.mk_neg
code: @[simp]
theorem mk_neg : (mk (-x) : M ⧸ p) = -(mk x : M ⧸ p) 
goal: Submodule.Quotient.mk (-x) = -Submodule.Quotient.mk x

full_name: Submodule.Quotient.mk_sub
code: @[simp]
theorem mk_sub : (mk (x - y) : M ⧸ p) = (mk x : M ⧸ p) - (mk y : M ⧸ p) 
goal: Submodule.Quotient.mk (x - y) = Submodule.Quotient.mk x - Submodule.Quotient.mk y

full_name: Submodule.Quotient.instSMul'
code: instance instSMul' : SMul S (M ⧸ P) 
goal: SMul S (M ⧸ P)

full_name: Submodule.Quotient.instSMul
code: /-- Shortcut to help the elaborator in the common case. -/
instance instSMul : SMul R (M ⧸ P) 
goal: SMul R (M ⧸ P)

full_name: Submodule.Quotient.mk_smul
code: @[simp]
theorem mk_smul (r : S) (x : M) : (mk (r • x) : M ⧸ p) = r • mk x 
goal: Submodule.Quotient.mk (r • x) = r • Submodule.Quotient.mk x

full_name: Submodule.Quotient.smulCommClass
code: instance smulCommClass (T : Type*) [SMul T R] [SMul T M] [IsScalarTower T R M]
    [SMulCommClass S T M] : SMulCommClass S T (M ⧸ P) 
goal: SMulCommClass S T (M ⧸ P)

full_name: Submodule.Quotient.isScalarTower
code: instance isScalarTower (T : Type*) [SMul T R] [SMul T M] [IsScalarTower T R M] [SMul S T]
    [IsScalarTower S T M] : IsScalarTower S T (M ⧸ P) 
goal: IsScalarTower S T (M ⧸ P)

full_name: Submodule.Quotient.isCentralScalar
code: instance isCentralScalar [SMul Sᵐᵒᵖ R] [SMul Sᵐᵒᵖ M] [IsScalarTower Sᵐᵒᵖ R M]
    [IsCentralScalar S M] : IsCentralScalar S (M ⧸ P) 
goal: IsCentralScalar S (M ⧸ P)

full_name: Submodule.Quotient.mulAction'
code: instance mulAction' [Monoid S] [SMul S R] [MulAction S M] [IsScalarTower S R M]
    (P : Submodule R M) : MulAction S (M ⧸ P) 
goal: MulAction S (M ⧸ P)

full_name: Submodule.Quotient.mulAction
code: instance mulAction (P : Submodule R M) : MulAction R (M ⧸ P) 
goal: MulAction R (M ⧸ P)

full_name: Submodule.Quotient.smulZeroClass'
code: instance smulZeroClass' [SMul S R] [SMulZeroClass S M] [IsScalarTower S R M] (P : Submodule R M) :
    SMulZeroClass S (M ⧸ P) 
goal: SMulZeroClass S (M ⧸ P)

full_name: Submodule.Quotient.smulZeroClass
code: instance smulZeroClass (P : Submodule R M) : SMulZeroClass R (M ⧸ P) 
goal: SMulZeroClass R (M ⧸ P)

full_name: Submodule.Quotient.distribSMul'
code: instance distribSMul' [SMul S R] [DistribSMul S M] [IsScalarTower S R M] (P : Submodule R M) :
    DistribSMul S (M ⧸ P) 
goal: DistribSMul S (M ⧸ P)

full_name: Submodule.Quotient.distribSMul
code: instance distribSMul (P : Submodule R M) : DistribSMul R (M ⧸ P) 
goal: DistribSMul R (M ⧸ P)

full_name: Submodule.Quotient.distribMulAction'
code: instance distribMulAction' [Monoid S] [SMul S R] [DistribMulAction S M] [IsScalarTower S R M]
    (P : Submodule R M) : DistribMulAction S (M ⧸ P) 
goal: DistribMulAction S (M ⧸ P)

full_name: Submodule.Quotient.distribMulAction
code: instance distribMulAction (P : Submodule R M) : DistribMulAction R (M ⧸ P) 
goal: DistribMulAction R (M ⧸ P)

full_name: Submodule.Quotient.module'
code: instance module' [Semiring S] [SMul S R] [Module S M] [IsScalarTower S R M] (P : Submodule R M) :
    Module S (M ⧸ P) 
goal: Module S (M ⧸ P)

full_name: Submodule.Quotient.module
code: instance module (P : Submodule R M) : Module R (M ⧸ P) 
goal: Module R (M ⧸ P)

full_name: Submodule.Quotient.restrictScalarsEquiv
code: /-- The quotient of `P` as an `S`-submodule is the same as the quotient of `P` as an `R`-submodule,
where `P : Submodule R M`.
-/
def restrictScalarsEquiv [Ring S] [SMul S R] [Module S M] [IsScalarTower S R M]
    (P : Submodule R M) : (M ⧸ P.restrictScalars S) ≃ₗ[S] M ⧸ P 
goal: (M ⧸ Submodule.restrictScalars S P) ≃ₗ[S] M ⧸ P

full_name: Submodule.Quotient.restrictScalarsEquiv_mk
code: @[simp]
theorem restrictScalarsEquiv_mk [Ring S] [SMul S R] [Module S M] [IsScalarTower S R M]
    (P : Submodule R M) (x : M) :
    restrictScalarsEquiv S P (mk x : M ⧸ P) = (mk x : M ⧸ P) 
goal: (Submodule.Quotient.restrictScalarsEquiv S P) (Submodule.Quotient.mk x) = Submodule.Quotient.mk x

full_name: Submodule.Quotient.restrictScalarsEquiv_symm_mk
code: @[simp]
theorem restrictScalarsEquiv_symm_mk [Ring S] [SMul S R] [Module S M] [IsScalarTower S R M]
    (P : Submodule R M) (x : M) :
    (restrictScalarsEquiv S P).symm ((mk : M → M ⧸ P) x) = (mk : M → M ⧸ P) x 
goal: (Submodule.Quotient.restrictScalarsEquiv S P).symm (Submodule.Quotient.mk x) = Submodule.Quotient.mk x

full_name: Submodule.Quotient.mk_surjective
code: theorem mk_surjective : Function.Surjective (@mk _ _ _ _ _ p) 
goal: Function.Surjective Submodule.Quotient.mk

full_name: Submodule.Quotient.nontrivial_of_lt_top
code: theorem nontrivial_of_lt_top (h : p < ⊤) : Nontrivial (M ⧸ p) 
goal: Nontrivial (M ⧸ p)

full_name: Submodule.QuotientBot.infinite
code: instance QuotientBot.infinite [Infinite M] : Infinite (M ⧸ (⊥ : Submodule R M)) 
goal: Infinite (M ⧸ ⊥)

full_name: Submodule.QuotientTop.unique
code: instance QuotientTop.unique : Unique (M ⧸ (⊤ : Submodule R M)) 
goal: Unique (M ⧸ ⊤)

full_name: Submodule.QuotientTop.fintype
code: instance QuotientTop.fintype : Fintype (M ⧸ (⊤ : Submodule R M)) 
goal: Fintype (M ⧸ ⊤)

full_name: Submodule.subsingleton_quotient_iff_eq_top
code: theorem subsingleton_quotient_iff_eq_top : Subsingleton (M ⧸ p) ↔ p = ⊤ 
goal: Subsingleton (M ⧸ p) ↔ p = ⊤

full_name: Submodule.unique_quotient_iff_eq_top
code: theorem unique_quotient_iff_eq_top : Nonempty (Unique (M ⧸ p)) ↔ p = ⊤ 
goal: Nonempty (Unique (M ⧸ p)) ↔ p = ⊤

full_name: Submodule.Quotient.fintype
code: noncomputable instance Quotient.fintype [Fintype M] (S : Submodule R M) : Fintype (M ⧸ S) 
goal: Fintype (M ⧸ S)

full_name: Submodule.card_eq_card_quotient_mul_card
code: theorem card_eq_card_quotient_mul_card (S : Submodule R M) :
    Nat.card M = Nat.card S * Nat.card (M ⧸ S) 
goal: Nat.card M = Nat.card ↥S * Nat.card (M ⧸ S)

full_name: Submodule.quot_hom_ext
code: theorem quot_hom_ext (f g : (M ⧸ p) →ₗ[R] M₂) (h : ∀ x : M, f (Quotient.mk x) = g (Quotient.mk x)) :
    f = g 
goal: f = g

full_name: Submodule.mkQ
code: /-- The map from a module `M` to the quotient of `M` by a submodule `p` as a linear map. -/
def mkQ : M →ₗ[R] M ⧸ p 
goal: M →ₗ[R] M ⧸ p

full_name: Submodule.mkQ_apply
code: @[simp]
theorem mkQ_apply (x : M) : p.mkQ x = (Quotient.mk x : M ⧸ p) 
goal: p.mkQ x = Submodule.Quotient.mk x

full_name: Submodule.mkQ_surjective
code: theorem mkQ_surjective (A : Submodule R M) : Function.Surjective A.mkQ 
goal: Function.Surjective ⇑A.mkQ

full_name: Submodule.linearMap_qext
code: /-- Two `LinearMap`s from a quotient module are equal if their compositions with
`submodule.mkQ` are equal.

See note [partially-applied ext lemmas]. -/
@[ext 1100] -- Porting note: increase priority so this applies before `LinearMap.ext`
theorem linearMap_qext ⦃f g : M ⧸ p →ₛₗ[τ₁₂] M₂⦄ (h : f.comp p.mkQ = g.comp p.mkQ) : f = g 
goal: f = g

full_name: Submodule.liftQ
code: /-- The map from the quotient of `M` by a submodule `p` to `M₂` induced by a linear map `f : M → M₂`
vanishing on `p`, as a linear map. -/
def liftQ (f : M →ₛₗ[τ₁₂] M₂) (h : p ≤ ker f) : M ⧸ p →ₛₗ[τ₁₂] M₂ 
goal: M ⧸ p →ₛₗ[τ₁₂] M₂

full_name: Submodule.liftQ_apply
code: @[simp]
theorem liftQ_apply (f : M →ₛₗ[τ₁₂] M₂) {h} (x : M) : p.liftQ f h (Quotient.mk x) = f x 
goal: (p.liftQ f h) (Submodule.Quotient.mk x) = f x

full_name: Submodule.liftQ_mkQ
code: @[simp]
theorem liftQ_mkQ (f : M →ₛₗ[τ₁₂] M₂) (h) : (p.liftQ f h).comp p.mkQ = f 
goal: (p.liftQ f h).comp p.mkQ = f

full_name: Submodule.liftQSpanSingleton
code: /-- Special case of `submodule.liftQ` when `p` is the span of `x`. In this case, the condition on
`f` simply becomes vanishing at `x`. -/
def liftQSpanSingleton (x : M) (f : M →ₛₗ[τ₁₂] M₂) (h : f x = 0) : (M ⧸ R ∙ x) →ₛₗ[τ₁₂] M₂ 
goal: M ⧸ Submodule.span R {x} →ₛₗ[τ₁₂] M₂

full_name: Submodule.liftQSpanSingleton_apply
code: @[simp]
theorem liftQSpanSingleton_apply (x : M) (f : M →ₛₗ[τ₁₂] M₂) (h : f x = 0) (y : M) :
    liftQSpanSingleton x f h (Quotient.mk y) = f y 
goal: (Submodule.liftQSpanSingleton x f h) (Submodule.Quotient.mk y) = f y

full_name: Submodule.range_mkQ
code: @[simp]
theorem range_mkQ : range p.mkQ = ⊤ 
goal: LinearMap.range p.mkQ = ⊤

full_name: Submodule.ker_mkQ
code: @[simp]
theorem ker_mkQ : ker p.mkQ = p 
goal: LinearMap.ker p.mkQ = p

full_name: Submodule.le_comap_mkQ
code: theorem le_comap_mkQ (p' : Submodule R (M ⧸ p)) : p ≤ comap p.mkQ p' 
goal: p ≤ Submodule.comap p.mkQ p'

full_name: Submodule.mkQ_map_self
code: @[simp]
theorem mkQ_map_self : map p.mkQ p = ⊥ 
goal: Submodule.map p.mkQ p = ⊥

full_name: Submodule.comap_map_mkQ
code: @[simp]
theorem comap_map_mkQ : comap p.mkQ (map p.mkQ p') = p ⊔ p' 
goal: Submodule.comap p.mkQ (Submodule.map p.mkQ p') = p ⊔ p'

full_name: Submodule.map_mkQ_eq_top
code: @[simp]
theorem map_mkQ_eq_top : map p.mkQ p' = ⊤ ↔ p ⊔ p' = ⊤ 
goal: Submodule.map p.mkQ p' = ⊤ ↔ p ⊔ p' = ⊤

full_name: Submodule.mapQ
code: /-- The map from the quotient of `M` by submodule `p` to the quotient of `M₂` by submodule `q` along
`f : M → M₂` is linear. -/
def mapQ (f : M →ₛₗ[τ₁₂] M₂) (h : p ≤ comap f q) : M ⧸ p →ₛₗ[τ₁₂] M₂ ⧸ q 
goal: M ⧸ p →ₛₗ[τ₁₂] M₂ ⧸ q

full_name: Submodule.mapQ_apply
code: @[simp]
theorem mapQ_apply (f : M →ₛₗ[τ₁₂] M₂) {h} (x : M) :
    mapQ p q f h (Quotient.mk x : M ⧸ p) = (Quotient.mk (f x) : M₂ ⧸ q) 
goal: (p.mapQ q f h) (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x)

full_name: Submodule.mapQ_mkQ
code: theorem mapQ_mkQ (f : M →ₛₗ[τ₁₂] M₂) {h} : (mapQ p q f h).comp p.mkQ = q.mkQ.comp f 
goal: (p.mapQ q f h).comp p.mkQ = q.mkQ.comp f

full_name: Submodule.mapQ_zero
code: @[simp]
theorem mapQ_zero (h : p ≤ q.comap (0 : M →ₛₗ[τ₁₂] M₂) := (by simp)) :
    p.mapQ q (0 : M →ₛₗ[τ₁₂] M₂) h = 0 
goal: p.mapQ q 0 h = 0

full_name: Submodule.mapQ_comp
code: /-- Given submodules `p ⊆ M`, `p₂ ⊆ M₂`, `p₃ ⊆ M₃` and maps `f : M → M₂`, `g : M₂ → M₃` inducing
`mapQ f : M ⧸ p → M₂ ⧸ p₂` and `mapQ g : M₂ ⧸ p₂ → M₃ ⧸ p₃` then
`mapQ (g ∘ f) = (mapQ g) ∘ (mapQ f)`. -/
theorem mapQ_comp {R₃ M₃ : Type*} [Ring R₃] [AddCommGroup M₃] [Module R₃ M₃] (p₂ : Submodule R₂ M₂)
    (p₃ : Submodule R₃ M₃) {τ₂₃ : R₂ →+* R₃} {τ₁₃ : R →+* R₃} [RingHomCompTriple τ₁₂ τ₂₃ τ₁₃]
    (f : M →ₛₗ[τ₁₂] M₂) (g : M₂ →ₛₗ[τ₂₃] M₃) (hf : p ≤ p₂.comap f) (hg : p₂ ≤ p₃.comap g)
    (h := hf.trans (comap_mono hg)) :
    p.mapQ p₃ (g.comp f) h = (p₂.mapQ p₃ g hg).comp (p.mapQ p₂ f hf) 
goal: p.mapQ p₃ (g.comp f) h = (p₂.mapQ p₃ g hg).comp (p.mapQ p₂ f hf)

full_name: Submodule.mapQ_id
code: @[simp]
theorem mapQ_id (h : p ≤ p.comap LinearMap.id := (by rw [comap_id])) :
    p.mapQ p LinearMap.id h = LinearMap.id 
goal: p.mapQ p LinearMap.id h = LinearMap.id

full_name: Submodule.mapQ_pow
code: theorem mapQ_pow {f : M →ₗ[R] M} (h : p ≤ p.comap f) (k : ℕ)
    (h' : p ≤ p.comap (f ^ k) := p.le_comap_pow_of_le_comap h k) :
    p.mapQ p (f ^ k) h' = p.mapQ p f h ^ k 
goal: p.mapQ p (f ^ k) h' = p.mapQ p f h ^ k

full_name: Submodule.comap_liftQ
code: theorem comap_liftQ (f : M →ₛₗ[τ₁₂] M₂) (h) : q.comap (p.liftQ f h) = (q.comap f).map (mkQ p) 
goal: Submodule.comap (p.liftQ f h) q = Submodule.map p.mkQ (Submodule.comap f q)

full_name: Submodule.map_liftQ
code: theorem map_liftQ [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) (h) (q : Submodule R (M ⧸ p)) :
    q.map (p.liftQ f h) = (q.comap p.mkQ).map f 
goal: Submodule.map (p.liftQ f h) q = Submodule.map f (Submodule.comap p.mkQ q)

full_name: Submodule.ker_liftQ
code: theorem ker_liftQ (f : M →ₛₗ[τ₁₂] M₂) (h) : ker (p.liftQ f h) = (ker f).map (mkQ p) 
goal: LinearMap.ker (p.liftQ f h) = Submodule.map p.mkQ (LinearMap.ker f)

full_name: Submodule.range_liftQ
code: theorem range_liftQ [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) (h) :
    range (p.liftQ f h) = range f 
goal: LinearMap.range (p.liftQ f h) = LinearMap.range f

full_name: Submodule.ker_liftQ_eq_bot
code: theorem ker_liftQ_eq_bot (f : M →ₛₗ[τ₁₂] M₂) (h) (h' : ker f ≤ p) : ker (p.liftQ f h) = ⊥ 
goal: LinearMap.ker (p.liftQ f h) = ⊥

full_name: Submodule.ker_liftQ_eq_bot'
code: theorem ker_liftQ_eq_bot' (f : M →ₛₗ[τ₁₂] M₂) (h : p = ker f) :
    ker (p.liftQ f (le_of_eq h)) = ⊥ 
goal: LinearMap.ker (p.liftQ f ⋯) = ⊥

full_name: Submodule.comapMkQRelIso
code: /-- The correspondence theorem for modules: there is an order isomorphism between submodules of the
quotient of `M` by `p`, and submodules of `M` larger than `p`. -/
def comapMkQRelIso : Submodule R (M ⧸ p) ≃o { p' : Submodule R M // p ≤ p' } 
goal: Submodule R (M ⧸ p) ≃o { p' // p ≤ p' }

full_name: Submodule.comapMkQOrderEmbedding
code: /-- The ordering on submodules of the quotient of `M` by `p` embeds into the ordering on submodules
of `M`. -/
def comapMkQOrderEmbedding : Submodule R (M ⧸ p) ↪o Submodule R M 
goal: Submodule R (M ⧸ p) ↪o Submodule R M

full_name: Submodule.comapMkQOrderEmbedding_eq
code: @[simp]
theorem comapMkQOrderEmbedding_eq (p' : Submodule R (M ⧸ p)) :
    comapMkQOrderEmbedding p p' = comap p.mkQ p' 
goal: p.comapMkQOrderEmbedding p' = Submodule.comap p.mkQ p'

full_name: Submodule.span_preimage_eq
code: theorem span_preimage_eq [RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {s : Set M₂} (h₀ : s.Nonempty)
    (h₁ : s ⊆ range f) : span R (f ⁻¹' s) = (span R₂ s).comap f 
goal: Submodule.span R (⇑f ⁻¹' s) = Submodule.comap f (Submodule.span R₂ s)

full_name: Submodule.Quotient.equiv_symm_apply
code: /-- If `P` is a submodule of `M` and `Q` a submodule of `N`,
and `f : M ≃ₗ N` maps `P` to `Q`, then `M ⧸ P` is equivalent to `N ⧸ Q`. -/
@[simps]
def Quotient.equiv {N : Type*} [AddCommGroup N] [Module R N] (P : Submodule R M)
    (Q : Submodule R N) (f : M ≃ₗ[R] N) (hf : P.map f = Q) : (M ⧸ P) ≃ₗ[R] N ⧸ Q 
goal: (Submodule.Quotient.equiv P Q f hf).symm a = (Q.mapQ P ↑f.symm ⋯) a

full_name: Submodule.Quotient.equiv_apply
code: /-- If `P` is a submodule of `M` and `Q` a submodule of `N`,
and `f : M ≃ₗ N` maps `P` to `Q`, then `M ⧸ P` is equivalent to `N ⧸ Q`. -/
@[simps]
def Quotient.equiv {N : Type*} [AddCommGroup N] [Module R N] (P : Submodule R M)
    (Q : Submodule R N) (f : M ≃ₗ[R] N) (hf : P.map f = Q) : (M ⧸ P) ≃ₗ[R] N ⧸ Q 
goal: (Submodule.Quotient.equiv P Q f hf) a = (P.mapQ Q ↑f ⋯) a

full_name: Submodule.Quotient.equiv
code: /-- If `P` is a submodule of `M` and `Q` a submodule of `N`,
and `f : M ≃ₗ N` maps `P` to `Q`, then `M ⧸ P` is equivalent to `N ⧸ Q`. -/
@[simps]
def Quotient.equiv {N : Type*} [AddCommGroup N] [Module R N] (P : Submodule R M)
    (Q : Submodule R N) (f : M ≃ₗ[R] N) (hf : P.map f = Q) : (M ⧸ P) ≃ₗ[R] N ⧸ Q 
goal: (M ⧸ P) ≃ₗ[R] N ⧸ Q

full_name: Submodule.Quotient.equiv_symm
code: @[simp]
theorem Quotient.equiv_symm {R M N : Type*} [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (P : Submodule R M) (Q : Submodule R N) (f : M ≃ₗ[R] N)
    (hf : P.map f = Q) :
    (Quotient.equiv P Q f hf).symm =
      Quotient.equiv Q P f.symm ((Submodule.map_symm_eq_iff f).mpr hf) 
goal: (Submodule.Quotient.equiv P Q f hf).symm = Submodule.Quotient.equiv Q P f.symm ⋯

full_name: Submodule.Quotient.equiv_trans
code: @[simp]
theorem Quotient.equiv_trans {N O : Type*} [AddCommGroup N] [Module R N] [AddCommGroup O]
    [Module R O] (P : Submodule R M) (Q : Submodule R N) (S : Submodule R O) (e : M ≃ₗ[R] N)
    (f : N ≃ₗ[R] O) (he : P.map e = Q) (hf : Q.map f = S) (hef : P.map (e.trans f) = S) :
    Quotient.equiv P S (e.trans f) hef =
      (Quotient.equiv P Q e he).trans (Quotient.equiv Q S f hf) 
goal: Submodule.Quotient.equiv P S (e ≪≫ₗ f) hef = Submodule.Quotient.equiv P Q e he ≪≫ₗ Submodule.Quotient.equiv Q S f hf

full_name: LinearMap.range_mkQ_comp
code: theorem range_mkQ_comp (f : M →ₛₗ[τ₁₂] M₂) : f.range.mkQ.comp f = 0 
goal: (LinearMap.range f).mkQ.comp f = 0

full_name: LinearMap.ker_le_range_iff
code: theorem ker_le_range_iff {f : M →ₛₗ[τ₁₂] M₂} {g : M₂ →ₛₗ[τ₂₃] M₃} :
    ker g ≤ range f ↔ f.range.mkQ.comp g.ker.subtype = 0 
goal: LinearMap.ker g ≤ LinearMap.range f ↔ (LinearMap.range f).mkQ ∘ₗ (LinearMap.ker g).subtype = 0

full_name: LinearMap.range_eq_top_of_cancel
code: /-- An epimorphism is surjective. -/
theorem range_eq_top_of_cancel {f : M →ₛₗ[τ₁₂] M₂}
    (h : ∀ u v : M₂ →ₗ[R₂] M₂ ⧸ (range f), u.comp f = v.comp f → u = v) : range f = ⊤ 
goal: LinearMap.range f = ⊤

full_name: Submodule.quotEquivOfEqBot
code: /-- If `p = ⊥`, then `M / p ≃ₗ[R] M`. -/
def quotEquivOfEqBot (hp : p = ⊥) : (M ⧸ p) ≃ₗ[R] M 
goal: (M ⧸ p) ≃ₗ[R] M

full_name: Submodule.quotEquivOfEqBot_apply_mk
code: @[simp]
theorem quotEquivOfEqBot_apply_mk (hp : p = ⊥) (x : M) :
    p.quotEquivOfEqBot hp (Quotient.mk x : M ⧸ p) = x 
goal: (p.quotEquivOfEqBot hp) (Submodule.Quotient.mk x) = x

full_name: Submodule.quotEquivOfEqBot_symm_apply
code: @[simp]
theorem quotEquivOfEqBot_symm_apply (hp : p = ⊥) (x : M) :
    (p.quotEquivOfEqBot hp).symm x = (Quotient.mk x : M ⧸ p) 
goal: (p.quotEquivOfEqBot hp).symm x = Submodule.Quotient.mk x

full_name: Submodule.coe_quotEquivOfEqBot_symm
code: @[simp]
theorem coe_quotEquivOfEqBot_symm (hp : p = ⊥) :
    ((p.quotEquivOfEqBot hp).symm : M →ₗ[R] M ⧸ p) = p.mkQ 
goal: ↑(p.quotEquivOfEqBot hp).symm = p.mkQ

full_name: Submodule.quotEquivOfEq
code: /-- Quotienting by equal submodules gives linearly equivalent quotients. -/
def quotEquivOfEq (h : p = p') : (M ⧸ p) ≃ₗ[R] M ⧸ p' 
goal: (M ⧸ p) ≃ₗ[R] M ⧸ p'

full_name: Submodule.quotEquivOfEq_mk
code: @[simp]
theorem quotEquivOfEq_mk (h : p = p') (x : M) :
    Submodule.quotEquivOfEq p p' h (Submodule.Quotient.mk x : M ⧸ p) =
      (Submodule.Quotient.mk x : M ⧸ p') 
goal: (p.quotEquivOfEq p' h) (Submodule.Quotient.mk x) = Submodule.Quotient.mk x

full_name: Submodule.Quotient.equiv_refl
code: @[simp]
theorem Quotient.equiv_refl (P : Submodule R M) (Q : Submodule R M)
    (hf : P.map (LinearEquiv.refl R M : M →ₗ[R] M) = Q) :
    Quotient.equiv P Q (LinearEquiv.refl R M) hf = quotEquivOfEq _ _ (by simpa using hf) 
goal: Submodule.Quotient.equiv P Q (LinearEquiv.refl R M) hf = P.quotEquivOfEq Q ⋯

full_name: Submodule.mapQLinear
code: /-- Given modules `M`, `M₂` over a commutative ring, together with submodules `p ⊆ M`, `q ⊆ M₂`,
the natural map $\{f ∈ Hom(M, M₂) | f(p) ⊆ q \} \to Hom(M/p, M₂/q)$ is linear. -/
def mapQLinear : compatibleMaps p q →ₗ[R] M ⧸ p →ₗ[R] M₂ ⧸ q 
goal: ↥(p.compatibleMaps q) →ₗ[R] M ⧸ p →ₗ[R] M₂ ⧸ q