ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.GradedObject.ι_descMapObj
@[reassoc (attr := simp)]
lemma ι_descMapObj {A : C} {j : J}
    (φ : ∀ (i : I) (_ : p i = j), X i ⟶ A) (i : I) (hi : p i = j) :
    X.ιMapObj p i j hi ≫ X.descMapObj p φ = φ i hi 
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} (φ : (i : I) → p i = j → (X i ⟶ A)) (i : I) (hi : p i = j)
Goal: CategoryTheory.CategoryStruct.comp (X.ιMapObj p i j hi) (X.descMapObj p φ) = φ i hi
-- CategoryTheory.GradedObject.CofanMapObjFun.hasMap
lemma hasMap (c : ∀ j, CofanMapObjFun X p j) (hc : ∀ j, IsColimit (c j)) :
    X.HasMap p 
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) (c : (j : J) → X.CofanMapObjFun p j) (hc : (j : J) → CategoryTheory.Limits.IsColimit (c j))
Goal: X.HasMap p
-- CategoryTheory.GradedObject.CofanMapObjFun.inj_iso_hom
@[reassoc (attr := simp)]
lemma inj_iso_hom (i : I) (hi : p i = j) :
    c.inj ⟨i, hi⟩ ≫ (c.iso hc).hom = X.ιMapObj p i j hi 
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} {j : J} {c : X.CofanMapObjFun p j} (hc : CategoryTheory.Limits.IsColimit c) [X.HasMap p] (i : I) (hi : p i = j)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj c ⟨i, hi⟩)
    (CategoryTheory.GradedObject.CofanMapObjFun.iso hc).hom =
  X.ιMapObj p i j hi
-- CategoryTheory.GradedObject.CofanMapObjFun.ιMapObj_iso_inv
@[reassoc (attr := simp)]
lemma ιMapObj_iso_inv (i : I) (hi : p i = j) :
    X.ιMapObj p i j hi ≫ (c.iso hc).inv = c.inj ⟨i, hi⟩ 
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} {j : J} {c : X.CofanMapObjFun p j} (hc : CategoryTheory.Limits.IsColimit c) [X.HasMap p] (i : I) (hi : p i = j)
Goal: CategoryTheory.CategoryStruct.comp (X.ιMapObj p i j hi) (CategoryTheory.GradedObject.CofanMapObjFun.iso hc).inv =
  CategoryTheory.Limits.Cofan.inj c ⟨i, hi⟩
-- CategoryTheory.GradedObject.ι_mapMap
@[reassoc (attr := simp)]
lemma ι_mapMap (i : I) (j : J) (hij : p i = j) :
    X.ιMapObj p i j hij ≫ mapMap φ p j = φ i ≫ Y.ιMapObj p i j hij 
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} (φ : X ⟶ Y) (p : I → J) [X.HasMap p] [Y.HasMap p] (i : I) (j : J) (hij : p i = j)
Goal: CategoryTheory.CategoryStruct.comp (X.ιMapObj p i j hij) (CategoryTheory.GradedObject.mapMap φ p j) =
  CategoryTheory.CategoryStruct.comp (φ i) (Y.ιMapObj p i j hij)
-- CategoryTheory.GradedObject.congr_mapMap
lemma congr_mapMap (φ₁ φ₂ : X ⟶ Y) (h : φ₁ = φ₂) : mapMap φ₁ p = mapMap φ₂ 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} (p : I → J) [X.HasMap p] [Y.HasMap p] (φ₁ φ₂ : X ⟶ Y) (h : φ₁ = φ₂)
Goal: CategoryTheory.GradedObject.mapMap φ₁ p = CategoryTheory.GradedObject.mapMap φ₂ p
-- CategoryTheory.GradedObject.mapMap_id
@[simp]
lemma mapMap_id : mapMap (𝟙 X) p = 𝟙 _ 
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]
Goal: CategoryTheory.GradedObject.mapMap (CategoryTheory.CategoryStruct.id X) p =
  CategoryTheory.CategoryStruct.id (X.mapObj p)
