ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.RelCat.opEquivalence_inverse
@[simps]
def opEquivalence : Equivalence RelCat RelCatᵒᵖ 
Goal: CategoryTheory.RelCat.opEquivalence.inverse = CategoryTheory.RelCat.unopFunctor
-- CategoryTheory.Pairwise.cocone_ι_app
@[simps]
def cocone : Cocone (diagram U) 
Arguments: {ι α : Type v} (U : ι → α) [CompleteLattice α] (o : CategoryTheory.Pairwise ι)
Goal: (CategoryTheory.Pairwise.cocone U).ι.app o = CategoryTheory.Pairwise.coconeιApp U o
-- CategoryTheory.Pairwise.cocone_pt
@[simps]
def cocone : Cocone (diagram U) 
Arguments: {ι α : Type v} (U : ι → α) [CompleteLattice α]
Goal: (CategoryTheory.Pairwise.cocone U).pt = iSup U
-- CategoryTheory.ULift.upFunctor_obj_down
@[simps]
def ULift.upFunctor : C ⥤ ULift.{u₂} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (down : C)
Goal: (CategoryTheory.ULift.upFunctor.obj down).down = down
-- CategoryTheory.ULift.upFunctor_map
@[simps]
def ULift.upFunctor : C ⥤ ULift.{u₂} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.ULift.upFunctor.map f = f
-- CategoryTheory.ULift.downFunctor_map
@[simps]
def ULift.downFunctor : ULift.{u₂} C ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : ULift.{u₂, u₁} C} (f : X ⟶ Y), CategoryTheory.ULift.downFunctor.map f = f
-- CategoryTheory.ULift.downFunctor_obj
@[simps]
def ULift.downFunctor : ULift.{u₂} C ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (self : ULift.{u₂, u₁} C)
Goal: CategoryTheory.ULift.downFunctor.obj self = self.down
-- CategoryTheory.ULift.equivalence_counitIso_hom_app
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : ULift.{u₂, u₁} C)
Goal: CategoryTheory.ULift.equivalence.counitIso.hom.app X =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.ULift.downFunctor.comp CategoryTheory.ULift.upFunctor).obj X)
-- CategoryTheory.ULift.equivalence_functor
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.ULift.equivalence.functor = CategoryTheory.ULift.upFunctor
-- CategoryTheory.ULift.equivalence_inverse
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.ULift.equivalence.inverse = CategoryTheory.ULift.downFunctor
-- CategoryTheory.ULift.equivalence_unitIso_inv
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.ULift.equivalence.unitIso.inv =
  CategoryTheory.CategoryStruct.id (CategoryTheory.ULift.upFunctor.comp CategoryTheory.ULift.downFunctor)
