ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.LocalizerMorphism.smallHomMap_comp
lemma smallHomMap_comp (f : SmallHom.{w} W₁ X Y) (g : SmallHom.{w} W₁ Y Z) :
    Φ.smallHomMap (f.comp g) = (Φ.smallHomMap f).comp (Φ.smallHomMap g) 
Arguments: {C₁ : Type u₁} [CategoryTheory.Category.{v₁, u₁} C₁] {W₁ : CategoryTheory.MorphismProperty C₁} {C₂ : Type u₂} [CategoryTheory.Category.{v₂, u₂} C₂] {W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {X Y Z : C₁} [CategoryTheory.Localization.HasSmallLocalizedHom W₁ X Y] [CategoryTheory.Localization.HasSmallLocalizedHom W₁ Y Z] [CategoryTheory.Localization.HasSmallLocalizedHom W₁ X Z] [CategoryTheory.Localization.HasSmallLocalizedHom W₂ (Φ.functor.obj X) (Φ.functor.obj Y)] [CategoryTheory.Localization.HasSmallLocalizedHom W₂ (Φ.functor.obj Y) (Φ.functor.obj Z)] [CategoryTheory.Localization.HasSmallLocalizedHom W₂ (Φ.functor.obj X) (Φ.functor.obj Z)] (f : CategoryTheory.Localization.SmallHom W₁ X Y) (g : CategoryTheory.Localization.SmallHom W₁ Y Z)
Goal: Φ.smallHomMap (f.comp g) = (Φ.smallHomMap f).comp (Φ.smallHomMap g)
-- CategoryTheory.predicateShift_iff
lemma predicateShift_iff (a : A) (X : C) : PredicateShift P a X ↔ P (X⟦a⟧) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (P : C → Prop) {A : Type u_2} [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: CategoryTheory.PredicateShift P a X ↔ P ((CategoryTheory.shiftFunctor C a).obj X)
-- CategoryTheory.predicateShift_zero
@[simp]
lemma predicateShift_zero [ClosedUnderIsomorphisms P] : PredicateShift P (0 : A) = P 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (P : C → Prop) (A : Type u_2) [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.ClosedUnderIsomorphisms P]
Goal: CategoryTheory.PredicateShift P 0 = P
-- CategoryTheory.predicateShift_predicateShift
lemma predicateShift_predicateShift (a b c : A) (h : a + b = c) [ClosedUnderIsomorphisms P] :
    PredicateShift (PredicateShift P b) a = PredicateShift P c 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (P : C → Prop) {A : Type u_2} [AddMonoid A] [CategoryTheory.HasShift C A] (a b c : A) (h : a + b = c) [CategoryTheory.ClosedUnderIsomorphisms P]
Goal: CategoryTheory.PredicateShift (CategoryTheory.PredicateShift P b) a = CategoryTheory.PredicateShift P c
-- CategoryTheory.Mat_.hom_ext
@[ext]
theorem hom_ext {M N : Mat_ C} (f g : M ⟶ N) (H : ∀ i j, f i j = g i j) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {M N : CategoryTheory.Mat_ C} (f g : M ⟶ N) (H : ∀ (i : M.ι) (j : N.ι), f i j = g i j)
Goal: f = g
-- CategoryTheory.Mat_.id_def
theorem id_def (M : Mat_ C) :
    (𝟙 M : Hom M M) = fun i j => if h : i = j then eqToHom (congr_arg M.X h) else 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (M : CategoryTheory.Mat_ C)
Goal: 𝟙 M = fun i j => if h : i = j then CategoryTheory.eqToHom ⋯ else 0
-- CategoryTheory.Mat_.id_apply
theorem id_apply (M : Mat_ C) (i j : M.ι) :
    (𝟙 M : Hom M M) i j = if h : i = j then eqToHom (congr_arg M.X h) else 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (M : CategoryTheory.Mat_ C) (i j : M.ι)
Goal: 𝟙 M i j = if h : i = j then CategoryTheory.eqToHom ⋯ else 0
-- CategoryTheory.Mat_.id_apply_self
@[simp]
theorem id_apply_self (M : Mat_ C) (i : M.ι) : (𝟙 M : Hom M M) i i = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (M : CategoryTheory.Mat_ C) (i : M.ι)
Goal: 𝟙 M i i = 𝟙 (M.X i)
-- CategoryTheory.Mat_.id_apply_of_ne
@[simp]
theorem id_apply_of_ne (M : Mat_ C) (i j : M.ι) (h : i ≠ j) : (𝟙 M : Hom M M) i j = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (M : CategoryTheory.Mat_ C) (i j : M.ι) (h : i ≠ j)
Goal: 𝟙 M i j = 0
-- CategoryTheory.Mat_.comp_def
theorem comp_def {M N K : Mat_ C} (f : M ⟶ N) (g : N ⟶ K) :
    f ≫ g = fun i k => ∑ j : N.ι, f i j ≫ g j k 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {M N K : CategoryTheory.Mat_ C} (f : M ⟶ N) (g : N ⟶ K)
Goal: f ≫ g = fun i k => ∑ j : N.ι, f i j ≫ g j k
-- CategoryTheory.Mat_.comp_apply
@[simp]
theorem comp_apply {M N K : Mat_ C} (f : M ⟶ N) (g : N ⟶ K) (i k) :
    (f ≫ g) i k = ∑ j : N.ι, f i j ≫ g j k 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {M N K : CategoryTheory.Mat_ C} (f : M ⟶ N) (g : N ⟶ K) (i : M.ι) (k : K.ι)
Goal: (f ≫ g) i k = ∑ j : N.ι, f i j ≫ g j k
-- CategoryTheory.Mat_.add_apply
@[simp]
theorem add_apply {M N : Mat_ C} (f g : M ⟶ N) (i j) : (f + g) i j = f i j + g i j 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {M N : CategoryTheory.Mat_ C} (f g : M ⟶ N) (i : M.ι) (j : N.ι)
Goal: (f + g) i j = f i j + g i j
-- CategoryTheory.Functor.mapMat__obj_ι
@[simps]
def mapMat_ (F : C ⥤ D) [Functor.Additive F] : Mat_ C ⥤ Mat_ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u_1} [CategoryTheory.Category.{v₁, u_1} D] [CategoryTheory.Preadditive D] (F : C ⥤ D) [F.Additive] (M : CategoryTheory.Mat_ C)
Goal: (F.mapMat_.obj M).ι = M.ι
-- CategoryTheory.Functor.mapMat__map
@[simps]
def mapMat_ (F : C ⥤ D) [Functor.Additive F] : Mat_ C ⥤ Mat_ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u_1} [CategoryTheory.Category.{v₁, u_1} D] [CategoryTheory.Preadditive D] (F : C ⥤ D) [F.Additive]
Goal: ∀ {X Y : CategoryTheory.Mat_ C} (f : X ⟶ Y) (i : ((fun M => CategoryTheory.Mat_.mk M.ι fun i => F.obj (M.X i)) X).ι)
  (j : ((fun M => CategoryTheory.Mat_.mk M.ι fun i => F.obj (M.X i)) Y).ι), F.mapMat_.map f i j = F.map (f i j)
