ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Sigma.inclCompMap_inv_app
@[simps!]
def inclCompMap (j : J) : incl j ⋙ map C g ≅ incl (g j) 
Arguments: {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) (j : J) (X : C (g j))
Goal: (CategoryTheory.Sigma.inclCompMap C g j).inv.app X = CategoryTheory.CategoryStruct.id ⟨g j, X⟩
-- CategoryTheory.Sigma.inclCompMap_hom_app
@[simps!]
def inclCompMap (j : J) : incl j ⋙ map C g ≅ incl (g j) 
Arguments: {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} (g : J → I) (j : J) (X : C (g j))
Goal: (CategoryTheory.Sigma.inclCompMap C g j).hom.app X = CategoryTheory.CategoryStruct.id ⟨g j, X⟩
-- CategoryTheory.Sigma.mapId_hom_app
@[simps!]
def mapId : map C (id : I → I) ≅ 𝟭 (Σi, C i) 
Arguments: (I : Type w₁) (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
Goal: ∀ (x : (i : I) × (fun i => C (id i)) i),
  (CategoryTheory.Sigma.mapId I C).hom.app x = CategoryTheory.CategoryStruct.id ⟨x.fst, x.snd⟩
-- CategoryTheory.Sigma.mapId_inv_app
@[simps!]
def mapId : map C (id : I → I) ≅ 𝟭 (Σi, C i) 
Arguments: (I : Type w₁) (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
Goal: ∀ (x : (i : I) × (fun i => C (id i)) i),
  (CategoryTheory.Sigma.mapId I C).inv.app x = CategoryTheory.CategoryStruct.id ⟨x.fst, x.snd⟩
-- CategoryTheory.Sigma.mapComp_hom_app
@[simps!]
def mapComp (f : K → J) (g : J → I) : map (fun x ↦ C (g x)) f ⋙ (map C g : _) ≅ map C (g ∘ f) 
Arguments: {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} {K : Type w₃} (f : K → J) (g : J → I) (X : (i : K) × (fun i => C (g (f i))) i)
Goal: (CategoryTheory.Sigma.mapComp C f g).hom.app X = CategoryTheory.CategoryStruct.id ⟨g (f X.fst), X.snd⟩
-- CategoryTheory.Sigma.mapComp_inv_app
@[simps!]
def mapComp (f : K → J) (g : J → I) : map (fun x ↦ C (g x)) f ⋙ (map C g : _) ≅ map C (g ∘ f) 
Arguments: {I : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₂} {K : Type w₃} (f : K → J) (g : J → I) (X : (i : K) × (fun i => C (g (f i))) i)
Goal: (CategoryTheory.Sigma.mapComp C f g).inv.app X = CategoryTheory.CategoryStruct.id ⟨g (f X.fst), X.snd⟩
-- CategoryTheory.Over.pullback_obj_hom
@[simps! (config := { simpRhs := true}) obj_left obj_hom map_left]
def pullback {X Y : C} (f : X ⟶ Y) : Over Y ⥤ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] {X Y : C} (f : X ⟶ Y) (g : CategoryTheory.Over Y)
Goal: ((CategoryTheory.Over.pullback f).obj g).hom = CategoryTheory.Limits.pullback.snd g.hom f
-- CategoryTheory.Over.pullback_obj_left
@[simps! (config := { simpRhs := true}) obj_left obj_hom map_left]
def pullback {X Y : C} (f : X ⟶ Y) : Over Y ⥤ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] {X Y : C} (f : X ⟶ Y) (g : CategoryTheory.Over Y)
Goal: ((CategoryTheory.Over.pullback f).obj g).left = CategoryTheory.Limits.pullback g.hom f
-- CategoryTheory.Over.pullback_map_left
@[simps! (config := { simpRhs := true}) obj_left obj_hom map_left]
def pullback {X Y : C} (f : X ⟶ Y) : Over Y ⥤ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] {X Y : C} (f : X ⟶ Y) (g : CategoryTheory.Over Y) {h : CategoryTheory.Over Y} {k : g ⟶ h}
Goal: ((CategoryTheory.Over.pullback f).map k).left =
  CategoryTheory.Limits.pullback.lift
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst g.hom f) k.left)
    (CategoryTheory.Limits.pullback.snd g.hom f) ⋯
