File: Mathlib/RingTheory/Congruence/Basic.lean

full_name: RingCon
code: /-- A congruence relation on a type with an addition and multiplication is an equivalence relation
which preserves both. -/
structure RingCon (R : Type*) [Add R] [Mul R] extends Con R, AddCon R where
goal: Type u_1

full_name: RingConGen.Rel.of
code: /-- The inductively defined smallest ring congruence relation containing a given binary
    relation. -/
inductive RingConGen.Rel [Add R] [Mul R] (r : R → R → Prop) : R → R → Prop
  | of : ∀ x y, r x y → RingConGen.Rel r x y
  | refl : ∀ x, RingConGen.Rel r x x
  | symm : ∀ {x y}, RingConGen.Rel r x y → RingConGen.Rel r y x
  | trans : ∀ {x y z}, RingConGen.Rel r x y → RingConGen.Rel r y z → RingConGen.Rel r x z
  | add : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w + y) (x + z)
  | mul : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w * y) (x * z)
goal: r x y → RingConGen.Rel r x y

full_name: RingConGen.Rel.trans
code: /-- The inductively defined smallest ring congruence relation containing a given binary
    relation. -/
inductive RingConGen.Rel [Add R] [Mul R] (r : R → R → Prop) : R → R → Prop
  | of : ∀ x y, r x y → RingConGen.Rel r x y
  | refl : ∀ x, RingConGen.Rel r x x
  | symm : ∀ {x y}, RingConGen.Rel r x y → RingConGen.Rel r y x
  | trans : ∀ {x y z}, RingConGen.Rel r x y → RingConGen.Rel r y z → RingConGen.Rel r x z
  | add : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w + y) (x + z)
  | mul : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w * y) (x * z)
goal: RingConGen.Rel r x y → RingConGen.Rel r y z → RingConGen.Rel r x z

full_name: RingConGen.Rel.refl
code: /-- The inductively defined smallest ring congruence relation containing a given binary
    relation. -/
inductive RingConGen.Rel [Add R] [Mul R] (r : R → R → Prop) : R → R → Prop
  | of : ∀ x y, r x y → RingConGen.Rel r x y
  | refl : ∀ x, RingConGen.Rel r x x
  | symm : ∀ {x y}, RingConGen.Rel r x y → RingConGen.Rel r y x
  | trans : ∀ {x y z}, RingConGen.Rel r x y → RingConGen.Rel r y z → RingConGen.Rel r x z
  | add : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w + y) (x + z)
  | mul : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w * y) (x * z)
goal: RingConGen.Rel r x x

full_name: RingConGen.Rel
code: /-- The inductively defined smallest ring congruence relation containing a given binary
    relation. -/
inductive RingConGen.Rel [Add R] [Mul R] (r : R → R → Prop) : R → R → Prop
  | of : ∀ x y, r x y → RingConGen.Rel r x y
  | refl : ∀ x, RingConGen.Rel r x x
  | symm : ∀ {x y}, RingConGen.Rel r x y → RingConGen.Rel r y x
  | trans : ∀ {x y z}, RingConGen.Rel r x y → RingConGen.Rel r y z → RingConGen.Rel r x z
  | add : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w + y) (x + z)
  | mul : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w * y) (x * z)
goal: R → R → Prop

full_name: RingConGen.Rel.add
code: /-- The inductively defined smallest ring congruence relation containing a given binary
    relation. -/
inductive RingConGen.Rel [Add R] [Mul R] (r : R → R → Prop) : R → R → Prop
  | of : ∀ x y, r x y → RingConGen.Rel r x y
  | refl : ∀ x, RingConGen.Rel r x x
  | symm : ∀ {x y}, RingConGen.Rel r x y → RingConGen.Rel r y x
  | trans : ∀ {x y z}, RingConGen.Rel r x y → RingConGen.Rel r y z → RingConGen.Rel r x z
  | add : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w + y) (x + z)
  | mul : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w * y) (x * z)
goal: RingConGen.Rel r w x → RingConGen.Rel r y z → RingConGen.Rel r (w + y) (x + z)

full_name: RingConGen.Rel.mul
code: /-- The inductively defined smallest ring congruence relation containing a given binary
    relation. -/
