algebra.category.Ring.constructions | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

70fd9563

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

0b7c740e

bump to nightly-2024-04-06-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

e34029c9

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 -/
 import CategoryTheory.Limits.Shapes.Pullbacks
-import RingTheory.TensorProduct
+import LinearAlgebra.TensorProduct.Tower
 import Algebra.Category.Ring.Limits
 import Algebra.Category.Ring.Instances
 import CategoryTheory.Limits.Shapes.StrictInitial

0b7c740e

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -149,7 +149,7 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
   ext
   have e : (0 : X) = 1 := by rw [← f.map_one, ← f.map_zero]; congr
   replace e : 0 * x = 1 * x := congr_arg (fun a => a * x) e
-  rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e 
+  rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e
   exact e
 #align CommRing.CommRing_has_strict_terminal_objects CommRingCat.commRingCat_hasStrictTerminalObjects
 -/
@@ -241,7 +241,7 @@ instance equalizer_ι_isLocalRingHom (F : WalkingParallelPair ⥤ CommRingCat.{u
     IsLocalRingHom (limit.π F WalkingParallelPair.zero) :=
   by
   have := lim_map_π (diagram_iso_parallel_pair F).Hom walking_parallel_pair.zero
-  rw [← is_iso.comp_inv_eq] at this 
+  rw [← is_iso.comp_inv_eq] at this
   rw [← this]
   rw [←
     limit.iso_limit_cone_hom_π

0b7c740e

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,12 +3,12 @@ Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 -/
-import Mathbin.CategoryTheory.Limits.Shapes.Pullbacks
-import Mathbin.RingTheory.TensorProduct
-import Mathbin.Algebra.Category.Ring.Limits
-import Mathbin.Algebra.Category.Ring.Instances
-import Mathbin.CategoryTheory.Limits.Shapes.StrictInitial
-import Mathbin.RingTheory.Subring.Basic
+import CategoryTheory.Limits.Shapes.Pullbacks
+import RingTheory.TensorProduct
+import Algebra.Category.Ring.Limits
+import Algebra.Category.Ring.Instances
+import CategoryTheory.Limits.Shapes.StrictInitial
+import RingTheory.Subring.Basic
 
 #align_import algebra.category.Ring.constructions from "leanprover-community/mathlib"@"0b7c740e25651db0ba63648fbae9f9d6f941e31b"

0b7c740e

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
-
-! This file was ported from Lean 3 source module algebra.category.Ring.constructions
-! leanprover-community/mathlib commit 0b7c740e25651db0ba63648fbae9f9d6f941e31b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Limits.Shapes.Pullbacks
 import Mathbin.RingTheory.TensorProduct
@@ -15,6 +10,8 @@ import Mathbin.Algebra.Category.Ring.Instances
 import Mathbin.CategoryTheory.Limits.Shapes.StrictInitial
 import Mathbin.RingTheory.Subring.Basic
 
+#align_import algebra.category.Ring.constructions from "leanprover-community/mathlib"@"0b7c740e25651db0ba63648fbae9f9d6f941e31b"
+
 /-!
 # Constructions of (co)limits in CommRing

0b7c740e

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -80,6 +80,7 @@ theorem pushoutCocone_inr :
 #align CommRing.pushout_cocone_inr CommRingCat.pushoutCocone_inr
 -/
 
+#print CommRingCat.pushoutCocone_pt /-
 @[simp]
 theorem pushoutCocone_pt :
     (pushoutCocone f g).pt = by
@@ -87,6 +88,7 @@ theorem pushoutCocone_pt :
       exact CommRingCat.of (A ⊗[R] B) :=
   rfl
 #align CommRing.pushout_cocone_X CommRingCat.pushoutCocone_pt
+-/
 
 #print CommRingCat.pushoutCoconeIsColimit /-
 /-- Verify that the `pushout_cocone` is indeed the colimit. -/
@@ -162,12 +164,14 @@ theorem subsingleton_of_isTerminal {X : CommRingCat} (hX : IsTerminal X) : Subsi
 #align CommRing.subsingleton_of_is_terminal CommRingCat.subsingleton_of_isTerminal
 -/
 
+#print CommRingCat.zIsInitial /-
 /-- `ℤ` is the initial object of `CommRing`. -/
 def zIsInitial : IsInitial (CommRingCat.of ℤ) :=
   by
   apply (config := { instances := false }) is_initial.of_unique
   exact fun R => ⟨⟨Int.castRingHom R⟩, fun a => a.ext_int _⟩
 #align CommRing.Z_is_initial CommRingCat.zIsInitial
+-/
 
 end Terminal
 
@@ -235,6 +239,7 @@ instance : IsLocalRingHom (equalizerFork f g).ι :=
   rw [isUnit_iff_exists_inv]
   exact ⟨⟨y, this⟩, Subtype.eq h₃⟩
 
+#print CommRingCat.equalizer_ι_isLocalRingHom /-
 instance equalizer_ι_isLocalRingHom (F : WalkingParallelPair ⥤ CommRingCat.{u}) :
     IsLocalRingHom (limit.π F WalkingParallelPair.zero) :=
   by
@@ -250,11 +255,13 @@ instance equalizer_ι_isLocalRingHom (F : WalkingParallelPair ⥤ CommRingCat.{u
   change IsLocalRingHom ((lim.map _ ≫ _ ≫ (equalizer_fork _ _).ι) ≫ _)
   infer_instance
 #align CommRing.equalizer_ι_is_local_ring_hom CommRingCat.equalizer_ι_isLocalRingHom
+-/
 
 open CategoryTheory.Limits.WalkingParallelPair Opposite
 
 open CategoryTheory.Limits.WalkingParallelPairHom
 
+#print CommRingCat.equalizer_ι_is_local_ring_hom' /-
 instance equalizer_ι_is_local_ring_hom' (F : WalkingParallelPairᵒᵖ ⥤ CommRingCat.{u}) :
     IsLocalRingHom (limit.π F (Opposite.op WalkingParallelPair.one)) :=
   by
@@ -266,6 +273,7 @@ instance equalizer_ι_is_local_ring_hom' (F : WalkingParallelPairᵒᵖ ⥤ Comm
   erw [← this]
   infer_instance
 #align CommRing.equalizer_ι_is_local_ring_hom' CommRingCat.equalizer_ι_is_local_ring_hom'
+-/
 
 end Equalizer

0b7c740e

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -150,7 +150,7 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
   ext
   have e : (0 : X) = 1 := by rw [← f.map_one, ← f.map_zero]; congr
   replace e : 0 * x = 1 * x := congr_arg (fun a => a * x) e
-  rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e
+  rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e 
   exact e
 #align CommRing.CommRing_has_strict_terminal_objects CommRingCat.commRingCat_hasStrictTerminalObjects
 -/
@@ -239,7 +239,7 @@ instance equalizer_ι_isLocalRingHom (F : WalkingParallelPair ⥤ CommRingCat.{u
     IsLocalRingHom (limit.π F WalkingParallelPair.zero) :=
   by
   have := lim_map_π (diagram_iso_parallel_pair F).Hom walking_parallel_pair.zero
-  rw [← is_iso.comp_inv_eq] at this
+  rw [← is_iso.comp_inv_eq] at this 
   rw [← this]
   rw [←
     limit.iso_limit_cone_hom_π

0b7c740e

bump to nightly-2023-05-28-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

8d353152

Diff

@@ -35,7 +35,7 @@ universe u u'
 
 open CategoryTheory CategoryTheory.Limits
 
-open TensorProduct
+open scoped TensorProduct
 
 namespace CommRingCat

0b7c740e

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -80,9 +80,6 @@ theorem pushoutCocone_inr :
 #align CommRing.pushout_cocone_inr CommRingCat.pushoutCocone_inr
 -/
 
-/- warning: CommRing.pushout_cocone_X -> CommRingCat.pushoutCocone_pt is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align CommRing.pushout_cocone_X CommRingCat.pushoutCocone_ptₓ'. -/
 @[simp]
 theorem pushoutCocone_pt :
     (pushoutCocone f g).pt = by
@@ -165,12 +162,6 @@ theorem subsingleton_of_isTerminal {X : CommRingCat} (hX : IsTerminal X) : Subsi
 #align CommRing.subsingleton_of_is_terminal CommRingCat.subsingleton_of_isTerminal
 -/
 
-/- warning: CommRing.Z_is_initial -> CommRingCat.zIsInitial is a dubious translation:
-lean 3 declaration is
-  CategoryTheory.Limits.IsInitial.{0, 1} CommRingCat.{0} CommRingCat.largeCategory.{0} (CommRingCat.of.{0} Int Int.commRing)
-but is expected to have type
-  CategoryTheory.Limits.IsInitial.{0, 1} CommRingCat.{0} instCommRingCatLargeCategory.{0} (CommRingCat.of.{0} Int Int.instCommRingInt)
-Case conversion may be inaccurate. Consider using '#align CommRing.Z_is_initial CommRingCat.zIsInitialₓ'. -/
 /-- `ℤ` is the initial object of `CommRing`. -/
 def zIsInitial : IsInitial (CommRingCat.of ℤ) :=
   by
@@ -244,9 +235,6 @@ instance : IsLocalRingHom (equalizerFork f g).ι :=
   rw [isUnit_iff_exists_inv]
   exact ⟨⟨y, this⟩, Subtype.eq h₃⟩
 
-/- warning: CommRing.equalizer_ι_is_local_ring_hom -> CommRingCat.equalizer_ι_isLocalRingHom is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align CommRing.equalizer_ι_is_local_ring_hom CommRingCat.equalizer_ι_isLocalRingHomₓ'. -/
 instance equalizer_ι_isLocalRingHom (F : WalkingParallelPair ⥤ CommRingCat.{u}) :
     IsLocalRingHom (limit.π F WalkingParallelPair.zero) :=
   by
@@ -267,9 +255,6 @@ open CategoryTheory.Limits.WalkingParallelPair Opposite
 
 open CategoryTheory.Limits.WalkingParallelPairHom
 
-/- warning: CommRing.equalizer_ι_is_local_ring_hom' -> CommRingCat.equalizer_ι_is_local_ring_hom' is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align CommRing.equalizer_ι_is_local_ring_hom' CommRingCat.equalizer_ι_is_local_ring_hom'ₓ'. -/
 instance equalizer_ι_is_local_ring_hom' (F : WalkingParallelPairᵒᵖ ⥤ CommRingCat.{u}) :
     IsLocalRingHom (limit.π F (Opposite.op WalkingParallelPair.one)) :=
   by

0b7c740e

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -64,8 +64,7 @@ def pushoutCocone : Limits.PushoutCocone f g :=
 @[simp]
 theorem pushoutCocone_inl :
     (pushoutCocone f g).inl = by
-      letI := f.to_algebra
-      letI := g.to_algebra
+      letI := f.to_algebra; letI := g.to_algebra
       exact algebra.tensor_product.include_left.to_ring_hom :=
   rfl
 #align CommRing.pushout_cocone_inl CommRingCat.pushoutCocone_inl
@@ -75,8 +74,7 @@ theorem pushoutCocone_inl :
 @[simp]
 theorem pushoutCocone_inr :
     (pushoutCocone f g).inr = by
-      letI := f.to_algebra
-      letI := g.to_algebra
+      letI := f.to_algebra; letI := g.to_algebra
       exact algebra.tensor_product.include_right.to_ring_hom :=
   rfl
 #align CommRing.pushout_cocone_inr CommRingCat.pushoutCocone_inr
@@ -88,8 +86,7 @@ Case conversion may be inaccurate. Consider using '#align CommRing.pushout_cocon
 @[simp]
 theorem pushoutCocone_pt :
     (pushoutCocone f g).pt = by
-      letI := f.to_algebra
-      letI := g.to_algebra
+      letI := f.to_algebra; letI := g.to_algebra
       exact CommRingCat.of (A ⊗[R] B) :=
   rfl
 #align CommRing.pushout_cocone_X CommRingCat.pushoutCocone_pt
@@ -103,10 +100,7 @@ def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
     letI := RingHom.toAlgebra g
     letI := RingHom.toAlgebra (f ≫ s.inl)
     let f' : A →ₐ[R] s.X :=
-      { s.inl with
-        commutes' := fun r => by
-          change s.inl.to_fun (f r) = (f ≫ s.inl) r
-          rfl }
+      { s.inl with commutes' := fun r => by change s.inl.to_fun (f r) = (f ≫ s.inl) r; rfl }
     let g' : B →ₐ[R] s.X :=
       { s.inr with
         commutes' := fun r => by
@@ -118,19 +112,14 @@ def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
     -- The factor map is a ⊗ b ↦ f(a) * g(b).
     use AlgHom.toRingHom (Algebra.TensorProduct.productMap f' g')
     simp only [pushout_cocone_inl, pushout_cocone_inr]
-    constructor
-    · ext x
-      exact Algebra.TensorProduct.productMap_left_apply _ _ x
-    constructor
-    · ext x
-      exact Algebra.TensorProduct.productMap_right_apply _ _ x
+    constructor; · ext x; exact Algebra.TensorProduct.productMap_left_apply _ _ x
+    constructor; · ext x; exact Algebra.TensorProduct.productMap_right_apply _ _ x
     intro h eq1 eq2
     let h' : A ⊗[R] B →ₐ[R] s.X :=
       { h with
         commutes' := fun r => by
           change h (f r ⊗ₜ[R] 1) = s.inl (f r)
-          rw [← eq1]
-          simp }
+          rw [← eq1]; simp }
     suffices h' = Algebra.TensorProduct.productMap f' g'
       by
       ext x
@@ -162,9 +151,7 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
   intro X f
   refine' ⟨⟨by tidy, by ext, _⟩⟩
   ext
-  have e : (0 : X) = 1 := by
-    rw [← f.map_one, ← f.map_zero]
-    congr
+  have e : (0 : X) = 1 := by rw [← f.map_one, ← f.map_zero]; congr
   replace e : 0 * x = 1 * x := congr_arg (fun a => a * x) e
   rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e
   exact e
@@ -210,13 +197,11 @@ def prodFan : BinaryFan A B :=
 def prodFanIsLimit : IsLimit (prodFan A B)
     where
   lift c := RingHom.prod (c.π.app ⟨WalkingPair.left⟩) (c.π.app ⟨WalkingPair.right⟩)
-  fac c j := by
-    ext
+  fac c j := by ext;
     rcases j with ⟨⟨⟩⟩ <;>
       simpa only [binary_fan.π_app_left, binary_fan.π_app_right, comp_apply, RingHom.prod_apply]
   uniq s m h := by
-    ext
-    · simpa using congr_hom (h ⟨walking_pair.left⟩) x
+    ext; · simpa using congr_hom (h ⟨walking_pair.left⟩) x
     · simpa using congr_hom (h ⟨walking_pair.right⟩) x
 #align CommRing.prod_fan_is_limit CommRingCat.prodFanIsLimit
 -/
@@ -230,10 +215,7 @@ variable {A B : CommRingCat.{u}} (f g : A ⟶ B)
 #print CommRingCat.equalizerFork /-
 /-- The equalizer in `CommRing` is the equalizer as sets. This is the equalizer fork. -/
 def equalizerFork : Fork f g :=
-  Fork.ofι (CommRingCat.ofHom (RingHom.eqLocus f g).Subtype)
-    (by
-      ext ⟨x, e⟩
-      simpa using e)
+  Fork.ofι (CommRingCat.ofHom (RingHom.eqLocus f g).Subtype) (by ext ⟨x, e⟩; simpa using e)
 #align CommRing.equalizer_fork CommRingCat.equalizerFork
 -/
 
@@ -245,11 +227,8 @@ def equalizerForkIsLimit : IsLimit (equalizerFork f g) :=
   intro s
   use s.ι.cod_restrict _ fun x => (concrete_category.congr_hom s.condition x : _)
   constructor
-  · ext
-    rfl
-  · intro m hm
-    ext x
-    exact concrete_category.congr_hom hm x
+  · ext; rfl
+  · intro m hm; ext x; exact concrete_category.congr_hom hm x
 #align CommRing.equalizer_fork_is_limit CommRingCat.equalizerForkIsLimit
 -/
 
@@ -319,9 +298,7 @@ def pullbackCone {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) : Pullbac
     (CommRingCat.ofHom <|
       (RingHom.snd A B).comp
         (RingHom.eqLocus (f.comp (RingHom.fst A B)) (g.comp (RingHom.snd A B))).Subtype)
-    (by
-      ext ⟨x, e⟩
-      simpa [CommRingCat.ofHom] using e)
+    (by ext ⟨x, e⟩; simpa [CommRingCat.ofHom] using e)
 #align CommRing.pullback_cone CommRingCat.pullbackCone
 -/
 
@@ -333,16 +310,10 @@ def pullbackConeIsLimit {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) :
   fapply pullback_cone.is_limit.mk
   · intro s
     apply (s.fst.prod s.snd).codRestrict
-    intro x
-    exact congr_arg (fun f : s.X →+* C => f x) s.condition
-  · intro s
-    ext x
-    rfl
-  · intro s
-    ext x
-    rfl
-  · intro s m e₁ e₂
-    ext
+    intro x; exact congr_arg (fun f : s.X →+* C => f x) s.condition
+  · intro s; ext x; rfl
+  · intro s; ext x; rfl
+  · intro s m e₁ e₂; ext
     · exact (congr_arg (fun f : s.X →+* A => f x) e₁ : _)
     · exact (congr_arg (fun f : s.X →+* B => f x) e₂ : _)
 #align CommRing.pullback_cone_is_limit CommRingCat.pullbackConeIsLimit

0b7c740e

bump to nightly-2023-05-28-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6c6011cf

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 
 ! This file was ported from Lean 3 source module algebra.category.Ring.constructions
-! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
+! leanprover-community/mathlib commit 0b7c740e25651db0ba63648fbae9f9d6f941e31b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -18,6 +18,9 @@ import Mathbin.RingTheory.Subring.Basic
 /-!
 # Constructions of (co)limits in CommRing
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we provide the explicit (co)cones for various (co)limits in `CommRing`, including
 * tensor product is the pushout
 * `Z` is the initial object
@@ -80,10 +83,7 @@ theorem pushoutCocone_inr :
 -/
 
 /- warning: CommRing.pushout_cocone_X -> CommRingCat.pushoutCocone_pt is a dubious translation:
-lean 3 declaration is
-  forall {R : CommRingCat.{u1}} {A : CommRingCat.{u1}} {B : CommRingCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1})) R A) (g : Quiver.Hom.{succ u1, succ u1} CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1})) R B), Eq.{succ (succ u1)} CommRingCat.{u1} (CategoryTheory.Limits.Cocone.pt.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingSpan (CategoryTheory.Limits.WidePushoutShape.category.{0} CategoryTheory.Limits.WalkingPair) CommRingCat.{u1} CommRingCat.largeCategory.{u1} (CategoryTheory.Limits.span.{u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} R A B f g) (CommRingCat.pushoutCocone.{u1} R A B f g)) (let _inst : Algebra.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (CommRingCat.commRing.{u1} R)) (CommSemiring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRingCat.commRing.{u1} A))) := RingHom.toAlgebra.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (CommRingCat.commRing.{u1} R)) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRingCat.commRing.{u1} A)) f; let _inst_1 : Algebra.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (CommRingCat.commRing.{u1} R)) (CommSemiring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRingCat.commRing.{u1} B))) := RingHom.toAlgebra.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (CommRingCat.commRing.{u1} R)) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRingCat.commRing.{u1} B)) g; CommRingCat.of.{u1} (TensorProduct.{u1, u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRingCat.commRing.{u1} R)) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (AddCommGroup.toAddCommMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (NonUnitalNonAssocRing.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (Ring.toNonAssocRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRingCat.commRing.{u1} A)))))) (AddCommGroup.toAddCommMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (NonUnitalNonAssocRing.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (Ring.toNonAssocRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRingCat.commRing.{u1} B)))))) (Algebra.toModule.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRingCat.commRing.{u1} R)) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRingCat.commRing.{u1} A))) _inst) (Algebra.toModule.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRingCat.commRing.{u1} R)) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRingCat.commRing.{u1} B))) _inst_1)) (Algebra.TensorProduct.TensorProduct.commRing.{u1, u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRingCat.commRing.{u1} R) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRingCat.commRing.{u1} A) _inst (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRingCat.commRing.{u1} B) _inst_1))
-but is expected to have type
-  forall {R : CommRingCat.{u1}} {A : CommRingCat.{u1}} {B : CommRingCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) R A) (g : Quiver.Hom.{succ u1, succ u1} CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) R B), Eq.{succ (succ u1)} CommRingCat.{u1} (CategoryTheory.Limits.Cocone.pt.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingSpan (CategoryTheory.Limits.WidePushoutShape.category.{0} CategoryTheory.Limits.WalkingPair) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (CategoryTheory.Limits.span.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} R A B f g) (CommRingCat.pushoutCocone.{u1} R A B f g)) (CommRingCat.of.{u1} (TensorProduct.{u1, u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (Ring.toNonAssocRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A)))))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (Ring.toNonAssocRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B)))))) (Algebra.toModule.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommSemiring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A))) (RingHom.toAlgebra.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A)) f)) (Algebra.toModule.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommSemiring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B))) (RingHom.toAlgebra.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B)) g))) (Algebra.TensorProduct.instCommRingTensorProductToCommSemiringToAddCommMonoidToNonUnitalNonAssocSemiringToNonUnitalNonAssocRingToNonAssocRingToRingToAddCommMonoidToNonUnitalNonAssocSemiringToNonUnitalNonAssocRingToNonAssocRingToRingToModuleToSemiringToCommSemiringToModuleToSemiringToCommSemiring.{u1, u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A) (RingHom.toAlgebra.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A)) f) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B) (RingHom.toAlgebra.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B)) g)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align CommRing.pushout_cocone_X CommRingCat.pushoutCocone_ptₓ'. -/
 @[simp]
 theorem pushoutCocone_pt :
