ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Subgroupoid.map_objs_eq
@[simp]
theorem map_objs_eq (hφ : Function.Injective φ.obj) : (map φ hφ S).objs = φ.obj '' S.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj)
Goal: (CategoryTheory.Subgroupoid.map φ hφ S).objs = φ.obj '' S.objs
-- CategoryTheory.Subgroupoid.mem_im_iff
theorem mem_im_iff (hφ : Function.Injective φ.obj) {c d : D} (f : c ⟶ d) :
    f ∈ (im φ hφ).arrows c d ↔
      ∃ (a b : C) (g : a ⟶ b) (ha : φ.obj a = c) (hb : φ.obj b = d),
        f = eqToHom ha.symm ≫ φ.map g ≫ eqToHom hb 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) {c d : D} (f : c ⟶ d)
Goal: f ∈ (CategoryTheory.Subgroupoid.im φ hφ).arrows c d ↔
  ∃ a b g,
    ∃ (ha : φ.obj a = c) (hb : φ.obj b = d),
      f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
          (CategoryTheory.CategoryStruct.comp (φ.map g) (CategoryTheory.eqToHom hb))
-- CategoryTheory.Subgroupoid.mem_im_objs_iff
theorem mem_im_objs_iff (hφ : Function.Injective φ.obj) (d : D) :
    d ∈ (im φ hφ).objs ↔ ∃ c : C, φ.obj c = d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (d : D)
Goal: d ∈ (CategoryTheory.Subgroupoid.im φ hφ).objs ↔ ∃ c, φ.obj c = d
-- CategoryTheory.Subgroupoid.obj_surjective_of_im_eq_top
theorem obj_surjective_of_im_eq_top (hφ : Function.Injective φ.obj) (hφ' : im φ hφ = ⊤) :
    Function.Surjective φ.obj 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (hφ' : CategoryTheory.Subgroupoid.im φ hφ = ⊤)
Goal: Function.Surjective φ.obj
-- CategoryTheory.Subgroupoid.isNormal_map
theorem isNormal_map (hφ : Function.Injective φ.obj) (hφ' : im φ hφ = ⊤) (Sn : S.IsNormal) :
    (map φ hφ S).IsNormal 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (hφ' : CategoryTheory.Subgroupoid.im φ hφ = ⊤) (Sn : S.IsNormal)
Goal: (CategoryTheory.Subgroupoid.map φ hφ S).IsNormal
-- CategoryTheory.Subgroupoid.isThin_iff
nonrec theorem isThin_iff : S.IsThin ↔ ∀ c : S.objs, Subsingleton (S.arrows c c) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: S.IsThin ↔ ∀ (c : ↑S.objs), Subsingleton ↑(S.arrows ↑c ↑c)
-- CategoryTheory.Subgroupoid.isTotallyDisconnected_iff
theorem isTotallyDisconnected_iff :
    S.IsTotallyDisconnected ↔ ∀ c d, (S.arrows c d).Nonempty → c = d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: S.IsTotallyDisconnected ↔ ∀ (c d : C), (S.arrows c d).Nonempty → c = d
-- CategoryTheory.Subgroupoid.disconnect_le
theorem disconnect_le : S.disconnect ≤ S 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: S.disconnect ≤ S
-- CategoryTheory.Subgroupoid.disconnect_normal
theorem disconnect_normal (Sn : S.IsNormal) : S.disconnect.IsNormal 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (Sn : S.IsNormal)
Goal: S.disconnect.IsNormal
-- CategoryTheory.Subgroupoid.mem_disconnect_objs_iff
@[simp]
theorem mem_disconnect_objs_iff {c : C} : c ∈ S.disconnect.objs ↔ c ∈ S.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c : C}
Goal: c ∈ S.disconnect.objs ↔ c ∈ S.objs
-- CategoryTheory.Subgroupoid.disconnect_objs
theorem disconnect_objs : S.disconnect.objs = S.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: S.disconnect.objs = S.objs
-- CategoryTheory.Subgroupoid.disconnect_isTotallyDisconnected
theorem disconnect_isTotallyDisconnected : S.disconnect.IsTotallyDisconnected 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: S.disconnect.IsTotallyDisconnected
-- CategoryTheory.Subgroupoid.full_objs
theorem full_objs : (full D).objs = D 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (D : Set C)
Goal: (CategoryTheory.Subgroupoid.full D).objs = D
-- CategoryTheory.Subgroupoid.mem_full_iff
@[simp]
theorem mem_full_iff {c d : C} {f : c ⟶ d} : f ∈ (full D).arrows c d ↔ c ∈ D ∧ d ∈ D 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (D : Set C) {c d : C} {f : c ⟶ d}
Goal: f ∈ (CategoryTheory.Subgroupoid.full D).arrows c d ↔ c ∈ D ∧ d ∈ D
-- CategoryTheory.Subgroupoid.mem_full_objs_iff
@[simp]
theorem mem_full_objs_iff {c : C} : c ∈ (full D).objs ↔ c ∈ D 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (D : Set C) {c : C}
Goal: c ∈ (CategoryTheory.Subgroupoid.full D).objs ↔ c ∈ D
-- CategoryTheory.Subgroupoid.full_empty
@[simp]
theorem full_empty : full ∅ = (⊥ : Subgroupoid C) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C]
Goal: CategoryTheory.Subgroupoid.full ∅ = ⊥
-- CategoryTheory.Subgroupoid.full_univ
@[simp]
theorem full_univ : full Set.univ = (⊤ : Subgroupoid C) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C]
Goal: CategoryTheory.Subgroupoid.full Set.univ = ⊤
-- CategoryTheory.Subgroupoid.full_mono
theorem full_mono {D E : Set C} (h : D ≤ E) : full D ≤ full E 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D E : Set C} (h : D ≤ E)
Goal: CategoryTheory.Subgroupoid.full D ≤ CategoryTheory.Subgroupoid.full E
-- CategoryTheory.Subgroupoid.full_arrow_eq_iff
theorem full_arrow_eq_iff {c d : (full D).objs} {f g : c ⟶ d} :
    f = g ↔ (f.1 : c.val ⟶ d.val) = g.1 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (D : Set C) {c d : ↑(CategoryTheory.Subgroupoid.full D).objs} {f g : c ⟶ d}
