ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Functorial.map_comp'
class Functorial (F : C → D) : Type max v₁ v₂ u₁ u₂ where
    map' : ∀ {X Y : C}, (X ⟶ Y) → (F X ⟶ F Y)
    map_id' : ∀ X : C, map' (𝟙 X) = 𝟙 (F X) := by aesop_cat
    map_comp' : ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), map' (f ≫ g) = map' f ≫ map' g := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C → D} [self : CategoryTheory.Functorial F] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.Functorial.map' (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Functorial.map' f) (CategoryTheory.Functorial.map' g)
-- CategoryTheory.Functorial.map_id'
class Functorial (F : C → D) : Type max v₁ v₂ u₁ u₂ where
    map' : ∀ {X Y : C}, (X ⟶ Y) → (F X ⟶ F Y)
    map_id' : ∀ X : C, map' (𝟙 X) = 𝟙 (F X) := by aesop_cat
    map_comp' : ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), map' (f ≫ g) = map' f ≫ map' g := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C → D} [self : CategoryTheory.Functorial F] (X : C)
Goal: CategoryTheory.Functorial.map' (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (F X)
-- CategoryTheory.map'_as_map
@[simp]
theorem map'_as_map {F : C → D} [Functorial.{v₁, v₂} F] {X Y : C} {f : X ⟶ Y} :
    Functorial.map'.{v₁, v₂} f = map F f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C → D} [CategoryTheory.Functorial F] {X Y : C} {f : X ⟶ Y}
Goal: CategoryTheory.Functorial.map' f = CategoryTheory.map F f
-- CategoryTheory.Functorial.map_id
@[simp]
theorem Functorial.map_id {F : C → D} [Functorial.{v₁, v₂} F] {X : C} : map F (𝟙 X) = 𝟙 (F X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C → D} [CategoryTheory.Functorial F] {X : C}
Goal: CategoryTheory.map F (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (F X)
-- CategoryTheory.Functorial.map_comp
@[simp]
theorem Functorial.map_comp {F : C → D} [Functorial.{v₁, v₂} F] {X Y Z : C} {f : X ⟶ Y}
    {g : Y ⟶ Z} : map F (f ≫ g) = map F f ≫ map F g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C → D} [CategoryTheory.Functorial F] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: CategoryTheory.map F (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.map F f) (CategoryTheory.map F g)
-- CategoryTheory.map_functorial_obj
@[simp]
theorem map_functorial_obj (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) : map F.obj f = F.map f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.map F.obj f = F.map f
-- CategoryTheory.Functor.const_obj_obj
@[simps]
def const : C ⥤ J ⥤ C 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] (X : C)
Goal: ∀ (x : J), ((CategoryTheory.Functor.const J).obj X).obj x = X
-- CategoryTheory.Functor.const_map_app
@[simps]
def const : C ⥤ J ⥤ C 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y) (x : J), ((CategoryTheory.Functor.const J).map f).app x = f
-- CategoryTheory.Functor.const_obj_map
@[simps]
def const : C ⥤ J ⥤ C 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] (X : C)
Goal: ∀ {X_1 Y : J} (x : X_1 ⟶ Y), ((CategoryTheory.Functor.const J).obj X).map x = 𝟙 X
-- CategoryTheory.Functor.const.opObjOp_inv_app
@[simps]
def opObjOp (X : C) : (const Jᵒᵖ).obj (op X) ≅ ((const J).obj X).op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] (X : C) (j : Jᵒᵖ)
Goal: (CategoryTheory.Functor.const.opObjOp X).inv.app j = 𝟙 (((CategoryTheory.Functor.const J).obj X).op.obj j)
-- CategoryTheory.Functor.const.opObjOp_hom_app
@[simps]
def opObjOp (X : C) : (const Jᵒᵖ).obj (op X) ≅ ((const J).obj X).op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] (X : C) (j : Jᵒᵖ)
Goal: (CategoryTheory.Functor.const.opObjOp X).hom.app j = 𝟙 (((CategoryTheory.Functor.const Jᵒᵖ).obj (Opposite.op X)).obj j)
-- CategoryTheory.Functor.const.opObjUnop_hom_app
@[simp]
theorem opObjUnop_hom_app (X : Cᵒᵖ) (j : Jᵒᵖ) : (opObjUnop.{v₁, v₂} X).hom.app j = 𝟙 _ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] (X : Cᵒᵖ) (j : Jᵒᵖ)
Goal: (CategoryTheory.Functor.const.opObjUnop X).hom.app j =
  𝟙 (((CategoryTheory.Functor.const Jᵒᵖ).obj (Opposite.unop X)).obj j)