-- CategoryTheory.Over.mapPullbackAdj_unit_app
@[simps! unit_app counit_app]
def mapPullbackAdj {X Y : C} (f : X ⟶ Y) : Over.map f ⊣ pullback f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] {X Y : C} (f : X ⟶ Y)
Goal: ∀ (X_1 : CategoryTheory.Over X),
  (CategoryTheory.Over.mapPullbackAdj f).unit.app X_1 =
    CategoryTheory.Over.homMk
      (CategoryTheory.Limits.pullback.lift (CategoryTheory.CategoryStruct.id X_1.left) X_1.hom ⋯) ⋯
-- CategoryTheory.Over.mapPullbackAdj_counit_app
@[simps! unit_app counit_app]
def mapPullbackAdj {X Y : C} (f : X ⟶ Y) : Over.map f ⊣ pullback f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] {X Y : C} (f : X ⟶ Y)
Goal: ∀ (Y_1 : CategoryTheory.Over Y),
  (CategoryTheory.Over.mapPullbackAdj f).counit.app Y_1 =
    CategoryTheory.Over.homMk (CategoryTheory.Limits.pullback.fst Y_1.hom f) ⋯
-- CategoryTheory.Over.star_obj_left
@[simps! obj_left obj_hom map_left]
def star [HasBinaryProducts C] : C ⥤ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C]
Goal: ∀ (X_1 : C), ((CategoryTheory.Over.star X).obj X_1).left = (X ⨯ X_1)
-- CategoryTheory.Over.star_obj_hom
@[simps! obj_left obj_hom map_left]
def star [HasBinaryProducts C] : C ⥤ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C]
Goal: ∀ (X_1 : C), ((CategoryTheory.Over.star X).obj X_1).hom = CategoryTheory.Limits.prod.fst
-- CategoryTheory.Over.star_map_left
@[simps! obj_left obj_hom map_left]
def star [HasBinaryProducts C] : C ⥤ Over X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) [CategoryTheory.Limits.HasBinaryProducts C]
Goal: ∀ {X_1 Y : C} (f : X_1 ⟶ Y),
  ((CategoryTheory.Over.star X).map f).left = CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X) f