inductive RingConGen.Rel [Add R] [Mul R] (r : R → R → Prop) : R → R → Prop
  | of : ∀ x y, r x y → RingConGen.Rel r x y
  | refl : ∀ x, RingConGen.Rel r x x
  | symm : ∀ {x y}, RingConGen.Rel r x y → RingConGen.Rel r y x
  | trans : ∀ {x y z}, RingConGen.Rel r x y → RingConGen.Rel r y z → RingConGen.Rel r x z
  | add : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w + y) (x + z)
  | mul : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w * y) (x * z)
goal: RingConGen.Rel r w x → RingConGen.Rel r y z → RingConGen.Rel r (w * y) (x * z)

full_name: RingConGen.Rel.symm
code: /-- The inductively defined smallest ring congruence relation containing a given binary
    relation. -/
inductive RingConGen.Rel [Add R] [Mul R] (r : R → R → Prop) : R → R → Prop
  | of : ∀ x y, r x y → RingConGen.Rel r x y
  | refl : ∀ x, RingConGen.Rel r x x
  | symm : ∀ {x y}, RingConGen.Rel r x y → RingConGen.Rel r y x
  | trans : ∀ {x y z}, RingConGen.Rel r x y → RingConGen.Rel r y z → RingConGen.Rel r x z
  | add : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w + y) (x + z)
  | mul : ∀ {w x y z}, RingConGen.Rel r w x → RingConGen.Rel r y z →
      RingConGen.Rel r (w * y) (x * z)
goal: RingConGen.Rel r x y → RingConGen.Rel r y x

full_name: ringConGen
code: /-- The inductively defined smallest ring congruence relation containing a given binary
    relation. -/
def ringConGen [Add R] [Mul R] (r : R → R → Prop) : RingCon R 
goal: RingCon R

full_name: RingCon.instFunLikeForallProp
code: /-- A coercion from a congruence relation to its underlying binary relation. -/
instance : FunLike (RingCon R) R (R → Prop) 
goal: FunLike (RingCon R) R (R → Prop)

full_name: RingCon.rel_eq_coe
code: theorem rel_eq_coe : c.r = c 
goal: Setoid.r = ⇑c

full_name: RingCon.toCon_coe_eq_coe
code: @[simp]
theorem toCon_coe_eq_coe : (c.toCon : R → R → Prop) = c 
goal: ⇑c.toCon = ⇑c

full_name: RingCon.refl
code: protected theorem refl (x) : c x x 
goal: c x x

full_name: RingCon.symm
code: protected theorem symm {x y} : c x y → c y x 
goal: c x y → c y x

full_name: RingCon.trans
code: protected theorem trans {x y z} : c x y → c y z → c x z 
goal: c x y → c y z → c x z

full_name: RingCon.add
code: protected theorem add {w x y z} : c w x → c y z → c (w + y) (x + z) 
goal: c w x → c y z → c (w + y) (x + z)

full_name: RingCon.mul
code: protected theorem mul {w x y z} : c w x → c y z → c (w * y) (x * z) 
goal: c w x → c y z → c (w * y) (x * z)

full_name: RingCon.sub
code: protected theorem sub {S : Type*} [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) 
goal: t (a - c) (b - d)

full_name: RingCon.neg
code: protected theorem neg {S : Type*} [AddGroup S] [Mul S] (t : RingCon S)
    {a b} (h : t a b) : t (-a) (-b) 
goal: t (-a) (-b)

full_name: RingCon.nsmul
code: protected theorem nsmul {S : Type*} [AddGroup S] [Mul S] (t : RingCon S)
    (m : ℕ) {x y : S} (hx : t x y) : t (m • x) (m • y) 
goal: t (m • x) (m • y)

full_name: RingCon.zsmul
code: protected theorem zsmul {S : Type*} [AddGroup S] [Mul S] (t : RingCon S)
    (z : ℤ) {x y : S} (hx : t x y) : t (z • x) (z • y) 
goal: t (z • x) (z • y)

full_name: RingCon.instInhabited
code: instance : Inhabited (RingCon R) 
goal: Inhabited (RingCon R)

