ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.CostructuredArrow.IsUniversal.uniq
theorem uniq (h : IsUniversal f) (η : g ⟶ f) : η = h.from g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f g : CategoryTheory.CostructuredArrow S T} (h : f.IsUniversal) (η : g ⟶ f)
Goal: η = CategoryTheory.Limits.IsTerminal.from h g
-- CategoryTheory.CostructuredArrow.IsUniversal.fac
@[reassoc (attr := simp)]
theorem fac (h : IsUniversal f) (g : CostructuredArrow S T) :
    S.map (h.lift g) ≫ f.hom = g.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f : CategoryTheory.CostructuredArrow S T} (h : f.IsUniversal) (g : CategoryTheory.CostructuredArrow S T)
Goal: CategoryTheory.CategoryStruct.comp (S.map (h.lift g)) f.hom = g.hom
-- CategoryTheory.CostructuredArrow.IsUniversal.hom_desc
theorem hom_desc (h : IsUniversal f) {c : C} (η : c ⟶ f.left) :
    η = h.lift (mk <| S.map η ≫ f.hom) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f : CategoryTheory.CostructuredArrow S T} (h : f.IsUniversal) {c : C} (η : c ⟶ f.left)
Goal: η = h.lift (CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (S.map η) f.hom))
-- CategoryTheory.CostructuredArrow.IsUniversal.hom_ext
theorem hom_ext (h : IsUniversal f) {c : C} {η η' : c ⟶ f.left}
    (w : S.map η ≫ f.hom = S.map η' ≫ f.hom) : η = η' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f : CategoryTheory.CostructuredArrow S T} (h : f.IsUniversal) {c : C} {η η' : c ⟶ f.left} (w : CategoryTheory.CategoryStruct.comp (S.map η) f.hom = CategoryTheory.CategoryStruct.comp (S.map η') f.hom)
Goal: η = η'
-- CategoryTheory.CostructuredArrow.IsUniversal.existsUnique
theorem existsUnique (h : IsUniversal f) (g : CostructuredArrow S T) :
    ∃! η : g.left ⟶ f.left, S.map η ≫ f.hom = g.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {T : D} {S : CategoryTheory.Functor C D} {f : CategoryTheory.CostructuredArrow S T} (h : f.IsUniversal) (g : CategoryTheory.CostructuredArrow S T)
Goal: ∃! η, CategoryTheory.CategoryStruct.comp (S.map η) f.hom = g.hom
-- CategoryTheory.Functor.toStructuredArrow_map
@[simps]
def toStructuredArrow (G : E ⥤ C) (X : D) (F : C ⥤ D) (f : (Y : E) → X ⟶ F.obj (G.obj Y))
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) : E ⥤ StructuredArrow X 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] (G : CategoryTheory.Functor E C) (X : D) (F : CategoryTheory.Functor C D) (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map (G.map g)) = f Z)
Goal: ∀ {X_1 Y : E} (g : X_1 ⟶ Y), (G.toStructuredArrow X F f h).map g = CategoryTheory.StructuredArrow.homMk (G.map g) ⋯
-- CategoryTheory.Functor.toStructuredArrow_obj
@[simps]
def toStructuredArrow (G : E ⥤ C) (X : D) (F : C ⥤ D) (f : (Y : E) → X ⟶ F.obj (G.obj Y))
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) : E ⥤ StructuredArrow X 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] (G : CategoryTheory.Functor E C) (X : D) (F : CategoryTheory.Functor C D) (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map (G.map g)) = f Z) (Y : E)
Goal: (G.toStructuredArrow X F f h).obj Y = CategoryTheory.StructuredArrow.mk (f Y)
-- CategoryTheory.Functor.toStructuredArrow_comp_proj
@[simp]
lemma toStructuredArrow_comp_proj (G : E ⥤ C) (X : D) (F : C ⥤ D)
    (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) :
    G.toStructuredArrow X F f h ⋙ StructuredArrow.proj _ _ = G 
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] (G : CategoryTheory.Functor E C) (X : D) (F : CategoryTheory.Functor C D) (f : (Y : E) → X ⟶ F.obj (G.obj Y)) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (f Y) (F.map (G.map g)) = f Z)
Goal: (G.toStructuredArrow X F f ⋯).comp (CategoryTheory.StructuredArrow.proj X F) = G
-- CategoryTheory.Functor.toCostructuredArrow_obj
@[simps]
def toCostructuredArrow (G : E ⥤ C) (F : C ⥤ D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X)
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) : E ⥤ CostructuredArrow F 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] (G : CategoryTheory.Functor E C) (F : CategoryTheory.Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y) (Y : E)
Goal: (G.toCostructuredArrow F X f h).obj Y = CategoryTheory.CostructuredArrow.mk (f Y)
-- CategoryTheory.Functor.toCostructuredArrow_map
@[simps]
def toCostructuredArrow (G : E ⥤ C) (F : C ⥤ D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X)
    (h : ∀ {Y Z : E} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) : E ⥤ CostructuredArrow F 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] (G : CategoryTheory.Functor E C) (F : CategoryTheory.Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y)