-- CategoryTheory.GradedObject.mapMap_comp
@[simp, reassoc]
lemma mapMap_comp : mapMap (φ ≫ ψ) p = mapMap φ p ≫ mapMap ψ p 
Arguments: {I : Type u_1} {J : Type u_2} {C : Type u_4} [CategoryTheory.Category.{u_5, u_4} C] {X Y Z : CategoryTheory.GradedObject I C} (φ : X ⟶ Y) (ψ : Y ⟶ Z) (p : I → J) [X.HasMap p] [Y.HasMap p] [Z.HasMap p]
Goal: CategoryTheory.GradedObject.mapMap (CategoryTheory.CategoryStruct.comp φ ψ) p =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.mapMap φ p) (CategoryTheory.GradedObject.mapMap ψ p)
-- CategoryTheory.GradedObject.mapIso_hom
@[simps]
noncomputable def mapIso : X.mapObj p ≅ Y.mapObj 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] [Y.HasMap p] (i : J)
Goal: (CategoryTheory.GradedObject.mapIso e p).hom i = CategoryTheory.GradedObject.mapMap e.hom p i
-- CategoryTheory.GradedObject.mapIso_inv
@[simps]
noncomputable def mapIso : X.mapObj p ≅ Y.mapObj 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] [Y.HasMap p] (i : J)
Goal: (CategoryTheory.GradedObject.mapIso e p).inv i = CategoryTheory.GradedObject.mapMap e.inv p i
-- CategoryTheory.GradedObject.map_obj
@[simps]
noncomputable def map [∀ (j : J), HasColimitsOfShape (Discrete (p ⁻¹' {j})) C] :
    GradedObject I C ⥤ GradedObject J C 
Arguments: {I : Type u_1} {J : Type u_2} (C : Type u_4) [CategoryTheory.Category.{u_5, u_4} C] (p : I → J) [∀ (j : J), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ↑(p ⁻¹' {j})) C] (X : CategoryTheory.GradedObject I C)
Goal: (CategoryTheory.GradedObject.map C p).obj X = X.mapObj p
-- CategoryTheory.GradedObject.map_map
@[simps]
noncomputable def map [∀ (j : J), HasColimitsOfShape (Discrete (p ⁻¹' {j})) C] :
    GradedObject I C ⥤ GradedObject J C 
Arguments: {I : Type u_1} {J : Type u_2} (C : Type u_4) [CategoryTheory.Category.{u_5, u_4} C] (p : I → J) [∀ (j : J), CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ↑(p ⁻¹' {j})) C]
Goal: ∀ {X Y : CategoryTheory.GradedObject I C} (φ : X ⟶ Y) (i : J),
  (CategoryTheory.GradedObject.map C p).map φ i = CategoryTheory.GradedObject.mapMap φ p i
-- CategoryTheory.GradedObject.hasMap_comp
lemma hasMap_comp [X.HasMap p] [(X.mapObj p).HasMap q] : X.HasMap r 
Arguments: {I : Type u_1} {J : Type u_2} {K : Type u_3} {C : Type u_4} [CategoryTheory.Category.{u_5, u_4} C] (X : CategoryTheory.GradedObject I C) (p : I → J) (q : J → K) (r : I → K) (hpqr : ∀ (i : I), q (p i) = r i) [X.HasMap p] [(X.mapObj p).HasMap q]
Goal: X.HasMap r
-- CategoryTheory.GradedObject.ιMapObjOrZero_eq
lemma ιMapObjOrZero_eq (h : p i = j) : X.ιMapObjOrZero p i j = X.ιMapObj p i j h 
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] [CategoryTheory.Limits.HasZeroMorphisms C] [DecidableEq J] (i : I) (j : J) (h : p i = j)
Goal: X.ιMapObjOrZero p i j = X.ιMapObj p i j h
-- CategoryTheory.GradedObject.ιMapObjOrZero_eq_zero
lemma ιMapObjOrZero_eq_zero (h : p i ≠ j) : X.ιMapObjOrZero p i j = 0 
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] [CategoryTheory.Limits.HasZeroMorphisms C] [DecidableEq J] (i : I) (j : J) (h : p i ≠ j)
Goal: X.ιMapObjOrZero p i j = 0
-- CategoryTheory.GradedObject.ιMapObjOrZero_mapMap
@[reassoc (attr := simp)]
lemma ιMapObjOrZero_mapMap :
    X.ιMapObjOrZero p i j ≫ mapMap φ p j = φ i ≫ Y.ιMapObjOrZero p i j 
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} (φ : X ⟶ Y) (p : I → J) [X.HasMap p] [Y.HasMap p] [CategoryTheory.Limits.HasZeroMorphisms C] [DecidableEq J] (i : I) (j : J)
Goal: CategoryTheory.CategoryStruct.comp (X.ιMapObjOrZero p i j) (CategoryTheory.GradedObject.mapMap φ p j) =
  CategoryTheory.CategoryStruct.comp (φ i) (Y.ιMapObjOrZero p i j)
-- CategoryTheory.End.one_def
@[simp, nolint simpNF] -- Porting note (#11215): TODO: use `of`/`asHom`?
theorem one_def : (1 : End X) = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.CategoryStruct.{v, u} C] {X : C}
Goal: 1 = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.End.mul_def
@[simp] -- Porting note (#11215): TODO: use `of`/`asHom`?
theorem mul_def (xs ys : End X) : xs * ys = ys ≫ xs 
Arguments: {C : Type u} [CategoryTheory.CategoryStruct.{v, u} C] {X : C} (xs ys : CategoryTheory.End X)
Goal: xs * ys = CategoryTheory.CategoryStruct.comp ys xs
-- CategoryTheory.End.smul_right
theorem smul_right {X Y : C} {r : End Y} {f : X ⟶ Y} : r • f = f ≫ r 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {r : CategoryTheory.End Y} {f : X ⟶ Y}
Goal: r • f = CategoryTheory.CategoryStruct.comp f r
-- CategoryTheory.End.smul_left
theorem smul_left {X : Cᵒᵖ} {Y : C} {r : End X} {f : unop X ⟶ Y} : r • f = r.unop ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : Cᵒᵖ} {Y : C} {r : CategoryTheory.End X} {f : Opposite.unop X ⟶ Y}
Goal: r • f = CategoryTheory.CategoryStruct.comp (Quiver.Hom.unop r) f
-- CategoryTheory.isUnit_iff_isIso
theorem isUnit_iff_isIso {C : Type u} [Category.{v} C] {X : C} (f : End X) :
    IsUnit (f : End X) ↔ IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (f : CategoryTheory.End X)
Goal: IsUnit f ↔ CategoryTheory.IsIso f
-- CategoryTheory.Aut.ext
@[ext]
lemma ext {X : C} {φ₁ φ₂ : Aut X} (h : φ₁.hom = φ₂.hom) : φ₁ = φ₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {φ₁ φ₂ : CategoryTheory.Aut X} (h : φ₁.hom = φ₂.hom)
Goal: φ₁ = φ₂
-- CategoryTheory.Aut.Aut_mul_def
theorem Aut_mul_def (f g : Aut X) : f * g = g.trans f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) (f g : CategoryTheory.Aut X)
Goal: f * g = g ≪≫ f
-- CategoryTheory.Aut.Aut_inv_def
theorem Aut_inv_def (f : Aut X) : f⁻¹ = f.symm 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) (f : CategoryTheory.Aut X)
Goal: f⁻¹ = CategoryTheory.Iso.symm f
-- CategoryTheory.Aut.toEnd_apply
@[simps!]
def toEnd (X : C) : Aut X →* End X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: ∀ (a : CategoryTheory.Aut X), (CategoryTheory.Aut.toEnd X) a = ↑((CategoryTheory.Aut.unitsEndEquivAut X).symm a)
-- CategoryTheory.Functor.mapEnd_apply
@[simps]
def mapEnd : End X →* End (f.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) {D : Type u'} [CategoryTheory.Category.{v', u'} D] (f : CategoryTheory.Functor C D)
Goal: ∀ (a : X ⟶ X), (CategoryTheory.Functor.mapEnd X f) a = f.map a
-- CategoryTheory.Functor.FullyFaithful.mulEquivEnd_apply
@[simps!]
noncomputable def mulEquivEnd (X : C) :
    End X ≃* End (f.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {f : CategoryTheory.Functor C D} (hf : f.FullyFaithful) (X : C)
Goal: ∀ (a : X ⟶ X), (hf.mulEquivEnd X) a = f.map a
-- CategoryTheory.Functor.FullyFaithful.mulEquivEnd_symm_apply
@[simps!]
noncomputable def mulEquivEnd (X : C) :
    End X ≃* End (f.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {f : CategoryTheory.Functor C D} (hf : f.FullyFaithful) (X : C)
Goal: ∀ (f_1 : f.obj X ⟶ f.obj X), (hf.mulEquivEnd X).symm f_1 = hf.preimage f_1
-- CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_apply_inv
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {f : CategoryTheory.Functor C D} (hf : f.FullyFaithful) (X : C) (i : X ≅ X)
Goal: ((hf.autMulEquivOfFullyFaithful X) i).inv = f.map i.inv
-- CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_apply_hom
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {f : CategoryTheory.Functor C D} (hf : f.FullyFaithful) (X : C) (i : X ≅ X)
Goal: ((hf.autMulEquivOfFullyFaithful X) i).hom = f.map i.hom
-- CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_symm_apply_inv
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {f : CategoryTheory.Functor C D} (hf : f.FullyFaithful) (X : C) (e : f.obj X ≅ f.obj X)
Goal: ((hf.autMulEquivOfFullyFaithful X).symm e).inv = hf.preimage e.inv
-- CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_symm_apply_hom
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {f : CategoryTheory.Functor C D} (hf : f.FullyFaithful) (X : C) (e : f.obj X ≅ f.obj X)
Goal: ((hf.autMulEquivOfFullyFaithful X).symm e).hom = hf.preimage e.hom
-- CategoryTheory.IsSubterminal.def
theorem IsSubterminal.def : IsSubterminal A ↔ ∀ ⦃Z : C⦄ (f g : Z ⟶ A), f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C}
Goal: CategoryTheory.IsSubterminal A ↔ ∀ ⦃Z : C⦄ (f g : Z ⟶ A), f = g
-- CategoryTheory.IsSubterminal.mono_isTerminal_from
theorem IsSubterminal.mono_isTerminal_from (hA : IsSubterminal A) {T : C} (hT : IsTerminal T) :
    Mono (hT.from A) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C} (hA : CategoryTheory.IsSubterminal A) {T : C} (hT : CategoryTheory.Limits.IsTerminal T)
Goal: CategoryTheory.Mono (hT.from A)
-- CategoryTheory.IsSubterminal.mono_terminal_from
theorem IsSubterminal.mono_terminal_from [HasTerminal C] (hA : IsSubterminal A) :
    Mono (terminal.from A) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C} [CategoryTheory.Limits.HasTerminal C] (hA : CategoryTheory.IsSubterminal A)
Goal: CategoryTheory.Mono (CategoryTheory.Limits.terminal.from A)
-- CategoryTheory.isSubterminal_of_mono_isTerminal_from
theorem isSubterminal_of_mono_isTerminal_from {T : C} (hT : IsTerminal T) [Mono (hT.from A)] :
    IsSubterminal A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A T : C} (hT : CategoryTheory.Limits.IsTerminal T) [CategoryTheory.Mono (hT.from A)]
Goal: CategoryTheory.IsSubterminal A
-- CategoryTheory.isSubterminal_of_mono_terminal_from
theorem isSubterminal_of_mono_terminal_from [HasTerminal C] [Mono (terminal.from A)] :
    IsSubterminal A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C} [CategoryTheory.Limits.HasTerminal C] [CategoryTheory.Mono (CategoryTheory.Limits.terminal.from A)]
Goal: CategoryTheory.IsSubterminal A
-- CategoryTheory.isSubterminal_of_isTerminal
theorem isSubterminal_of_isTerminal {T : C} (hT : IsTerminal T) : IsSubterminal T 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T : C} (hT : CategoryTheory.Limits.IsTerminal T)
Goal: CategoryTheory.IsSubterminal T
-- CategoryTheory.isSubterminal_of_terminal
theorem isSubterminal_of_terminal [HasTerminal C] : IsSubterminal (⊤_ C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C]
Goal: CategoryTheory.IsSubterminal (⊤_ C)
-- CategoryTheory.IsSubterminal.isIso_diag
theorem IsSubterminal.isIso_diag (hA : IsSubterminal A) [HasBinaryProduct A A] : IsIso (diag A) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C} (hA : CategoryTheory.IsSubterminal A) [CategoryTheory.Limits.HasBinaryProduct A A]
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.diag A)
-- CategoryTheory.isSubterminal_of_isIso_diag
theorem isSubterminal_of_isIso_diag [HasBinaryProduct A A] [IsIso (diag A)] : IsSubterminal A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C} [CategoryTheory.Limits.HasBinaryProduct A A] [CategoryTheory.IsIso (CategoryTheory.Limits.diag A)]
Goal: CategoryTheory.IsSubterminal A
-- CategoryTheory.IsSubterminal.isoDiag_inv
@[simps!]
def IsSubterminal.isoDiag (hA : IsSubterminal A) [HasBinaryProduct A A] : A ⨯ A ≅ A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C} (hA : CategoryTheory.IsSubterminal A) [CategoryTheory.Limits.HasBinaryProduct A A]
Goal: hA.isoDiag.inv = CategoryTheory.Limits.diag A
-- CategoryTheory.IsSubterminal.isoDiag_hom
@[simps!]
def IsSubterminal.isoDiag (hA : IsSubterminal A) [HasBinaryProduct A A] : A ⨯ A ≅ A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : C} (hA : CategoryTheory.IsSubterminal A) [CategoryTheory.Limits.HasBinaryProduct A A]
Goal: hA.isoDiag.hom = CategoryTheory.inv (CategoryTheory.Limits.diag A)
-- CategoryTheory.subterminalInclusion_obj
@[simps!]
def subterminalInclusion : Subterminals C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.FullSubcategory fun A => CategoryTheory.IsSubterminal A)
Goal: (CategoryTheory.subterminalInclusion C).obj self = self.obj
-- CategoryTheory.subterminalInclusion_map
@[simps!]
def subterminalInclusion : Subterminals C ⥤ C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : CategoryTheory.InducedCategory C CategoryTheory.FullSubcategory.obj} (f : X ⟶ Y),
  (CategoryTheory.subterminalInclusion C).map f = f
