ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono'
theorem mono_of_epi_of_mono_of_mono' (hR₁ : R₁.map' 0 2 = 0)
    (hR₁' : (mk₂ (R₁.map' 1 2) (R₁.map' 2 3)).Exact)
    (hR₂ : (mk₂ (R₂.map' 0 1) (R₂.map' 1 2)).Exact)
    (h₀ : Epi (app' φ 0)) (h₁ : Mono (app' φ 1)) (h₃ : Mono (app' φ 3)) :
    Mono (app' φ 2) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 3} (φ : R₁ ⟶ R₂) (hR₁ : R₁.map' 0 2 ⋯ ⋯ = 0) (hR₁' : (CategoryTheory.ComposableArrows.mk₂ (R₁.map' 1 2 ⋯ ⋯) (R₁.map' 2 3 ⋯ ⋯)).Exact) (hR₂ : (CategoryTheory.ComposableArrows.mk₂ (R₂.map' 0 1 ⋯ ⋯) (R₂.map' 1 2 ⋯ ⋯)).Exact) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₁ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 1 ⋯)) (h₃ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 3 ⋯))
Goal: CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 2 ⋯)
-- CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono
theorem mono_of_epi_of_mono_of_mono (hR₁ : R₁.Exact) (hR₂ : R₂.Exact)
    (h₀ : Epi (app' φ 0)) (h₁ : Mono (app' φ 1)) (h₃ : Mono (app' φ 3)) :
    Mono (app' φ 2) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 3} (φ : R₁ ⟶ R₂) (hR₁ : R₁.Exact) (hR₂ : R₂.Exact) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₁ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 1 ⋯)) (h₃ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 3 ⋯))
Goal: CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 2 ⋯)
-- CategoryTheory.Abelian.epi_of_epi_of_epi_of_mono'
theorem epi_of_epi_of_epi_of_mono'
    (hR₁ : (mk₂ (R₁.map' 1 2) (R₁.map' 2 3)).Exact)
    (hR₂ : (mk₂ (R₂.map' 0 1) (R₂.map' 1 2)).Exact) (hR₂' : R₂.map' 1 3 = 0)
    (h₀ : Epi (app' φ 0)) (h₂ : Epi (app' φ 2)) (h₃ : Mono (app' φ 3)) :
    Epi (app' φ 1) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 3} (φ : R₁ ⟶ R₂) (hR₁ : (CategoryTheory.ComposableArrows.mk₂ (R₁.map' 1 2 ⋯ ⋯) (R₁.map' 2 3 ⋯ ⋯)).Exact) (hR₂ : (CategoryTheory.ComposableArrows.mk₂ (R₂.map' 0 1 ⋯ ⋯) (R₂.map' 1 2 ⋯ ⋯)).Exact) (hR₂' : R₂.map' 1 3 ⋯ ⋯ = 0) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₂ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 2 ⋯)) (h₃ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 3 ⋯))
Goal: CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 1 ⋯)
-- CategoryTheory.Abelian.epi_of_epi_of_epi_of_mono
theorem epi_of_epi_of_epi_of_mono (hR₁ : R₁.Exact) (hR₂ : R₂.Exact)
    (h₀ : Epi (app' φ 0)) (h₂ : Epi (app' φ 2)) (h₃ : Mono (app' φ 3)) :
    Epi (app' φ 1) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 3} (φ : R₁ ⟶ R₂) (hR₁ : R₁.Exact) (hR₂ : R₂.Exact) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₂ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 2 ⋯)) (h₃ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 3 ⋯))
Goal: CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 1 ⋯)
-- CategoryTheory.Abelian.isIso_of_epi_of_isIso_of_isIso_of_mono
theorem isIso_of_epi_of_isIso_of_isIso_of_mono (h₀ : Epi (app' φ 0)) (h₁ : IsIso (app' φ 1))
    (h₂ : IsIso (app' φ 3)) (h₃ : Mono (app' φ 4)) : IsIso (app' φ 2) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 4} (hR₁ : R₁.Exact) (hR₂ : R₂.Exact) (φ : R₁ ⟶ R₂) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₁ : CategoryTheory.IsIso (CategoryTheory.ComposableArrows.app' φ 1 ⋯)) (h₂ : CategoryTheory.IsIso (CategoryTheory.ComposableArrows.app' φ 3 ⋯)) (h₃ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 4 ⋯))
Goal: CategoryTheory.IsIso (CategoryTheory.ComposableArrows.app' φ 2 ⋯)
-- CategoryTheory.Abelian.mono_of_epi_of_epi_mono'
theorem mono_of_epi_of_epi_mono' (hR₁ : R₁.map' 0 2 = 0) (hR₁' : Epi (R₁.map' 1 2))
    (hR₂ : R₂.Exact) (h₀ : Epi (app' φ 0)) (h₁ : Mono (app' φ 1)) :
    Mono (app' φ 2) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 2} (φ : R₁ ⟶ R₂) (hR₁ : R₁.map' 0 2 ⋯ ⋯ = 0) (hR₁' : CategoryTheory.Epi (R₁.map' 1 2 ⋯ ⋯)) (hR₂ : R₂.Exact) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₁ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 1 ⋯))
Goal: CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 2 ⋯)
-- CategoryTheory.Abelian.mono_of_epi_of_epi_of_mono
theorem mono_of_epi_of_epi_of_mono (hR₁ : R₁.Exact) (hR₂ : R₂.Exact)
    (hR₁' : Epi (R₁.map' 1 2)) (h₀ : Epi (app' φ 0)) (h₁ : Mono (app' φ 1)) :
    Mono (app' φ 2) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 2} (φ : R₁ ⟶ R₂) (hR₁ : R₁.Exact) (hR₂ : R₂.Exact) (hR₁' : CategoryTheory.Epi (R₁.map' 1 2 ⋯ ⋯)) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₁ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 1 ⋯))
Goal: CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 2 ⋯)
-- CategoryTheory.Abelian.epi_of_mono_of_epi_of_mono'
theorem epi_of_mono_of_epi_of_mono' (hR₁ : R₁.Exact) (hR₂ : R₂.map' 0 2 = 0)
    (hR₂' : Mono (R₂.map' 0 1)) (h₀ : Epi (app' φ 1)) (h₁ : Mono (app' φ 2)) :
    Epi (app' φ 0) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 2} (φ : R₁ ⟶ R₂) (hR₁ : R₁.Exact) (hR₂ : R₂.map' 0 2 ⋯ ⋯ = 0) (hR₂' : CategoryTheory.Mono (R₂.map' 0 1 ⋯ ⋯)) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 1 ⋯)) (h₁ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 2 ⋯))