Goal: ∀ {X_1 Y : E} (g : X_1 ⟶ Y), (G.toCostructuredArrow F X f h).map g = CategoryTheory.CostructuredArrow.homMk (G.map g) ⋯
-- CategoryTheory.Functor.toCostructuredArrow_comp_proj
@[simp]
lemma toCostructuredArrow_comp_proj (G : E ⥤ C) (F : C ⥤ D) (X : D)
    (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) :
    G.toCostructuredArrow F X f h ⋙ CostructuredArrow.proj _ _ = G 
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] (G : CategoryTheory.Functor E C) (F : CategoryTheory.Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X) (h : ∀ {Y Z : E} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F.map (G.map g)) (f Z) = f Y)
Goal: (G.toCostructuredArrow F X f ⋯).comp (CategoryTheory.CostructuredArrow.proj F X) = G
-- CategoryTheory.StructuredArrow.toCostructuredArrow_obj
@[simps]
def toCostructuredArrow (F : C ⥤ D) (d : D) :
    (StructuredArrow d F)ᵒᵖ ⥤ CostructuredArrow F.op (op d) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (d : D) (X : (CategoryTheory.StructuredArrow d F)ᵒᵖ)
Goal: (CategoryTheory.StructuredArrow.toCostructuredArrow F d).obj X =
  CategoryTheory.CostructuredArrow.mk (Opposite.unop X).hom.op
-- CategoryTheory.StructuredArrow.toCostructuredArrow_map
@[simps]
def toCostructuredArrow (F : C ⥤ D) (d : D) :
    (StructuredArrow d F)ᵒᵖ ⥤ CostructuredArrow F.op (op d) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (d : D)
Goal: ∀ {X Y : (CategoryTheory.StructuredArrow d F)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.toCostructuredArrow F d).map f =
    CategoryTheory.CostructuredArrow.homMk f.unop.right.op ⋯
-- CategoryTheory.StructuredArrow.toCostructuredArrow'_map
@[simps]
def toCostructuredArrow' (F : C ⥤ D) (d : D) :
    (StructuredArrow (op d) F.op)ᵒᵖ ⥤ CostructuredArrow F d 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (d : D)
