Theorem: CategoryTheory.Over.coprod_obj
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ : Over A
k : X✝ ⟶ Y✝
g : Over A
⊢ coprod.map k.left (𝟙 ((𝟭 C).obj g.left)) ≫ (((fun f => f.coprodObj) Y✝).obj g).hom =
    (((fun f => f.coprodObj) X✝).obj g).hom
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ : Over A
k : X✝ ⟶ Y✝
g : Over A
⊢ coprod.map k.left (𝟙 g.left) ≫ coprod.desc Y✝.hom g.hom = coprod.desc X✝.hom g.hom
tactic: dsimp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ : Over A
k : X✝ ⟶ Y✝
g : Over A
⊢ coprod.map k.left (𝟙 g.left) ≫ coprod.desc Y✝.hom g.hom = coprod.desc X✝.hom g.hom
state_after: no goals
tactic: rw [coprod.map_desc, Category.id_comp, Over.w k]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ : Over A
k✝ : X✝ ⟶ Y✝
f g : Over A
k : f ⟶ g
⊢ ((fun f => f.coprodObj) X✝).map k ≫ (fun g => homMk (coprod.map k✝.left (𝟙 ((𝟭 C).obj g.left))) ⋯) g =
    (fun g => homMk (coprod.map k✝.left (𝟙 ((𝟭 C).obj g.left))) ⋯) f ≫ ((fun f => f.coprodObj) Y✝).map k
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ : Over A
k✝ : X✝ ⟶ Y✝
f g : Over A
k : f ⟶ g
⊢ (((fun f => f.coprodObj) X✝).map k ≫ (fun g => homMk (coprod.map k✝.left (𝟙 ((𝟭 C).obj g.left))) ⋯) g).left =
    ((fun g => homMk (coprod.map k✝.left (𝟙 ((𝟭 C).obj g.left))) ⋯) f ≫ ((fun f => f.coprodObj) Y✝).map k).left
tactic: ext
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ : Over A
k✝ : X✝ ⟶ Y✝
f g : Over A
k : f ⟶ g
⊢ (((fun f => f.coprodObj) X✝).map k ≫ (fun g => homMk (coprod.map k✝.left (𝟙 ((𝟭 C).obj g.left))) ⋯) g).left =
    ((fun g => homMk (coprod.map k✝.left (𝟙 ((𝟭 C).obj g.left))) ⋯) f ≫ ((fun f => f.coprodObj) Y✝).map k).left
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ : Over A
k✝ : X✝ ⟶ Y✝
f g : Over A
k : f ⟶ g
⊢ coprod.map (𝟙 X✝.left) k.left ≫ coprod.map k✝.left (𝟙 g.left) =
    coprod.map k✝.left (𝟙 f.left) ≫ coprod.map (𝟙 Y✝.left) k.left
tactic: dsimp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ : Over A
k✝ : X✝ ⟶ Y✝
f g : Over A
k : f ⟶ g
⊢ coprod.map (𝟙 X✝.left) k.left ≫ coprod.map k✝.left (𝟙 g.left) =
    coprod.map k✝.left (𝟙 f.left) ≫ coprod.map (𝟙 Y✝.left) k.left
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X : Over A
⊢ { obj := fun f => f.coprodObj,
          map := fun {X Y} k =>
            { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun f => f.coprodObj,
            map := fun {X Y} k =>
              { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.obj
        X)
state_after: case w.h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X x✝ : Over A
⊢ (({ obj := fun f => f.coprodObj,
                map := fun {X Y} k =>
                  { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
            (𝟙 X)).app
        x✝).left =
    ((𝟙
            ({ obj := fun f => f.coprodObj,
                  map := fun {X Y} k =>
                    { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.obj
              X)).app
        x✝).left
tactic: ext
state_before: case w.h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X x✝ : Over A
⊢ (({ obj := fun f => f.coprodObj,
                map := fun {X Y} k =>
                  { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
            (𝟙 X)).app
        x✝).left =
    ((𝟙
            ({ obj := fun f => f.coprodObj,
                  map := fun {X Y} k =>
                    { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.obj
              X)).app
        x✝).left
state_after: case w.h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X x✝ : Over A
⊢ coprod.map (𝟙 X.left) (𝟙 x✝.left) = 𝟙 (X.left ⨿ x✝.left)
tactic: dsimp
state_before: case w.h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X x✝ : Over A
⊢ coprod.map (𝟙 X.left) (𝟙 x✝.left) = 𝟙 (X.left ⨿ x✝.left)
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ Z✝ : Over A
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun f => f.coprodObj,
          map := fun {X Y} k =>
            { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
      (f ≫ g) =
    { obj := fun f => f.coprodObj,
            map := fun {X Y} k =>
              { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
        f ≫
      { obj := fun f => f.coprodObj,
            map := fun {X Y} k =>
              { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
        g
state_after: case w.h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ Z✝ : Over A
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
x✝ : Over A
⊢ (({ obj := fun f => f.coprodObj,
                map := fun {X Y} k =>
                  { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
            (f ≫ g)).app
        x✝).left =
    (({ obj := fun f => f.coprodObj,
                  map := fun {X Y} k =>
                    { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
              f ≫
            { obj := fun f => f.coprodObj,
                  map := fun {X Y} k =>
                    { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
              g).app
        x✝).left
tactic: ext
state_before: case w.h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ Z✝ : Over A
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
x✝ : Over A
⊢ (({ obj := fun f => f.coprodObj,
                map := fun {X Y} k =>
                  { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
            (f ≫ g)).app
        x✝).left =
    (({ obj := fun f => f.coprodObj,
                  map := fun {X Y} k =>
                    { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
              f ≫
            { obj := fun f => f.coprodObj,
                  map := fun {X Y} k =>
                    { app := fun g => homMk (coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯, naturality := ⋯ } }.map
              g).app
        x✝).left
state_after: case w.h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ Z✝ : Over A
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
x✝ : Over A
⊢ coprod.map (f.left ≫ g.left) (𝟙 x✝.left) = coprod.map f.left (𝟙 x✝.left) ≫ coprod.map g.left (𝟙 x✝.left)
tactic: dsimp
state_before: case w.h.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasBinaryCoproducts C
A : C
X✝ Y✝ Z✝ : Over A
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
x✝ : Over A
⊢ coprod.map (f.left ≫ g.left) (𝟙 x✝.left) = coprod.map f.left (𝟙 x✝.left) ≫ coprod.map g.left (𝟙 x✝.left)
state_after: no goals
tactic: simp