Goal: CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)
-- CategoryTheory.Abelian.epi_of_mono_of_epi_of_mono
theorem epi_of_mono_of_epi_of_mono (hR₁ : R₁.Exact) (hR₂ : R₂.Exact)
    (hR₂' : Mono (R₂.map' 0 1)) (h₀ : Epi (app' φ 1)) (h₁ : Mono (app' φ 2)) :
    Epi (app' φ 0) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 2} (φ : R₁ ⟶ R₂) (hR₁ : R₁.Exact) (hR₂ : R₂.Exact) (hR₂' : CategoryTheory.Mono (R₂.map' 0 1 ⋯ ⋯)) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 1 ⋯)) (h₁ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 2 ⋯))
Goal: CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)
-- CategoryTheory.Abelian.mono_of_mono_of_mono_of_mono
theorem mono_of_mono_of_mono_of_mono (hR₁ : R₁.Exact)
    (hR₂' : Mono (R₂.map' 0 1))
    (h₀ : Mono (app' φ 0))
    (h₁ : Mono (app' φ 2)) :
    Mono (app' φ 1) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 2} (φ : R₁ ⟶ R₂) (hR₁ : R₁.Exact) (hR₂' : CategoryTheory.Mono (R₂.map' 0 1 ⋯ ⋯)) (h₀ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₁ : CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 2 ⋯))
Goal: CategoryTheory.Mono (CategoryTheory.ComposableArrows.app' φ 1 ⋯)
-- CategoryTheory.Abelian.epi_of_epi_of_epi_of_epi
theorem epi_of_epi_of_epi_of_epi (hR₂ : R₂.Exact) (hR₁' : Epi (R₁.map' 1 2))
    (h₀ : Epi (app' φ 0)) (h₁ : Epi (app' φ 2)) :
    Epi (app' φ 1) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {R₁ R₂ : CategoryTheory.ComposableArrows C 2} (φ : R₁ ⟶ R₂) (hR₂ : R₂.Exact) (hR₁' : CategoryTheory.Epi (R₁.map' 1 2 ⋯ ⋯)) (h₀ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 0 ⋯)) (h₁ : CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 2 ⋯))
Goal: CategoryTheory.Epi (CategoryTheory.ComposableArrows.app' φ 1 ⋯)
-- CategoryTheory.Idempotents.app_idem
@[reassoc (attr := simp)]
theorem app_idem : P.p.app X ≫ P.p.app X = P.p.app X 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_4, u_1} J] [CategoryTheory.Category.{u_3, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (J ⥤ C)) (X : J)
Goal: P.p.app X ≫ P.p.app X = P.p.app X
-- CategoryTheory.Idempotents.app_p_comp
@[reassoc (attr := simp)]
theorem app_p_comp : P.p.app X ≫ f.f.app X = f.f.app X 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_4, u_1} J] [CategoryTheory.Category.{u_3, u_2} C] {P Q : CategoryTheory.Idempotents.Karoubi (J ⥤ C)} (f : P ⟶ Q) (X : J)
Goal: P.p.app X ≫ f.f.app X = f.f.app X
-- CategoryTheory.Idempotents.app_comp_p
@[reassoc (attr := simp)]
theorem app_comp_p : f.f.app X ≫ Q.p.app X = f.f.app X 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_4, u_1} J] [CategoryTheory.Category.{u_3, u_2} C] {P Q : CategoryTheory.Idempotents.Karoubi (J ⥤ C)} (f : P ⟶ Q) (X : J)
Goal: f.f.app X ≫ Q.p.app X = f.f.app X
-- CategoryTheory.Idempotents.app_p_comm
@[reassoc]
theorem app_p_comm : P.p.app X ≫ f.f.app X = f.f.app X ≫ Q.p.app X 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_4, u_1} J] [CategoryTheory.Category.{u_3, u_2} C] {P Q : CategoryTheory.Idempotents.Karoubi (J ⥤ C)} (f : P ⟶ Q) (X : J)
Goal: P.p.app X ≫ f.f.app X = f.f.app X ≫ Q.p.app X
-- CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj_obj_X
@[simps]
def obj (P : Karoubi (J ⥤ C)) : J ⥤ Karoubi C 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_3, u_1} J] [CategoryTheory.Category.{u_4, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (J ⥤ C)) (j : J)
Goal: ((CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj P).obj j).X = P.X.obj j
-- CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj_map_f
@[simps]
def obj (P : Karoubi (J ⥤ C)) : J ⥤ Karoubi C 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_3, u_1} J] [CategoryTheory.Category.{u_4, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (J ⥤ C)) {j j' : J} (φ : j ⟶ j')
Goal: ((CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj P).map φ).f = P.p.app j ≫ P.X.map φ
-- CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj_obj_p
@[simps]
def obj (P : Karoubi (J ⥤ C)) : J ⥤ Karoubi C 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_3, u_1} J] [CategoryTheory.Category.{u_4, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (J ⥤ C)) (j : J)
Goal: ((CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj P).obj j).p = P.p.app j
-- CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.map_app_f
@[simps]
def map {P Q : Karoubi (J ⥤ C)} (f : P ⟶ Q) : obj P ⟶ obj Q 
Arguments: {J : Type u_1} {C : Type u_2} [CategoryTheory.Category.{u_3, u_1} J] [CategoryTheory.Category.{u_4, u_2} C] {P Q : CategoryTheory.Idempotents.Karoubi (J ⥤ C)} (f : P ⟶ Q) (j : J)
Goal: ((CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.map f).app j).f = f.f.app j
-- CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding_obj
@[simps]
def karoubiFunctorCategoryEmbedding : Karoubi (J ⥤ C) ⥤ J ⥤ Karoubi C 
Arguments: (J : Type u_1) (C : Type u_2) [CategoryTheory.Category.{u_3, u_1} J] [CategoryTheory.Category.{u_4, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (J ⥤ C))
Goal: (CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding J C).obj P =
  CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj P
-- CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding_map
@[simps]
def karoubiFunctorCategoryEmbedding : Karoubi (J ⥤ C) ⥤ J ⥤ Karoubi C 
Arguments: (J : Type u_1) (C : Type u_2) [CategoryTheory.Category.{u_3, u_1} J] [CategoryTheory.Category.{u_4, u_2} C]
Goal: ∀ {X Y : CategoryTheory.Idempotents.Karoubi (J ⥤ C)} (f : X ⟶ Y),
  (CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding J C).map f =
    CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.map f
-- CategoryTheory.Idempotents.toKaroubi_comp_karoubiFunctorCategoryEmbedding
theorem toKaroubi_comp_karoubiFunctorCategoryEmbedding :
    toKaroubi _ ⋙ karoubiFunctorCategoryEmbedding J C =
      (whiskeringRight J _ _).obj (toKaroubi C) 
Arguments: (J : Type u_1) (C : Type u_2) [CategoryTheory.Category.{u_3, u_1} J] [CategoryTheory.Category.{u_4, u_2} C]
Goal: CategoryTheory.Idempotents.toKaroubi (J ⥤ C) ⋙ CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding J C =
  (CategoryTheory.whiskeringRight J C (CategoryTheory.Idempotents.Karoubi C)).obj
    (CategoryTheory.Idempotents.toKaroubi C)
-- CategoryTheory.GradedObject.categoryOfGradedObjects_comp
@[simps!]
instance categoryOfGradedObjects (β : Type w) : Category.{max w v} (GradedObject β C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (β : Type w)
Goal: ∀ {X Y Z : (i : β) → (fun x => C) i} (f : X ⟶ Y) (g : Y ⟶ Z) (i : β),
  CategoryTheory.CategoryStruct.comp f g i = CategoryTheory.CategoryStruct.comp (f i) (g i)
-- CategoryTheory.GradedObject.categoryOfGradedObjects_id
@[simps!]
instance categoryOfGradedObjects (β : Type w) : Category.{max w v} (GradedObject β C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (β : Type w) (X : (i : β) → (fun x => C) i) (i : β)
Goal: CategoryTheory.CategoryStruct.id X i = CategoryTheory.CategoryStruct.id (X i)
-- CategoryTheory.GradedObject.hom_ext
@[ext]
lemma hom_ext {β : Type*} {X Y : GradedObject β C} (f g : X ⟶ Y) (h : ∀ x, f x = g x) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} {X Y : CategoryTheory.GradedObject β C} (f g : X ⟶ Y) (h : ∀ (x : β), f x = g x)
Goal: f = g
-- CategoryTheory.GradedObject.eval_obj
@[simps]
def eval {β : Type w} (b : β) : GradedObject β C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type w} (b : β) (X : CategoryTheory.GradedObject β C)
Goal: (CategoryTheory.GradedObject.eval b).obj X = X b
-- CategoryTheory.GradedObject.eval_map
@[simps]
def eval {β : Type w} (b : β) : GradedObject β C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type w} (b : β)
Goal: ∀ {X Y : CategoryTheory.GradedObject β C} (f : X ⟶ Y), (CategoryTheory.GradedObject.eval b).map f = f b
-- CategoryTheory.GradedObject.isoMk_inv
@[simps]
def isoMk (e : ∀ i, X i ≅ Y i) : X ≅ Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} (X Y : CategoryTheory.GradedObject β C) (e : (i : β) → X i ≅ Y i) (i : β)
Goal: (X.isoMk Y e).inv i = (e i).inv
-- CategoryTheory.GradedObject.isoMk_hom
@[simps]
def isoMk (e : ∀ i, X i ≅ Y i) : X ≅ Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} (X Y : CategoryTheory.GradedObject β C) (e : (i : β) → X i ≅ Y i) (i : β)
Goal: (X.isoMk Y e).hom i = (e i).hom
-- CategoryTheory.GradedObject.isIso_of_isIso_apply
lemma isIso_of_isIso_apply (f : X ⟶ Y) [hf : ∀ i, IsIso (f i)] :
    IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} {X Y : CategoryTheory.GradedObject β C} (f : X ⟶ Y) [hf : ∀ (i : β), CategoryTheory.IsIso (f i)]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Iso.hom_inv_id_eval