Goal: ∀ {X Y : (CategoryTheory.StructuredArrow (Opposite.op d) F.op)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.toCostructuredArrow' F d).map f =
    CategoryTheory.CostructuredArrow.homMk f.unop.right.unop ⋯
-- CategoryTheory.StructuredArrow.toCostructuredArrow'_obj
@[simps]
def toCostructuredArrow' (F : C ⥤ D) (d : D) :
    (StructuredArrow (op d) F.op)ᵒᵖ ⥤ CostructuredArrow F d 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (d : D) (X : (CategoryTheory.StructuredArrow (Opposite.op d) F.op)ᵒᵖ)
Goal: (CategoryTheory.StructuredArrow.toCostructuredArrow' F d).obj X =
  CategoryTheory.CostructuredArrow.mk (Opposite.unop X).hom.unop
-- CategoryTheory.CostructuredArrow.toStructuredArrow_obj
@[simps]
def toStructuredArrow (F : C ⥤ D) (d : D) :
    (CostructuredArrow F d)ᵒᵖ ⥤ StructuredArrow (op d) F.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (d : D) (X : (CategoryTheory.CostructuredArrow F d)ᵒᵖ)
Goal: (CategoryTheory.CostructuredArrow.toStructuredArrow F d).obj X =
  CategoryTheory.StructuredArrow.mk (Opposite.unop X).hom.op
-- CategoryTheory.CostructuredArrow.toStructuredArrow_map
@[simps]
def toStructuredArrow (F : C ⥤ D) (d : D) :
    (CostructuredArrow F d)ᵒᵖ ⥤ StructuredArrow (op d) F.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (d : D)
Goal: ∀ {X Y : (CategoryTheory.CostructuredArrow F d)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.CostructuredArrow.toStructuredArrow F d).map f = CategoryTheory.StructuredArrow.homMk f.unop.left.op ⋯
-- CategoryTheory.CostructuredArrow.toStructuredArrow'_map
@[simps]
def toStructuredArrow' (F : C ⥤ D) (d : D) :
    (CostructuredArrow F.op (op d))ᵒᵖ ⥤ StructuredArrow d F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (d : D)
Goal: ∀ {X Y : (CategoryTheory.CostructuredArrow F.op (Opposite.op d))ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.CostructuredArrow.toStructuredArrow' F d).map f =
    CategoryTheory.StructuredArrow.homMk f.unop.left.unop ⋯
-- CategoryTheory.CostructuredArrow.toStructuredArrow'_obj
@[simps]
def toStructuredArrow' (F : C ⥤ D) (d : D) :
    (CostructuredArrow F.op (op d))ᵒᵖ ⥤ StructuredArrow d F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (d : D) (X : (CategoryTheory.CostructuredArrow F.op (Opposite.op d))ᵒᵖ)
Goal: (CategoryTheory.CostructuredArrow.toStructuredArrow' F d).obj X =
  CategoryTheory.StructuredArrow.mk (Opposite.unop X).hom.unop
-- CategoryTheory.MorphismProperty.MapFactorizationData.hp
structure MapFactorizationData {X Y : C} (f : X ⟶ Y) where
    Z : C
    i : X ⟶ Z
    p : Z ⟶ Y
  fac : i ≫ p = f := by aesop_cat
  hi : W₁ i
  hp : W₂ p
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} {X Y : C} {f : X ⟶ Y} (self : W₁.MapFactorizationData W₂ f)
Goal: W₂ self.p
-- CategoryTheory.MorphismProperty.MapFactorizationData.hi
structure MapFactorizationData {X Y : C} (f : X ⟶ Y) where
    Z : C
    i : X ⟶ Z
    p : Z ⟶ Y
  fac : i ≫ p = f := by aesop_cat
  hi : W₁ i
  hp : W₂ p
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} {X Y : C} {f : X ⟶ Y} (self : W₁.MapFactorizationData W₂ f)
Goal: W₁ self.i
-- CategoryTheory.MorphismProperty.MapFactorizationData.fac
structure MapFactorizationData {X Y : C} (f : X ⟶ Y) where
    Z : C
    i : X ⟶ Z
    p : Z ⟶ Y
  fac : i ≫ p = f := by aesop_cat
  hi : W₁ i
  hp : W₂ p
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} {X Y : C} {f : X ⟶ Y} (self : W₁.MapFactorizationData W₂ f)
Goal: CategoryTheory.CategoryStruct.comp self.i self.p = f
-- CategoryTheory.MorphismProperty.HasFactorization.nonempty_mapFactorizationData
class HasFactorization : Prop where
  nonempty_mapFactorizationData {X Y : C} (f : X ⟶ Y) : Nonempty (MapFactorizationData W₁ W₂ f)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} [self : W₁.HasFactorization W₂] {X Y : C} (f : X ⟶ Y)
Goal: Nonempty (W₁.MapFactorizationData W₂ f)
-- CategoryTheory.MorphismProperty.comp_eq_top_iff
lemma comp_eq_top_iff : W₁.comp W₂ = ⊤ ↔ HasFactorization W₁ W₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (W₁ W₂ : CategoryTheory.MorphismProperty C)
Goal: W₁.comp W₂ = ⊤ ↔ W₁.HasFactorization W₂
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.hi
structure FunctorialFactorizationData where
    Z : Arrow C ⥤ C
    i : Arrow.leftFunc ⟶ Z
    p : Z ⟶ Arrow.rightFunc
  fac : i ≫ p = Arrow.leftToRight := by aesop_cat
  hi (f : Arrow C) : W₁ (i.app f)
  hp (f : Arrow C) : W₂ (p.app f)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (self : W₁.FunctorialFactorizationData W₂) (f : CategoryTheory.Arrow C)
