ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.hasLimit_of_created
theorem hasLimit_of_created (K : J ⥤ C) (F : C ⥤ D) [HasLimit (K ⋙ F)] [CreatesLimit K F] :
    HasLimit K 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type w} [CategoryTheory.Category.{w', w} J] (K : J ⥤ C) (F : C ⥤ D) [CategoryTheory.Limits.HasLimit (K ⋙ F)] [CategoryTheory.CreatesLimit K F]
Goal: CategoryTheory.Limits.HasLimit K
-- CategoryTheory.hasLimitsOfShape_of_hasLimitsOfShape_createsLimitsOfShape
theorem hasLimitsOfShape_of_hasLimitsOfShape_createsLimitsOfShape (F : C ⥤ D) [HasLimitsOfShape J D]
    [CreatesLimitsOfShape J F] : HasLimitsOfShape J C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type w} [CategoryTheory.Category.{w', w} J] (F : C ⥤ D) [CategoryTheory.Limits.HasLimitsOfShape J D] [CategoryTheory.CreatesLimitsOfShape J F]
Goal: CategoryTheory.Limits.HasLimitsOfShape J C
-- CategoryTheory.hasLimits_of_hasLimits_createsLimits
theorem hasLimits_of_hasLimits_createsLimits (F : C ⥤ D) [HasLimitsOfSize.{w, w'} D]
    [CreatesLimitsOfSize.{w, w'} F] : HasLimitsOfSize.{w, w'} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) [CategoryTheory.Limits.HasLimitsOfSize.{w, w', v₂, u₂} D] [CategoryTheory.CreatesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{w, w', v₁, u₁} C
-- CategoryTheory.hasColimit_of_created
theorem hasColimit_of_created (K : J ⥤ C) (F : C ⥤ D) [HasColimit (K ⋙ F)] [CreatesColimit K F] :
    HasColimit K 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type w} [CategoryTheory.Category.{w', w} J] (K : J ⥤ C) (F : C ⥤ D) [CategoryTheory.Limits.HasColimit (K ⋙ F)] [CategoryTheory.CreatesColimit K F]
Goal: CategoryTheory.Limits.HasColimit K
-- CategoryTheory.hasColimitsOfShape_of_hasColimitsOfShape_createsColimitsOfShape
theorem hasColimitsOfShape_of_hasColimitsOfShape_createsColimitsOfShape (F : C ⥤ D)
    [HasColimitsOfShape J D] [CreatesColimitsOfShape J F] : HasColimitsOfShape J C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type w} [CategoryTheory.Category.{w', w} J] (F : C ⥤ D) [CategoryTheory.Limits.HasColimitsOfShape J D] [CategoryTheory.CreatesColimitsOfShape J F]
Goal: CategoryTheory.Limits.HasColimitsOfShape J C
-- CategoryTheory.hasColimits_of_hasColimits_createsColimits
theorem hasColimits_of_hasColimits_createsColimits (F : C ⥤ D) [HasColimitsOfSize.{w, w'} D]
    [CreatesColimitsOfSize.{w, w'} F] : HasColimitsOfSize.{w, w'} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) [CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₂, u₂} D] [CategoryTheory.CreatesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F]
Goal: CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₁, u₁} C
-- CategoryTheory.IsSplitEqualizer.bottom_rightRetraction
structure IsSplitEqualizer {W : C} (ι : W ⟶ X) where
    leftRetraction : X ⟶ W
    rightRetraction : Y ⟶ X
    condition : ι ≫ f = ι ≫ g := by aesop_cat
    ι_leftRetraction : ι ≫ leftRetraction = 𝟙 W := by aesop_cat
    bottom_rightRetraction : g ≫ rightRetraction = 𝟙 X := by aesop_cat
    top_rightRetraction : f ≫ rightRetraction = leftRetraction ≫ ι := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι)
Goal: CategoryTheory.CategoryStruct.comp g self.rightRetraction = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.IsSplitEqualizer.condition
structure IsSplitEqualizer {W : C} (ι : W ⟶ X) where
    leftRetraction : X ⟶ W
    rightRetraction : Y ⟶ X
    condition : ι ≫ f = ι ≫ g := by aesop_cat
    ι_leftRetraction : ι ≫ leftRetraction = 𝟙 W := by aesop_cat
    bottom_rightRetraction : g ≫ rightRetraction = 𝟙 X := by aesop_cat
    top_rightRetraction : f ≫ rightRetraction = leftRetraction ≫ ι := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι)
Goal: CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g
-- CategoryTheory.IsSplitEqualizer.ι_leftRetraction
structure IsSplitEqualizer {W : C} (ι : W ⟶ X) where
    leftRetraction : X ⟶ W
    rightRetraction : Y ⟶ X
    condition : ι ≫ f = ι ≫ g := by aesop_cat
    ι_leftRetraction : ι ≫ leftRetraction = 𝟙 W := by aesop_cat
    bottom_rightRetraction : g ≫ rightRetraction = 𝟙 X := by aesop_cat
    top_rightRetraction : f ≫ rightRetraction = leftRetraction ≫ ι := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι)
Goal: CategoryTheory.CategoryStruct.comp ι self.leftRetraction = CategoryTheory.CategoryStruct.id W
-- CategoryTheory.IsSplitEqualizer.top_rightRetraction
structure IsSplitEqualizer {W : C} (ι : W ⟶ X) where
    leftRetraction : X ⟶ W
    rightRetraction : Y ⟶ X
    condition : ι ≫ f = ι ≫ g := by aesop_cat
    ι_leftRetraction : ι ≫ leftRetraction = 𝟙 W := by aesop_cat
    bottom_rightRetraction : g ≫ rightRetraction = 𝟙 X := by aesop_cat
    top_rightRetraction : f ≫ rightRetraction = leftRetraction ≫ ι := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι)
Goal: CategoryTheory.CategoryStruct.comp f self.rightRetraction = CategoryTheory.CategoryStruct.comp self.leftRetraction ι
-- CategoryTheory.IsSplitEqualizer.map_leftRetraction
@[simps]
def IsSplitEqualizer.map {W : C} {ι : W ⟶ X} (q : IsSplitEqualizer f g ι) (F : C ⥤ D) :
    IsSplitEqualizer (F.map f) (F.map g) (F.map ι) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X Y : C} {f g : X ⟶ Y} {W : C} {ι : W ⟶ X} (q : CategoryTheory.IsSplitEqualizer f g ι) (F : CategoryTheory.Functor C D)
Goal: (q.map F).leftRetraction = F.map q.leftRetraction
-- CategoryTheory.IsSplitEqualizer.map_rightRetraction
@[simps]
def IsSplitEqualizer.map {W : C} {ι : W ⟶ X} (q : IsSplitEqualizer f g ι) (F : C ⥤ D) :
    IsSplitEqualizer (F.map f) (F.map g) (F.map ι) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X Y : C} {f g : X ⟶ Y} {W : C} {ι : W ⟶ X} (q : CategoryTheory.IsSplitEqualizer f g ι) (F : CategoryTheory.Functor C D)
Goal: (q.map F).rightRetraction = F.map q.rightRetraction
-- CategoryTheory.IsSplitEqualizer.asFork_pt
@[simps! pt]
def IsSplitEqualizer.asFork {W : C} {h : W ⟶ X} (t : IsSplitEqualizer f g h) :
    Fork f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {W : C} {h : W ⟶ X} (t : CategoryTheory.IsSplitEqualizer f g h)
Goal: t.asFork.pt = W
-- CategoryTheory.IsSplitEqualizer.asFork_ι
@[simp]
theorem IsSplitEqualizer.asFork_ι {W : C} {h : W ⟶ X} (t : IsSplitEqualizer f g h) :
    t.asFork.ι = h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {W : C} {h : W ⟶ X} (t : CategoryTheory.IsSplitEqualizer f g h)
Goal: t.asFork.ι = h
-- CategoryTheory.HasSplitEqualizer.splittable
class HasSplitEqualizer : Prop where
    splittable : ∃ (W : C) (h : W ⟶ X), Nonempty (IsSplitEqualizer f g h)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [self : CategoryTheory.HasSplitEqualizer f g]
Goal: ∃ W h, Nonempty (CategoryTheory.IsSplitEqualizer f g h)
-- CategoryTheory.GlueData.cocycle
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure GlueData where
  J : Type v
  U : J → C
  V : J × J → C
  f : ∀ i j, V (i, j) ⟶ U i
  f_mono : ∀ i j, Mono (f i j) := by infer_instance
  f_hasPullback : ∀ i j k, HasPullback (f i j) (f i k) := by infer_instance
  f_id : ∀ i, IsIso (f i i) := by infer_instance
  t : ∀ i j, V (i, j) ⟶ V (j, i)
  t_id : ∀ i, t i i = 𝟙 _
  t' : ∀ i j k, pullback (f i j) (f i k) ⟶ pullback (f j k) (f j i)
  t_fac : ∀ i j k, t' i j k ≫ pullback.snd _ _ = pullback.fst _ _ ≫ t i j
  cocycle : ∀ i j k, t' i j k ≫ t' j k i ≫ t' k i j = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData C) (i j k : self.J)
Goal: CategoryTheory.CategoryStruct.comp (self.t' i j k)
    (CategoryTheory.CategoryStruct.comp (self.t' j k i) (self.t' k i j)) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.pullback (self.f i j) (self.f i k))
-- CategoryTheory.GlueData.f_mono
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure GlueData where
  J : Type v
  U : J → C
  V : J × J → C
  f : ∀ i j, V (i, j) ⟶ U i
  f_mono : ∀ i j, Mono (f i j) := by infer_instance
  f_hasPullback : ∀ i j k, HasPullback (f i j) (f i k) := by infer_instance
  f_id : ∀ i, IsIso (f i i) := by infer_instance
  t : ∀ i j, V (i, j) ⟶ V (j, i)
  t_id : ∀ i, t i i = 𝟙 _
  t' : ∀ i j k, pullback (f i j) (f i k) ⟶ pullback (f j k) (f j i)
  t_fac : ∀ i j k, t' i j k ≫ pullback.snd _ _ = pullback.fst _ _ ≫ t i j
  cocycle : ∀ i j k, t' i j k ≫ t' j k i ≫ t' k i j = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData C) (i j : self.J)
Goal: CategoryTheory.Mono (self.f i j)
-- CategoryTheory.GlueData.t_fac
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure GlueData where
  J : Type v
  U : J → C
  V : J × J → C
  f : ∀ i j, V (i, j) ⟶ U i
  f_mono : ∀ i j, Mono (f i j) := by infer_instance
  f_hasPullback : ∀ i j k, HasPullback (f i j) (f i k) := by infer_instance
  f_id : ∀ i, IsIso (f i i) := by infer_instance
  t : ∀ i j, V (i, j) ⟶ V (j, i)
  t_id : ∀ i, t i i = 𝟙 _
  t' : ∀ i j k, pullback (f i j) (f i k) ⟶ pullback (f j k) (f j i)
  t_fac : ∀ i j k, t' i j k ≫ pullback.snd _ _ = pullback.fst _ _ ≫ t i j
  cocycle : ∀ i j k, t' i j k ≫ t' j k i ≫ t' k i j = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData C) (i j k : self.J)
Goal: CategoryTheory.CategoryStruct.comp (self.t' i j k) (CategoryTheory.Limits.pullback.snd (self.f j k) (self.f j i)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (self.f i j) (self.f i k)) (self.t i j)
-- CategoryTheory.GlueData.f_hasPullback
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure GlueData where
  J : Type v
  U : J → C
  V : J × J → C
  f : ∀ i j, V (i, j) ⟶ U i
  f_mono : ∀ i j, Mono (f i j) := by infer_instance
  f_hasPullback : ∀ i j k, HasPullback (f i j) (f i k) := by infer_instance
  f_id : ∀ i, IsIso (f i i) := by infer_instance
  t : ∀ i j, V (i, j) ⟶ V (j, i)
  t_id : ∀ i, t i i = 𝟙 _
  t' : ∀ i j k, pullback (f i j) (f i k) ⟶ pullback (f j k) (f j i)
  t_fac : ∀ i j k, t' i j k ≫ pullback.snd _ _ = pullback.fst _ _ ≫ t i j
  cocycle : ∀ i j k, t' i j k ≫ t' j k i ≫ t' k i j = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData C) (i j k : self.J)
Goal: CategoryTheory.Limits.HasPullback (self.f i j) (self.f i k)
-- CategoryTheory.GlueData.f_id
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure GlueData where
  J : Type v
  U : J → C
  V : J × J → C
  f : ∀ i j, V (i, j) ⟶ U i
  f_mono : ∀ i j, Mono (f i j) := by infer_instance
  f_hasPullback : ∀ i j k, HasPullback (f i j) (f i k) := by infer_instance
  f_id : ∀ i, IsIso (f i i) := by infer_instance
  t : ∀ i j, V (i, j) ⟶ V (j, i)
  t_id : ∀ i, t i i = 𝟙 _
  t' : ∀ i j k, pullback (f i j) (f i k) ⟶ pullback (f j k) (f j i)
  t_fac : ∀ i j k, t' i j k ≫ pullback.snd _ _ = pullback.fst _ _ ≫ t i j
  cocycle : ∀ i j k, t' i j k ≫ t' j k i ≫ t' k i j = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData C) (i : self.J)
Goal: CategoryTheory.IsIso (self.f i i)
-- CategoryTheory.GlueData.t_id
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure GlueData where
  J : Type v
  U : J → C
  V : J × J → C
  f : ∀ i j, V (i, j) ⟶ U i
  f_mono : ∀ i j, Mono (f i j) := by infer_instance
  f_hasPullback : ∀ i j k, HasPullback (f i j) (f i k) := by infer_instance
  f_id : ∀ i, IsIso (f i i) := by infer_instance
  t : ∀ i j, V (i, j) ⟶ V (j, i)
  t_id : ∀ i, t i i = 𝟙 _
  t' : ∀ i j k, pullback (f i j) (f i k) ⟶ pullback (f j k) (f j i)
  t_fac : ∀ i j k, t' i j k ≫ pullback.snd _ _ = pullback.fst _ _ ≫ t i j
  cocycle : ∀ i j k, t' i j k ≫ t' j k i ≫ t' k i j = 𝟙 _
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData C) (i : self.J)
Goal: self.t i i = CategoryTheory.CategoryStruct.id (self.V (i, i))
-- CategoryTheory.GlueData.t'_iij
@[simp]
theorem t'_iij (i j : D.J) : D.t' i i j = (pullbackSymmetry _ _).hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J)
Goal: D.t' i i j = (CategoryTheory.Limits.pullbackSymmetry (D.f i i) (D.f i j)).hom
-- CategoryTheory.GlueData.t'_jii
theorem t'_jii (i j : D.J) : D.t' j i i = pullback.fst _ _ ≫ D.t j i ≫ inv (pullback.snd _ _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J)
Goal: D.t' j i i =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j i))
    (CategoryTheory.CategoryStruct.comp (D.t j i)
      (CategoryTheory.inv (CategoryTheory.Limits.pullback.snd (D.f i i) (D.f i j))))
-- CategoryTheory.GlueData.t'_iji
theorem t'_iji (i j : D.J) : D.t' i j i = pullback.fst _ _ ≫ D.t i j ≫ inv (pullback.snd _ _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J)
Goal: D.t' i j i =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f i j) (D.f i i))
    (CategoryTheory.CategoryStruct.comp (D.t i j)
      (CategoryTheory.inv (CategoryTheory.Limits.pullback.snd (D.f j i) (D.f j i))))
-- CategoryTheory.GlueData.t_inv
@[reassoc, elementwise (attr := simp)]
theorem t_inv (i j : D.J) : D.t i j ≫ D.t j i = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J)
Goal: CategoryTheory.CategoryStruct.comp (D.t i j) (D.t j i) = CategoryTheory.CategoryStruct.id (D.V (i, j))
-- CategoryTheory.GlueData.t'_inv
theorem t'_inv (i j k : D.J) :
    D.t' i j k ≫ (pullbackSymmetry _ _).hom ≫ D.t' j i k ≫ (pullbackSymmetry _ _).hom = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j k : D.J)