@[reassoc (attr := simp)]
lemma hom_inv_id_eval (e : X ≅ Y) (j : J) :
    e.hom j ≫ e.inv j = 𝟙 _ 
Arguments: {C : Type u_1} {J : Type u_4} [CategoryTheory.Category.{u_5, u_1} C] {X Y : CategoryTheory.GradedObject J C} (e : X ≅ Y) (j : J)
Goal: CategoryTheory.CategoryStruct.comp (e.hom j) (e.inv j) = CategoryTheory.CategoryStruct.id (X j)
-- CategoryTheory.Iso.inv_hom_id_eval
@[reassoc (attr := simp)]
lemma inv_hom_id_eval (e : X ≅ Y) (j : J) :
    e.inv j ≫ e.hom j = 𝟙 _ 
Arguments: {C : Type u_1} {J : Type u_4} [CategoryTheory.Category.{u_5, u_1} C] {X Y : CategoryTheory.GradedObject J C} (e : X ≅ Y) (j : J)
Goal: CategoryTheory.CategoryStruct.comp (e.inv j) (e.hom j) = CategoryTheory.CategoryStruct.id (Y j)
-- CategoryTheory.Iso.map_hom_inv_id_eval
@[reassoc (attr := simp)]
lemma map_hom_inv_id_eval (e : X ≅ Y) (F : C ⥤ D) (j : J) :
    F.map (e.hom j) ≫ F.map (e.inv j) = 𝟙 _ 
