ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.PreGaloisCategory.fiber_in_connected_component
lemma fiber_in_connected_component (X : C) (x : F.obj X) : ∃ (Y : C) (i : Y ⟶ X) (y : F.obj Y),
    F.map i y = x ∧ IsConnected Y ∧ Mono i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (X : C) (x : ↑(F.obj X))
Goal: ∃ Y i y, F.map i y = x ∧ CategoryTheory.PreGaloisCategory.IsConnected Y ∧ CategoryTheory.Mono i
-- CategoryTheory.PreGaloisCategory.connected_component_unique
lemma connected_component_unique {X A B : C} [IsConnected A] [IsConnected B] (a : F.obj A)
    (b : F.obj B) (i : A ⟶ X) (j : B ⟶ X) (h : F.map i a = F.map j b) [Mono i] [Mono j] :
    ∃ (f : A ≅ B), F.map f.hom a = b 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] {X A B : C} [CategoryTheory.PreGaloisCategory.IsConnected A] [CategoryTheory.PreGaloisCategory.IsConnected B] (a : ↑(F.obj A)) (b : ↑(F.obj B)) (i : A ⟶ X) (j : B ⟶ X) (h : F.map i a = F.map j b) [CategoryTheory.Mono i] [CategoryTheory.Mono j]
Goal: ∃ f, F.map f.hom a = b
-- _private.Mathlib.CategoryTheory.Galois.Decomposition.0.CategoryTheory.PreGaloisCategory.mkSelfProdFib_map_π
@[simp]
private lemma mkSelfProdFib_map_π (t : F.obj X) : F.map (Pi.π _ t) (mkSelfProdFib F X) = t 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (X : C) (t : ↑(F.obj X))
Goal: F.map (CategoryTheory.Limits.Pi.π (fun x => X) t) (CategoryTheory.PreGaloisCategory.mkSelfProdFib F X) = t
-- _private.Mathlib.CategoryTheory.Galois.Decomposition.0.CategoryTheory.PreGaloisCategory.selfProdProj_fiber
private lemma selfProdProj_fiber (x : F.obj X) :
    F.map (selfProdProj u x) a = x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {F : CategoryTheory.Functor C FintypeCat} [CategoryTheory.PreGaloisCategory.FiberFunctor F] {X A : C} {u : A ⟶ CategoryTheory.PreGaloisCategory.selfProd F X} {a : ↑(F.obj A)} (h : F.map u a = CategoryTheory.PreGaloisCategory.mkSelfProdFib F X) (x : ↑(F.obj X))
Goal: F.map (CategoryTheory.PreGaloisCategory.selfProdProj u x) a = x
-- _private.Mathlib.CategoryTheory.Galois.Decomposition.0.CategoryTheory.PreGaloisCategory.selfProdTermIncl_fib_eq
private lemma selfProdTermIncl_fib_eq (b : F.obj A) :
    F.map u b = F.map (selfProdPermIncl h b) a 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {F : CategoryTheory.Functor C FintypeCat} [CategoryTheory.PreGaloisCategory.FiberFunctor F] {X A : C} [CategoryTheory.PreGaloisCategory.IsConnected A] {u : A ⟶ CategoryTheory.PreGaloisCategory.selfProd F X} {a : ↑(F.obj A)} (h : F.map u a = CategoryTheory.PreGaloisCategory.mkSelfProdFib F X) (b : ↑(F.obj A))
Goal: F.map u b = F.map (CategoryTheory.PreGaloisCategory.selfProdPermIncl h b) a
-- _private.Mathlib.CategoryTheory.Galois.Decomposition.0.CategoryTheory.PreGaloisCategory.subobj_selfProd_trans
private lemma subobj_selfProd_trans (b : F.obj A) : ∃ (f : A ≅ A), F.map f.hom b = a 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] {F : CategoryTheory.Functor C FintypeCat} [CategoryTheory.PreGaloisCategory.FiberFunctor F] {X A : C} [CategoryTheory.PreGaloisCategory.IsConnected A] {u : A ⟶ CategoryTheory.PreGaloisCategory.selfProd F X} [CategoryTheory.Mono u] {a : ↑(F.obj A)} (h : F.map u a = CategoryTheory.PreGaloisCategory.mkSelfProdFib F X) (b : ↑(F.obj A))
Goal: ∃ f, F.map f.hom b = a
-- CategoryTheory.PreGaloisCategory.exists_galois_representative
lemma exists_galois_representative (X : C) : ∃ (A : C) (a : F.obj A),
    IsGalois A ∧ Function.Bijective (fun (f : A ⟶ X) ↦ F.map f a) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (X : C)
