File: Mathlib/Algebra/RingQuot.lean

full_name: RingCon.instAlgebraQuotient
code: instance (c : RingCon A) : Algebra S c.Quotient 
goal: Algebra S c.Quotient

full_name: RingCon.coe_algebraMap
code: @[simp, norm_cast]
theorem coe_algebraMap (c : RingCon A) (s : S) :
    (algebraMap S A s : c.Quotient) = algebraMap S _ s 
goal: ↑((algebraMap S A) s) = (algebraMap S c.Quotient) s

full_name: RingQuot.Rel.add_left
code: /-- Given an arbitrary relation `r` on a ring, we strengthen it to a relation `Rel r`,
such that the equivalence relation generated by `Rel r` has `x ~ y` if and only if
`x - y` is in the ideal generated by elements `a - b` such that `r a b`.
-/
inductive Rel (r : R → R → Prop) : R → R → Prop
  | of ⦃x y : R⦄ (h : r x y) : Rel r x y
  | add_left ⦃a b c⦄ : Rel r a b → Rel r (a + c) (b + c)
  | mul_left ⦃a b c⦄ : Rel r a b → Rel r (a * c) (b * c)
  | mul_right ⦃a b c⦄ : Rel r b c → Rel r (a * b) (a * c)
goal: RingQuot.Rel r a b → RingQuot.Rel r (a + c) (b + c)

full_name: RingQuot.Rel.of
code: /-- Given an arbitrary relation `r` on a ring, we strengthen it to a relation `Rel r`,
such that the equivalence relation generated by `Rel r` has `x ~ y` if and only if
`x - y` is in the ideal generated by elements `a - b` such that `r a b`.
-/
inductive Rel (r : R → R → Prop) : R → R → Prop
  | of ⦃x y : R⦄ (h : r x y) : Rel r x y
  | add_left ⦃a b c⦄ : Rel r a b → Rel r (a + c) (b + c)
  | mul_left ⦃a b c⦄ : Rel r a b → Rel r (a * c) (b * c)
  | mul_right ⦃a b c⦄ : Rel r b c → Rel r (a * b) (a * c)
goal: RingQuot.Rel r x y

full_name: RingQuot.Rel.mul_left
code: /-- Given an arbitrary relation `r` on a ring, we strengthen it to a relation `Rel r`,
such that the equivalence relation generated by `Rel r` has `x ~ y` if and only if
`x - y` is in the ideal generated by elements `a - b` such that `r a b`.
-/
inductive Rel (r : R → R → Prop) : R → R → Prop
  | of ⦃x y : R⦄ (h : r x y) : Rel r x y
  | add_left ⦃a b c⦄ : Rel r a b → Rel r (a + c) (b + c)
  | mul_left ⦃a b c⦄ : Rel r a b → Rel r (a * c) (b * c)
  | mul_right ⦃a b c⦄ : Rel r b c → Rel r (a * b) (a * c)
goal: RingQuot.Rel r a b → RingQuot.Rel r (a * c) (b * c)

full_name: RingQuot.Rel
code: /-- Given an arbitrary relation `r` on a ring, we strengthen it to a relation `Rel r`,
such that the equivalence relation generated by `Rel r` has `x ~ y` if and only if
`x - y` is in the ideal generated by elements `a - b` such that `r a b`.
-/
inductive Rel (r : R → R → Prop) : R → R → Prop
  | of ⦃x y : R⦄ (h : r x y) : Rel r x y
  | add_left ⦃a b c⦄ : Rel r a b → Rel r (a + c) (b + c)
  | mul_left ⦃a b c⦄ : Rel r a b → Rel r (a * c) (b * c)
  | mul_right ⦃a b c⦄ : Rel r b c → Rel r (a * b) (a * c)
goal: R → R → Prop

full_name: RingQuot.Rel.mul_right
code: /-- Given an arbitrary relation `r` on a ring, we strengthen it to a relation `Rel r`,
such that the equivalence relation generated by `Rel r` has `x ~ y` if and only if
`x - y` is in the ideal generated by elements `a - b` such that `r a b`.
-/
inductive Rel (r : R → R → Prop) : R → R → Prop
  | of ⦃x y : R⦄ (h : r x y) : Rel r x y
  | add_left ⦃a b c⦄ : Rel r a b → Rel r (a + c) (b + c)
  | mul_left ⦃a b c⦄ : Rel r a b → Rel r (a * c) (b * c)
  | mul_right ⦃a b c⦄ : Rel r b c → Rel r (a * b) (a * c)