-- CategoryTheory.subterminalsEquivMonoOverTerminal_functor_map
@[simps]
def subterminalsEquivMonoOverTerminal [HasTerminal C] : Subterminals C ≌ MonoOver (⊤_ C) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C]
Goal: ∀ {X Y : CategoryTheory.Subterminals C} (f : X ⟶ Y),
  (CategoryTheory.subterminalsEquivMonoOverTerminal C).functor.map f = CategoryTheory.MonoOver.homMk f ⋯
-- CategoryTheory.subterminalsEquivMonoOverTerminal_functor_obj_obj
@[simps]
def subterminalsEquivMonoOverTerminal [HasTerminal C] : Subterminals C ≌ MonoOver (⊤_ C) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C] (X : CategoryTheory.Subterminals C)
Goal: ((CategoryTheory.subterminalsEquivMonoOverTerminal C).functor.obj X).obj =
  CategoryTheory.Over.mk (CategoryTheory.Limits.terminal.from X.obj)
-- CategoryTheory.subterminalsEquivMonoOverTerminal_inverse_map
@[simps]
def subterminalsEquivMonoOverTerminal [HasTerminal C] : Subterminals C ≌ MonoOver (⊤_ C) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C]
Goal: ∀ {X Y : CategoryTheory.MonoOver (⊤_ C)} (f : X ⟶ Y),
  (CategoryTheory.subterminalsEquivMonoOverTerminal C).inverse.map f = f.left
