fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
univ_eq_iUnion_image_add : (Set.univ (α := R)) = ⋃ x : R ⧸ I, x.out +ᵥ (I : Set R) :=
QuotientAddGroup.univ_eq_iUnion_vadd I.toAddSubgroup
variable {I} in | lemma | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | univ_eq_iUnion_image_add | A ring is made up of a disjoint union of cosets of an ideal. |
_root_.Finite.of_finite_quot_finite_ideal [hI : Finite I] [h : Finite (R ⧸ I)] : Finite R :=
@Finite.of_finite_quot_finite_addSubgroup _ _ _ hI h | lemma | RingTheory | [
"Mathlib.GroupTheory.QuotientGroup.Finite",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Basic",
"Mathlib.RingTheory.Ideal.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Quotient/Basic.lean | _root_.Finite.of_finite_quot_finite_ideal | null |
instHasQuotient : HasQuotient R (Ideal R) := Submodule.hasQuotient | instance | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | instHasQuotient | The quotient `R/I` of a ring `R` by an ideal `I`,
defined to equal the quotient of `I` as an `R`-submodule of `R`. |
protected ringCon (I : Ideal R) [I.IsTwoSided] : RingCon R where
__ := QuotientAddGroup.con I.toAddSubgroup
mul' {a₁ b₁ a₂ b₂} h₁ h₂ := by
rw [Submodule.quotientRel_def] at h₁ h₂ ⊢
exact mul_sub_mul_mem I h₁ h₂ | def | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | ringCon | Shortcut instance for commutative rings. -/
instance {R} [CommRing R] : HasQuotient R (Ideal R) := inferInstance
namespace Quotient
variable {I} {x y : R}
instance one (I : Ideal R) : One (R ⧸ I) :=
⟨Submodule.Quotient.mk 1⟩
/-- On `Ideal`s, `Submodule.quotientRel` is a ring congruence. |
ring (I : Ideal R) [I.IsTwoSided] : Ring (R ⧸ I) := fast_instance%
{ __ : AddCommGroup (R ⧸ I) := inferInstance
__ : Ring (Quotient.ringCon I).Quotient := inferInstance } | instance | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | ring | null |
commRing {R} [CommRing R] (I : Ideal R) : CommRing (R ⧸ I) := fast_instance%
{ mul_comm := by rintro ⟨a⟩ ⟨b⟩; exact congr_arg _ (mul_comm a b) } | instance | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | commRing | null |
commSemiring {R} [CommRing R] (I : Ideal R) : CommSemiring (R ⧸ I) := fast_instance%
inferInstance | instance | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | commSemiring | null |
semiring {R} [CommRing R] (I : Ideal R) : Semiring (R ⧸ I) := fast_instance% inferInstance
variable [I.IsTwoSided] | instance | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | semiring | null |
mk : R →+* R ⧸ I where
toFun a := Submodule.Quotient.mk a
map_zero' := rfl
map_one' := rfl
map_mul' _ _ := rfl
map_add' _ _ := rfl | def | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | mk | The ring homomorphism from a ring `R` to a quotient ring `R/I`. |
@[ext 1100]
ringHom_ext [NonAssocSemiring S] ⦃f g : R ⧸ I →+* S⦄ (h : f.comp (mk I) = g.comp (mk I)) :
f = g :=
RingHom.ext fun x => Quotient.inductionOn' x <| (RingHom.congr_fun h :) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | ringHom_ext | Two `RingHom`s from the quotient by an ideal are equal if their
compositions with `Ideal.Quotient.mk'` are equal.
See note [partially-applied ext lemmas]. |
protected eq : mk I x = mk I y ↔ x - y ∈ I :=
Submodule.Quotient.eq I
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | eq | null |
mk_eq_mk (x : R) : (Submodule.Quotient.mk x : R ⧸ I) = mk I x := rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | mk_eq_mk | null |
eq_zero_iff_mem : mk I a = 0 ↔ a ∈ I :=
Submodule.Quotient.mk_eq_zero _ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | eq_zero_iff_mem | null |
mk_eq_mk_iff_sub_mem (x y : R) : mk I x = mk I y ↔ x - y ∈ I := by
rw [← eq_zero_iff_mem, map_sub, sub_eq_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | mk_eq_mk_iff_sub_mem | null |
mk_out (x : R ⧸ I) : Ideal.Quotient.mk I (Quotient.out x) = x :=
Quotient.out_eq x | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | mk_out | null |
mk_surjective : Function.Surjective (mk I) := fun y =>
Quotient.inductionOn' y fun x => Exists.intro x rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | mk_surjective | null |
quotient_ring_saturate (s : Set R) :
mk I ⁻¹' (mk I '' s) = ⋃ x : I, (fun y => x.1 + y) '' s := by
ext x
simp only [mem_preimage, mem_image, mem_iUnion, Ideal.Quotient.eq]
exact
⟨fun ⟨a, a_in, h⟩ => ⟨⟨_, I.neg_mem h⟩, a, a_in, by simp⟩, fun ⟨⟨i, hi⟩, a, ha, Eq⟩ =>
⟨a, ha, by rw [← Eq, sub_add_eq_sub_sub_swap, sub_self, zero_sub]; exact I.neg_mem hi⟩⟩
variable [Semiring S] (I) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | quotient_ring_saturate | If `I` is an ideal of a commutative ring `R`, if `q : R → R/I` is the quotient map, and if
`s ⊆ R` is a subset, then `q⁻¹(q(s)) = ⋃ᵢ(i + s)`, the union running over all `i ∈ I`. |
lift (f : R →+* S) (H : ∀ a : R, a ∈ I → f a = 0) : R ⧸ I →+* S :=
{ QuotientAddGroup.lift I.toAddSubgroup f.toAddMonoidHom H with
map_one' := f.map_one
map_mul' := fun a₁ a₂ => Quotient.inductionOn₂' a₁ a₂ f.map_mul }
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | lift | Given a ring homomorphism `f : R →+* S` sending all elements of an ideal to zero,
lift it to the quotient by this ideal. |
lift_mk (f : R →+* S) (H : ∀ a : R, a ∈ I → f a = 0) :
lift I f H (mk I a) = f a :=
rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | lift_mk | null |
lift_comp_mk (f : R →+* S) (H : ∀ a : R, a ∈ I → f a = 0) :
(lift I f H).comp (mk I) = f := rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | lift_comp_mk | null |
lift_surjective_of_surjective {f : R →+* S} (H : ∀ a : R, a ∈ I → f a = 0)
(hf : Function.Surjective f) : Function.Surjective (Ideal.Quotient.lift I f H) := by
intro y
obtain ⟨x, rfl⟩ := hf y
use Ideal.Quotient.mk I x
simp only [Ideal.Quotient.lift_mk]
variable {S T U : Ideal R} [S.IsTwoSided] [T.IsTwoSided] [U.IsTwoSided] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | lift_surjective_of_surjective | null |
factor (H : S ≤ T) : R ⧸ S →+* R ⧸ T :=
Ideal.Quotient.lift S (mk T) fun _ hx => eq_zero_iff_mem.2 (H hx)
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | factor | The ring homomorphism from the quotient by a smaller ideal to the quotient by a larger ideal.
This is the `Ideal.Quotient` version of `Quot.Factor`
When the two ideals are of the form `I^m` and `I^n` and `n ≤ m`,
please refer to the dedicated version `Ideal.Quotient.factorPow`. |
factor_mk (H : S ≤ T) (x : R) : factor H (mk S x) = mk T x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | factor_mk | null |
factor_eq : factor (le_refl S) = RingHom.id _ := by
ext
simp
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | factor_eq | null |
factor_comp_mk (H : S ≤ T) : (factor H).comp (mk S) = mk T := by
ext x
rw [RingHom.comp_apply, factor_mk]
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | factor_comp_mk | null |
factor_comp (H1 : S ≤ T) (H2 : T ≤ U) :
(factor H2).comp (factor H1) = factor (H1.trans H2) := by
ext
simp
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | factor_comp | null |
factor_comp_apply (H1 : S ≤ T) (H2 : T ≤ U) (x : R ⧸ S) :
factor H2 (factor H1 x) = factor (H1.trans H2) x := by
rw [← RingHom.comp_apply]
simp | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | factor_comp_apply | null |
factor_surjective (H : S ≤ T) : Function.Surjective (factor H) :=
Ideal.Quotient.lift_surjective_of_surjective _ _ Ideal.Quotient.mk_surjective | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | factor_surjective | null |
quotEquivOfEq (h : I = J) : R ⧸ I ≃+* R ⧸ J :=
{ Submodule.quotEquivOfEq I J h with
map_mul' := by
rintro ⟨x⟩ ⟨y⟩
rfl }
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | quotEquivOfEq | Quotienting by equal ideals gives equivalent rings.
See also `Submodule.quotEquivOfEq` and `Ideal.quotientEquivAlgOfEq`. |
quotEquivOfEq_mk (h : I = J) (x : R) :
quotEquivOfEq h (Ideal.Quotient.mk I x) = Ideal.Quotient.mk J x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | quotEquivOfEq_mk | null |
quotEquivOfEq_symm (h : I = J) :
(Ideal.quotEquivOfEq h).symm = Ideal.quotEquivOfEq h.symm := by ext; rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Congruence.Defs",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/Quotient/Defs.lean | quotEquivOfEq_symm | null |
Submodule.finite_quotient_smul [Finite (R ⧸ I)] [Finite (M ⧸ N)] (hN : N.FG) :
Finite (M ⧸ I • N) := by
suffices (I • N).toAddSubgroup.FiniteIndex by
exact (I • N).toAddSubgroup.finite_quotient_of_finiteIndex
suffices Nat.card (N ⧸ (I • N).comap N.subtype) ≠ 0 by
constructor
rw [← AddSubgroup.relIndex_mul_index
(H := (I • N).toAddSubgroup) (K := N.toAddSubgroup) Submodule.smul_le_right]
have inst : Finite (M ⧸ N.toAddSubgroup) := ‹_›
exact mul_ne_zero this AddSubgroup.index_ne_zero_of_finite
let e : (N ⧸ (I • N).comap N.subtype) ≃ₗ[R] (R ⧸ I) ⊗[R] N :=
Submodule.quotEquivOfEq _ (I • (⊤ : Submodule R N)) (Submodule.map_injective_of_injective
N.injective_subtype (by simp [Submodule.smul_le_right])) ≪≫ₗ
(quotTensorEquivQuotSMul N I).symm
rw [Nat.card_congr e.toEquiv]
have : Module.Finite R N := Module.Finite.iff_fg.mpr hN
have : Finite ((R ⧸ I) ⊗[R] N) := Module.finite_of_finite (R ⧸ I)
exact Nat.card_pos.ne'
open TensorProduct in | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.GroupTheory.Index",
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.TensorProduct.Quotient",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory... | Mathlib/RingTheory/Ideal/Quotient/Index.lean | Submodule.finite_quotient_smul | Let `N` be a finite index f.g. `R`-submodule, and `I` be a finite index ideal.
Then `I • N` also has finite index. |
Submodule.index_smul_le [Finite (R ⧸ I)]
(s : Finset M) (hs : Submodule.span R s = N) :
(I • N).toAddSubgroup.index ≤ I.toAddSubgroup.index ^ s.card * N.toAddSubgroup.index := by
classical
cases nonempty_fintype (R ⧸ I)
rw [← AddSubgroup.relIndex_mul_index
(H := (I • N).toAddSubgroup) (K := N.toAddSubgroup) Submodule.smul_le_right]
gcongr
change (Nat.card (N ⧸ (I • N).comap N.subtype)) ≤ Nat.card (R ⧸ I) ^ s.card
let e : (N ⧸ (I • N).comap N.subtype) ≃ₗ[R] (R ⧸ I) ⊗[R] N :=
Submodule.quotEquivOfEq _ (I • (⊤ : Submodule R N)) (Submodule.map_injective_of_injective
N.injective_subtype (by simp [Submodule.smul_le_right])) ≪≫ₗ
(quotTensorEquivQuotSMul N I).symm
rw [Nat.card_congr e.toEquiv]
have H : LinearMap.range (Finsupp.linearCombination R (α := s) (↑)) = N := by
rw [Finsupp.range_linearCombination, ← hs, Subtype.range_val]; rfl
let f : (s →₀ R) →ₗ[R] N := (Finsupp.linearCombination R (↑)).codRestrict _
(fun c => by rw [← H, LinearMap.mem_range]; exact exists_apply_eq_apply _ _)
have hf : Function.Surjective f := fun x ↦ by
obtain ⟨y, hy⟩ := H.ge x.2; exact ⟨y, Subtype.ext hy⟩
have : Function.Surjective
(f.lTensor (R ⧸ I) ∘ₗ (finsuppScalarRight R (R ⧸ I) s).symm.toLinearMap) :=
(LinearMap.lTensor_surjective (R ⧸ I) hf).comp (LinearEquiv.surjective _)
refine (Nat.card_le_card_of_surjective _ this).trans ?_
simp only [Nat.card_eq_fintype_card, Fintype.card_finsupp, Fintype.card_coe, le_rfl]
variable {I} | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.GroupTheory.Index",
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.TensorProduct.Quotient",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory... | Mathlib/RingTheory/Ideal/Quotient/Index.lean | Submodule.index_smul_le | null |
Ideal.finite_quotient_prod {ι : Type*} (I : ι → Ideal R) (s : Finset ι)
(hI : ∀ i ∈ s, (I i).FG) (hI' : ∀ i ∈ s, Finite (R ⧸ I i)) : Finite (R ⧸ (∏ i ∈ s, I i)) := by
classical
induction s using Finset.induction_on with
| empty => simp only [Finset.prod_empty, one_eq_top]; infer_instance
| insert a s has IH =>
rw [Finset.prod_insert has, mul_comm]
have := hI' a (by simp)
have := IH (fun i hi ↦ hI _ (by simp [hi])) (fun i hi ↦ hI' _ (by simp [hi]))
exact Submodule.finite_quotient_smul _ (hI a (by simp)) | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.GroupTheory.Index",
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.TensorProduct.Quotient",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory... | Mathlib/RingTheory/Ideal/Quotient/Index.lean | Ideal.finite_quotient_prod | null |
Ideal.finite_quotient_pow (hI : I.FG) [Finite (R ⧸ I)] (n) : Finite (R ⧸ I ^ n) := by
induction n with
| zero =>
simp only [pow_zero, Ideal.one_eq_top]
infer_instance
| succ n _ =>
exact Submodule.finite_quotient_smul (I ^ n) hI | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.GroupTheory.Index",
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.TensorProduct.Quotient",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory... | Mathlib/RingTheory/Ideal/Quotient/Index.lean | Ideal.finite_quotient_pow | null |
Ideal.index_pow_le
(s : Finset R) (hs : Ideal.span s = I) [Finite (R ⧸ I)] (n) :
(I ^ n).toAddSubgroup.index ≤ I.toAddSubgroup.index ^ ∑ i ∈ Finset.range n, s.card ^ i := by
have := Ideal.finite_quotient_pow ⟨s, hs⟩
induction n with
| zero =>
simp
| succ n IH =>
refine (Submodule.index_smul_le (I ^ n) s hs).trans ?_
refine (Nat.mul_le_mul (Nat.pow_le_pow_left IH _) le_rfl).trans ?_
rw [← pow_mul, ← pow_succ, geom_sum_succ, mul_comm] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.Data.Finsupp.Fintype",
"Mathlib.GroupTheory.Index",
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.TensorProduct.Quotient",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.RingTheory... | Mathlib/RingTheory/Ideal/Quotient/Index.lean | Ideal.index_pow_le | null |
Ideal.isRadical_iff_quotient_reduced {R : Type*} [CommRing R] (I : Ideal R) :
I.IsRadical ↔ IsReduced (R ⧸ I) := by
conv_lhs => rw [← @Ideal.mk_ker R _ I]
exact RingHom.ker_isRadical_iff_reduced_of_surjective Quotient.mk_surjective
variable {S : Type*} [CommRing S] (I : Ideal S) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Ideal/Quotient/Nilpotent.lean | Ideal.isRadical_iff_quotient_reduced | null |
Ideal.IsNilpotent.induction_on (hI : IsNilpotent I)
{P : ∀ ⦃S : Type _⦄ [CommRing S], Ideal S → Prop}
(h₁ : ∀ ⦃S : Type _⦄ [CommRing S], ∀ I : Ideal S, I ^ 2 = ⊥ → P I)
(h₂ : ∀ ⦃S : Type _⦄ [CommRing S], ∀ I J : Ideal S, I ≤ J → P I →
P (J.map (Ideal.Quotient.mk I)) → P J) :
P I := by
obtain ⟨n, hI : I ^ n = ⊥⟩ := hI
induction n using Nat.strong_induction_on generalizing S with | _ n H
by_cases hI' : I = ⊥
· subst hI'
apply h₁
rw [← Ideal.zero_eq_bot, zero_pow two_ne_zero]
rcases n with - | n
· rw [pow_zero, Ideal.one_eq_top] at hI
haveI := subsingleton_of_bot_eq_top hI.symm
exact (hI' (Subsingleton.elim _ _)).elim
rcases n with - | n
· rw [pow_one] at hI
exact (hI' hI).elim
apply h₂ (I ^ 2) _ (Ideal.pow_le_self two_ne_zero)
· apply H n.succ _ (I ^ 2)
· rw [← pow_mul, eq_bot_iff, ← hI, Nat.succ_eq_add_one]
apply Ideal.pow_le_pow_right (by cutsat)
· exact n.succ.lt_succ_self
· apply h₁
rw [← Ideal.map_pow, Ideal.map_quotient_self] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Ideal/Quotient/Nilpotent.lean | Ideal.IsNilpotent.induction_on | Let `P` be a property on ideals. If `P` holds for square-zero ideals, and if
`P I → P (J ⧸ I) → P J`, then `P` holds for all nilpotent ideals. |
IsNilpotent.isUnit_quotient_mk_iff {R : Type*} [CommRing R] {I : Ideal R}
(hI : IsNilpotent I) {x : R} : IsUnit (Ideal.Quotient.mk I x) ↔ IsUnit x := by
refine ⟨?_, fun h => h.map <| Ideal.Quotient.mk I⟩
revert x
apply Ideal.IsNilpotent.induction_on (S := R) I hI <;> clear hI I
swap
· introv e h₁ h₂ h₃
apply h₁
apply h₂
exact
h₃.map
((DoubleQuot.quotQuotEquivQuotSup I J).trans
(Ideal.quotEquivOfEq (sup_eq_right.mpr e))).symm.toRingHom
· introv e H
obtain ⟨y, hy⟩ := Ideal.Quotient.mk_surjective (↑H.unit⁻¹ : S ⧸ I)
have : Ideal.Quotient.mk I (x * y) = Ideal.Quotient.mk I 1 := by
rw [map_one, map_mul, hy, IsUnit.mul_val_inv]
rw [Ideal.Quotient.eq] at this
have : (x * y - 1) ^ 2 = 0 := by
rw [← Ideal.mem_bot, ← e]
exact Ideal.pow_mem_pow this _
have : x * (y * (2 - x * y)) = 1 := by
rw [eq_comm, ← sub_eq_zero, ← this]
ring
exact isUnit_of_mul_eq_one _ _ this | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Ideal/Quotient/Nilpotent.lean | IsNilpotent.isUnit_quotient_mk_iff | null |
Ideal.Quotient.isNoetherianRing {R : Type*} [CommRing R] [IsNoetherianRing R]
(I : Ideal R) : IsNoetherianRing (R ⧸ I) :=
isNoetherianRing_iff.mpr <| isNoetherian_of_tower R <| inferInstance | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Noetherian.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Noetherian.lean | Ideal.Quotient.isNoetherianRing | null |
kerLift : R ⧸ ker f →+* S :=
Ideal.Quotient.lift _ f fun _ => mem_ker.mp
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | kerLift | The induced map from the quotient by the kernel to the codomain.
This is an isomorphism if `f` has a right inverse (`quotientKerEquivOfRightInverse`) /
is surjective (`quotientKerEquivOfSurjective`). |
kerLift_mk (r : R) : kerLift f (Ideal.Quotient.mk (ker f) r) = f r :=
Ideal.Quotient.lift_mk _ _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | kerLift_mk | null |
lift_injective_of_ker_le_ideal (I : Ideal R) [I.IsTwoSided]
{f : R →+* S} (H : ∀ a : R, a ∈ I → f a = 0)
(hI : ker f ≤ I) : Function.Injective (Ideal.Quotient.lift I f H) := by
rw [RingHom.injective_iff_ker_eq_bot, RingHom.ker_eq_bot_iff_eq_zero]
intro u hu
obtain ⟨v, rfl⟩ := Ideal.Quotient.mk_surjective u
rw [Ideal.Quotient.lift_mk] at hu
rw [Ideal.Quotient.eq_zero_iff_mem]
exact hI (RingHom.mem_ker.mpr hu) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | lift_injective_of_ker_le_ideal | null |
kerLift_injective : Function.Injective (kerLift f) :=
lift_injective_of_ker_le_ideal (ker f) (fun a => by simp only [mem_ker, imp_self]) le_rfl
variable {f} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | kerLift_injective | The induced map from the quotient by the kernel is injective. |
quotientKerEquivOfRightInverse {g : S → R} (hf : Function.RightInverse g f) :
R ⧸ ker f ≃+* S :=
{ kerLift f with
toFun := kerLift f
invFun := Ideal.Quotient.mk (ker f) ∘ g
left_inv := by
rintro ⟨x⟩
apply kerLift_injective
simp only [Submodule.Quotient.quot_mk_eq_mk, Ideal.Quotient.mk_eq_mk, kerLift_mk,
Function.comp_apply, hf (f x)]
right_inv := hf }
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientKerEquivOfRightInverse | The **first isomorphism theorem for commutative rings**, computable version. |
quotientKerEquivOfRightInverse.apply {g : S → R} (hf : Function.RightInverse g f)
(x : R ⧸ ker f) : quotientKerEquivOfRightInverse hf x = kerLift f x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientKerEquivOfRightInverse.apply | null |
quotientKerEquivOfRightInverse.Symm.apply {g : S → R} (hf : Function.RightInverse g f)
(x : S) : (quotientKerEquivOfRightInverse hf).symm x = Ideal.Quotient.mk (ker f) (g x) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientKerEquivOfRightInverse.Symm.apply | null |
noncomputable quotientKerEquivOfSurjective (hf : Function.Surjective f) : R ⧸ (ker f) ≃+* S :=
quotientKerEquivOfRightInverse (Classical.choose_spec hf.hasRightInverse)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientKerEquivOfSurjective | The **first isomorphism theorem** for commutative rings, surjective case. |
quotientKerEquivOfSurjective_apply_mk {f : R →+* S} (hf : Function.Surjective f) (x : R) :
f.quotientKerEquivOfSurjective hf (Ideal.Quotient.mk _ x) = f x :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientKerEquivOfSurjective_apply_mk | null |
noncomputable quotientKerEquivRangeS (f : R →+* S) : R ⧸ ker f ≃+* f.rangeS :=
(Ideal.quotEquivOfEq f.ker_rangeSRestrict.symm).trans <|
quotientKerEquivOfSurjective f.rangeSRestrict_surjective
variable {S : Type v} [Ring S] (f : R →+* S) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientKerEquivRangeS | The **first isomorphism theorem** for commutative rings (`RingHom.rangeS` version). |
noncomputable quotientKerEquivRange (f : R →+* S) : R ⧸ ker f ≃+* f.range :=
(Ideal.quotEquivOfEq f.ker_rangeRestrict.symm).trans <|
quotientKerEquivOfSurjective f.rangeRestrict_surjective | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientKerEquivRange | The **first isomorphism theorem** for commutative rings (`RingHom.range` version). |
@[simp]
map_quotient_self (I : Ideal R) [I.IsTwoSided] : map (Quotient.mk I) I = ⊥ :=
eq_bot_iff.2 <|
Ideal.map_le_iff_le_comap.2 fun _ hx =>
(Submodule.mem_bot (R ⧸ I)).2 <| Ideal.Quotient.eq_zero_iff_mem.2 hx
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | map_quotient_self | null |
mk_ker {I : Ideal R} [I.IsTwoSided] : ker (Quotient.mk I) = I := by
ext
rw [ker, mem_comap, Submodule.mem_bot, Quotient.eq_zero_iff_mem] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | mk_ker | null |
map_mk_eq_bot_of_le {I J : Ideal R} [J.IsTwoSided] (h : I ≤ J) :
I.map (Quotient.mk J) = ⊥ := by
rw [map_eq_bot_iff_le_ker, mk_ker]
exact h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | map_mk_eq_bot_of_le | null |
ker_quotient_lift {I : Ideal R} [I.IsTwoSided] (f : R →+* S)
(H : I ≤ ker f) :
ker (Ideal.Quotient.lift I f H) = (RingHom.ker f).map (Quotient.mk I) := by
apply Ideal.ext
intro x
constructor
· intro hx
obtain ⟨y, hy⟩ := Quotient.mk_surjective x
rw [mem_ker, ← hy, Ideal.Quotient.lift_mk, ← mem_ker] at hx
rw [← hy, mem_map_iff_of_surjective (Quotient.mk I) Quotient.mk_surjective]
exact ⟨y, hx, rfl⟩
· intro hx
rw [mem_map_iff_of_surjective (Quotient.mk I) Quotient.mk_surjective] at hx
obtain ⟨y, hy⟩ := hx
rw [mem_ker, ← hy.right, Ideal.Quotient.lift_mk]
exact hy.left | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | ker_quotient_lift | null |
injective_lift_iff {I : Ideal R} [I.IsTwoSided]
{f : R →+* S} (H : ∀ (a : R), a ∈ I → f a = 0) :
Injective (Quotient.lift I f H) ↔ ker f = I := by
rw [injective_iff_ker_eq_bot, ker_quotient_lift, map_eq_bot_iff_le_ker, mk_ker]
constructor
· exact fun h ↦ le_antisymm h H
· rintro rfl; rfl | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | injective_lift_iff | null |
ker_Pi_Quotient_mk {ι : Type*} (I : ι → Ideal R) [∀ i, (I i).IsTwoSided] :
ker (Pi.ringHom fun i : ι ↦ Quotient.mk (I i)) = ⨅ i, I i := by
simp [Pi.ker_ringHom, mk_ker]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | ker_Pi_Quotient_mk | null |
bot_quotient_isMaximal_iff (I : Ideal R) [I.IsTwoSided] :
(⊥ : Ideal (R ⧸ I)).IsMaximal ↔ I.IsMaximal :=
⟨fun hI =>
mk_ker (I := I) ▸
comap_isMaximal_of_surjective (Quotient.mk I) Quotient.mk_surjective (K := ⊥) (H := hI),
fun hI => by
letI := Quotient.divisionRing I
exact bot_isMaximal⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | bot_quotient_isMaximal_iff | null |
@[simp]
mem_quotient_iff_mem_sup {I J : Ideal R} [I.IsTwoSided] {x : R} :
Quotient.mk I x ∈ J.map (Quotient.mk I) ↔ x ∈ J ⊔ I := by
rw [← mem_comap, comap_map_of_surjective (Quotient.mk I) Quotient.mk_surjective, ←
ker_eq_comap_bot, mk_ker] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | mem_quotient_iff_mem_sup | See also `Ideal.mem_quotient_iff_mem` in case `I ≤ J`. |
mem_quotient_iff_mem {I J : Ideal R} [I.IsTwoSided] (hIJ : I ≤ J) {x : R} :
Quotient.mk I x ∈ J.map (Quotient.mk I) ↔ x ∈ J := by
rw [mem_quotient_iff_mem_sup, sup_eq_left.mpr hIJ] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | mem_quotient_iff_mem | See also `Ideal.mem_quotient_iff_mem_sup` if the assumption `I ≤ J` is not available. |
quotientInfToPiQuotient (I : ι → Ideal R) [∀ i, (I i).IsTwoSided] :
(R ⧸ ⨅ i, I i) →+* ∀ i, R ⧸ I i :=
Quotient.lift (⨅ i, I i) (Pi.ringHom fun i : ι ↦ Quotient.mk (I i))
(by simp [← RingHom.mem_ker, ker_Pi_Quotient_mk]) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfToPiQuotient | The homomorphism from `R/(⋂ i, f i)` to `∏ i, (R / f i)` featured in the Chinese
Remainder Theorem. It is bijective if the ideals `f i` are coprime. |
quotientInfToPiQuotient_mk (I : ι → Ideal R) [∀ i, (I i).IsTwoSided] (x : R) :
quotientInfToPiQuotient I (Quotient.mk _ x) = fun i : ι ↦ Quotient.mk (I i) x :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfToPiQuotient_mk | null |
quotientInfToPiQuotient_mk' (I : ι → Ideal R) [∀ i, (I i).IsTwoSided] (x : R) (i : ι) :
quotientInfToPiQuotient I (Quotient.mk _ x) i = Quotient.mk (I i) x :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfToPiQuotient_mk' | null |
quotientInfToPiQuotient_inj (I : ι → Ideal R) [∀ i, (I i).IsTwoSided] :
Injective (quotientInfToPiQuotient I) := by
rw [quotientInfToPiQuotient, injective_lift_iff, ker_Pi_Quotient_mk]
variable {R : Type*} [CommRing R] {ι : Type*} [Finite ι] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfToPiQuotient_inj | null |
quotientInfToPiQuotient_surj {I : ι → Ideal R}
(hI : Pairwise (IsCoprime on I)) : Surjective (quotientInfToPiQuotient I) := by
classical
cases nonempty_fintype ι
intro g
choose f hf using fun i ↦ mk_surjective (g i)
have key : ∀ i, ∃ e : R, mk (I i) e = 1 ∧ ∀ j, j ≠ i → mk (I j) e = 0 := by
intro i
have hI' : ∀ j ∈ ({i} : Finset ι)ᶜ, IsCoprime (I i) (I j) := by
intro j hj
exact hI (by simpa [ne_comm, isCoprime_iff_add] using hj)
rcases isCoprime_iff_exists.mp (isCoprime_biInf hI') with ⟨u, hu, e, he, hue⟩
replace he : ∀ j, j ≠ i → e ∈ I j := by simpa using he
refine ⟨e, ?_, ?_⟩
· simp [eq_sub_of_add_eq' hue, map_sub, eq_zero_iff_mem.mpr hu]
· exact fun j hj ↦ eq_zero_iff_mem.mpr (he j hj)
choose e he using key
use mk _ (∑ i, f i*e i)
ext i
rw [quotientInfToPiQuotient_mk', map_sum, Fintype.sum_eq_single i]
· simp [(he i).1, hf]
· intro j hj
simp [(he j).2 i hj.symm] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfToPiQuotient_surj | null |
noncomputable quotientInfRingEquivPiQuotient (f : ι → Ideal R)
(hf : Pairwise (IsCoprime on f)) : (R ⧸ ⨅ i, f i) ≃+* ∀ i, R ⧸ f i :=
{ Equiv.ofBijective _ ⟨quotientInfToPiQuotient_inj f, quotientInfToPiQuotient_surj hf⟩,
quotientInfToPiQuotient f with } | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfRingEquivPiQuotient | **Chinese Remainder Theorem**. Eisenbud Ex.2.6.
Similar to Atiyah-Macdonald 1.10 and Stacks 00DT |
pi_quotient_surjective {I : ι → Ideal R}
(hf : Pairwise fun i j ↦ IsCoprime (I i) (I j)) (x : (i : ι) → R ⧸ I i) :
∃ r : R, ∀ i, r = x i := by
obtain ⟨y, rfl⟩ := Ideal.quotientInfToPiQuotient_surj hf x
obtain ⟨r, rfl⟩ := Ideal.Quotient.mk_surjective y
exact ⟨r, fun i ↦ rfl⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | pi_quotient_surjective | Corollary of Chinese Remainder Theorem: if `Iᵢ` are pairwise coprime ideals in a
commutative ring then the canonical map `R → ∏ (R ⧸ Iᵢ)` is surjective. |
exists_forall_sub_mem_ideal
{I : ι → Ideal R} (hI : Pairwise fun i j ↦ IsCoprime (I i) (I j)) (x : ι → R) :
∃ r : R, ∀ i, r - x i ∈ I i := by
obtain ⟨y, hy⟩ := Ideal.pi_quotient_surjective hI (fun i ↦ x i)
exact ⟨y, fun i ↦ (Submodule.Quotient.eq (I i)).mp <| hy i⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | exists_forall_sub_mem_ideal | Corollary of Chinese Remainder Theorem: if `Iᵢ` are pairwise coprime ideals in a
commutative ring then given elements `xᵢ` you can find `r` with `r - xᵢ ∈ Iᵢ` for all `i`. |
noncomputable quotientInfEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
R ⧸ I ⊓ J ≃+* (R ⧸ I) × R ⧸ J :=
let f : Fin 2 → Ideal R := ![I, J]
have hf : Pairwise (IsCoprime on f) := by
intro i j h
fin_cases i <;> fin_cases j <;> try contradiction
· assumption
· exact coprime.symm
(Ideal.quotEquivOfEq (by simp [f, iInf, inf_comm])).trans <|
(Ideal.quotientInfRingEquivPiQuotient f hf).trans <| RingEquiv.piFinTwo fun i => R ⧸ f i
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfEquivQuotientProd | **Chinese remainder theorem**, specialized to two ideals. |
quotientInfEquivQuotientProd_fst (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I ⊓ J) :
(quotientInfEquivQuotientProd I J coprime x).fst =
Ideal.Quotient.factor inf_le_left x :=
Quot.inductionOn x fun _ => rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfEquivQuotientProd_fst | null |
quotientInfEquivQuotientProd_snd (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I ⊓ J) :
(quotientInfEquivQuotientProd I J coprime x).snd =
Ideal.Quotient.factor inf_le_right x :=
Quot.inductionOn x fun _ => rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientInfEquivQuotientProd_snd | null |
fst_comp_quotientInfEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
(RingHom.fst _ _).comp
(quotientInfEquivQuotientProd I J coprime : R ⧸ I ⊓ J →+* (R ⧸ I) × R ⧸ J) =
Ideal.Quotient.factor inf_le_left := by
apply Quotient.ringHom_ext; ext; rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | fst_comp_quotientInfEquivQuotientProd | null |
snd_comp_quotientInfEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
(RingHom.snd _ _).comp
(quotientInfEquivQuotientProd I J coprime : R ⧸ I ⊓ J →+* (R ⧸ I) × R ⧸ J) =
Ideal.Quotient.factor inf_le_right := by
apply Quotient.ringHom_ext; ext; rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | snd_comp_quotientInfEquivQuotientProd | null |
noncomputable quotientMulEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
R ⧸ I * J ≃+* (R ⧸ I) × R ⧸ J :=
Ideal.quotEquivOfEq (inf_eq_mul_of_isCoprime coprime).symm |>.trans <|
Ideal.quotientInfEquivQuotientProd I J coprime
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientMulEquivQuotientProd | **Chinese remainder theorem**, specialized to two ideals. |
quotientMulEquivQuotientProd_fst (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I * J) :
(quotientMulEquivQuotientProd I J coprime x).fst =
Ideal.Quotient.factor mul_le_right x :=
Quot.inductionOn x fun _ => rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientMulEquivQuotientProd_fst | null |
quotientMulEquivQuotientProd_snd (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I * J) :
(quotientMulEquivQuotientProd I J coprime x).snd =
Ideal.Quotient.factor mul_le_left x :=
Quot.inductionOn x fun _ => rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | quotientMulEquivQuotientProd_snd | null |
fst_comp_quotientMulEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
(RingHom.fst _ _).comp
(quotientMulEquivQuotientProd I J coprime : R ⧸ I * J →+* (R ⧸ I) × R ⧸ J) =
Ideal.Quotient.factor mul_le_right := by
apply Quotient.ringHom_ext; ext; rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | fst_comp_quotientMulEquivQuotientProd | null |
snd_comp_quotientMulEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
(RingHom.snd _ _).comp
(quotientMulEquivQuotientProd I J coprime : R ⧸ I * J →+* (R ⧸ I) × R ⧸ J) =
Ideal.Quotient.factor mul_le_left := by
apply Quotient.ringHom_ext; ext; rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | snd_comp_quotientMulEquivQuotientProd | null |
Quotient.algebra {I : Ideal A} [I.IsTwoSided] : Algebra R₁ (A ⧸ I) where
algebraMap := (Ideal.Quotient.mk I).comp (algebraMap R₁ A)
smul_def' := fun _ x =>
Quotient.inductionOn' x fun _ =>
((Quotient.mk I).congr_arg <| Algebra.smul_def _ _).trans (RingHom.map_mul _ _ _)
commutes' := by rintro r ⟨x⟩; exact congr_arg (⟦·⟧) (Algebra.commutes r x) | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.algebra | The `R₁`-algebra structure on `A/I` for an `R₁`-algebra `A` |
Quotient.isScalarTower [SMul R₁ R₂] [IsScalarTower R₁ R₂ A] (I : Ideal A) :
IsScalarTower R₁ R₂ (A ⧸ I) := inferInstance | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.isScalarTower | null |
Quotient.mkₐ (I : Ideal A) [I.IsTwoSided] : A →ₐ[R₁] A ⧸ I :=
⟨⟨⟨⟨fun a => Submodule.Quotient.mk a, rfl⟩, fun _ _ => rfl⟩, rfl, fun _ _ => rfl⟩, fun _ => rfl⟩ | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.mkₐ | The canonical morphism `A →ₐ[R₁] A ⧸ I` as morphism of `R₁`-algebras, for `I` an ideal of
`A`, where `A` is an `R₁`-algebra. |
Quotient.algHom_ext {I : Ideal A} [I.IsTwoSided]
{S} [Semiring S] [Algebra R₁ S] ⦃f g : A ⧸ I →ₐ[R₁] S⦄
(h : f.comp (Quotient.mkₐ R₁ I) = g.comp (Quotient.mkₐ R₁ I)) : f = g :=
AlgHom.ext fun x => Quotient.inductionOn' x <| AlgHom.congr_fun h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.algHom_ext | null |
Quotient.alg_map_eq {A} [CommRing A] [Algebra R₁ A] (I : Ideal A) :
algebraMap R₁ (A ⧸ I) = (algebraMap A (A ⧸ I)).comp (algebraMap R₁ A) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.alg_map_eq | null |
Quotient.mkₐ_toRingHom (I : Ideal A) [I.IsTwoSided] :
(Quotient.mkₐ R₁ I).toRingHom = Ideal.Quotient.mk I :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.mkₐ_toRingHom | null |
Quotient.mkₐ_eq_mk (I : Ideal A) [I.IsTwoSided] : ⇑(Quotient.mkₐ R₁ I) = Quotient.mk I :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.mkₐ_eq_mk | null |
Quotient.algebraMap_eq {R} [CommRing R] (I : Ideal R) :
algebraMap R (R ⧸ I) = Quotient.mk I :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.algebraMap_eq | null |
Quotient.mk_comp_algebraMap (I : Ideal A) [I.IsTwoSided] :
(Quotient.mk I).comp (algebraMap R₁ A) = algebraMap R₁ (A ⧸ I) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.mk_comp_algebraMap | null |
Quotient.mk_algebraMap (I : Ideal A) [I.IsTwoSided] (x : R₁) :
Quotient.mk I (algebraMap R₁ A x) = algebraMap R₁ (A ⧸ I) x :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.mk_algebraMap | null |
Quotient.mkₐ_surjective (I : Ideal A) [I.IsTwoSided] :
Function.Surjective (Quotient.mkₐ R₁ I) :=
Quot.mk_surjective | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.mkₐ_surjective | The canonical morphism `A →ₐ[R₁] I.quotient` is surjective. |
@[simp]
Quotient.mkₐ_ker (I : Ideal A) [I.IsTwoSided] :
RingHom.ker (Quotient.mkₐ R₁ I : A →+* A ⧸ I) = I :=
Ideal.mk_ker | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.mkₐ_ker | The kernel of `A →ₐ[R₁] I.quotient` is `I`. |
Quotient.mk_bijective_iff_eq_bot (I : Ideal A) [I.IsTwoSided] :
Function.Bijective (mk I) ↔ I = ⊥ := by
constructor
· intro h
rw [← map_eq_bot_iff_of_injective h.1]
exact (map_eq_bot_iff_le_ker _).mpr <| le_of_eq mk_ker.symm
· exact fun h => ⟨(injective_iff_ker_eq_bot _).mpr <| by rw [mk_ker, h], mk_surjective⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.mk_bijective_iff_eq_bot | null |
Quotient.factorₐ {I J : Ideal A} [I.IsTwoSided] [J.IsTwoSided] (hIJ : I ≤ J) :
A ⧸ I →ₐ[R₁] A ⧸ J where
__ := Ideal.Quotient.factor hIJ
commutes' _ := rfl
variable {I J : Ideal A} [I.IsTwoSided] [J.IsTwoSided] (hIJ : I ≤ J)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.factorₐ | `AlgHom` version of `Ideal.Quotient.factor`. |
Quotient.coe_factorₐ :
(Ideal.Quotient.factorₐ R₁ hIJ : A ⧸ I →+* A ⧸ J) = Ideal.Quotient.factor hIJ := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.coe_factorₐ | null |
Quotient.factorₐ_apply_mk (x : A) :
Ideal.Quotient.factorₐ R₁ hIJ x = x := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.factorₐ_apply_mk | null |
Quotient.factorₐ_comp_mk :
(Ideal.Quotient.factorₐ R₁ hIJ).comp (Ideal.Quotient.mkₐ R₁ I) = Ideal.Quotient.mkₐ R₁ J := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.factorₐ_comp_mk | null |
Quotient.factorₐ_comp {K : Ideal A} [K.IsTwoSided] (hJK : J ≤ K) :
(Ideal.Quotient.factorₐ R₁ hJK).comp (Ideal.Quotient.factorₐ R₁ hIJ) =
Ideal.Quotient.factorₐ R₁ (hIJ.trans hJK) :=
Ideal.Quotient.algHom_ext _ (by ext; simp) | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.factorₐ_comp | null |
Quotient.liftₐ (I : Ideal A) [I.IsTwoSided] (f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) :
A ⧸ I →ₐ[R₁] B :=
{-- this is IsScalarTower.algebraMap_apply R₁ A (A ⧸ I) but the file `Algebra.Algebra.Tower`
Ideal.Quotient.lift
I (f : A →+* B) hI with
commutes' := fun r => by
have : algebraMap R₁ (A ⧸ I) r = Ideal.Quotient.mk I (algebraMap R₁ A r) := rfl
rw [this, RingHom.toFun_eq_coe, Ideal.Quotient.lift_mk,
AlgHom.coe_toRingHom, Algebra.algebraMap_eq_smul_one, Algebra.algebraMap_eq_smul_one,
map_smul, map_one] }
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.liftₐ | `Ideal.quotient.lift` as an `AlgHom`. |
Quotient.liftₐ_apply (I : Ideal A) [I.IsTwoSided]
(f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) (x) :
Ideal.Quotient.liftₐ I f hI x = Ideal.Quotient.lift I (f : A →+* B) hI x :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.liftₐ_apply | null |
Quotient.liftₐ_comp (I : Ideal A) [I.IsTwoSided]
(f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) :
(Ideal.Quotient.liftₐ I f hI).comp (Ideal.Quotient.mkₐ R₁ I) = f :=
AlgHom.ext fun _ => (Ideal.Quotient.lift_mk I (f : A →+* B) hI :) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.liftₐ_comp | null |
Quotient.span_singleton_one (I : Ideal A) [I.IsTwoSided] :
Submodule.span A {(1 : A ⧸ I)} = ⊤ := by
rw [← map_one (mk _), ← Submodule.range_mkQ I, ← Submodule.map_top, ← Ideal.span_singleton_one,
Ideal.span, Submodule.map_span, Set.image_singleton, Submodule.mkQ_apply, Quotient.mk_eq_mk]
open Pointwise in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Operations",
"Mathlib.Algebra.Ring.Fin",
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Ideal.Quotient.Basic"
] | Mathlib/RingTheory/Ideal/Quotient/Operations.lean | Quotient.span_singleton_one | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.