ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.typeEquiv_functor_map_val_app
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Goal: ∀ {X Y : Type u} (f : X ⟶ Y) (Y_1 : Type uᵒᵖ)
  (g :
    ((fun X =>
            { obj := fun Y => Opposite.unop Y ⟶ X,
              map := fun {X_1 Y} f g => CategoryTheory.CategoryStruct.comp f.unop g, map_id := ⋯, map_comp := ⋯ })
          X).obj
      Y_1)
  (a : Opposite.unop Y_1), (CategoryTheory.typeEquiv.functor.map f).val.app Y_1 g a = f (g a)
-- CategoryTheory.typeEquiv_functor_obj_val_obj
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Arguments: (α : Type u) (Y : Type uᵒᵖ)
Goal: (CategoryTheory.typeEquiv.functor.obj α).val.obj Y = (Opposite.unop Y ⟶ α)
-- CategoryTheory.typeEquiv_unitIso_hom_app
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Arguments: (X : Type u)
Goal: ∀ (a : (CategoryTheory.Functor.id (Type u)).obj X),
  CategoryTheory.typeEquiv.unitIso.hom.app X a =
    CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.evalEquiv (CategoryTheory.yoneda.obj X) ⋯ PUnit.{u + 1}) fun x => a) fun f => f PUnit.unit
-- CategoryTheory.typeEquiv_unitIso_inv_app
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Arguments: (X : Type u)
Goal: ∀
  (a :
    (CategoryTheory.yoneda'.comp
          ((CategoryTheory.sheafOfTypesToPresheaf CategoryTheory.typesGrothendieckTopology).comp
            ((CategoryTheory.evaluation Type uᵒᵖ (Type u)).obj (Opposite.op PUnit.{u + 1})))).obj
      X),
  CategoryTheory.typeEquiv.unitIso.inv.app X a =
    (CategoryTheory.evalEquiv (CategoryTheory.yoneda.obj X) ⋯ PUnit.{u + 1}).symm
      (CategoryTheory.CategoryStruct.comp a fun x x_1 => x) PUnit.unit
-- CategoryTheory.typeEquiv_inverse_map
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Goal: ∀ {X Y : CategoryTheory.SheafOfTypes CategoryTheory.typesGrothendieckTopology} (f : X ⟶ Y)
  (a :
    ((CategoryTheory.evaluation Type uᵒᵖ (Type u)).obj (Opposite.op PUnit.{u + 1})).obj
      ((CategoryTheory.sheafOfTypesToPresheaf CategoryTheory.typesGrothendieckTopology).obj X)),
  CategoryTheory.typeEquiv.inverse.map f a = f.val.app (Opposite.op PUnit.{u + 1}) a
-- CategoryTheory.typeEquiv_counitIso_inv_app_val_app
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Arguments: (X : CategoryTheory.SheafOfTypes CategoryTheory.typesGrothendieckTopology)
Goal: ∀ (X_1 : Type uᵒᵖ) (a : X.val.obj X_1),
  (CategoryTheory.typeEquiv.counitIso.inv.app X).val.app X_1 a =
    (CategoryTheory.evalEquiv X.val ⋯ (Opposite.unop X_1)) a
-- CategoryTheory.typeEquiv_counitIso_hom_app_val_app
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Arguments: (X : CategoryTheory.SheafOfTypes CategoryTheory.typesGrothendieckTopology)
Goal: ∀ (X_1 : Type uᵒᵖ) (a : (CategoryTheory.yoneda.obj (X.val.obj (Opposite.op PUnit.{u + 1}))).obj X_1),
  (CategoryTheory.typeEquiv.counitIso.hom.app X).val.app X_1 a =
    (CategoryTheory.evalEquiv X.val ⋯ (Opposite.unop X_1)).symm a
-- CategoryTheory.typeEquiv_functor_obj_val_map
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Arguments: (α : Type u)
Goal: ∀ {X Y : Type uᵒᵖ} (f : X ⟶ Y) (g : Opposite.unop X ⟶ α) (a : Opposite.unop Y),
  (CategoryTheory.typeEquiv.functor.obj α).val.map f g a = g (f.unop a)