Goal: W₁ (self.i.app f)
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.fac
structure FunctorialFactorizationData where
    Z : Arrow C ⥤ C
    i : Arrow.leftFunc ⟶ Z
    p : Z ⟶ Arrow.rightFunc
  fac : i ≫ p = Arrow.leftToRight := by aesop_cat
  hi (f : Arrow C) : W₁ (i.app f)
  hp (f : Arrow C) : W₂ (p.app f)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (self : W₁.FunctorialFactorizationData W₂)
Goal: CategoryTheory.CategoryStruct.comp self.i self.p = CategoryTheory.Arrow.leftToRight
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.hp
structure FunctorialFactorizationData where
    Z : Arrow C ⥤ C
    i : Arrow.leftFunc ⟶ Z
    p : Z ⟶ Arrow.rightFunc
  fac : i ≫ p = Arrow.leftToRight := by aesop_cat
  hi (f : Arrow C) : W₁ (i.app f)
  hp (f : Arrow C) : W₂ (p.app f)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (self : W₁.FunctorialFactorizationData W₂) (f : CategoryTheory.Arrow C)
Goal: W₂ (self.p.app f)
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.fac_app
@[reassoc (attr := simp)]
lemma fac_app {f : Arrow C} : data.i.app f ≫ data.p.app f = f.hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (data : W₁.FunctorialFactorizationData W₂) {f : CategoryTheory.Arrow C}
Goal: CategoryTheory.CategoryStruct.comp (data.i.app f) (data.p.app f) = f.hom
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.i_mapZ
@[reassoc (attr := simp)]
lemma i_mapZ :
    (data.factorizationData f).i ≫ data.mapZ φ = φ.left ≫ (data.factorizationData g).i 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'} (φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g)
Goal: CategoryTheory.CategoryStruct.comp (data.factorizationData f).i (data.mapZ φ) =
  CategoryTheory.CategoryStruct.comp φ.left (data.factorizationData g).i
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_p
@[reassoc (attr := simp)]
lemma mapZ_p :
    data.mapZ φ ≫ (data.factorizationData g).p = (data.factorizationData f).p ≫ φ.right 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'} (φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g)
Goal: CategoryTheory.CategoryStruct.comp (data.mapZ φ) (data.factorizationData g).p =
  CategoryTheory.CategoryStruct.comp (data.factorizationData f).p φ.right
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_id
@[simp]
lemma mapZ_id : data.mapZ (𝟙 (Arrow.mk f)) = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (data : W₁.FunctorialFactorizationData W₂) {X Y : C} (f : X ⟶ Y)
Goal: data.mapZ (CategoryTheory.CategoryStruct.id (CategoryTheory.Arrow.mk f)) =
  CategoryTheory.CategoryStruct.id (data.factorizationData f).Z
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_comp
@[reassoc, simp]
lemma mapZ_comp {X'' Y'' : C} {h : X'' ⟶ Y''} (ψ : Arrow.mk g ⟶ Arrow.mk h) :
    data.mapZ (φ ≫ ψ) = data.mapZ φ ≫ data.mapZ ψ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'} (φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {X'' Y'' : C} {h : X'' ⟶ Y''} (ψ : CategoryTheory.Arrow.mk g ⟶ CategoryTheory.Arrow.mk h)
Goal: data.mapZ (CategoryTheory.CategoryStruct.comp φ ψ) = CategoryTheory.CategoryStruct.comp (data.mapZ φ) (data.mapZ ψ)
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory.Z_map_app
@[simps]
def functorCategory.Z : Arrow (J ⥤ C) ⥤ J ⥤ C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (data : W₁.FunctorialFactorizationData W₂) (J : Type u_2) [CategoryTheory.Category.{u_4, u_2} J]
Goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Functor J C)} (τ : X ⟶ Y) (j : J),
  ((CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory.Z data J).map τ).app j =
    data.mapZ { left := τ.left.app j, right := τ.right.app j, w := ⋯ }
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory.Z_obj_obj
@[simps]
def functorCategory.Z : Arrow (J ⥤ C) ⥤ J ⥤ C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (data : W₁.FunctorialFactorizationData W₂) (J : Type u_2) [CategoryTheory.Category.{u_4, u_2} J] (f : CategoryTheory.Arrow (CategoryTheory.Functor J C)) (j : J)
Goal: ((CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory.Z data J).obj f).obj j =
  (data.factorizationData (f.hom.app j)).Z
-- CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory.Z_obj_map
@[simps]
def functorCategory.Z : Arrow (J ⥤ C) ⥤ J ⥤ C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} (data : W₁.FunctorialFactorizationData W₂) (J : Type u_2) [CategoryTheory.Category.{u_4, u_2} J] (f : CategoryTheory.Arrow (CategoryTheory.Functor J C))
Goal: ∀ {X Y : J} (φ : X ⟶ Y),
  ((CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory.Z data J).obj f).map φ =
    data.mapZ { left := f.left.map φ, right := f.right.map φ, w := ⋯ }
-- CategoryTheory.MorphismProperty.HasFunctorialFactorization.nonempty_functorialFactorizationData
class HasFunctorialFactorization : Prop where
  nonempty_functorialFactorizationData : Nonempty (FunctorialFactorizationData W₁ W₂)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} [self : W₁.HasFunctorialFactorization W₂]
Goal: Nonempty (W₁.FunctorialFactorizationData W₂)
-- CategoryTheory.FreeMonoidalCategory.mk_comp
@[simp]
theorem mk_comp {X Y Z : F C} (f : X ⟶ᵐ Y) (g : Y ⟶ᵐ Z) :
    ⟦f.comp g⟧ = @CategoryStruct.comp (F C) _ _ _ _ ⟦f⟧ ⟦g⟧ 
Arguments: {C : Type u} {X Y Z : CategoryTheory.FreeMonoidalCategory C} (f : X.Hom Y) (g : Y.Hom Z)
Goal: ⟦f.comp g⟧ = CategoryTheory.CategoryStruct.comp ⟦f⟧ ⟦g⟧
-- CategoryTheory.FreeMonoidalCategory.mk_tensor
@[simp]
theorem mk_tensor {X₁ Y₁ X₂ Y₂ : F C} (f : X₁ ⟶ᵐ Y₁) (g : X₂ ⟶ᵐ Y₂) :
    ⟦f.tensor g⟧ = @MonoidalCategory.tensorHom (F C) _ _ _ _ _ _ ⟦f⟧ ⟦g⟧ 
Arguments: {C : Type u} {X₁ Y₁ X₂ Y₂ : CategoryTheory.FreeMonoidalCategory C} (f : X₁.Hom Y₁) (g : X₂.Hom Y₂)
Goal: ⟦f.tensor g⟧ = CategoryTheory.MonoidalCategory.tensorHom ⟦f⟧ ⟦g⟧
-- CategoryTheory.FreeMonoidalCategory.mk_whiskerLeft
@[simp]
theorem mk_whiskerLeft (X : F C) {Y₁ Y₂ : F C} (f : Y₁ ⟶ᵐ Y₂) :
    ⟦f.whiskerLeft X⟧ = MonoidalCategory.whiskerLeft (C := F C) (X := X) (f := ⟦f⟧) 
Arguments: {C : Type u} (X : CategoryTheory.FreeMonoidalCategory C) {Y₁ Y₂ : CategoryTheory.FreeMonoidalCategory C} (f : Y₁.Hom Y₂)
Goal: ⟦CategoryTheory.FreeMonoidalCategory.Hom.whiskerLeft X f⟧ = CategoryTheory.MonoidalCategory.whiskerLeft X ⟦f⟧
-- CategoryTheory.FreeMonoidalCategory.mk_whiskerRight
@[simp]
theorem mk_whiskerRight {X₁ X₂ : F C} (f : X₁ ⟶ᵐ X₂) (Y : F C) :
    ⟦f.whiskerRight Y⟧ = MonoidalCategory.whiskerRight (C := F C) (f := ⟦f⟧) (Y := Y) 
