File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

full_name: RingHom.kerLift
code: /-- 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`).
-/
def kerLift : R ⧸ ker f →+* S 
goal: R ⧸ RingHom.ker f →+* S

full_name: RingHom.kerLift_mk
code: @[simp]
theorem kerLift_mk (r : R) : kerLift f (Ideal.Quotient.mk (ker f) r) = f r 
goal: f.kerLift ((Ideal.Quotient.mk (RingHom.ker f)) r) = f r

full_name: RingHom.lift_injective_of_ker_le_ideal
code: theorem lift_injective_of_ker_le_ideal (I : Ideal R) {f : R →+* S} (H : ∀ a : R, a ∈ I → f a = 0)
    (hI : ker f ≤ I) : Function.Injective (Ideal.Quotient.lift I f H) 
goal: Function.Injective ⇑(Ideal.Quotient.lift I f H)

full_name: RingHom.kerLift_injective
code: /-- The induced map from the quotient by the kernel is injective. -/
theorem kerLift_injective : Function.Injective (kerLift f) 
goal: Function.Injective ⇑f.kerLift

full_name: RingHom.quotientKerEquivOfRightInverse
code: /-- The **first isomorphism theorem for commutative rings**, computable version. -/
def quotientKerEquivOfRightInverse {g : S → R} (hf : Function.RightInverse g f) :
    R ⧸ ker f ≃+* S 
goal: R ⧸ RingHom.ker f ≃+* S

full_name: RingHom.quotientKerEquivOfRightInverse.apply
code: @[simp]
theorem quotientKerEquivOfRightInverse.apply {g : S → R} (hf : Function.RightInverse g f)
    (x : R ⧸ ker f) : quotientKerEquivOfRightInverse hf x = kerLift f x 
goal: (RingHom.quotientKerEquivOfRightInverse hf) x = f.kerLift x

full_name: RingHom.quotientKerEquivOfRightInverse.Symm.apply
code: @[simp]
theorem quotientKerEquivOfRightInverse.Symm.apply {g : S → R} (hf : Function.RightInverse g f)
    (x : S) : (quotientKerEquivOfRightInverse hf).symm x = Ideal.Quotient.mk (ker f) (g x) 
goal: (RingHom.quotientKerEquivOfRightInverse hf).symm x = (Ideal.Quotient.mk (RingHom.ker f)) (g x)

full_name: RingEquiv.quotientBot
code: /-- The quotient of a ring by he zero ideal is isomorphic to the ring itself. -/
def _root_.RingEquiv.quotientBot : R ⧸ (⊥ : Ideal R) ≃+* R 
goal: R ⧸ ⊥ ≃+* R

full_name: RingHom.quotientKerEquivOfSurjective
code: /-- The **first isomorphism theorem** for commutative rings, surjective case. -/
noncomputable def quotientKerEquivOfSurjective (hf : Function.Surjective f) : R ⧸ (ker f) ≃+* S 
goal: R ⧸ RingHom.ker f ≃+* S

full_name: RingHom.quotientKerEquivRangeS
code: /-- The **first isomorphism theorem** for commutative rings (`RingHom.rangeS` version). -/
noncomputable def quotientKerEquivRangeS (f : R →+* S) : R ⧸ ker f ≃+* f.rangeS 
goal: R ⧸ RingHom.ker f ≃+* ↥f.rangeS

full_name: RingHom.quotientKerEquivRange
code: /-- The **first isomorphism theorem** for commutative rings (`RingHom.range` version). -/
noncomputable def quotientKerEquivRange (f : R →+* S) : R ⧸ ker f ≃+* f.range 
goal: R ⧸ RingHom.ker f ≃+* ↥f.range

full_name: Ideal.map_quotient_self
code: @[simp]
theorem map_quotient_self (I : Ideal R) : map (Quotient.mk I) I = ⊥ 
goal: Ideal.map (Ideal.Quotient.mk I) I = ⊥

full_name: Ideal.mk_ker
code: @[simp]
theorem mk_ker {I : Ideal R} : ker (Quotient.mk I) = I 
goal: RingHom.ker (Ideal.Quotient.mk I) = I

full_name: Ideal.map_mk_eq_bot_of_le
code: theorem map_mk_eq_bot_of_le {I J : Ideal R} (h : I ≤ J) : I.map (Quotient.mk J) = ⊥ 
goal: Ideal.map (Ideal.Quotient.mk J) I = ⊥

full_name: Ideal.ker_quotient_lift
code: theorem ker_quotient_lift {I : Ideal R} (f : R →+* S)
    (H : I ≤ ker f) :
    ker (Ideal.Quotient.lift I f H) = f.ker.map (Quotient.mk I) 
goal: RingHom.ker (Ideal.Quotient.lift I f H) = Ideal.map (Ideal.Quotient.mk I) (RingHom.ker f)

full_name: Ideal.injective_lift_iff
code: lemma injective_lift_iff {I : Ideal R} {f : R →+* S} (H : ∀ (a : R), a ∈ I → f a = 0) :
    Injective (Quotient.lift I f H) ↔ ker f = I 
goal: Function.Injective ⇑(Ideal.Quotient.lift I f H) ↔ RingHom.ker f = I

full_name: Ideal.ker_Pi_Quotient_mk
code: lemma ker_Pi_Quotient_mk {ι : Type*} (I : ι → Ideal R) :
    ker (Pi.ringHom fun i : ι ↦ Quotient.mk (I i)) = ⨅ i, I i 
goal: RingHom.ker (Pi.ringHom fun i => Ideal.Quotient.mk (I i)) = ⨅ i, I i

full_name: Ideal.bot_quotient_isMaximal_iff
code: @[simp]
theorem bot_quotient_isMaximal_iff (I : Ideal R) : (⊥ : Ideal (R ⧸ I)).IsMaximal ↔ I.IsMaximal 
goal: ⊥.IsMaximal ↔ I.IsMaximal

full_name: Ideal.mem_quotient_iff_mem_sup
code: /-- See also `Ideal.mem_quotient_iff_mem` in case `I ≤ J`. -/
@[simp]
theorem mem_quotient_iff_mem_sup {I J : Ideal R} {x : R} :
    Quotient.mk I x ∈ J.map (Quotient.mk I) ↔ x ∈ J ⊔ I 
goal: (Ideal.Quotient.mk I) x ∈ Ideal.map (Ideal.Quotient.mk I) J ↔ x ∈ J ⊔ I

full_name: Ideal.mem_quotient_iff_mem
code: /-- See also `Ideal.mem_quotient_iff_mem_sup` if the assumption `I ≤ J` is not available. -/
theorem mem_quotient_iff_mem {I J : Ideal R} (hIJ : I ≤ J) {x : R} :
    Quotient.mk I x ∈ J.map (Quotient.mk I) ↔ x ∈ J 
goal: (Ideal.Quotient.mk I) x ∈ Ideal.map (Ideal.Quotient.mk I) J ↔ x ∈ J

full_name: Ideal.quotientInfToPiQuotient
code: /-- 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. -/
def quotientInfToPiQuotient (I : ι → Ideal R) : (R ⧸ ⨅ i, I i) →+* ∀ i, R ⧸ I i 
goal: R ⧸ ⨅ i, I i →+* (i : ι) → R ⧸ I i

full_name: Ideal.quotientInfToPiQuotient_mk
code: lemma quotientInfToPiQuotient_mk (I : ι → Ideal R) (x : R) :
    quotientInfToPiQuotient I (Quotient.mk _ x) = fun i : ι ↦ Quotient.mk (I i) x 
goal: (Ideal.quotientInfToPiQuotient I) ((Ideal.Quotient.mk (⨅ i, I i)) x) = fun i => (Ideal.Quotient.mk (I i)) x

full_name: Ideal.quotientInfToPiQuotient_mk'
code: lemma quotientInfToPiQuotient_mk' (I : ι → Ideal R) (x : R) (i : ι) :
    quotientInfToPiQuotient I (Quotient.mk _ x) i = Quotient.mk (I i) x 
goal: (Ideal.quotientInfToPiQuotient I) ((Ideal.Quotient.mk (⨅ i, I i)) x) i = (Ideal.Quotient.mk (I i)) x

full_name: Ideal.quotientInfToPiQuotient_inj
code: lemma quotientInfToPiQuotient_inj (I : ι → Ideal R) : Injective (quotientInfToPiQuotient I) 
goal: Function.Injective ⇑(Ideal.quotientInfToPiQuotient I)

full_name: Ideal.quotientInfToPiQuotient_surj
code: lemma quotientInfToPiQuotient_surj [Finite ι] {I : ι → Ideal R}
    (hI : Pairwise fun i j => IsCoprime (I i) (I j)) : Surjective (quotientInfToPiQuotient I) 
goal: Function.Surjective ⇑(Ideal.quotientInfToPiQuotient I)

full_name: Ideal.quotientInfRingEquivPiQuotient
code: /-- **Chinese Remainder Theorem**. Eisenbud Ex.2.6.
Similar to Atiyah-Macdonald 1.10 and Stacks 00DT -/
noncomputable def quotientInfRingEquivPiQuotient [Finite ι] (f : ι → Ideal R)
    (hf : Pairwise fun i j => IsCoprime (f i) (f j)) : (R ⧸ ⨅ i, f i) ≃+* ∀ i, R ⧸ f i 
goal: R ⧸ ⨅ i, f i ≃+* ((i : ι) → R ⧸ f i)

full_name: Ideal.pi_quotient_surjective
code: /-- Corollary of Chinese Remainder Theorem: if `Iᵢ` are pairwise coprime ideals in a
commutative ring then the canonical map `R → ∏ (R ⧸ Iᵢ)` is surjective. -/
lemma pi_quotient_surjective {R : Type*} [CommRing R] {ι : Type*} [Finite ι] {I : ι → Ideal R}
    (hf : Pairwise fun i j ↦ IsCoprime (I i) (I j)) (x : (i : ι) → R ⧸ I i) :
    ∃ r : R, ∀ i, r = x i 
goal: ∃ r, ∀ (i : ι), (Ideal.Quotient.mk (I i)) r = x i

full_name: Ideal.exists_forall_sub_mem_ideal
code: /-- 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`. -/
lemma exists_forall_sub_mem_ideal {R : Type*} [CommRing R] {ι : Type*} [Finite ι]
    {I : ι → Ideal R} (hI : Pairwise fun i j ↦ IsCoprime (I i) (I j)) (x : ι → R) :
    ∃ r : R, ∀ i, r - x i ∈ I i 