-- CategoryTheory.ULift.equivalence_unitIso_hom
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.ULift.equivalence.unitIso.hom = CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)
-- CategoryTheory.ULift.equivalence_counitIso_inv_app
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : ULift.{u₂, u₁} C)
Goal: CategoryTheory.ULift.equivalence.counitIso.inv.app X =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id (ULift.{u₂, u₁} C)).obj X)
-- CategoryTheory.objDown_objUp
@[simp]
theorem objDown_objUp {C} (A : C) : (ULiftHom.objUp A).objDown = A 
Arguments: {C : Type u_1} (A : C)
Goal: (CategoryTheory.ULiftHom.objUp A).objDown = A
-- CategoryTheory.objUp_objDown
@[simp]
theorem objUp_objDown {C} (A : ULiftHom C) : ULiftHom.objUp A.objDown = A 
Arguments: {C : Type u_1} (A : CategoryTheory.ULiftHom C)
Goal: CategoryTheory.ULiftHom.objUp A.objDown = A
-- CategoryTheory.ULiftHom.up_obj
@[simps]
def ULiftHom.up : C ⥤ ULiftHom C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (A : C)
Goal: CategoryTheory.ULiftHom.up.obj A = CategoryTheory.ULiftHom.objUp A
-- CategoryTheory.ULiftHom.up_map_down
@[simps]
def ULiftHom.up : C ⥤ ULiftHom C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.ULiftHom.up.map f).down = f
-- CategoryTheory.ULiftHom.down_map
@[simps]
def ULiftHom.down : ULiftHom C ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : CategoryTheory.ULiftHom C} (f : X ⟶ Y), CategoryTheory.ULiftHom.down.map f = f.down
-- CategoryTheory.ULiftHom.down_obj
@[simps]
def ULiftHom.down : ULiftHom C ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (A : CategoryTheory.ULiftHom C)
Goal: CategoryTheory.ULiftHom.down.obj A = A.objDown
-- CategoryTheory.AsSmall.up_obj_down
@[simps]
def AsSmall.up : C ⥤ AsSmall C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.AsSmall.up.obj X).down = X
-- CategoryTheory.AsSmall.up_map_down
@[simps]
def AsSmall.up : C ⥤ AsSmall C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.AsSmall.up.map f).down = f
-- CategoryTheory.AsSmall.down_obj
@[simps]
def AsSmall.down : AsSmall C ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : CategoryTheory.AsSmall C)
Goal: CategoryTheory.AsSmall.down.obj X = X.down
-- CategoryTheory.AsSmall.down_map
@[simps]
def AsSmall.down : AsSmall C ⥤ C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : CategoryTheory.AsSmall C} (f : X ⟶ Y), CategoryTheory.AsSmall.down.map f = f.down
-- CategoryTheory.AsSmall.equiv_counitIso
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.AsSmall.equiv.counitIso = CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.eqToIso ⋯) ⋯
-- CategoryTheory.AsSmall.equiv_unitIso
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.AsSmall.equiv.unitIso = CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.eqToIso ⋯) ⋯
-- CategoryTheory.AsSmall.equiv_functor
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.AsSmall.equiv.functor = CategoryTheory.AsSmall.up
-- CategoryTheory.AsSmall.equiv_inverse
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: CategoryTheory.AsSmall.equiv.inverse = CategoryTheory.AsSmall.down
-- CategoryTheory.HasLiftingProperty.sq_hasLift
class HasLiftingProperty : Prop where
    sq_hasLift : ∀ {f : A ⟶ X} {g : B ⟶ Y} (sq : CommSq f i p g), sq.HasLift
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {i : A ⟶ B} {p : X ⟶ Y} [self : CategoryTheory.HasLiftingProperty i p] {f : A ⟶ X} {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g)
Goal: sq.HasLift
-- CategoryTheory.HasLiftingProperty.op
theorem op (h : HasLiftingProperty i p) : HasLiftingProperty p.op i.op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {i : A ⟶ B} {p : X ⟶ Y} (h : CategoryTheory.HasLiftingProperty i p)
Goal: CategoryTheory.HasLiftingProperty p.op i.op
-- CategoryTheory.HasLiftingProperty.unop
theorem unop {A B X Y : Cᵒᵖ} {i : A ⟶ B} {p : X ⟶ Y} (h : HasLiftingProperty i p) :
    HasLiftingProperty p.unop i.unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : Cᵒᵖ} {i : A ⟶ B} {p : X ⟶ Y} (h : CategoryTheory.HasLiftingProperty i p)