Goal: CategoryTheory.CategoryStruct.comp (D.t' i j k)
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackSymmetry (D.f j k) (D.f j i)).hom
      (CategoryTheory.CategoryStruct.comp (D.t' j i k)
        (CategoryTheory.Limits.pullbackSymmetry (D.f i k) (D.f i j)).hom)) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.pullback (D.f i j) (D.f i k))
-- CategoryTheory.GlueData.t'_comp_eq_pullbackSymmetry
@[reassoc]
theorem t'_comp_eq_pullbackSymmetry (i j k : D.J) :
    D.t' j k i ≫ D.t' k i j =
      (pullbackSymmetry _ _).hom ≫ D.t' j i k ≫ (pullbackSymmetry _ _).hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j k : D.J)
Goal: CategoryTheory.CategoryStruct.comp (D.t' j k i) (D.t' k i j) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackSymmetry (D.f j k) (D.f j i)).hom
    (CategoryTheory.CategoryStruct.comp (D.t' j i k) (CategoryTheory.Limits.pullbackSymmetry (D.f i k) (D.f i j)).hom)
-- CategoryTheory.GlueData.diagram_l
@[simp]
theorem diagram_l : D.diagram.L = (D.J × D.J) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C)
Goal: D.diagram.L = (D.J × D.J)
-- CategoryTheory.GlueData.diagram_r
@[simp]
theorem diagram_r : D.diagram.R = D.J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C)
Goal: D.diagram.R = D.J
-- CategoryTheory.GlueData.diagram_fstFrom
@[simp]
theorem diagram_fstFrom (i j : D.J) : D.diagram.fstFrom ⟨i, j⟩ = i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J)
Goal: D.diagram.fstFrom (i, j) = i
-- CategoryTheory.GlueData.diagram_sndFrom
@[simp]
theorem diagram_sndFrom (i j : D.J) : D.diagram.sndFrom ⟨i, j⟩ = j 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J)
Goal: D.diagram.sndFrom (i, j) = j
-- CategoryTheory.GlueData.diagram_fst
@[simp]
theorem diagram_fst (i j : D.J) : D.diagram.fst ⟨i, j⟩ = D.f i j 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J)
Goal: D.diagram.fst (i, j) = D.f i j
-- CategoryTheory.GlueData.diagram_snd
@[simp]
theorem diagram_snd (i j : D.J) : D.diagram.snd ⟨i, j⟩ = D.t i j ≫ D.f j i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J)
Goal: D.diagram.snd (i, j) = CategoryTheory.CategoryStruct.comp (D.t i j) (D.f j i)
-- CategoryTheory.GlueData.diagram_left
@[simp]
theorem diagram_left : D.diagram.left = D.V 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C)
Goal: D.diagram.left = D.V
-- CategoryTheory.GlueData.diagram_right
@[simp]
theorem diagram_right : D.diagram.right = D.U 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C)
Goal: D.diagram.right = D.U
-- CategoryTheory.GlueData.glue_condition
@[elementwise (attr := simp)]
theorem glue_condition (i j : D.J) : D.t i j ≫ D.f j i ≫ D.ι j = D.f i j ≫ D.ι i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) [CategoryTheory.Limits.HasMulticoequalizer D.diagram] (i j : D.J)
Goal: CategoryTheory.CategoryStruct.comp (D.t i j) (CategoryTheory.CategoryStruct.comp (D.f j i) (D.ι j)) =
  CategoryTheory.CategoryStruct.comp (D.f i j) (D.ι i)