-- CategoryTheory.Functor.const.opObjUnop_inv_app
@[simp]
theorem opObjUnop_inv_app (X : Cᵒᵖ) (j : Jᵒᵖ) : (opObjUnop.{v₁, v₂} X).inv.app j = 𝟙 _ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] (X : Cᵒᵖ) (j : Jᵒᵖ)
Goal: (CategoryTheory.Functor.const.opObjUnop X).inv.app j = 𝟙 (((CategoryTheory.Functor.const J).obj X).leftOp.obj j)
-- CategoryTheory.Functor.const.unop_functor_op_obj_map
@[simp]
theorem unop_functor_op_obj_map (X : Cᵒᵖ) {j₁ j₂ : J} (f : j₁ ⟶ j₂) :
    (unop ((Functor.op (const J)).obj X)).map f = 𝟙 (unop X) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] (X : Cᵒᵖ) {j₁ j₂ : J} (f : j₁ ⟶ j₂)
Goal: (Opposite.unop ((CategoryTheory.Functor.const J).op.obj X)).map f = 𝟙 (Opposite.unop X)
-- CategoryTheory.Functor.constComp_inv_app
@[simps]
def constComp (X : C) (F : C ⥤ D) : (const J).obj X ⋙ F ≅ (const J).obj (F.obj X) 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] (X : C) (F : C ⥤ D)
Goal: ∀ (x : J),
  (CategoryTheory.Functor.constComp J X F).inv.app x = 𝟙 (((CategoryTheory.Functor.const J).obj (F.obj X)).obj x)
-- CategoryTheory.Functor.constComp_hom_app
@[simps]
def constComp (X : C) (F : C ⥤ D) : (const J).obj X ⋙ F ≅ (const J).obj (F.obj X) 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] (X : C) (F : C ⥤ D)
Goal: ∀ (x : J), (CategoryTheory.Functor.constComp J X F).hom.app x = 𝟙 (((CategoryTheory.Functor.const J).obj X ⋙ F).obj x)
-- CategoryTheory.Functor.compConstIso_inv_app_app
@[simps!]
def compConstIso (F : C ⥤ D) :
    F ⋙ Functor.const J ≅ Functor.const J ⋙ (whiskeringRight J C D).obj F 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] (F : C ⥤ D) (X : C)
Goal: ∀ (X_1 : J), ((CategoryTheory.Functor.compConstIso J F).inv.app X).app X_1 = 𝟙 (F.obj X)
-- CategoryTheory.Functor.compConstIso_hom_app_app
@[simps!]
def compConstIso (F : C ⥤ D) :
    F ⋙ Functor.const J ≅ Functor.const J ⋙ (whiskeringRight J C D).obj F 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] (F : C ⥤ D) (X : C)
Goal: ∀ (X_1 : J), ((CategoryTheory.Functor.compConstIso J F).hom.app X).app X_1 = 𝟙 (F.obj X)
-- CategoryTheory.Functor.hom_map
@[simps]
def hom : Cᵒᵖ × C ⥤ Type v 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : Cᵒᵖ × C} (f : X ⟶ Y) (h : Opposite.unop X.1 ⟶ X.2), (CategoryTheory.Functor.hom C).map f h = f.1.unop ≫ h ≫ f.2
-- CategoryTheory.Functor.hom_obj
@[simps]
def hom : Cᵒᵖ × C ⥤ Type v 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (p : Cᵒᵖ × C)
Goal: (CategoryTheory.Functor.hom C).obj p = (Opposite.unop p.1 ⟶ p.2)
-- CategoryTheory.Functor.OfSequence.congr_f
lemma congr_f (i j : ℕ) (h : i = j) :
    f i = eqToHom (by rw [h]) ≫ f j ≫ eqToHom (by rw [h]) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)) (i j : ℕ) (h : i = j)
