Theorem: CategoryTheory.Grothendieck.grothendieckTypeToCat_unitIso_hom_app_fiber
File: Mathlib/CategoryTheory/Grothendieck.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
X : Grothendieck (G ⋙ typeToCat)
⊢ (𝟭 (Grothendieck (G ⋙ typeToCat))).obj X ≅ (grothendieckTypeToCatFunctor G ⋙ grothendieckTypeToCatInverse G).obj X
state_after: case mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝ : C
as✝ : G.obj base✝
⊢ (𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base✝, fiber := { as := as✝ } } ≅
    (grothendieckTypeToCatFunctor G ⋙ grothendieckTypeToCatInverse G).obj { base := base✝, fiber := { as := as✝ } }
tactic: rcases X with ⟨_, ⟨⟩⟩
state_before: case mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝ : C
as✝ : G.obj base✝
⊢ (𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base✝, fiber := { as := as✝ } } ≅
    (grothendieckTypeToCatFunctor G ⋙ grothendieckTypeToCatInverse G).obj { base := base✝, fiber := { as := as✝ } }
state_after: no goals
tactic: exact Iso.refl _
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
⊢ ∀ {X Y : Grothendieck (G ⋙ typeToCat)} (f : X ⟶ Y),
    (𝟭 (Grothendieck (G ⋙ typeToCat))).map f ≫
        ((fun X =>
              Grothendieck.casesOn X fun base fiber =>
                Discrete.casesOn fiber fun as =>
                  Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
            Y).hom =
      ((fun X =>
              Grothendieck.casesOn X fun base fiber =>
                Discrete.casesOn fiber fun as =>
                  Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
            X).hom ≫
        (grothendieckTypeToCatFunctor G ⋙ grothendieckTypeToCatInverse G).map f
state_after: case mk.mk.mk.mk.mk.up.up
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝¹ : C
as✝¹ : G.obj base✝¹
base✝ : C
as✝ : G.obj base✝
base : { base := base✝¹, fiber := { as := as✝¹ } }.base ⟶ { base := base✝, fiber := { as := as✝ } }.base
f :
  (((G ⋙ typeToCat).map base).obj { base := base✝¹, fiber := { as := as✝¹ } }.fiber).as =
    { base := base✝, fiber := { as := as✝ } }.fiber.as
⊢ (𝟭 (Grothendieck (G ⋙ typeToCat))).map { base := base, fiber := { down := { down := f } } } ≫
      ((fun X =>
            Grothendieck.casesOn X fun base fiber =>
              Discrete.casesOn fiber fun as =>
                Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
          { base := base✝, fiber := { as := as✝ } }).hom =
    ((fun X =>
            Grothendieck.casesOn X fun base fiber =>
              Discrete.casesOn fiber fun as =>
                Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
          { base := base✝¹, fiber := { as := as✝¹ } }).hom ≫
      (grothendieckTypeToCatFunctor G ⋙ grothendieckTypeToCatInverse G).map
        { base := base, fiber := { down := { down := f } } }
tactic: rintro ⟨_, ⟨⟩⟩ ⟨_, ⟨⟩⟩ ⟨base, ⟨⟨f⟩⟩⟩
state_before: case mk.mk.mk.mk.mk.up.up
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝¹ : C
as✝¹ : G.obj base✝¹
base✝ : C
as✝ : G.obj base✝
base : { base := base✝¹, fiber := { as := as✝¹ } }.base ⟶ { base := base✝, fiber := { as := as✝ } }.base
f :
  (((G ⋙ typeToCat).map base).obj { base := base✝¹, fiber := { as := as✝¹ } }.fiber).as =
    { base := base✝, fiber := { as := as✝ } }.fiber.as
⊢ (𝟭 (Grothendieck (G ⋙ typeToCat))).map { base := base, fiber := { down := { down := f } } } ≫
      ((fun X =>
            Grothendieck.casesOn X fun base fiber =>
              Discrete.casesOn fiber fun as =>
                Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
          { base := base✝, fiber := { as := as✝ } }).hom =
    ((fun X =>
            Grothendieck.casesOn X fun base fiber =>
              Discrete.casesOn fiber fun as =>
                Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
          { base := base✝¹, fiber := { as := as✝¹ } }).hom ≫
      (grothendieckTypeToCatFunctor G ⋙ grothendieckTypeToCatInverse G).map
        { base := base, fiber := { down := { down := f } } }
state_after: case mk.mk.mk.mk.mk.up.up
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝¹ : C
as✝¹ : G.obj base✝¹
base✝ : C
as✝ : G.obj base✝
base : { base := base✝¹, fiber := { as := as✝¹ } }.base ⟶ { base := base✝, fiber := { as := as✝ } }.base
f :
  (((G ⋙ typeToCat).map base).obj { base := base✝¹, fiber := { as := as✝¹ } }.fiber).as =
    { base := base✝, fiber := { as := as✝ } }.fiber.as
⊢ { base := base, fiber := { down := { down := f } } } ≫ 𝟙 { base := base✝, fiber := { as := as✝ } } =
    𝟙 { base := base✝¹, fiber := { as := as✝¹ } } ≫
      (grothendieckTypeToCatInverse G).map
        ((grothendieckTypeToCatFunctor G).map { base := base, fiber := { down := { down := f } } })
tactic: dsimp at *
state_before: case mk.mk.mk.mk.mk.up.up
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝¹ : C
as✝¹ : G.obj base✝¹
base✝ : C
as✝ : G.obj base✝
base : { base := base✝¹, fiber := { as := as✝¹ } }.base ⟶ { base := base✝, fiber := { as := as✝ } }.base
f :
  (((G ⋙ typeToCat).map base).obj { base := base✝¹, fiber := { as := as✝¹ } }.fiber).as =
    { base := base✝, fiber := { as := as✝ } }.fiber.as
⊢ { base := base, fiber := { down := { down := f } } } ≫ 𝟙 { base := base✝, fiber := { as := as✝ } } =
    𝟙 { base := base✝¹, fiber := { as := as✝¹ } } ≫
      (grothendieckTypeToCatInverse G).map
        ((grothendieckTypeToCatFunctor G).map { base := base, fiber := { down := { down := f } } })
state_after: case mk.mk.mk.mk.mk.up.up
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝¹ : C
as✝¹ : G.obj base✝¹
base✝ : C
as✝ : G.obj base✝
base : { base := base✝¹, fiber := { as := as✝¹ } }.base ⟶ { base := base✝, fiber := { as := as✝ } }.base
f :
  (((G ⋙ typeToCat).map base).obj { base := base✝¹, fiber := { as := as✝¹ } }.fiber).as =
    { base := base✝, fiber := { as := as✝ } }.fiber.as
⊢ { base := base, fiber := { down := { down := f } } } =
    (grothendieckTypeToCatInverse G).map
      ((grothendieckTypeToCatFunctor G).map { base := base, fiber := { down := { down := f } } })
tactic: simp
state_before: case mk.mk.mk.mk.mk.up.up
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝¹ : C
as✝¹ : G.obj base✝¹
base✝ : C
as✝ : G.obj base✝
base : { base := base✝¹, fiber := { as := as✝¹ } }.base ⟶ { base := base✝, fiber := { as := as✝ } }.base
f :
  (((G ⋙ typeToCat).map base).obj { base := base✝¹, fiber := { as := as✝¹ } }.fiber).as =
    { base := base✝, fiber := { as := as✝ } }.fiber.as
⊢ { base := base, fiber := { down := { down := f } } } =
    (grothendieckTypeToCatInverse G).map
      ((grothendieckTypeToCatFunctor G).map { base := base, fiber := { down := { down := f } } })
state_after: no goals
tactic: rfl
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
X : G.Elements
⊢ (grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X
state_after: case mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
fst✝ : C
snd✝ : G.obj fst✝
⊢ (grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst✝, snd✝⟩ ≅ (𝟭 G.Elements).obj ⟨fst✝, snd✝⟩
tactic: cases X
state_before: case mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
fst✝ : C
snd✝ : G.obj fst✝
⊢ (grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst✝, snd✝⟩ ≅ (𝟭 G.Elements).obj ⟨fst✝, snd✝⟩
state_after: no goals
tactic: exact Iso.refl _
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
⊢ ∀ {X Y : G.Elements} (f : X ⟶ Y),
    (grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).map f ≫
        ((fun X =>
              Sigma.casesOn (motive := fun t =>
                X = t →
                  ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
                X
                (fun fst snd h =>
                  ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
                ⋯)
            Y).hom =
      ((fun X =>
              Sigma.casesOn (motive := fun t =>
                X = t →
                  ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
                X
                (fun fst snd h =>
                  ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
                ⋯)
            X).hom ≫
        (𝟭 G.Elements).map f
state_after: case mk.mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
fst✝¹ : C
snd✝¹ : G.obj fst✝¹
fst✝ : C
snd✝ : G.obj fst✝
f : ⟨fst✝¹, snd✝¹⟩.fst ⟶ ⟨fst✝, snd✝⟩.fst
e : G.map f ⟨fst✝¹, snd✝¹⟩.snd = ⟨fst✝, snd✝⟩.snd
⊢ (grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).map ⟨f, e⟩ ≫
      ((fun X =>
            Sigma.casesOn (motive := fun t =>
              X = t → ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
              X
              (fun fst snd h =>
                ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
              ⋯)
          ⟨fst✝, snd✝⟩).hom =
    ((fun X =>
            Sigma.casesOn (motive := fun t =>
              X = t → ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
              X
              (fun fst snd h =>
                ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
              ⋯)
          ⟨fst✝¹, snd✝¹⟩).hom ≫
      (𝟭 G.Elements).map ⟨f, e⟩
tactic: rintro ⟨⟩ ⟨⟩ ⟨f, e⟩
state_before: case mk.mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
fst✝¹ : C
snd✝¹ : G.obj fst✝¹
fst✝ : C
snd✝ : G.obj fst✝
f : ⟨fst✝¹, snd✝¹⟩.fst ⟶ ⟨fst✝, snd✝⟩.fst
e : G.map f ⟨fst✝¹, snd✝¹⟩.snd = ⟨fst✝, snd✝⟩.snd
⊢ (grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).map ⟨f, e⟩ ≫
      ((fun X =>
            Sigma.casesOn (motive := fun t =>
              X = t → ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
              X
              (fun fst snd h =>
                ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
              ⋯)
          ⟨fst✝, snd✝⟩).hom =
    ((fun X =>
            Sigma.casesOn (motive := fun t =>
              X = t → ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
              X
              (fun fst snd h =>
                ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
              ⋯)
          ⟨fst✝¹, snd✝¹⟩).hom ≫
      (𝟭 G.Elements).map ⟨f, e⟩
state_after: case mk.mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
fst✝¹ : C
snd✝¹ : G.obj fst✝¹
fst✝ : C
snd✝ : G.obj fst✝
f : ⟨fst✝¹, snd✝¹⟩.fst ⟶ ⟨fst✝, snd✝⟩.fst
e : G.map f ⟨fst✝¹, snd✝¹⟩.snd = ⟨fst✝, snd✝⟩.snd
⊢ (grothendieckTypeToCatFunctor G).map ((grothendieckTypeToCatInverse G).map ⟨f, e⟩) ≫
      𝟙 ((grothendieckTypeToCatFunctor G).obj ((grothendieckTypeToCatInverse G).obj ⟨fst✝, snd✝⟩)) =
    𝟙 ((grothendieckTypeToCatFunctor G).obj ((grothendieckTypeToCatInverse G).obj ⟨fst✝¹, snd✝¹⟩)) ≫ ⟨f, e⟩
tactic: dsimp at *
state_before: case mk.mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
fst✝¹ : C
snd✝¹ : G.obj fst✝¹
fst✝ : C
snd✝ : G.obj fst✝
f : ⟨fst✝¹, snd✝¹⟩.fst ⟶ ⟨fst✝, snd✝⟩.fst
e : G.map f ⟨fst✝¹, snd✝¹⟩.snd = ⟨fst✝, snd✝⟩.snd
⊢ (grothendieckTypeToCatFunctor G).map ((grothendieckTypeToCatInverse G).map ⟨f, e⟩) ≫
      𝟙 ((grothendieckTypeToCatFunctor G).obj ((grothendieckTypeToCatInverse G).obj ⟨fst✝, snd✝⟩)) =
    𝟙 ((grothendieckTypeToCatFunctor G).obj ((grothendieckTypeToCatInverse G).obj ⟨fst✝¹, snd✝¹⟩)) ≫ ⟨f, e⟩
state_after: case mk.mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
fst✝¹ : C
snd✝¹ : G.obj fst✝¹
fst✝ : C
snd✝ : G.obj fst✝
f : ⟨fst✝¹, snd✝¹⟩.fst ⟶ ⟨fst✝, snd✝⟩.fst
e : G.map f ⟨fst✝¹, snd✝¹⟩.snd = ⟨fst✝, snd✝⟩.snd
⊢ (grothendieckTypeToCatFunctor G).map ((grothendieckTypeToCatInverse G).map ⟨f, e⟩) = ⟨f, e⟩
tactic: simp
state_before: case mk.mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
fst✝¹ : C
snd✝¹ : G.obj fst✝¹
fst✝ : C
snd✝ : G.obj fst✝
f : ⟨fst✝¹, snd✝¹⟩.fst ⟶ ⟨fst✝, snd✝⟩.fst
e : G.map f ⟨fst✝¹, snd✝¹⟩.snd = ⟨fst✝, snd✝⟩.snd
⊢ (grothendieckTypeToCatFunctor G).map ((grothendieckTypeToCatInverse G).map ⟨f, e⟩) = ⟨f, e⟩
state_after: no goals
tactic: rfl
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
⊢ ∀ (X : Grothendieck (G ⋙ typeToCat)),
    (grothendieckTypeToCatFunctor G).map
          ((NatIso.ofComponents
                  (fun X =>
                    Grothendieck.casesOn X fun base fiber =>
                      Discrete.casesOn fiber fun as =>
                        Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
                  ⋯).hom.app
            X) ≫
        (NatIso.ofComponents
                (fun X =>
                  Sigma.casesOn (motive := fun t =>
                    X = t →
                      ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
                    X
                    (fun fst snd h =>
                      ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
                    ⋯)
                ⋯).hom.app
          ((grothendieckTypeToCatFunctor G).obj X) =
      𝟙 ((grothendieckTypeToCatFunctor G).obj X)
state_after: case mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝ : C
as✝ : G.obj base✝
⊢ (grothendieckTypeToCatFunctor G).map
        ((NatIso.ofComponents
                (fun X =>
                  Grothendieck.casesOn X fun base fiber =>
                    Discrete.casesOn fiber fun as =>
                      Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
                ⋯).hom.app
          { base := base✝, fiber := { as := as✝ } }) ≫
      (NatIso.ofComponents
              (fun X =>
                Sigma.casesOn (motive := fun t =>
                  X = t →
                    ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
                  X
                  (fun fst snd h =>
                    ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
                  ⋯)
              ⋯).hom.app
        ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }) =
    𝟙 ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })
tactic: rintro ⟨_, ⟨⟩⟩
state_before: case mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝ : C
as✝ : G.obj base✝
⊢ (grothendieckTypeToCatFunctor G).map
        ((NatIso.ofComponents
                (fun X =>
                  Grothendieck.casesOn X fun base fiber =>
                    Discrete.casesOn fiber fun as =>
                      Iso.refl ((𝟭 (Grothendieck (G ⋙ typeToCat))).obj { base := base, fiber := { as := as } }))
                ⋯).hom.app
          { base := base✝, fiber := { as := as✝ } }) ≫
      (NatIso.ofComponents
              (fun X =>
                Sigma.casesOn (motive := fun t =>
                  X = t →
                    ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj X ≅ (𝟭 G.Elements).obj X))
                  X
                  (fun fst snd h =>
                    ⋯ ▸ Iso.refl ((grothendieckTypeToCatInverse G ⋙ grothendieckTypeToCatFunctor G).obj ⟨fst, snd⟩))
                  ⋯)
              ⋯).hom.app
        ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }) =
    𝟙 ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })
state_after: case mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝ : C
as✝ : G.obj base✝
⊢ (grothendieckTypeToCatFunctor G).map (𝟙 { base := base✝, fiber := { as := as✝ } }) ≫
      (Sigma.rec (motive := fun t =>
          (grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } } = t →
            ((grothendieckTypeToCatFunctor G).obj
                ((grothendieckTypeToCatInverse G).obj
                  ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })) ≅
              (grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }))
          (fun fst snd h =>
            ⋯ ▸ Iso.refl ((grothendieckTypeToCatFunctor G).obj ((grothendieckTypeToCatInverse G).obj ⟨fst, snd⟩)))
          ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }) ⋯).hom =
    𝟙 ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })
tactic: dsimp
state_before: case mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝ : C
as✝ : G.obj base✝
⊢ (grothendieckTypeToCatFunctor G).map (𝟙 { base := base✝, fiber := { as := as✝ } }) ≫
      (Sigma.rec (motive := fun t =>
          (grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } } = t →
            ((grothendieckTypeToCatFunctor G).obj
                ((grothendieckTypeToCatInverse G).obj
                  ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })) ≅
              (grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }))
          (fun fst snd h =>
            ⋯ ▸ Iso.refl ((grothendieckTypeToCatFunctor G).obj ((grothendieckTypeToCatInverse G).obj ⟨fst, snd⟩)))
          ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }) ⋯).hom =
    𝟙 ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })
state_after: case mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝ : C
as✝ : G.obj base✝
⊢ (Sigma.rec (motive := fun t =>
        (grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } } = t →
          ((grothendieckTypeToCatFunctor G).obj
              ((grothendieckTypeToCatInverse G).obj
                ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })) ≅
            (grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }))
        (fun fst snd h =>
          ⋯ ▸ Iso.refl ((grothendieckTypeToCatFunctor G).obj ((grothendieckTypeToCatInverse G).obj ⟨fst, snd⟩)))
        ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }) ⋯).hom =
    𝟙 ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })
tactic: simp
state_before: case mk.mk
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.62170, u_1} C
inst✝ : Category.{?u.62174, u_2} D
F : C ⥤ Cat
G : C ⥤ Type w
base✝ : C
as✝ : G.obj base✝
⊢ (Sigma.rec (motive := fun t =>
        (grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } } = t →
          ((grothendieckTypeToCatFunctor G).obj
              ((grothendieckTypeToCatInverse G).obj
                ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })) ≅
            (grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }))
        (fun fst snd h =>
          ⋯ ▸ Iso.refl ((grothendieckTypeToCatFunctor G).obj ((grothendieckTypeToCatInverse G).obj ⟨fst, snd⟩)))
        ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } }) ⋯).hom =
    𝟙 ((grothendieckTypeToCatFunctor G).obj { base := base✝, fiber := { as := as✝ } })
state_after: no goals
tactic: rfl