@@ -266,10 +266,7 @@ instance : IsLocalRingHom (equalizerFork f g).ι :=
   exact ⟨⟨y, this⟩, Subtype.eq h₃⟩
 
 /- warning: CommRing.equalizer_ι_is_local_ring_hom -> CommRingCat.equalizer_ι_isLocalRingHom is a dubious translation:
-lean 3 declaration is
-  forall (F : CategoryTheory.Functor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1}), IsLocalRingHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F CategoryTheory.Limits.WalkingParallelPair.zero)) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRingCat.commRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))))) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F CategoryTheory.Limits.WalkingParallelPair.zero)) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F CategoryTheory.Limits.WalkingParallelPair.zero)) (CommRingCat.commRing.{u1} (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F CategoryTheory.Limits.WalkingParallelPair.zero)))) (CategoryTheory.Limits.limit.π.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F) CategoryTheory.Limits.WalkingParallelPair.zero)
-but is expected to have type
-  forall (F : CategoryTheory.Functor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1}), IsLocalRingHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.CategoryStruct.toQuiver.{0, 0} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.Category.toCategoryStruct.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory)) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) CategoryTheory.Limits.WalkingParallelPair.zero)) (Ring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CategoryTheory.Bundled.str.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))))) (Ring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.CategoryStruct.toQuiver.{0, 0} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.Category.toCategoryStruct.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory)) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) CategoryTheory.Limits.WalkingParallelPair.zero)) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.CategoryStruct.toQuiver.{0, 0} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.Category.toCategoryStruct.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory)) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) CategoryTheory.Limits.WalkingParallelPair.zero)) (CategoryTheory.Bundled.str.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.CategoryStruct.toQuiver.{0, 0} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.Category.toCategoryStruct.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory)) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) CategoryTheory.Limits.WalkingParallelPair.zero)))) (CategoryTheory.Limits.limit.π.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F) CategoryTheory.Limits.WalkingParallelPair.zero)
+<too large>
 Case conversion may be inaccurate. Consider using '#align CommRing.equalizer_ι_is_local_ring_hom CommRingCat.equalizer_ι_isLocalRingHomₓ'. -/
 instance equalizer_ι_isLocalRingHom (F : WalkingParallelPair ⥤ CommRingCat.{u}) :
     IsLocalRingHom (limit.π F WalkingParallelPair.zero) :=
