Congruence relations on rings

This file defines congruence relations on rings, which extend Con and AddCon on monoids and additive monoids.

Most of the time you likely want to use the Ideal.Quotient API that is built on top of this.

Main Definitions

• RingCon R: the type of congruence relations respecting + and *.
• RingConGen r: the inductively defined smallest ring congruence relation containing a given binary relation.

TODO

• Copy across more API from Con and AddCon in Mathlib/GroupTheory/Congruence/.

structure RingCon (R : Type u_1) [Add R] [Mul R] extends Con R, AddCon R : Type u_1

A congruence relation on a type with an addition and multiplication is an equivalence relation which preserves both.

• r : R → R → Prop
• iseqv : Equivalence ⇑self.toSetoid
• mul' {w x y z : R} : self.toSetoid w x → self.toSetoid y z → self.toSetoid (w * y) (x * z)
• add' {w x y z : R} : self.toSetoid w x → self.toSetoid y z → self.toSetoid (w + y) (x + z)

inductive RingConGen.Rel {R : Type u_1} [Add R] [Mul R] (r : R → R → Prop) : R → R → Prop

The inductively defined smallest ring congruence relation containing a given binary relation.

• of {R : Type u_1} [Add R] [Mul R] {r : R → R → Prop} (x y : R) : r x y → Rel r x y
• refl {R : Type u_1} [Add R] [Mul R] {r : R → R → Prop} (x : R) : Rel r x x
• symm {R : Type u_1} [Add R] [Mul R] {r : R → R → Prop} {x y : R} : Rel r x y → Rel r y x
• trans {R : Type u_1} [Add R] [Mul R] {r : R → R → Prop} {x y z : R} : Rel r x y → Rel r y z → Rel r x z
• add {R : Type u_1} [Add R] [Mul R] {r : R → R → Prop} {w x y z : R} : Rel r w x → Rel r y z → Rel r (w + y) (x + z)
• mul {R : Type u_1} [Add R] [Mul R] {r : R → R → Prop} {w x y z : R} : Rel r w x → Rel r y z → Rel r (w * y) (x * z)

def ringConGen {R : Type u_1} [Add R] [Mul R] (r : R → R → Prop) : RingCon R

The inductively defined smallest ring congruence relation containing a given binary relation.

theorem RingCon.toCon_injective {R : Type u_1} [Add R] [Mul R] : Function.Injective fun (c : RingCon R) => c.toCon

@[simp]

theorem RingCon.toCon_inj {R : Type u_1} [Add R] [Mul R] {c d : RingCon R} : c.toCon = d.toCon ↔ c = d

@[instance_reducible, macro_inline]

instance RingCon.instFunLikeForallProp {R : Type u_1} [Add R] [Mul R] : FunLike (RingCon R) R (R → Prop)

A coercion from a congruence relation to its underlying binary relation.

@[simp]

