File: Mathlib/RingTheory/Ideal/Quotient.lean

full_name: Ideal.instHasQuotient
code: /-- The quotient `R/I` of a ring `R` by an ideal `I`.

The ideal quotient of `I` is defined to equal the quotient of `I` as an `R`-submodule of `R`.
This definition uses `abbrev` so that typeclass instances can be shared between
`Ideal.Quotient I` and `Submodule.Quotient I`.
-/
@[instance] abbrev instHasQuotient : HasQuotient R (Ideal R) 
goal: HasQuotient R (Ideal R)

full_name: Ideal.Quotient.one
code: instance one (I : Ideal R) : One (R ⧸ I) 
goal: One (R ⧸ I)

full_name: Ideal.Quotient.ringCon
code: /-- On `Ideal`s, `Submodule.quotientRel` is a ring congruence. -/
protected def ringCon (I : Ideal R) : RingCon R 
goal: RingCon R

full_name: Ideal.Quotient.commRing
code: instance commRing (I : Ideal R) : CommRing (R ⧸ I) 
goal: CommRing (R ⧸ I)

full_name: Ideal.Quotient.isScalarTower_right
code: instance (priority := 100) isScalarTower_right {α} [SMul α R] [IsScalarTower α R R] :
    IsScalarTower α (R ⧸ I) (R ⧸ I) 
goal: IsScalarTower α (R ⧸ I) (R ⧸ I)

full_name: Ideal.Quotient.smulCommClass
code: instance smulCommClass {α} [SMul α R] [IsScalarTower α R R] [SMulCommClass α R R] :
    SMulCommClass α (R ⧸ I) (R ⧸ I) 
goal: SMulCommClass α (R ⧸ I) (R ⧸ I)

full_name: Ideal.Quotient.smulCommClass'
code: instance smulCommClass' {α} [SMul α R] [IsScalarTower α R R] [SMulCommClass R α R] :
    SMulCommClass (R ⧸ I) α (R ⧸ I) 
goal: SMulCommClass (R ⧸ I) α (R ⧸ I)

full_name: Ideal.Quotient.mk
code: /-- The ring homomorphism from a ring `R` to a quotient ring `R/I`. -/
def mk (I : Ideal R) : R →+* R ⧸ I 
goal: R →+* R ⧸ I

full_name: Ideal.Quotient.instCoeQuotient
code: instance {I : Ideal R} : Coe R (R ⧸ I) 
goal: Coe R (R ⧸ I)

full_name: Ideal.Quotient.ringHom_ext
code: /-- 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]. -/
@[ext 1100]
theorem ringHom_ext [NonAssocSemiring S] ⦃f g : R ⧸ I →+* S⦄ (h : f.comp (mk I) = g.comp (mk I)) :
    f = g 
goal: f = g

full_name: Ideal.Quotient.inhabited
code: instance inhabited : Inhabited (R ⧸ I) 
goal: Inhabited (R ⧸ I)