goal: ∃ r, ∀ (i : ι), r - x i ∈ I i

full_name: Ideal.quotientInfEquivQuotientProd
code: /-- **Chinese remainder theorem**, specialized to two ideals. -/
noncomputable def quotientInfEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
    R ⧸ I ⊓ J ≃+* (R ⧸ I) × R ⧸ J 
goal: R ⧸ I ⊓ J ≃+* (R ⧸ I) × R ⧸ J

full_name: Ideal.quotientInfEquivQuotientProd_fst
code: @[simp]
theorem quotientInfEquivQuotientProd_fst (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I ⊓ J) :
    (quotientInfEquivQuotientProd I J coprime x).fst =
      Ideal.Quotient.factor (I ⊓ J) I inf_le_left x 
goal: ((I.quotientInfEquivQuotientProd J coprime) x).1 = (Ideal.Quotient.factor (I ⊓ J) I ⋯) x

full_name: Ideal.quotientInfEquivQuotientProd_snd
code: @[simp]
theorem quotientInfEquivQuotientProd_snd (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I ⊓ J) :
    (quotientInfEquivQuotientProd I J coprime x).snd =
      Ideal.Quotient.factor (I ⊓ J) J inf_le_right x 
goal: ((I.quotientInfEquivQuotientProd J coprime) x).2 = (Ideal.Quotient.factor (I ⊓ J) J ⋯) x