Goal: CategoryTheory.HasLiftingProperty p.unop i.unop
-- CategoryTheory.HasLiftingProperty.iff_op
theorem iff_op : HasLiftingProperty i p ↔ HasLiftingProperty p.op i.op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {i : A ⟶ B} {p : X ⟶ Y}
Goal: CategoryTheory.HasLiftingProperty i p ↔ CategoryTheory.HasLiftingProperty p.op i.op
-- CategoryTheory.HasLiftingProperty.iff_unop
theorem iff_unop {A B X Y : Cᵒᵖ} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty i p ↔ HasLiftingProperty p.unop i.unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : Cᵒᵖ} (i : A ⟶ B) (p : X ⟶ Y)
Goal: CategoryTheory.HasLiftingProperty i p ↔ CategoryTheory.HasLiftingProperty p.unop i.unop
-- CategoryTheory.HasLiftingProperty.of_arrow_iso_left
theorem of_arrow_iso_left {A B A' B' X Y : C} {i : A ⟶ B} {i' : A' ⟶ B'}
    (e : Arrow.mk i ≅ Arrow.mk i') (p : X ⟶ Y) [hip : HasLiftingProperty i p] :
    HasLiftingProperty i' p 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B A' B' X Y : C} {i : A ⟶ B} {i' : A' ⟶ B'} (e : CategoryTheory.Arrow.mk i ≅ CategoryTheory.Arrow.mk i') (p : X ⟶ Y) [hip : CategoryTheory.HasLiftingProperty i p]
Goal: CategoryTheory.HasLiftingProperty i' p
-- CategoryTheory.HasLiftingProperty.of_arrow_iso_right
theorem of_arrow_iso_right {A B X Y X' Y' : C} (i : A ⟶ B) {p : X ⟶ Y} {p' : X' ⟶ Y'}
    (e : Arrow.mk p ≅ Arrow.mk p') [hip : HasLiftingProperty i p] : HasLiftingProperty i p' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y X' Y' : C} (i : A ⟶ B) {p : X ⟶ Y} {p' : X' ⟶ Y'} (e : CategoryTheory.Arrow.mk p ≅ CategoryTheory.Arrow.mk p') [hip : CategoryTheory.HasLiftingProperty i p]
Goal: CategoryTheory.HasLiftingProperty i p'
-- CategoryTheory.HasLiftingProperty.iff_of_arrow_iso_left
theorem iff_of_arrow_iso_left {A B A' B' X Y : C} {i : A ⟶ B} {i' : A' ⟶ B'}
    (e : Arrow.mk i ≅ Arrow.mk i') (p : X ⟶ Y) :
    HasLiftingProperty i p ↔ HasLiftingProperty i' p 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B A' B' X Y : C} {i : A ⟶ B} {i' : A' ⟶ B'} (e : CategoryTheory.Arrow.mk i ≅ CategoryTheory.Arrow.mk i') (p : X ⟶ Y)
Goal: CategoryTheory.HasLiftingProperty i p ↔ CategoryTheory.HasLiftingProperty i' p
-- CategoryTheory.HasLiftingProperty.iff_of_arrow_iso_right
theorem iff_of_arrow_iso_right {A B X Y X' Y' : C} (i : A ⟶ B) {p : X ⟶ Y} {p' : X' ⟶ Y'}
    (e : Arrow.mk p ≅ Arrow.mk p') : HasLiftingProperty i p ↔ HasLiftingProperty i p' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y X' Y' : C} (i : A ⟶ B) {p : X ⟶ Y} {p' : X' ⟶ Y'} (e : CategoryTheory.Arrow.mk p ≅ CategoryTheory.Arrow.mk p')
Goal: CategoryTheory.HasLiftingProperty i p ↔ CategoryTheory.HasLiftingProperty i p'
-- CategoryTheory.homOfLE_refl
@[simp]
theorem homOfLE_refl {x : X} (h : x ≤ x) : h.hom = 𝟙 x 
Arguments: {X : Type u} [Preorder X] {x : X} (h : x ≤ x)
Goal: h.hom = CategoryTheory.CategoryStruct.id x
-- CategoryTheory.homOfLE_comp
@[simp]
theorem homOfLE_comp {x y z : X} (h : x ≤ y) (k : y ≤ z) :
    homOfLE h ≫ homOfLE k = homOfLE (h.trans k) 
Arguments: {X : Type u} [Preorder X] {x y z : X} (h : x ≤ y) (k : y ≤ z)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.homOfLE h) (CategoryTheory.homOfLE k) = CategoryTheory.homOfLE ⋯
-- CategoryTheory.leOfHom
theorem leOfHom {x y : X} (h : x ⟶ y) : x ≤ y 
Arguments: {X : Type u} [Preorder X] {x y : X} (h : x ⟶ y)
Goal: x ≤ y
-- CategoryTheory.leOfHom_homOfLE
theorem leOfHom_homOfLE {x y : X} (h : x ≤ y) : h.hom.le = h 
Arguments: {X : Type u} [Preorder X] {x y : X} (h : x ≤ y)
Goal: ⋯ = h
-- CategoryTheory.homOfLE_leOfHom
theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.hom = h 
Arguments: {X : Type u} [Preorder X] {x y : X} (h : x ⟶ y)
Goal: ⋯.hom = h
-- CategoryTheory.homOfLE_isIso_of_eq
lemma homOfLE_isIso_of_eq {x y : X} (h : x ≤ y) (heq : x = y) :
    IsIso (homOfLE h) 
Arguments: {X : Type u} [Preorder X] {x y : X} (h : x ≤ y) (heq : x = y)
Goal: CategoryTheory.IsIso (CategoryTheory.homOfLE h)
-- CategoryTheory.homOfLE_comp_eqToHom
@[simp, reassoc]
lemma homOfLE_comp_eqToHom {a b c : X} (hab : a ≤ b) (hbc : b = c) :
    homOfLE hab ≫ eqToHom hbc = homOfLE (hab.trans (le_of_eq hbc)) 
Arguments: {X : Type u} [Preorder X] {a b c : X} (hab : a ≤ b) (hbc : b = c)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.homOfLE hab) (CategoryTheory.eqToHom hbc) = CategoryTheory.homOfLE ⋯
-- CategoryTheory.eqToHom_comp_homOfLE
@[simp, reassoc]
lemma eqToHom_comp_homOfLE {a b c : X} (hab : a = b) (hbc : b ≤ c) :
    eqToHom hab ≫ homOfLE hbc = homOfLE ((le_of_eq hab).trans hbc) 
Arguments: {X : Type u} [Preorder X] {a b c : X} (hab : a = b) (hbc : b ≤ c)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom hab) (CategoryTheory.homOfLE hbc) = CategoryTheory.homOfLE ⋯
-- CategoryTheory.homOfLE_op_comp_eqToHom
@[simp, reassoc]
lemma homOfLE_op_comp_eqToHom {a b c : X} (hab : b ≤ a) (hbc : op b = op c) :
    (homOfLE hab).op ≫ eqToHom hbc = (homOfLE ((le_of_eq (op_injective hbc.symm)).trans hab)).op 
Arguments: {X : Type u} [Preorder X] {a b c : X} (hab : b ≤ a) (hbc : Opposite.op b = Opposite.op c)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.homOfLE hab).op (CategoryTheory.eqToHom hbc) =
  (CategoryTheory.homOfLE ⋯).op
-- CategoryTheory.eqToHom_comp_homOfLE_op
@[simp, reassoc]
lemma eqToHom_comp_homOfLE_op {a b c : X} (hab : op a = op b) (hbc : c ≤ b) :
    eqToHom hab ≫ (homOfLE hbc).op = (homOfLE (hbc.trans (le_of_eq (op_injective hab.symm)))).op 
Arguments: {X : Type u} [Preorder X] {a b c : X} (hab : Opposite.op a = Opposite.op b) (hbc : c ≤ b)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom hab) (CategoryTheory.homOfLE hbc).op =
  (CategoryTheory.homOfLE ⋯).op
-- CategoryTheory.le_of_op_hom
theorem le_of_op_hom {x y : Xᵒᵖ} (h : x ⟶ y) : unop y ≤ unop x 
Arguments: {X : Type u} [Preorder X] {x y : Xᵒᵖ} (h : x ⟶ y)
Goal: Opposite.unop y ≤ Opposite.unop x
-- CategoryTheory.orderDualEquivalence_inverse_map
@[simps]
def orderDualEquivalence : Xᵒᵈ ≌ Xᵒᵖ 
Arguments: (X : Type u) [Preorder X]
Goal: ∀ {X_1 Y : Xᵒᵖ} (f : X_1 ⟶ Y), (CategoryTheory.orderDualEquivalence X).inverse.map f = CategoryTheory.homOfLE ⋯
-- CategoryTheory.orderDualEquivalence_functor_map
@[simps]
def orderDualEquivalence : Xᵒᵈ ≌ Xᵒᵖ 
Arguments: (X : Type u) [Preorder X]
Goal: ∀ {X_1 Y : Xᵒᵈ} (f : X_1 ⟶ Y), (CategoryTheory.orderDualEquivalence X).functor.map f = (CategoryTheory.homOfLE ⋯).op
-- CategoryTheory.orderDualEquivalence_inverse_obj
@[simps]
def orderDualEquivalence : Xᵒᵈ ≌ Xᵒᵖ 
Arguments: (X : Type u) [Preorder X] (x : Xᵒᵖ)
Goal: (CategoryTheory.orderDualEquivalence X).inverse.obj x = OrderDual.toDual (Opposite.unop x)
-- CategoryTheory.orderDualEquivalence_unitIso
@[simps]
def orderDualEquivalence : Xᵒᵈ ≌ Xᵒᵖ 
Arguments: (X : Type u) [Preorder X]
Goal: (CategoryTheory.orderDualEquivalence X).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id Xᵒᵈ)
-- CategoryTheory.orderDualEquivalence_functor_obj
@[simps]
def orderDualEquivalence : Xᵒᵈ ≌ Xᵒᵖ 
Arguments: (X : Type u) [Preorder X] (x : Xᵒᵈ)
Goal: (CategoryTheory.orderDualEquivalence X).functor.obj x = Opposite.op (OrderDual.ofDual x)
-- CategoryTheory.orderDualEquivalence_counitIso
@[simps]
def orderDualEquivalence : Xᵒᵈ ≌ Xᵒᵖ 
Arguments: (X : Type u) [Preorder X]
Goal: (CategoryTheory.orderDualEquivalence X).counitIso =
  CategoryTheory.Iso.refl
    ({ obj := fun x => OrderDual.toDual (Opposite.unop x), map := fun {X_1 Y} f => CategoryTheory.homOfLE ⋯,
          map_id := ⋯, map_comp := ⋯ }.comp
      { obj := fun x => Opposite.op (OrderDual.ofDual x), map := fun {X_1 Y} f => (CategoryTheory.homOfLE ⋯).op,
        map_id := ⋯, map_comp := ⋯ })