Goal: ∃ A a, CategoryTheory.PreGaloisCategory.IsGalois A ∧ Function.Bijective fun f => F.map f a
-- CategoryTheory.PreGaloisCategory.exists_hom_from_galois_of_fiber
lemma exists_hom_from_galois_of_fiber (X : C) (x : F.obj X) :
    ∃ (A : C) (f : A ⟶ X) (a : F.obj A), IsGalois A ∧ F.map f a = x 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (X : C) (x : ↑(F.obj X))
Goal: ∃ A f a, CategoryTheory.PreGaloisCategory.IsGalois A ∧ F.map f a = x
-- CategoryTheory.PreGaloisCategory.exists_hom_from_galois_of_fiber_nonempty
lemma exists_hom_from_galois_of_fiber_nonempty (X : C) (h : Nonempty (F.obj X)) :
    ∃ (A : C) (_ : A ⟶ X), IsGalois A 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] [CategoryTheory.GaloisCategory C] (F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (X : C) (h : Nonempty ↑(F.obj X))
Goal: ∃ A x, CategoryTheory.PreGaloisCategory.IsGalois A
-- CategoryTheory.PreGaloisCategory.exists_hom_from_galois_of_connected
lemma exists_hom_from_galois_of_connected (X : C) [IsConnected X] :
    ∃ (A : C) (_ : A ⟶ X), IsGalois A 
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: ∃ A x, CategoryTheory.PreGaloisCategory.IsGalois A
-- TwoP.coe_of
@[simp]
theorem coe_of {X : Type*} (toTwoPointing : TwoPointing X) : ↥(of toTwoPointing) = X 
Arguments: {X : Type u_3} (toTwoPointing : TwoPointing X)
Goal: (TwoP.of toTwoPointing).X = X
-- TwoP.coe_toBipointed
@[simp]
theorem coe_toBipointed (X : TwoP) : ↥X.toBipointed = ↥X 
Arguments: (X : TwoP)
Goal: X.toBipointed.X = X.X
-- TwoP.swap_obj_X
@[simps]
noncomputable def swap : TwoP ⥤ TwoP 
Arguments: (X : TwoP)
Goal: (TwoP.swap.obj X).X = X.X
-- TwoP.swap_obj_toTwoPointing
@[simps]
noncomputable def swap : TwoP ⥤ TwoP 
Arguments: (X : TwoP)
Goal: (TwoP.swap.obj X).toTwoPointing = X.toTwoPointing.swap
-- TwoP.swap_map_toFun
@[simps]
noncomputable def swap : TwoP ⥤ TwoP 
Goal: ∀ {X Y : TwoP} (f : X ⟶ Y) (a : X.toBipointed.X), (TwoP.swap.map f).toFun a = f.toFun a
-- TwoP.swapEquiv_inverse_obj_X
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Arguments: (X : TwoP)
Goal: (TwoP.swapEquiv.inverse.obj X).X = X.X
-- TwoP.swapEquiv_functor_obj_toTwoPointing_toProd
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Arguments: (X : TwoP)
Goal: (TwoP.swapEquiv.functor.obj X).toTwoPointing.toProd = (X.toTwoPointing.toProd.2, X.toTwoPointing.toProd.1)
-- TwoP.swapEquiv_counitIso_hom_app_toFun
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Arguments: (X : TwoP) (a : ((TwoP.swap ⋙ TwoP.swap).obj X).toBipointed.X)
Goal: (TwoP.swapEquiv.counitIso.hom.app X).toFun a = a
-- TwoP.swapEquiv_functor_obj_X
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Arguments: (X : TwoP)
Goal: (TwoP.swapEquiv.functor.obj X).X = X.X
-- TwoP.swapEquiv_counitIso_inv_app_toFun
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Arguments: (X : TwoP) (a : ((𝟭 TwoP).obj X).toBipointed.X)
Goal: (TwoP.swapEquiv.counitIso.inv.app X).toFun a = a
-- TwoP.swapEquiv_inverse_map_toFun
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Goal: ∀ {X Y : TwoP} (f : X ⟶ Y) (a : X.toBipointed.X), (TwoP.swapEquiv.inverse.map f).toFun a = f.toFun a
-- TwoP.swapEquiv_functor_map_toFun
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Goal: ∀ {X Y : TwoP} (f : X ⟶ Y) (a : X.toBipointed.X), (TwoP.swapEquiv.functor.map f).toFun a = f.toFun a
-- TwoP.swapEquiv_unitIso_hom_app_toFun
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Arguments: (X : TwoP)
Goal: ∀ (a : ((𝟭 TwoP).obj X).toBipointed.X),
  (TwoP.swapEquiv.unitIso.hom.app X).toFun a =
    (𝟙 (TwoP.swap.obj (TwoP.swap.obj X))).toFun
      (({ toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫
            TwoP.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫
              TwoP.swap.map (TwoP.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ })).toFun
        a)
-- TwoP.swapEquiv_unitIso_inv_app_toFun
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Arguments: (X : TwoP)
Goal: ∀ (a : ((TwoP.swap ⋙ TwoP.swap).obj X).toBipointed.X),
  (TwoP.swapEquiv.unitIso.inv.app X).toFun a =
    (TwoP.swap.map (TwoP.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ }) ≫
          TwoP.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫ { toFun := id, map_fst := ⋯, map_snd := ⋯ }).toFun
      ((𝟙 (TwoP.swap.obj (TwoP.swap.obj X))).toFun a)