full_name: Ideal.fst_comp_quotientInfEquivQuotientProd
code: @[simp]
theorem 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 (I ⊓ J) I inf_le_left 
goal: (RingHom.fst (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientInfEquivQuotientProd J coprime) = Ideal.Quotient.factor (I ⊓ J) I ⋯

full_name: Ideal.snd_comp_quotientInfEquivQuotientProd
code: @[simp]
theorem 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 (I ⊓ J) J inf_le_right 
goal: (RingHom.snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientInfEquivQuotientProd J coprime) = Ideal.Quotient.factor (I ⊓ J) J ⋯

full_name: Ideal.quotientMulEquivQuotientProd
code: /-- **Chinese remainder theorem**, specialized to two ideals. -/
noncomputable def quotientMulEquivQuotientProd (I J : Ideal R) (coprime : IsCoprime I J) :
    R ⧸ I * J ≃+* (R ⧸ I) × R ⧸ J 
goal: R ⧸ I * J ≃+* (R ⧸ I) × R ⧸ J

full_name: Ideal.quotientMulEquivQuotientProd_fst
code: @[simp]
theorem quotientMulEquivQuotientProd_fst (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I * J) :
    (quotientMulEquivQuotientProd I J coprime x).fst =
      Ideal.Quotient.factor (I * J) I mul_le_right x 
goal: ((I.quotientMulEquivQuotientProd J coprime) x).1 = (Ideal.Quotient.factor (I * J) I ⋯) x

full_name: Ideal.quotientMulEquivQuotientProd_snd
code: @[simp]
theorem quotientMulEquivQuotientProd_snd (I J : Ideal R) (coprime : IsCoprime I J) (x : R ⧸ I * J) :
    (quotientMulEquivQuotientProd I J coprime x).snd =
      Ideal.Quotient.factor (I * J) J mul_le_left x 
goal: ((I.quotientMulEquivQuotientProd J coprime) x).2 = (Ideal.Quotient.factor (I * J) J ⋯) x

full_name: Ideal.fst_comp_quotientMulEquivQuotientProd
code: @[simp]
theorem 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 (I * J) I mul_le_right 
goal: (RingHom.fst (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime) = Ideal.Quotient.factor (I * J) I ⋯

full_name: Ideal.snd_comp_quotientMulEquivQuotientProd
code: @[simp]
theorem 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 (I * J) J mul_le_left 
goal: (RingHom.snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientMulEquivQuotientProd J coprime) = Ideal.Quotient.factor (I * J) J ⋯

full_name: Ideal.Quotient.algebra
code: /-- The `R₁`-algebra structure on `A/I` for an `R₁`-algebra `A` -/
instance Quotient.algebra {I : Ideal A} : Algebra R₁ (A ⧸ I) 
goal: Algebra R₁ (A ⧸ I)

full_name: Ideal.Quotient.isScalarTower
code: instance Quotient.isScalarTower [SMul R₁ R₂] [IsScalarTower R₁ R₂ A] (I : Ideal A) :
    IsScalarTower R₁ R₂ (A ⧸ I) 
goal: IsScalarTower R₁ R₂ (A ⧸ I)

full_name: Ideal.Quotient.mkₐ
code: /-- The canonical morphism `A →ₐ[R₁] A ⧸ I` as morphism of `R₁`-algebras, for `I` an ideal of
`A`, where `A` is an `R₁`-algebra. -/
def Quotient.mkₐ (I : Ideal A) : A →ₐ[R₁] A ⧸ I 
goal: A →ₐ[R₁] A ⧸ I

full_name: Ideal.Quotient.algHom_ext
code: theorem Quotient.algHom_ext {I : Ideal A} {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 
goal: f = g

full_name: Ideal.Quotient.alg_map_eq
code: theorem Quotient.alg_map_eq (I : Ideal A) :
    algebraMap R₁ (A ⧸ I) = (algebraMap A (A ⧸ I)).comp (algebraMap R₁ A) 
goal: algebraMap R₁ (A ⧸ I) = (algebraMap A (A ⧸ I)).comp (algebraMap R₁ A)

full_name: Ideal.Quotient.mkₐ_toRingHom
code: theorem Quotient.mkₐ_toRingHom (I : Ideal A) :
    (Quotient.mkₐ R₁ I).toRingHom = Ideal.Quotient.mk I 
goal: (Ideal.Quotient.mkₐ R₁ I).toRingHom = Ideal.Quotient.mk I

full_name: Ideal.Quotient.mkₐ_eq_mk
code: @[simp]
theorem Quotient.mkₐ_eq_mk (I : Ideal A) : ⇑(Quotient.mkₐ R₁ I) = Quotient.mk I 
goal: ⇑(Ideal.Quotient.mkₐ R₁ I) = ⇑(Ideal.Quotient.mk I)

full_name: Ideal.Quotient.algebraMap_eq
code: @[simp]
theorem Quotient.algebraMap_eq (I : Ideal R) : algebraMap R (R ⧸ I) = Quotient.mk I 
goal: algebraMap R (R ⧸ I) = Ideal.Quotient.mk I

full_name: Ideal.Quotient.mk_comp_algebraMap
code: @[simp]
theorem Quotient.mk_comp_algebraMap (I : Ideal A) :
    (Quotient.mk I).comp (algebraMap R₁ A) = algebraMap R₁ (A ⧸ I) 
goal: (Ideal.Quotient.mk I).comp (algebraMap R₁ A) = algebraMap R₁ (A ⧸ I)

full_name: Ideal.Quotient.mk_algebraMap
code: @[simp]
theorem Quotient.mk_algebraMap (I : Ideal A) (x : R₁) :
    Quotient.mk I (algebraMap R₁ A x) = algebraMap R₁ (A ⧸ I) x 
goal: (Ideal.Quotient.mk I) ((algebraMap R₁ A) x) = (algebraMap R₁ (A ⧸ I)) x

full_name: Ideal.Quotient.mkₐ_surjective
code: /-- The canonical morphism `A →ₐ[R₁] I.quotient` is surjective. -/
theorem Quotient.mkₐ_surjective (I : Ideal A) : Function.Surjective (Quotient.mkₐ R₁ I) 
goal: Function.Surjective ⇑(Ideal.Quotient.mkₐ R₁ I)

full_name: Ideal.Quotient.mkₐ_ker
code: /-- The kernel of `A →ₐ[R₁] I.quotient` is `I`. -/
@[simp]
theorem Quotient.mkₐ_ker (I : Ideal A) : RingHom.ker (Quotient.mkₐ R₁ I : A →+* A ⧸ I) = I 
goal: RingHom.ker ↑(Ideal.Quotient.mkₐ R₁ I) = I

full_name: Ideal.Quotient.liftₐ
code: /-- `Ideal.quotient.lift` as an `AlgHom`. -/
def Quotient.liftₐ (I : Ideal A) (f : A →ₐ[R₁] B) (hI : ∀ a : A, a ∈ I → f a = 0) :
    A ⧸ I →ₐ[R₁] B 
goal: A ⧸ I →ₐ[R₁] B

full_name: Ideal.Quotient.liftₐ_apply
code: @[simp]
theorem Quotient.liftₐ_apply (I : Ideal A) (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 
goal: (Ideal.Quotient.liftₐ I f hI) x = (Ideal.Quotient.lift I (↑f) hI) x

full_name: Ideal.Quotient.liftₐ_comp
code: theorem Quotient.liftₐ_comp (I : Ideal A) (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 
goal: (Ideal.Quotient.liftₐ I f hI).comp (Ideal.Quotient.mkₐ R₁ I) = f

full_name: Ideal.KerLift.map_smul
code: theorem KerLift.map_smul (f : A →ₐ[R₁] B) (r : R₁) (x : A ⧸ (RingHom.ker f)) :
    f.kerLift (r • x) = r • f.kerLift x 
goal: f.kerLift (r • x) = r • f.kerLift x

full_name: Ideal.kerLiftAlg
code: /-- The induced algebras morphism from the quotient by the kernel to the codomain.

This is an isomorphism if `f` has a right inverse (`quotientKerAlgEquivOfRightInverse`) /
is surjective (`quotientKerAlgEquivOfSurjective`).
-/
def kerLiftAlg (f : A →ₐ[R₁] B) : A ⧸ (RingHom.ker f) →ₐ[R₁] B 
goal: A ⧸ RingHom.ker f →ₐ[R₁] B

full_name: Ideal.kerLiftAlg_mk
code: @[simp]
theorem kerLiftAlg_mk (f : A →ₐ[R₁] B) (a : A) :
    kerLiftAlg f (Quotient.mk (RingHom.ker f) a) = f a 
goal: (Ideal.kerLiftAlg f) ((Ideal.Quotient.mk (RingHom.ker f)) a) = f a

full_name: Ideal.kerLiftAlg_toRingHom
code: @[simp]
theorem kerLiftAlg_toRingHom (f : A →ₐ[R₁] B) :
    (kerLiftAlg f : A ⧸ ker f →+* B) = RingHom.kerLift (f : A →+* B) 
goal: ↑(Ideal.kerLiftAlg f) = (↑f).kerLift

full_name: Ideal.kerLiftAlg_injective
code: /-- The induced algebra morphism from the quotient by the kernel is injective. -/
theorem kerLiftAlg_injective (f : A →ₐ[R₁] B) : Function.Injective (kerLiftAlg f) 
goal: Function.Injective ⇑(Ideal.kerLiftAlg f)

full_name: Ideal.quotientKerAlgEquivOfRightInverse_apply
code: /-- The **first isomorphism** theorem for algebras, computable version. -/
@[simps!]
def quotientKerAlgEquivOfRightInverse {f : A →ₐ[R₁] B} {g : B → A}
    (hf : Function.RightInverse g f) : (A ⧸ RingHom.ker f) ≃ₐ[R₁] B 
goal: (Ideal.quotientKerAlgEquivOfRightInverse hf) a = (↑f).kerLift a

full_name: Ideal.quotientKerAlgEquivOfRightInverse_symm_apply
code: /-- The **first isomorphism** theorem for algebras, computable version. -/
@[simps!]
def quotientKerAlgEquivOfRightInverse {f : A →ₐ[R₁] B} {g : B → A}
    (hf : Function.RightInverse g f) : (A ⧸ RingHom.ker f) ≃ₐ[R₁] B 
goal: ∀ (a : B), (Ideal.quotientKerAlgEquivOfRightInverse hf).symm a = (Ideal.Quotient.mk (RingHom.ker ↑f)) (g a)

full_name: Ideal.quotientKerAlgEquivOfRightInverse
code: /-- The **first isomorphism** theorem for algebras, computable version. -/
@[simps!]
def quotientKerAlgEquivOfRightInverse {f : A →ₐ[R₁] B} {g : B → A}
    (hf : Function.RightInverse g f) : (A ⧸ RingHom.ker f) ≃ₐ[R₁] B 
goal: (A ⧸ RingHom.ker f) ≃ₐ[R₁] B

full_name: Ideal.quotientKerAlgEquivOfSurjective_symm_apply
code: /-- The **first isomorphism theorem** for algebras. -/
@[simps!]
noncomputable def quotientKerAlgEquivOfSurjective {f : A →ₐ[R₁] B} (hf : Function.Surjective f) :
    (A ⧸ (RingHom.ker f)) ≃ₐ[R₁] B 
goal: ∀ (a : B),
  (Ideal.quotientKerAlgEquivOfSurjective hf).symm a = (Ideal.Quotient.mk (RingHom.ker ↑f)) (Classical.choose ⋯ a)

full_name: Ideal.quotientKerAlgEquivOfSurjective
code: /-- The **first isomorphism theorem** for algebras. -/
@[simps!]
noncomputable def quotientKerAlgEquivOfSurjective {f : A →ₐ[R₁] B} (hf : Function.Surjective f) :
    (A ⧸ (RingHom.ker f)) ≃ₐ[R₁] B 
goal: (A ⧸ RingHom.ker f) ≃ₐ[R₁] B

full_name: Ideal.quotientKerAlgEquivOfSurjective_apply
code: /-- The **first isomorphism theorem** for algebras. -/
@[simps!]
noncomputable def quotientKerAlgEquivOfSurjective {f : A →ₐ[R₁] B} (hf : Function.Surjective f) :
    (A ⧸ (RingHom.ker f)) ≃ₐ[R₁] B 
goal: (Ideal.quotientKerAlgEquivOfSurjective hf) a = (↑f).kerLift a

full_name: Ideal.quotientMap
code: /-- The ring hom `R/I →+* S/J` induced by a ring hom `f : R →+* S` with `I ≤ f⁻¹(J)` -/
def quotientMap {I : Ideal R} (J : Ideal S) (f : R →+* S) (hIJ : I ≤ J.comap f) : R ⧸ I →+* S ⧸ J 
goal: R ⧸ I →+* S ⧸ J

full_name: Ideal.quotientMap_mk
code: @[simp]
theorem quotientMap_mk {J : Ideal R} {I : Ideal S} {f : R →+* S} {H : J ≤ I.comap f} {x : R} :
    quotientMap I f H (Quotient.mk J x) = Quotient.mk I (f x) 
goal: (Ideal.quotientMap I f H) ((Ideal.Quotient.mk J) x) = (Ideal.Quotient.mk I) (f x)

full_name: Ideal.quotientMap_algebraMap
code: @[simp]
theorem quotientMap_algebraMap {J : Ideal A} {I : Ideal S} {f : A →+* S} {H : J ≤ I.comap f}
    {x : R₁} : quotientMap I f H (algebraMap R₁ (A ⧸ J) x) = Quotient.mk I (f (algebraMap _ _ x)) 
goal: (Ideal.quotientMap I f H) ((algebraMap R₁ (A ⧸ J)) x) = (Ideal.Quotient.mk I) (f ((algebraMap R₁ A) x))

full_name: Ideal.quotientMap_comp_mk
code: theorem quotientMap_comp_mk {J : Ideal R} {I : Ideal S} {f : R →+* S} (H : J ≤ I.comap f) :
    (quotientMap I f H).comp (Quotient.mk J) = (Quotient.mk I).comp f 
goal: (Ideal.quotientMap I f H).comp (Ideal.Quotient.mk J) = (Ideal.Quotient.mk I).comp f

full_name: Ideal.quotientEquiv_symm_apply
code: /-- The ring equiv `R/I ≃+* S/J` induced by a ring equiv `f : R ≃+* S`, where `J = f(I)`. -/
@[simps]
def quotientEquiv (I : Ideal R) (J : Ideal S) (f : R ≃+* S) (hIJ : J = I.map (f : R →+* S)) :
    R ⧸ I ≃+* S ⧸ J 
goal: (I.quotientEquiv J f hIJ).symm a = (Ideal.quotientMap I ↑f.symm ⋯) a

full_name: Ideal.quotientEquiv_apply
code: /-- The ring equiv `R/I ≃+* S/J` induced by a ring equiv `f : R ≃+* S`, where `J = f(I)`. -/
@[simps]
def quotientEquiv (I : Ideal R) (J : Ideal S) (f : R ≃+* S) (hIJ : J = I.map (f : R →+* S)) :
    R ⧸ I ≃+* S ⧸ J 
goal: ∀ (a : R ⧸ I), (I.quotientEquiv J f hIJ) a = (↑↑(Ideal.quotientMap J ↑f ⋯)).toFun a

full_name: Ideal.quotientEquiv
code: /-- The ring equiv `R/I ≃+* S/J` induced by a ring equiv `f : R ≃+* S`, where `J = f(I)`. -/
@[simps]
def quotientEquiv (I : Ideal R) (J : Ideal S) (f : R ≃+* S) (hIJ : J = I.map (f : R →+* S)) :
    R ⧸ I ≃+* S ⧸ J 
goal: R ⧸ I ≃+* S ⧸ J

full_name: Ideal.quotientEquiv_mk
code: theorem quotientEquiv_mk (I : Ideal R) (J : Ideal S) (f : R ≃+* S) (hIJ : J = I.map (f : R →+* S))
    (x : R) : quotientEquiv I J f hIJ (Ideal.Quotient.mk I x) = Ideal.Quotient.mk J (f x) 
goal: (I.quotientEquiv J f hIJ) ((Ideal.Quotient.mk I) x) = (Ideal.Quotient.mk J) (f x)

full_name: Ideal.quotientEquiv_symm_mk
code: @[simp]
theorem quotientEquiv_symm_mk (I : Ideal R) (J : Ideal S) (f : R ≃+* S)
    (hIJ : J = I.map (f : R →+* S)) (x : S) :
    (quotientEquiv I J f hIJ).symm (Ideal.Quotient.mk J x) = Ideal.Quotient.mk I (f.symm x) 
goal: (I.quotientEquiv J f hIJ).symm ((Ideal.Quotient.mk J) x) = (Ideal.Quotient.mk I) (f.symm x)

full_name: Ideal.quotientMap_injective'
code: /-- `H` and `h` are kept as separate hypothesis since H is used in constructing the quotient map. -/
theorem quotientMap_injective' {J : Ideal R} {I : Ideal S} {f : R →+* S} {H : J ≤ I.comap f}
    (h : I.comap f ≤ J) : Function.Injective (quotientMap I f H) 
goal: Function.Injective ⇑(Ideal.quotientMap I f H)

full_name: Ideal.quotientMap_injective
code: /-- If we take `J = I.comap f` then `QuotientMap` is injective automatically. -/
theorem quotientMap_injective {I : Ideal S} {f : R →+* S} :
    Function.Injective (quotientMap I f le_rfl) 
goal: Function.Injective ⇑(Ideal.quotientMap I f ⋯)

full_name: Ideal.quotientMap_surjective
code: theorem quotientMap_surjective {J : Ideal R} {I : Ideal S} {f : R →+* S} {H : J ≤ I.comap f}
    (hf : Function.Surjective f) : Function.Surjective (quotientMap I f H) 
goal: Function.Surjective ⇑(Ideal.quotientMap I f H)

full_name: Ideal.comp_quotientMap_eq_of_comp_eq
code: /-- Commutativity of a square is preserved when taking quotients by an ideal. -/
theorem comp_quotientMap_eq_of_comp_eq {R' S' : Type*} [CommRing R'] [CommRing S'] {f : R →+* S}
    {f' : R' →+* S'} {g : R →+* R'} {g' : S →+* S'} (hfg : f'.comp g = g'.comp f) (I : Ideal S') :
    -- Porting note: was losing track of I
    let leq := le_of_eq (_root_.trans (comap_comap (I := I) f g') (hfg ▸ comap_comap (I := I) g f'))
    (quotientMap I g' le_rfl).comp (quotientMap (I.comap g') f le_rfl) =
    (quotientMap I f' le_rfl).comp (quotientMap (I.comap f') g leq) 
goal: let leq := ⋯;
(Ideal.quotientMap I g' ⋯).comp (Ideal.quotientMap (Ideal.comap g' I) f ⋯) =
  (Ideal.quotientMap I f' ⋯).comp (Ideal.quotientMap (Ideal.comap f' I) g leq)

full_name: Ideal.quotientMapₐ
code: /-- The algebra hom `A/I →+* B/J` induced by an algebra hom `f : A →ₐ[R₁] B` with `I ≤ f⁻¹(J)`. -/
def quotientMapₐ {I : Ideal A} (J : Ideal B) (f : A →ₐ[R₁] B) (hIJ : I ≤ J.comap f) :
    A ⧸ I →ₐ[R₁] B ⧸ J 
goal: A ⧸ I →ₐ[R₁] B ⧸ J

full_name: Ideal.quotient_map_mkₐ
code: @[simp]
theorem quotient_map_mkₐ {I : Ideal A} (J : Ideal B) (f : A →ₐ[R₁] B) (H : I ≤ J.comap f) {x : A} :
    quotientMapₐ J f H (Quotient.mk I x) = Quotient.mkₐ R₁ J (f x) 
goal: (Ideal.quotientMapₐ J f H) ((Ideal.Quotient.mk I) x) = (Ideal.Quotient.mkₐ R₁ J) (f x)

full_name: Ideal.quotient_map_comp_mkₐ
code: theorem quotient_map_comp_mkₐ {I : Ideal A} (J : Ideal B) (f : A →ₐ[R₁] B) (H : I ≤ J.comap f) :
    (quotientMapₐ J f H).comp (Quotient.mkₐ R₁ I) = (Quotient.mkₐ R₁ J).comp f 
goal: (Ideal.quotientMapₐ J f H).comp (Ideal.Quotient.mkₐ R₁ I) = (Ideal.Quotient.mkₐ R₁ J).comp f

full_name: Ideal.quotientEquivAlg
code: /-- The algebra equiv `A/I ≃ₐ[R] B/J` induced by an algebra equiv `f : A ≃ₐ[R] B`,
where`J = f(I)`. -/
def quotientEquivAlg (I : Ideal A) (J : Ideal B) (f : A ≃ₐ[R₁] B) (hIJ : J = I.map (f : A →+* B)) :
    (A ⧸ I) ≃ₐ[R₁] B ⧸ J 
goal: (A ⧸ I) ≃ₐ[R₁] B ⧸ J

full_name: Ideal.quotientAlgebra
code: instance (priority := 100) quotientAlgebra {I : Ideal A} [Algebra R A] :
    Algebra (R ⧸ I.comap (algebraMap R A)) (A ⧸ I) 
goal: Algebra (R ⧸ Ideal.comap (algebraMap R A) I) (A ⧸ I)

full_name: Ideal.algebraMap_quotient_injective
code: theorem algebraMap_quotient_injective {I : Ideal A} [Algebra R A] :
    Function.Injective (algebraMap (R ⧸ I.comap (algebraMap R A)) (A ⧸ I)) 
goal: Function.Injective ⇑(algebraMap (R ⧸ Ideal.comap (algebraMap R A) I) (A ⧸ I))

full_name: Ideal.quotientEquivAlgOfEq
code: /-- Quotienting by equal ideals gives equivalent algebras. -/
def quotientEquivAlgOfEq {I J : Ideal A} (h : I = J) : (A ⧸ I) ≃ₐ[R₁] A ⧸ J 
goal: (A ⧸ I) ≃ₐ[R₁] A ⧸ J

full_name: Ideal.quotientEquivAlgOfEq_mk
code: @[simp]
theorem quotientEquivAlgOfEq_mk {I J : Ideal A} (h : I = J) (x : A) :
    quotientEquivAlgOfEq R₁ h (Ideal.Quotient.mk I x) = Ideal.Quotient.mk J x 
goal: (Ideal.quotientEquivAlgOfEq R₁ h) ((Ideal.Quotient.mk I) x) = (Ideal.Quotient.mk J) x

full_name: Ideal.quotientEquivAlgOfEq_symm
code: @[simp]
theorem quotientEquivAlgOfEq_symm {I J : Ideal A} (h : I = J) :
    (quotientEquivAlgOfEq R₁ h).symm = quotientEquivAlgOfEq R₁ h.symm 
goal: (Ideal.quotientEquivAlgOfEq R₁ h).symm = Ideal.quotientEquivAlgOfEq R₁ ⋯

full_name: Ideal.comap_map_mk
code: lemma comap_map_mk {I J : Ideal R} (h : I ≤ J) :
    Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J 
goal: Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J

full_name: Ideal.quotientKerEquivRange
code: /-- The **first isomorphism theorem** for commutative algebras (`AlgHom.range` version). -/
noncomputable def quotientKerEquivRange
  {A B : Type*} [CommRing A] [Algebra R A] [Semiring B] [Algebra R B]
  (f : A →ₐ[R] B) :
  (A ⧸ RingHom.ker f) ≃ₐ[R] f.range 
goal: (A ⧸ RingHom.ker f) ≃ₐ[R] ↥f.range

full_name: DoubleQuot.quotLeftToQuotSup
code: /-- The obvious ring hom `R/I → R/(I ⊔ J)` -/
def quotLeftToQuotSup : R ⧸ I →+* R ⧸ I ⊔ J 
goal: R ⧸ I →+* R ⧸ I ⊔ J

full_name: DoubleQuot.ker_quotLeftToQuotSup
code: /-- The kernel of `quotLeftToQuotSup` -/
theorem ker_quotLeftToQuotSup : RingHom.ker (quotLeftToQuotSup I J) =
    J.map (Ideal.Quotient.mk I) 
goal: RingHom.ker (DoubleQuot.quotLeftToQuotSup I J) = Ideal.map (Ideal.Quotient.mk I) J

full_name: DoubleQuot.quotQuotToQuotSup
code: /-- The ring homomorphism `(R/I)/J' -> R/(I ⊔ J)` induced by `quotLeftToQuotSup` where `J'`
  is the image of `J` in `R/I`-/
def quotQuotToQuotSup : (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) →+* R ⧸ I ⊔ J 
goal: (R ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mk I) J →+* R ⧸ I ⊔ J

full_name: DoubleQuot.quotQuotMk
code: /-- The composite of the maps `R → (R/I)` and `(R/I) → (R/I)/J'` -/
def quotQuotMk : R →+* (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) 
goal: R →+* (R ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mk I) J

full_name: DoubleQuot.ker_quotQuotMk
code: /-- The kernel of `quotQuotMk` -/
theorem ker_quotQuotMk : RingHom.ker (quotQuotMk I J) = I ⊔ J 
goal: RingHom.ker (DoubleQuot.quotQuotMk I J) = I ⊔ J

full_name: DoubleQuot.liftSupQuotQuotMk
code: /-- The ring homomorphism `R/(I ⊔ J) → (R/I)/J' `induced by `quotQuotMk` -/
def liftSupQuotQuotMk (I J : Ideal R) : R ⧸ I ⊔ J →+* (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) 
goal: R ⧸ I ⊔ J →+* (R ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mk I) J

full_name: DoubleQuot.quotQuotEquivQuotSup
code: /-- `quotQuotToQuotSup` and `liftSupQuotQuotMk` are inverse isomorphisms. In the case where
    `I ≤ J`, this is the Third Isomorphism Theorem (see `quotQuotEquivQuotOfLe`)-/
def quotQuotEquivQuotSup : (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) ≃+* R ⧸ I ⊔ J 
goal: (R ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mk I) J ≃+* R ⧸ I ⊔ J

full_name: DoubleQuot.quotQuotEquivQuotSup_quotQuotMk
code: @[simp]
theorem quotQuotEquivQuotSup_quotQuotMk (x : R) :
    quotQuotEquivQuotSup I J (quotQuotMk I J x) = Ideal.Quotient.mk (I ⊔ J) x 
goal: (DoubleQuot.quotQuotEquivQuotSup I J) ((DoubleQuot.quotQuotMk I J) x) = (Ideal.Quotient.mk (I ⊔ J)) x

full_name: DoubleQuot.quotQuotEquivQuotSup_symm_quotQuotMk
code: @[simp]
theorem quotQuotEquivQuotSup_symm_quotQuotMk (x : R) :
    (quotQuotEquivQuotSup I J).symm (Ideal.Quotient.mk (I ⊔ J) x) = quotQuotMk I J x 
goal: (DoubleQuot.quotQuotEquivQuotSup I J).symm ((Ideal.Quotient.mk (I ⊔ J)) x) = (DoubleQuot.quotQuotMk I J) x

full_name: DoubleQuot.quotQuotEquivComm
code: /-- The obvious isomorphism `(R/I)/J' → (R/J)/I'` -/
def quotQuotEquivComm : (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) ≃+*
    (R ⧸ J) ⧸ I.map (Ideal.Quotient.mk J) 
goal: (R ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mk I) J ≃+* (R ⧸ J) ⧸ Ideal.map (Ideal.Quotient.mk J) I

full_name: DoubleQuot.quotQuotEquivComm_quotQuotMk
code: @[simp]
theorem quotQuotEquivComm_quotQuotMk (x : R) :
    quotQuotEquivComm I J (quotQuotMk I J x) = quotQuotMk J I x 
goal: (DoubleQuot.quotQuotEquivComm I J) ((DoubleQuot.quotQuotMk I J) x) = (DoubleQuot.quotQuotMk J I) x

full_name: DoubleQuot.quotQuotEquivComm_comp_quotQuotMk
code: @[simp]
theorem quotQuotEquivComm_comp_quotQuotMk :
    RingHom.comp (↑(quotQuotEquivComm I J)) (quotQuotMk I J) = quotQuotMk J I 
goal: (↑(DoubleQuot.quotQuotEquivComm I J)).comp (DoubleQuot.quotQuotMk I J) = DoubleQuot.quotQuotMk J I

full_name: DoubleQuot.quotQuotEquivComm_symm
code: @[simp]
theorem quotQuotEquivComm_symm : (quotQuotEquivComm I J).symm = quotQuotEquivComm J I 
goal: (DoubleQuot.quotQuotEquivComm I J).symm = DoubleQuot.quotQuotEquivComm J I

full_name: DoubleQuot.quotQuotEquivQuotOfLE
code: /-- **The Third Isomorphism theorem** for rings. See `quotQuotEquivQuotSup` for a version
    that does not assume an inclusion of ideals. -/
def quotQuotEquivQuotOfLE (h : I ≤ J) : (R ⧸ I) ⧸ J.map (Ideal.Quotient.mk I) ≃+* R ⧸ J 
goal: (R ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mk I) J ≃+* R ⧸ J

full_name: DoubleQuot.quotQuotEquivQuotOfLE_quotQuotMk
code: @[simp]
theorem quotQuotEquivQuotOfLE_quotQuotMk (x : R) (h : I ≤ J) :
    quotQuotEquivQuotOfLE h (quotQuotMk I J x) = (Ideal.Quotient.mk J) x 
goal: (DoubleQuot.quotQuotEquivQuotOfLE h) ((DoubleQuot.quotQuotMk I J) x) = (Ideal.Quotient.mk J) x

full_name: DoubleQuot.quotQuotEquivQuotOfLE_symm_mk
code: @[simp]
theorem quotQuotEquivQuotOfLE_symm_mk (x : R) (h : I ≤ J) :
    (quotQuotEquivQuotOfLE h).symm ((Ideal.Quotient.mk J) x) = quotQuotMk I J x 
goal: (DoubleQuot.quotQuotEquivQuotOfLE h).symm ((Ideal.Quotient.mk J) x) = (DoubleQuot.quotQuotMk I J) x

full_name: DoubleQuot.quotQuotEquivQuotOfLE_comp_quotQuotMk
code: theorem quotQuotEquivQuotOfLE_comp_quotQuotMk (h : I ≤ J) :
    RingHom.comp (↑(quotQuotEquivQuotOfLE h)) (quotQuotMk I J) = (Ideal.Quotient.mk J) 
goal: (↑(DoubleQuot.quotQuotEquivQuotOfLE h)).comp (DoubleQuot.quotQuotMk I J) = Ideal.Quotient.mk J

full_name: DoubleQuot.quotQuotEquivQuotOfLE_symm_comp_mk
code: theorem quotQuotEquivQuotOfLE_symm_comp_mk (h : I ≤ J) :
    RingHom.comp (↑(quotQuotEquivQuotOfLE h).symm) (Ideal.Quotient.mk J) = quotQuotMk I J 
goal: (↑(DoubleQuot.quotQuotEquivQuotOfLE h).symm).comp (Ideal.Quotient.mk J) = DoubleQuot.quotQuotMk I J

full_name: DoubleQuot.quotQuotEquivComm_mk_mk
code: @[simp]
theorem quotQuotEquivComm_mk_mk [CommRing R] (I J : Ideal R) (x : R) :
    quotQuotEquivComm I J (Ideal.Quotient.mk _ (Ideal.Quotient.mk _ x)) = algebraMap R _ x 
goal: (DoubleQuot.quotQuotEquivComm I J) ((Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk I) J)) ((Ideal.Quotient.mk I) x)) =
  (algebraMap R ((R ⧸ J) ⧸ Ideal.map (Ideal.Quotient.mk J) I)) x

