awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
ψ : CatCospanTransform F G F₁ G₁
X : Type u₇
inst_6 : Category.{v₇, u₇} X
w :
  ∀ (x : CatCommSqOver.{v₁, v₂, v₃, v₇, u₁, u₂, u₃, u₇} F G X) (x_1 : X),
    Eq (α :=
      (obj (obj (precompose F G) (𝟭 X) ⋙ obj (transform X) ψ) x).fst.obj x_1 ⟶
        (obj (obj (transform X) ψ ⋙ 𝟭 (CatCommSqOver.{v₄, v₅, v₆, v₇, u₄, u₅, u₆, u₇} F₁ G₁ X)) x).fst.obj x_1)
      (NatTrans.app
        (Hom.fst
          (NatTrans.app
            (Iso.hom
                (CatCommSq.iso (obj (precompose F G) (𝟭 X)) (obj (transform X) ψ) (obj (transform X) ψ)
                  (obj (precompose F₁ G₁) (𝟭 X))) ≫
              whiskerLeft (obj (transform X) ψ) (Iso.hom (precomposeObjId F₁ G₁ X)))
            x))
        x_1)
      (NatTrans.app
        (Hom.fst
          (NatTrans.app
            (whiskerRight (Iso.hom (precomposeObjId F G X)) (obj (transform X) ψ) ≫
              Iso.hom (leftUnitor (obj (transform X) ψ)) ≫ Iso.inv (rightUnitor (obj (transform X) ψ)))
            x))
        x_1)
w₁ :
  ∀ (x : CatCommSqOver.{v₁, v₂, v₃, v₇, u₁, u₂, u₃, u₇} F G X) (x_1 : X),
    Eq (α :=
      (obj (obj (precompose F G) (𝟭 X) ⋙ obj (transform X) ψ) x).snd.obj x_1 ⟶
        (obj (obj (transform X) ψ ⋙ 𝟭 (CatCommSqOver.{v₄, v₅, v₆, v₇, u₄, u₅, u₆, u₇} F₁ G₁ X)) x).snd.obj x_1)
      (NatTrans.app
        (Hom.snd
          (NatTrans.app
            (Iso.hom
                (CatCommSq.iso (obj (precompose F G) (𝟭 X)) (obj (transform X) ψ) (obj (transform X) ψ)
                  (obj (precompose F₁ G₁) (𝟭 X))) ≫
              whiskerLeft (obj (transform X) ψ) (Iso.hom (precomposeObjId F₁ G₁ X)))
            x))
        x_1)
      (NatTrans.app
        (Hom.snd
          (NatTrans.app
            (whiskerRight (Iso.hom (precomposeObjId F G X)) (obj (transform X) ψ) ≫
              Iso.hom (leftUnitor (obj (transform X) ψ)) ≫ Iso.inv (rightUnitor (obj (transform X) ψ)))
            x))
        x_1)
⊢ Eq (α :=
    Quiver.Hom (V :=
      CatCommSqOver.{v₁, v₂, v₃, v₇, u₁, u₂, u₃, u₇} F G X ⥤ CatCommSqOver.{v₄, v₅, v₆, v₇, u₄, u₅, u₆, u₇} F₁ G₁ X)
      (obj (precompose F G) (𝟭 X) ⋙ obj (transform X) ψ)
      (obj (transform X) ψ ⋙ 𝟭 (CatCommSqOver.{v₄, v₅, v₆, v₇, u₄, u₅, u₆, u₇} F₁ G₁ X)))
    (Iso.hom
        (CatCommSq.iso (obj (precompose F G) (𝟭 X)) (obj (transform X) ψ) (obj (transform X) ψ)
          (obj (precompose F₁ G₁) (𝟭 X))) ≫
      whiskerLeft (obj (transform X) ψ) (Iso.hom (precomposeObjId F₁ G₁ X)))
    (whiskerRight (Iso.hom (precomposeObjId F G X)) (obj (transform X) ψ) ≫
      Iso.hom (leftUnitor (obj (transform X) ψ)) ≫ Iso.inv (rightUnitor (obj (transform X) ψ)))