Arguments: {C : Type u_1} {D : Type u_2} {J : Type u_4} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {X Y : CategoryTheory.GradedObject J C} (e : X ≅ Y) (F : CategoryTheory.Functor C D) (j : J)
Goal: CategoryTheory.CategoryStruct.comp (F.map (e.hom j)) (F.map (e.inv j)) = CategoryTheory.CategoryStruct.id (F.obj (X j))
-- CategoryTheory.Iso.map_inv_hom_id_eval
@[reassoc (attr := simp)]
lemma map_inv_hom_id_eval (e : X ≅ Y) (F : C ⥤ D) (j : J) :
    F.map (e.inv j) ≫ F.map (e.hom j) = 𝟙 _ 
Arguments: {C : Type u_1} {D : Type u_2} {J : Type u_4} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {X Y : CategoryTheory.GradedObject J C} (e : X ≅ Y) (F : CategoryTheory.Functor C D) (j : J)
Goal: CategoryTheory.CategoryStruct.comp (F.map (e.inv j)) (F.map (e.hom j)) = CategoryTheory.CategoryStruct.id (F.obj (Y j))
-- CategoryTheory.Iso.map_hom_inv_id_eval_app
@[reassoc (attr := simp)]
lemma map_hom_inv_id_eval_app (e : X ≅ Y) (F : C ⥤ D ⥤ E) (j : J) (Y : D) :
    (F.map (e.hom j)).app Y ≫ (F.map (e.inv j)).app Y = 𝟙 _ 