@@ -292,10 +289,7 @@ open CategoryTheory.Limits.WalkingParallelPair Opposite
 open CategoryTheory.Limits.WalkingParallelPairHom
 
 /- warning: CommRing.equalizer_ι_is_local_ring_hom' -> CommRingCat.equalizer_ι_is_local_ring_hom' is a dubious translation:
-lean 3 declaration is
-  forall (F : CategoryTheory.Functor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1}), IsLocalRingHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRingCat.commRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))))) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (CommRingCat.commRing.{u1} (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))))) (CategoryTheory.Limits.limit.π.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))
-but is expected to have type
-  forall (F : CategoryTheory.Functor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1}), IsLocalRingHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.CategoryStruct.toQuiver.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.toCategoryStruct.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory))) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (Ring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CategoryTheory.Bundled.str.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))))) (Ring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.CategoryStruct.toQuiver.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.toCategoryStruct.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory))) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.CategoryStruct.toQuiver.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.toCategoryStruct.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory))) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (CategoryTheory.Bundled.str.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.CategoryStruct.toQuiver.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.toCategoryStruct.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory))) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))))) (CategoryTheory.Limits.limit.π.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))
+<too large>
 Case conversion may be inaccurate. Consider using '#align CommRing.equalizer_ι_is_local_ring_hom' CommRingCat.equalizer_ι_is_local_ring_hom'ₓ'. -/
 instance equalizer_ι_is_local_ring_hom' (F : WalkingParallelPairᵒᵖ ⥤ CommRingCat.{u}) :
     IsLocalRingHom (limit.π F (Opposite.op WalkingParallelPair.one)) :=

70fd9563

bump to nightly-2023-05-26-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/e1a18cad9cd462973d760af7de36b05776b8811c

4d5619cc

Diff

@@ -40,6 +40,7 @@ section Pushout
 
 variable {R A B : CommRingCat.{u}} (f : R ⟶ A) (g : R ⟶ B)
 
+#print CommRingCat.pushoutCocone /-
 /-- The explicit cocone with tensor products as the fibered product in `CommRing`. -/
 def pushoutCocone : Limits.PushoutCocone f g :=
   by
@@ -54,7 +55,9 @@ def pushoutCocone : Limits.PushoutCocone f g :=
   · exact algebra.tensor_product.include_left.commutes r
   · exact (algebra.tensor_product.include_right.commutes r).symm
 #align CommRing.pushout_cocone CommRingCat.pushoutCocone