-- CategoryTheory.subterminalsEquivMonoOverTerminal_inverse_obj_obj
@[simps]
def subterminalsEquivMonoOverTerminal [HasTerminal C] : Subterminals C ≌ MonoOver (⊤_ C) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C] (X : CategoryTheory.MonoOver (⊤_ C))
Goal: ((CategoryTheory.subterminalsEquivMonoOverTerminal C).inverse.obj X).obj = X.obj.left
-- CategoryTheory.subterminalsEquivMonoOverTerminal_unitIso
@[simps]
def subterminalsEquivMonoOverTerminal [HasTerminal C] : Subterminals C ≌ MonoOver (⊤_ C) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C]
Goal: (CategoryTheory.subterminalsEquivMonoOverTerminal C).unitIso =
  CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯
-- CategoryTheory.subterminalsEquivMonoOverTerminal_counitIso
@[simps]
def subterminalsEquivMonoOverTerminal [HasTerminal C] : Subterminals C ≌ MonoOver (⊤_ C) 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C]
Goal: (CategoryTheory.subterminalsEquivMonoOverTerminal C).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun X =>
      CategoryTheory.MonoOver.isoMk
        (CategoryTheory.Iso.refl
          (({ obj := fun X => { obj := X.obj.left, property := ⋯ }, map := fun {X Y} f => f.left, map_id := ⋯,
                        map_comp := ⋯ }.comp
                    {
                      obj := fun X =>
                        { obj := CategoryTheory.Over.mk (CategoryTheory.Limits.terminal.from X.obj), property := ⋯ },
                      map := fun {X Y} f => CategoryTheory.MonoOver.homMk f ⋯, map_id := ⋯, map_comp := ⋯ }).obj
                X).obj.left)
        ⋯)
    ⋯
