File: Mathlib/CategoryTheory/GuitartExact/Basic.lean

full_name: CategoryTheory.TwoSquare
code: /-- A `2`-square consists of a natural transformation `T ⋙ R ⟶ L ⋙ B`
involving fours functors `T`, `L`, `R`, `B` that are on the
top/left/right/bottom sides of a square of categories. -/
def TwoSquare 
goal: Type (max u₁ v₄)

full_name: CategoryTheory.TwoSquare.mk
code: /-- Constructor for `TwoSquare`. -/
abbrev mk (α : T ⋙ R ⟶ L ⋙ B) : TwoSquare T L R B 
goal: CategoryTheory.TwoSquare T L R B

full_name: CategoryTheory.TwoSquare.ext
code: @[ext]
lemma ext (w w' : TwoSquare T L R B) (h : ∀ (X : C₁), w.app X = w'.app X) :
    w = w' 
goal: w = w'

full_name: CategoryTheory.TwoSquare.costructuredArrowRightwards
code: /-- Given `w : TwoSquare T L R B` and `X₃ : C₃`, this is the obvious functor
`CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃)`. -/
@[simps! obj map]
def costructuredArrowRightwards (X₃ : C₃) :
    CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃) 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow L X₃) (CategoryTheory.CostructuredArrow R (B.obj X₃))

full_name: CategoryTheory.TwoSquare.costructuredArrowRightwards_map
code: /-- Given `w : TwoSquare T L R B` and `X₃ : C₃`, this is the obvious functor
`CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃)`. -/
@[simps! obj map]
def costructuredArrowRightwards (X₃ : C₃) :
    CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃) 
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 ⋯))

full_name: CategoryTheory.TwoSquare.costructuredArrowRightwards_obj
code: /-- Given `w : TwoSquare T L R B` and `X₃ : C₃`, this is the obvious functor
`CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃)`. -/
@[simps! obj map]
def costructuredArrowRightwards (X₃ : C₃) :
    CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj 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)))

full_name: CategoryTheory.TwoSquare.structuredArrowDownwards
code: /-- Given `w : TwoSquare T L R B` and `X₂ : C₂`, this is the obvious functor
`StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B`. -/
@[simps! obj map]
def structuredArrowDownwards (X₂ : C₂) :
    StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow X₂ T) (CategoryTheory.StructuredArrow (R.obj X₂) B)

full_name: CategoryTheory.TwoSquare.structuredArrowDownwards_obj
code: /-- Given `w : TwoSquare T L R B` and `X₂ : C₂`, this is the obvious functor
`StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B`. -/
@[simps! obj map]
def structuredArrowDownwards (X₂ : C₂) :
    StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B 
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)))

full_name: CategoryTheory.TwoSquare.structuredArrowDownwards_map
code: /-- Given `w : TwoSquare T L R B` and `X₂ : C₂`, this is the obvious functor
`StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B`. -/
@[simps! obj map]
def structuredArrowDownwards (X₂ : C₂) :
    StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B 
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 ⋯))

full_name: CategoryTheory.TwoSquare.StructuredArrowRightwards
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is the
category `StructuredArrow (CostructuredArrow.mk g) (w.costructuredArrowRightwards X₃)`,
see the constructor `StructuredArrowRightwards.mk` for the data that is involved. -/
abbrev StructuredArrowRightwards 
goal: Type (max (max u₁ v₃) v₂)

full_name: CategoryTheory.TwoSquare.CostructuredArrowDownwards
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is the
category `CostructuredArrow (w.structuredArrowDownwards X₂) (StructuredArrow.mk g)`,
see the constructor `CostructuredArrowDownwards.mk` for the data that is involved. -/
abbrev CostructuredArrowDownwards 
goal: Type (max (max u₁ v₂) v₃)

full_name: CategoryTheory.TwoSquare.StructuredArrowRightwards.mk
code: /-- Constructor for objects in `w.StructuredArrowRightwards g`. -/
abbrev StructuredArrowRightwards.mk (comm : R.map a ≫ w.app X₁ ≫ B.map b = g) :
    w.StructuredArrowRightwards g 
goal: w.StructuredArrowRightwards g