full_name: Ideal.Quotient.eq
code: protected theorem eq : mk I x = mk I y ↔ x - y ∈ I 
goal: (Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y ↔ x - y ∈ I

full_name: Ideal.Quotient.mk_eq_mk
code: @[simp]
theorem mk_eq_mk (x : R) : (Submodule.Quotient.mk x : R ⧸ I) = mk I x 
goal: Submodule.Quotient.mk x = (Ideal.Quotient.mk I) x

full_name: Ideal.Quotient.eq_zero_iff_mem
code: theorem eq_zero_iff_mem {I : Ideal R} : mk I a = 0 ↔ a ∈ I 
goal: (Ideal.Quotient.mk I) a = 0 ↔ a ∈ I

full_name: Ideal.Quotient.eq_zero_iff_dvd
code: theorem eq_zero_iff_dvd (x y : R) : Ideal.Quotient.mk (Ideal.span ({x} : Set R)) y = 0 ↔ x ∣ y 
goal: (Ideal.Quotient.mk (Ideal.span {x})) y = 0 ↔ x ∣ y

full_name: Ideal.Quotient.mk_singleton_self
code: @[simp]
lemma mk_singleton_self (x : R) : mk (Ideal.span {x}) x = 0 
goal: (Ideal.Quotient.mk (Ideal.span {x})) x = 0

full_name: Ideal.Quotient.mk_eq_mk_iff_sub_mem
code: theorem mk_eq_mk_iff_sub_mem (x y : R) : mk I x = mk I y ↔ x - y ∈ I 
goal: (Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y ↔ x - y ∈ I

full_name: Ideal.Quotient.zero_eq_one_iff
code: theorem zero_eq_one_iff {I : Ideal R} : (0 : R ⧸ I) = 1 ↔ I = ⊤ 
goal: 0 = 1 ↔ I = ⊤

full_name: Ideal.Quotient.zero_ne_one_iff
code: theorem zero_ne_one_iff {I : Ideal R} : (0 : R ⧸ I) ≠ 1 ↔ I ≠ ⊤ 
goal: 0 ≠ 1 ↔ I ≠ ⊤

full_name: Ideal.Quotient.nontrivial
code: protected theorem nontrivial {I : Ideal R} (hI : I ≠ ⊤) : Nontrivial (R ⧸ I) 
goal: Nontrivial (R ⧸ I)

full_name: Ideal.Quotient.subsingleton_iff
code: theorem subsingleton_iff {I : Ideal R} : Subsingleton (R ⧸ I) ↔ I = ⊤ 
goal: Subsingleton (R ⧸ I) ↔ I = ⊤

full_name: Ideal.Quotient.instUniqueQuotientTop
code: instance : Unique (R ⧸ (⊤ : Ideal R)) 
goal: Unique (R ⧸ ⊤)

full_name: Ideal.Quotient.mk_surjective
code: theorem mk_surjective : Function.Surjective (mk I) 
goal: Function.Surjective ⇑(Ideal.Quotient.mk I)

full_name: Ideal.Quotient.instRingHomSurjectiveQuotientMk
code: instance : RingHomSurjective (mk I) 
goal: RingHomSurjective (Ideal.Quotient.mk I)

full_name: Ideal.Quotient.quotient_ring_saturate
code: /-- 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`. -/
theorem quotient_ring_saturate (I : Ideal R) (s : Set R) :
    mk I ⁻¹' (mk I '' s) = ⋃ x : I, (fun y => x.1 + y) '' s 
goal: ⇑(Ideal.Quotient.mk I) ⁻¹' (⇑(Ideal.Quotient.mk I) '' s) = ⋃ x, (fun y => ↑x + y) '' s

full_name: Ideal.Quotient.noZeroDivisors
code: instance noZeroDivisors (I : Ideal R) [hI : I.IsPrime] : NoZeroDivisors (R ⧸ I) 
goal: NoZeroDivisors (R ⧸ I)

full_name: Ideal.Quotient.isDomain
code: instance isDomain (I : Ideal R) [hI : I.IsPrime] : IsDomain (R ⧸ I) 
goal: IsDomain (R ⧸ I)

full_name: Ideal.Quotient.isDomain_iff_prime
code: theorem isDomain_iff_prime (I : Ideal R) : IsDomain (R ⧸ I) ↔ I.IsPrime 
goal: IsDomain (R ⧸ I) ↔ I.IsPrime

full_name: Ideal.Quotient.exists_inv
code: theorem exists_inv {I : Ideal R} [hI : I.IsMaximal] :
    ∀ {a : R ⧸ I}, a ≠ 0 → ∃ b : R ⧸ I, a * b = 1 
goal: a ≠ 0 → ∃ b, a * b = 1

full_name: Ideal.Quotient.groupWithZero
code: /-- The quotient by a maximal ideal is a group with zero. This is a `def` rather than `instance`,
since users will have computable inverses in some applications.

See note [reducible non-instances]. -/
protected noncomputable abbrev groupWithZero (I : Ideal R) [hI : I.IsMaximal] :
    GroupWithZero (R ⧸ I) 
goal: GroupWithZero (R ⧸ I)

full_name: Ideal.Quotient.field
code: /-- The quotient by a maximal ideal is a field. This is a `def` rather than `instance`, since users
will have computable inverses (and `qsmul`, `ratCast`) in some applications.

See note [reducible non-instances]. -/
protected noncomputable abbrev field (I : Ideal R) [hI : I.IsMaximal] : Field (R ⧸ I) 
goal: Field (R ⧸ I)

full_name: Ideal.Quotient.maximal_of_isField
code: /-- If the quotient by an ideal is a field, then the ideal is maximal. -/
theorem maximal_of_isField (I : Ideal R) (hqf : IsField (R ⧸ I)) : I.IsMaximal 
goal: I.IsMaximal

full_name: Ideal.Quotient.maximal_ideal_iff_isField_quotient
code: /-- The quotient of a ring by an ideal is a field iff the ideal is maximal. -/
theorem maximal_ideal_iff_isField_quotient (I : Ideal R) : I.IsMaximal ↔ IsField (R ⧸ I) 
goal: I.IsMaximal ↔ IsField (R ⧸ I)

full_name: Ideal.Quotient.lift
code: /-- Given a ring homomorphism `f : R →+* S` sending all elements of an ideal to zero,
lift it to the quotient by this ideal. -/
def lift (I : Ideal R) (f : R →+* S) (H : ∀ a : R, a ∈ I → f a = 0) : R ⧸ I →+* S 
goal: R ⧸ I →+* S

full_name: Ideal.Quotient.lift_mk
code: @[simp]
theorem lift_mk (I : Ideal R) (f : R →+* S) (H : ∀ a : R, a ∈ I → f a = 0) :
    lift I f H (mk I a) = f a 
goal: (Ideal.Quotient.lift I f H) ((Ideal.Quotient.mk I) a) = f a

full_name: Ideal.Quotient.lift_surjective_of_surjective
code: theorem lift_surjective_of_surjective (I : Ideal R) {f : R →+* S} (H : ∀ a : R, a ∈ I → f a = 0)
    (hf : Function.Surjective f) : Function.Surjective (Ideal.Quotient.lift I f H) 
goal: Function.Surjective ⇑(Ideal.Quotient.lift I f H)

full_name: Ideal.Quotient.factor
code: /-- 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` -/
def factor (S T : Ideal R) (H : S ≤ T) : R ⧸ S →+* R ⧸ T 
goal: R ⧸ S →+* R ⧸ T

full_name: Ideal.Quotient.factor_mk
code: @[simp]
theorem factor_mk (S T : Ideal R) (H : S ≤ T) (x : R) : factor S T H (mk S x) = mk T x 
goal: (Ideal.Quotient.factor S T H) ((Ideal.Quotient.mk S) x) = (Ideal.Quotient.mk T) x

full_name: Ideal.Quotient.factor_comp_mk
code: @[simp]
theorem factor_comp_mk (S T : Ideal R) (H : S ≤ T) : (factor S T H).comp (mk S) = mk T 
goal: (Ideal.Quotient.factor S T H).comp (Ideal.Quotient.mk S) = Ideal.Quotient.mk T

full_name: Ideal.quotEquivOfEq
code: /-- Quotienting by equal ideals gives equivalent rings.

See also `Submodule.quotEquivOfEq` and `Ideal.quotientEquivAlgOfEq`.
-/
def quotEquivOfEq {R : Type*} [CommRing R] {I J : Ideal R} (h : I = J) : R ⧸ I ≃+* R ⧸ J 
goal: R ⧸ I ≃+* R ⧸ J

full_name: Ideal.quotEquivOfEq_mk
code: @[simp]
theorem quotEquivOfEq_mk {R : Type*} [CommRing R] {I J : Ideal R} (h : I = J) (x : R) :
    quotEquivOfEq h (Ideal.Quotient.mk I x) = Ideal.Quotient.mk J x 
goal: (Ideal.quotEquivOfEq h) ((Ideal.Quotient.mk I) x) = (Ideal.Quotient.mk J) x

full_name: Ideal.quotEquivOfEq_symm
code: @[simp]
theorem quotEquivOfEq_symm {R : Type*} [CommRing R] {I J : Ideal R} (h : I = J) :
    (Ideal.quotEquivOfEq h).symm = Ideal.quotEquivOfEq h.symm 
goal: (Ideal.quotEquivOfEq h).symm = Ideal.quotEquivOfEq ⋯

full_name: Ideal.modulePi
code: /-- `R^n/I^n` is a `R/I`-module. -/
instance modulePi : Module (R ⧸ I) ((ι → R) ⧸ I.pi ι) 
goal: Module (R ⧸ I) ((ι → R) ⧸ I.pi ι)

full_name: Ideal.piQuotEquiv
code: /-- `R^n/I^n` is isomorphic to `(R/I)^n` as an `R/I`-module. -/
noncomputable def piQuotEquiv : ((ι → R) ⧸ I.pi ι) ≃ₗ[R ⧸ I] ι → (R ⧸ I) 
goal: ((ι → R) ⧸ I.pi ι) ≃ₗ[R ⧸ I] ι → R ⧸ I

full_name: Ideal.map_pi
code: /-- If `f : R^n → R^m` is an `R`-linear map and `I ⊆ R` is an ideal, then the image of `I^n` is
    contained in `I^m`. -/
theorem map_pi {ι : Type*} [Finite ι] {ι' : Type w} (x : ι → R) (hi : ∀ i, x i ∈ I)
    (f : (ι → R) →ₗ[R] ι' → R) (i : ι') : f x i ∈ I 
goal: f x i ∈ I