algebra.category.Algebra.basic | 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

79ffb556

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

1a51edf1

bump to nightly-2024-04-14-09

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

f736ea6b

Diff

@@ -232,7 +232,8 @@ instance (X : Type u) [Ring X] [Algebra R X] : Coe (Subalgebra R X) (AlgebraCat
   ⟨fun N => AlgebraCat.of R N⟩
 
 #print AlgebraCat.forget_reflects_isos /-
-instance AlgebraCat.forget_reflects_isos : ReflectsIsomorphisms (forget (AlgebraCat.{u} R))
+instance AlgebraCat.forget_reflects_isos :
+    CategoryTheory.Functor.ReflectsIsomorphisms (forget (AlgebraCat.{u} R))
     where reflects X Y f _ := by
     skip
     let i := as_iso ((forget (AlgebraCat.{u} R)).map f)

1a51edf1

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -6,7 +6,7 @@ Authors: Scott Morrison
 import Algebra.Algebra.Subalgebra.Basic
 import Algebra.FreeAlgebra
 import Algebra.Category.Ring.Basic
-import Algebra.Category.Module.Basic
+import Algebra.Category.ModuleCat.Basic
 
 #align_import algebra.category.Algebra.basic from "leanprover-community/mathlib"@"1a51edf13debfcbe223fa06b1cb353b9ed9751cc"

1a51edf1

bump to nightly-2023-12-20-06

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

058cd493

Diff

@@ -150,7 +150,7 @@ def free : Type u ⥤ AlgebraCat.{u} R
       isRing := Algebra.semiringToRing R }
   map S T f := FreeAlgebra.lift _ <| FreeAlgebra.ι _ ∘ f
   -- obviously can fill the next two goals, but it is slow
-  map_id' := by intro X; ext1; simp only [FreeAlgebra.ι_comp_lift]; rfl
+  map_id'' := by intro X; ext1; simp only [FreeAlgebra.ι_comp_lift]; rfl
   map_comp' := by
     intros; ext1; simp only [FreeAlgebra.ι_comp_lift]; ext1
     simp only [FreeAlgebra.lift_ι_apply, CategoryTheory.coe_comp, Function.comp_apply,

1a51edf1

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathbin.Algebra.Algebra.Subalgebra.Basic
-import Mathbin.Algebra.FreeAlgebra
-import Mathbin.Algebra.Category.Ring.Basic
-import Mathbin.Algebra.Category.Module.Basic
+import Algebra.Algebra.Subalgebra.Basic
+import Algebra.FreeAlgebra
+import Algebra.Category.Ring.Basic
+import Algebra.Category.Module.Basic
 
 #align_import algebra.category.Algebra.basic from "leanprover-community/mathlib"@"1a51edf13debfcbe223fa06b1cb353b9ed9751cc"

1a51edf1

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module algebra.category.Algebra.basic
-! leanprover-community/mathlib commit 1a51edf13debfcbe223fa06b1cb353b9ed9751cc
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Algebra.Subalgebra.Basic
 import Mathbin.Algebra.FreeAlgebra
 import Mathbin.Algebra.Category.Ring.Basic
 import Mathbin.Algebra.Category.Module.Basic
 
+#align_import algebra.category.Algebra.basic from "leanprover-community/mathlib"@"1a51edf13debfcbe223fa06b1cb353b9ed9751cc"
+
 /-!
 # Category instance for algebras over a commutative ring

1a51edf1

bump to nightly-2023-07-09-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/1a51edf13debfcbe223fa06b1cb353b9ed9751cc

e0217a15

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 
 ! This file was ported from Lean 3 source module algebra.category.Algebra.basic
-! leanprover-community/mathlib commit 79ffb5563b56fefdea3d60b5736dad168a9494ab
+! leanprover-community/mathlib commit 1a51edf13debfcbe223fa06b1cb353b9ed9751cc
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Algebra.Category.Module.Basic
 /-!
 # Category instance for algebras over a commutative ring
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We introduce the bundled category `Algebra` of algebras over a fixed commutative ring `R ` along
 with the forgetful functors to `Ring` and `Module`. We furthermore show that the functor associating
 to a type the free `R`-algebra on that type is left adjoint to the forgetful functor.

79ffb556

bump to nightly-2023-07-05-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/5dc6092d09e5e489106865241986f7f2ad28d4c8

90214d1f

Diff

@@ -30,12 +30,14 @@ universe v u
 
 variable (R : Type u) [CommRing R]
 
+#print AlgebraCat /-
 /-- The category of R-algebras and their morphisms. -/
 structure AlgebraCat where
   carrier : Type v
   [isRing : Ring carrier]
   [isAlgebra : Algebra R carrier]
 #align Algebra AlgebraCat
+-/
 
 attribute [instance] AlgebraCat.isRing AlgebraCat.isAlgebra
 
@@ -57,46 +59,59 @@ instance : ConcreteCategory.{v} (AlgebraCat.{v} R)
       map := fun R S f => (f : R → S) }
   forget_faithful := { }
 