-- CategoryTheory.Functor.mapMat__obj_fintype
@[simps]
def mapMat_ (F : C ⥤ D) [Functor.Additive F] : Mat_ C ⥤ Mat_ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u_1} [CategoryTheory.Category.{v₁, u_1} D] [CategoryTheory.Preadditive D] (F : C ⥤ D) [F.Additive] (M : CategoryTheory.Mat_ C)
Goal: (F.mapMat_.obj M).fintype = M.fintype
-- CategoryTheory.Functor.mapMat__obj_X
@[simps]
def mapMat_ (F : C ⥤ D) [Functor.Additive F] : Mat_ C ⥤ Mat_ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u_1} [CategoryTheory.Category.{v₁, u_1} D] [CategoryTheory.Preadditive D] (F : C ⥤ D) [F.Additive] (M : CategoryTheory.Mat_ C) (i : M.ι)
Goal: (F.mapMat_.obj M).X i = F.obj (M.X i)
-- CategoryTheory.Functor.mapMatId_inv_app
@[simps!]
def mapMatId : (𝟭 C).mapMat_ ≅ 𝟭 (Mat_ C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.Mat_ C)
Goal: CategoryTheory.Functor.mapMatId.inv.app X = 𝟙 ((𝟭 C).mapMat_.obj X)
-- CategoryTheory.Functor.mapMatId_hom_app
@[simps!]
def mapMatId : (𝟭 C).mapMat_ ≅ 𝟭 (Mat_ C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.Mat_ C)
Goal: CategoryTheory.Functor.mapMatId.hom.app X = 𝟙 ((𝟭 C).mapMat_.obj X)
-- CategoryTheory.Functor.mapMatComp_inv_app
@[simps!]
def mapMatComp {E : Type*} [Category.{v₁} E] [Preadditive E] (F : C ⥤ D) [Functor.Additive F]
    (G : D ⥤ E) [Functor.Additive G] : (F ⋙ G).mapMat_ ≅ F.mapMat_ ⋙ G.mapMat_ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u_1} [CategoryTheory.Category.{v₁, u_1} D] [CategoryTheory.Preadditive D] {E : Type u_2} [CategoryTheory.Category.{v₁, u_2} E] [CategoryTheory.Preadditive E] (F : C ⥤ D) [F.Additive] (G : D ⥤ E) [G.Additive] (X : CategoryTheory.Mat_ C)