Goal: f i =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp (f j) (CategoryTheory.eqToHom ⋯))
-- CategoryTheory.Functor.OfSequence.map_id
lemma map_id (i : ℕ) : map f i i (by omega) = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)) (i : ℕ)
Goal: CategoryTheory.Functor.OfSequence.map f i i ⋯ = CategoryTheory.CategoryStruct.id (X i)
-- CategoryTheory.Functor.OfSequence.map_le_succ
lemma map_le_succ (i : ℕ) : map f i (i + 1) (by omega) = f i 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)) (i : ℕ)
Goal: CategoryTheory.Functor.OfSequence.map f i (i + 1) ⋯ = f i
-- CategoryTheory.Functor.OfSequence.map_comp
@[reassoc]
lemma map_comp (i j k : ℕ) (hij : i ≤ j) (hjk : j ≤ k) :
    map f i k (hij.trans hjk) = map f i j hij ≫ map f j k hjk 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)) (i j k : ℕ) (hij : i ≤ j) (hjk : j ≤ k)
Goal: CategoryTheory.Functor.OfSequence.map f i k ⋯ =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OfSequence.map f i j hij)
    (CategoryTheory.Functor.OfSequence.map f j k hjk)
-- CategoryTheory.Functor.ofSequence_obj
@[simps obj]
def ofSequence : ℕ ⥤ C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1))
Goal: ∀ (a : ℕ), (CategoryTheory.Functor.ofSequence f).obj a = X a
-- CategoryTheory.Functor.ofSequence_map_homOfLE_succ
@[simp]
lemma ofSequence_map_homOfLE_succ (n : ℕ) :
    (ofSequence f).map (homOfLE (Nat.le_add_right n 1)) = f n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)) (n : ℕ)
Goal: (CategoryTheory.Functor.ofSequence f).map (CategoryTheory.homOfLE ⋯) = f n
-- CategoryTheory.NatTrans.ofSequence_app
@[simps app]
def ofSequence : F ⟶ G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.Functor ℕ C} (app : (n : ℕ) → F.obj n ⟶ G.obj n) (naturality :
  ∀ (n : ℕ),
    CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.homOfLE ⋯)) (app (n + 1)) =
      CategoryTheory.CategoryStruct.comp (app n) (G.map (CategoryTheory.homOfLE ⋯))) (n : ℕ)
Goal: (CategoryTheory.NatTrans.ofSequence app naturality).app n = app n
-- CategoryTheory.Functor.PreservesMonomorphisms.preserves
class PreservesMonomorphisms (F : C ⥤ D) : Prop where
    preserves : ∀ {X Y : C} (f : X ⟶ Y) [Mono f], Mono (F.map f)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C ⥤ D} [self : F.PreservesMonomorphisms] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.Mono (F.map f)
-- CategoryTheory.Functor.PreservesEpimorphisms.preserves
class PreservesEpimorphisms (F : C ⥤ D) : Prop where
    preserves : ∀ {X Y : C} (f : X ⟶ Y) [Epi f], Epi (F.map f)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C ⥤ D} [self : F.PreservesEpimorphisms] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f]
Goal: CategoryTheory.Epi (F.map f)
-- CategoryTheory.Functor.ReflectsMonomorphisms.reflects
class ReflectsMonomorphisms (F : C ⥤ D) : Prop where
     reflects : ∀ {X Y : C} (f : X ⟶ Y), Mono (F.map f) → Mono f
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C ⥤ D} [self : F.ReflectsMonomorphisms] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Mono (F.map f) → CategoryTheory.Mono f
-- CategoryTheory.Functor.mono_of_mono_map
theorem mono_of_mono_map (F : C ⥤ D) [ReflectsMonomorphisms F] {X Y : C} {f : X ⟶ Y}
    (h : Mono (F.map f)) : Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) [F.ReflectsMonomorphisms] {X Y : C} {f : X ⟶ Y} (h : CategoryTheory.Mono (F.map f))