-- TwoP.swapEquiv_inverse_obj_toTwoPointing_toProd
@[simps!]
noncomputable def swapEquiv : TwoP ≌ TwoP 
Arguments: (X : TwoP)
Goal: (TwoP.swapEquiv.inverse.obj X).toTwoPointing.toProd = (X.toTwoPointing.toProd.2, X.toTwoPointing.toProd.1)
-- TwoP.swapEquiv_symm
@[simp]
theorem swapEquiv_symm : swapEquiv.symm = swapEquiv 
Goal: TwoP.swapEquiv.symm = TwoP.swapEquiv
-- TwoP_swap_comp_forget_to_Bipointed
@[simp]
theorem TwoP_swap_comp_forget_to_Bipointed :
    TwoP.swap ⋙ forget₂ TwoP Bipointed = forget₂ TwoP Bipointed ⋙ Bipointed.swap 
Goal: TwoP.swap ⋙ CategoryTheory.forget₂ TwoP Bipointed = CategoryTheory.forget₂ TwoP Bipointed ⋙ Bipointed.swap
-- pointedToTwoPFst_map_toFun
@[simps]
noncomputable def pointedToTwoPFst : Pointed.{u} ⥤ TwoP 
Goal: ∀ {X Y : Pointed} (f : X ⟶ Y) (a : Option X.X), (pointedToTwoPFst.map f).toFun a = Option.map f.toFun a
-- pointedToTwoPFst_obj_toTwoPointing_toProd
@[simps]
noncomputable def pointedToTwoPFst : Pointed.{u} ⥤ TwoP 
Arguments: (X : Pointed)
Goal: (pointedToTwoPFst.obj X).toTwoPointing.toProd = (some X.point, none)
-- pointedToTwoPFst_obj_X
@[simps]
noncomputable def pointedToTwoPFst : Pointed.{u} ⥤ TwoP 
Arguments: (X : Pointed)
Goal: (pointedToTwoPFst.obj X).X = Option X.X
-- pointedToTwoPSnd_map_toFun
@[simps]
noncomputable def pointedToTwoPSnd : Pointed.{u} ⥤ TwoP 
Goal: ∀ {X Y : Pointed} (f : X ⟶ Y) (a : Option X.X), (pointedToTwoPSnd.map f).toFun a = Option.map f.toFun a
-- pointedToTwoPSnd_obj_X
@[simps]
noncomputable def pointedToTwoPSnd : Pointed.{u} ⥤ TwoP 
Arguments: (X : Pointed)
Goal: (pointedToTwoPSnd.obj X).X = Option X.X
-- pointedToTwoPSnd_obj_toTwoPointing_toProd
@[simps]
noncomputable def pointedToTwoPSnd : Pointed.{u} ⥤ TwoP 
Arguments: (X : Pointed)
Goal: (pointedToTwoPSnd.obj X).toTwoPointing.toProd = (none, some X.point)
-- pointedToTwoPFst_comp_swap
@[simp]
theorem pointedToTwoPFst_comp_swap : pointedToTwoPFst ⋙ TwoP.swap = pointedToTwoPSnd 
Goal: pointedToTwoPFst ⋙ TwoP.swap = pointedToTwoPSnd
-- pointedToTwoPSnd_comp_swap
@[simp]
theorem pointedToTwoPSnd_comp_swap : pointedToTwoPSnd ⋙ TwoP.swap = pointedToTwoPFst 
Goal: pointedToTwoPSnd ⋙ TwoP.swap = pointedToTwoPFst
-- pointedToTwoPFst_comp_forget_to_bipointed
@[simp]
theorem pointedToTwoPFst_comp_forget_to_bipointed :
    pointedToTwoPFst ⋙ forget₂ TwoP Bipointed = pointedToBipointedFst 