+-/
 
+#print CommRingCat.pushoutCocone_inl /-
 @[simp]
 theorem pushoutCocone_inl :
     (pushoutCocone f g).inl = by
@@ -63,7 +66,9 @@ theorem pushoutCocone_inl :
       exact algebra.tensor_product.include_left.to_ring_hom :=
   rfl
 #align CommRing.pushout_cocone_inl CommRingCat.pushoutCocone_inl
+-/
 
+#print CommRingCat.pushoutCocone_inr /-
 @[simp]
 theorem pushoutCocone_inr :
     (pushoutCocone f g).inr = by
@@ -72,7 +77,14 @@ theorem pushoutCocone_inr :
       exact algebra.tensor_product.include_right.to_ring_hom :=
   rfl
 #align CommRing.pushout_cocone_inr CommRingCat.pushoutCocone_inr
+-/
 
+/- warning: CommRing.pushout_cocone_X -> CommRingCat.pushoutCocone_pt is a dubious translation:
+lean 3 declaration is
+  forall {R : CommRingCat.{u1}} {A : CommRingCat.{u1}} {B : CommRingCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1})) R A) (g : Quiver.Hom.{succ u1, succ u1} CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1})) R B), Eq.{succ (succ u1)} CommRingCat.{u1} (CategoryTheory.Limits.Cocone.pt.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingSpan (CategoryTheory.Limits.WidePushoutShape.category.{0} CategoryTheory.Limits.WalkingPair) CommRingCat.{u1} CommRingCat.largeCategory.{u1} (CategoryTheory.Limits.span.{u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} R A B f g) (CommRingCat.pushoutCocone.{u1} R A B f g)) (let _inst : Algebra.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (CommRingCat.commRing.{u1} R)) (CommSemiring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRingCat.commRing.{u1} A))) := RingHom.toAlgebra.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (CommRingCat.commRing.{u1} R)) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) A) (CommRingCat.commRing.{u1} A)) f; let _inst_1 : Algebra.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (CommRingCat.commRing.{u1} R)) (CommSemiring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRingCat.commRing.{u1} B))) := RingHom.toAlgebra.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) R) (CommRingCat.commRing.{u1} R)) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) B) (CommRingCat.commRing.{u1} B)) g; CommRingCat.of.{u1} (TensorProduct.{u1, u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRingCat.commRing.{u1} R)) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (AddCommGroup.toAddCommMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (NonUnitalNonAssocRing.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (Ring.toNonAssocRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRingCat.commRing.{u1} A)))))) (AddCommGroup.toAddCommMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (NonUnitalNonAssocRing.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (Ring.toNonAssocRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRingCat.commRing.{u1} B)))))) (Algebra.toModule.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRingCat.commRing.{u1} R)) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRingCat.commRing.{u1} A))) _inst) (Algebra.toModule.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRing.toCommSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRingCat.commRing.{u1} R)) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRingCat.commRing.{u1} B))) _inst_1)) (Algebra.TensorProduct.TensorProduct.commRing.{u1, u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} R) (CommRingCat.commRing.{u1} R) (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} A) (CommRingCat.commRing.{u1} A) _inst (coeSort.{succ (succ u1), succ (succ u1)} CommRingCat.{u1} Type.{u1} CommRingCat.hasCoeToSort.{u1} B) (CommRingCat.commRing.{u1} B) _inst_1))
+but is expected to have type
+  forall {R : CommRingCat.{u1}} {A : CommRingCat.{u1}} {B : CommRingCat.{u1}} (f : Quiver.Hom.{succ u1, succ u1} CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) R A) (g : Quiver.Hom.{succ u1, succ u1} CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) R B), Eq.{succ (succ u1)} CommRingCat.{u1} (CategoryTheory.Limits.Cocone.pt.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingSpan (CategoryTheory.Limits.WidePushoutShape.category.{0} CategoryTheory.Limits.WalkingPair) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (CategoryTheory.Limits.span.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} R A B f g) (CommRingCat.pushoutCocone.{u1} R A B f g)) (CommRingCat.of.{u1} (TensorProduct.{u1, u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (Ring.toNonAssocRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A)))))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (NonAssocRing.toNonUnitalNonAssocRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (Ring.toNonAssocRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B)))))) (Algebra.toModule.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommSemiring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A))) (RingHom.toAlgebra.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A)) f)) (Algebra.toModule.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommSemiring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B))) (RingHom.toAlgebra.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B)) g))) (Algebra.TensorProduct.instCommRingTensorProductToCommSemiringToAddCommMonoidToNonUnitalNonAssocSemiringToNonUnitalNonAssocRingToNonAssocRingToRingToAddCommMonoidToNonUnitalNonAssocSemiringToNonUnitalNonAssocRingToNonAssocRingToRingToModuleToSemiringToCommSemiringToModuleToSemiringToCommSemiring.{u1, u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A) (RingHom.toAlgebra.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} A) (CommRingCat.instCommRingα_1.{u1} A)) f) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B) (RingHom.toAlgebra.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} R) (CommRingCat.instCommRingα_1.{u1} R)) (CommRing.toCommSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} B) (CommRingCat.instCommRingα_1.{u1} B)) g)))
+Case conversion may be inaccurate. Consider using '#align CommRing.pushout_cocone_X CommRingCat.pushoutCocone_ptₓ'. -/
 @[simp]
 theorem pushoutCocone_pt :
     (pushoutCocone f g).pt = by
@@ -82,6 +94,7 @@ theorem pushoutCocone_pt :
   rfl
 #align CommRing.pushout_cocone_X CommRingCat.pushoutCocone_pt
 
+#print CommRingCat.pushoutCoconeIsColimit /-
 /-- Verify that the `pushout_cocone` is indeed the colimit. -/
 def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
   Limits.PushoutCocone.isColimitAux' _ fun s =>
@@ -127,18 +140,22 @@ def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
     intro a b
     simp [← eq1, ← eq2, ← h.map_mul]
 #align CommRing.pushout_cocone_is_colimit CommRingCat.pushoutCoconeIsColimit
+-/
 
 end Pushout
 
 section Terminal
 
+#print CommRingCat.punitIsTerminal /-
 /-- The trivial ring is the (strict) terminal object of `CommRing`. -/
 def punitIsTerminal : IsTerminal (CommRingCat.of.{u} PUnit) :=
   by
   apply (config := { instances := false }) is_terminal.of_unique
   tidy
 #align CommRing.punit_is_terminal CommRingCat.punitIsTerminal
+-/
 
+#print CommRingCat.commRingCat_hasStrictTerminalObjects /-
 instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRingCat.{u} :=
   by
   apply has_strict_terminal_objects_of_terminal_is_strict (CommRingCat.of PUnit)
@@ -152,12 +169,21 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
   rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e
   exact e
 #align CommRing.CommRing_has_strict_terminal_objects CommRingCat.commRingCat_hasStrictTerminalObjects
+-/
 
+#print CommRingCat.subsingleton_of_isTerminal /-
 theorem subsingleton_of_isTerminal {X : CommRingCat} (hX : IsTerminal X) : Subsingleton X :=
   (hX.uniqueUpToIso punitIsTerminal).commRingCatIsoToRingEquiv.toEquiv.subsingleton_congr.mpr
     (show Subsingleton PUnit by infer_instance)
 #align CommRing.subsingleton_of_is_terminal CommRingCat.subsingleton_of_isTerminal
+-/
 
+/- warning: CommRing.Z_is_initial -> CommRingCat.zIsInitial is a dubious translation:
+lean 3 declaration is
+  CategoryTheory.Limits.IsInitial.{0, 1} CommRingCat.{0} CommRingCat.largeCategory.{0} (CommRingCat.of.{0} Int Int.commRing)
+but is expected to have type
+  CategoryTheory.Limits.IsInitial.{0, 1} CommRingCat.{0} instCommRingCatLargeCategory.{0} (CommRingCat.of.{0} Int Int.instCommRingInt)
+Case conversion may be inaccurate. Consider using '#align CommRing.Z_is_initial CommRingCat.zIsInitialₓ'. -/
 /-- `ℤ` is the initial object of `CommRing`. -/
 def zIsInitial : IsInitial (CommRingCat.of ℤ) :=
   by
@@ -171,12 +197,15 @@ section Product
 
 variable (A B : CommRingCat.{u})
 
+#print CommRingCat.prodFan /-
 /-- The product in `CommRing` is the cartesian product. This is the binary fan. -/
 @[simps pt]
 def prodFan : BinaryFan A B :=
   BinaryFan.mk (CommRingCat.ofHom <| RingHom.fst A B) (CommRingCat.ofHom <| RingHom.snd A B)
 #align CommRing.prod_fan CommRingCat.prodFan
+-/
 
+#print CommRingCat.prodFanIsLimit /-
 /-- The product in `CommRing` is the cartesian product. -/
 def prodFanIsLimit : IsLimit (prodFan A B)
     where