full_name: DoubleQuot.quotQuotEquivQuotSup_quot_quot_algebraMap
code: @[simp]
theorem quotQuotEquivQuotSup_quot_quot_algebraMap (x : R) :
    DoubleQuot.quotQuotEquivQuotSup I J (algebraMap R _ x) = algebraMap _ _ x 
goal: (DoubleQuot.quotQuotEquivQuotSup I J) ((algebraMap R ((A ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mk I) J)) x) =
  (algebraMap R (A ⧸ I ⊔ J)) x

full_name: DoubleQuot.quotQuotEquivComm_algebraMap
code: @[simp]
theorem quotQuotEquivComm_algebraMap (x : R) :
    quotQuotEquivComm I J (algebraMap R _ x) = algebraMap _ _ x 
goal: (DoubleQuot.quotQuotEquivComm I J) ((algebraMap R ((A ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mk I) J)) x) =
  (algebraMap R ((A ⧸ J) ⧸ Ideal.map (Ideal.Quotient.mk J) I)) x

full_name: DoubleQuot.quotLeftToQuotSupₐ
code: /-- The natural algebra homomorphism `A / I → A / (I ⊔ J)`. -/
def quotLeftToQuotSupₐ : A ⧸ I →ₐ[R] A ⧸ I ⊔ J 
goal: A ⧸ I →ₐ[R] A ⧸ I ⊔ J