Goal: (F.mapMatComp G).inv.app X = 𝟙 ((F ⋙ G).mapMat_.obj X)
-- CategoryTheory.Functor.mapMatComp_hom_app
@[simps!]
def mapMatComp {E : Type*} [Category.{v₁} E] [Preadditive E] (F : C ⥤ D) [Functor.Additive F]
    (G : D ⥤ E) [Functor.Additive G] : (F ⋙ G).mapMat_ ≅ F.mapMat_ ⋙ G.mapMat_ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u_1} [CategoryTheory.Category.{v₁, u_1} D] [CategoryTheory.Preadditive D] {E : Type u_2} [CategoryTheory.Category.{v₁, u_2} E] [CategoryTheory.Preadditive E] (F : C ⥤ D) [F.Additive] (G : D ⥤ E) [G.Additive] (X : CategoryTheory.Mat_ C)
Goal: (F.mapMatComp G).hom.app X = 𝟙 ((F ⋙ G).mapMat_.obj X)
-- CategoryTheory.Mat_.embedding_obj_fintype
@[simps]
def embedding : C ⥤ Mat_ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (X : C)
Goal: ((CategoryTheory.Mat_.embedding C).obj X).fintype = PUnit.fintype
-- CategoryTheory.Mat_.embedding_map
@[simps]
def embedding : C ⥤ Mat_ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C]
Goal: ∀ {X Y : C} (f : X ⟶ Y) (x : ((fun X => CategoryTheory.Mat_.mk PUnit.{1} fun x => X) X).ι)
  (x_1 : ((fun X => CategoryTheory.Mat_.mk PUnit.{1} fun x => X) Y).ι),
  (CategoryTheory.Mat_.embedding C).map f x x_1 = f
-- CategoryTheory.Mat_.embedding_obj_X
@[simps]
def embedding : C ⥤ Mat_ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (X : C)
Goal: ∀ (x : PUnit.{1}), ((CategoryTheory.Mat_.embedding C).obj X).X x = X
-- CategoryTheory.Mat_.embedding_obj_ι
@[simps]
def embedding : C ⥤ Mat_ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (X : C)
Goal: ((CategoryTheory.Mat_.embedding C).obj X).ι = PUnit.{1}
-- CategoryTheory.Mat_.isoBiproductEmbedding_hom
@[simps]
def isoBiproductEmbedding (M : Mat_ C) : M ≅ ⨁ fun i => (embedding C).obj (M.X i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (M : CategoryTheory.Mat_ C)
Goal: M.isoBiproductEmbedding.hom =
  CategoryTheory.Limits.biproduct.lift fun i j k => if h : j = i then CategoryTheory.eqToHom ⋯ else 0
-- CategoryTheory.Mat_.isoBiproductEmbedding_inv
@[simps]
def isoBiproductEmbedding (M : Mat_ C) : M ≅ ⨁ fun i => (embedding C).obj (M.X i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] (M : CategoryTheory.Mat_ C)
Goal: M.isoBiproductEmbedding.inv =
  CategoryTheory.Limits.biproduct.desc fun i j k => if h : i = k then CategoryTheory.eqToHom ⋯ else 0
-- CategoryTheory.Mat_.additiveObjIsoBiproduct_hom_π
@[reassoc (attr := simp)]
lemma additiveObjIsoBiproduct_hom_π (F : Mat_ C ⥤ D) [Functor.Additive F] (M : Mat_ C) (i : M.ι) :
    (additiveObjIsoBiproduct F M).hom ≫ biproduct.π _ i =
      F.map (M.isoBiproductEmbedding.hom ≫ biproduct.π _ i) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] [CategoryTheory.Preadditive D] (F : CategoryTheory.Mat_ C ⥤ D) [F.Additive] (M : CategoryTheory.Mat_ C) (i : M.ι)
