File: Mathlib/LinearAlgebra/Isomorphisms.lean

full_name: LinearMap.quotKerEquivRange
code: /-- The **first isomorphism law for modules**. The quotient of `M` by the kernel of `f` is linearly
equivalent to the range of `f`. -/
noncomputable def quotKerEquivRange : (M ⧸ LinearMap.ker f) ≃ₗ[R] LinearMap.range f 
goal: (M ⧸ LinearMap.ker f) ≃ₗ[R] ↥(LinearMap.range f)

full_name: LinearMap.quotKerEquivOfSurjective
code: /-- The **first isomorphism theorem for surjective linear maps**. -/
noncomputable def quotKerEquivOfSurjective (f : M →ₗ[R] M₂) (hf : Function.Surjective f) :
    (M ⧸ LinearMap.ker f) ≃ₗ[R] M₂ 
goal: (M ⧸ LinearMap.ker f) ≃ₗ[R] M₂

full_name: LinearMap.quotKerEquivRange_apply_mk
code: @[simp]
theorem quotKerEquivRange_apply_mk (x : M) :
    (f.quotKerEquivRange (Submodule.Quotient.mk x) : M₂) = f x 
goal: ↑(f.quotKerEquivRange (Submodule.Quotient.mk x)) = f x

full_name: LinearMap.quotKerEquivRange_symm_apply_image
code: @[simp]
theorem quotKerEquivRange_symm_apply_image (x : M) (h : f x ∈ LinearMap.range f) :
    f.quotKerEquivRange.symm ⟨f x, h⟩ = f.ker.mkQ x 
goal: f.quotKerEquivRange.symm ⟨f x, h⟩ = (LinearMap.ker f).mkQ x