-- CategoryTheory.typeEquiv_inverse_obj
@[simps!]
noncomputable def typeEquiv : Type u ≌ SheafOfTypes typesGrothendieckTopology 
Arguments: (X : CategoryTheory.SheafOfTypes CategoryTheory.typesGrothendieckTopology)
Goal: CategoryTheory.typeEquiv.inverse.obj X = X.val.obj (Opposite.op PUnit.{u + 1})
-- CategoryTheory.subcanonical_typesGrothendieckTopology
theorem subcanonical_typesGrothendieckTopology : Sheaf.Subcanonical typesGrothendieckTopology.{u} 
Goal: CategoryTheory.Sheaf.Subcanonical CategoryTheory.typesGrothendieckTopology
-- CategoryTheory.typesGrothendieckTopology_eq_canonical
theorem typesGrothendieckTopology_eq_canonical :
    typesGrothendieckTopology.{u} = Sheaf.canonicalTopology (Type u) 
Goal: CategoryTheory.typesGrothendieckTopology = CategoryTheory.Sheaf.canonicalTopology (Type u)
-- CategoryTheory.regularTopology.isLocallySurjective_iff
lemma regularTopology.isLocallySurjective_iff [Preregular C] {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G) :
    Presheaf.IsLocallySurjective (regularTopology C) f ↔
      ∀ (X : C) (y : G.obj ⟨X⟩), (∃ (X' : C) (φ : X' ⟶ X) (_ : EffectiveEpi φ) (x : F.obj ⟨X'⟩),
        f.app ⟨X'⟩ x = G.map ⟨φ⟩ y) 
Arguments: {C : Type u_1} (D : Type u_2) [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.ConcreteCategory D] [CategoryTheory.Preregular C] {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G)
Goal: CategoryTheory.Presheaf.IsLocallySurjective (CategoryTheory.regularTopology C) f ↔
  ∀ (X : C) (y : (CategoryTheory.forget D).obj (G.obj (Opposite.op X))),
    ∃ X' φ, ∃ (_ : CategoryTheory.EffectiveEpi φ), ∃ x, (f.app (Opposite.op X')) x = (G.map (Opposite.op φ)) y
-- CategoryTheory.extensiveTopology.surjective_of_isLocallySurjective_sheafOfTypes
lemma extensiveTopology.surjective_of_isLocallySurjective_sheafOfTypes [FinitaryPreExtensive C]
    {F G : Cᵒᵖ ⥤ Type w} (f : F ⟶ G) [PreservesFiniteProducts F] [PreservesFiniteProducts G]
      (h : Presheaf.IsLocallySurjective (extensiveTopology C) f) {X : C} :
        Function.Surjective (f.app (op X)) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.FinitaryPreExtensive C] {F G : Cᵒᵖ ⥤ Type w} (f : F ⟶ G) [CategoryTheory.Limits.PreservesFiniteProducts F] [CategoryTheory.Limits.PreservesFiniteProducts G] (h : CategoryTheory.Presheaf.IsLocallySurjective (CategoryTheory.extensiveTopology C) f) {X : C}
Goal: Function.Surjective (f.app (Opposite.op X))
-- CategoryTheory.extensiveTopology.presheafIsLocallySurjective_iff
lemma extensiveTopology.presheafIsLocallySurjective_iff [FinitaryPreExtensive C] {F G : Cᵒᵖ ⥤ D}
    (f : F ⟶ G) [PreservesFiniteProducts F] [PreservesFiniteProducts G]
      [PreservesFiniteProducts (forget D)] : Presheaf.IsLocallySurjective (extensiveTopology C) f ↔
        ∀ (X : C), Function.Surjective (f.app (op X)) 
Arguments: {C : Type u_1} (D : Type u_2) [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.ConcreteCategory D] [CategoryTheory.FinitaryPreExtensive C] {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G) [CategoryTheory.Limits.PreservesFiniteProducts F] [CategoryTheory.Limits.PreservesFiniteProducts G] [CategoryTheory.Limits.PreservesFiniteProducts (CategoryTheory.forget D)]
Goal: CategoryTheory.Presheaf.IsLocallySurjective (CategoryTheory.extensiveTopology C) f ↔
  ∀ (X : C), Function.Surjective ⇑(f.app (Opposite.op X))
-- CategoryTheory.extensiveTopology.isLocallySurjective_iff
lemma extensiveTopology.isLocallySurjective_iff [FinitaryExtensive C]
    {F G : Sheaf (extensiveTopology C) D} (f : F ⟶ G)
      [PreservesFiniteProducts (forget D)] : IsLocallySurjective f ↔
        ∀ (X : C), Function.Surjective (f.val.app (op X)) 