Goal: (CategoryTheory.Mat_.additiveObjIsoBiproduct F M).hom ≫
    CategoryTheory.Limits.biproduct.π (fun i => F.obj ((CategoryTheory.Mat_.embedding C).obj (M.X i))) i =
  F.map
    (M.isoBiproductEmbedding.hom ≫
      CategoryTheory.Limits.biproduct.π (fun i => (CategoryTheory.Mat_.embedding C).obj (M.X i)) i)
-- CategoryTheory.Mat_.ι_additiveObjIsoBiproduct_inv
@[reassoc (attr := simp)]
lemma ι_additiveObjIsoBiproduct_inv (F : Mat_ C ⥤ D) [Functor.Additive F] (M : Mat_ C) (i : M.ι) :
    biproduct.ι _ i ≫ (additiveObjIsoBiproduct F M).inv =
      F.map (biproduct.ι _ i ≫ M.isoBiproductEmbedding.inv) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] [CategoryTheory.Preadditive D] (F : CategoryTheory.Mat_ C ⥤ D) [F.Additive] (M : CategoryTheory.Mat_ C) (i : M.ι)
Goal: CategoryTheory.Limits.biproduct.ι (fun i => F.obj ((CategoryTheory.Mat_.embedding C).obj (M.X i))) i ≫
    (CategoryTheory.Mat_.additiveObjIsoBiproduct F M).inv =
  F.map
    (CategoryTheory.Limits.biproduct.ι (fun i => (CategoryTheory.Mat_.embedding C).obj (M.X i)) i ≫
      M.isoBiproductEmbedding.inv)
-- CategoryTheory.Mat_.additiveObjIsoBiproduct_naturality
@[reassoc]
theorem additiveObjIsoBiproduct_naturality (F : Mat_ C ⥤ D) [Functor.Additive F] {M N : Mat_ C}
    (f : M ⟶ N) :
    F.map f ≫ (additiveObjIsoBiproduct F N).hom =
      (additiveObjIsoBiproduct F M).hom ≫
        biproduct.matrix fun i j => F.map ((embedding C).map (f i j)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Mat_ C ⥤ D) [F.Additive] {M N : CategoryTheory.Mat_ C} (f : M ⟶ N)
Goal: F.map f ≫ (CategoryTheory.Mat_.additiveObjIsoBiproduct F N).hom =
  (CategoryTheory.Mat_.additiveObjIsoBiproduct F M).hom ≫
    CategoryTheory.Limits.biproduct.matrix fun i j => F.map ((CategoryTheory.Mat_.embedding C).map (f i j))
-- CategoryTheory.Mat_.additiveObjIsoBiproduct_naturality'
@[reassoc]
theorem additiveObjIsoBiproduct_naturality' (F : Mat_ C ⥤ D) [Functor.Additive F] {M N : Mat_ C}
    (f : M ⟶ N) :
    (additiveObjIsoBiproduct F M).inv ≫ F.map f =
      biproduct.matrix (fun i j => F.map ((embedding C).map (f i j)) : _) ≫
        (additiveObjIsoBiproduct F N).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Mat_ C ⥤ D) [F.Additive] {M N : CategoryTheory.Mat_ C} (f : M ⟶ N)
Goal: (CategoryTheory.Mat_.additiveObjIsoBiproduct F M).inv ≫ F.map f =
  (CategoryTheory.Limits.biproduct.matrix fun i j => F.map ((CategoryTheory.Mat_.embedding C).map (f i j))) ≫
    (CategoryTheory.Mat_.additiveObjIsoBiproduct F N).inv