-- Monotone.functor_obj
@[simp]
theorem Monotone.functor_obj {f : X → Y} (h : Monotone f) : h.functor.obj = f 
Arguments: {X : Type u} {Y : Type v} [Preorder X] [Preorder Y] {f : X → Y} (h : Monotone f)
Goal: h.functor.obj = f
-- OrderIso.equivalence_unitIso
@[simps]
def OrderIso.equivalence (e : X ≃o Y) : X ≌ Y 
Arguments: {X : Type u} {Y : Type v} [Preorder X] [Preorder Y] (e : X ≃o Y)
Goal: e.equivalence.unitIso = CategoryTheory.NatIso.ofComponents (fun x => CategoryTheory.eqToIso ⋯) ⋯
-- OrderIso.equivalence_functor
@[simps]
def OrderIso.equivalence (e : X ≃o Y) : X ≌ Y 
Arguments: {X : Type u} {Y : Type v} [Preorder X] [Preorder Y] (e : X ≃o Y)
Goal: e.equivalence.functor = ⋯.functor
-- OrderIso.equivalence_counitIso
@[simps]
def OrderIso.equivalence (e : X ≃o Y) : X ≌ Y 
Arguments: {X : Type u} {Y : Type v} [Preorder X] [Preorder Y] (e : X ≃o Y)
Goal: e.equivalence.counitIso = CategoryTheory.NatIso.ofComponents (fun x => CategoryTheory.eqToIso ⋯) ⋯
-- OrderIso.equivalence_inverse
@[simps]
def OrderIso.equivalence (e : X ≃o Y) : X ≌ Y 
Arguments: {X : Type u} {Y : Type v} [Preorder X] [Preorder Y] (e : X ≃o Y)
Goal: e.equivalence.inverse = ⋯.functor
-- CategoryTheory.Functor.monotone
@[mono]
theorem Functor.monotone (f : X ⥤ Y) : Monotone f.obj 
Arguments: {X : Type u} {Y : Type v} [Preorder X] [Preorder Y] (f : CategoryTheory.Functor X Y)
Goal: Monotone f.obj
-- CategoryTheory.Iso.to_eq
theorem Iso.to_eq {x y : X} (f : x ≅ y) : x = y 
Arguments: {X : Type u} [PartialOrder X] {x y : X} (f : x ≅ y)
Goal: x = y
-- CategoryTheory.Equivalence.toOrderIso_apply
@[simp]
theorem Equivalence.toOrderIso_apply (e : X ≌ Y) (x : X) : e.toOrderIso x = e.functor.obj x 
Arguments: {X : Type u} {Y : Type v} [PartialOrder X] [PartialOrder Y] (e : X ≌ Y) (x : X)
Goal: e.toOrderIso x = e.functor.obj x
-- CategoryTheory.Equivalence.toOrderIso_symm_apply
@[simp]
theorem Equivalence.toOrderIso_symm_apply (e : X ≌ Y) (y : Y) :
    e.toOrderIso.symm y = e.inverse.obj y 