Arguments: {C : Type u_1} (D : Type u_2) [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.ConcreteCategory D] [CategoryTheory.FinitaryExtensive C] {F G : CategoryTheory.Sheaf (CategoryTheory.extensiveTopology C) D} (f : F ⟶ G) [CategoryTheory.Limits.PreservesFiniteProducts (CategoryTheory.forget D)]
Goal: CategoryTheory.Sheaf.IsLocallySurjective f ↔ ∀ (X : C), Function.Surjective ⇑(f.val.app (Opposite.op X))
-- CategoryTheory.regularTopology.isLocallySurjective_sheafOfTypes
lemma regularTopology.isLocallySurjective_sheafOfTypes [Preregular C] [FinitaryPreExtensive C]
    {F G : Cᵒᵖ ⥤ Type w} (f : F ⟶ G) [PreservesFiniteProducts F] [PreservesFiniteProducts G]
      (h : Presheaf.IsLocallySurjective (coherentTopology C) f) :
        Presheaf.IsLocallySurjective (regularTopology C) f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preregular C] [CategoryTheory.FinitaryPreExtensive C] {F G : Cᵒᵖ ⥤ Type w} (f : F ⟶ G) [CategoryTheory.Limits.PreservesFiniteProducts F] [CategoryTheory.Limits.PreservesFiniteProducts G] (h : CategoryTheory.Presheaf.IsLocallySurjective (CategoryTheory.coherentTopology C) f)
Goal: CategoryTheory.Presheaf.IsLocallySurjective (CategoryTheory.regularTopology C) f
-- CategoryTheory.coherentTopology.presheafIsLocallySurjective_iff
lemma coherentTopology.presheafIsLocallySurjective_iff {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G)
    [Preregular C] [FinitaryPreExtensive C] [PreservesFiniteProducts F] [PreservesFiniteProducts G]
      [PreservesFiniteProducts (forget D)] :
        Presheaf.IsLocallySurjective (coherentTopology C) f ↔
          Presheaf.IsLocallySurjective (regularTopology C) f 
Arguments: {C : Type u_1} (D : Type u_2) [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.ConcreteCategory D] {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G) [CategoryTheory.Preregular C] [CategoryTheory.FinitaryPreExtensive C] [CategoryTheory.Limits.PreservesFiniteProducts F] [CategoryTheory.Limits.PreservesFiniteProducts G] [CategoryTheory.Limits.PreservesFiniteProducts (CategoryTheory.forget D)]
Goal: CategoryTheory.Presheaf.IsLocallySurjective (CategoryTheory.coherentTopology C) f ↔
  CategoryTheory.Presheaf.IsLocallySurjective (CategoryTheory.regularTopology C) f
-- CategoryTheory.coherentTopology.isLocallySurjective_iff
lemma coherentTopology.isLocallySurjective_iff [Preregular C] [FinitaryExtensive C]
    {F G : Sheaf (coherentTopology C) D} (f : F ⟶ G) [PreservesFiniteProducts (forget D)] :
      IsLocallySurjective f ↔ Presheaf.IsLocallySurjective (regularTopology C) f.val 
Arguments: {C : Type u_1} (D : Type u_2) [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.ConcreteCategory D] [CategoryTheory.Preregular C] [CategoryTheory.FinitaryExtensive C] {F G : CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) D} (f : F ⟶ G) [CategoryTheory.Limits.PreservesFiniteProducts (CategoryTheory.forget D)]
Goal: CategoryTheory.Sheaf.IsLocallySurjective f ↔
  CategoryTheory.Presheaf.IsLocallySurjective (CategoryTheory.regularTopology C) f.val
-- CategoryTheory.TwoSquare.ext
@[ext]
lemma ext (w w' : TwoSquare T L R B) (h : ∀ (X : C₁), w.app X = w'.app X) :
    w = w' 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w w' : CategoryTheory.TwoSquare T L R B) (h : ∀ (X : C₁), w.app X = w'.app X)
Goal: w = w'
-- CategoryTheory.TwoSquare.costructuredArrowRightwards_map
@[simps! obj map]
def costructuredArrowRightwards (X₃ : C₃) :
    CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃) 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) (X₃ : C₃)