-- CategoryTheory.Mat_.lift_map
@[simps]
def lift (F : C ⥤ D) [Functor.Additive F] : Mat_ C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasFiniteBiproducts D] (F : C ⥤ D) [F.Additive]
Goal: ∀ {X Y : CategoryTheory.Mat_ C} (f : X ⟶ Y),
  (CategoryTheory.Mat_.lift F).map f = CategoryTheory.Limits.biproduct.matrix fun i j => F.map (f i j)
-- CategoryTheory.Mat_.lift_obj
@[simps]
def lift (F : C ⥤ D) [Functor.Additive F] : Mat_ C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasFiniteBiproducts D] (F : C ⥤ D) [F.Additive] (X : CategoryTheory.Mat_ C)
Goal: (CategoryTheory.Mat_.lift F).obj X = ⨁ fun i => F.obj (X.X i)
-- CategoryTheory.Mat_.embeddingLiftIso_hom_app
@[simps!]
def embeddingLiftIso (F : C ⥤ D) [Functor.Additive F] : embedding C ⋙ lift F ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasFiniteBiproducts D] (F : C ⥤ D) [F.Additive] (X : C)
Goal: (CategoryTheory.Mat_.embeddingLiftIso F).hom.app X = CategoryTheory.Limits.biproduct.desc fun x => 𝟙 (F.obj X)
-- CategoryTheory.Mat_.embeddingLiftIso_inv_app
@[simps!]
def embeddingLiftIso (F : C ⥤ D) [Functor.Additive F] : embedding C ⋙ lift F ≅ F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasFiniteBiproducts D] (F : C ⥤ D) [F.Additive] (X : C)
Goal: (CategoryTheory.Mat_.embeddingLiftIso F).inv.app X = CategoryTheory.Limits.biproduct.lift fun x => 𝟙 (F.obj X)
-- CategoryTheory.Mat_.equivalenceSelfOfHasFiniteBiproducts_functor
@[simp]
theorem equivalenceSelfOfHasFiniteBiproducts_functor {C : Type (u₁ + 1)} [LargeCategory C]
    [Preadditive C] [HasFiniteBiproducts C] :
    (equivalenceSelfOfHasFiniteBiproducts C).functor = lift (𝟭 C) 
Arguments: {C : Type (u₁ + 1)} [CategoryTheory.LargeCategory C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasFiniteBiproducts C]
Goal: (CategoryTheory.Mat_.equivalenceSelfOfHasFiniteBiproducts C).functor = CategoryTheory.Mat_.lift (𝟭 C)
-- CategoryTheory.Mat_.equivalenceSelfOfHasFiniteBiproducts_inverse
@[simp]
theorem equivalenceSelfOfHasFiniteBiproducts_inverse {C : Type (u₁ + 1)} [LargeCategory C]
    [Preadditive C] [HasFiniteBiproducts C] :
    (equivalenceSelfOfHasFiniteBiproducts C).inverse = embedding C 
Arguments: {C : Type (u₁ + 1)} [CategoryTheory.LargeCategory C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasFiniteBiproducts C]
Goal: (CategoryTheory.Mat_.equivalenceSelfOfHasFiniteBiproducts C).inverse = CategoryTheory.Mat_.embedding C
-- CategoryTheory.Mat.hom_ext
@[ext]
theorem hom_ext {X Y : Mat R} (f g : X ⟶ Y) (h : ∀ i j, f i j = g i j) : f = g 
Arguments: {R : Type u} [Semiring R] {X Y : CategoryTheory.Mat R} (f g : X ⟶ Y) (h : ∀ (i : ↑X) (j : ↑Y), f i j = g i j)
Goal: f = g
-- CategoryTheory.Mat.id_def
theorem id_def (M : Mat R) : 𝟙 M = fun i j => if i = j then 1 else 0 
Arguments: (R : Type u) [Semiring R] (M : CategoryTheory.Mat R)
Goal: 𝟙 M = fun i j => if i = j then 1 else 0
-- CategoryTheory.Mat.id_apply
theorem id_apply (M : Mat R) (i j : M) : (𝟙 M : Matrix M M R) i j = if i = j then 1 else 0 
Arguments: (R : Type u) [Semiring R] (M : CategoryTheory.Mat R) (i j : ↑M)
Goal: 𝟙 M i j = if i = j then 1 else 0
-- CategoryTheory.Mat.id_apply_self
@[simp]
theorem id_apply_self (M : Mat R) (i : M) : (𝟙 M : Matrix M M R) i i = 1 
Arguments: (R : Type u) [Semiring R] (M : CategoryTheory.Mat R) (i : ↑M)
Goal: 𝟙 M i i = 1
-- CategoryTheory.Mat.id_apply_of_ne
@[simp]
theorem id_apply_of_ne (M : Mat R) (i j : M) (h : i ≠ j) : (𝟙 M : Matrix M M R) i j = 0 
Arguments: (R : Type u) [Semiring R] (M : CategoryTheory.Mat R) (i j : ↑M) (h : i ≠ j)
Goal: 𝟙 M i j = 0
-- CategoryTheory.Mat.comp_def
theorem comp_def {M N K : Mat R} (f : M ⟶ N) (g : N ⟶ K) :
    f ≫ g = fun i k => ∑ j : N, f i j * g j k 