full_name: DoubleQuot.quotLeftToQuotSupₐ_toRingHom
code: @[simp]
theorem quotLeftToQuotSupₐ_toRingHom :
    (quotLeftToQuotSupₐ R I J : _ →+* _) = quotLeftToQuotSup I J 
goal: ↑(DoubleQuot.quotLeftToQuotSupₐ R I J) = DoubleQuot.quotLeftToQuotSup I J

full_name: DoubleQuot.coe_quotLeftToQuotSupₐ
code: @[simp]
theorem coe_quotLeftToQuotSupₐ : ⇑(quotLeftToQuotSupₐ R I J) = quotLeftToQuotSup I J 
goal: ⇑(DoubleQuot.quotLeftToQuotSupₐ R I J) = ⇑(DoubleQuot.quotLeftToQuotSup I J)

full_name: DoubleQuot.quotQuotToQuotSupₐ
code: /-- The algebra homomorphism `(A / I) / J' -> A / (I ⊔ J)` induced by `quotQuotToQuotSup`,
  where `J'` is the projection of `J` in `A / I`. -/
def quotQuotToQuotSupₐ : (A ⧸ I) ⧸ J.map (Quotient.mkₐ R I) →ₐ[R] A ⧸ I ⊔ J 
goal: (A ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mkₐ R I) J →ₐ[R] A ⧸ I ⊔ J