Arguments: {X : Type u} {Y : Type v} [PartialOrder X] [PartialOrder Y] (e : X ≌ Y) (y : Y)
Goal: e.toOrderIso.symm y = e.inverse.obj y
-- Bipointed.coe_of
@[simp]
theorem coe_of {X : Type*} (to_prod : X × X) : ↥(of to_prod) = X 
Arguments: {X : Type u_3} (to_prod : X × X)
Goal: (Bipointed.of to_prod).X = X
-- Bipointed.Hom.map_fst
@[ext]
protected structure Hom (X Y : Bipointed.{u}) : Type u where
    toFun : X → Y
  map_fst : toFun X.toProd.1 = Y.toProd.1
  map_snd : toFun X.toProd.2 = Y.toProd.2
Arguments: {X Y : Bipointed} (self : X.Hom Y)
Goal: self.toFun X.toProd.1 = Y.toProd.1
-- Bipointed.Hom.map_snd
@[ext]
protected structure Hom (X Y : Bipointed.{u}) : Type u where
    toFun : X → Y
  map_fst : toFun X.toProd.1 = Y.toProd.1
  map_snd : toFun X.toProd.2 = Y.toProd.2
Arguments: {X Y : Bipointed} (self : X.Hom Y)
Goal: self.toFun X.toProd.2 = Y.toProd.2
-- Bipointed.Hom.id_toFun
@[simps]
nonrec def id (X : Bipointed) : Bipointed.Hom X X 
Arguments: (X : Bipointed) (a : X.X)
Goal: (Bipointed.Hom.id X).toFun a = id a
-- Bipointed.Hom.comp_toFun
@[simps]
def comp {X Y Z : Bipointed.{u}} (f : Bipointed.Hom X Y) (g : Bipointed.Hom Y Z) :
    Bipointed.Hom X Z 