@@ -190,6 +219,7 @@ def prodFanIsLimit : IsLimit (prodFan A B)
     · simpa using congr_hom (h ⟨walking_pair.left⟩) x
     · simpa using congr_hom (h ⟨walking_pair.right⟩) x
 #align CommRing.prod_fan_is_limit CommRingCat.prodFanIsLimit
+-/
 
 end Product
 
@@ -197,6 +227,7 @@ section Equalizer
 
 variable {A B : CommRingCat.{u}} (f g : A ⟶ B)
 
+#print CommRingCat.equalizerFork /-
 /-- The equalizer in `CommRing` is the equalizer as sets. This is the equalizer fork. -/
 def equalizerFork : Fork f g :=
   Fork.ofι (CommRingCat.ofHom (RingHom.eqLocus f g).Subtype)
@@ -204,7 +235,9 @@ def equalizerFork : Fork f g :=
       ext ⟨x, e⟩
       simpa using e)
 #align CommRing.equalizer_fork CommRingCat.equalizerFork
+-/
 
+#print CommRingCat.equalizerForkIsLimit /-
 /-- The equalizer in `CommRing` is the equalizer as sets. -/
 def equalizerForkIsLimit : IsLimit (equalizerFork f g) :=
   by
@@ -218,6 +251,7 @@ def equalizerForkIsLimit : IsLimit (equalizerFork f g) :=
     ext x
     exact concrete_category.congr_hom hm x
 #align CommRing.equalizer_fork_is_limit CommRingCat.equalizerForkIsLimit
+-/
 
 instance : IsLocalRingHom (equalizerFork f g).ι :=
   by
@@ -231,6 +265,12 @@ instance : IsLocalRingHom (equalizerFork f g).ι :=
   rw [isUnit_iff_exists_inv]
   exact ⟨⟨y, this⟩, Subtype.eq h₃⟩
 
+/- warning: CommRing.equalizer_ι_is_local_ring_hom -> CommRingCat.equalizer_ι_isLocalRingHom is a dubious translation:
+lean 3 declaration is
+  forall (F : CategoryTheory.Functor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1}), IsLocalRingHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F CategoryTheory.Limits.WalkingParallelPair.zero)) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRingCat.commRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))))) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F CategoryTheory.Limits.WalkingParallelPair.zero)) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F CategoryTheory.Limits.WalkingParallelPair.zero)) (CommRingCat.commRing.{u1} (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F CategoryTheory.Limits.WalkingParallelPair.zero)))) (CategoryTheory.Limits.limit.π.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F) CategoryTheory.Limits.WalkingParallelPair.zero)
+but is expected to have type
+  forall (F : CategoryTheory.Functor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1}), IsLocalRingHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.CategoryStruct.toQuiver.{0, 0} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.Category.toCategoryStruct.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory)) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) CategoryTheory.Limits.WalkingParallelPair.zero)) (Ring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CategoryTheory.Bundled.str.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F))))) (Ring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.CategoryStruct.toQuiver.{0, 0} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.Category.toCategoryStruct.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory)) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) CategoryTheory.Limits.WalkingParallelPair.zero)) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.CategoryStruct.toQuiver.{0, 0} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.Category.toCategoryStruct.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory)) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) CategoryTheory.Limits.WalkingParallelPair.zero)) (CategoryTheory.Bundled.str.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.CategoryStruct.toQuiver.{0, 0} CategoryTheory.Limits.WalkingParallelPair (CategoryTheory.Category.toCategoryStruct.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory)) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) CategoryTheory.Limits.WalkingParallelPair.zero)))) (CategoryTheory.Limits.limit.π.{0, 0, u1, succ u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory CommRingCat.hasLimitsOfSize.{0, u1}) F) CategoryTheory.Limits.WalkingParallelPair.zero)
+Case conversion may be inaccurate. Consider using '#align CommRing.equalizer_ι_is_local_ring_hom CommRingCat.equalizer_ι_isLocalRingHomₓ'. -/
 instance equalizer_ι_isLocalRingHom (F : WalkingParallelPair ⥤ CommRingCat.{u}) :
     IsLocalRingHom (limit.π F WalkingParallelPair.zero) :=
   by
@@ -251,6 +291,12 @@ open CategoryTheory.Limits.WalkingParallelPair Opposite
 
 open CategoryTheory.Limits.WalkingParallelPairHom
 
+/- warning: CommRing.equalizer_ι_is_local_ring_hom' -> CommRingCat.equalizer_ι_is_local_ring_hom' is a dubious translation:
+lean 3 declaration is
+  forall (F : CategoryTheory.Functor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1}), IsLocalRingHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRingCat.commRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))))) (Ring.toSemiring.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (CommRing.toRing.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommRing.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommRing.{u1}) (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (CommRingCat.commRing.{u1} (CategoryTheory.Functor.obj.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))))) (CategoryTheory.Limits.limit.π.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} CommRingCat.largeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} CommRingCat.largeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))
+but is expected to have type
+  forall (F : CategoryTheory.Functor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1}), IsLocalRingHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.CategoryStruct.toQuiver.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.toCategoryStruct.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory))) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (Ring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))) (CategoryTheory.Bundled.str.{u1, u1} CommRing.{u1} (CategoryTheory.Limits.limit.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F))))) (Ring.toSemiring.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.CategoryStruct.toQuiver.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.toCategoryStruct.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory))) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (CommRing.toRing.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.CategoryStruct.toQuiver.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.toCategoryStruct.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory))) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))) (CategoryTheory.Bundled.str.{u1, u1} CommRing.{u1} (Prefunctor.obj.{1, succ u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.CategoryStruct.toQuiver.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.toCategoryStruct.{0, 0} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory))) CommRingCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommRingCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{0, u1, 0, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))))) (CategoryTheory.Limits.limit.π.{0, 0, u1, succ u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.{u1} instCommRingCatLargeCategory.{u1} F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} CommRingCat.{u1} instCommRingCatLargeCategory.{u1} (Opposite.{1} CategoryTheory.Limits.WalkingParallelPair) (CategoryTheory.Category.opposite.{0, 0} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory) CommRingCat.hasLimitsOfSize.{0, u1}) F) (Opposite.op.{1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.WalkingParallelPair.one))
+Case conversion may be inaccurate. Consider using '#align CommRing.equalizer_ι_is_local_ring_hom' CommRingCat.equalizer_ι_is_local_ring_hom'ₓ'. -/
 instance equalizer_ι_is_local_ring_hom' (F : WalkingParallelPairᵒᵖ ⥤ CommRingCat.{u}) :
     IsLocalRingHom (limit.π F (Opposite.op WalkingParallelPair.one)) :=
   by
@@ -267,6 +313,7 @@ end Equalizer
 
 section Pullback
 
+#print CommRingCat.pullbackCone /-
 /-- In the category of `CommRing`, the pullback of `f : A ⟶ C` and `g : B ⟶ C` is the `eq_locus` of
 the two maps `A × B ⟶ C`. This is the constructed pullback cone.
 -/
@@ -282,7 +329,9 @@ def pullbackCone {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) : Pullbac
       ext ⟨x, e⟩
       simpa [CommRingCat.ofHom] using e)
 #align CommRing.pullback_cone CommRingCat.pullbackCone
+-/
 
+#print CommRingCat.pullbackConeIsLimit /-
 /-- The constructed pullback cone is indeed the limit. -/
 def pullbackConeIsLimit {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) :
     IsLimit (pullbackCone f g) :=
@@ -303,6 +352,7 @@ def pullbackConeIsLimit {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) :
     · exact (congr_arg (fun f : s.X →+* A => f x) e₁ : _)
     · exact (congr_arg (fun f : s.X →+* B => f x) e₂ : _)
 #align CommRing.pullback_cone_is_limit CommRingCat.pullbackConeIsLimit
+-/
 
 end Pullback

70fd9563

bump to nightly-2023-05-14-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

f29e26a7

Diff

@@ -154,7 +154,7 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
 #align CommRing.CommRing_has_strict_terminal_objects CommRingCat.commRingCat_hasStrictTerminalObjects
 
 theorem subsingleton_of_isTerminal {X : CommRingCat} (hX : IsTerminal X) : Subsingleton X :=
-  (hX.uniqueUpToIso punitIsTerminal).commRingIsoToRingEquiv.toEquiv.subsingleton_congr.mpr
+  (hX.uniqueUpToIso punitIsTerminal).commRingCatIsoToRingEquiv.toEquiv.subsingleton_congr.mpr
     (show Subsingleton PUnit by infer_instance)
 #align CommRing.subsingleton_of_is_terminal CommRingCat.subsingleton_of_isTerminal

70fd9563

bump to nightly-2023-03-11-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

cd44fb92

Diff

@@ -149,7 +149,7 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
     rw [← f.map_one, ← f.map_zero]
     congr
   replace e : 0 * x = 1 * x := congr_arg (fun a => a * x) e