+#print AlgebraCat.hasForgetToRing /-
 instance hasForgetToRing : HasForget₂ (AlgebraCat.{v} R) RingCat.{v}
     where forget₂ :=
     { obj := fun A => RingCat.of A
       map := fun A₁ A₂ f => AlgHom.toRingHom f }
 #align Algebra.has_forget_to_Ring AlgebraCat.hasForgetToRing
+-/
 
+#print AlgebraCat.hasForgetToModule /-
 instance hasForgetToModule : HasForget₂ (AlgebraCat.{v} R) (ModuleCat.{v} R)
     where forget₂ :=
     { obj := fun M => ModuleCat.of R M
       map := fun M₁ M₂ f => AlgHom.toLinearMap f }
 #align Algebra.has_forget_to_Module AlgebraCat.hasForgetToModule
+-/
 
+#print AlgebraCat.of /-
 /-- The object in the category of R-algebras associated to a type equipped with the appropriate
 typeclasses. -/
 def of (X : Type v) [Ring X] [Algebra R X] : AlgebraCat.{v} R :=
   ⟨X⟩
 #align Algebra.of AlgebraCat.of
+-/
 
+#print AlgebraCat.ofHom /-
 /-- Typecheck a `alg_hom` as a morphism in `Algebra R`. -/
 def ofHom {R : Type u} [CommRing R] {X Y : Type v} [Ring X] [Algebra R X] [Ring Y] [Algebra R Y]
     (f : X →ₐ[R] Y) : of R X ⟶ of R Y :=
   f
 #align Algebra.of_hom AlgebraCat.ofHom
+-/
 
+#print AlgebraCat.ofHom_apply /-
 @[simp]
 theorem ofHom_apply {R : Type u} [CommRing R] {X Y : Type v} [Ring X] [Algebra R X] [Ring Y]
     [Algebra R Y] (f : X →ₐ[R] Y) (x : X) : ofHom f x = f x :=
   rfl
 #align Algebra.of_hom_apply AlgebraCat.ofHom_apply
+-/
 
 instance : Inhabited (AlgebraCat R) :=
   ⟨of R R⟩
 
+#print AlgebraCat.coe_of /-
 @[simp]
 theorem coe_of (X : Type u) [Ring X] [Algebra R X] : (of R X : Type u) = X :=
   rfl
 #align Algebra.coe_of AlgebraCat.coe_of
+-/
 
 variable {R}
 
+#print AlgebraCat.ofSelfIso /-
 /-- Forgetting to the underlying type and then building the bundled object returns the original
 algebra. -/
 @[simps]
@@ -105,21 +120,27 @@ def ofSelfIso (M : AlgebraCat.{v} R) : AlgebraCat.of R M ≅ M
   hom := 𝟙 M
   inv := 𝟙 M
 #align Algebra.of_self_iso AlgebraCat.ofSelfIso
+-/
 
 variable {R} {M N U : ModuleCat.{v} R}
 
+#print AlgebraCat.id_apply /-
 @[simp]
 theorem id_apply (m : M) : (𝟙 M : M → M) m = m :=
   rfl
 #align Algebra.id_apply AlgebraCat.id_apply