Goal: f = g ↔ ↑f = ↑g
-- CategoryTheory.ProjectiveResolution.quasiIso
structure ProjectiveResolution (Z : C) where
    complex : ChainComplex C ℕ
    projective : ∀ n, Projective (complex.X n) := by infer_instance
    [hasHomology : ∀ i, complex.HasHomology i]
    π : complex ⟶ (ChainComplex.single₀ C).obj Z
    quasiIso : QuasiIso π := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (self : CategoryTheory.ProjectiveResolution Z)
Goal: QuasiIso self.π
-- CategoryTheory.ProjectiveResolution.hasHomology
structure ProjectiveResolution (Z : C) where
    complex : ChainComplex C ℕ
    projective : ∀ n, Projective (complex.X n) := by infer_instance
    [hasHomology : ∀ i, complex.HasHomology i]
    π : complex ⟶ (ChainComplex.single₀ C).obj Z
    quasiIso : QuasiIso π := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (self : CategoryTheory.ProjectiveResolution Z) (i : ℕ)
Goal: HomologicalComplex.HasHomology self.complex i
-- CategoryTheory.ProjectiveResolution.projective
structure ProjectiveResolution (Z : C) where
    complex : ChainComplex C ℕ
    projective : ∀ n, Projective (complex.X n) := by infer_instance
    [hasHomology : ∀ i, complex.HasHomology i]
    π : complex ⟶ (ChainComplex.single₀ C).obj Z
    quasiIso : QuasiIso π := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (self : CategoryTheory.ProjectiveResolution Z) (n : ℕ)
Goal: CategoryTheory.Projective (self.complex.X n)
-- CategoryTheory.HasProjectiveResolution.out
class HasProjectiveResolution (Z : C) : Prop where
  out : Nonempty (ProjectiveResolution Z)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} [self : CategoryTheory.HasProjectiveResolution Z]
Goal: Nonempty (CategoryTheory.ProjectiveResolution Z)
-- CategoryTheory.HasProjectiveResolutions.out
class HasProjectiveResolutions : Prop where
  out : ∀ Z : C, HasProjectiveResolution Z
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] [self : CategoryTheory.HasProjectiveResolutions C] (Z : C)
Goal: CategoryTheory.HasProjectiveResolution Z
-- CategoryTheory.ProjectiveResolution.complex_exactAt_succ
lemma complex_exactAt_succ (n : ℕ) :
    P.complex.ExactAt (n + 1) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ)