Goal: CategoryTheory.Mono f
-- CategoryTheory.Functor.ReflectsEpimorphisms.reflects
class ReflectsEpimorphisms (F : C ⥤ D) : Prop where
    reflects : ∀ {X Y : C} (f : X ⟶ Y), Epi (F.map f) → Epi f
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C ⥤ D} [self : F.ReflectsEpimorphisms] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Epi (F.map f) → CategoryTheory.Epi f
-- CategoryTheory.Functor.epi_of_epi_map
theorem epi_of_epi_map (F : C ⥤ D) [ReflectsEpimorphisms F] {X Y : C} {f : X ⟶ Y}
    (h : Epi (F.map f)) : Epi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) [F.ReflectsEpimorphisms] {X Y : C} {f : X ⟶ Y} (h : CategoryTheory.Epi (F.map f))
Goal: CategoryTheory.Epi f
-- CategoryTheory.Functor.preservesEpimorphisms_of_preserves_of_reflects
theorem preservesEpimorphisms_of_preserves_of_reflects (F : C ⥤ D) (G : D ⥤ E)
    [PreservesEpimorphisms (F ⋙ G)] [ReflectsEpimorphisms G] : PreservesEpimorphisms 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] (F : C ⥤ D) (G : D ⥤ E) [(F ⋙ G).PreservesEpimorphisms] [G.ReflectsEpimorphisms]
Goal: F.PreservesEpimorphisms
-- CategoryTheory.Functor.preservesMonomorphisms_of_preserves_of_reflects
theorem preservesMonomorphisms_of_preserves_of_reflects (F : C ⥤ D) (G : D ⥤ E)
    [PreservesMonomorphisms (F ⋙ G)] [ReflectsMonomorphisms G] : PreservesMonomorphisms 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] (F : C ⥤ D) (G : D ⥤ E) [(F ⋙ G).PreservesMonomorphisms] [G.ReflectsMonomorphisms]
Goal: F.PreservesMonomorphisms
-- CategoryTheory.Functor.reflectsEpimorphisms_of_preserves_of_reflects
theorem reflectsEpimorphisms_of_preserves_of_reflects (F : C ⥤ D) (G : D ⥤ E)
    [PreservesEpimorphisms G] [ReflectsEpimorphisms (F ⋙ G)] : ReflectsEpimorphisms 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] (F : C ⥤ D) (G : D ⥤ E) [G.PreservesEpimorphisms] [(F ⋙ G).ReflectsEpimorphisms]
Goal: F.ReflectsEpimorphisms
-- CategoryTheory.Functor.reflectsMonomorphisms_of_preserves_of_reflects
theorem reflectsMonomorphisms_of_preserves_of_reflects (F : C ⥤ D) (G : D ⥤ E)
    [PreservesMonomorphisms G] [ReflectsMonomorphisms (F ⋙ G)] : ReflectsMonomorphisms 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] (F : C ⥤ D) (G : D ⥤ E) [G.PreservesMonomorphisms] [(F ⋙ G).ReflectsMonomorphisms]
Goal: F.ReflectsMonomorphisms
-- CategoryTheory.Functor.preservesMonomorphisms.of_iso
theorem preservesMonomorphisms.of_iso {F G : C ⥤ D} [PreservesMonomorphisms F] (α : F ≅ G) :
    PreservesMonomorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} [F.PreservesMonomorphisms] (α : F ≅ G)
Goal: G.PreservesMonomorphisms
-- CategoryTheory.Functor.preservesMonomorphisms.iso_iff
theorem preservesMonomorphisms.iso_iff {F G : C ⥤ D} (α : F ≅ G) :
    PreservesMonomorphisms F ↔ PreservesMonomorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G)
Goal: F.PreservesMonomorphisms ↔ G.PreservesMonomorphisms
-- CategoryTheory.Functor.preservesEpimorphisms.of_iso
theorem preservesEpimorphisms.of_iso {F G : C ⥤ D} [PreservesEpimorphisms F] (α : F ≅ G) :
    PreservesEpimorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} [F.PreservesEpimorphisms] (α : F ≅ G)
Goal: G.PreservesEpimorphisms
-- CategoryTheory.Functor.preservesEpimorphisms.iso_iff
theorem preservesEpimorphisms.iso_iff {F G : C ⥤ D} (α : F ≅ G) :
    PreservesEpimorphisms F ↔ PreservesEpimorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G)
Goal: F.PreservesEpimorphisms ↔ G.PreservesEpimorphisms
-- CategoryTheory.Functor.reflectsMonomorphisms.of_iso
theorem reflectsMonomorphisms.of_iso {F G : C ⥤ D} [ReflectsMonomorphisms F] (α : F ≅ G) :
    ReflectsMonomorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} [F.ReflectsMonomorphisms] (α : F ≅ G)