Goal: ∀ {X Y : CategoryTheory.CostructuredArrow L X₃} (f : X ⟶ Y),
  (w.costructuredArrowRightwards X₃).map f =
    (CategoryTheory.CostructuredArrow.pre T R (B.obj X₃)).map
      ((CategoryTheory.Comma.mapLeft (CategoryTheory.Functor.fromPUnit (B.obj X₃)) w).map
        (CategoryTheory.CostructuredArrow.homMk f.left ⋯))
-- CategoryTheory.TwoSquare.costructuredArrowRightwards_obj
@[simps! obj map]
def costructuredArrowRightwards (X₃ : C₃) :
    CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃) 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) (X₃ : C₃) (X : CategoryTheory.CostructuredArrow L X₃)
Goal: (w.costructuredArrowRightwards X₃).obj X =
  (CategoryTheory.CostructuredArrow.pre T R (B.obj X₃)).obj
    ((CategoryTheory.Comma.mapLeft (CategoryTheory.Functor.fromPUnit (B.obj X₃)) w).obj
      (CategoryTheory.CostructuredArrow.mk (B.map X.hom)))
-- CategoryTheory.TwoSquare.structuredArrowDownwards_obj
@[simps! obj map]
def structuredArrowDownwards (X₂ : C₂) :
    StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) (X₂ : C₂) (X : CategoryTheory.StructuredArrow X₂ T)
Goal: (w.structuredArrowDownwards X₂).obj X =
  (CategoryTheory.StructuredArrow.pre (R.obj X₂) L B).obj
    ((CategoryTheory.Comma.mapRight (CategoryTheory.Functor.fromPUnit (R.obj X₂)) w).obj
      (CategoryTheory.StructuredArrow.mk (R.map X.hom)))
-- CategoryTheory.TwoSquare.structuredArrowDownwards_map
@[simps! obj map]
def structuredArrowDownwards (X₂ : C₂) :
    StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) (X₂ : C₂)
Goal: ∀ {X Y : CategoryTheory.StructuredArrow X₂ T} (f : X ⟶ Y),
  (w.structuredArrowDownwards X₂).map f =
    (CategoryTheory.StructuredArrow.pre (R.obj X₂) L B).map
      ((CategoryTheory.Comma.mapRight (CategoryTheory.Functor.fromPUnit (R.obj X₂)) w).map
        (CategoryTheory.StructuredArrow.homMk f.right ⋯))
-- CategoryTheory.TwoSquare.StructuredArrowRightwards.mk_surjective
lemma StructuredArrowRightwards.mk_surjective
    (f : w.StructuredArrowRightwards g) :
    ∃ (X₁ : C₁) (a : X₂ ⟶ T.obj X₁) (b : L.obj X₁ ⟶ X₃)
      (comm : R.map a ≫ w.app X₁ ≫ B.map b = g), f = mk w g X₁ a b comm 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} {w : CategoryTheory.TwoSquare T L R B} {X₂ : C₂} {X₃ : C₃} {g : R.obj X₂ ⟶ B.obj X₃} (f : w.StructuredArrowRightwards g)
Goal: ∃ X₁ a b,
  ∃ (comm : CategoryTheory.CategoryStruct.comp (R.map a) (CategoryTheory.CategoryStruct.comp (w.app X₁) (B.map b)) = g),
    f = CategoryTheory.TwoSquare.StructuredArrowRightwards.mk w g X₁ a b comm
-- CategoryTheory.TwoSquare.CostructuredArrowDownwards.mk_surjective
lemma CostructuredArrowDownwards.mk_surjective
    (f : w.CostructuredArrowDownwards g) :
    ∃ (X₁ : C₁) (a : X₂ ⟶ T.obj X₁) (b : L.obj X₁ ⟶ X₃)
      (comm : R.map a ≫ w.app X₁ ≫ B.map b = g), f = mk w g X₁ a b comm 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} {w : CategoryTheory.TwoSquare T L R B} {X₂ : C₂} {X₃ : C₃} {g : R.obj X₂ ⟶ B.obj X₃} (f : w.CostructuredArrowDownwards g)
Goal: ∃ X₁ a b,
  ∃ (comm : CategoryTheory.CategoryStruct.comp (R.map a) (CategoryTheory.CategoryStruct.comp (w.app X₁) (B.map b)) = g),
    f = CategoryTheory.TwoSquare.CostructuredArrowDownwards.mk w g X₁ a b comm