Goal: HomologicalComplex.ExactAt P.complex (n + 1)
-- CategoryTheory.ProjectiveResolution.exact_succ
lemma exact_succ (n : ℕ) :
    (ShortComplex.mk _ _ (P.complex.d_comp_d (n + 2) (n + 1) n)).Exact 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ)
Goal: (CategoryTheory.ShortComplex.mk (P.complex.d (n + 2) (n + 1)) (P.complex.d (n + 1) n) ⋯).Exact
-- CategoryTheory.ProjectiveResolution.π_f_succ
@[simp]
theorem π_f_succ (n : ℕ) : P.π.f (n + 1) = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ)
Goal: P.π.f (n + 1) = 0
-- CategoryTheory.ProjectiveResolution.complex_d_comp_π_f_zero
@[reassoc (attr := simp)]
theorem complex_d_comp_π_f_zero :
    P.complex.d 1 0 ≫ P.π.f 0 = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z)
Goal: CategoryTheory.CategoryStruct.comp (P.complex.d 1 0) (P.π.f 0) = 0
-- CategoryTheory.ProjectiveResolution.complex_d_succ_comp
theorem complex_d_succ_comp (n : ℕ) :
    P.complex.d n (n + 1) ≫ P.complex.d (n + 1) (n + 2) = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ)
Goal: CategoryTheory.CategoryStruct.comp (P.complex.d n (n + 1)) (P.complex.d (n + 1) (n + 2)) = 0
-- CategoryTheory.ProjectiveResolution.self_π
@[simps]
noncomputable def self [Projective Z] : ProjectiveResolution Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (Z : C) [CategoryTheory.Projective Z]
Goal: (CategoryTheory.ProjectiveResolution.self Z).π = CategoryTheory.CategoryStruct.id ((ChainComplex.single₀ C).obj Z)
-- CategoryTheory.ProjectiveResolution.self_complex
@[simps]
noncomputable def self [Projective Z] : ProjectiveResolution Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (Z : C) [CategoryTheory.Projective Z]
Goal: (CategoryTheory.ProjectiveResolution.self Z).complex = (ChainComplex.single₀ C).obj Z
-- CategoryTheory.SmallObject.FunctorObjIndex.w
structure FunctorObjIndex where
    i : I
    t : A i ⟶ X
    b : B i ⟶ S
  w : t ≫ πX = f i ≫ b
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} {f : (i : I) → A i ⟶ B i} {S X : C} {πX : X ⟶ S} (self : CategoryTheory.SmallObject.FunctorObjIndex f πX)
Goal: CategoryTheory.CategoryStruct.comp self.t πX = CategoryTheory.CategoryStruct.comp (f self.i) self.b
-- CategoryTheory.SmallObject.functorObj_comm
@[reassoc]
lemma functorObj_comm :
    functorObjTop f πX ≫ ιFunctorObj f πX = functorObjLeft f πX ≫ ρFunctorObj f πX 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C} (πX : X ⟶ S) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.functorObjLeft f πX)]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.ιFunctorObj f πX) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.functorObjLeft f πX)
    (CategoryTheory.SmallObject.ρFunctorObj f πX)
-- CategoryTheory.SmallObject.FunctorObjIndex.comm
@[reassoc]
lemma FunctorObjIndex.comm (x : FunctorObjIndex f πX) :
    f x.i ≫ Sigma.ι (functorObjTgtFamily f πX) x ≫ ρFunctorObj f πX = x.t ≫ ιFunctorObj f πX 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C} (πX : X ⟶ S) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.functorObjLeft f πX)] (x : CategoryTheory.SmallObject.FunctorObjIndex f πX)
Goal: CategoryTheory.CategoryStruct.comp (f x.i)
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.Limits.Sigma.ι (CategoryTheory.SmallObject.functorObjTgtFamily f πX) x)
      (CategoryTheory.SmallObject.ρFunctorObj f πX)) =
  CategoryTheory.CategoryStruct.comp x.t (CategoryTheory.SmallObject.ιFunctorObj f πX)
-- CategoryTheory.SmallObject.ρFunctorObj_π
@[reassoc (attr := simp)]
lemma ρFunctorObj_π : ρFunctorObj f πX ≫ πFunctorObj f πX = π'FunctorObj f πX 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C} (πX : X ⟶ S) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.functorObjLeft f πX)]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.ρFunctorObj f πX)
    (CategoryTheory.SmallObject.πFunctorObj f πX) =
  CategoryTheory.SmallObject.π'FunctorObj f πX