Arguments: {X Y Z : Bipointed} (f : X.Hom Y) (g : Y.Hom Z)
Goal: ∀ (a : X.X), (f.comp g).toFun a = (g.toFun ∘ f.toFun) a
-- Bipointed.swap_obj_X
@[simps]
def swap : Bipointed ⥤ Bipointed 
Arguments: (X : Bipointed)
Goal: (Bipointed.swap.obj X).X = X.X
-- Bipointed.swap_obj_toProd
@[simps]
def swap : Bipointed ⥤ Bipointed 
Arguments: (X : Bipointed)
Goal: (Bipointed.swap.obj X).toProd = X.toProd.swap
-- Bipointed.swap_map_toFun
@[simps]
def swap : Bipointed ⥤ Bipointed 
Goal: ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swap.map f).toFun a = f.toFun a
-- Bipointed.swapEquiv_counitIso_inv_app_toFun
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Arguments: (X : Bipointed) (a : ((𝟭 Bipointed).obj X).X)
Goal: (Bipointed.swapEquiv.counitIso.inv.app X).toFun a = a
-- Bipointed.swapEquiv_inverse_obj_toProd
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Arguments: (X : Bipointed)
Goal: (Bipointed.swapEquiv.inverse.obj X).toProd = X.toProd.swap
-- Bipointed.swapEquiv_functor_obj_X
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Arguments: (X : Bipointed)
Goal: (Bipointed.swapEquiv.functor.obj X).X = X.X
-- Bipointed.swapEquiv_unitIso_inv_app_toFun
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Arguments: (X : Bipointed)
Goal: ∀ (a : ((Bipointed.swap ⋙ Bipointed.swap).obj X).X),
  (Bipointed.swapEquiv.unitIso.inv.app X).toFun a =
    (Bipointed.swap.map (Bipointed.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ }) ≫
          Bipointed.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫
            { toFun := id, map_fst := ⋯, map_snd := ⋯ }).toFun
      ((𝟙 (Bipointed.swap.obj (Bipointed.swap.obj X))).toFun a)
-- Bipointed.swapEquiv_functor_obj_toProd
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Arguments: (X : Bipointed)
Goal: (Bipointed.swapEquiv.functor.obj X).toProd = X.toProd.swap
-- Bipointed.swapEquiv_inverse_obj_X
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Arguments: (X : Bipointed)
Goal: (Bipointed.swapEquiv.inverse.obj X).X = X.X
-- Bipointed.swapEquiv_counitIso_hom_app_toFun
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Arguments: (X : Bipointed) (a : ((Bipointed.swap ⋙ Bipointed.swap).obj X).X)
Goal: (Bipointed.swapEquiv.counitIso.hom.app X).toFun a = a
-- Bipointed.swapEquiv_unitIso_hom_app_toFun
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Arguments: (X : Bipointed)
Goal: ∀ (a : ((𝟭 Bipointed).obj X).X),
  (Bipointed.swapEquiv.unitIso.hom.app X).toFun a =
    (𝟙 (Bipointed.swap.obj (Bipointed.swap.obj X))).toFun
      (({ toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫
            Bipointed.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ } ≫
              Bipointed.swap.map (Bipointed.swap.map { toFun := id, map_fst := ⋯, map_snd := ⋯ })).toFun
        a)