theorem RingCon.coe_mk {R : Type u_1} [Add R] [Mul R] (s : Con R) (h : ∀ {w x y z : R}, s.toSetoid w x → s.toSetoid y z → s.toSetoid (w + y) (x + z)) : ⇑{ toCon := s, add' := h } = ⇑s

theorem RingCon.rel_eq_coe {R : Type u_1} [Add R] [Mul R] (c : RingCon R) : ⇑c.toSetoid = ⇑c

@[simp]

theorem RingCon.toCon_coe_eq_coe {R : Type u_1} [Add R] [Mul R] (c : RingCon R) : ⇑c.toCon = ⇑c

theorem RingCon.refl {R : Type u_1} [Add R] [Mul R] (c : RingCon R) (x : R) : c x x

theorem RingCon.symm {R : Type u_1} [Add R] [Mul R] (c : RingCon R) {x y : R} : c x y → c y x

theorem RingCon.trans {R : Type u_1} [Add R] [Mul R] (c : RingCon R) {x y z : R} : c x y → c y z → c x z

theorem RingCon.add {R : Type u_1} [Add R] [Mul R] (c : RingCon R) {w x y z : R} : c w x → c y z → c (w + y) (x + z)

theorem RingCon.mul {R : Type u_1} [Add R] [Mul R] (c : RingCon R) {w x y z : R} : c w x → c y z → c (w * y) (x * z)

theorem RingCon.sub {S : Type u_2} [AddGroup S] [Mul S] (t : RingCon S) {a b c d : S} (h : t a b) (h' : t c d) : t (a - c) (b - d)

theorem RingCon.neg {S : Type u_2} [AddGroup S] [Mul S] (t : RingCon S) {a b : S} (h : t a b) : t (-a) (-b)

theorem RingCon.nsmul {S : Type u_2} [AddMonoid S] [Mul S] (t : RingCon S) (m : ℕ) {x y : S} (hx : t x y) : t (m • x) (m • y)

theorem RingCon.zsmul {S : Type u_2} [AddGroup S] [Mul S] (t : RingCon S) (z : ℤ) {x y : S} (hx : t x y) : t (z • x) (z • y)

@[instance_reducible]

instance RingCon.instInhabited {R : Type u_1} [Add R] [Mul R] : Inhabited (RingCon R)

@[simp]

theorem RingCon.rel_mk {R : Type u_1} [Add R] [Mul R] {s : Con R} {h : ∀ {w x y z : R}, s.toSetoid w x → s.toSetoid y z → s.toSetoid (w + y) (x + z)} {a b : R} : { toCon := s, add' := h } a b ↔ s a b

theorem RingCon.ext' {R : Type u_1} [Add R] [Mul R] {c d : RingCon R} (H : ⇑c = ⇑d) : c = d

The map sending a congruence relation to its underlying binary relation is injective.

theorem RingCon.ext {R : Type u_1} [Add R] [Mul R] {c d : RingCon R} (H : ∀ (x y : R), c x y ↔ d x y) : c = d

Extensionality rule for congruence relations.

theorem RingCon.ext_iff {R : Type u_1} [Add R] [Mul R] {c d : RingCon R} : c = d ↔ ∀ (x y : R), c x y ↔ d x y

theorem RingCon.ext'' {R : Type u_1} [Add R] [Mul R] {c d : RingCon R} (H : c.toSetoid = d.toSetoid) : c = d

The map sending a ring congruence relation to its underlying equivalence relation is injective.

theorem RingCon.coe_inj {R : Type u_1} [Add R] [Mul R] {c d : RingCon R} : ⇑c = ⇑d ↔ c = d

Two ring congruence relations are equal iff their underlying binary relations are equal.

def RingCon.comap {R : Type u_2} {R' : Type u_3} {F : Type u_4} [Add R] [Add R'] [FunLike F R R'] [AddHomClass F R R'] [Mul R] [Mul R'] [MulHomClass F R R'] (J : RingCon R') (f : F) : RingCon R

Pulling back a RingCon across a ring homomorphism.

@[simp]

theorem RingCon.comap_rel {R : Type u_2} {R' : Type u_3} {F : Type u_4} [Add R] [Add R'] [FunLike F R R'] [AddHomClass F R R'] [Mul R] [Mul R'] [MulHomClass F R R'] {J : RingCon R'} {f : F} {x y : R} : (J.comap f) x y ↔ J (f x) (f y)

@[simp]

theorem RingCon.comap_nonUnitalRingHomId {R : Type u_5} [NonUnitalNonAssocSemiring R] (J : RingCon R) : J.comap (NonUnitalRingHom.id R) = J

@[simp]

theorem RingCon.comap_nonUnitalRingHomComp {R : Type u_5} {R' : Type u_6} {R'' : Type u_7} [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring R'] [NonUnitalNonAssocSemiring R''] (J : RingCon R) (g : R' →ₙ+* R) (f : R'' →ₙ+* R') : J.comap (g.comp f) = (J.comap g).comap f

@[simp]

theorem RingCon.comap_ringHomId {R : Type u_5} [NonAssocSemiring R] (J : RingCon R) : J.comap (RingHom.id R) = J

@[simp]

theorem RingCon.comap_ringHomComp {R : Type u_5} {R' : Type u_6} {R'' : Type u_7} [NonAssocSemiring R] [NonAssocSemiring R'] [NonAssocSemiring R''] (J : RingCon R) (g : R' →+* R) (f : R'' →+* R') : J.comap (g.comp f) = (J.comap g).comap f

def RingCon.Quotient {R : Type u_1} [Add R] [Mul R] (c : RingCon R) : Type u_1

Defining the quotient by a congruence relation of a type with addition and multiplication.

def RingCon.toQuotient {R : Type u_1} [Add R] [Mul R] {c : RingCon R} (r : R) : c.Quotient

The morphism into the quotient by a congruence relation

@[instance_reducible]

instance RingCon.instCoeTCQuotient {R : Type u_1} [Add R] [Mul R] (c : RingCon R) : CoeTC R c.Quotient

Coercion from a type with addition and multiplication to its quotient by a congruence relation.

See Note [use has_coe_t].

@[instance_reducible, instance 500]

instance RingCon.instDecidableEqQuotientOfDecidableCoeForallProp {R : Type u_1} [Add R] [Mul R] (c : RingCon R) [_d : (a b : R) → Decidable (c a b)] : DecidableEq c.Quotient

The quotient by a decidable congruence relation has decidable equality.

@[simp]

theorem RingCon.quot_mk_eq_coe {R : Type u_1} [Add R] [Mul R] (c : RingCon R) (x : R) : Quot.mk (⇑c) x = ↑x

@[simp]

theorem RingCon.eq {R : Type u_1} [Add R] [Mul R] (c : RingCon R) {a b : R} : ↑a = ↑b ↔ c a b

Two elements are related by a congruence relation c iff they are represented by the same element of the quotient by c.

Basic notation

The basic algebraic notation, 0, 1, +, *, -, ^, descend naturally under the quotient

@[instance_reducible]

instance RingCon.instAddQuotient {R : Type u_1} [Add R] [Mul R] (c : RingCon R) : Add c.Quotient

@[simp]

theorem RingCon.coe_add {R : Type u_1} [Add R] [Mul R] (c : RingCon R) (x y : R) : ↑(x + y) = ↑x + ↑y

@[instance_reducible]

instance RingCon.instMulQuotient {R : Type u_1} [Add R] [Mul R] (c : RingCon R) : Mul c.Quotient

@[simp]

theorem RingCon.coe_mul {R : Type u_1} [Add R] [Mul R] (c : RingCon R) (x y : R) : ↑(x * y) = ↑x * ↑y

@[instance_reducible]

instance RingCon.instZeroQuotient {R : Type u_1} [AddZeroClass R] [Mul R] (c : RingCon R) : Zero c.Quotient

@[simp]

theorem RingCon.coe_zero {R : Type u_1} [AddZeroClass R] [Mul R] (c : RingCon R) : ↑0 = 0

@[instance_reducible]

instance RingCon.instOneQuotient {R : Type u_1} [Add R] [MulOneClass R] (c : RingCon R) : One c.Quotient

@[simp]

theorem RingCon.coe_one {R : Type u_1} [Add R] [MulOneClass R] (c : RingCon R) : ↑1 = 1

def RingCon.smulAux {R : Type u_1} [Add R] [Mul R] {α : Type u_2} [SMul α R] (c : RingCon R) (h : ∀ (a : α) (x y : R), c x y → c (a • x) (a • y)) (a : α) (x : c.Quotient) : c.Quotient

A function used to define scalar actions on RingCon.Quotient. To make sure such actions coming from different sources are reducibly defeq, they should all go through this function.

@[instance_reducible]

instance RingCon.instNegQuotient {R : Type u_1} [AddGroup R] [Mul R] (c : RingCon R) : Neg c.Quotient

@[simp]

theorem RingCon.coe_neg {R : Type u_1} [AddGroup R] [Mul R] (c : RingCon R) (x : R) : ↑(-x) = -↑x

@[instance_reducible]

instance RingCon.instSubQuotient {R : Type u_1} [AddGroup R] [Mul R] (c : RingCon R) : Sub c.Quotient

@[simp]

theorem RingCon.coe_sub {R : Type u_1} [AddGroup R] [Mul R] (c : RingCon R) (x y : R) : ↑(x - y) = ↑x - ↑y

@[instance_reducible]

instance RingCon.hasZSMul {R : Type u_1} [AddGroup R] [Mul R] (c : RingCon R) : SMul ℤ c.Quotient

@[simp]

theorem RingCon.coe_zsmul {R : Type u_1} [AddGroup R] [Mul R] (c : RingCon R) (z : ℤ) (x : R) : ↑(z • x) = z • ↑x

@[instance_reducible]

instance RingCon.hasNSMul {R : Type u_1} [AddMonoid R] [Mul R] (c : RingCon R) : SMul ℕ c.Quotient

@[simp]

theorem RingCon.coe_nsmul {R : Type u_1} [AddMonoid R] [Mul R] (c : RingCon R) (n : ℕ) (x : R) : ↑(n • x) = n • ↑x

@[instance_reducible]

instance RingCon.instPowQuotientNat {R : Type u_1} [Add R] [Monoid R] (c : RingCon R) : Pow c.Quotient ℕ

@[simp]

theorem RingCon.coe_pow {R : Type u_1} [Add R] [Monoid R] (c : RingCon R) (x : R) (n : ℕ) : ↑(x ^ n) = ↑x ^ n

@[instance_reducible]

instance RingCon.instNatCastQuotient {R : Type u_1} [AddMonoidWithOne R] [Mul R] (c : RingCon R) : NatCast c.Quotient

@[simp]

theorem RingCon.coe_natCast {R : Type u_1} [AddMonoidWithOne R] [Mul R] (c : RingCon R) (n : ℕ) : ↑↑n = ↑n

@[instance_reducible]

instance RingCon.instIntCastQuotient {R : Type u_1} [AddGroupWithOne R] [Mul R] (c : RingCon R) : IntCast c.Quotient

@[simp]

theorem RingCon.coe_intCast {R : Type u_1} [AddGroupWithOne R] [Mul R] (c : RingCon R) (n : ℕ) : ↑↑n = ↑n

@[instance_reducible]

instance RingCon.instInhabitedQuotient {R : Type u_1} [Inhabited R] [Add R] [Mul R] (c : RingCon R) : Inhabited c.Quotient

Algebraic structure

The operations above on the quotient by c : RingCon R preserve the algebraic structure of R.

@[instance_reducible]

instance RingCon.instAddZeroClassQuotient {R : Type u_1} [AddZeroClass R] [Mul R] (c : RingCon R) : AddZeroClass c.Quotient

@[instance_reducible]

instance RingCon.instAddSemigroupQuotient {R : Type u_1} [AddSemigroup R] [Mul R] (c : RingCon R) : AddSemigroup c.Quotient

@[instance_reducible]

instance RingCon.instAddCommMagmaQuotient {R : Type u_1} [AddCommMagma R] [Mul R] (c : RingCon R) : AddCommMagma c.Quotient

@[instance_reducible]

instance RingCon.instAddCommSemigroupQuotient {R : Type u_1} [AddCommSemigroup R] [Mul R] (c : RingCon R) : AddCommSemigroup c.Quotient

@[instance_reducible]

instance RingCon.instAddMonoidQuotient {R : Type u_1} [AddMonoid R] [Mul R] (c : RingCon R) : AddMonoid c.Quotient

@[instance_reducible]

instance RingCon.instAddCommMonoidQuotient {R : Type u_1} [AddCommMonoid R] [Mul R] (c : RingCon R) : AddCommMonoid c.Quotient

@[instance_reducible]

instance RingCon.instAddGroupQuotient {R : Type u_1} [AddGroup R] [Mul R] (c : RingCon R) : AddGroup c.Quotient

@[instance_reducible]

instance RingCon.instAddCommGroupQuotient {R : Type u_1} [AddCommGroup R] [Mul R] (c : RingCon R) : AddCommGroup c.Quotient

@[instance_reducible]

instance RingCon.instMulOneClassQuotient {R : Type u_1} [Add R] [MulOneClass R] (c : RingCon R) : MulOneClass c.Quotient

@[instance_reducible]

instance RingCon.instSemigroupQuotient {R : Type u_1} [Add R] [Semigroup R] (c : RingCon R) : Semigroup c.Quotient

@[instance_reducible]

instance RingCon.instCommMagmaQuotient {R : Type u_1} [Add R] [CommMagma R] (c : RingCon R) : CommMagma c.Quotient

@[instance_reducible]

instance RingCon.instCommSemigroupQuotient {R : Type u_1} [Add R] [CommSemigroup R] (c : RingCon R) : CommSemigroup c.Quotient

@[instance_reducible]

instance RingCon.instMonoidQuotient {R : Type u_1} [Add R] [Monoid R] (c : RingCon R) : Monoid c.Quotient

@[instance_reducible]

instance RingCon.instCommMonoidQuotient {R : Type u_1} [Add R] [CommMonoid R] (c : RingCon R) : CommMonoid c.Quotient

@[instance_reducible]

instance RingCon.instNonUnitalNonAssocSemiringQuotient {R : Type u_1} [NonUnitalNonAssocSemiring R] (c : RingCon R) : NonUnitalNonAssocSemiring c.Quotient

@[instance_reducible]

instance RingCon.instNonUnitalNonAssocCommSemiringQuotient {R : Type u_1} [NonUnitalNonAssocCommSemiring R] (c : RingCon R) : NonUnitalNonAssocCommSemiring c.Quotient

@[instance_reducible]

instance RingCon.instNonAssocSemiringQuotient {R : Type u_1} [NonAssocSemiring R] (c : RingCon R) : NonAssocSemiring c.Quotient

@[instance_reducible]

instance RingCon.instNonAssocCommSemiringQuotient {R : Type u_1} [NonAssocCommSemiring R] (c : RingCon R) : NonAssocCommSemiring c.Quotient

@[instance_reducible]

instance RingCon.instNonUnitalSemiringQuotient {R : Type u_1} [NonUnitalSemiring R] (c : RingCon R) : NonUnitalSemiring c.Quotient

@[instance_reducible]

instance RingCon.instNonUnitalCommSemiringQuotient {R : Type u_1} [NonUnitalCommSemiring R] (c : RingCon R) : NonUnitalCommSemiring c.Quotient

@[instance_reducible]

instance RingCon.instSemiringQuotient {R : Type u_1} [Semiring R] (c : RingCon R) : Semiring c.Quotient

@[instance_reducible]

instance RingCon.instCommSemiringQuotient {R : Type u_1} [CommSemiring R] (c : RingCon R) : CommSemiring c.Quotient

@[instance_reducible]

instance RingCon.instNonUnitalNonAssocRingQuotient {R : Type u_1} [NonUnitalNonAssocRing R] (c : RingCon R) : NonUnitalNonAssocRing c.Quotient

@[instance_reducible]

instance RingCon.instNonUnitalNonAssocCommRingQuotient {R : Type u_1} [NonUnitalNonAssocCommRing R] (c : RingCon R) : NonUnitalNonAssocCommRing c.Quotient

@[instance_reducible]

instance RingCon.instNonAssocRingQuotient {R : Type u_1} [NonAssocRing R] (c : RingCon R) : NonAssocRing c.Quotient

@[instance_reducible]

instance RingCon.instNonAssocCommRingQuotient {R : Type u_1} [NonAssocCommRing R] (c : RingCon R) : NonAssocCommRing c.Quotient

@[instance_reducible]

instance RingCon.instNonUnitalRingQuotient {R : Type u_1} [NonUnitalRing R] (c : RingCon R) : NonUnitalRing c.Quotient

@[instance_reducible]

instance RingCon.instNonUnitalCommRingQuotient {R : Type u_1} [NonUnitalCommRing R] (c : RingCon R) : NonUnitalCommRing c.Quotient

@[instance_reducible]

instance RingCon.instRingQuotient {R : Type u_1} [Ring R] (c : RingCon R) : Ring c.Quotient

@[instance_reducible]

instance RingCon.instCommRingQuotient {R : Type u_1} [CommRing R] (c : RingCon R) : CommRing c.Quotient

def RingCon.mk' {R : Type u_1} [NonAssocSemiring R] (c : RingCon R) : R →+* c.Quotient

The natural homomorphism from a ring to its quotient by a ring congruence relation.

theorem RingCon.mk'_surjective {R : Type u_1} [NonAssocSemiring R] (c : RingCon R) : Function.Surjective ⇑c.mk'

@[simp]

theorem RingCon.coe_mk' {R : Type u_1} [NonAssocSemiring R] (c : RingCon R) : ⇑c.mk' = toQuotient