-- CategoryTheory.Under.pushout_obj
@[simps]
def pushout {X Y : C} (f : X ⟶ Y) : Under X ⥤ Under Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPushouts C] {X Y : C} (f : X ⟶ Y) (x : CategoryTheory.Under X)
Goal: (CategoryTheory.Under.pushout f).obj x = CategoryTheory.Under.mk (CategoryTheory.Limits.pushout.inr x.hom f)
-- CategoryTheory.Under.pushout_map
@[simps]
def pushout {X Y : C} (f : X ⟶ Y) : Under X ⥤ Under Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPushouts C] {X Y : C} (f : X ⟶ Y) (x : CategoryTheory.Under X) {x' : CategoryTheory.Under X} {u : x ⟶ x'}
Goal: (CategoryTheory.Under.pushout f).map u =
  CategoryTheory.Under.homMk
    (CategoryTheory.Limits.pushout.desc
      (CategoryTheory.CategoryStruct.comp u.right (CategoryTheory.Limits.pushout.inl x'.hom f))
      (CategoryTheory.Limits.pushout.inr x'.hom f) ⋯)
    ⋯
-- CategoryTheory.Under.mapPushoutAdj_counit_app
@[simps! unit_app counit_app]
def mapPushoutAdj {X Y : C} (f : X ⟶ Y) : pushout f ⊣ map f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPushouts C] {X Y : C} (f : X ⟶ Y)
Goal: ∀ (Y_1 : CategoryTheory.Under Y),
  (CategoryTheory.Under.mapPushoutAdj f).counit.app Y_1 =
    CategoryTheory.Under.homMk
      (CategoryTheory.Limits.pushout.desc (CategoryTheory.CategoryStruct.id Y_1.right) Y_1.hom ⋯) ⋯
-- CategoryTheory.Under.mapPushoutAdj_unit_app
@[simps! unit_app counit_app]
def mapPushoutAdj {X Y : C} (f : X ⟶ Y) : pushout f ⊣ map f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPushouts C] {X Y : C} (f : X ⟶ Y)
Goal: ∀ (X_1 : CategoryTheory.Under X),
  (CategoryTheory.Under.mapPushoutAdj f).unit.app X_1 =
    CategoryTheory.Under.homMk (CategoryTheory.Limits.pushout.inl X_1.hom f) ⋯
-- CategoryTheory.IsFilteredOrEmpty.isPreconnected
theorem IsFilteredOrEmpty.isPreconnected [IsFilteredOrEmpty C] : IsPreconnected C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C]
Goal: CategoryTheory.IsPreconnected C
-- CategoryTheory.IsCofilteredOrEmpty.isPreconnected
theorem IsCofilteredOrEmpty.isPreconnected [IsCofilteredOrEmpty C] : IsPreconnected C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C]
Goal: CategoryTheory.IsPreconnected C
-- CategoryTheory.IsFiltered.isConnected
theorem IsFiltered.isConnected [IsFiltered C] : IsConnected C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C]
Goal: CategoryTheory.IsConnected C
-- CategoryTheory.IsCofiltered.isConnected
theorem IsCofiltered.isConnected [IsCofiltered C] : IsConnected C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofiltered C]
Goal: CategoryTheory.IsConnected C
-- CategoryTheory.IsFiltered.small_fullSubcategory_filteredClosure
theorem small_fullSubcategory_filteredClosure :
    Small.{max v w} (FullSubcategory (FilteredClosure f)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFilteredOrEmpty C] {α : Type w} (f : α → C)
