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

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X : Grothendieck F
⊢ { obj := fun X => { base := X.base, fiber := (α.app X.base).obj X.fiber },
          map := fun {X Y} f => { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber } }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => { base := X.base, fiber := (α.app X.base).obj X.fiber },
            map := fun {X Y} f =>
              { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber } }.obj
        X)
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X : Grothendieck F
⊢ { base := (𝟙 X).base, fiber := (eqToHom ⋯).app X.fiber ≫ eqToHom ⋯ } =
    𝟙 { base := X.base, fiber := (α.app X.base).obj X.fiber }
tactic: simp only [Cat.comp_obj, id_fiber', eqToHom_map]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X : Grothendieck F
⊢ { base := (𝟙 X).base, fiber := (eqToHom ⋯).app X.fiber ≫ eqToHom ⋯ } =
    𝟙 { base := X.base, fiber := (α.app X.base).obj X.fiber }
state_after: case e_fiber
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X : Grothendieck F
⊢ (eqToHom ⋯).app X.fiber ≫ eqToHom ⋯ = eqToHom ⋯
tactic: congr 1
state_before: case e_fiber
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X : Grothendieck F
⊢ (eqToHom ⋯).app X.fiber ≫ eqToHom ⋯ = eqToHom ⋯
state_after: no goals
tactic: rw [eqToHom_app, eqToHom_trans]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => { base := X.base, fiber := (α.app X.base).obj X.fiber },
          map := fun {X Y} f => { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber } }.map
      (f ≫ g) =
    { obj := fun X => { base := X.base, fiber := (α.app X.base).obj X.fiber },
            map := fun {X Y} f =>
              { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber } }.map
        f ≫
      { obj := fun X => { base := X.base, fiber := (α.app X.base).obj X.fiber },
            map := fun {X Y} f =>
              { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber } }.map
        g
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ { base := (f ≫ g).base,
      fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Z.base).map (eqToHom ⋯ ≫ (F.map g.base).map f.fiber ≫ g.fiber) } =
    { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber } ≫
      { base := g.base, fiber := (eqToHom ⋯).app Y.fiber ≫ (α.app Z.base).map g.fiber }
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ { base := (f ≫ g).base,
      fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Z.base).map (eqToHom ⋯ ≫ (F.map g.base).map f.fiber ≫ g.fiber) } =
    { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber } ≫
      { base := g.base, fiber := (eqToHom ⋯).app Y.fiber ≫ (α.app Z.base).map g.fiber }
state_after: case e_fiber
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ (eqToHom ⋯).app X.fiber ≫ (α.app Z.base).map (eqToHom ⋯ ≫ (F.map g.base).map f.fiber ≫ g.fiber) =
    eqToHom ⋯ ≫
      (G.map { base := g.base, fiber := (eqToHom ⋯).app Y.fiber ≫ (α.app Z.base).map g.fiber }.base).map
          { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber }.fiber ≫
        { base := g.base, fiber := (eqToHom ⋯).app Y.fiber ≫ (α.app Z.base).map g.fiber }.fiber
tactic: congr 1
state_before: case e_fiber
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ (eqToHom ⋯).app X.fiber ≫ (α.app Z.base).map (eqToHom ⋯ ≫ (F.map g.base).map f.fiber ≫ g.fiber) =
    eqToHom ⋯ ≫
      (G.map { base := g.base, fiber := (eqToHom ⋯).app Y.fiber ≫ (α.app Z.base).map g.fiber }.base).map
          { base := f.base, fiber := (eqToHom ⋯).app X.fiber ≫ (α.app Y.base).map f.fiber }.fiber ≫
        { base := g.base, fiber := (eqToHom ⋯).app Y.fiber ≫ (α.app Z.base).map g.fiber }.fiber
state_after: case e_fiber
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ (((eqToHom ⋯).app X.fiber ≫ eqToHom ⋯) ≫ (α.app Z.base).map ((F.map g.base).map f.fiber)) ≫
      (α.app Z.base).map g.fiber =
    (((eqToHom ⋯ ≫ (G.map g.base).map ((eqToHom ⋯).app X.fiber)) ≫ (G.map g.base).map ((α.app Y.base).map f.fiber)) ≫
        (eqToHom ⋯).app Y.fiber) ≫
      (α.app Z.base).map g.fiber