Goal: G.ReflectsMonomorphisms
-- CategoryTheory.Functor.reflectsMonomorphisms.iso_iff
theorem reflectsMonomorphisms.iso_iff {F G : C ⥤ D} (α : F ≅ G) :
    ReflectsMonomorphisms F ↔ ReflectsMonomorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G)
Goal: F.ReflectsMonomorphisms ↔ G.ReflectsMonomorphisms
-- CategoryTheory.Functor.reflectsEpimorphisms.of_iso
theorem reflectsEpimorphisms.of_iso {F G : C ⥤ D} [ReflectsEpimorphisms F] (α : F ≅ G) :
    ReflectsEpimorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} [F.ReflectsEpimorphisms] (α : F ≅ G)
Goal: G.ReflectsEpimorphisms
-- CategoryTheory.Functor.reflectsEpimorphisms.iso_iff
theorem reflectsEpimorphisms.iso_iff {F G : C ⥤ D} (α : F ≅ G) :
    ReflectsEpimorphisms F ↔ ReflectsEpimorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F G : C ⥤ D} (α : F ≅ G)
Goal: F.ReflectsEpimorphisms ↔ G.ReflectsEpimorphisms
-- CategoryTheory.Functor.preservesEpimorphsisms_of_adjunction
theorem preservesEpimorphsisms_of_adjunction {F : C ⥤ D} {G : D ⥤ C} (adj : F ⊣ G) :
    PreservesEpimorphisms F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C ⥤ D} {G : D ⥤ C} (adj : F ⊣ G)
Goal: F.PreservesEpimorphisms
-- CategoryTheory.Functor.preservesMonomorphisms_of_adjunction
theorem preservesMonomorphisms_of_adjunction {F : C ⥤ D} {G : D ⥤ C} (adj : F ⊣ G) :
    PreservesMonomorphisms G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : C ⥤ D} {G : D ⥤ C} (adj : F ⊣ G)
Goal: G.PreservesMonomorphisms
-- CategoryTheory.Functor.isSplitEpi_iff
@[simp]
theorem isSplitEpi_iff [Full F] [Faithful F] : IsSplitEpi (F.map f) ↔ IsSplitEpi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [F.Full] [F.Faithful]
Goal: CategoryTheory.IsSplitEpi (F.map f) ↔ CategoryTheory.IsSplitEpi f
-- CategoryTheory.Functor.isSplitMono_iff
@[simp]
theorem isSplitMono_iff [Full F] [Faithful F] : IsSplitMono (F.map f) ↔ IsSplitMono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [F.Full] [F.Faithful]
Goal: CategoryTheory.IsSplitMono (F.map f) ↔ CategoryTheory.IsSplitMono f
-- CategoryTheory.Functor.epi_map_iff_epi
@[simp]
theorem epi_map_iff_epi [hF₁ : PreservesEpimorphisms F] [hF₂ : ReflectsEpimorphisms F] :
    Epi (F.map f) ↔ Epi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [hF₁ : F.PreservesEpimorphisms] [hF₂ : F.ReflectsEpimorphisms]
Goal: CategoryTheory.Epi (F.map f) ↔ CategoryTheory.Epi f
-- CategoryTheory.Functor.mono_map_iff_mono
@[simp]
theorem mono_map_iff_mono [hF₁ : PreservesMonomorphisms F] [hF₂ : ReflectsMonomorphisms F] :
    Mono (F.map f) ↔ Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [hF₁ : F.PreservesMonomorphisms] [hF₂ : F.ReflectsMonomorphisms]
Goal: CategoryTheory.Mono (F.map f) ↔ CategoryTheory.Mono f
-- CategoryTheory.Functor.splitEpiCategoryImpOfIsEquivalence
theorem splitEpiCategoryImpOfIsEquivalence [IsEquivalence F] [SplitEpiCategory C] :
    SplitEpiCategory D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) [F.IsEquivalence] [CategoryTheory.SplitEpiCategory C]