full_name: DoubleQuot.quotQuotToQuotSupₐ_toRingHom
code: @[simp]
theorem quotQuotToQuotSupₐ_toRingHom :
    ((quotQuotToQuotSupₐ R I J) : _ ⧸ map (Ideal.Quotient.mkₐ R I) J →+* _) =
      quotQuotToQuotSup I J 
goal: ↑(DoubleQuot.quotQuotToQuotSupₐ R I J) = DoubleQuot.quotQuotToQuotSup I J

full_name: DoubleQuot.coe_quotQuotToQuotSupₐ
code: @[simp]
theorem coe_quotQuotToQuotSupₐ : ⇑(quotQuotToQuotSupₐ R I J) = quotQuotToQuotSup I J 
goal: ⇑(DoubleQuot.quotQuotToQuotSupₐ R I J) = ⇑(DoubleQuot.quotQuotToQuotSup I J)

full_name: DoubleQuot.quotQuotMkₐ
code: /-- The composition of the algebra homomorphisms `A → (A / I)` and `(A / I) → (A / I) / J'`,
  where `J'` is the projection `J` in `A / I`. -/
def quotQuotMkₐ : A →ₐ[R] (A ⧸ I) ⧸ J.map (Quotient.mkₐ R I) 
goal: A →ₐ[R] (A ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mkₐ R I) J