-- CategoryTheory.GlueData.types_π_surjective
theorem types_π_surjective (D : GlueData Type*) : Function.Surjective D.π 
Arguments: (D : CategoryTheory.GlueData (Type u_1))
Goal: Function.Surjective D.π
-- CategoryTheory.GlueData.types_ι_jointly_surjective
theorem types_ι_jointly_surjective (D : GlueData (Type v)) (x : D.glued) :
    ∃ (i : _) (y : D.U i), D.ι i y = x 
Arguments: (D : CategoryTheory.GlueData (Type v)) (x : D.glued)
Goal: ∃ i y, D.ι i y = x
-- CategoryTheory.GlueData.mapGlueData_f
@[simps]
def mapGlueData : GlueData C' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i j : D.J)
Goal: (D.mapGlueData F).f i j = F.map (D.f i j)
-- CategoryTheory.GlueData.mapGlueData_V
@[simps]
def mapGlueData : GlueData C' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i : D.J × D.J)
Goal: (D.mapGlueData F).V i = F.obj (D.V i)
-- CategoryTheory.GlueData.mapGlueData_t'
@[simps]
def mapGlueData : GlueData C' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i j k : D.J)
Goal: (D.mapGlueData F).t' i j k =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PreservesPullback.iso F (D.f i j) (D.f i k)).inv
    (CategoryTheory.CategoryStruct.comp (F.map (D.t' i j k))
      (CategoryTheory.Limits.PreservesPullback.iso F (D.f j k) (D.f j i)).hom)
-- CategoryTheory.GlueData.mapGlueData_J
@[simps]
def mapGlueData : GlueData C' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F]
Goal: (D.mapGlueData F).J = D.J
-- CategoryTheory.GlueData.mapGlueData_U
@[simps]
def mapGlueData : GlueData C' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i : D.J)
Goal: (D.mapGlueData F).U i = F.obj (D.U i)
-- CategoryTheory.GlueData.mapGlueData_t
@[simps]
def mapGlueData : GlueData C' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i j : D.J)
Goal: (D.mapGlueData F).t i j = F.map (D.t i j)
-- CategoryTheory.GlueData.diagramIso_app_left
@[simp]
theorem diagramIso_app_left (i : D.J × D.J) :
    (D.diagramIso F).app (WalkingMultispan.left i) = Iso.refl _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i : D.J × D.J)
Goal: (D.diagramIso F).app (CategoryTheory.Limits.WalkingMultispan.left i) =
  CategoryTheory.Iso.refl ((D.diagram.multispan.comp F).obj (CategoryTheory.Limits.WalkingMultispan.left i))
-- CategoryTheory.GlueData.diagramIso_app_right
@[simp]
theorem diagramIso_app_right (i : D.J) :
    (D.diagramIso F).app (WalkingMultispan.right i) = Iso.refl _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i : D.J)