-- CategoryTheory.TwoSquare.EquivalenceJ.functor_map
@[simps]
def functor : w.StructuredArrowRightwards g ⥤ w.CostructuredArrowDownwards g 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) {f₁ f₂ : w.StructuredArrowRightwards g} (φ : f₁ ⟶ f₂)
Goal: (CategoryTheory.TwoSquare.EquivalenceJ.functor w g).map φ =
  CategoryTheory.CostructuredArrow.homMk (CategoryTheory.StructuredArrow.homMk φ.right.left ⋯) ⋯
-- CategoryTheory.TwoSquare.EquivalenceJ.functor_obj
@[simps]
def functor : w.StructuredArrowRightwards g ⥤ w.CostructuredArrowDownwards g 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) (f : w.StructuredArrowRightwards g)
Goal: (CategoryTheory.TwoSquare.EquivalenceJ.functor w g).obj f =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.StructuredArrow.homMk f.right.hom ⋯)
-- CategoryTheory.TwoSquare.EquivalenceJ.inverse_obj
@[simps]
def inverse : w.CostructuredArrowDownwards g ⥤ w.StructuredArrowRightwards g 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) (f : w.CostructuredArrowDownwards g)
Goal: (CategoryTheory.TwoSquare.EquivalenceJ.inverse w g).obj f =
  CategoryTheory.StructuredArrow.mk (CategoryTheory.CostructuredArrow.homMk f.left.hom ⋯)
-- CategoryTheory.TwoSquare.EquivalenceJ.inverse_map
@[simps]
def inverse : w.CostructuredArrowDownwards g ⥤ w.StructuredArrowRightwards g 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) {f₁ f₂ : w.CostructuredArrowDownwards g} (φ : f₁ ⟶ f₂)
Goal: (CategoryTheory.TwoSquare.EquivalenceJ.inverse w g).map φ =
  CategoryTheory.StructuredArrow.homMk (CategoryTheory.CostructuredArrow.homMk φ.left.right ⋯) ⋯
-- CategoryTheory.TwoSquare.equivalenceJ_functor
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃)
Goal: (w.equivalenceJ g).functor = CategoryTheory.TwoSquare.EquivalenceJ.functor w g
-- CategoryTheory.TwoSquare.equivalenceJ_unitIso
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃)
Goal: (w.equivalenceJ g).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (w.StructuredArrowRightwards g))
-- CategoryTheory.TwoSquare.equivalenceJ_counitIso
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃)
Goal: (w.equivalenceJ g).counitIso =
  CategoryTheory.Iso.refl
    ((CategoryTheory.TwoSquare.EquivalenceJ.inverse w g).comp (CategoryTheory.TwoSquare.EquivalenceJ.functor w g))
-- CategoryTheory.TwoSquare.equivalenceJ_inverse
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃)
Goal: (w.equivalenceJ g).inverse = CategoryTheory.TwoSquare.EquivalenceJ.inverse w g
-- CategoryTheory.TwoSquare.isConnected_rightwards_iff_downwards
lemma isConnected_rightwards_iff_downwards :
    IsConnected (w.StructuredArrowRightwards g) ↔ IsConnected (w.CostructuredArrowDownwards g) 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃)
Goal: CategoryTheory.IsConnected (w.StructuredArrowRightwards g) ↔ CategoryTheory.IsConnected (w.CostructuredArrowDownwards g)
-- CategoryTheory.TwoSquare.costructuredArrowDownwardsPrecomp_obj
@[simps]
def costructuredArrowDownwardsPrecomp
    {X₂ X₂' : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) (g' : R.obj X₂' ⟶ B.obj X₃)
    (γ : X₂' ⟶ X₂) (hγ : R.map γ ≫ g = g') :
    w.CostructuredArrowDownwards g ⥤ w.CostructuredArrowDownwards g' 
Arguments: {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [CategoryTheory.Category.{v₁, u₁} C₁] [CategoryTheory.Category.{v₂, u₂} C₂] [CategoryTheory.Category.{v₃, u₃} C₃] [CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃} {R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ X₂' : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) (g' : R.obj X₂' ⟶ B.obj X₃) (γ : X₂' ⟶ X₂) (hγ : CategoryTheory.CategoryStruct.comp (R.map γ) g = g') (A : w.CostructuredArrowDownwards g)
Goal: (w.costructuredArrowDownwardsPrecomp g g' γ hγ).obj A =
  CategoryTheory.TwoSquare.CostructuredArrowDownwards.mk w g' A.left.right
    (CategoryTheory.CategoryStruct.comp γ A.left.hom) A.hom.right ⋯