full_name: DoubleQuot.quotQuotMkₐ_toRingHom
code: @[simp]
theorem quotQuotMkₐ_toRingHom :
    (quotQuotMkₐ R I J : _ →+* _ ⧸ J.map (Quotient.mkₐ R I)) = quotQuotMk I J 
goal: ↑(DoubleQuot.quotQuotMkₐ R I J) = DoubleQuot.quotQuotMk I J

full_name: DoubleQuot.coe_quotQuotMkₐ
code: @[simp]
theorem coe_quotQuotMkₐ : ⇑(quotQuotMkₐ R I J) = quotQuotMk I J 
goal: ⇑(DoubleQuot.quotQuotMkₐ R I J) = ⇑(DoubleQuot.quotQuotMk I J)

full_name: DoubleQuot.liftSupQuotQuotMkₐ
code: /-- The injective algebra homomorphism `A / (I ⊔ J) → (A / I) / J'`induced by `quot_quot_mk`,
  where `J'` is the projection `J` in `A / I`. -/
def liftSupQuotQuotMkₐ (I J : Ideal A) : A ⧸ I ⊔ J →ₐ[R] (A ⧸ I) ⧸ J.map (Quotient.mkₐ R I) 
goal: A ⧸ I ⊔ J →ₐ[R] (A ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mkₐ R I) J

full_name: DoubleQuot.liftSupQuotQuotMkₐ_toRingHom
code: @[simp]
theorem liftSupQuotQuotMkₐ_toRingHom :
    (liftSupQuotQuotMkₐ R I J : _ →+* _ ⧸ J.map (Quotient.mkₐ R I)) = liftSupQuotQuotMk I J 
goal: ↑(DoubleQuot.liftSupQuotQuotMkₐ R I J) = DoubleQuot.liftSupQuotQuotMk I J

full_name: DoubleQuot.coe_liftSupQuotQuotMkₐ
code: @[simp]
theorem coe_liftSupQuotQuotMkₐ : ⇑(liftSupQuotQuotMkₐ R I J) = liftSupQuotQuotMk I J 
goal: ⇑(DoubleQuot.liftSupQuotQuotMkₐ R I J) = ⇑(DoubleQuot.liftSupQuotQuotMk I J)

full_name: DoubleQuot.quotQuotEquivQuotSupₐ
code: /-- `quotQuotToQuotSup` and `liftSupQuotQuotMk` are inverse isomorphisms. In the case where
`I ≤ J`, this is the Third Isomorphism Theorem (see `DoubleQuot.quotQuotEquivQuotOfLE`). -/
def quotQuotEquivQuotSupₐ : ((A ⧸ I) ⧸ J.map (Quotient.mkₐ R I)) ≃ₐ[R] A ⧸ I ⊔ J 
goal: ((A ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mkₐ R I) J) ≃ₐ[R] A ⧸ I ⊔ J

full_name: DoubleQuot.quotQuotEquivQuotSupₐ_toRingEquiv
code: @[simp]
theorem quotQuotEquivQuotSupₐ_toRingEquiv :
    (quotQuotEquivQuotSupₐ R I J : _ ⧸ J.map (Quotient.mkₐ R I) ≃+* _) = quotQuotEquivQuotSup I J 
goal: ↑(DoubleQuot.quotQuotEquivQuotSupₐ R I J) = DoubleQuot.quotQuotEquivQuotSup I J

full_name: DoubleQuot.coe_quotQuotEquivQuotSupₐ
code: @[simp]
-- Porting note: had to add an extra coercion arrow on the right hand side.
theorem coe_quotQuotEquivQuotSupₐ : ⇑(quotQuotEquivQuotSupₐ R I J) = ⇑(quotQuotEquivQuotSup I J) 
goal: ⇑(DoubleQuot.quotQuotEquivQuotSupₐ R I J) = ⇑(DoubleQuot.quotQuotEquivQuotSup I J)

full_name: DoubleQuot.quotQuotEquivQuotSupₐ_symm_toRingEquiv
code: @[simp]
theorem quotQuotEquivQuotSupₐ_symm_toRingEquiv :
    ((quotQuotEquivQuotSupₐ R I J).symm : _ ≃+* _ ⧸ J.map (Quotient.mkₐ R I)) =
      (quotQuotEquivQuotSup I J).symm 