Goal: (D.diagramIso F).app (CategoryTheory.Limits.WalkingMultispan.right i) =
  CategoryTheory.Iso.refl ((D.diagram.multispan.comp F).obj (CategoryTheory.Limits.WalkingMultispan.right i))
-- CategoryTheory.GlueData.diagramIso_hom_app_left
@[simp]
theorem diagramIso_hom_app_left (i : D.J × D.J) :
    (D.diagramIso F).hom.app (WalkingMultispan.left i) = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i : D.J × D.J)
Goal: (D.diagramIso F).hom.app (CategoryTheory.Limits.WalkingMultispan.left i) =
  CategoryTheory.CategoryStruct.id ((D.diagram.multispan.comp F).obj (CategoryTheory.Limits.WalkingMultispan.left i))
-- CategoryTheory.GlueData.diagramIso_hom_app_right
@[simp]
theorem diagramIso_hom_app_right (i : D.J) :
    (D.diagramIso F).hom.app (WalkingMultispan.right i) = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {C' : Type u₂} [CategoryTheory.Category.{v, u₂} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C') [H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F] (i : D.J)
Goal: (D.diagramIso F).hom.app (CategoryTheory.Limits.WalkingMultispan.right i) =
  CategoryTheory.CategoryStruct.id ((D.diagram.multispan.comp F).obj (CategoryTheory.Limits.WalkingMultispan.right i))