Arguments: (R : Type u) [Semiring R] {M N K : CategoryTheory.Mat R} (f : M ⟶ N) (g : N ⟶ K)
Goal: f ≫ g = fun i k => ∑ j : ↑N, f i j * g j k
-- CategoryTheory.Mat.comp_apply
@[simp]
theorem comp_apply {M N K : Mat R} (f : M ⟶ N) (g : N ⟶ K) (i k) :
    (f ≫ g) i k = ∑ j : N, f i j * g j k 
Arguments: (R : Type u) [Semiring R] {M N K : CategoryTheory.Mat R} (f : M ⟶ N) (g : N ⟶ K) (i : ↑M) (k : ↑K)
Goal: (f ≫ g) i k = ∑ j : ↑N, f i j * g j k
-- CategoryTheory.Mat.equivalenceSingleObjInverse_map
@[simps]
def equivalenceSingleObjInverse : Mat_ (SingleObj Rᵐᵒᵖ) ⥤ Mat R 
Arguments: (R : Type) [Ring R]
Goal: ∀ {X Y : CategoryTheory.Mat_ (CategoryTheory.SingleObj Rᵐᵒᵖ)} (f : X ⟶ Y) (i : ↑((fun X => FintypeCat.of X.ι) X))
  (j : ↑((fun X => FintypeCat.of X.ι) Y)),
  (CategoryTheory.Mat.equivalenceSingleObjInverse R).map f i j = MulOpposite.unop (f i j)