-- Bipointed.swapEquiv_functor_map_toFun
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Goal: ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.functor.map f).toFun a = f.toFun a
-- Bipointed.swapEquiv_inverse_map_toFun
@[simps!]
def swapEquiv : Bipointed ≌ Bipointed 
Goal: ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.inverse.map f).toFun a = f.toFun a
-- Bipointed.swapEquiv_symm
@[simp]
theorem swapEquiv_symm : swapEquiv.symm = swapEquiv 
Goal: Bipointed.swapEquiv.symm = Bipointed.swapEquiv
-- bipointedToPointedFst_comp_forget
@[simp]
theorem bipointedToPointedFst_comp_forget :
    bipointedToPointedFst ⋙ forget Pointed = forget Bipointed 
Goal: bipointedToPointedFst ⋙ CategoryTheory.forget Pointed = CategoryTheory.forget Bipointed
-- bipointedToPointedSnd_comp_forget
@[simp]
theorem bipointedToPointedSnd_comp_forget :
    bipointedToPointedSnd ⋙ forget Pointed = forget Bipointed 
Goal: bipointedToPointedSnd ⋙ CategoryTheory.forget Pointed = CategoryTheory.forget Bipointed
-- swap_comp_bipointedToPointedFst
@[simp]
theorem swap_comp_bipointedToPointedFst :
    Bipointed.swap ⋙ bipointedToPointedFst = bipointedToPointedSnd 
Goal: Bipointed.swap ⋙ bipointedToPointedFst = bipointedToPointedSnd
-- swap_comp_bipointedToPointedSnd
@[simp]
theorem swap_comp_bipointedToPointedSnd :
    Bipointed.swap ⋙ bipointedToPointedSnd = bipointedToPointedFst 
Goal: Bipointed.swap ⋙ bipointedToPointedSnd = bipointedToPointedFst
-- pointedToBipointedFst_comp_swap
@[simp]
theorem pointedToBipointedFst_comp_swap :
    pointedToBipointedFst ⋙ Bipointed.swap = pointedToBipointedSnd 
Goal: pointedToBipointedFst ⋙ Bipointed.swap = pointedToBipointedSnd
-- pointedToBipointedSnd_comp_swap
@[simp]
theorem pointedToBipointedSnd_comp_swap :
    pointedToBipointedSnd ⋙ Bipointed.swap = pointedToBipointedFst 
Goal: pointedToBipointedSnd ⋙ Bipointed.swap = pointedToBipointedFst
-- pointedToBipointedCompBipointedToPointedFst_inv_app_toFun
@[simps!]
def pointedToBipointedCompBipointedToPointedFst :
    pointedToBipointed ⋙ bipointedToPointedFst ≅ 𝟭 _ 
Arguments: (X : Pointed) (a : ((𝟭 Pointed).obj X).X)
Goal: (pointedToBipointedCompBipointedToPointedFst.inv.app X).toFun a = a
-- pointedToBipointedCompBipointedToPointedFst_hom_app_toFun
@[simps!]
def pointedToBipointedCompBipointedToPointedFst :
    pointedToBipointed ⋙ bipointedToPointedFst ≅ 𝟭 _ 
Arguments: (X : Pointed) (a : ((pointedToBipointed ⋙ bipointedToPointedFst).obj X).X)
Goal: (pointedToBipointedCompBipointedToPointedFst.hom.app X).toFun a = a
-- pointedToBipointedCompBipointedToPointedSnd_hom_app_toFun
@[simps!]
def pointedToBipointedCompBipointedToPointedSnd :
    pointedToBipointed ⋙ bipointedToPointedSnd ≅ 𝟭 _ 
Arguments: (X : Pointed) (a : ((pointedToBipointed ⋙ bipointedToPointedSnd).obj X).X)
Goal: (pointedToBipointedCompBipointedToPointedSnd.hom.app X).toFun a = a
-- pointedToBipointedCompBipointedToPointedSnd_inv_app_toFun
@[simps!]
def pointedToBipointedCompBipointedToPointedSnd :
    pointedToBipointed ⋙ bipointedToPointedSnd ≅ 𝟭 _ 
Arguments: (X : Pointed) (a : ((𝟭 Pointed).obj X).X)
Goal: (pointedToBipointedCompBipointedToPointedSnd.inv.app X).toFun a = a