Arguments: {C : Type u_1} {D : Type u_2} {E : Type u_3} {J : Type u_4} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] [CategoryTheory.Category.{u_6, u_3} E] {X Y : CategoryTheory.GradedObject J C} (e : X ≅ Y) (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (j : J)
Goal: ∀ (Y_1 : D),
  CategoryTheory.CategoryStruct.comp ((F.map (e.hom j)).app Y_1) ((F.map (e.inv j)).app Y_1) =
    CategoryTheory.CategoryStruct.id ((F.obj (X j)).obj Y_1)
-- CategoryTheory.Iso.map_inv_hom_id_eval_app
@[reassoc (attr := simp)]
lemma map_inv_hom_id_eval_app (e : X ≅ Y) (F : C ⥤ D ⥤ E) (j : J) (Y : D) :
    (F.map (e.inv j)).app Y ≫ (F.map (e.hom j)).app Y = 𝟙 _ 
Arguments: {C : Type u_1} {D : Type u_2} {E : Type u_3} {J : Type u_4} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] [CategoryTheory.Category.{u_6, u_3} E] {X Y : CategoryTheory.GradedObject J C} (e : X ≅ Y) (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (j : J)
Goal: ∀ (Y_1 : D),
  CategoryTheory.CategoryStruct.comp ((F.map (e.inv j)).app Y_1) ((F.map (e.hom j)).app Y_1) =
    CategoryTheory.CategoryStruct.id ((F.obj (Y j)).obj Y_1)
-- CategoryTheory.GradedObject.eqToHom_proj
@[simp]
theorem eqToHom_proj {I : Type*} {x x' : GradedObject I C} (h : x = x') (i : I) :
    (eqToHom h : x ⟶ x') i = eqToHom (Function.funext_iff.mp h i) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {I : Type u_1} {x x' : CategoryTheory.GradedObject I C} (h : x = x') (i : I)
Goal: CategoryTheory.eqToHom h i = CategoryTheory.eqToHom ⋯
-- CategoryTheory.GradedObject.comapEq_hom_app
@[simps]
def comapEq {β γ : Type w} {f g : β → γ} (h : f = g) : comap C f ≅ comap C g 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β γ : Type w} {f g : β → γ} (h : f = g) (X : CategoryTheory.GradedObject γ C) (b : β)
Goal: (CategoryTheory.GradedObject.comapEq C h).hom.app X b = CategoryTheory.eqToHom ⋯
-- CategoryTheory.GradedObject.comapEq_inv_app
@[simps]
def comapEq {β γ : Type w} {f g : β → γ} (h : f = g) : comap C f ≅ comap C g 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β γ : Type w} {f g : β → γ} (h : f = g) (X : CategoryTheory.GradedObject γ C) (b : β)
Goal: (CategoryTheory.GradedObject.comapEq C h).inv.app X b = CategoryTheory.eqToHom ⋯
-- CategoryTheory.GradedObject.comapEq_symm
theorem comapEq_symm {β γ : Type w} {f g : β → γ} (h : f = g) :
    comapEq C h.symm = (comapEq C h).symm 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β γ : Type w} {f g : β → γ} (h : f = g)