-  rw [one_mul, zero_mul, ← f.map_zero] at e
+  rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e
   exact e
 #align CommRing.CommRing_has_strict_terminal_objects CommRingCat.commRingCat_hasStrictTerminalObjects

70fd9563

bump to nightly-2023-02-28-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/9da1b3534b65d9661eb8f42443598a92bbb49211

1fb1623f

Diff

@@ -74,13 +74,13 @@ theorem pushoutCocone_inr :
 #align CommRing.pushout_cocone_inr CommRingCat.pushoutCocone_inr
 
 @[simp]
-theorem pushoutCocone_x :
-    (pushoutCocone f g).x = by
+theorem pushoutCocone_pt :
+    (pushoutCocone f g).pt = by
       letI := f.to_algebra
       letI := g.to_algebra
       exact CommRingCat.of (A ⊗[R] B) :=
   rfl
-#align CommRing.pushout_cocone_X CommRingCat.pushoutCocone_x
+#align CommRing.pushout_cocone_X CommRingCat.pushoutCocone_pt
 
 /-- Verify that the `pushout_cocone` is indeed the colimit. -/
 def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
@@ -172,7 +172,7 @@ section Product
 variable (A B : CommRingCat.{u})
 
 /-- The product in `CommRing` is the cartesian product. This is the binary fan. -/
-@[simps x]
+@[simps pt]
 def prodFan : BinaryFan A B :=
   BinaryFan.mk (CommRingCat.ofHom <| RingHom.fst A B) (CommRingCat.ofHom <| RingHom.snd A B)
 #align CommRing.prod_fan CommRingCat.prodFan

70fd9563

bump to nightly-2023-02-27-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/eb0cb4511aaef0da2462207b67358a0e1fe1e2ee

91d8c210

Diff

@@ -181,11 +181,11 @@ def prodFan : BinaryFan A B :=
 def prodFanIsLimit : IsLimit (prodFan A B)
     where
   lift c := RingHom.prod (c.π.app ⟨WalkingPair.left⟩) (c.π.app ⟨WalkingPair.right⟩)
-  fac' c j := by
+  fac c j := by
     ext
     rcases j with ⟨⟨⟩⟩ <;>
       simpa only [binary_fan.π_app_left, binary_fan.π_app_right, comp_apply, RingHom.prod_apply]
-  uniq' s m h := by
+  uniq s m h := by
     ext
     · simpa using congr_hom (h ⟨walking_pair.left⟩) x
     · simpa using congr_hom (h ⟨walking_pair.right⟩) x

70fd9563

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

70fd9563