full_name: LinearMap.subToSupQuotient
code: /-- Linear map from `p` to `p+p'/p'` where `p p'` are submodules of `R` -/
abbrev subToSupQuotient (p p' : Submodule R M) :
    { x // x ∈ p } →ₗ[R] { x // x ∈ p ⊔ p' } ⧸ comap (Submodule.subtype (p ⊔ p')) p' 
goal: ↥p →ₗ[R] ↥(p ⊔ p') ⧸ Submodule.comap (p ⊔ p').subtype p'

full_name: LinearMap.comap_leq_ker_subToSupQuotient
code: theorem comap_leq_ker_subToSupQuotient (p p' : Submodule R M) :
    comap (Submodule.subtype p) (p ⊓ p') ≤ ker (subToSupQuotient p p') 
goal: Submodule.comap p.subtype (p ⊓ p') ≤ LinearMap.ker (LinearMap.subToSupQuotient p p')

full_name: LinearMap.quotientInfToSupQuotient
code: /-- Canonical linear map from the quotient `p/(p ∩ p')` to `(p+p')/p'`, mapping `x + (p ∩ p')`
to `x + p'`, where `p` and `p'` are submodules of an ambient module.
-/
def quotientInfToSupQuotient (p p' : Submodule R M) :
    (↥p) ⧸ (comap p.subtype (p ⊓ p')) →ₗ[R] (↥(p ⊔ p')) ⧸ (comap (p ⊔ p').subtype p') 
goal: ↥p ⧸ Submodule.comap p.subtype (p ⊓ p') →ₗ[R] ↥(p ⊔ p') ⧸ Submodule.comap (p ⊔ p').subtype p'

full_name: LinearMap.quotientInfEquivSupQuotient_injective
code: theorem quotientInfEquivSupQuotient_injective (p p' : Submodule R M) :
    Function.Injective (quotientInfToSupQuotient p p') 
goal: Function.Injective ⇑(LinearMap.quotientInfToSupQuotient p p')

full_name: LinearMap.quotientInfEquivSupQuotient_surjective
code: theorem quotientInfEquivSupQuotient_surjective (p p' : Submodule R M) :
    Function.Surjective (quotientInfToSupQuotient p p') 
goal: Function.Surjective ⇑(LinearMap.quotientInfToSupQuotient p p')

full_name: LinearMap.quotientInfEquivSupQuotient
code: /--
Second Isomorphism Law : the canonical map from `p/(p ∩ p')` to `(p+p')/p'` as a linear isomorphism.
-/
noncomputable def quotientInfEquivSupQuotient (p p' : Submodule R M) :
    (p ⧸ comap p.subtype (p ⊓ p')) ≃ₗ[R] _ ⧸ comap (p ⊔ p').subtype p' 
goal: (↥p ⧸ Submodule.comap p.subtype (p ⊓ p')) ≃ₗ[R] ↥(p ⊔ p') ⧸ Submodule.comap (p ⊔ p').subtype p'

full_name: LinearMap.coe_quotientInfToSupQuotient
code: theorem coe_quotientInfToSupQuotient (p p' : Submodule R M) :
    ⇑(quotientInfToSupQuotient p p') = quotientInfEquivSupQuotient p p' 
goal: ⇑(LinearMap.quotientInfToSupQuotient p p') = ⇑(LinearMap.quotientInfEquivSupQuotient p p')

full_name: LinearMap.quotientInfEquivSupQuotient_apply_mk
code: @[simp, nolint simpNF]
theorem quotientInfEquivSupQuotient_apply_mk (p p' : Submodule R M) (x : p) :
    let map := inclusion (le_sup_left : p ≤ p ⊔ p')
    quotientInfEquivSupQuotient p p' (Submodule.Quotient.mk x) =
      @Submodule.Quotient.mk R (p ⊔ p' : Submodule R M) _ _ _ (comap (p ⊔ p').subtype p') (map x) 
goal: let map := Submodule.inclusion ⋯;
(LinearMap.quotientInfEquivSupQuotient p p') (Submodule.Quotient.mk x) = Submodule.Quotient.mk (map x)

full_name: LinearMap.quotientInfEquivSupQuotient_symm_apply_left
code: theorem quotientInfEquivSupQuotient_symm_apply_left (p p' : Submodule R M) (x : ↥(p ⊔ p'))
    (hx : (x : M) ∈ p) :
    (quotientInfEquivSupQuotient p p').symm (Submodule.Quotient.mk x) =
      Submodule.Quotient.mk ⟨x, hx⟩ 
goal: (LinearMap.quotientInfEquivSupQuotient p p').symm (Submodule.Quotient.mk x) = Submodule.Quotient.mk ⟨↑x, hx⟩

full_name: LinearMap.quotientInfEquivSupQuotient_symm_apply_eq_zero_iff
code: theorem quotientInfEquivSupQuotient_symm_apply_eq_zero_iff {p p' : Submodule R M} {x : ↥(p ⊔ p')} :
    (quotientInfEquivSupQuotient p p').symm (Submodule.Quotient.mk x) = 0 ↔ (x : M) ∈ p' 
goal: (LinearMap.quotientInfEquivSupQuotient p p').symm (Submodule.Quotient.mk x) = 0 ↔ ↑x ∈ p'

full_name: LinearMap.quotientInfEquivSupQuotient_symm_apply_right
code: theorem quotientInfEquivSupQuotient_symm_apply_right (p p' : Submodule R M) {x : ↥(p ⊔ p')}
    (hx : (x : M) ∈ p') : (quotientInfEquivSupQuotient p p').symm (Submodule.Quotient.mk x)
    = 0 
goal: (LinearMap.quotientInfEquivSupQuotient p p').symm (Submodule.Quotient.mk x) = 0

full_name: Submodule.quotientQuotientEquivQuotientAux
code: /-- The map from the third isomorphism theorem for modules: `(M / S) / (T / S) → M / T`. -/
def quotientQuotientEquivQuotientAux (h : S ≤ T) : (M ⧸ S) ⧸ T.map S.mkQ →ₗ[R] M ⧸ T 
goal: (M ⧸ S) ⧸ Submodule.map S.mkQ T →ₗ[R] M ⧸ T

full_name: Submodule.quotientQuotientEquivQuotientAux_mk
code: @[simp]
theorem quotientQuotientEquivQuotientAux_mk (x : M ⧸ S) :
    quotientQuotientEquivQuotientAux S T h (Quotient.mk x) = mapQ S T LinearMap.id h x 
goal: (S.quotientQuotientEquivQuotientAux T h) (Submodule.Quotient.mk x) = (S.mapQ T LinearMap.id h) x

full_name: Submodule.quotientQuotientEquivQuotientAux_mk_mk
code: theorem quotientQuotientEquivQuotientAux_mk_mk (x : M) :
    quotientQuotientEquivQuotientAux S T h (Quotient.mk (Quotient.mk x)) = Quotient.mk x 
goal: (S.quotientQuotientEquivQuotientAux T h) (Submodule.Quotient.mk (Submodule.Quotient.mk x)) = Submodule.Quotient.mk x

full_name: Submodule.quotientQuotientEquivQuotient
code: /-- **Noether's third isomorphism theorem** for modules: `(M / S) / (T / S) ≃ M / T`. -/
def quotientQuotientEquivQuotient : ((M ⧸ S) ⧸ T.map S.mkQ) ≃ₗ[R] M ⧸ T 
goal: ((M ⧸ S) ⧸ Submodule.map S.mkQ T) ≃ₗ[R] M ⧸ T

full_name: Submodule.quotientQuotientEquivQuotientSup
code: /-- Essentially the same equivalence as in the third isomorphism theorem,
except restated in terms of suprema/addition of submodules instead of `≤`. -/
def quotientQuotientEquivQuotientSup : ((M ⧸ S) ⧸ T.map S.mkQ) ≃ₗ[R] M ⧸ S ⊔ T 
goal: ((M ⧸ S) ⧸ Submodule.map S.mkQ T) ≃ₗ[R] M ⧸ S ⊔ T

full_name: Submodule.card_quotient_mul_card_quotient
code: /-- Corollary of the third isomorphism theorem: `[S : T] [M : S] = [M : T]` -/
theorem card_quotient_mul_card_quotient (S T : Submodule R M) (hST : T ≤ S) :
    Nat.card (S.map T.mkQ) * Nat.card (M ⧸ S) = Nat.card (M ⧸ T) 
goal: Nat.card ↥(Submodule.map T.mkQ S) * Nat.card (M ⧸ S) = Nat.card (M ⧸ T)