-- CategoryTheory.SmallObject.ιFunctorObj_πFunctorObj
@[reassoc (attr := simp)]
lemma ιFunctorObj_πFunctorObj : ιFunctorObj f πX ≫ πFunctorObj f πX = πX 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C} (πX : X ⟶ S) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.functorObjLeft f πX)]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.ιFunctorObj f πX)
    (CategoryTheory.SmallObject.πFunctorObj f πX) =
  πX
-- CategoryTheory.SmallObject.ι_functorMapSrc
@[reassoc]
lemma ι_functorMapSrc (i : I) (t : A i ⟶ X) (b : B i ⟶ S) (w : t ≫ πX = f i ≫ b)
    (t' : A i ⟶ Y) (fac : t ≫ φ = t') :
    Sigma.ι _ (FunctorObjIndex.mk i t b w) ≫ functorMapSrc f πX πY φ hφ =
      Sigma.ι (functorObjSrcFamily f πY)
        (FunctorObjIndex.mk i t' b (by rw [← w, ← fac, assoc, hφ])) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X Y : C} (πX : X ⟶ S) (πY : Y ⟶ S) (φ : X ⟶ Y) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πY)) C] (hφ : CategoryTheory.CategoryStruct.comp φ πY = πX) (i : I) (t : A i ⟶ X) (b : B i ⟶ S) (w : CategoryTheory.CategoryStruct.comp t πX = CategoryTheory.CategoryStruct.comp (f i) b) (t' : A i ⟶ Y) (fac : CategoryTheory.CategoryStruct.comp t φ = t')
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.Sigma.ι (CategoryTheory.SmallObject.functorObjSrcFamily f πX)
      { i := i, t := t, b := b, w := w })
    (CategoryTheory.SmallObject.functorMapSrc f πX πY φ hφ) =
  CategoryTheory.Limits.Sigma.ι (CategoryTheory.SmallObject.functorObjSrcFamily f πY)
    { i := i, t := t', b := b, w := ⋯ }
-- CategoryTheory.SmallObject.functorMapSrc_functorObjTop
@[reassoc (attr := simp)]
lemma functorMapSrc_functorObjTop :
    functorMapSrc f πX πY φ hφ ≫ functorObjTop f πY = functorObjTop f πX ≫ φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X Y : C} (πX : X ⟶ S) (πY : Y ⟶ S) (φ : X ⟶ Y) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πY)) C] (hφ : CategoryTheory.CategoryStruct.comp φ πY = πX)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.functorMapSrc f πX πY φ hφ)
    (CategoryTheory.SmallObject.functorObjTop f πY) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.functorObjTop f πX) φ
-- CategoryTheory.SmallObject.ι_functorMapTgt
@[reassoc]
lemma ι_functorMapTgt (i : I) (t : A i ⟶ X) (b : B i ⟶ S) (w : t ≫ πX = f i ≫ b)
    (t' : A i ⟶ Y) (fac : t ≫ φ = t') :
    Sigma.ι _ (FunctorObjIndex.mk i t b w) ≫ functorMapTgt f πX πY φ hφ =
      Sigma.ι (functorObjTgtFamily f πY)
        (FunctorObjIndex.mk i t' b (by rw [← w, ← fac, assoc, hφ])) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X Y : C} (πX : X ⟶ S) (πY : Y ⟶ S) (φ : X ⟶ Y) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πY)) C] (hφ : CategoryTheory.CategoryStruct.comp φ πY = πX) (i : I) (t : A i ⟶ X) (b : B i ⟶ S) (w : CategoryTheory.CategoryStruct.comp t πX = CategoryTheory.CategoryStruct.comp (f i) b) (t' : A i ⟶ Y) (fac : CategoryTheory.CategoryStruct.comp t φ = t')
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.Sigma.ι (CategoryTheory.SmallObject.functorObjTgtFamily f πX)
      { i := i, t := t, b := b, w := w })
    (CategoryTheory.SmallObject.functorMapTgt f πX πY φ hφ) =
  CategoryTheory.Limits.Sigma.ι (CategoryTheory.SmallObject.functorObjTgtFamily f πY)
    { i := i, t := t', b := b, w := ⋯ }
-- CategoryTheory.SmallObject.functorMap_comm
lemma functorMap_comm :
    functorObjLeft f πX ≫ functorMapTgt f πX πY φ hφ =
      functorMapSrc f πX πY φ hφ ≫ functorObjLeft f πY 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X Y : C} (πX : X ⟶ S) (πY : Y ⟶ S) (φ : X ⟶ Y) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πY)) C] (hφ : CategoryTheory.CategoryStruct.comp φ πY = πX)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.functorObjLeft f πX)
    (CategoryTheory.SmallObject.functorMapTgt f πX πY φ hφ) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.functorMapSrc f πX πY φ hφ)
    (CategoryTheory.SmallObject.functorObjLeft f πY)