goal: RingQuot.Rel r b c → RingQuot.Rel r (a * b) (a * c)

full_name: RingQuot.Rel.add_right
code: theorem Rel.add_right {r : R → R → Prop} ⦃a b c : R⦄ (h : Rel r b c) : Rel r (a + b) (a + c) 
goal: RingQuot.Rel r (a + b) (a + c)

full_name: RingQuot.Rel.neg
code: theorem Rel.neg {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b : R⦄ (h : Rel r a b) :
    Rel r (-a) (-b) 
goal: RingQuot.Rel r (-a) (-b)

full_name: RingQuot.Rel.sub_left
code: theorem Rel.sub_left {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b c : R⦄ (h : Rel r a b) :
    Rel r (a - c) (b - c) 
goal: RingQuot.Rel r (a - c) (b - c)

full_name: RingQuot.Rel.sub_right
code: theorem Rel.sub_right {R : Type uR} [Ring R] {r : R → R → Prop} ⦃a b c : R⦄ (h : Rel r b c) :
    Rel r (a - b) (a - c) 
goal: RingQuot.Rel r (a - b) (a - c)

full_name: RingQuot.Rel.smul
code: theorem Rel.smul {r : A → A → Prop} (k : S) ⦃a b : A⦄ (h : Rel r a b) : Rel r (k • a) (k • b) 
goal: RingQuot.Rel r (k • a) (k • b)

full_name: RingQuot.ringCon
code: /-- `EqvGen (RingQuot.Rel r)` is a ring congruence. -/
def ringCon (r : R → R → Prop) : RingCon R 
goal: RingCon R

full_name: RingQuot.eqvGen_rel_eq
code: theorem eqvGen_rel_eq (r : R → R → Prop) : EqvGen (Rel r) = RingConGen.Rel r 
goal: EqvGen (RingQuot.Rel r) = RingConGen.Rel r

full_name: RingQuot.toQuot
code: /-- The quotient of a ring by an arbitrary relation. -/
structure RingQuot (r : R → R → Prop) where
  toQuot : Quot (RingQuot.Rel r)
goal: Quot (RingQuot.Rel r)

full_name: RingQuot
code: /-- The quotient of a ring by an arbitrary relation. -/
structure RingQuot (r : R → R → Prop) where
  toQuot : Quot (RingQuot.Rel r)
goal: Type uR

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.natCast
code: private def natCast (n : ℕ) : RingQuot r 
goal: RingQuot r

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.1412
code: private irreducible_def zero : RingQuot r 
goal: RingQuot r

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.1412
code: private irreducible_def zero : RingQuot r 
goal: Subtype (Eq @RingQuot.definition✝)

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.zero_def
code: private irreducible_def zero : RingQuot r 
goal: RingQuot.zero r = { toQuot := Quot.mk (RingQuot.Rel r) 0 }

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.zero
code: private irreducible_def zero : RingQuot r 
goal: RingQuot r

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.1615
code: private irreducible_def one : RingQuot r 
goal: Subtype (Eq @RingQuot.definition✝)

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.1615
code: private irreducible_def one : RingQuot r 
goal: RingQuot r

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.one
code: private irreducible_def one : RingQuot r 
goal: RingQuot r

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.one_def
code: private irreducible_def one : RingQuot r 
goal: RingQuot.one r = { toQuot := Quot.mk (RingQuot.Rel r) 1 }

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.1818
code: private irreducible_def add : RingQuot r → RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r → RingQuot r

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.1818
code: private irreducible_def add : RingQuot r → RingQuot r → RingQuot r
  
goal: Subtype (Eq @RingQuot.definition✝)

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.add_def
code: private irreducible_def add : RingQuot r → RingQuot r → RingQuot r
  
goal: ∀ (x x_1 : RingQuot r),
  RingQuot.add r x x_1 =
    match x, x_1 with
    | { toQuot := a }, { toQuot := b } => { toQuot := Quot.map₂ (fun x x_2 => x + x_2) ⋯ ⋯ a b }

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.add
code: private irreducible_def add : RingQuot r → RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r → RingQuot r

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.mul_def
code: private irreducible_def mul : RingQuot r → RingQuot r → RingQuot r
  
goal: ∀ (x x_1 : RingQuot r),
  RingQuot.mul r x x_1 =
    match x, x_1 with
    | { toQuot := a }, { toQuot := b } => { toQuot := Quot.map₂ (fun x x_2 => x * x_2) ⋯ ⋯ a b }

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.mul
code: private irreducible_def mul : RingQuot r → RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r → RingQuot r

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.2084
code: private irreducible_def mul : RingQuot r → RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r → RingQuot r

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.2084
code: private irreducible_def mul : RingQuot r → RingQuot r → RingQuot r
  
goal: Subtype (Eq @RingQuot.definition✝)

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.2350
code: private irreducible_def neg {R : Type uR} [Ring R] (r : R → R → Prop) : RingQuot r → RingQuot r
  
goal: Subtype (Eq @RingQuot.definition✝)

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.2350
code: private irreducible_def neg {R : Type uR} [Ring R] (r : R → R → Prop) : RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.neg_def
code: private irreducible_def neg {R : Type uR} [Ring R] (r : R → R → Prop) : RingQuot r → RingQuot r
  
goal: ∀ (x : RingQuot r),
  RingQuot.neg r x =
    match x with
    | { toQuot := a } => { toQuot := Quot.map (fun a => -a) ⋯ a }

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.neg
code: private irreducible_def neg {R : Type uR} [Ring R] (r : R → R → Prop) : RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.sub
code: private irreducible_def sub {R : Type uR} [Ring R] (r : R → R → Prop) :
  RingQuot r → RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r → RingQuot r

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.2595
code: private irreducible_def sub {R : Type uR} [Ring R] (r : R → R → Prop) :
  RingQuot r → RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r → RingQuot r

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.2595
code: private irreducible_def sub {R : Type uR} [Ring R] (r : R → R → Prop) :
  RingQuot r → RingQuot r → RingQuot r
  
goal: Subtype (Eq @RingQuot.definition✝)

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.sub_def
code: private irreducible_def sub {R : Type uR} [Ring R] (r : R → R → Prop) :
  RingQuot r → RingQuot r → RingQuot r
  
goal: ∀ (x x_1 : RingQuot r),
  RingQuot.sub r x x_1 =
    match x, x_1 with
    | { toQuot := a }, { toQuot := b } => { toQuot := Quot.map₂ Sub.sub ⋯ ⋯ a b }

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.npow
code: private irreducible_def npow (n : ℕ) : RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.npow_def
code: private irreducible_def npow (n : ℕ) : RingQuot r → RingQuot r
  
goal: ∀ (x : RingQuot r),
  RingQuot.npow r n x =
    match x with
    | { toQuot := a } => { toQuot := Quot.lift (fun a => Quot.mk (RingQuot.Rel r) (a ^ n)) ⋯ a }

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.2856
code: private irreducible_def npow (n : ℕ) : RingQuot r → RingQuot r
  
goal: Subtype (Eq @RingQuot.definition✝)

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.2856
code: private irreducible_def npow (n : ℕ) : RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.smul
code: private def smul [Algebra S R] (n : S) : RingQuot r → RingQuot r
  
goal: RingQuot r → RingQuot r

full_name: RingQuot.instNatCast
code: instance : NatCast (RingQuot r) 
goal: NatCast (RingQuot r)

full_name: RingQuot.instZero
code: instance : Zero (RingQuot r) 
goal: Zero (RingQuot r)

full_name: RingQuot.instOne
code: instance : One (RingQuot r) 
goal: One (RingQuot r)

full_name: RingQuot.instAdd
code: instance : Add (RingQuot r) 
goal: Add (RingQuot r)

full_name: RingQuot.instMul
code: instance : Mul (RingQuot r) 
goal: Mul (RingQuot r)

full_name: RingQuot.instNatPow
code: instance : NatPow (RingQuot r) 
goal: NatPow (RingQuot r)

full_name: RingQuot.instNeg
code: instance {R : Type uR} [Ring R] (r : R → R → Prop) : Neg (RingQuot r) 
goal: Neg (RingQuot r)

full_name: RingQuot.instSub
code: instance {R : Type uR} [Ring R] (r : R → R → Prop) : Sub (RingQuot r) 
goal: Sub (RingQuot r)

full_name: RingQuot.instSMulOfAlgebra
code: instance [Algebra S R] : SMul S (RingQuot r) 
goal: SMul S (RingQuot r)

full_name: RingQuot.zero_quot
code: theorem zero_quot : (⟨Quot.mk _ 0⟩ : RingQuot r) = 0 
goal: { toQuot := Quot.mk (RingQuot.Rel r) 0 } = 0

full_name: RingQuot.one_quot
code: theorem one_quot : (⟨Quot.mk _ 1⟩ : RingQuot r) = 1 
goal: { toQuot := Quot.mk (RingQuot.Rel r) 1 } = 1

full_name: RingQuot.add_quot
code: theorem add_quot {a b} : (⟨Quot.mk _ a⟩ + ⟨Quot.mk _ b⟩ : RingQuot r) = ⟨Quot.mk _ (a + b)⟩ 
goal: { toQuot := Quot.mk (RingQuot.Rel r) a } + { toQuot := Quot.mk (RingQuot.Rel r) b } =
  { toQuot := Quot.mk (RingQuot.Rel r) (a + b) }

full_name: RingQuot.mul_quot
code: theorem mul_quot {a b} : (⟨Quot.mk _ a⟩ * ⟨Quot.mk _ b⟩ : RingQuot r) = ⟨Quot.mk _ (a * b)⟩ 
goal: { toQuot := Quot.mk (RingQuot.Rel r) a } * { toQuot := Quot.mk (RingQuot.Rel r) b } =
  { toQuot := Quot.mk (RingQuot.Rel r) (a * b) }

full_name: RingQuot.pow_quot
code: theorem pow_quot {a} {n : ℕ} : (⟨Quot.mk _ a⟩ ^ n : RingQuot r) = ⟨Quot.mk _ (a ^ n)⟩ 
goal: { toQuot := Quot.mk (RingQuot.Rel r) a } ^ n = { toQuot := Quot.mk (RingQuot.Rel r) (a ^ n) }

full_name: RingQuot.neg_quot
code: theorem neg_quot {R : Type uR} [Ring R] (r : R → R → Prop) {a} :
    (-⟨Quot.mk _ a⟩ : RingQuot r) = ⟨Quot.mk _ (-a)⟩ 
goal: -{ toQuot := Quot.mk (RingQuot.Rel r) a } = { toQuot := Quot.mk (RingQuot.Rel r) (-a) }

full_name: RingQuot.sub_quot
code: theorem sub_quot {R : Type uR} [Ring R] (r : R → R → Prop) {a b} :
    (⟨Quot.mk _ a⟩ - ⟨Quot.mk _ b⟩ : RingQuot r) = ⟨Quot.mk _ (a - b)⟩ 
goal: { toQuot := Quot.mk (RingQuot.Rel r) a } - { toQuot := Quot.mk (RingQuot.Rel r) b } =
  { toQuot := Quot.mk (RingQuot.Rel r) (a - b) }

full_name: RingQuot.smul_quot
code: theorem smul_quot [Algebra S R] {n : S} {a : R} :
    (n • ⟨Quot.mk _ a⟩ : RingQuot r) = ⟨Quot.mk _ (n • a)⟩ 
goal: n • { toQuot := Quot.mk (RingQuot.Rel r) a } = { toQuot := Quot.mk (RingQuot.Rel r) (n • a) }

full_name: RingQuot.instIsScalarTower
code: instance instIsScalarTower [CommSemiring T] [SMul S T] [Algebra S R] [Algebra T R]
    [IsScalarTower S T R] : IsScalarTower S T (RingQuot r) 
goal: IsScalarTower S T (RingQuot r)

full_name: RingQuot.instSMulCommClass
code: instance instSMulCommClass [CommSemiring T] [Algebra S R] [Algebra T R] [SMulCommClass S T R] :
    SMulCommClass S T (RingQuot r) 
goal: SMulCommClass S T (RingQuot r)

full_name: RingQuot.instAddCommMonoid
code: instance instAddCommMonoid (r : R → R → Prop) : AddCommMonoid (RingQuot r) 
goal: AddCommMonoid (RingQuot r)

full_name: RingQuot.instMonoidWithZero
code: instance instMonoidWithZero (r : R → R → Prop) : MonoidWithZero (RingQuot r) 
goal: MonoidWithZero (RingQuot r)

full_name: RingQuot.instSemiring
code: instance instSemiring (r : R → R → Prop) : Semiring (RingQuot r) 
goal: Semiring (RingQuot r)

full_name: _private.Mathlib.Algebra.RingQuot.0.RingQuot.intCast
code: private def intCast {R : Type uR} [Ring R] (r : R → R → Prop) (z : ℤ) : RingQuot r 
goal: RingQuot r

full_name: RingQuot.instRing
code: instance instRing {R : Type uR} [Ring R] (r : R → R → Prop) : Ring (RingQuot r) 
goal: Ring (RingQuot r)

full_name: RingQuot.instCommSemiring
code: instance instCommSemiring {R : Type uR} [CommSemiring R] (r : R → R → Prop) :
  CommSemiring (RingQuot r) 
goal: CommSemiring (RingQuot r)

full_name: RingQuot.instCommRing
code: instance {R : Type uR} [CommRing R] (r : R → R → Prop) : CommRing (RingQuot r) 
goal: CommRing (RingQuot r)

full_name: RingQuot.instInhabited
code: instance instInhabited (r : R → R → Prop) : Inhabited (RingQuot r) 
goal: Inhabited (RingQuot r)

full_name: RingQuot.instAlgebra
code: instance instAlgebra [Algebra S R] (r : R → R → Prop) : Algebra S (RingQuot r) 
goal: Algebra S (RingQuot r)

full_name: RingQuot.mkRingHom
code: /-- The quotient map from a ring to its quotient, as a homomorphism of rings.
-/
irreducible_def mkRingHom (r : R → R → Prop) : R →+* RingQuot r 
goal: R →+* RingQuot r

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.5605
code: /-- The quotient map from a ring to its quotient, as a homomorphism of rings.
-/
irreducible_def mkRingHom (r : R → R → Prop) : R →+* RingQuot r 
goal: R →+* RingQuot r

full_name: RingQuot.mkRingHom_def
code: /-- The quotient map from a ring to its quotient, as a homomorphism of rings.
-/
irreducible_def mkRingHom (r : R → R → Prop) : R →+* RingQuot r 
goal: RingQuot.mkRingHom r =
  { toFun := fun x => { toQuot := Quot.mk (RingQuot.Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
    map_add' := ⋯ }

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.5605
code: /-- The quotient map from a ring to its quotient, as a homomorphism of rings.
-/
irreducible_def mkRingHom (r : R → R → Prop) : R →+* RingQuot r 
goal: Subtype (Eq @RingQuot.definition✝)

full_name: RingQuot.mkRingHom_rel
code: theorem mkRingHom_rel {r : R → R → Prop} {x y : R} (w : r x y) : mkRingHom r x = mkRingHom r y 
goal: (RingQuot.mkRingHom r) x = (RingQuot.mkRingHom r) y

full_name: RingQuot.mkRingHom_surjective
code: theorem mkRingHom_surjective (r : R → R → Prop) : Function.Surjective (mkRingHom r) 
goal: Function.Surjective ⇑(RingQuot.mkRingHom r)

full_name: RingQuot.ringQuot_ext
code: @[ext 1100]
theorem ringQuot_ext [Semiring T] {r : R → R → Prop} (f g : RingQuot r →+* T)
    (w : f.comp (mkRingHom r) = g.comp (mkRingHom r)) : f = g 
goal: f = g

full_name: RingQuot.preLift_def
code: irreducible_def preLift {r : R → R → Prop} {f : R →+* T} (h : ∀ ⦃x y⦄, r x y → f x = f y) :
  RingQuot r →+* T 
goal: RingQuot.preLift h =
  { toFun := fun x => Quot.lift ⇑f ⋯ x.toQuot, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.6044
code: irreducible_def preLift {r : R → R → Prop} {f : R →+* T} (h : ∀ ⦃x y⦄, r x y → f x = f y) :
  RingQuot r →+* T 
goal: RingQuot r →+* T

full_name: RingQuot.preLift
code: irreducible_def preLift {r : R → R → Prop} {f : R →+* T} (h : ∀ ⦃x y⦄, r x y → f x = f y) :
  RingQuot r →+* T 
goal: RingQuot r →+* T

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.6044
code: irreducible_def preLift {r : R → R → Prop} {f : R →+* T} (h : ∀ ⦃x y⦄, r x y → f x = f y) :
  RingQuot r →+* T 
goal: Subtype (Eq @RingQuot.definition✝)

full_name: RingQuot.lift
code: /-- Any ring homomorphism `f : R →+* T` which respects a relation `r : R → R → Prop`
factors uniquely through a morphism `RingQuot r →+* T`.
-/
irreducible_def lift {r : R → R → Prop} :
  { f : R →+* T // ∀ ⦃x y⦄, r x y → f x = f y } ≃ (RingQuot r →+* T) 
goal: { f // ∀ ⦃x y : R⦄, r x y → f x = f y } ≃ (RingQuot r →+* T)

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.6456
code: /-- Any ring homomorphism `f : R →+* T` which respects a relation `r : R → R → Prop`
factors uniquely through a morphism `RingQuot r →+* T`.
-/
irreducible_def lift {r : R → R → Prop} :
  { f : R →+* T // ∀ ⦃x y⦄, r x y → f x = f y } ≃ (RingQuot r →+* T) 
goal: { f // ∀ ⦃x y : R⦄, r x y → f x = f y } ≃ (RingQuot r →+* T)

full_name: RingQuot.lift_def
code: /-- Any ring homomorphism `f : R →+* T` which respects a relation `r : R → R → Prop`
factors uniquely through a morphism `RingQuot r →+* T`.
-/
irreducible_def lift {r : R → R → Prop} :
  { f : R →+* T // ∀ ⦃x y⦄, r x y → f x = f y } ≃ (RingQuot r →+* T) 
goal: RingQuot.lift =
  { toFun := fun f => RingQuot.preLift ⋯, invFun := fun F => ⟨F.comp (RingQuot.mkRingHom r), ⋯⟩, left_inv := ⋯,
    right_inv := ⋯ }

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.6456
code: /-- Any ring homomorphism `f : R →+* T` which respects a relation `r : R → R → Prop`
factors uniquely through a morphism `RingQuot r →+* T`.
-/
irreducible_def lift {r : R → R → Prop} :
  { f : R →+* T // ∀ ⦃x y⦄, r x y → f x = f y } ≃ (RingQuot r →+* T) 
goal: Subtype (Eq @RingQuot.definition✝)

full_name: RingQuot.lift_mkRingHom_apply
code: @[simp]
theorem lift_mkRingHom_apply (f : R →+* T) {r : R → R → Prop} (w : ∀ ⦃x y⦄, r x y → f x = f y) (x) :
    lift ⟨f, w⟩ (mkRingHom r x) = f x 
goal: (RingQuot.lift ⟨f, w⟩) ((RingQuot.mkRingHom r) x) = f x

full_name: RingQuot.lift_unique
code: theorem lift_unique (f : R →+* T) {r : R → R → Prop} (w : ∀ ⦃x y⦄, r x y → f x = f y)
    (g : RingQuot r →+* T) (h : g.comp (mkRingHom r) = f) : g = lift ⟨f, w⟩ 
goal: g = RingQuot.lift ⟨f, w⟩

full_name: RingQuot.eq_lift_comp_mkRingHom
code: theorem eq_lift_comp_mkRingHom {r : R → R → Prop} (f : RingQuot r →+* T) :
    f = lift ⟨f.comp (mkRingHom r), fun x y h ↦ congr_arg f (mkRingHom_rel h)⟩ 
goal: f = RingQuot.lift ⟨f.comp (RingQuot.mkRingHom r), ⋯⟩

full_name: RingQuot.ringQuotToIdealQuotient
code: /-- The universal ring homomorphism from `RingQuot r` to `B ⧸ Ideal.ofRel r`. -/
def ringQuotToIdealQuotient (r : B → B → Prop) : RingQuot r →+* B ⧸ Ideal.ofRel r 
goal: RingQuot r →+* B ⧸ Ideal.ofRel r

full_name: RingQuot.ringQuotToIdealQuotient_apply
code: @[simp]
theorem ringQuotToIdealQuotient_apply (r : B → B → Prop) (x : B) :
    ringQuotToIdealQuotient r (mkRingHom r x) = Ideal.Quotient.mk (Ideal.ofRel r) x 
goal: (RingQuot.ringQuotToIdealQuotient r) ((RingQuot.mkRingHom r) x) = (Ideal.Quotient.mk (Ideal.ofRel r)) x

full_name: RingQuot.idealQuotientToRingQuot
code: /-- The universal ring homomorphism from `B ⧸ Ideal.ofRel r` to `RingQuot r`. -/
def idealQuotientToRingQuot (r : B → B → Prop) : B ⧸ Ideal.ofRel r →+* RingQuot r 
goal: B ⧸ Ideal.ofRel r →+* RingQuot r

full_name: RingQuot.idealQuotientToRingQuot_apply
code: @[simp]
theorem idealQuotientToRingQuot_apply (r : B → B → Prop) (x : B) :
    idealQuotientToRingQuot r (Ideal.Quotient.mk _ x) = mkRingHom r x 
goal: (RingQuot.idealQuotientToRingQuot r) ((Ideal.Quotient.mk (Ideal.ofRel r)) x) = (RingQuot.mkRingHom r) x

full_name: RingQuot.ringQuotEquivIdealQuotient
code: /-- The ring equivalence between `RingQuot r` and `(Ideal.ofRel r).quotient`
-/
def ringQuotEquivIdealQuotient (r : B → B → Prop) : RingQuot r ≃+* B ⧸ Ideal.ofRel r 
goal: RingQuot r ≃+* B ⧸ Ideal.ofRel r

full_name: RingQuot.mkAlgHom
code: /-- The quotient map from an `S`-algebra to its quotient, as a homomorphism of `S`-algebras.
-/
irreducible_def mkAlgHom (s : A → A → Prop) : A →ₐ[S] RingQuot s 
goal: A →ₐ[S] RingQuot s

full_name: RingQuot.mkAlgHom_def
code: /-- The quotient map from an `S`-algebra to its quotient, as a homomorphism of `S`-algebras.
-/
irreducible_def mkAlgHom (s : A → A → Prop) : A →ₐ[S] RingQuot s 
goal: RingQuot.mkAlgHom S s =
  let __src := RingQuot.mkRingHom s;
  { toRingHom := __src, commutes' := ⋯ }

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.7783
code: /-- The quotient map from an `S`-algebra to its quotient, as a homomorphism of `S`-algebras.
-/
irreducible_def mkAlgHom (s : A → A → Prop) : A →ₐ[S] RingQuot s 
goal: Subtype (Eq RingQuot.definition✝)

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.7783
code: /-- The quotient map from an `S`-algebra to its quotient, as a homomorphism of `S`-algebras.
-/
irreducible_def mkAlgHom (s : A → A → Prop) : A →ₐ[S] RingQuot s 
goal: A →ₐ[S] RingQuot s

full_name: RingQuot.mkAlgHom_coe
code: @[simp]
theorem mkAlgHom_coe (s : A → A → Prop) : (mkAlgHom S s : A →+* RingQuot s) = mkRingHom s 
goal: ↑(RingQuot.mkAlgHom S s) = RingQuot.mkRingHom s

full_name: RingQuot.mkAlgHom_rel
code: theorem mkAlgHom_rel {s : A → A → Prop} {x y : A} (w : s x y) :
    mkAlgHom S s x = mkAlgHom S s y 
goal: (RingQuot.mkAlgHom S s) x = (RingQuot.mkAlgHom S s) y

full_name: RingQuot.mkAlgHom_surjective
code: theorem mkAlgHom_surjective (s : A → A → Prop) : Function.Surjective (mkAlgHom S s) 
goal: Function.Surjective ⇑(RingQuot.mkAlgHom S s)

full_name: RingQuot.ringQuot_ext'
code: @[ext 1100]
theorem ringQuot_ext' {s : A → A → Prop} (f g : RingQuot s →ₐ[S] B)
    (w : f.comp (mkAlgHom S s) = g.comp (mkAlgHom S s)) : f = g 
goal: f = g

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.8403
code: irreducible_def preLiftAlgHom {s : A → A → Prop} {f : A →ₐ[S] B}
  (h : ∀ ⦃x y⦄, s x y → f x = f y) : RingQuot s →ₐ[S] B 
goal: Subtype (Eq RingQuot.definition✝)

full_name: RingQuot.preLiftAlgHom
code: irreducible_def preLiftAlgHom {s : A → A → Prop} {f : A →ₐ[S] B}
  (h : ∀ ⦃x y⦄, s x y → f x = f y) : RingQuot s →ₐ[S] B 
goal: RingQuot s →ₐ[S] B

full_name: RingQuot.preLiftAlgHom_def
code: irreducible_def preLiftAlgHom {s : A → A → Prop} {f : A →ₐ[S] B}
  (h : ∀ ⦃x y⦄, s x y → f x = f y) : RingQuot s →ₐ[S] B 
goal: RingQuot.preLiftAlgHom S h =
  { toFun := fun x => Quot.lift ⇑f ⋯ x.toQuot, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯,
    commutes' := ⋯ }

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.8403
code: irreducible_def preLiftAlgHom {s : A → A → Prop} {f : A →ₐ[S] B}
  (h : ∀ ⦃x y⦄, s x y → f x = f y) : RingQuot s →ₐ[S] B 
goal: RingQuot s →ₐ[S] B

full_name: RingQuot.definition._@.Mathlib.Algebra.RingQuot._hyg.8774
code: /-- Any `S`-algebra homomorphism `f : A →ₐ[S] B` which respects a relation `s : A → A → Prop`
factors uniquely through a morphism `RingQuot s →ₐ[S] B`.
-/
irreducible_def liftAlgHom {s : A → A → Prop} :
  { f : A →ₐ[S] B // ∀ ⦃x y⦄, s x y → f x = f y } ≃ (RingQuot s →ₐ[S] B) 
goal: { f // ∀ ⦃x y : A⦄, s x y → f x = f y } ≃ (RingQuot s →ₐ[S] B)

full_name: RingQuot.liftAlgHom
code: /-- Any `S`-algebra homomorphism `f : A →ₐ[S] B` which respects a relation `s : A → A → Prop`
factors uniquely through a morphism `RingQuot s →ₐ[S] B`.
-/
irreducible_def liftAlgHom {s : A → A → Prop} :
  { f : A →ₐ[S] B // ∀ ⦃x y⦄, s x y → f x = f y } ≃ (RingQuot s →ₐ[S] B) 
goal: { f // ∀ ⦃x y : A⦄, s x y → f x = f y } ≃ (RingQuot s →ₐ[S] B)

full_name: RingQuot.wrapped._@.Mathlib.Algebra.RingQuot._hyg.8774
code: /-- Any `S`-algebra homomorphism `f : A →ₐ[S] B` which respects a relation `s : A → A → Prop`
factors uniquely through a morphism `RingQuot s →ₐ[S] B`.
-/
irreducible_def liftAlgHom {s : A → A → Prop} :
  { f : A →ₐ[S] B // ∀ ⦃x y⦄, s x y → f x = f y } ≃ (RingQuot s →ₐ[S] B) 
goal: Subtype (Eq RingQuot.definition✝)

full_name: RingQuot.liftAlgHom_def
code: /-- Any `S`-algebra homomorphism `f : A →ₐ[S] B` which respects a relation `s : A → A → Prop`
factors uniquely through a morphism `RingQuot s →ₐ[S] B`.
-/
irreducible_def liftAlgHom {s : A → A → Prop} :
  { f : A →ₐ[S] B // ∀ ⦃x y⦄, s x y → f x = f y } ≃ (RingQuot s →ₐ[S] B) 
goal: RingQuot.liftAlgHom S =
  { toFun := fun f' => RingQuot.preLiftAlgHom S ⋯, invFun := fun F => ⟨F.comp (RingQuot.mkAlgHom S s), ⋯⟩,
    left_inv := ⋯, right_inv := ⋯ }

full_name: RingQuot.liftAlgHom_mkAlgHom_apply
code: @[simp]
theorem liftAlgHom_mkAlgHom_apply (f : A →ₐ[S] B) {s : A → A → Prop}
    (w : ∀ ⦃x y⦄, s x y → f x = f y) (x) : (liftAlgHom S ⟨f, w⟩) ((mkAlgHom S s) x) = f x 
goal: ((RingQuot.liftAlgHom S) ⟨f, w⟩) ((RingQuot.mkAlgHom S s) x) = f x

full_name: RingQuot.liftAlgHom_unique
code: theorem liftAlgHom_unique (f : A →ₐ[S] B) {s : A → A → Prop} (w : ∀ ⦃x y⦄, s x y → f x = f y)
    (g : RingQuot s →ₐ[S] B) (h : g.comp (mkAlgHom S s) = f) : g = liftAlgHom S ⟨f, w⟩ 
goal: g = (RingQuot.liftAlgHom S) ⟨f, w⟩

full_name: RingQuot.eq_liftAlgHom_comp_mkAlgHom
code: theorem eq_liftAlgHom_comp_mkAlgHom {s : A → A → Prop} (f : RingQuot s →ₐ[S] B) :
    f = liftAlgHom S ⟨f.comp (mkAlgHom S s), fun x y h ↦ congr_arg f (mkAlgHom_rel S h)⟩ 
goal: f = (RingQuot.liftAlgHom S) ⟨f.comp (RingQuot.mkAlgHom S s), ⋯⟩