+-/
 
+#print AlgebraCat.coe_comp /-
 @[simp]
 theorem coe_comp (f : M ⟶ N) (g : N ⟶ U) : (f ≫ g : M → U) = g ∘ f :=
   rfl
 #align Algebra.coe_comp AlgebraCat.coe_comp
+-/
 
 variable (R)
 
+#print AlgebraCat.free /-
 /-- The "free algebra" functor, sending a type `S` to the free algebra on `S`. -/
 @[simps]
 def free : Type u ⥤ AlgebraCat.{u} R
@@ -135,7 +156,9 @@ def free : Type u ⥤ AlgebraCat.{u} R
     simp only [FreeAlgebra.lift_ι_apply, CategoryTheory.coe_comp, Function.comp_apply,
       types_comp_apply]
 #align Algebra.free AlgebraCat.free
+-/
 
+#print AlgebraCat.adj /-
 /-- The free/forget adjunction for `R`-algebras. -/
 def adj : free.{u} R ⊣ forget (AlgebraCat.{u} R) :=
   Adjunction.mkOfHomEquiv
@@ -150,6 +173,7 @@ def adj : free.{u} R ⊣ forget (AlgebraCat.{u} R) :=
         simp only [forget_map_eq_coe, CategoryTheory.coe_comp, Function.comp_apply,
           FreeAlgebra.lift_symm_apply, types_comp_apply] }
 #align Algebra.adj AlgebraCat.adj
+-/
 
 instance : IsRightAdjoint (forget (AlgebraCat.{u} R)) :=
   ⟨_, adj R⟩
@@ -160,6 +184,7 @@ variable {R}
 
 variable {X₁ X₂ : Type u}
 
+#print AlgEquiv.toAlgebraIso /-
 /-- Build an isomorphism in the category `Algebra R` from a `alg_equiv` between `algebra`s. -/
 @[simps]
 def AlgEquiv.toAlgebraIso {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra R X₁} {m₂ : Algebra R X₂}