full_name: CategoryTheory.TwoSquare.CostructuredArrowDownwards.mk
code: /-- Constructor for objects in `w.CostructuredArrowDownwards g`. -/
abbrev CostructuredArrowDownwards.mk (comm : R.map a ≫ w.app X₁ ≫ B.map b = g) :
    w.CostructuredArrowDownwards g 
goal: w.CostructuredArrowDownwards g

full_name: CategoryTheory.TwoSquare.StructuredArrowRightwards.mk_surjective
code: 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 
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

full_name: CategoryTheory.TwoSquare.CostructuredArrowDownwards.mk_surjective
code: 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 
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

full_name: CategoryTheory.TwoSquare.EquivalenceJ.functor
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious functor `w.StructuredArrowRightwards g ⥤ w.CostructuredArrowDownwards g`. -/
@[simps]
def functor : w.StructuredArrowRightwards g ⥤ w.CostructuredArrowDownwards g 
goal: CategoryTheory.Functor (w.StructuredArrowRightwards g) (w.CostructuredArrowDownwards g)

full_name: CategoryTheory.TwoSquare.EquivalenceJ.functor_map
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious functor `w.StructuredArrowRightwards g ⥤ w.CostructuredArrowDownwards g`. -/
@[simps]
def functor : w.StructuredArrowRightwards g ⥤ w.CostructuredArrowDownwards g 
goal: (CategoryTheory.TwoSquare.EquivalenceJ.functor w g).map φ =
  CategoryTheory.CostructuredArrow.homMk (CategoryTheory.StructuredArrow.homMk φ.right.left ⋯) ⋯

full_name: CategoryTheory.TwoSquare.EquivalenceJ.functor_obj
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious functor `w.StructuredArrowRightwards g ⥤ w.CostructuredArrowDownwards g`. -/
@[simps]
def functor : w.StructuredArrowRightwards g ⥤ w.CostructuredArrowDownwards g 
goal: (CategoryTheory.TwoSquare.EquivalenceJ.functor w g).obj f =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.StructuredArrow.homMk f.right.hom ⋯)

full_name: CategoryTheory.TwoSquare.EquivalenceJ.inverse
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious functor `w.CostructuredArrowDownwards g ⥤ w.StructuredArrowRightwards g`. -/
@[simps]
def inverse : w.CostructuredArrowDownwards g ⥤ w.StructuredArrowRightwards g 
goal: CategoryTheory.Functor (w.CostructuredArrowDownwards g) (w.StructuredArrowRightwards g)

full_name: CategoryTheory.TwoSquare.EquivalenceJ.inverse_obj
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious functor `w.CostructuredArrowDownwards g ⥤ w.StructuredArrowRightwards g`. -/
@[simps]
def inverse : w.CostructuredArrowDownwards g ⥤ w.StructuredArrowRightwards g 
goal: (CategoryTheory.TwoSquare.EquivalenceJ.inverse w g).obj f =
  CategoryTheory.StructuredArrow.mk (CategoryTheory.CostructuredArrow.homMk f.left.hom ⋯)

full_name: CategoryTheory.TwoSquare.EquivalenceJ.inverse_map
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious functor `w.CostructuredArrowDownwards g ⥤ w.StructuredArrowRightwards g`. -/
@[simps]
def inverse : w.CostructuredArrowDownwards g ⥤ w.StructuredArrowRightwards g 
goal: (CategoryTheory.TwoSquare.EquivalenceJ.inverse w g).map φ =
  CategoryTheory.StructuredArrow.homMk (CategoryTheory.CostructuredArrow.homMk φ.left.right ⋯) ⋯

full_name: CategoryTheory.TwoSquare.equivalenceJ_functor
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious equivalence of categories
`w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g`. -/
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
goal: (w.equivalenceJ g).functor = CategoryTheory.TwoSquare.EquivalenceJ.functor w g

full_name: CategoryTheory.TwoSquare.equivalenceJ
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious equivalence of categories
`w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g`. -/
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
goal: w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g

full_name: CategoryTheory.TwoSquare.equivalenceJ_unitIso
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious equivalence of categories
`w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g`. -/
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
goal: (w.equivalenceJ g).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (w.StructuredArrowRightwards g))