chore: adaptations to lean 4.8.0 (#12549)

e50e1c94

Diff

@@ -147,7 +147,7 @@ section Terminal
 /-- The trivial ring is the (strict) terminal object of `CommRingCat`. -/
 def punitIsTerminal : IsTerminal (CommRingCat.of.{u} PUnit) := by
   refine IsTerminal.ofUnique (h := fun X => ⟨⟨⟨⟨1, rfl⟩, fun _ _ => rfl⟩, ?_, ?_⟩, ?_⟩)
-  · dsimp
+  · rfl
   · intros; dsimp
   · intros f; ext; rfl
 set_option linter.uppercaseLean3 false in

70fd9563

chore: adapt to multiple goal linter 1 (#12338)

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -42,13 +42,13 @@ def pushoutCocone : Limits.PushoutCocone f g := by
   letI := RingHom.toAlgebra f
   letI := RingHom.toAlgebra g
   fapply Limits.PushoutCocone.mk
-  show CommRingCat; exact CommRingCat.of (A ⊗[R] B)
-  show A ⟶ _; exact Algebra.TensorProduct.includeLeftRingHom
-  show B ⟶ _; exact Algebra.TensorProduct.includeRight.toRingHom
-  ext r
-  trans algebraMap R (A ⊗[R] B) r
-  · exact Algebra.TensorProduct.includeLeft.commutes (R := R) r
-  · exact (Algebra.TensorProduct.includeRight.commutes (R := R) r).symm
+  · show CommRingCat; exact CommRingCat.of (A ⊗[R] B)
+  · show A ⟶ _; exact Algebra.TensorProduct.includeLeftRingHom
+  · show B ⟶ _; exact Algebra.TensorProduct.includeRight.toRingHom
+  · ext r
+    trans algebraMap R (A ⊗[R] B) r
+    · exact Algebra.TensorProduct.includeLeft.commutes (R := R) r
+    · exact (Algebra.TensorProduct.includeRight.commutes (R := R) r).symm
 set_option linter.uppercaseLean3 false in
 #align CommRing.pushout_cocone CommRingCat.pushoutCocone

70fd9563

Acl/reorg tensor product (#11282)

Move:

Mathlib/Algebra/Module/DirectLimitAndTensorProduct.lean to LinearAlgebra/TensorProduct/DirectLimit.lean
Mathlib/LinearAlgebra/TensorProduct to Mathlib/LinearAlgebra.TensorProduct.Basic.lean
Mathlib/RingTheory/TensorProduct to Mathlib/RingTheory/TensorProduct/Basic.lean.

This follows suggestions 1, 2, 3 of

https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Tensor.20Products.20of.20modules.20and.20rings/near/424605543

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

0ee5f823

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 -/
 import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
-import Mathlib.RingTheory.TensorProduct
+import Mathlib.RingTheory.TensorProduct.Basic
 import Mathlib.Algebra.Category.Ring.Limits
 import Mathlib.Algebra.Category.Ring.Instances
 import Mathlib.CategoryTheory.Limits.Shapes.StrictInitial

70fd9563

chore: prepare Lean version bump with explicit simp (#10999)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

38bce757

Diff

@@ -132,9 +132,8 @@ def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
       rw [this]
     apply Algebra.TensorProduct.ext'
     intro a b
-    simp only [PushoutCocone.ι_app_left, pushoutCocone_pt, coe_of, RingHom.toMonoidHom_eq_coe,
-      AlgHom.coe_mk, RingHom.coe_mk, MonoidHom.coe_coe, ← eq1, AlgHom.toRingHom_eq_coe,
-      PushoutCocone.ι_app_right, ← eq2, Algebra.TensorProduct.productMap_apply_tmul]
+    simp only [f', g', ← eq1, pushoutCocone_pt, ← eq2, AlgHom.toRingHom_eq_coe,
+      Algebra.TensorProduct.productMap_apply_tmul, AlgHom.coe_mk]
     change _ = h (a ⊗ₜ 1) * h (1 ⊗ₜ b)
     rw [← h.map_mul, Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul]
     rfl

70fd9563

style: reduce spacing variation in "porting note" comments (#10886)

In this pull request, I have systematically eliminated the leading whitespace preceding the colon (:) within all unlabelled or unclassified porting notes. This adjustment facilitates a more efficient review process for the remaining notes by ensuring no entries are overlooked due to formatting inconsistencies.

86b84c52

Diff

@@ -99,7 +99,7 @@ def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
           exact
             (s.ι.naturality Limits.WalkingSpan.Hom.snd).trans
               (s.ι.naturality Limits.WalkingSpan.Hom.fst).symm }
-    -- Porting note : Lean has forget why `A ⊗[R] B` makes sense
+    -- Porting note: Lean has forget why `A ⊗[R] B` makes sense
     letI : Algebra R A := f.toAlgebra
     letI : Algebra R B := g.toAlgebra
     letI : Algebra R (pushoutCocone f g).pt := show Algebra R (A ⊗[R] B) by infer_instance
@@ -108,13 +108,13 @@ def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
     simp only [pushoutCocone_inl, pushoutCocone_inr]
     constructor
     · ext x
-      -- Porting note : Lean can't see through `forget` functor
+      -- Porting note: Lean can't see through `forget` functor
       letI : Semiring ((forget CommRingCat).obj A) := A.str.toSemiring
       letI : Algebra R ((forget CommRingCat).obj A) := show Algebra R A by infer_instance
       exact Algebra.TensorProduct.productMap_left_apply _ _ x
     constructor
     · ext x
-      -- Porting note : Lean can't see through `forget` functor
+      -- Porting note: Lean can't see through `forget` functor
       letI : Semiring ((forget CommRingCat).obj B) := B.str.toSemiring
       letI : Algebra R ((forget CommRingCat).obj B) := show Algebra R B by infer_instance
       exact Algebra.TensorProduct.productMap_right_apply _ _ x
@@ -266,7 +266,7 @@ set_option linter.uppercaseLean3 false in
 def equalizerForkIsLimit : IsLimit (equalizerFork f g) := by
   fapply Fork.IsLimit.mk'
   intro s
-  -- Porting note : Lean can't see through `(parallelPair f g).obj zero`
+  -- Porting note: Lean can't see through `(parallelPair f g).obj zero`
   haveI : SubsemiringClass (Subring A) ((parallelPair f g).obj WalkingParallelPair.zero) :=
     show SubsemiringClass (Subring A) A by infer_instance
   use s.ι.codRestrict _ fun x => (ConcreteCategory.congr_hom s.condition x : _)

70fd9563

feat(Algebra/Category/Ring/Constructions): categorical product of rings is the cartesian product (#9394)

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

93d4e6e3

Diff

@@ -20,6 +20,7 @@ In this file we provide the explicit (co)cones for various (co)limits in `CommRi
 * `Z` is the initial object
 * `0` is the strict terminal object
 * cartesian product is the product
+* arbitrary direct product of a family of rings is the product object (Pi object)
 * `RingHom.eqLocus` is the equalizer
 
 -/
@@ -215,6 +216,40 @@ set_option linter.uppercaseLean3 false in
 
 end Product
 
+section Pi
+
+variable {ι : Type u} (R : ι → CommRingCat.{u})
+
+/--
+The categorical product of rings is the cartesian product of rings. This is its `Fan`.
+-/
+@[simps! pt]
+def piFan : Fan R :=
+  Fan.mk (CommRingCat.of ((i : ι) → R i)) (Pi.evalRingHom _)
+
+/--
+The categorical product of rings is the cartesian product of rings.
+-/
+def piFanIsLimit : IsLimit (piFan R) where
+  lift s := Pi.ringHom fun i ↦ s.π.1 ⟨i⟩
+  fac s i := by rfl
+  uniq s g h := DFunLike.ext _ _ fun x ↦ funext fun i ↦ DFunLike.congr_fun (h ⟨i⟩) x
+
+/--
+The categorical product and the usual product agrees
+-/
+def piIsoPi : ∏ R ≅ CommRingCat.of ((i : ι) → R i) :=
+  limit.isoLimitCone ⟨_, piFanIsLimit R⟩
+
+/--
+The categorical product and the usual product agrees
+-/
+def _root_.RingEquiv.piEquivPi (R : ι → Type u) [∀ i, CommRing (R i)] :
+    (∏ (fun i : ι ↦ CommRingCat.of (R i)) : CommRingCat.{u}) ≃+* ((i : ι) → R i) :=
+  (piIsoPi (CommRingCat.of <| R ·)).commRingCatIsoToRingEquiv
+
+end Pi
+
 section Equalizer
 
 variable {A B : CommRingCat.{u}} (f g : A ⟶ B)

70fd9563

chore: space after ← (#8178)

Co-authored-by: Moritz Firsching <firsching@google.com>

5fb9beab

Diff

@@ -135,7 +135,7 @@ def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
       AlgHom.coe_mk, RingHom.coe_mk, MonoidHom.coe_coe, ← eq1, AlgHom.toRingHom_eq_coe,
       PushoutCocone.ι_app_right, ← eq2, Algebra.TensorProduct.productMap_apply_tmul]
     change _ = h (a ⊗ₜ 1) * h (1 ⊗ₜ b)
-    rw [←h.map_mul, Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul]
+    rw [← h.map_mul, Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul]
     rfl
 set_option linter.uppercaseLean3 false in
 #align CommRing.pushout_cocone_is_colimit CommRingCat.pushoutCoconeIsColimit
@@ -208,7 +208,7 @@ def prodFanIsLimit : IsLimit (prodFan A B) where
     have eq2 := congr_hom (h ⟨WalkingPair.right⟩) x
     dsimp at eq1 eq2
     -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-    erw [←eq1, ←eq2]
+    erw [← eq1, ← eq2]
     rfl
 set_option linter.uppercaseLean3 false in
 #align CommRing.prod_fan_is_limit CommRingCat.prodFanIsLimit
@@ -323,7 +323,7 @@ def pullbackConeIsLimit {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) :
     change (m x).1 = (_, _)
     have eq1 := (congr_arg (fun f : s.pt →+* A => f x) e₁ : _)
     have eq2 := (congr_arg (fun f : s.pt →+* B => f x) e₂ : _)
-    rw [←eq1, ←eq2]
+    rw [← eq1, ← eq2]
     rfl
 set_option linter.uppercaseLean3 false in
 #align CommRing.pullback_cone_is_limit CommRingCat.pullbackConeIsLimit

70fd9563

Revert "chore: revert #7703 (#7710)"

This reverts commit f3695eb2.

ab56fa28

Diff

@@ -207,7 +207,8 @@ def prodFanIsLimit : IsLimit (prodFan A B) where
     have eq1 := congr_hom (h ⟨WalkingPair.left⟩) x
     have eq2 := congr_hom (h ⟨WalkingPair.right⟩) x
     dsimp at eq1 eq2
-    rw [←eq1, ←eq2]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [←eq1, ←eq2]
     rfl
 set_option linter.uppercaseLean3 false in
 #align CommRing.prod_fan_is_limit CommRingCat.prodFanIsLimit

70fd9563

chore: revert #7703 (#7710)

This reverts commit 26eb2b0a.

f3695eb2

Diff

@@ -207,8 +207,7 @@ def prodFanIsLimit : IsLimit (prodFan A B) where
     have eq1 := congr_hom (h ⟨WalkingPair.left⟩) x
     have eq2 := congr_hom (h ⟨WalkingPair.right⟩) x
     dsimp at eq1 eq2
-    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-    erw [←eq1, ←eq2]
+    rw [←eq1, ←eq2]
     rfl
 set_option linter.uppercaseLean3 false in
 #align CommRing.prod_fan_is_limit CommRingCat.prodFanIsLimit

70fd9563

chore: bump toolchain to v4.2.0-rc2 (#7703)

This includes all the changes from #7606.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

26eb2b0a

Diff

@@ -207,7 +207,8 @@ def prodFanIsLimit : IsLimit (prodFan A B) where
     have eq1 := congr_hom (h ⟨WalkingPair.left⟩) x
     have eq2 := congr_hom (h ⟨WalkingPair.right⟩) x
     dsimp at eq1 eq2
-    rw [←eq1, ←eq2]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [←eq1, ←eq2]
     rfl
 set_option linter.uppercaseLean3 false in
 #align CommRing.prod_fan_is_limit CommRingCat.prodFanIsLimit

70fd9563

feat: use suppress_compilation in tensor products (#7504)

More principled version of #7281.

9ff5b6f1

Diff

@@ -24,6 +24,7 @@ In this file we provide the explicit (co)cones for various (co)limits in `CommRi
 
 -/
 
+suppress_compilation
 
 universe u u'

70fd9563

chore: drop MulZeroClass. in mul_zero/zero_mul (#6682)

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

277dea95

Diff

@@ -161,7 +161,7 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
     rw [← f.map_one, ← f.map_zero]
     congr
   replace e : 0 * x = 1 * x := congr_arg (· * x) e
-  rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e
+  rw [one_mul, zero_mul, ← f.map_zero] at e
   exact e
 set_option linter.uppercaseLean3 false in
 #align CommRing.CommRing_has_strict_terminal_objects CommRingCat.commRingCat_hasStrictTerminalObjects

70fd9563

feat(RingTheory/TensorProduct): heterogenize (#6417)

This:

Improves the module docstring, which was both out of date and not very informative
Addresses a TODO to generalize includeLeft to commuting actions. As a result a few downstream results are changed to be about includeLeftRingHom or a ⊗ₜ 1, as carrying around the extra useless ring just makes the lemmas harder to use. Nothing seems to suffer from this change.
Introduces TensorProduct.AlgebraTensorModule.rid
Generalizes the following to work for towers of rings:
- Algebra.TensorProduct.algHomOfLinearMapTensorProduct
- Algebra.TensorProduct.map
- Algebra.TensorProduct.congr
- Algebra.TensorProduct.endTensorEndAlgHom
- Algebra.TensorProduct.ext (and renames it to Algebra.TensorProduct.ext')
- Algebra.TensorProduct.rid
Introduces a new Algebra.TensorProduct.ext which follows "partially-applied ext lemmas", and uses it to golf a proof in RingTheory/Etale.lean

I need many of these results for building AlgEquivs relating to the base change of clifford algebras.

759a1d08

Diff

@@ -41,7 +41,7 @@ def pushoutCocone : Limits.PushoutCocone f g := by
   letI := RingHom.toAlgebra g
   fapply Limits.PushoutCocone.mk
   show CommRingCat; exact CommRingCat.of (A ⊗[R] B)
-  show A ⟶ _; exact Algebra.TensorProduct.includeLeft.toRingHom
+  show A ⟶ _; exact Algebra.TensorProduct.includeLeftRingHom
   show B ⟶ _; exact Algebra.TensorProduct.includeRight.toRingHom
   ext r
   trans algebraMap R (A ⊗[R] B) r
@@ -55,7 +55,7 @@ theorem pushoutCocone_inl :
     (pushoutCocone f g).inl = by
       letI := f.toAlgebra
       letI := g.toAlgebra
-      exact Algebra.TensorProduct.includeLeft.toRingHom :=
+      exact Algebra.TensorProduct.includeLeftRingHom :=
   rfl
 set_option linter.uppercaseLean3 false in
 #align CommRing.pushout_cocone_inl CommRingCat.pushoutCocone_inl
@@ -128,7 +128,7 @@ def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone f g) :=
       ext x
       change h' x = Algebra.TensorProduct.productMap f' g' x
       rw [this]
-    apply Algebra.TensorProduct.ext
+    apply Algebra.TensorProduct.ext'
     intro a b
     simp only [PushoutCocone.ι_app_left, pushoutCocone_pt, coe_of, RingHom.toMonoidHom_eq_coe,
       AlgHom.coe_mk, RingHom.coe_mk, MonoidHom.coe_coe, ← eq1, AlgHom.toRingHom_eq_coe,

70fd9563

chore: use · instead of . (#6085)

898a8e78

Diff

@@ -160,7 +160,7 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
   have e : (0 : X) = 1 := by
     rw [← f.map_one, ← f.map_zero]
     congr
-  replace e : 0 * x = 1 * x := congr_arg (. * x) e
+  replace e : 0 * x = 1 * x := congr_arg (· * x) e
   rw [one_mul, MulZeroClass.zero_mul, ← f.map_zero] at e
   exact e
 set_option linter.uppercaseLean3 false in

70fd9563

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
-
-! This file was ported from Lean 3 source module algebra.category.Ring.constructions
-! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
 import Mathlib.RingTheory.TensorProduct
@@ -15,6 +10,8 @@ import Mathlib.Algebra.Category.Ring.Instances
 import Mathlib.CategoryTheory.Limits.Shapes.StrictInitial
 import Mathlib.RingTheory.Subring.Basic
 
+#align_import algebra.category.Ring.constructions from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
+
 /-!
 # Constructions of (co)limits in `CommRingCat`

70fd9563

chore: remove superfluous parentheses in calls to ext (#5258)

Co-authored-by: Xavier Roblot <46200072+xroblot@users.noreply.github.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Riccardo Brasca <riccardo.brasca@gmail.com> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Pol'tta / Miyahara Kō <pol_tta@outlook.jp> Co-authored-by: Jason Yuen <jason_yuen2007@hotmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Jireh Loreaux <loreaujy@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com> Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

3d6731dc

Diff

@@ -159,7 +159,7 @@ instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRin
   apply hasStrictTerminalObjects_of_terminal_is_strict (CommRingCat.of PUnit)
   intro X f
   refine ⟨⟨⟨1, rfl, fun _ _ => rfl⟩, by ext; rfl, ?_⟩⟩
-  ext (x : X)
+  ext x
   have e : (0 : X) = 1 := by
     rw [← f.map_one, ← f.map_zero]
     congr
@@ -204,8 +204,7 @@ def prodFanIsLimit : IsLimit (prodFan A B) where
       FunctorToTypes.map_comp_apply, forget_map, coe_of, RingHom.prod_apply] <;>
     rfl
   uniq s m h := by
-    dsimp
-    ext (x : s.pt)
+    ext x
     change m x = (BinaryFan.fst s x, BinaryFan.snd s x)
     have eq1 := congr_hom (h ⟨WalkingPair.left⟩) x
     have eq2 := congr_hom (h ⟨WalkingPair.right⟩) x

70fd9563

chore: tidy various files (#4423)

9f94180e

Diff

@@ -16,23 +16,21 @@ import Mathlib.CategoryTheory.Limits.Shapes.StrictInitial
 import Mathlib.RingTheory.Subring.Basic
 
 /-!
-# Constructions of (co)limits in CommRing
+# Constructions of (co)limits in `CommRingCat`
 
-In this file we provide the explicit (co)cones for various (co)limits in `CommRing`, including
+In this file we provide the explicit (co)cones for various (co)limits in `CommRingCat`, including
 * tensor product is the pushout
 * `Z` is the initial object
 * `0` is the strict terminal object
 * cartesian product is the product
-* `ring_hom.eq_locus` is the equalizer
+* `RingHom.eqLocus` is the equalizer
 
 -/
 
 
 universe u u'
 
-open CategoryTheory CategoryTheory.Limits
-
-open TensorProduct
+open CategoryTheory CategoryTheory.Limits TensorProduct
 
 namespace CommRingCat
 
@@ -40,7 +38,7 @@ section Pushout
 
 variable {R A B : CommRingCat.{u}} (f : R ⟶ A) (g : R ⟶ B)
 
-/-- The explicit cocone with tensor products as the fibered product in `CommRing`. -/
+/-- The explicit cocone with tensor products as the fibered product in `CommRingCat`. -/
 def pushoutCocone : Limits.PushoutCocone f g := by
   letI := RingHom.toAlgebra f
   letI := RingHom.toAlgebra g
@@ -148,12 +146,12 @@ end Pushout
 
 section Terminal
 
-/-- The trivial ring is the (strict) terminal object of `CommRing`. -/
+/-- The trivial ring is the (strict) terminal object of `CommRingCat`. -/
 def punitIsTerminal : IsTerminal (CommRingCat.of.{u} PUnit) := by
   refine IsTerminal.ofUnique (h := fun X => ⟨⟨⟨⟨1, rfl⟩, fun _ _ => rfl⟩, ?_, ?_⟩, ?_⟩)
-  . dsimp
-  . intros; dsimp
-  . intros f; ext; rfl
+  · dsimp
+  · intros; dsimp
+  · intros f; ext; rfl
 set_option linter.uppercaseLean3 false in
 #align CommRing.punit_is_terminal CommRingCat.punitIsTerminal
 
@@ -177,7 +175,7 @@ theorem subsingleton_of_isTerminal {X : CommRingCat} (hX : IsTerminal X) : Subsi
 set_option linter.uppercaseLean3 false in
 #align CommRing.subsingleton_of_is_terminal CommRingCat.subsingleton_of_isTerminal
 
-/-- `ℤ` is the initial object of `CommRing`. -/
+/-- `ℤ` is the initial object of `CommRingCat`. -/
 def zIsInitial : IsInitial (CommRingCat.of ℤ) :=
   IsInitial.ofUnique (h := fun R => ⟨⟨Int.castRingHom R⟩, fun a => a.ext_int _⟩)
 set_option linter.uppercaseLean3 false in
@@ -189,14 +187,14 @@ section Product
 
 variable (A B : CommRingCat.{u})
 
-/-- The product in `CommRing` is the cartesian product. This is the binary fan. -/
+/-- The product in `CommRingCat` is the cartesian product. This is the binary fan. -/
 @[simps! pt]
 def prodFan : BinaryFan A B :=
   BinaryFan.mk (CommRingCat.ofHom <| RingHom.fst A B) (CommRingCat.ofHom <| RingHom.snd A B)
 set_option linter.uppercaseLean3 false in
 #align CommRing.prod_fan CommRingCat.prodFan
 
-/-- The product in `CommRing` is the cartesian product. -/
+/-- The product in `CommRingCat` is the cartesian product. -/
 def prodFanIsLimit : IsLimit (prodFan A B) where
   lift c := RingHom.prod (c.π.app ⟨WalkingPair.left⟩) (c.π.app ⟨WalkingPair.right⟩)
   fac c j := by
@@ -223,7 +221,7 @@ section Equalizer
 
 variable {A B : CommRingCat.{u}} (f g : A ⟶ B)
 
-/-- The equalizer in `CommRing` is the equalizer as sets. This is the equalizer fork. -/
+/-- The equalizer in `CommRingCat` is the equalizer as sets. This is the equalizer fork. -/
 def equalizerFork : Fork f g :=
   Fork.ofι (CommRingCat.ofHom (RingHom.eqLocus f g).subtype) <| by
       ext ⟨x, e⟩
@@ -231,7 +229,7 @@ def equalizerFork : Fork f g :=
 set_option linter.uppercaseLean3 false in
 #align CommRing.equalizer_fork CommRingCat.equalizerFork
 
-/-- The equalizer in `CommRing` is the equalizer as sets. -/
+/-- The equalizer in `CommRingCat` is the equalizer as sets. -/
 def equalizerForkIsLimit : IsLimit (equalizerFork f g) := by
   fapply Fork.IsLimit.mk'
   intro s
@@ -291,8 +289,8 @@ end Equalizer
 
 section Pullback
 
-/-- In the category of `CommRing`, the pullback of `f : A ⟶ C` and `g : B ⟶ C` is the `eq_locus` of
-the two maps `A × B ⟶ C`. This is the constructed pullback cone.
+/-- In the category of `CommRingCat`, the pullback of `f : A ⟶ C` and `g : B ⟶ C` is the `eqLocus`
+of the two maps `A × B ⟶ C`. This is the constructed pullback cone.
 -/
 def pullbackCone {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) : PullbackCone f g :=
   PullbackCone.mk

70fd9563

feat: port Algebra.Category.Ring.Constructions (#4366)

ca45801a

`algebra.category.Ring.constructions` ⟷ `Mathlib.Algebra.Category.Ring.Constructions`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 674

algebra.category.Ring.constructions ⟷ Mathlib.Algebra.Category.Ring.Constructions

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 674

`algebra.category.Ring.constructions` ⟷ `Mathlib.Algebra.Category.Ring.Constructions`