full_name: RingCon.rel_mk
code: @[simp]
theorem rel_mk {s : Con R} {h a b} : RingCon.mk s h a b ↔ s a b 
goal: { toCon := s, add' := h } a b ↔ s a b

full_name: RingCon.ext'
code: /-- The map sending a congruence relation to its underlying binary relation is injective. -/
theorem ext' {c d : RingCon R} (H : ⇑c = ⇑d) : c = d 
goal: c = d

full_name: RingCon.ext
code: /-- Extensionality rule for congruence relations. -/
theorem ext {c d : RingCon R} (H : ∀ x y, c x y ↔ d x y) : c = d 
goal: c = d

full_name: RingCon.Quotient
code: /-- Defining the quotient by a congruence relation of a type with addition and multiplication. -/
protected def Quotient 
goal: Type u_2

full_name: RingCon.toQuotient
code: /-- The morphism into the quotient by a congruence relation -/
@[coe] def toQuotient (r : R) : c.Quotient 
goal: c.Quotient

full_name: RingCon.instCoeTCQuotient
code: /-- Coercion from a type with addition and multiplication to its quotient by a congruence relation.

See Note [use has_coe_t]. -/
instance : CoeTC R c.Quotient 
goal: CoeTC R c.Quotient

full_name: RingCon.instDecidableEqQuotientOfDecidableCoeForallProp
code: /-- The quotient by a decidable congruence relation has decidable equality. -/
instance (priority := 500) [_d : ∀ a b, Decidable (c a b)] : DecidableEq c.Quotient 
goal: DecidableEq c.Quotient

full_name: RingCon.quot_mk_eq_coe
code: @[simp]
theorem quot_mk_eq_coe (x : R) : Quot.mk c x = (x : c.Quotient) 
goal: Quot.mk (⇑c) x = ↑x

full_name: RingCon.eq
code: /-- Two elements are related by a congruence relation `c` iff they are represented by the same
element of the quotient by `c`. -/
@[simp]
protected theorem eq {a b : R} : (a : c.Quotient) = (b : c.Quotient) ↔ c a b 
goal: ↑a = ↑b ↔ c a b

full_name: RingCon.instAddQuotient
code: instance : Add c.Quotient 
goal: Add c.Quotient

full_name: RingCon.coe_add
code: @[simp, norm_cast]
theorem coe_add (x y : R) : (↑(x + y) : c.Quotient) = ↑x + ↑y 
goal: ↑(x + y) = ↑x + ↑y

full_name: RingCon.instMulQuotient
code: instance : Mul c.Quotient 
goal: Mul c.Quotient

full_name: RingCon.coe_mul
code: @[simp, norm_cast]
theorem coe_mul (x y : R) : (↑(x * y) : c.Quotient) = ↑x * ↑y 
goal: ↑(x * y) = ↑x * ↑y

full_name: RingCon.instZeroQuotient
code: instance : Zero c.Quotient 
goal: Zero c.Quotient

full_name: RingCon.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : (↑(0 : R) : c.Quotient) = 0 
goal: ↑0 = 0

full_name: RingCon.instOneQuotient
code: instance : One c.Quotient 
goal: One c.Quotient

full_name: RingCon.coe_one
code: @[simp, norm_cast]
theorem coe_one : (↑(1 : R) : c.Quotient) = 1 
goal: ↑1 = 1

full_name: RingCon.instSMulQuotient
code: instance : SMul α c.Quotient 
goal: SMul α c.Quotient

full_name: RingCon.coe_smul
code: @[simp, norm_cast]
theorem coe_smul (a : α) (x : R) : (↑(a • x) : c.Quotient) = a • (x : c.Quotient) 
goal: ↑(a • x) = a • ↑x

full_name: RingCon.instNegQuotient
code: instance : Neg c.Quotient 
goal: Neg c.Quotient

full_name: RingCon.coe_neg
code: @[simp, norm_cast]
theorem coe_neg (x : R) : (↑(-x) : c.Quotient) = -x 
goal: ↑(-x) = -↑x

full_name: RingCon.instSubQuotient
code: instance : Sub c.Quotient 
goal: Sub c.Quotient

full_name: RingCon.coe_sub
code: @[simp, norm_cast]
theorem coe_sub (x y : R) : (↑(x - y) : c.Quotient) = x - y 
goal: ↑(x - y) = ↑x - ↑y

full_name: RingCon.hasZSMul
code: instance hasZSMul : SMul ℤ c.Quotient 
goal: SMul ℤ c.Quotient

full_name: RingCon.coe_zsmul
code: @[simp, norm_cast]
theorem coe_zsmul (z : ℤ) (x : R) : (↑(z • x) : c.Quotient) = z • (x : c.Quotient) 
goal: ↑(z • x) = z • ↑x

full_name: RingCon.hasNSMul
code: instance hasNSMul : SMul ℕ c.Quotient 
goal: SMul ℕ c.Quotient

full_name: RingCon.coe_nsmul
code: @[simp, norm_cast]
theorem coe_nsmul (n : ℕ) (x : R) : (↑(n • x) : c.Quotient) = n • (x : c.Quotient) 
goal: ↑(n • x) = n • ↑x

full_name: RingCon.instPowQuotientNat
code: instance : Pow c.Quotient ℕ 
goal: Pow c.Quotient ℕ

full_name: RingCon.coe_pow
code: @[simp, norm_cast]
theorem coe_pow (x : R) (n : ℕ) : (↑(x ^ n) : c.Quotient) = (x : c.Quotient) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: RingCon.instNatCastQuotient
code: instance : NatCast c.Quotient 
goal: NatCast c.Quotient

full_name: RingCon.coe_natCast
code: @[simp, norm_cast]
theorem coe_natCast (n : ℕ) : (↑(n : R) : c.Quotient) = n 
goal: ↑↑n = ↑n

full_name: RingCon.instIntCastQuotient
code: instance : IntCast c.Quotient 
goal: IntCast c.Quotient

full_name: RingCon.coe_intCast
code: @[simp, norm_cast]
theorem coe_intCast (n : ℕ) : (↑(n : R) : c.Quotient) = n 
goal: ↑↑n = ↑n

full_name: RingCon.instInhabitedQuotient
code: instance [Inhabited R] [Add R] [Mul R] (c : RingCon R) : Inhabited c.Quotient 
goal: Inhabited c.Quotient

full_name: RingCon.instNonUnitalNonAssocSemiringQuotient
code: instance [NonUnitalNonAssocSemiring R] (c : RingCon R) : NonUnitalNonAssocSemiring c.Quotient 
goal: NonUnitalNonAssocSemiring c.Quotient

full_name: RingCon.instNonAssocSemiringQuotient
code: instance [NonAssocSemiring R] (c : RingCon R) : NonAssocSemiring c.Quotient 
goal: NonAssocSemiring c.Quotient

full_name: RingCon.instNonUnitalSemiringQuotient
code: instance [NonUnitalSemiring R] (c : RingCon R) : NonUnitalSemiring c.Quotient 
goal: NonUnitalSemiring c.Quotient

full_name: RingCon.instSemiringQuotient
code: instance [Semiring R] (c : RingCon R) : Semiring c.Quotient 
goal: Semiring c.Quotient

full_name: RingCon.instCommSemiringQuotient
code: instance [CommSemiring R] (c : RingCon R) : CommSemiring c.Quotient 
goal: CommSemiring c.Quotient

full_name: RingCon.instNonUnitalNonAssocRingQuotient
code: instance [NonUnitalNonAssocRing R] (c : RingCon R) : NonUnitalNonAssocRing c.Quotient 
goal: NonUnitalNonAssocRing c.Quotient

full_name: RingCon.instNonAssocRingQuotient
code: instance [NonAssocRing R] (c : RingCon R) : NonAssocRing c.Quotient 
goal: NonAssocRing c.Quotient

full_name: RingCon.instNonUnitalRingQuotient
code: instance [NonUnitalRing R] (c : RingCon R) : NonUnitalRing c.Quotient 
goal: NonUnitalRing c.Quotient

full_name: RingCon.instRingQuotient
code: instance [Ring R] (c : RingCon R) : Ring c.Quotient 
goal: Ring c.Quotient

full_name: RingCon.instCommRingQuotient
code: instance [CommRing R] (c : RingCon R) : CommRing c.Quotient 
goal: CommRing c.Quotient

full_name: RingCon.isScalarTower_right
code: instance isScalarTower_right [Add R] [MulOneClass R] [SMul α R] [IsScalarTower α R R]
    (c : RingCon R) : IsScalarTower α c.Quotient c.Quotient 
goal: IsScalarTower α c.Quotient c.Quotient

full_name: RingCon.smulCommClass
code: instance smulCommClass [Add R] [MulOneClass R] [SMul α R] [IsScalarTower α R R]
    [SMulCommClass α R R] (c : RingCon R) : SMulCommClass α c.Quotient c.Quotient 
goal: SMulCommClass α c.Quotient c.Quotient

full_name: RingCon.smulCommClass'
code: instance smulCommClass' [Add R] [MulOneClass R] [SMul α R] [IsScalarTower α R R]
    [SMulCommClass R α R] (c : RingCon R) : SMulCommClass c.Quotient α c.Quotient 
goal: SMulCommClass c.Quotient α c.Quotient

full_name: RingCon.instDistribMulActionQuotientOfIsScalarTower
code: instance [Monoid α] [NonAssocSemiring R] [DistribMulAction α R] [IsScalarTower α R R]
    (c : RingCon R) : DistribMulAction α c.Quotient 
goal: DistribMulAction α c.Quotient

full_name: RingCon.instMulSemiringActionQuotientOfIsScalarTower
code: instance [Monoid α] [Semiring R] [MulSemiringAction α R] [IsScalarTower α R R] (c : RingCon R) :
    MulSemiringAction α c.Quotient 
goal: MulSemiringAction α c.Quotient

full_name: RingCon.mk'
code: /-- The natural homomorphism from a ring to its quotient by a congruence relation. -/
def mk' [NonAssocSemiring R] (c : RingCon R) : R →+* c.Quotient 
goal: R →+* c.Quotient

full_name: RingCon.instLE
code: /-- For congruence relations `c, d` on a type `M` with multiplication and addition, `c ≤ d` iff
`∀ x y ∈ M`, `x` is related to `y` by `d` if `x` is related to `y` by `c`. -/
instance : LE (RingCon R) 
goal: LE (RingCon R)

full_name: RingCon.le_def
code: /-- Definition of `≤` for congruence relations. -/
theorem le_def {c d : RingCon R} : c ≤ d ↔ ∀ {x y}, c x y → d x y 
goal: c ≤ d ↔ ∀ {x y : R}, c x y → d x y

full_name: RingCon.instInfSet
code: /-- The infimum of a set of congruence relations on a given type with multiplication and
addition. -/
instance : InfSet (RingCon R) 
goal: InfSet (RingCon R)

full_name: RingCon.sInf_toSetoid
code: /-- The infimum of a set of congruence relations is the same as the infimum of the set's image
    under the map to the underlying equivalence relation. -/
theorem sInf_toSetoid (S : Set (RingCon R)) : (sInf S).toSetoid = sInf ((·.toSetoid) '' S) 
goal: (sInf S).toSetoid = sInf ((fun x => x.toSetoid) '' S)

full_name: RingCon.coe_sInf
code: /-- The infimum of a set of congruence relations is the same as the infimum of the set's image
    under the map to the underlying binary relation. -/
@[simp, norm_cast]
theorem coe_sInf (S : Set (RingCon R)) : ⇑(sInf S) = sInf ((⇑) '' S) 
goal: ⇑(sInf S) = sInf (DFunLike.coe '' S)

full_name: RingCon.coe_iInf
code: @[simp, norm_cast]
theorem coe_iInf {ι : Sort*} (f : ι → RingCon R) : ⇑(iInf f) = ⨅ i, ⇑(f i) 
goal: ⇑(iInf f) = ⨅ i, ⇑(f i)

full_name: RingCon.instPartialOrder
code: instance : PartialOrder (RingCon R) 
goal: PartialOrder (RingCon R)

full_name: RingCon.instCompleteLattice
code: /-- The complete lattice of congruence relations on a given type with multiplication and
addition. -/
instance : CompleteLattice (RingCon R) 
goal: CompleteLattice (RingCon R)

full_name: RingCon.coe_top
code: @[simp, norm_cast]
theorem coe_top : ⇑(⊤ : RingCon R) = ⊤ 
goal: ⇑⊤ = ⊤

full_name: RingCon.coe_bot
code: @[simp, norm_cast]
theorem coe_bot : ⇑(⊥ : RingCon R) = Eq 
goal: ⇑⊥ = Eq

full_name: RingCon.coe_inf
code: /-- The infimum of two congruence relations equals the infimum of the underlying binary
operations. -/
@[simp, norm_cast]
theorem coe_inf {c d : RingCon R} : ⇑(c ⊓ d) = ⇑c ⊓ ⇑d 
goal: ⇑(c ⊓ d) = ⇑c ⊓ ⇑d

full_name: RingCon.inf_iff_and
code: /-- Definition of the infimum of two congruence relations. -/
theorem inf_iff_and {c d : RingCon R} {x y} : (c ⊓ d) x y ↔ c x y ∧ d x y 
goal: (c ⊓ d) x y ↔ c x y ∧ d x y

full_name: RingCon.instNontrivial
code: instance [Nontrivial R] : Nontrivial (RingCon R) 
goal: Nontrivial (RingCon R)

full_name: RingCon.ringConGen_eq
code: /-- The inductively defined smallest congruence relation containing a binary relation `r` equals
    the infimum of the set of congruence relations containing `r`. -/
theorem ringConGen_eq (r : R → R → Prop) :
    ringConGen r = sInf {s : RingCon R | ∀ x y, r x y → s x y} 
goal: ringConGen r = sInf {s | ∀ (x y : R), r x y → s x y}

full_name: RingCon.ringConGen_le
code: /-- The smallest congruence relation containing a binary relation `r` is contained in any
    congruence relation containing `r`. -/
theorem ringConGen_le {r : R → R → Prop} {c : RingCon R}
    (h : ∀ x y, r x y → c x y) : ringConGen r ≤ c 
goal: ringConGen r ≤ c

full_name: RingCon.ringConGen_mono
code: /-- Given binary relations `r, s` with `r` contained in `s`, the smallest congruence relation
    containing `s` contains the smallest congruence relation containing `r`. -/
theorem ringConGen_mono {r s : R → R → Prop} (h : ∀ x y, r x y → s x y) :
    ringConGen r ≤ ringConGen s 
goal: ringConGen r ≤ ringConGen s

full_name: RingCon.ringConGen_of_ringCon
code: /-- Congruence relations equal the smallest congruence relation in which they are contained. -/
theorem ringConGen_of_ringCon (c : RingCon R) : ringConGen c = c 
goal: ringConGen ⇑c = c

full_name: RingCon.ringConGen_idem
code: /-- The map sending a binary relation to the smallest congruence relation in which it is
    contained is idempotent. -/
theorem ringConGen_idem (r : R → R → Prop) : ringConGen (ringConGen r) = ringConGen r 
goal: ringConGen ⇑(ringConGen r) = ringConGen r

full_name: RingCon.sup_eq_ringConGen
code: /-- The supremum of congruence relations `c, d` equals the smallest congruence relation containing
    the binary relation '`x` is related to `y` by `c` or `d`'. -/
theorem sup_eq_ringConGen (c d : RingCon R) : c ⊔ d = ringConGen fun x y => c x y ∨ d x y 
goal: c ⊔ d = ringConGen fun x y => c x y ∨ d x y

full_name: RingCon.sup_def
code: /-- The supremum of two congruence relations equals the smallest congruence relation containing
    the supremum of the underlying binary operations. -/
theorem sup_def {c d : RingCon R} : c ⊔ d = ringConGen (⇑c ⊔ ⇑d) 
goal: c ⊔ d = ringConGen (⇑c ⊔ ⇑d)

full_name: RingCon.sSup_eq_ringConGen
code: /-- The supremum of a set of congruence relations `S` equals the smallest congruence relation
    containing the binary relation 'there exists `c ∈ S` such that `x` is related to `y` by
    `c`'. -/
theorem sSup_eq_ringConGen (S : Set (RingCon R)) :
    sSup S = ringConGen fun x y => ∃ c : RingCon R, c ∈ S ∧ c x y 
goal: sSup S = ringConGen fun x y => ∃ c ∈ S, c x y

full_name: RingCon.sSup_def
code: /-- The supremum of a set of congruence relations is the same as the smallest congruence relation
    containing the supremum of the set's image under the map to the underlying binary relation. -/
theorem sSup_def {S : Set (RingCon R)} :
    sSup S = ringConGen (sSup (@Set.image (RingCon R) (R → R → Prop) (⇑) S)) 
goal: sSup S = ringConGen (sSup (DFunLike.coe '' S))

full_name: RingCon.gi
code: /-- There is a Galois insertion of congruence relations on a type with multiplication and addition
`R` into binary relations on `R`. -/
protected def gi : @GaloisInsertion (R → R → Prop) (RingCon R) _ _ ringConGen (⇑) 
goal: GaloisInsertion ringConGen DFunLike.coe