Arguments: {C : Type u} {X₁ X₂ : CategoryTheory.FreeMonoidalCategory C} (f : X₁.Hom X₂) (Y : CategoryTheory.FreeMonoidalCategory C)
Goal: ⟦f.whiskerRight Y⟧ = CategoryTheory.MonoidalCategory.whiskerRight ⟦f⟧ Y
-- CategoryTheory.FreeMonoidalCategory.mk_id
@[simp]
theorem mk_id {X : F C} : ⟦Hom.id X⟧ = 𝟙 X 
Arguments: {C : Type u} {X : CategoryTheory.FreeMonoidalCategory C}
Goal: ⟦CategoryTheory.FreeMonoidalCategory.Hom.id X⟧ = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.FreeMonoidalCategory.mk_α_hom
@[simp]
theorem mk_α_hom {X Y Z : F C} : ⟦Hom.α_hom X Y Z⟧ = (α_ X Y Z).hom 
Arguments: {C : Type u} {X Y Z : CategoryTheory.FreeMonoidalCategory C}
Goal: ⟦CategoryTheory.FreeMonoidalCategory.Hom.α_hom X Y Z⟧ = (CategoryTheory.MonoidalCategory.associator X Y Z).hom
-- CategoryTheory.FreeMonoidalCategory.mk_α_inv
@[simp]
theorem mk_α_inv {X Y Z : F C} : ⟦Hom.α_inv X Y Z⟧ = (α_ X Y Z).inv 
Arguments: {C : Type u} {X Y Z : CategoryTheory.FreeMonoidalCategory C}
Goal: ⟦CategoryTheory.FreeMonoidalCategory.Hom.α_inv X Y Z⟧ = (CategoryTheory.MonoidalCategory.associator X Y Z).inv
-- CategoryTheory.FreeMonoidalCategory.mk_ρ_hom
@[simp]
theorem mk_ρ_hom {X : F C} : ⟦Hom.ρ_hom X⟧ = (ρ_ X).hom 
Arguments: {C : Type u} {X : CategoryTheory.FreeMonoidalCategory C}
Goal: ⟦CategoryTheory.FreeMonoidalCategory.Hom.ρ_hom X⟧ = (CategoryTheory.MonoidalCategory.rightUnitor X).hom
-- CategoryTheory.FreeMonoidalCategory.mk_ρ_inv
@[simp]
theorem mk_ρ_inv {X : F C} : ⟦Hom.ρ_inv X⟧ = (ρ_ X).inv 
Arguments: {C : Type u} {X : CategoryTheory.FreeMonoidalCategory C}
Goal: ⟦CategoryTheory.FreeMonoidalCategory.Hom.ρ_inv X⟧ = (CategoryTheory.MonoidalCategory.rightUnitor X).inv
-- CategoryTheory.FreeMonoidalCategory.mk_l_hom
@[simp]
theorem mk_l_hom {X : F C} : ⟦Hom.l_hom X⟧ = (λ_ X).hom 
Arguments: {C : Type u} {X : CategoryTheory.FreeMonoidalCategory C}
Goal: ⟦CategoryTheory.FreeMonoidalCategory.Hom.l_hom X⟧ = (CategoryTheory.MonoidalCategory.leftUnitor X).hom
-- CategoryTheory.FreeMonoidalCategory.mk_l_inv
@[simp]
theorem mk_l_inv {X : F C} : ⟦Hom.l_inv X⟧ = (λ_ X).inv 
Arguments: {C : Type u} {X : CategoryTheory.FreeMonoidalCategory C}
Goal: ⟦CategoryTheory.FreeMonoidalCategory.Hom.l_inv X⟧ = (CategoryTheory.MonoidalCategory.leftUnitor X).inv
-- CategoryTheory.FreeMonoidalCategory.tensor_eq_tensor
@[simp]
theorem tensor_eq_tensor {X Y : F C} : X.tensor Y = X ⊗ Y 
Arguments: {C : Type u} {X Y : CategoryTheory.FreeMonoidalCategory C}
Goal: X.tensor Y = CategoryTheory.MonoidalCategory.tensorObj X Y
-- CategoryTheory.FreeMonoidalCategory.unit_eq_unit
@[simp]
theorem unit_eq_unit : FreeMonoidalCategory.unit = 𝟙_ (F C) 
Arguments: {C : Type u}
Goal: CategoryTheory.FreeMonoidalCategory.unit = 𝟙_ (CategoryTheory.FreeMonoidalCategory C)