@@ -170,9 +195,11 @@ def AlgEquiv.toAlgebraIso {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra
   hom_inv_id' := by ext; exact e.left_inv x
   inv_hom_id' := by ext; exact e.right_inv x
 #align alg_equiv.to_Algebra_iso AlgEquiv.toAlgebraIso
+-/
 
 namespace CategoryTheory.Iso
 
+#print CategoryTheory.Iso.toAlgEquiv /-
 /-- Build a `alg_equiv` from an isomorphism in the category `Algebra R`. -/
 @[simps]
 def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y
@@ -185,9 +212,11 @@ def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y
   map_mul' := by tidy
   commutes' := by tidy
 #align category_theory.iso.to_alg_equiv CategoryTheory.Iso.toAlgEquiv
+-/
 
 end CategoryTheory.Iso
 
+#print algEquivIsoAlgebraIso /-
 /-- Algebra equivalences between `algebras`s are the same as (isomorphic to) isomorphisms in
 `Algebra`. -/
 @[simps]
@@ -197,10 +226,12 @@ def algEquivIsoAlgebraIso {X Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebr
   hom e := e.toAlgebraIso
   inv i := i.toAlgEquiv
 #align alg_equiv_iso_Algebra_iso algEquivIsoAlgebraIso
+-/
 
 instance (X : Type u) [Ring X] [Algebra R X] : Coe (Subalgebra R X) (AlgebraCat R) :=
   ⟨fun N => AlgebraCat.of R N⟩
 
+#print AlgebraCat.forget_reflects_isos /-
 instance AlgebraCat.forget_reflects_isos : ReflectsIsomorphisms (forget (AlgebraCat.{u} R))
     where reflects X Y f _ := by
     skip
@@ -208,4 +239,5 @@ instance AlgebraCat.forget_reflects_isos : ReflectsIsomorphisms (forget (Algebra
     let e : X ≃ₐ[R] Y := { f, i.to_equiv with }
     exact ⟨(is_iso.of_iso e.to_Algebra_iso).1⟩
 #align Algebra.forget_reflects_isos AlgebraCat.forget_reflects_isos
+-/

79ffb556

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -131,7 +131,7 @@ def free : Type u ⥤ AlgebraCat.{u} R
   -- obviously can fill the next two goals, but it is slow
   map_id' := by intro X; ext1; simp only [FreeAlgebra.ι_comp_lift]; rfl
   map_comp' := by
-    intros ; ext1; simp only [FreeAlgebra.ι_comp_lift]; ext1
+    intros; ext1; simp only [FreeAlgebra.ι_comp_lift]; ext1
     simp only [FreeAlgebra.lift_ι_apply, CategoryTheory.coe_comp, Function.comp_apply,
       types_comp_apply]
 #align Algebra.free AlgebraCat.free
@@ -142,11 +142,11 @@ def adj : free.{u} R ⊣ forget (AlgebraCat.{u} R) :=
     { homEquiv := fun X A => (FreeAlgebra.lift _).symm
       -- Relying on `obviously` to fill out these proofs is very slow :(
       homEquiv_naturality_left_symm := by
-        intros ; ext
+        intros; ext
         simp only [free_map, Equiv.symm_symm, FreeAlgebra.lift_ι_apply, CategoryTheory.coe_comp,
           Function.comp_apply, types_comp_apply]
       homEquiv_naturality_right := by
-        intros ; ext
+        intros; ext
         simp only [forget_map_eq_coe, CategoryTheory.coe_comp, Function.comp_apply,
           FreeAlgebra.lift_symm_apply, types_comp_apply] }
 #align Algebra.adj AlgebraCat.adj

79ffb556

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -129,16 +129,9 @@ def free : Type u ⥤ AlgebraCat.{u} R
       isRing := Algebra.semiringToRing R }
   map S T f := FreeAlgebra.lift _ <| FreeAlgebra.ι _ ∘ f
   -- obviously can fill the next two goals, but it is slow
-  map_id' := by
-    intro X
-    ext1
-    simp only [FreeAlgebra.ι_comp_lift]
-    rfl
+  map_id' := by intro X; ext1; simp only [FreeAlgebra.ι_comp_lift]; rfl
   map_comp' := by
-    intros
-    ext1
-    simp only [FreeAlgebra.ι_comp_lift]
-    ext1
+    intros ; ext1; simp only [FreeAlgebra.ι_comp_lift]; ext1
     simp only [FreeAlgebra.lift_ι_apply, CategoryTheory.coe_comp, Function.comp_apply,
       types_comp_apply]
 #align Algebra.free AlgebraCat.free
@@ -149,13 +142,11 @@ def adj : free.{u} R ⊣ forget (AlgebraCat.{u} R) :=
     { homEquiv := fun X A => (FreeAlgebra.lift _).symm
       -- Relying on `obviously` to fill out these proofs is very slow :(
       homEquiv_naturality_left_symm := by
-        intros
-        ext
+        intros ; ext
         simp only [free_map, Equiv.symm_symm, FreeAlgebra.lift_ι_apply, CategoryTheory.coe_comp,
           Function.comp_apply, types_comp_apply]
       homEquiv_naturality_right := by
-        intros
-        ext
+        intros ; ext
         simp only [forget_map_eq_coe, CategoryTheory.coe_comp, Function.comp_apply,
           FreeAlgebra.lift_symm_apply, types_comp_apply] }
 #align Algebra.adj AlgebraCat.adj

79ffb556

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

79ffb556

chore(CategoryTheory): move Full, Faithful, EssSurj, IsEquivalence and ReflectsIsomorphisms to the Functor namespace (#11985)

These notions on functors are now Functor.Full, Functor.Faithful, Functor.EssSurj, Functor.IsEquivalence, Functor.ReflectsIsomorphisms. Deprecated aliases are introduced for the previous names.

65b7affc

Diff

@@ -247,7 +247,7 @@ def algEquivIsoAlgebraIso {X Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebr
 instance (X : Type u) [Ring X] [Algebra R X] : CoeOut (Subalgebra R X) (AlgebraCat R) :=
   ⟨fun N => AlgebraCat.of R N⟩
 
-instance AlgebraCat.forget_reflects_isos : ReflectsIsomorphisms (forget (AlgebraCat.{u} R)) where
+instance AlgebraCat.forget_reflects_isos : (forget (AlgebraCat.{u} R)).ReflectsIsomorphisms where
   reflects {X Y} f _ := by
     let i := asIso ((forget (AlgebraCat.{u} R)).map f)
     let e : X ≃ₐ[R] Y := { f, i.toEquiv with }

79ffb556

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -196,7 +196,6 @@ instance : IsRightAdjoint (forget (AlgebraCat.{u} R)) :=
 end AlgebraCat
 
 variable {R}
-
 variable {X₁ X₂ : Type u}
 
 /-- Build an isomorphism in the category `AlgebraCat R` from a `AlgEquiv` between `Algebra`s. -/

79ffb556

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -154,10 +154,10 @@ def free : Type u ⥤ AlgebraCat.{u} R where
     { carrier := FreeAlgebra R S
       isRing := Algebra.semiringToRing R }
   map f := FreeAlgebra.lift _ <| FreeAlgebra.ι _ ∘ f
-  -- porting note: `apply FreeAlgebra.hom_ext` was `ext1`.
+  -- Porting note: `apply FreeAlgebra.hom_ext` was `ext1`.
   map_id := by intro X; apply FreeAlgebra.hom_ext; simp only [FreeAlgebra.ι_comp_lift]; rfl
   map_comp := by
-  -- porting note: `apply FreeAlgebra.hom_ext` was `ext1`.
+  -- Porting note: `apply FreeAlgebra.hom_ext` was `ext1`.
     intros; apply FreeAlgebra.hom_ext; simp only [FreeAlgebra.ι_comp_lift]; ext1
     -- Porting node: this ↓ `erw` used to be handled by the `simp` below it
     erw [CategoryTheory.coe_comp]
@@ -173,7 +173,7 @@ def adj : free.{u} R ⊣ forget (AlgebraCat.{u} R) :=
     { homEquiv := fun X A => (FreeAlgebra.lift _).symm
       -- Relying on `obviously` to fill out these proofs is very slow :(
       homEquiv_naturality_left_symm := by
-        -- porting note: `apply FreeAlgebra.hom_ext` was `ext1`.
+        -- Porting note: `apply FreeAlgebra.hom_ext` was `ext1`.
         intros; apply FreeAlgebra.hom_ext; simp only [FreeAlgebra.ι_comp_lift]; ext1
         simp only [free_map, Equiv.symm_symm, FreeAlgebra.lift_ι_apply, CategoryTheory.coe_comp,
           Function.comp_apply, types_comp_apply]
@@ -217,13 +217,13 @@ def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y where
   toFun := i.hom
   invFun := i.inv
   left_inv x := by
-    -- porting note: was `by tidy`
+    -- Porting note: was `by tidy`
     change (i.hom ≫ i.inv) x = x
     simp only [hom_inv_id]
     -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
     erw [id_apply]
   right_inv x := by
-    -- porting note: was `by tidy`
+    -- Porting note: was `by tidy`
     change (i.inv ≫ i.hom) x = x
     simp only [inv_hom_id]
     -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644

79ffb556

refactor(Data/FunLike): use unbundled inheritance from FunLike (#8386)

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

`simp` not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

c6a73d4f

Diff

@@ -57,6 +57,9 @@ instance : Category (AlgebraCat.{v} R) where
   id A := AlgHom.id R A
   comp f g := g.comp f
 
+instance {M N : AlgebraCat.{v} R} : FunLike (M ⟶ N) M N :=
+  AlgHom.funLike
+
 instance {M N : AlgebraCat.{v} R} : AlgHomClass (M ⟶ N) R M N :=
   AlgHom.algHomClass

79ffb556

chore: golfing in categories of algebraic objects (#10114)

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

0c4b7314

Diff

@@ -225,8 +225,8 @@ def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y where
     simp only [inv_hom_id]
     -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
     erw [id_apply]
-  map_add' := i.hom.map_add -- Porting note: was `by tidy`
-  map_mul' := i.hom.map_mul -- Porting note: was `by tidy`
+  map_add' := by aesop
+  map_mul' := by aesop
   commutes' := i.hom.commutes -- Porting note: was `by tidy`
 #align category_theory.iso.to_alg_equiv CategoryTheory.Iso.toAlgEquiv

79ffb556

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

This reverts commit f3695eb2.

ab56fa28

Diff

@@ -217,12 +217,14 @@ def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y where
     -- porting note: was `by tidy`
     change (i.hom ≫ i.inv) x = x
     simp only [hom_inv_id]
-    rw [id_apply]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [id_apply]
   right_inv x := by
     -- porting note: was `by tidy`
     change (i.inv ≫ i.hom) x = x
     simp only [inv_hom_id]
-    rw [id_apply]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [id_apply]
   map_add' := i.hom.map_add -- Porting note: was `by tidy`
   map_mul' := i.hom.map_mul -- Porting note: was `by tidy`
   commutes' := i.hom.commutes -- Porting note: was `by tidy`

79ffb556

chore: revert #7703 (#7710)

This reverts commit 26eb2b0a.

f3695eb2

Diff

@@ -217,14 +217,12 @@ def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y where
     -- porting note: was `by tidy`
     change (i.hom ≫ i.inv) x = x
     simp only [hom_inv_id]
-    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-    erw [id_apply]
+    rw [id_apply]
   right_inv x := by
     -- porting note: was `by tidy`
     change (i.inv ≫ i.hom) x = x
     simp only [inv_hom_id]
-    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-    erw [id_apply]
+    rw [id_apply]
   map_add' := i.hom.map_add -- Porting note: was `by tidy`
   map_mul' := i.hom.map_mul -- Porting note: was `by tidy`
   commutes' := i.hom.commutes -- Porting note: was `by tidy`

79ffb556

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

@@ -217,12 +217,14 @@ def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y where
     -- porting note: was `by tidy`
     change (i.hom ≫ i.inv) x = x
     simp only [hom_inv_id]
-    rw [id_apply]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [id_apply]
   right_inv x := by
     -- porting note: was `by tidy`
     change (i.inv ≫ i.hom) x = x
     simp only [inv_hom_id]
-    rw [id_apply]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [id_apply]
   map_add' := i.hom.map_add -- Porting note: was `by tidy`
   map_mul' := i.hom.map_mul -- Porting note: was `by tidy`
   commutes' := i.hom.commutes -- Porting note: was `by tidy`

79ffb556

feat: MonoidalCategory (AlgebraCat R) (#7598)

Some of these proofs are a little awkward as they have to fight with:

non-reducible type issues with Quiver.Hom vs AlgHom
mazes of coercions between AlgEquiv and LinearMap
defeqs not matching between module and algebra tensor product

This also corrects an accidental mis-statement of Algebra.TensorProduct.assoc_tmul.

7a8ef174

Diff

@@ -84,6 +84,16 @@ instance hasForgetToModule : HasForget₂ (AlgebraCat.{v} R) (ModuleCat.{v} R) w
       map := fun f => ModuleCat.ofHom f.toLinearMap }
 #align Algebra.has_forget_to_Module AlgebraCat.hasForgetToModule
 
+@[simp]
+lemma forget₂_module_obj (X : AlgebraCat.{v} R) :
+    (forget₂ (AlgebraCat.{v} R) (ModuleCat.{v} R)).obj X = ModuleCat.of R X :=
+  rfl
+
+@[simp]
+lemma forget₂_module_map {X Y : AlgebraCat.{v} R} (f : X ⟶ Y) :
+    (forget₂ (AlgebraCat.{v} R) (ModuleCat.{v} R)).map f = ModuleCat.ofHom f.toLinearMap :=
+  rfl
+
 /-- The object in the category of R-algebras associated to a type equipped with the appropriate
 typeclasses. -/
 def of (X : Type v) [Ring X] [Algebra R X] : AlgebraCat.{v} R :=

79ffb556

chore: remove trailing space in backticks (#7617)

This will improve spaces in the mathlib4 docs.

9106dcf8

Diff

@@ -13,7 +13,7 @@ import Mathlib.Algebra.Category.ModuleCat.Basic
 /-!
 # Category instance for algebras over a commutative ring
 
-We introduce the bundled category `AlgebraCat` of algebras over a fixed commutative ring `R ` along
+We introduce the bundled category `AlgebraCat` of algebras over a fixed commutative ring `R` along
 with the forgetful functors to `RingCat` and `ModuleCat`. We furthermore show that the functor
 associating to a type the free `R`-algebra on that type is left adjoint to the forgetful functor.
 -/

79ffb556

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,17 +2,14 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module algebra.category.Algebra.basic
-! leanprover-community/mathlib commit 79ffb5563b56fefdea3d60b5736dad168a9494ab
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Algebra.Subalgebra.Basic
 import Mathlib.Algebra.FreeAlgebra
 import Mathlib.Algebra.Category.Ring.Basic
 import Mathlib.Algebra.Category.ModuleCat.Basic
 
+#align_import algebra.category.Algebra.basic from "leanprover-community/mathlib"@"79ffb5563b56fefdea3d60b5736dad168a9494ab"
+
 /-!
 # Category instance for algebras over a commutative ring

79ffb556

chore: tidy various files (#5971)

bb6d52f7

Diff

@@ -16,9 +16,9 @@ import Mathlib.Algebra.Category.ModuleCat.Basic
 /-!
 # Category instance for algebras over a commutative ring
 
-We introduce the bundled category `Algebra` of algebras over a fixed commutative ring `R ` along
-with the forgetful functors to `Ring` and `Module`. We furthermore show that the functor associating
-to a type the free `R`-algebra on that type is left adjoint to the forgetful functor.
+We introduce the bundled category `AlgebraCat` of algebras over a fixed commutative ring `R ` along
+with the forgetful functors to `RingCat` and `ModuleCat`. We furthermore show that the functor
+associating to a type the free `R`-algebra on that type is left adjoint to the forgetful functor.
 -/
 
 set_option linter.uppercaseLean3 false
@@ -93,7 +93,7 @@ def of (X : Type v) [Ring X] [Algebra R X] : AlgebraCat.{v} R :=
   ⟨X⟩
 #align Algebra.of AlgebraCat.of
 
-/-- Typecheck a `alg_hom` as a morphism in `Algebra R`. -/
+/-- Typecheck a `AlgHom` as a morphism in `AlgebraCat R`. -/
 def ofHom {R : Type u} [CommRing R] {X Y : Type v} [Ring X] [Algebra R X] [Ring Y] [Algebra R Y]
     (f : X →ₐ[R] Y) : of R X ⟶ of R Y :=
   f
@@ -189,7 +189,7 @@ variable {R}
 
 variable {X₁ X₂ : Type u}
 
-/-- Build an isomorphism in the category `Algebra R` from a `alg_equiv` between `algebra`s. -/
+/-- Build an isomorphism in the category `AlgebraCat R` from a `AlgEquiv` between `Algebra`s. -/
 @[simps]
 def AlgEquiv.toAlgebraIso {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra R X₁} {m₂ : Algebra R X₂}
     (e : X₁ ≃ₐ[R] X₂) : AlgebraCat.of R X₁ ≅ AlgebraCat.of R X₂ where
@@ -201,7 +201,7 @@ def AlgEquiv.toAlgebraIso {g₁ : Ring X₁} {g₂ : Ring X₂} {m₁ : Algebra
 
 namespace CategoryTheory.Iso
 
-/-- Build a `alg_equiv` from an isomorphism in the category `Algebra R`. -/
+/-- Build a `AlgEquiv` from an isomorphism in the category `AlgebraCat R`. -/
 @[simps]
 def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y where
   toFun := i.hom
@@ -223,8 +223,8 @@ def toAlgEquiv {X Y : AlgebraCat R} (i : X ≅ Y) : X ≃ₐ[R] Y where
 
 end CategoryTheory.Iso
 
-/-- Algebra equivalences between `algebras`s are the same as (isomorphic to) isomorphisms in
-`Algebra`. -/
+/-- Algebra equivalences between `Algebra`s are the same as (isomorphic to) isomorphisms in
+`AlgebraCat`. -/
 @[simps]
 def algEquivIsoAlgebraIso {X Y : Type u} [Ring X] [Ring Y] [Algebra R X] [Algebra R Y] :
     (X ≃ₐ[R] Y) ≅ AlgebraCat.of R X ≅ AlgebraCat.of R Y where
@@ -238,7 +238,7 @@ instance (X : Type u) [Ring X] [Algebra R X] : CoeOut (Subalgebra R X) (AlgebraC
 
 instance AlgebraCat.forget_reflects_isos : ReflectsIsomorphisms (forget (AlgebraCat.{u} R)) where
   reflects {X Y} f _ := by
-    { let i := asIso ((forget (AlgebraCat.{u} R)).map f)
-      let e : X ≃ₐ[R] Y := { f, i.toEquiv with }
-      exact ⟨(IsIso.of_iso e.toAlgebraIso).1⟩ }
+    let i := asIso ((forget (AlgebraCat.{u} R)).map f)
+    let e : X ≃ₐ[R] Y := { f, i.toEquiv with }
+    exact ⟨(IsIso.of_iso e.toAlgebraIso).1⟩
 #align Algebra.forget_reflects_isos AlgebraCat.forget_reflects_isos

79ffb556

feat: port Algebra.Category.Algebra.Limits (#5716)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Calvin Lee <calvins.lee@utah.edu> Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

811ee339

Diff

@@ -38,6 +38,12 @@ structure AlgebraCat where
   [isAlgebra : Algebra R carrier]
 #align Algebra AlgebraCat
 
+-- Porting note: typemax hack to fix universe complaints
+/-- An alias for `AlgebraCat.{max u₁ u₂}`, to deal around unification issues.
+Since the universe the ring lives in can be inferred, we put that last. -/
+@[nolint checkUnivs]
+abbrev AlgebraCatMax.{v₁, v₂, u₁} (R : Type u₁) [CommRing R] := AlgebraCat.{max v₁ v₂} R
+
 attribute [instance] AlgebraCat.isRing AlgebraCat.isAlgebra
 
 initialize_simps_projections AlgebraCat (-isRing, -isAlgebra)
@@ -54,9 +60,8 @@ instance : Category (AlgebraCat.{v} R) where
   id A := AlgHom.id R A
   comp f g := g.comp f
 
--- simplifies definitions below
-instance {S T : AlgebraCat.{v} R} : FunLike (S ⟶ T) S (fun _ => T) :=
-  ⟨fun f => f.toFun, fun _ _ h => AlgHom.ext (congr_fun h)⟩
+instance {M N : AlgebraCat.{v} R} : AlgHomClass (M ⟶ N) R M N :=
+  AlgHom.algHomClass
 
 instance : ConcreteCategory.{v} (AlgebraCat.{v} R) where
   forget :=

79ffb556

feat: port Algebra.Category.Algebra.Basic (#4504)

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Calvin Lee <calvins.lee@utah.edu> Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

d6a45165

`algebra.category.Algebra.basic` ⟷ `Mathlib.Algebra.Category.AlgebraCat.Basic`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Important changes

Remaining issues

Slower (failing) search

`simp` not firing sometimes

Missing instances due to unification failing

Workaround for issues

Dependencies 8 + 555

algebra.category.Algebra.basic ⟷ Mathlib.Algebra.Category.AlgebraCat.Basic

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Important changes

Remaining issues

Slower (failing) search

simp not firing sometimes

Missing instances due to unification failing

Workaround for issues

Dependencies 8 + 555

`algebra.category.Algebra.basic` ⟷ `Mathlib.Algebra.Category.AlgebraCat.Basic`

`simp` not firing sometimes