-- CategoryTheory.subterminals_to_monoOver_terminal_comp_forget
@[simp]
theorem subterminals_to_monoOver_terminal_comp_forget [HasTerminal C] :
    (subterminalsEquivMonoOverTerminal C).functor ⋙ MonoOver.forget _ ⋙ Over.forget _ =
      subterminalInclusion C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C]
Goal: (CategoryTheory.subterminalsEquivMonoOverTerminal C).functor.comp
    ((CategoryTheory.MonoOver.forget (⊤_ C)).comp (CategoryTheory.Over.forget (⊤_ C))) =
  CategoryTheory.subterminalInclusion C
-- CategoryTheory.monoOver_terminal_to_subterminals_comp
@[simp]
theorem monoOver_terminal_to_subterminals_comp [HasTerminal C] :
    (subterminalsEquivMonoOverTerminal C).inverse ⋙ subterminalInclusion C =
      MonoOver.forget _ ⋙ Over.forget _ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C]
Goal: (CategoryTheory.subterminalsEquivMonoOverTerminal C).inverse.comp (CategoryTheory.subterminalInclusion C) =
  (CategoryTheory.MonoOver.forget (⊤_ C)).comp (CategoryTheory.Over.forget (⊤_ C))
-- CategoryTheory.sum.associator_obj_inl_inl
@[simp]
theorem associator_obj_inl_inl (X) : (associator C D E).obj (inl (inl X)) = inl X 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] (X : C)
Goal: (CategoryTheory.sum.associator C D E).obj (Sum.inl (Sum.inl X)) = Sum.inl X
-- CategoryTheory.sum.associator_obj_inl_inr
@[simp]
theorem associator_obj_inl_inr (X) : (associator C D E).obj (inl (inr X)) = inr (inl X) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] (X : D)
Goal: (CategoryTheory.sum.associator C D E).obj (Sum.inl (Sum.inr X)) = Sum.inr (Sum.inl X)
-- CategoryTheory.sum.associator_obj_inr
@[simp]
theorem associator_obj_inr (X) : (associator C D E).obj (inr X) = inr (inr X) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] (X : E)
Goal: (CategoryTheory.sum.associator C D E).obj (Sum.inr X) = Sum.inr (Sum.inr X)
-- CategoryTheory.sum.associator_map_inl_inl
@[simp]
theorem associator_map_inl_inl {X Y : C} (f : inl (inl X) ⟶ inl (inl Y)) :
    (associator C D E).map f = f 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] {X Y : C} (f : Sum.inl (Sum.inl X) ⟶ Sum.inl (Sum.inl Y))
Goal: (CategoryTheory.sum.associator C D E).map f = f
-- CategoryTheory.sum.associator_map_inl_inr
@[simp]
theorem associator_map_inl_inr {X Y : D} (f : inl (inr X) ⟶ inl (inr Y)) :
    (associator C D E).map f = f 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] {X Y : D} (f : Sum.inl (Sum.inr X) ⟶ Sum.inl (Sum.inr Y))
Goal: (CategoryTheory.sum.associator C D E).map f = f
-- CategoryTheory.sum.associator_map_inr
@[simp]
theorem associator_map_inr {X Y : E} (f : inr X ⟶ inr Y) : (associator C D E).map f = f 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] {X Y : E} (f : Sum.inr X ⟶ Sum.inr Y)
Goal: (CategoryTheory.sum.associator C D E).map f = f
-- CategoryTheory.sum.inverseAssociator_obj_inl
@[simp]
theorem inverseAssociator_obj_inl (X) : (inverseAssociator C D E).obj (inl X) = inl (inl X) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] (X : C)
Goal: (CategoryTheory.sum.inverseAssociator C D E).obj (Sum.inl X) = Sum.inl (Sum.inl X)