goal: ↑(DoubleQuot.quotQuotEquivQuotSupₐ R I J).symm = (DoubleQuot.quotQuotEquivQuotSup I J).symm

full_name: DoubleQuot.coe_quotQuotEquivQuotSupₐ_symm
code: @[simp]
-- Porting note: had to add an extra coercion arrow on the right hand side.
theorem coe_quotQuotEquivQuotSupₐ_symm :
    ⇑(quotQuotEquivQuotSupₐ R I J).symm = ⇑(quotQuotEquivQuotSup I J).symm 
goal: ⇑(DoubleQuot.quotQuotEquivQuotSupₐ R I J).symm = ⇑(DoubleQuot.quotQuotEquivQuotSup I J).symm

full_name: DoubleQuot.quotQuotEquivCommₐ
code: /-- The natural algebra isomorphism `(A / I) / J' → (A / J) / I'`,
  where `J'` (resp. `I'`) is the projection of `J` in `A / I` (resp. `I` in `A / J`). -/
def quotQuotEquivCommₐ :
    ((A ⧸ I) ⧸ J.map (Quotient.mkₐ R I)) ≃ₐ[R] (A ⧸ J) ⧸ I.map (Quotient.mkₐ R J) 
goal: ((A ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mkₐ R I) J) ≃ₐ[R] (A ⧸ J) ⧸ Ideal.map (Ideal.Quotient.mkₐ R J) I

full_name: DoubleQuot.quotQuotEquivCommₐ_toRingEquiv
code: @[simp]
theorem quotQuotEquivCommₐ_toRingEquiv :
    (quotQuotEquivCommₐ R I J : _ ⧸ J.map (Quotient.mkₐ R I) ≃+* _ ⧸ I.map (Quotient.mkₐ R J)) =
      quotQuotEquivComm I J 
goal: ↑(DoubleQuot.quotQuotEquivCommₐ R I J) = DoubleQuot.quotQuotEquivComm I J

full_name: DoubleQuot.coe_quotQuotEquivCommₐ
code: @[simp]
theorem coe_quotQuotEquivCommₐ : ⇑(quotQuotEquivCommₐ R I J) = ⇑(quotQuotEquivComm I J) 
goal: ⇑(DoubleQuot.quotQuotEquivCommₐ R I J) = ⇑(DoubleQuot.quotQuotEquivComm I J)

full_name: DoubleQuot.quotQuotEquivComm_symmₐ
code: @[simp]
theorem quotQuotEquivComm_symmₐ : (quotQuotEquivCommₐ R I J).symm = quotQuotEquivCommₐ R J I 
goal: (DoubleQuot.quotQuotEquivCommₐ R I J).symm = DoubleQuot.quotQuotEquivCommₐ R J I

full_name: DoubleQuot.quotQuotEquivComm_comp_quotQuotMkₐ
code: @[simp]
theorem quotQuotEquivComm_comp_quotQuotMkₐ :
    AlgHom.comp (↑(quotQuotEquivCommₐ R I J)) (quotQuotMkₐ R I J) = quotQuotMkₐ R J I 
goal: (↑(DoubleQuot.quotQuotEquivCommₐ R I J)).comp (DoubleQuot.quotQuotMkₐ R I J) = DoubleQuot.quotQuotMkₐ R J I

full_name: DoubleQuot.quotQuotEquivQuotOfLEₐ
code: /-- The **third isomorphism theorem** for algebras. See `quotQuotEquivQuotSupₐ` for version
    that does not assume an inclusion of ideals. -/
def quotQuotEquivQuotOfLEₐ (h : I ≤ J) : ((A ⧸ I) ⧸ J.map (Quotient.mkₐ R I)) ≃ₐ[R] A ⧸ J 
goal: ((A ⧸ I) ⧸ Ideal.map (Ideal.Quotient.mkₐ R I) J) ≃ₐ[R] A ⧸ J

full_name: DoubleQuot.quotQuotEquivQuotOfLEₐ_toRingEquiv
code: @[simp]
theorem quotQuotEquivQuotOfLEₐ_toRingEquiv (h : I ≤ J) :
    (quotQuotEquivQuotOfLEₐ R h : _ ⧸ J.map (Quotient.mkₐ R I) ≃+* _) = quotQuotEquivQuotOfLE h 
goal: ↑(DoubleQuot.quotQuotEquivQuotOfLEₐ R h) = DoubleQuot.quotQuotEquivQuotOfLE h

full_name: DoubleQuot.coe_quotQuotEquivQuotOfLEₐ
code: @[simp]
-- Porting note: had to add an extra coercion arrow on the right hand side.
theorem coe_quotQuotEquivQuotOfLEₐ (h : I ≤ J) :
    ⇑(quotQuotEquivQuotOfLEₐ R h) = ⇑(quotQuotEquivQuotOfLE h) 
goal: ⇑(DoubleQuot.quotQuotEquivQuotOfLEₐ R h) = ⇑(DoubleQuot.quotQuotEquivQuotOfLE h)

full_name: DoubleQuot.quotQuotEquivQuotOfLEₐ_symm_toRingEquiv
code: @[simp]
theorem quotQuotEquivQuotOfLEₐ_symm_toRingEquiv (h : I ≤ J) :
    ((quotQuotEquivQuotOfLEₐ R h).symm : _ ≃+* _ ⧸ J.map (Quotient.mkₐ R I)) =
      (quotQuotEquivQuotOfLE h).symm 
goal: ↑(DoubleQuot.quotQuotEquivQuotOfLEₐ R h).symm = (DoubleQuot.quotQuotEquivQuotOfLE h).symm

full_name: DoubleQuot.coe_quotQuotEquivQuotOfLEₐ_symm
code: @[simp]
-- Porting note: had to add an extra coercion arrow on the right hand side.
theorem coe_quotQuotEquivQuotOfLEₐ_symm (h : I ≤ J) :
    ⇑(quotQuotEquivQuotOfLEₐ R h).symm = ⇑(quotQuotEquivQuotOfLE h).symm 
goal: ⇑(DoubleQuot.quotQuotEquivQuotOfLEₐ R h).symm = ⇑(DoubleQuot.quotQuotEquivQuotOfLE h).symm

full_name: DoubleQuot.quotQuotEquivQuotOfLE_comp_quotQuotMkₐ
code: @[simp]
theorem quotQuotEquivQuotOfLE_comp_quotQuotMkₐ (h : I ≤ J) :
    AlgHom.comp (↑(quotQuotEquivQuotOfLEₐ R h)) (quotQuotMkₐ R I J) = Quotient.mkₐ R J 
goal: (↑(DoubleQuot.quotQuotEquivQuotOfLEₐ R h)).comp (DoubleQuot.quotQuotMkₐ R I J) = Ideal.Quotient.mkₐ R J

full_name: DoubleQuot.quotQuotEquivQuotOfLE_symm_comp_mkₐ
code: @[simp]
theorem quotQuotEquivQuotOfLE_symm_comp_mkₐ (h : I ≤ J) :
    AlgHom.comp (↑(quotQuotEquivQuotOfLEₐ R h).symm) (Quotient.mkₐ R J) = quotQuotMkₐ R I J 
goal: (↑(DoubleQuot.quotQuotEquivQuotOfLEₐ R h).symm).comp (Ideal.Quotient.mkₐ R J) = DoubleQuot.quotQuotMkₐ R I J