-- CategoryTheory.Mat.equivalenceSingleObjInverse_obj
@[simps]
def equivalenceSingleObjInverse : Mat_ (SingleObj Rᵐᵒᵖ) ⥤ Mat R 
Arguments: (R : Type) [Ring R] (X : CategoryTheory.Mat_ (CategoryTheory.SingleObj Rᵐᵒᵖ))
Goal: (CategoryTheory.Mat.equivalenceSingleObjInverse R).obj X = FintypeCat.of X.ι
-- CategoryTheory.Mat.add_apply
@[simp]
theorem add_apply {M N : Mat R} (f g : M ⟶ N) (i j) : (f + g) i j = f i j + g i j 
Arguments: {R : Type} [Ring R] {M N : CategoryTheory.Mat R} (f g : M ⟶ N) (i : ↑M) (j : ↑N)
Goal: (f + g) i j = f i j + g i j
-- HomRel.IsCompatibleWithShift.condition
class IsCompatibleWithShift : Prop :=
    condition : ∀ (a : A) ⦃X Y : C⦄ (f g : X ⟶ Y), r f g → r (f⟦a⟧') (g⟦a⟧')
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {r : HomRel C} {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] [self : r.IsCompatibleWithShift A] (a : A) ⦃X Y : C⦄ (f g : X ⟶ Y)
Goal: r f g → r ((CategoryTheory.shiftFunctor C a).map f) ((CategoryTheory.shiftFunctor C a).map g)
-- CategoryTheory.Quotient.LiftCommShift.iso_hom_app
@[simp]
lemma iso_hom_app (a : A) (X : C) :
    (iso F r hF a).hom.app ((functor r).obj X) =
      (lift r F hF).map (((functor r).commShiftIso a).inv.app X) ≫
      (F.commShiftIso a).hom.app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : C ⥤ D) (r : HomRel C) {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [r.IsCompatibleWithShift A] [F.CommShift A] (hF : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) (a : A) (X : C)
Goal: (CategoryTheory.Quotient.LiftCommShift.iso F r hF a).hom.app ((CategoryTheory.Quotient.functor r).obj X) =
  (CategoryTheory.Quotient.lift r F hF).map (((CategoryTheory.Quotient.functor r).commShiftIso a).inv.app X) ≫
    (F.commShiftIso a).hom.app X
-- CategoryTheory.Quotient.LiftCommShift.iso_inv_app
@[simp]
lemma iso_inv_app (a : A) (X : C) :
    (iso F r hF a).inv.app ((functor r).obj X) =
      (F.commShiftIso a).inv.app X ≫
      (lift r F hF).map (((functor r).commShiftIso a).hom.app X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : C ⥤ D) (r : HomRel C) {A : Type w} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [r.IsCompatibleWithShift A] [F.CommShift A] (hF : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) (a : A) (X : C)
Goal: (CategoryTheory.Quotient.LiftCommShift.iso F r hF a).inv.app ((CategoryTheory.Quotient.functor r).obj X) =
  (F.commShiftIso a).inv.app X ≫
    (CategoryTheory.Quotient.lift r F hF).map (((CategoryTheory.Quotient.functor r).commShiftIso a).hom.app X)
-- CategoryTheory.MorphismProperty.LeftFraction₂.hs
structure LeftFraction₂ (X Y : C) where
    {Y' : C}
    f : X ⟶ Y'
    f' : X ⟶ Y'
    s : Y ⟶ Y'
    hs : W s
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C} (self : W.LeftFraction₂ X Y)
Goal: W self.s
-- CategoryTheory.MorphismProperty.LeftFraction₃.hs
structure LeftFraction₃ (X Y : C) where
    {Y' : C}
    f : X ⟶ Y'
    f' : X ⟶ Y'
    f'' : X ⟶ Y'
    s : Y ⟶ Y'
    hs : W s
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C} (self : W.LeftFraction₃ X Y)
Goal: W self.s
-- CategoryTheory.MorphismProperty.RightFraction₂.hs
structure RightFraction₂ (X Y : C) where
    {X' : C}
    s : X' ⟶ X
    hs : W s
    f : X' ⟶ Y
    f' : X' ⟶ Y
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C} (self : W.RightFraction₂ X Y)
Goal: W self.s
-- CategoryTheory.MorphismProperty.LeftFraction₂Rel.fst
lemma fst (h : LeftFraction₂Rel z₁ z₂) : LeftFractionRel z₁.fst z₂.fst 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C} {z₁ z₂ : W.LeftFraction₂ X Y} (h : CategoryTheory.MorphismProperty.LeftFraction₂Rel z₁ z₂)
Goal: CategoryTheory.MorphismProperty.LeftFractionRel z₁.fst z₂.fst
-- CategoryTheory.MorphismProperty.LeftFraction₂Rel.snd
lemma snd (h : LeftFraction₂Rel z₁ z₂) : LeftFractionRel z₁.snd z₂.snd 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C} {z₁ z₂ : W.LeftFraction₂ X Y} (h : CategoryTheory.MorphismProperty.LeftFraction₂Rel z₁ z₂)
Goal: CategoryTheory.MorphismProperty.LeftFractionRel z₁.snd z₂.snd
-- CategoryTheory.MorphismProperty.LeftFraction₂.map_eq_iff
lemma map_eq_iff {X Y : C} (φ ψ : W.LeftFraction₂ X Y) :
    (φ.fst.map L (Localization.inverts _ _) = ψ.fst.map L (Localization.inverts _ _) ∧
    φ.snd.map L (Localization.inverts _ _) = ψ.snd.map L (Localization.inverts _ _)) ↔
      LeftFraction₂Rel φ ψ 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : C} (φ ψ : W.LeftFraction₂ X Y)
Goal: φ.fst.map L ⋯ = ψ.fst.map L ⋯ ∧ φ.snd.map L ⋯ = ψ.snd.map L ⋯ ↔ CategoryTheory.MorphismProperty.LeftFraction₂Rel φ ψ