Goal: Small.{max v w, u} (CategoryTheory.FullSubcategory (CategoryTheory.IsFiltered.FilteredClosure f))
-- CategoryTheory.IsCofiltered.small_fullSubcategory_cofilteredClosure
theorem small_fullSubcategory_cofilteredClosure :
    Small.{max v w} (FullSubcategory (CofilteredClosure f)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {α : Type w} (f : α → C)
Goal: Small.{max v w, u} (CategoryTheory.FullSubcategory (CategoryTheory.IsCofiltered.CofilteredClosure f))
-- CategoryTheory.PreGaloisCategory.IsGalois.quotientByAutTerminal
class IsGalois {C : Type u₁} [Category.{u₂, u₁} C] [GaloisCategory C] (X : C)
    extends IsConnected X : Prop where
  quotientByAutTerminal : Nonempty (IsTerminal <| colimit <| SingleObj.functor <| Aut.toEnd X)
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {X : C} [self : CategoryTheory.PreGaloisCategory.IsGalois X]
Goal: Nonempty
  (CategoryTheory.Limits.IsTerminal
    (CategoryTheory.Limits.colimit (CategoryTheory.SingleObj.functor (CategoryTheory.Aut.toEnd X))))
-- CategoryTheory.PreGaloisCategory.isGalois_iff_aux
lemma isGalois_iff_aux (X : C) [IsConnected X] :
    IsGalois X ↔ Nonempty (IsTerminal <| colimit <| SingleObj.functor <| Aut.toEnd X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (X : C) [CategoryTheory.PreGaloisCategory.IsConnected X]
Goal: CategoryTheory.PreGaloisCategory.IsGalois X ↔
  Nonempty
    (CategoryTheory.Limits.IsTerminal
      (CategoryTheory.Limits.colimit (CategoryTheory.SingleObj.functor (CategoryTheory.Aut.toEnd X))))
-- CategoryTheory.PreGaloisCategory.isGalois_iff_pretransitive
theorem isGalois_iff_pretransitive (X : C) [IsConnected X] :
    IsGalois X ↔ MulAction.IsPretransitive (Aut X) (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (X : C) [CategoryTheory.PreGaloisCategory.IsConnected X]
Goal: CategoryTheory.PreGaloisCategory.IsGalois X ↔ MulAction.IsPretransitive (CategoryTheory.Aut X) ↑(F.obj X)
-- CategoryTheory.PreGaloisCategory.evaluation_aut_surjective_of_isGalois
theorem evaluation_aut_surjective_of_isGalois (A : C) [IsGalois A] (a : F.obj A) :
    Function.Surjective (fun f : Aut A ↦ F.map f.hom a) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (A : C) [CategoryTheory.PreGaloisCategory.IsGalois A] (a : ↑(F.obj A))
Goal: Function.Surjective fun f => F.map f.hom a
-- CategoryTheory.PreGaloisCategory.evaluation_aut_bijective_of_isGalois
theorem evaluation_aut_bijective_of_isGalois (A : C) [IsGalois A] (a : F.obj A) :
    Function.Bijective (fun f : Aut A ↦ F.map f.hom a) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (A : C) [CategoryTheory.PreGaloisCategory.IsGalois A] (a : ↑(F.obj A))
Goal: Function.Bijective fun f => F.map f.hom a
-- CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois_apply
@[simp]
lemma evaluationEquivOfIsGalois_apply (A : C) [IsGalois A] (a : F.obj A) (φ : Aut A) :
    evaluationEquivOfIsGalois F A a φ = F.map φ.hom a 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (A : C) [CategoryTheory.PreGaloisCategory.IsGalois A] (a : ↑(F.obj A)) (φ : CategoryTheory.Aut A)
Goal: (CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois F A a) φ = F.map φ.hom a
-- CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois_symm_fiber
@[simp]
lemma evaluationEquivOfIsGalois_symm_fiber (A : C) [IsGalois A] (a b : F.obj A) :
    F.map ((evaluationEquivOfIsGalois F A a).symm b).hom a = b 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (A : C) [CategoryTheory.PreGaloisCategory.IsGalois A] (a b : ↑(F.obj A))
Goal: F.map ((CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois F A a).symm b).hom a = b
-- CategoryTheory.PreGaloisCategory.exists_autMap
lemma exists_autMap {A B : C} (f : A ⟶ B) [IsConnected A] [IsGalois B] (σ : Aut A) :
    ∃! (τ : Aut B), f ≫ τ.hom = σ.hom ≫ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {A B : C} (f : A ⟶ B) [CategoryTheory.PreGaloisCategory.IsConnected A] [CategoryTheory.PreGaloisCategory.IsGalois B] (σ : CategoryTheory.Aut A)
Goal: ∃! τ, CategoryTheory.CategoryStruct.comp f τ.hom = CategoryTheory.CategoryStruct.comp σ.hom f
-- CategoryTheory.PreGaloisCategory.comp_autMap
@[simp]
lemma comp_autMap {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ : Aut A) :
    f ≫ (autMap f σ).hom = σ.hom ≫ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {A B : C} [CategoryTheory.PreGaloisCategory.IsConnected A] [CategoryTheory.PreGaloisCategory.IsGalois B] (f : A ⟶ B) (σ : CategoryTheory.Aut A)
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.PreGaloisCategory.autMap f σ).hom =
  CategoryTheory.CategoryStruct.comp σ.hom f
-- CategoryTheory.PreGaloisCategory.comp_autMap_apply
@[simp]
lemma comp_autMap_apply {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ : Aut A)
    (a : F.obj A) :
    F.map (autMap f σ).hom (F.map f a) = F.map f (F.map σ.hom a) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) {A B : C} [CategoryTheory.PreGaloisCategory.IsConnected A] [CategoryTheory.PreGaloisCategory.IsGalois B] (f : A ⟶ B) (σ : CategoryTheory.Aut A) (a : ↑(F.obj A))
Goal: F.map (CategoryTheory.PreGaloisCategory.autMap f σ).hom (F.map f a) = F.map f (F.map σ.hom a)
-- CategoryTheory.PreGaloisCategory.autMap_unique
lemma autMap_unique {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ : Aut A)
    (τ : Aut B) (h : f ≫ τ.hom = σ.hom ≫ f) :
    autMap f σ = τ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {A B : C} [CategoryTheory.PreGaloisCategory.IsConnected A] [CategoryTheory.PreGaloisCategory.IsGalois B] (f : A ⟶ B) (σ : CategoryTheory.Aut A) (τ : CategoryTheory.Aut B) (h : CategoryTheory.CategoryStruct.comp f τ.hom = CategoryTheory.CategoryStruct.comp σ.hom f)
Goal: CategoryTheory.PreGaloisCategory.autMap f σ = τ
-- CategoryTheory.PreGaloisCategory.autMap_id
@[simp]
lemma autMap_id {A : C} [IsGalois A] : autMap (𝟙 A) = id 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {A : C} [CategoryTheory.PreGaloisCategory.IsGalois A]
Goal: CategoryTheory.PreGaloisCategory.autMap (CategoryTheory.CategoryStruct.id A) = id
-- CategoryTheory.PreGaloisCategory.autMap_comp
@[simp]
lemma autMap_comp {X Y Z : C} [IsConnected X] [IsGalois Y] [IsGalois Z] (f : X ⟶ Y)
    (g : Y ⟶ Z) : autMap (f ≫ g) = autMap g ∘ autMap f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {X Y Z : C} [CategoryTheory.PreGaloisCategory.IsConnected X] [CategoryTheory.PreGaloisCategory.IsGalois Y] [CategoryTheory.PreGaloisCategory.IsGalois Z] (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.PreGaloisCategory.autMap (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.PreGaloisCategory.autMap g ∘ CategoryTheory.PreGaloisCategory.autMap f
-- CategoryTheory.PreGaloisCategory.autMap_surjective_of_isGalois
lemma autMap_surjective_of_isGalois {A B : C} [IsGalois A] [IsGalois B] (f : A ⟶ B) :
    Function.Surjective (autMap f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {A B : C} [CategoryTheory.PreGaloisCategory.IsGalois A] [CategoryTheory.PreGaloisCategory.IsGalois B] (f : A ⟶ B)
Goal: Function.Surjective (CategoryTheory.PreGaloisCategory.autMap f)
-- CategoryTheory.PreGaloisCategory.autMap_apply_mul
@[simp]
lemma autMap_apply_mul {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ τ : Aut A) :
    autMap f (σ * τ) = autMap f σ * autMap f τ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {A B : C} [CategoryTheory.PreGaloisCategory.IsConnected A] [CategoryTheory.PreGaloisCategory.IsGalois B] (f : A ⟶ B) (σ τ : CategoryTheory.Aut A)
Goal: CategoryTheory.PreGaloisCategory.autMap f (σ * τ) =
  CategoryTheory.PreGaloisCategory.autMap f σ * CategoryTheory.PreGaloisCategory.autMap f τ
-- CategoryTheory.PreGaloisCategory.autMapHom_apply
@[simps!]
noncomputable def autMapHom {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) :
     Aut A →* Aut B 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {A B : C} [CategoryTheory.PreGaloisCategory.IsConnected A] [CategoryTheory.PreGaloisCategory.IsGalois B] (f : A ⟶ B) (σ : CategoryTheory.Aut A)
Goal: (CategoryTheory.PreGaloisCategory.autMapHom f) σ = CategoryTheory.PreGaloisCategory.autMap f σ
-- CategoryTheory.FintypeCat.Action.pretransitive_of_isConnected
theorem Action.pretransitive_of_isConnected (X : Action FintypeCat (MonCat.of G))
    [IsConnected X] : MulAction.IsPretransitive G X.V 
Arguments: (G : Type u) [Group G] (X : Action FintypeCat (MonCat.of G)) [CategoryTheory.PreGaloisCategory.IsConnected X]
Goal: MulAction.IsPretransitive G ↑X.V
-- CategoryTheory.FintypeCat.Action.isConnected_of_transitive
theorem Action.isConnected_of_transitive (X : FintypeCat) [MulAction G X]
    [MulAction.IsPretransitive G X] [h : Nonempty X] :
    IsConnected (Action.FintypeCat.ofMulAction G X) 
Arguments: (G : Type u) [Group G] (X : FintypeCat) [MulAction G ↑X] [MulAction.IsPretransitive G ↑X] [h : Nonempty ↑X]
Goal: CategoryTheory.PreGaloisCategory.IsConnected (Action.FintypeCat.ofMulAction G X)
-- CategoryTheory.FintypeCat.Action.isConnected_iff_transitive
theorem Action.isConnected_iff_transitive (X : Action FintypeCat (MonCat.of G)) [Nonempty X.V] :
    IsConnected X ↔ MulAction.IsPretransitive G X.V 
Arguments: (G : Type u) [Group G] (X : Action FintypeCat (MonCat.of G)) [Nonempty ↑X.V]
Goal: CategoryTheory.PreGaloisCategory.IsConnected X ↔ MulAction.IsPretransitive G ↑X.V
-- CategoryTheory.Bifunctor.map_id
@[simp]
theorem map_id (F : C × D ⥤ E) (X : C) (Y : D) :
    F.map ((𝟙 X, 𝟙 Y) : (X, Y) ⟶ (X, Y)) = 𝟙 (F.obj (X, Y)) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] (F : C × D ⥤ E) (X : C) (Y : D)
Goal: F.map (𝟙 X, 𝟙 Y) = 𝟙 (F.obj (X, Y))
-- CategoryTheory.Bifunctor.map_id_comp
@[simp]
theorem map_id_comp (F : C × D ⥤ E) (W : C) {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z) :
    F.map ((𝟙 W, f ≫ g) : (W, X) ⟶ (W, Z)) =
      F.map ((𝟙 W, f) : (W, X) ⟶ (W, Y)) ≫ F.map ((𝟙 W, g) : (W, Y) ⟶ (W, Z)) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] (F : C × D ⥤ E) (W : C) {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: F.map (𝟙 W, f ≫ g) = F.map (𝟙 W, f) ≫ F.map (𝟙 W, g)
-- CategoryTheory.Bifunctor.map_comp_id
@[simp]
theorem map_comp_id (F : C × D ⥤ E) (X Y Z : C) (W : D) (f : X ⟶ Y) (g : Y ⟶ Z) :
    F.map ((f ≫ g, 𝟙 W) : (X, W) ⟶ (Z, W)) =
      F.map ((f, 𝟙 W) : (X, W) ⟶ (Y, W)) ≫ F.map ((g, 𝟙 W) : (Y, W) ⟶ (Z, W)) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] (F : C × D ⥤ E) (X Y Z : C) (W : D) (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: F.map (f ≫ g, 𝟙 W) = F.map (f, 𝟙 W) ≫ F.map (g, 𝟙 W)
-- CategoryTheory.Bifunctor.diagonal
@[simp]
theorem diagonal (F : C × D ⥤ E) (X X' : C) (f : X ⟶ X') (Y Y' : D) (g : Y ⟶ Y') :
    F.map ((𝟙 X, g) : (X, Y) ⟶ (X, Y')) ≫ F.map ((f, 𝟙 Y') : (X, Y') ⟶ (X', Y')) =
      F.map ((f, g) : (X, Y) ⟶ (X', Y')) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] (F : C × D ⥤ E) (X X' : C) (f : X ⟶ X') (Y Y' : D) (g : Y ⟶ Y')
Goal: F.map (𝟙 X, g) ≫ F.map (f, 𝟙 Y') = F.map (f, g)
-- CategoryTheory.Bifunctor.diagonal'
@[simp]
theorem diagonal' (F : C × D ⥤ E) (X X' : C) (f : X ⟶ X') (Y Y' : D) (g : Y ⟶ Y') :
    F.map ((f, 𝟙 Y) : (X, Y) ⟶ (X', Y)) ≫ F.map ((𝟙 X', g) : (X', Y) ⟶ (X', Y')) =
      F.map ((f, g) : (X, Y) ⟶ (X', Y')) 
Arguments: {C : Type u₁} {D : Type u₂} {E : Type u₃} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Category.{v₃, u₃} E] (F : C × D ⥤ E) (X X' : C) (f : X ⟶ X') (Y Y' : D) (g : Y ⟶ Y')
Goal: F.map (f, 𝟙 Y) ≫ F.map (𝟙 X', g) = F.map (f, g)
-- CategoryTheory.prod.leftUnitor_obj
@[simps]
def leftUnitor : Discrete (PUnit : Type w) × C ⥤ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Discrete PUnit.{w + 1} × C)
Goal: (CategoryTheory.prod.leftUnitor C).obj X = X.2
-- CategoryTheory.prod.leftUnitor_map
@[simps]
def leftUnitor : Discrete (PUnit : Type w) × C ⥤ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Discrete PUnit.{w + 1} × C} (f : X ⟶ Y), (CategoryTheory.prod.leftUnitor C).map f = f.2
-- CategoryTheory.prod.rightUnitor_obj
@[simps]
def rightUnitor : C × Discrete (PUnit : Type w) ⥤ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (X : C × CategoryTheory.Discrete PUnit.{w + 1})
Goal: (CategoryTheory.prod.rightUnitor C).obj X = X.1
-- CategoryTheory.prod.rightUnitor_map
@[simps]
def rightUnitor : C × Discrete (PUnit : Type w) ⥤ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : C × CategoryTheory.Discrete PUnit.{w + 1}} (f : X ⟶ Y), (CategoryTheory.prod.rightUnitor C).map f = f.1
-- CategoryTheory.prod.leftInverseUnitor_obj
@[simps]
def leftInverseUnitor : C ⥤ Discrete (PUnit : Type w) × C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (X : C)
Goal: (CategoryTheory.prod.leftInverseUnitor C).obj X = ({ as := PUnit.unit }, X)
-- CategoryTheory.prod.leftInverseUnitor_map
@[simps]
def leftInverseUnitor : C ⥤ Discrete (PUnit : Type w) × C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y),
  (CategoryTheory.prod.leftInverseUnitor C).map f = (𝟙 ((fun X => ({ as := PUnit.unit }, X)) X).1, f)
-- CategoryTheory.prod.rightInverseUnitor_map
@[simps]
def rightInverseUnitor : C ⥤ C × Discrete (PUnit : Type w) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y),
  (CategoryTheory.prod.rightInverseUnitor C).map f = (f, 𝟙 ((fun X => (X, { as := PUnit.unit })) X).2)
-- CategoryTheory.prod.rightInverseUnitor_obj
@[simps]
def rightInverseUnitor : C ⥤ C × Discrete (PUnit : Type w) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (X : C)
Goal: (CategoryTheory.prod.rightInverseUnitor C).obj X = (X, { as := PUnit.unit })
-- CategoryTheory.prod.leftUnitorEquivalence_functor
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.prod.leftUnitorEquivalence C).functor = CategoryTheory.prod.leftUnitor C