Goal: CategoryTheory.GradedObject.comapEq C ⋯ = (CategoryTheory.GradedObject.comapEq C h).symm
-- CategoryTheory.GradedObject.comapEq_trans
theorem comapEq_trans {β γ : Type w} {f g h : β → γ} (k : f = g) (l : g = h) :
    comapEq C (k.trans l) = comapEq C k ≪≫ comapEq C l 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β γ : Type w} {f g h : β → γ} (k : f = g) (l : g = h)
Goal: CategoryTheory.GradedObject.comapEq C ⋯ =
  CategoryTheory.GradedObject.comapEq C k ≪≫ CategoryTheory.GradedObject.comapEq C l
-- CategoryTheory.GradedObject.eqToHom_apply
theorem eqToHom_apply {β : Type w} {X Y : β → C} (h : X = Y) (b : β) :
    (eqToHom h : X ⟶ Y) b = eqToHom (by rw [h]) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β : Type w} {X Y : β → C} (h : X = Y) (b : β)
Goal: CategoryTheory.eqToHom h b = CategoryTheory.eqToHom ⋯
-- CategoryTheory.GradedObject.comapEquiv_inverse
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β γ : Type w} (e : β ≃ γ)
Goal: (CategoryTheory.GradedObject.comapEquiv C e).inverse = CategoryTheory.GradedObject.comap C ⇑e
-- CategoryTheory.GradedObject.comapEquiv_functor
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β γ : Type w} (e : β ≃ γ)
Goal: (CategoryTheory.GradedObject.comapEquiv C e).functor = CategoryTheory.GradedObject.comap C ⇑e.symm
-- CategoryTheory.GradedObject.comapEquiv_unitIso
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β γ : Type w} (e : β ≃ γ)
Goal: (CategoryTheory.GradedObject.comapEquiv C e).unitIso =
  CategoryTheory.GradedObject.comapEq C ⋯ ≪≫ (CategoryTheory.Pi.comapComp (fun x => C) ⇑e ⇑e.symm).symm