full_name: CategoryTheory.TwoSquare.equivalenceJ_counitIso
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious equivalence of categories
`w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g`. -/
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
goal: (w.equivalenceJ g).counitIso =
  CategoryTheory.Iso.refl
    ((CategoryTheory.TwoSquare.EquivalenceJ.inverse w g).comp (CategoryTheory.TwoSquare.EquivalenceJ.functor w g))

full_name: CategoryTheory.TwoSquare.equivalenceJ_inverse
code: /-- Given `w : TwoSquare T L R B` and a morphism `g : R.obj X₂ ⟶ B.obj X₃`, this is
the obvious equivalence of categories
`w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g`. -/
@[simps functor inverse unitIso counitIso]
def equivalenceJ : w.StructuredArrowRightwards g ≌ w.CostructuredArrowDownwards g 
goal: (w.equivalenceJ g).inverse = CategoryTheory.TwoSquare.EquivalenceJ.inverse w g

full_name: CategoryTheory.TwoSquare.isConnected_rightwards_iff_downwards
code: lemma isConnected_rightwards_iff_downwards :
    IsConnected (w.StructuredArrowRightwards g) ↔ IsConnected (w.CostructuredArrowDownwards g) 
goal: CategoryTheory.IsConnected (w.StructuredArrowRightwards g) ↔ CategoryTheory.IsConnected (w.CostructuredArrowDownwards g)