Goal: pointedToTwoPFst ⋙ CategoryTheory.forget₂ TwoP Bipointed = pointedToBipointedFst
-- pointedToTwoPSnd_comp_forget_to_bipointed
@[simp]
theorem pointedToTwoPSnd_comp_forget_to_bipointed :
    pointedToTwoPSnd ⋙ forget₂ TwoP Bipointed = pointedToBipointedSnd 
Goal: pointedToTwoPSnd ⋙ CategoryTheory.forget₂ TwoP Bipointed = pointedToBipointedSnd
-- Pointed.coe_of
@[simp]
theorem coe_of {X : Type*} (point : X) : ↥(of point) = X 
Arguments: {X : Type u_3} (point : X)
Goal: (Pointed.of point).X = X
-- Pointed.Hom.map_point
@[ext]
protected structure Hom (X Y : Pointed.{u}) : Type u where
    toFun : X → Y
    map_point : toFun X.point = Y.point
Arguments: {X Y : Pointed} (self : X.Hom Y)
Goal: self.toFun X.point = Y.point
-- Pointed.Hom.id_toFun
@[simps]
def id (X : Pointed) : Pointed.Hom X X 
Arguments: (X : Pointed) (a : X.X)
Goal: (Pointed.Hom.id X).toFun a = id a
-- Pointed.Hom.comp_toFun
@[simps]
def comp {X Y Z : Pointed.{u}} (f : Pointed.Hom X Y) (g : Pointed.Hom Y Z) : Pointed.Hom X Z 
Arguments: {X Y Z : Pointed} (f : X.Hom Y) (g : Y.Hom Z)
Goal: ∀ (a : X.X), (f.comp g).toFun a = (g.toFun ∘ f.toFun) a
-- Pointed.Hom.id_toFun'
@[simp] lemma Hom.id_toFun' (X : Pointed.{u}) : (𝟙 X : X ⟶ X).toFun = _root_.id 
Arguments: (X : Pointed)
Goal: (𝟙 X).toFun = id
-- Pointed.Hom.comp_toFun'
@[simp] lemma Hom.comp_toFun' {X Y Z : Pointed.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).toFun = g.toFun ∘ f.toFun 
Arguments: {X Y Z : Pointed} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (f ≫ g).toFun = g.toFun ∘ f.toFun
-- Pointed.Iso.mk_hom_toFun
@[simps]
def Iso.mk {α β : Pointed} (e : α ≃ β) (he : e α.point = β.point) : α ≅ β 
Arguments: {α β : Pointed} (e : α.X ≃ β.X) (he : e α.point = β.point) (a : α.X)
Goal: (Pointed.Iso.mk e he).hom.toFun a = e a
-- Pointed.Iso.mk_inv_toFun
@[simps]
def Iso.mk {α β : Pointed} (e : α ≃ β) (he : e α.point = β.point) : α ≅ β 
Arguments: {α β : Pointed} (e : α.X ≃ β.X) (he : e α.point = β.point) (a : β.X)
Goal: (Pointed.Iso.mk e he).inv.toFun a = e.symm a
-- typeToPointed_obj_X
@[simps]
def typeToPointed : Type u ⥤ Pointed.{u} 
Arguments: (X : Type u)
Goal: (typeToPointed.obj X).X = Option X
-- typeToPointed_obj_point
@[simps]
def typeToPointed : Type u ⥤ Pointed.{u} 
Arguments: (X : Type u)
Goal: (typeToPointed.obj X).point = none
-- typeToPointed_map_toFun
@[simps]
def typeToPointed : Type u ⥤ Pointed.{u} 
Goal: ∀ {X Y : Type u} (f : X ⟶ Y) (a : Option X), (typeToPointed.map f).toFun a = Option.map f a
-- PartialFun.Iso.mk_inv
@[simps]
def Iso.mk {α β : PartialFun.{u}} (e : α ≃ β) : α ≅ β 
Arguments: {α β : PartialFun} (e : α ≃ β) (x : β)
Goal: (PartialFun.Iso.mk e).inv x = ↑(some (e.symm x))
-- PartialFun.Iso.mk_hom
@[simps]
def Iso.mk {α β : PartialFun.{u}} (e : α ≃ β) : α ≅ β 
Arguments: {α β : PartialFun} (e : α ≃ β) (x : α)
Goal: (PartialFun.Iso.mk e).hom x = ↑(some (e x))
-- pointedToPartialFun_map
@[simps obj map]
def pointedToPartialFun : Pointed.{u} ⥤ PartialFun 
Goal: ∀ {X Y : Pointed} (f : X ⟶ Y) (a : { x // x ≠ X.point }),
  pointedToPartialFun.map f a = (PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val) a
-- pointedToPartialFun_obj
@[simps obj map]
def pointedToPartialFun : Pointed.{u} ⥤ PartialFun 
Arguments: (X : Pointed)
Goal: pointedToPartialFun.obj X = { x // x ≠ X.point }
-- partialFunToPointed_obj
@[simps obj map]
noncomputable def partialFunToPointed : PartialFun ⥤ Pointed 
Arguments: (X : PartialFun)
Goal: partialFunToPointed.obj X = { X := Option X, point := none }
-- partialFunToPointed_map
@[simps obj map]
noncomputable def partialFunToPointed : PartialFun ⥤ Pointed 
Goal: ∀ {X Y : PartialFun} (f : X ⟶ Y),
  partialFunToPointed.map f = { toFun := Option.elim' none fun a => (f a).toOption, map_point := ⋯ }
-- partialFunEquivPointed_inverse_map_get_coe
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Goal: ∀ {X Y : Pointed} (f : X ⟶ Y) (a : { x // x ≠ X.point }) (property : f.toFun ↑a ≠ Y.point),
  ↑((partialFunEquivPointed.inverse.map f a).get property) = f.toFun ↑a
-- partialFunEquivPointed_functor_obj_X
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Arguments: (X : PartialFun)
Goal: (partialFunEquivPointed.functor.obj X).X = Option X
-- partialFunEquivPointed_functor_map_toFun
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Goal: ∀ {X Y : PartialFun} (f : X ⟶ Y) (a : Option X),
  (partialFunEquivPointed.functor.map f).toFun a = Option.elim' none (fun a => (f a).toOption) a
-- partialFunEquivPointed_functor_obj_point
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Arguments: (X : PartialFun)
Goal: (partialFunEquivPointed.functor.obj X).point = none
-- partialFunEquivPointed_inverse_map_Dom
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Goal: ∀ {X Y : Pointed} (f : X ⟶ Y) (a : { x // x ≠ X.point }),
  (partialFunEquivPointed.inverse.map f a).Dom = ¬f.toFun ↑a = Y.point
-- partialFunEquivPointed_unitIso_hom_app
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Arguments: (X : PartialFun)
Goal: partialFunEquivPointed.unitIso.hom.app X =
  (PartialFun.Iso.mk
        { toFun := fun a => ⟨some a, ⋯⟩, invFun := fun a => (↑a).get ⋯, left_inv := ⋯, right_inv := ⋯ }).hom ≫
    pointedToPartialFun.map (Pointed.Iso.mk (Equiv.optionSubtypeNe none) ⋯).inv ≫
      pointedToPartialFun.map { toFun := Option.elim' none fun a => ↑a, map_point := ⋯ }
-- partialFunEquivPointed_counitIso_hom_app_toFun
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Arguments: (X : Pointed) (a : ((pointedToPartialFun ⋙ partialFunToPointed).obj X).X)
Goal: (partialFunEquivPointed.counitIso.hom.app X).toFun a = Option.casesOn' a X.point Subtype.val
-- partialFunEquivPointed_inverse_obj
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Arguments: (X : Pointed)
Goal: partialFunEquivPointed.inverse.obj X = { x // ¬x = X.point }
-- partialFunEquivPointed_unitIso_inv_app
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Arguments: (X : PartialFun)
Goal: partialFunEquivPointed.unitIso.inv.app X =
  pointedToPartialFun.map { toFun := Option.elim' none fun a => some ⟨some a, ⋯⟩, map_point := ⋯ } ≫
    pointedToPartialFun.map (Pointed.Iso.mk (Equiv.optionSubtypeNe none) ⋯).hom ≫
      (PartialFun.Iso.mk
          { toFun := fun a => ⟨some a, ⋯⟩, invFun := fun a => (↑a).get ⋯, left_inv := ⋯, right_inv := ⋯ }).inv
-- partialFunEquivPointed_counitIso_inv_app_toFun
@[simps!]
noncomputable def partialFunEquivPointed : PartialFun.{u} ≌ Pointed 
Arguments: (X : Pointed) (a : ((𝟭 Pointed).obj X).X)
Goal: (partialFunEquivPointed.counitIso.inv.app X).toFun a = if h : a = X.point then none else some ⟨a, h⟩
-- typeToPartialFunIsoPartialFunToPointed_hom_app_toFun
@[simps!]
noncomputable def typeToPartialFunIsoPartialFunToPointed :
    typeToPartialFun ⋙ partialFunToPointed ≅ typeToPointed 
Arguments: (X : Type u_3) (a : ((typeToPartialFun ⋙ partialFunToPointed).obj X).X)
Goal: (typeToPartialFunIsoPartialFunToPointed.hom.app X).toFun a = a
-- typeToPartialFunIsoPartialFunToPointed_inv_app_toFun
@[simps!]
noncomputable def typeToPartialFunIsoPartialFunToPointed :
    typeToPartialFun ⋙ partialFunToPointed ≅ typeToPointed 
Arguments: (X : Type u_3) (a : (typeToPointed.obj X).X)
Goal: (typeToPartialFunIsoPartialFunToPointed.inv.app X).toFun a = a
-- CategoryTheory.Factorisation.ι_π
structure Factorisation {X Y : C} (f : X ⟶ Y) where
    mid : C
    ι   : X ⟶ mid
    π   : mid ⟶ Y
    ι_π : ι ≫ π = f := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (self : CategoryTheory.Factorisation f)
Goal: CategoryTheory.CategoryStruct.comp self.ι self.π = f
-- CategoryTheory.Factorisation.Hom.ι_h
@[ext]
protected structure Hom (d e : Factorisation f) : Type (max u v) where
    h : d.mid ⟶ e.mid
    ι_h : d.ι ≫ h = e.ι := by aesop_cat
    h_π : h ≫ e.π = d.π := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {d e : CategoryTheory.Factorisation f} (self : d.Hom e)
Goal: CategoryTheory.CategoryStruct.comp d.ι self.h = e.ι
-- CategoryTheory.Factorisation.Hom.h_π
@[ext]
protected structure Hom (d e : Factorisation f) : Type (max u v) where
    h : d.mid ⟶ e.mid
    ι_h : d.ι ≫ h = e.ι := by aesop_cat
    h_π : h ≫ e.π = d.π := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {d e : CategoryTheory.Factorisation f} (self : d.Hom e)
Goal: CategoryTheory.CategoryStruct.comp self.h e.π = d.π
-- CategoryTheory.Factorisation.Hom.id_h
@[simps]
protected def Hom.id (d : Factorisation f) : Factorisation.Hom d d 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : CategoryTheory.Factorisation f)
Goal: (CategoryTheory.Factorisation.Hom.id d).h = CategoryTheory.CategoryStruct.id d.mid
-- CategoryTheory.Factorisation.Hom.comp_h
@[simps]
protected def Hom.comp {d₁ d₂ d₃ : Factorisation f}
    (f : Factorisation.Hom d₁ d₂) (g : Factorisation.Hom d₂ d₃) : Factorisation.Hom d₁ d₃ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {d₁ d₂ d₃ : CategoryTheory.Factorisation f}
Goal: ∀ (f_1 : d₁.Hom d₂) (g : d₂.Hom d₃), (f_1.comp g).h = CategoryTheory.CategoryStruct.comp f_1.h g.h
-- CategoryTheory.Factorisation.initial_ι
@[simps]
protected def initial : Factorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
Goal: CategoryTheory.Factorisation.initial.ι = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Factorisation.initial_π
@[simps]
protected def initial : Factorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
Goal: CategoryTheory.Factorisation.initial.π = f
-- CategoryTheory.Factorisation.initial_mid
@[simps]
protected def initial : Factorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
Goal: CategoryTheory.Factorisation.initial.mid = X
-- CategoryTheory.Factorisation.initialHom_h
@[simps]
protected def initialHom (d : Factorisation f) :
    Factorisation.Hom (Factorisation.initial : Factorisation f) d 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : CategoryTheory.Factorisation f)
Goal: d.initialHom.h = d.ι
-- CategoryTheory.Factorisation.terminal_mid
@[simps]
protected def terminal : Factorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
Goal: CategoryTheory.Factorisation.terminal.mid = Y
-- CategoryTheory.Factorisation.terminal_ι
@[simps]
protected def terminal : Factorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
Goal: CategoryTheory.Factorisation.terminal.ι = f
-- CategoryTheory.Factorisation.terminal_π
@[simps]
protected def terminal : Factorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
Goal: CategoryTheory.Factorisation.terminal.π = CategoryTheory.CategoryStruct.id Y
-- CategoryTheory.Factorisation.terminalHom_h
@[simps]
protected def terminalHom (d : Factorisation f) :
    Factorisation.Hom d (Factorisation.terminal : Factorisation f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : CategoryTheory.Factorisation f)
Goal: d.terminalHom.h = d.π
-- CategoryTheory.Factorisation.forget_map
@[simps]
def forget : Factorisation f ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
Goal: ∀ {X_1 Y_1 : CategoryTheory.Factorisation f} (f_1 : X_1 ⟶ Y_1), CategoryTheory.Factorisation.forget.map f_1 = f_1.h
-- CategoryTheory.Factorisation.forget_obj
@[simps]
def forget : Factorisation f ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (self : CategoryTheory.Factorisation f)
Goal: CategoryTheory.Factorisation.forget.obj self = self.mid
-- CategoryTheory.Cat.id_map
@[simp]
theorem id_map {C : Cat} {X Y : C} (f : X ⟶ Y) : (𝟙 C : C ⥤ C).map f = f 
Arguments: {C : CategoryTheory.Cat} {X Y : ↑C} (f : X ⟶ Y)
Goal: (CategoryTheory.CategoryStruct.id C).map f = f
-- CategoryTheory.Cat.comp_obj
@[simp]
theorem comp_obj {C D E : Cat} (F : C ⟶ D) (G : D ⟶ E) (X : C) : (F ≫ G).obj X = G.obj (F.obj X) 
Arguments: {C D E : CategoryTheory.Cat} (F : C ⟶ D) (G : D ⟶ E) (X : ↑C)
Goal: (CategoryTheory.CategoryStruct.comp F G).obj X = G.obj (F.obj X)
-- CategoryTheory.Cat.comp_map
@[simp]
theorem comp_map {C D E : Cat} (F : C ⟶ D) (G : D ⟶ E) {X Y : C} (f : X ⟶ Y) :
    (F ≫ G).map f = G.map (F.map f) 
Arguments: {C D E : CategoryTheory.Cat} (F : C ⟶ D) (G : D ⟶ E) {X Y : ↑C} (f : X ⟶ Y)
Goal: (CategoryTheory.CategoryStruct.comp F G).map f = G.map (F.map f)
-- CategoryTheory.Cat.whiskerLeft_app
@[simp]
lemma whiskerLeft_app {C D E : Cat} (F : C ⟶ D) {G H : D ⟶ E} (η : G ⟶ H) (X : C) :
    (F ◁ η).app X = η.app (F.obj X) 
Arguments: {C D E : CategoryTheory.Cat} (F : C ⟶ D) {G H : D ⟶ E} (η : G ⟶ H) (X : ↑C)
Goal: (CategoryTheory.Bicategory.whiskerLeft F η).app X = η.app (F.obj X)