Tactic:
ext
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
ψ : CatCospanTransform F G F₁ G₁
X : Type u₇
inst_6 : Category.{v₇, u₇} X
x : CatCommSqOver.{v₁, v₂, v₃, v₇, u₁, u₂, u₃, u₇} F G X
x_1 : X
⊢ Eq (α :=
    (obj (obj (precompose F G) (𝟭 X) ⋙ obj (transform X) ψ) x).fst.obj x_1 ⟶
      (obj (obj (transform X) ψ ⋙ 𝟭 (CatCommSqOver.{v₄, v₅, v₆, v₇, u₄, u₅, u₆, u₇} F₁ G₁ X)) x).fst.obj x_1)
    (NatTrans.app
      (Hom.fst
        (NatTrans.app
          (Iso.hom
              (CatCommSq.iso (obj (precompose F G) (𝟭 X)) (obj (transform X) ψ) (obj (transform X) ψ)
                (obj (precompose F₁ G₁) (𝟭 X))) ≫
            whiskerLeft (obj (transform X) ψ) (Iso.hom (precomposeObjId F₁ G₁ X)))
          x))
      x_1)
    (NatTrans.app
      (Hom.fst
        (NatTrans.app
          (whiskerRight (Iso.hom (precomposeObjId F G X)) (obj (transform X) ψ) ≫
            Iso.hom (leftUnitor (obj (transform X) ψ)) ≫ Iso.inv (rightUnitor (obj (transform X) ψ)))
          x))
      x_1)

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
ψ : CatCospanTransform F G F₁ G₁
X : Type u₇
inst_6 : Category.{v₇, u₇} X
x : CatCommSqOver.{v₁, v₂, v₃, v₇, u₁, u₂, u₃, u₇} F G X
x_1 : X
⊢ Eq (α :=
    (obj (obj (precompose F G) (𝟭 X) ⋙ obj (transform X) ψ) x).snd.obj x_1 ⟶
      (obj (obj (transform X) ψ ⋙ 𝟭 (CatCommSqOver.{v₄, v₅, v₆, v₇, u₄, u₅, u₆, u₇} F₁ G₁ X)) x).snd.obj x_1)
    (NatTrans.app
      (Hom.snd
        (NatTrans.app
          (Iso.hom
              (CatCommSq.iso (obj (precompose F G) (𝟭 X)) (obj (transform X) ψ) (obj (transform X) ψ)
                (obj (precompose F₁ G₁) (𝟭 X))) ≫
            whiskerLeft (obj (transform X) ψ) (Iso.hom (precomposeObjId F₁ G₁ X)))
          x))
      x_1)
    (NatTrans.app
      (Hom.snd
        (NatTrans.app
          (whiskerRight (Iso.hom (precomposeObjId F G X)) (obj (transform X) ψ) ≫
            Iso.hom (leftUnitor (obj (transform X) ψ)) ≫ Iso.inv (rightUnitor (obj (transform X) ψ)))
          x))
      x_1)

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
X : Type u₇
Y : Type u₈
Z : Type u₉
inst_6 : Category.{v₇, u₇} X
inst_7 : Category.{v₈, u₈} Y
inst_8 : Category.{v₉, u₉} Z
ψ : CatCospanTransform F G F₁ G₁
U : Functor.{v₇, v₈, u₇, u₈} X Y
V : Functor.{v₈, v₉, u₈, u₉} Y Z
x : CatCommSqOver.{v₁, v₂, v₃, v₉, u₁, u₂, u₃, u₉} F G Z
x_1 : X
⊢ ((Iso.hom
                  (CatCommSq.iso (obj (precompose F G) (U ⋙ V)) (obj (transform Z) ψ) (obj (transform X) ψ)
                    (obj (precompose F₁ G₁) (U ⋙ V))) ≫
                whiskerLeft (obj (transform Z) ψ) (precomposeObjComp F₁ G₁ U V).hom).app
            x).fst.app
      x_1 =
    NatTrans.app
      (Hom.fst
        ((whiskerRight (precomposeObjComp F G U V).hom (obj (transform X) ψ) ≫
              ((obj (precompose F G) V).associator (obj (precompose F G) U) (obj (transform X) ψ)).hom ≫
                (obj (precompose F G) V).whiskerLeft
                    (Iso.hom
                      (CatCommSq.iso (obj (precompose F G) U) (obj (transform Y) ψ) (obj (transform X) ψ)
                        (obj (precompose F₁ G₁) U))) ≫
                  ((obj (precompose F G) V).associator (obj (transform Y) ψ) (obj (precompose F₁ G₁) U)).inv ≫
                    whiskerRight
                        (Iso.hom
                          (CatCommSq.iso (obj (precompose F G) V) (obj (transform Z) ψ) (obj (transform Y) ψ)
                            (obj (precompose F₁ G₁) V)))
                        (obj (precompose F₁ G₁) U) ≫
                      Iso.hom
                        (associator (obj (transform Z) ψ) (obj (precompose F₁ G₁) V) (obj (precompose F₁ G₁) U))).app
          x))
      x_1

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
X : Type u₇
Y : Type u₈
Z : Type u₉
inst_6 : Category.{v₇, u₇} X
inst_7 : Category.{v₈, u₈} Y
inst_8 : Category.{v₉, u₉} Z
ψ : CatCospanTransform F G F₁ G₁
U : Functor.{v₇, v₈, u₇, u₈} X Y
V : Functor.{v₈, v₉, u₈, u₉} Y Z
x : CatCommSqOver.{v₁, v₂, v₃, v₉, u₁, u₂, u₃, u₉} F G Z
x_1 : X
⊢ ((Iso.hom
                  (CatCommSq.iso (obj (precompose F G) (U ⋙ V)) (obj (transform Z) ψ) (obj (transform X) ψ)
                    (obj (precompose F₁ G₁) (U ⋙ V))) ≫
                whiskerLeft (obj (transform Z) ψ) (precomposeObjComp F₁ G₁ U V).hom).app
            x).snd.app
      x_1 =
    NatTrans.app
      (Hom.snd
        ((whiskerRight (precomposeObjComp F G U V).hom (obj (transform X) ψ) ≫
              ((obj (precompose F G) V).associator (obj (precompose F G) U) (obj (transform X) ψ)).hom ≫
                (obj (precompose F G) V).whiskerLeft
                    (Iso.hom
                      (CatCommSq.iso (obj (precompose F G) U) (obj (transform Y) ψ) (obj (transform X) ψ)
                        (obj (precompose F₁ G₁) U))) ≫
                  ((obj (precompose F G) V).associator (obj (transform Y) ψ) (obj (precompose F₁ G₁) U)).inv ≫
                    whiskerRight
                        (Iso.hom
                          (CatCommSq.iso (obj (precompose F G) V) (obj (transform Z) ψ) (obj (transform Y) ψ)
                            (obj (precompose F₁ G₁) V)))
                        (obj (precompose F₁ G₁) U) ≫
                      Iso.hom
                        (associator (obj (transform Z) ψ) (obj (precompose F₁ G₁) V) (obj (precompose F₁ G₁) U))).app
          x))
      x_1

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
X : Type u₇
Y : Type u₈
inst_6 : Category.{v₇, u₇} X
inst_7 : Category.{v₈, u₈} Y
U : Functor.{v₇, v₈, u₇, u₈} X Y
ψ : CatCospanTransform F G F₁ G₁
x y : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y
f : x ⟶ y
x_1 : X
⊢ NatTrans.app
      (Hom.fst
        ((obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).map f ≫
          Iso.hom
            ((fun (x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y) ↦
                (mkIso (U.associator x.fst ψ.left).symm (U.associator x.snd ψ.right).symm ⋯ :
                  (obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).obj x ≅
                    (obj (precompose F G) U ⋙ obj (transform X) ψ).obj x))
              y)))
      x_1 =
    NatTrans.app
      (Hom.fst
        (Iso.hom
            ((fun (x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y) ↦
                (mkIso (U.associator x.fst ψ.left).symm (U.associator x.snd ψ.right).symm ⋯ :
                  (obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).obj x ≅
                    (obj (precompose F G) U ⋙ obj (transform X) ψ).obj x))
              x) ≫
          (obj (precompose F G) U ⋙ obj (transform X) ψ).map f))
      x_1

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
X : Type u₇
Y : Type u₈
inst_6 : Category.{v₇, u₇} X
inst_7 : Category.{v₈, u₈} Y
U : Functor.{v₇, v₈, u₇, u₈} X Y
ψ : CatCospanTransform F G F₁ G₁
x y : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y
f : x ⟶ y
x_1 : X
⊢ NatTrans.app
      (Hom.snd
        ((obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).map f ≫
          Iso.hom
            ((fun (x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y) ↦
                (mkIso (U.associator x.fst ψ.left).symm (U.associator x.snd ψ.right).symm ⋯ :
                  (obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).obj x ≅
                    (obj (precompose F G) U ⋙ obj (transform X) ψ).obj x))
              y)))
      x_1 =
    NatTrans.app
      (Hom.snd
        (Iso.hom
            ((fun (x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y) ↦
                (mkIso (U.associator x.fst ψ.left).symm (U.associator x.snd ψ.right).symm ⋯ :
                  (obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).obj x ≅
                    (obj (precompose F G) U ⋙ obj (transform X) ψ).obj x))
              x) ≫
          (obj (precompose F G) U ⋙ obj (transform X) ψ).map f))
      x_1

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
X : Type u₇
Y : Type u₈
inst_6 : Category.{v₇, u₇} X
inst_7 : Category.{v₈, u₈} Y
U : Functor.{v₇, v₈, u₇, u₈} X Y
ψ ψ' : CatCospanTransform F G F₁ G₁
η : ψ ⟶ ψ'
w :
  ∀ (x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y) (x_1 : X),
    Eq (α :=
      ((obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).obj x).fst.obj x_1 ⟶
        ((obj (precompose F G) U ⋙ obj (transform X) ψ').obj x).fst.obj x_1)
      (NatTrans.app
        (Hom.fst
          (NatTrans.app
            (whiskerRight (map (transform Y) η) (obj (precompose F₁ G₁) U) ≫
              Iso.hom
                (CatCommSq.iso (obj (transform Y) ψ') (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
                  (obj (transform X) ψ')))
            x))
        x_1)
      (NatTrans.app
        (Hom.fst
          (NatTrans.app
            (Iso.hom
                (CatCommSq.iso (obj (transform Y) ψ) (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
                  (obj (transform X) ψ)) ≫
              (obj (precompose F G) U).whiskerLeft (map (transform X) η))
            x))
        x_1)
w₁ :
  ∀ (x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y) (x_1 : X),
    Eq (α :=
      ((obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).obj x).snd.obj x_1 ⟶
        ((obj (precompose F G) U ⋙ obj (transform X) ψ').obj x).snd.obj x_1)
      (NatTrans.app
        (Hom.snd
          (NatTrans.app
            (whiskerRight (map (transform Y) η) (obj (precompose F₁ G₁) U) ≫
              Iso.hom
                (CatCommSq.iso (obj (transform Y) ψ') (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
                  (obj (transform X) ψ')))
            x))
        x_1)
      (NatTrans.app
        (Hom.snd
          (NatTrans.app
            (Iso.hom
                (CatCommSq.iso (obj (transform Y) ψ) (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
                  (obj (transform X) ψ)) ≫
              (obj (precompose F G) U).whiskerLeft (map (transform X) η))
            x))
        x_1)
⊢ Eq (α := obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U ⟶ obj (precompose F G) U ⋙ obj (transform X) ψ')
    (whiskerRight (map (transform Y) η) (obj (precompose F₁ G₁) U) ≫
      Iso.hom
        (CatCommSq.iso (obj (transform Y) ψ') (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
          (obj (transform X) ψ')))
    (Iso.hom
        (CatCommSq.iso (obj (transform Y) ψ) (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
          (obj (transform X) ψ)) ≫
      (obj (precompose F G) U).whiskerLeft (map (transform X) η))

Tactic:
ext
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
X : Type u₇
Y : Type u₈
inst_6 : Category.{v₇, u₇} X
inst_7 : Category.{v₈, u₈} Y
U : Functor.{v₇, v₈, u₇, u₈} X Y
ψ ψ' : CatCospanTransform F G F₁ G₁
η : ψ ⟶ ψ'
x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y
x_1 : X
⊢ Eq (α :=
    ((obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).obj x).fst.obj x_1 ⟶
      ((obj (precompose F G) U ⋙ obj (transform X) ψ').obj x).fst.obj x_1)
    (NatTrans.app
      (Hom.fst
        (NatTrans.app
          (whiskerRight (map (transform Y) η) (obj (precompose F₁ G₁) U) ≫
            Iso.hom
              (CatCommSq.iso (obj (transform Y) ψ') (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
                (obj (transform X) ψ')))
          x))
      x_1)
    (NatTrans.app
      (Hom.fst
        (NatTrans.app
          (Iso.hom
              (CatCommSq.iso (obj (transform Y) ψ) (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
                (obj (transform X) ψ)) ≫
            (obj (precompose F G) U).whiskerLeft (map (transform X) η))
          x))
      x_1)

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
A₁ : Type u₄
B₁ : Type u₅
C₁ : Type u₆
inst_3 : Category.{v₄, u₄} A₁
inst_4 : Category.{v₅, u₅} B₁
inst_5 : Category.{v₆, u₆} C₁
F₁ : Functor.{v₄, v₅, u₄, u₅} A₁ B₁
G₁ : Functor.{v₆, v₅, u₆, u₅} C₁ B₁
X : Type u₇
Y : Type u₈
inst_6 : Category.{v₇, u₇} X
inst_7 : Category.{v₈, u₈} Y
U : Functor.{v₇, v₈, u₇, u₈} X Y
ψ ψ' : CatCospanTransform F G F₁ G₁
η : ψ ⟶ ψ'
x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y
x_1 : X
⊢ Eq (α :=
    ((obj (transform Y) ψ ⋙ obj (precompose F₁ G₁) U).obj x).snd.obj x_1 ⟶
      ((obj (precompose F G) U ⋙ obj (transform X) ψ').obj x).snd.obj x_1)
    (NatTrans.app
      (Hom.snd
        (NatTrans.app
          (whiskerRight (map (transform Y) η) (obj (precompose F₁ G₁) U) ≫
            Iso.hom
              (CatCommSq.iso (obj (transform Y) ψ') (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
                (obj (transform X) ψ')))
          x))
      x_1)
    (NatTrans.app
      (Hom.snd
        (NatTrans.app
          (Iso.hom
              (CatCommSq.iso (obj (transform Y) ψ) (obj (precompose F G) U) (obj (precompose F₁ G₁) U)
                (obj (transform X) ψ)) ≫
            (obj (precompose F G) U).whiskerLeft (map (transform X) η))
          x))
      x_1)

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
X : Type u₇
Y : Type u₈
inst_3 : Category.{v₇, u₇} X
inst_4 : Category.{v₈, u₈} Y
U : Functor.{v₇, v₈, u₇, u₈} X Y
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
w :
  ∀ (x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y) (x_1 : X),
    NatTrans.app
        (Hom.fst
          (NatTrans.app
            (Iso.hom
                (CatCommSq.iso (obj (transform Y) (CatCospanTransform.id F G)) (obj (precompose F G) U)
                  (obj (precompose F G) U) (obj (transform X) (CatCospanTransform.id F G))) ≫
              (obj (precompose F G) U).whiskerLeft (Iso.hom (transformObjId X F G)))
            x))
        x_1 =
      ((whiskerRight (Iso.hom (transformObjId Y F G)) (obj (precompose F G) U) ≫
                  (obj (precompose F G) U).leftUnitor.hom ≫ (obj (precompose F G) U).rightUnitor.inv).app
              x).fst.app
        x_1
w₁ :
  ∀ (x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y) (x_1 : X),
    NatTrans.app
        (Hom.snd
          (NatTrans.app
            (Iso.hom
                (CatCommSq.iso (obj (transform Y) (CatCospanTransform.id F G)) (obj (precompose F G) U)
                  (obj (precompose F G) U) (obj (transform X) (CatCospanTransform.id F G))) ≫
              (obj (precompose F G) U).whiskerLeft (Iso.hom (transformObjId X F G)))
            x))
        x_1 =
      ((whiskerRight (Iso.hom (transformObjId Y F G)) (obj (precompose F G) U) ≫
                  (obj (precompose F G) U).leftUnitor.hom ≫ (obj (precompose F G) U).rightUnitor.inv).app
              x).snd.app
        x_1
⊢ Iso.hom
        (CatCommSq.iso (obj (transform Y) (CatCospanTransform.id F G)) (obj (precompose F G) U) (obj (precompose F G) U)
          (obj (transform X) (CatCospanTransform.id F G))) ≫
      (obj (precompose F G) U).whiskerLeft (Iso.hom (transformObjId X F G)) =
    whiskerRight (Iso.hom (transformObjId Y F G)) (obj (precompose F G) U) ≫
      (obj (precompose F G) U).leftUnitor.hom ≫ (obj (precompose F G) U).rightUnitor.inv

Tactic:
ext
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
X : Type u₇
Y : Type u₈
inst_3 : Category.{v₇, u₇} X
inst_4 : Category.{v₈, u₈} Y
U : Functor.{v₇, v₈, u₇, u₈} X Y
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y
x_1 : X
⊢ NatTrans.app
      (Hom.fst
        (NatTrans.app
          (Iso.hom
              (CatCommSq.iso (obj (transform Y) (CatCospanTransform.id F G)) (obj (precompose F G) U)
                (obj (precompose F G) U) (obj (transform X) (CatCospanTransform.id F G))) ≫
            (obj (precompose F G) U).whiskerLeft (Iso.hom (transformObjId X F G)))
          x))
      x_1 =
    ((whiskerRight (Iso.hom (transformObjId Y F G)) (obj (precompose F G) U) ≫
                (obj (precompose F G) U).leftUnitor.hom ≫ (obj (precompose F G) U).rightUnitor.inv).app
            x).fst.app
      x_1

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
Goal:
A : Type u₁
B : Type u₂
C : Type u₃
inst : Category.{v₁, u₁} A
inst_1 : Category.{v₂, u₂} B
inst_2 : Category.{v₃, u₃} C
X : Type u₇
Y : Type u₈
inst_3 : Category.{v₇, u₇} X
inst_4 : Category.{v₈, u₈} Y
U : Functor.{v₇, v₈, u₇, u₈} X Y
F : Functor.{v₁, v₂, u₁, u₂} A B
G : Functor.{v₃, v₂, u₃, u₂} C B
x : CatCommSqOver.{v₁, v₂, v₃, v₈, u₁, u₂, u₃, u₈} F G Y
x_1 : X
⊢ NatTrans.app
      (Hom.snd
        (NatTrans.app
          (Iso.hom
              (CatCommSq.iso (obj (transform Y) (CatCospanTransform.id F G)) (obj (precompose F G) U)
                (obj (precompose F G) U) (obj (transform X) (CatCospanTransform.id F G))) ≫
            (obj (precompose F G) U).whiskerLeft (Iso.hom (transformObjId X F G)))
          x))
      x_1 =
    ((whiskerRight (Iso.hom (transformObjId Y F G)) (obj (precompose F G) U) ≫
                (obj (precompose F G) U).leftUnitor.hom ≫ (obj (precompose F G) U).rightUnitor.inv).app
            x).snd.app
      x_1

Tactic:
simp