Goal: CategoryTheory.SplitEpiCategory D
-- CategoryTheory.Adjunction.strongEpi_map_of_strongEpi
theorem strongEpi_map_of_strongEpi (adj : F ⊣ F') (f : A ⟶ B) [h₁ : F'.PreservesMonomorphisms]
    [h₂ : F.PreservesEpimorphisms] [StrongEpi f] : StrongEpi (F.map f) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {F : C ⥤ D} {F' : D ⥤ C} {A B : C} (adj : F ⊣ F') (f : A ⟶ B) [h₁ : F'.PreservesMonomorphisms] [h₂ : F.PreservesEpimorphisms] [CategoryTheory.StrongEpi f]
Goal: CategoryTheory.StrongEpi (F.map f)
-- CategoryTheory.Functor.strongEpi_map_iff_strongEpi_of_isEquivalence
@[simp]
theorem strongEpi_map_iff_strongEpi_of_isEquivalence [IsEquivalence F] :
    StrongEpi (F.map f) ↔ StrongEpi f 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {F : C ⥤ D} {A B : C} (f : A ⟶ B) [F.IsEquivalence]
Goal: CategoryTheory.StrongEpi (F.map f) ↔ CategoryTheory.StrongEpi f
-- ModuleCat.MonModuleEquivalenceAlgebra.algebraMap
@[simp]
theorem algebraMap (A : Mon_ (ModuleCat.{u} R)) (r : R) : algebraMap R A.X r = A.one r 
Arguments: {R : Type u} [CommRing R] (A : Mon_ (ModuleCat R)) (r : R)
Goal: (algebraMap R ↑A.X) r = A.one r
-- ModuleCat.MonModuleEquivalenceAlgebra.functor_obj_carrier
@[simps!]
def functor : Mon_ (ModuleCat.{u} R) ⥤ AlgebraCat R 
Arguments: {R : Type u} [CommRing R] (A : Mon_ (ModuleCat R))
Goal: ↑(ModuleCat.MonModuleEquivalenceAlgebra.functor.obj A) = ↑A.X
-- ModuleCat.MonModuleEquivalenceAlgebra.functor_map_apply
@[simps!]
def functor : Mon_ (ModuleCat.{u} R) ⥤ AlgebraCat R 
Arguments: {R : Type u} [CommRing R] {A B : Mon_ (ModuleCat R)} (f : A ⟶ B) (a : ↑A.X)
Goal: (ModuleCat.MonModuleEquivalenceAlgebra.functor.map f) a = f.hom a
-- ModuleCat.MonModuleEquivalenceAlgebra.inverseObj_one
@[simps]
def inverseObj (A : AlgebraCat.{u} R) : Mon_ (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (A : AlgebraCat R)
Goal: (ModuleCat.MonModuleEquivalenceAlgebra.inverseObj A).one = Algebra.linearMap R ↑A
-- ModuleCat.MonModuleEquivalenceAlgebra.inverseObj_mul
@[simps]
def inverseObj (A : AlgebraCat.{u} R) : Mon_ (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (A : AlgebraCat R)
Goal: (ModuleCat.MonModuleEquivalenceAlgebra.inverseObj A).mul = LinearMap.mul' R ↑A
-- ModuleCat.MonModuleEquivalenceAlgebra.inverseObj_X
@[simps]
def inverseObj (A : AlgebraCat.{u} R) : Mon_ (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (A : AlgebraCat R)
Goal: (ModuleCat.MonModuleEquivalenceAlgebra.inverseObj A).X = ModuleCat.of R ↑A
-- ModuleCat.MonModuleEquivalenceAlgebra.inverse_map_hom
@[simps]
def inverse : AlgebraCat.{u} R ⥤ Mon_ (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R]
Goal: ∀ {X Y : AlgebraCat R} (f : X ⟶ Y), (ModuleCat.MonModuleEquivalenceAlgebra.inverse.map f).hom = AlgHom.toLinearMap f
-- ModuleCat.MonModuleEquivalenceAlgebra.inverse_obj
@[simps]
def inverse : AlgebraCat.{u} R ⥤ Mon_ (ModuleCat.{u} R) 
Arguments: {R : Type u} [CommRing R] (A : AlgebraCat R)
Goal: ModuleCat.MonModuleEquivalenceAlgebra.inverse.obj A = ModuleCat.MonModuleEquivalenceAlgebra.inverseObj A