full_name: CategoryTheory.TwoSquare.costructuredArrowDownwardsPrecomp
code: /-- The functor `w.CostructuredArrowDownwards g ⥤ w.CostructuredArrowDownwards g'` induced
by a morphism `γ` such that `R.map γ ≫ g = g'`. -/
@[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' 
goal: CategoryTheory.Functor (w.CostructuredArrowDownwards g) (w.CostructuredArrowDownwards g')

full_name: CategoryTheory.TwoSquare.costructuredArrowDownwardsPrecomp_obj
code: /-- The functor `w.CostructuredArrowDownwards g ⥤ w.CostructuredArrowDownwards g'` induced
by a morphism `γ` such that `R.map γ ≫ g = g'`. -/
@[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' 
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 ⋯

full_name: CategoryTheory.TwoSquare.costructuredArrowDownwardsPrecomp_map
code: /-- The functor `w.CostructuredArrowDownwards g ⥤ w.CostructuredArrowDownwards g'` induced
by a morphism `γ` such that `R.map γ ≫ g = g'`. -/
@[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' 
goal: (w.costructuredArrowDownwardsPrecomp g g' γ hγ).map φ =
  CategoryTheory.CostructuredArrow.homMk (CategoryTheory.StructuredArrow.homMk φ.left.right ⋯) ⋯

full_name: CategoryTheory.TwoSquare.GuitartExact
code: /-- Condition on `w : TwoSquare T L R B` expressing that it is a Guitart exact square.
It is equivalent to saying that for any `X₃ : C₃`, the induced functor
`CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃)` is final (see `guitartExact_iff_final`)
or equivalently that for any `X₂ : C₂`, the induced functor
`StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B` is initial (see `guitartExact_iff_initial`).
See also  `guitartExact_iff_isConnected_rightwards`, `guitartExact_iff_isConnected_downwards`
for characterizations in terms of the connectedness of auxiliary categories. -/
class GuitartExact : Prop where
  isConnected_rightwards {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) :
    IsConnected (w.StructuredArrowRightwards g)
goal: Prop

full_name: CategoryTheory.TwoSquare.GuitartExact.isConnected_rightwards
code: /-- Condition on `w : TwoSquare T L R B` expressing that it is a Guitart exact square.
It is equivalent to saying that for any `X₃ : C₃`, the induced functor
`CostructuredArrow L X₃ ⥤ CostructuredArrow R (B.obj X₃)` is final (see `guitartExact_iff_final`)
or equivalently that for any `X₂ : C₂`, the induced functor
`StructuredArrow X₂ T ⥤ StructuredArrow (R.obj X₂) B` is initial (see `guitartExact_iff_initial`).
See also  `guitartExact_iff_isConnected_rightwards`, `guitartExact_iff_isConnected_downwards`
for characterizations in terms of the connectedness of auxiliary categories. -/
class GuitartExact : Prop where
  isConnected_rightwards {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) :
    IsConnected (w.StructuredArrowRightwards g)
goal: CategoryTheory.IsConnected (w.StructuredArrowRightwards g)

full_name: CategoryTheory.TwoSquare.guitartExact_iff_isConnected_rightwards
code: lemma guitartExact_iff_isConnected_rightwards :
    w.GuitartExact ↔ ∀ {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃),
      IsConnected (w.StructuredArrowRightwards g) 
goal: w.GuitartExact ↔
  ∀ {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃), CategoryTheory.IsConnected (w.StructuredArrowRightwards g)

full_name: CategoryTheory.TwoSquare.guitartExact_iff_isConnected_downwards
code: lemma guitartExact_iff_isConnected_downwards :
    w.GuitartExact ↔ ∀ {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃),
      IsConnected (w.CostructuredArrowDownwards g) 
goal: w.GuitartExact ↔
  ∀ {X₂ : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃), CategoryTheory.IsConnected (w.CostructuredArrowDownwards g)

full_name: CategoryTheory.TwoSquare.instIsConnectedStructuredArrowCostructuredArrowObjCostructuredArrowRightwardsOfGuitartExact
code: instance [hw : w.GuitartExact] {X₃ : C₃} (g : CostructuredArrow R (B.obj X₃)) :
    IsConnected (StructuredArrow g (w.costructuredArrowRightwards X₃)) 
goal: CategoryTheory.IsConnected (CategoryTheory.StructuredArrow g (w.costructuredArrowRightwards X₃))

full_name: CategoryTheory.TwoSquare.instIsConnectedCostructuredArrowStructuredArrowObjStructuredArrowDownwardsOfGuitartExact
code: instance [hw : w.GuitartExact] {X₂ : C₂} (g : StructuredArrow (R.obj X₂) B) :
    IsConnected (CostructuredArrow (w.structuredArrowDownwards X₂) g) 
goal: CategoryTheory.IsConnected (CategoryTheory.CostructuredArrow (w.structuredArrowDownwards X₂) g)

full_name: CategoryTheory.TwoSquare.guitartExact_iff_final
code: lemma guitartExact_iff_final :
    w.GuitartExact ↔ ∀ (X₃ : C₃), (w.costructuredArrowRightwards X₃).Final 
goal: w.GuitartExact ↔ ∀ (X₃ : C₃), (w.costructuredArrowRightwards X₃).Final

full_name: CategoryTheory.TwoSquare.instFinalCostructuredArrowObjCostructuredArrowRightwardsOfGuitartExact
code: instance [hw : w.GuitartExact] (X₃ : C₃) :
    (w.costructuredArrowRightwards X₃).Final 
goal: (w.costructuredArrowRightwards X₃).Final

full_name: CategoryTheory.TwoSquare.guitartExact_iff_initial
code: lemma guitartExact_iff_initial :
    w.GuitartExact ↔ ∀ (X₂ : C₂), (w.structuredArrowDownwards X₂).Initial 
goal: w.GuitartExact ↔ ∀ (X₂ : C₂), (w.structuredArrowDownwards X₂).Initial

full_name: CategoryTheory.TwoSquare.instInitialStructuredArrowObjStructuredArrowDownwardsOfGuitartExact
code: instance [hw : w.GuitartExact] (X₂ : C₂) :
    (w.structuredArrowDownwards X₂).Initial 
goal: (w.structuredArrowDownwards X₂).Initial

full_name: CategoryTheory.TwoSquare.guitartExact_of_isEquivalence_of_isIso
code: /-- When the left and right functors of a 2-square are equivalences, and the natural
transformation of the 2-square is an isomorphism, then the 2-square is Guitart exact. -/
instance (priority := 100) guitartExact_of_isEquivalence_of_isIso
    [L.IsEquivalence] [R.IsEquivalence] [IsIso w] : GuitartExact w 
goal: w.GuitartExact

full_name: CategoryTheory.TwoSquare.guitartExact_id
code: instance guitartExact_id (F : C₁ ⥤ C₂) :
    GuitartExact (TwoSquare.mk (𝟭 C₁) F F (𝟭 C₂) (𝟙 F)) 
goal: (CategoryTheory.TwoSquare.mk (CategoryTheory.Functor.id C₁) F F (CategoryTheory.Functor.id C₂)
    (CategoryTheory.CategoryStruct.id F)).GuitartExact