-- CategoryTheory.SmallObject.functorMap_π
@[reassoc (attr := simp)]
lemma functorMap_π : functorMap f πX πY φ hφ ≫ πFunctorObj f πY = πFunctorObj f πX 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X Y : C} (πX : X ⟶ S) (πY : Y ⟶ S) (φ : X ⟶ Y) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πY)) C] (hφ : CategoryTheory.CategoryStruct.comp φ πY = πX) [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.functorObjLeft f πX)] [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πY)
    (CategoryTheory.SmallObject.functorObjLeft f πY)]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.functorMap f πX πY φ hφ)
    (CategoryTheory.SmallObject.πFunctorObj f πY) =
  CategoryTheory.SmallObject.πFunctorObj f πX
-- CategoryTheory.SmallObject.functorMap_id
@[simp]
lemma functorMap_id : functorMap f πX πX (𝟙 X) (by simp) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S : C} (X : C) (πX : X ⟶ S) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.functorObjLeft f πX)]
Goal: CategoryTheory.SmallObject.functorMap f πX πX (CategoryTheory.CategoryStruct.id X) ⋯ =
  CategoryTheory.CategoryStruct.id (CategoryTheory.SmallObject.functorObj f πX)
-- CategoryTheory.SmallObject.ιFunctorObj_naturality
@[reassoc (attr := simp)]
lemma ιFunctorObj_naturality :
    ιFunctorObj f πX ≫ functorMap f πX πY φ hφ = φ ≫ ιFunctorObj f πY 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X Y : C} (πX : X ⟶ S) (πY : Y ⟶ S) (φ : X ⟶ Y) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πY)) C] (hφ : CategoryTheory.CategoryStruct.comp φ πY = πX) [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.functorObjLeft f πX)] [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πY)
    (CategoryTheory.SmallObject.functorObjLeft f πY)]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.SmallObject.ιFunctorObj f πX)
    (CategoryTheory.SmallObject.functorMap f πX πY φ hφ) =
  CategoryTheory.CategoryStruct.comp φ (CategoryTheory.SmallObject.ιFunctorObj f πY)
-- CategoryTheory.SmallObject.ιFunctorObj_extension
lemma ιFunctorObj_extension {i : I} (t : A i ⟶ X) (b : B i ⟶ S)
    (sq : CommSq t (f i) πX b) :
    ∃ (l : B i ⟶ functorObj f πX), f i ≫ l = t ≫ ιFunctorObj f πX ∧
      l ≫ πFunctorObj f πX = b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C} (πX : X ⟶ S) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] [CategoryTheory.Limits.HasPushout (CategoryTheory.SmallObject.functorObjTop f πX)
    (CategoryTheory.SmallObject.functorObjLeft f πX)] {i : I} (t : A i ⟶ X) (b : B i ⟶ S) (sq : CategoryTheory.CommSq t (f i) πX b)
Goal: ∃ l,
  CategoryTheory.CategoryStruct.comp (f i) l =
      CategoryTheory.CategoryStruct.comp t (CategoryTheory.SmallObject.ιFunctorObj f πX) ∧
    CategoryTheory.CategoryStruct.comp l (CategoryTheory.SmallObject.πFunctorObj f πX) = b
-- CategoryTheory.SmallObject.functor_obj
@[simps! obj map]
noncomputable def functor : Over S ⥤ Over S 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) (S : C) [CategoryTheory.Limits.HasPushouts C] [∀ {X : C} (πX : X ⟶ S),
    CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX))
      C] (π : CategoryTheory.Over S)
Goal: (CategoryTheory.SmallObject.functor f S).obj π = CategoryTheory.Over.mk (CategoryTheory.SmallObject.πFunctorObj f π.hom)