tactic: simp only [comp_fiber' f g, ← Category.assoc, Functor.map_comp, eqToHom_map]
state_before: case e_fiber
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ (((eqToHom ⋯).app X.fiber ≫ eqToHom ⋯) ≫ (α.app Z.base).map ((F.map g.base).map f.fiber)) ≫
      (α.app Z.base).map g.fiber =
    (((eqToHom ⋯ ≫ (G.map g.base).map ((eqToHom ⋯).app X.fiber)) ≫ (G.map g.base).map ((α.app Y.base).map f.fiber)) ≫
        (eqToHom ⋯).app Y.fiber) ≫
      (α.app Z.base).map g.fiber
state_after: case e_fiber.e_a
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ ((eqToHom ⋯).app X.fiber ≫ eqToHom ⋯) ≫ (α.app Z.base).map ((F.map g.base).map f.fiber) =
    ((eqToHom ⋯ ≫ (G.map g.base).map ((eqToHom ⋯).app X.fiber)) ≫ (G.map g.base).map ((α.app Y.base).map f.fiber)) ≫
      (eqToHom ⋯).app Y.fiber
tactic: congr 1
state_before: case e_fiber.e_a
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ ((eqToHom ⋯).app X.fiber ≫ eqToHom ⋯) ≫ (α.app Z.base).map ((F.map g.base).map f.fiber) =
    ((eqToHom ⋯ ≫ (G.map g.base).map ((eqToHom ⋯).app X.fiber)) ≫ (G.map g.base).map ((α.app Y.base).map f.fiber)) ≫
      (eqToHom ⋯).app Y.fiber
state_after: case e_fiber.e_a
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ (eqToHom ⋯).app X.fiber ≫ eqToHom ⋯ ≫ (α.app Z.base).map ((F.map g.base).map f.fiber) =
    eqToHom ⋯ ≫
      (G.map g.base).map ((eqToHom ⋯).app X.fiber) ≫
        (G.map g.base).map ((α.app Y.base).map f.fiber) ≫ (eqToHom ⋯).app Y.fiber
tactic: simp only [Cat.comp_obj, eqToHom_trans, eqToHom_map, Cat.comp_map, eqToHom_trans_assoc,
      Category.assoc]
state_before: case e_fiber.e_a
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ (eqToHom ⋯).app X.fiber ≫ eqToHom ⋯ ≫ (α.app Z.base).map ((F.map g.base).map f.fiber) =
    eqToHom ⋯ ≫
      (G.map g.base).map ((eqToHom ⋯).app X.fiber) ≫
        (G.map g.base).map ((α.app Y.base).map f.fiber) ≫ (eqToHom ⋯).app Y.fiber
state_after: case e_fiber.e_a
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ eqToHom ⋯ ≫ eqToHom ⋯ ≫ (α.app Z.base).map ((F.map g.base).map f.fiber) =
    eqToHom ⋯ ≫ (G.map g.base).map (eqToHom ⋯) ≫ (G.map g.base).map ((α.app Y.base).map f.fiber) ≫ eqToHom ⋯
tactic: rw [eqToHom_app, eqToHom_app, eqToHom_app]
state_before: case e_fiber.e_a
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ eqToHom ⋯ ≫ eqToHom ⋯ ≫ (α.app Z.base).map ((F.map g.base).map f.fiber) =
    eqToHom ⋯ ≫ (G.map g.base).map (eqToHom ⋯) ≫ (G.map g.base).map ((α.app Y.base).map f.fiber) ≫ eqToHom ⋯
state_after: case e_fiber.e_a
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ eqToHom ⋯ ≫ eqToHom ⋯ ≫ (α.app Z.base).map ((F.map g.base).map f.fiber) =
    eqToHom ⋯ ≫
      (G.map g.base).map (eqToHom ⋯) ≫ (eqToHom ⋯ ≫ (F.map g.base ≫ α.app Z.base).map f.fiber ≫ eqToHom ⋯) ≫ eqToHom ⋯
tactic: erw [Functor.congr_hom (α.naturality g.base).symm f.fiber]
state_before: case e_fiber.e_a
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.25278, u_1} C
inst✝ : Category.{?u.25282, u_2} D
F G : C ⥤ Cat
α : F ⟶ G
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ eqToHom ⋯ ≫ eqToHom ⋯ ≫ (α.app Z.base).map ((F.map g.base).map f.fiber) =
    eqToHom ⋯ ≫
      (G.map g.base).map (eqToHom ⋯) ≫ (eqToHom ⋯ ≫ (F.map g.base ≫ α.app Z.base).map f.fiber ≫ eqToHom ⋯) ≫ eqToHom ⋯
state_after: no goals
tactic: simp