-- CategoryTheory.GradedObject.comapEquiv_counitIso
@[simps]
def comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {β γ : Type w} (e : β ≃ γ)
Goal: (CategoryTheory.GradedObject.comapEquiv C e).counitIso =
  CategoryTheory.Pi.comapComp (fun x => C) ⇑e.symm ⇑e ≪≫ CategoryTheory.GradedObject.comapEq C ⋯
-- CategoryTheory.GradedObject.shiftFunctor_obj_apply
@[simp]
theorem shiftFunctor_obj_apply {β : Type*} [AddCommGroup β] (s : β) (X : β → C) (t : β) (n : ℤ) :
    (shiftFunctor (GradedObjectWithShift s C) n).obj X t = X (t + n • s) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} [AddCommGroup β] (s : β) (X : β → C) (t : β) (n : ℤ)
Goal: (CategoryTheory.shiftFunctor (CategoryTheory.GradedObjectWithShift s C) n).obj X t = X (t + n • s)
-- CategoryTheory.GradedObject.shiftFunctor_map_apply
@[simp]
theorem shiftFunctor_map_apply {β : Type*} [AddCommGroup β] (s : β)
    {X Y : GradedObjectWithShift s C} (f : X ⟶ Y) (t : β) (n : ℤ) :
    (shiftFunctor (GradedObjectWithShift s C) n).map f t = f (t + n • s) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type u_1} [AddCommGroup β] (s : β) {X Y : CategoryTheory.GradedObjectWithShift s C} (f : X ⟶ Y) (t : β) (n : ℤ)
Goal: (CategoryTheory.shiftFunctor (CategoryTheory.GradedObjectWithShift s C) n).map f t = f (t + n • s)
-- CategoryTheory.GradedObject.zero_apply
@[simp, nolint simpNF]
theorem zero_apply [HasZeroMorphisms C] (β : Type w) (X Y : GradedObject β C) (b : β) :
    (0 : X ⟶ Y) b = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] (β : Type w) (X Y : CategoryTheory.GradedObject β C) (b : β)
Goal: 0 b = 0
-- CategoryTheory.GradedObject.hasMap_of_iso
lemma hasMap_of_iso (e : X ≅ Y) (p: I → J) [HasMap X p] : HasMap Y p 
Arguments: {I : Type u_1} {J : Type u_2} {C : Type u_4} [CategoryTheory.Category.{u_5, u_4} C] {X Y : CategoryTheory.GradedObject I C} (e : X ≅ Y) (p : I → J) [X.HasMap p]
Goal: Y.HasMap p
-- CategoryTheory.GradedObject.mapObj_ext
@[ext]
lemma mapObj_ext {A : C} {j : J} (f g : X.mapObj p j ⟶ A)
    (hfg : ∀ (i : I) (hij : p i = j), X.ιMapObj p i j hij ≫ f = X.ιMapObj p i j hij ≫ g) :
    f = g 
Arguments: {I : Type u_1} {J : Type u_2} {C : Type u_4} [CategoryTheory.Category.{u_5, u_4} C] (X : CategoryTheory.GradedObject I C) (p : I → J) [X.HasMap p] {A : C} {j : J} (f g : X.mapObj p j ⟶ A) (hfg :
  ∀ (i : I) (hij : p i = j),
    CategoryTheory.CategoryStruct.comp (X.ιMapObj p i j hij) f =
      CategoryTheory.CategoryStruct.comp (X.ιMapObj p i j hij) g)
Goal: f = g