Theorem: CategoryTheory.Limits.opCoproductIsoProduct'_comp_self
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: apply Quiver.Hom.unop_inj
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
⊢ (opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv = (hc.coconePointUniqueUpToIso hc').op.inv
state_after: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
⊢ ((opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv).unop =
    (hc.coconePointUniqueUpToIso hc').op.inv.unop

tactic: apply hc'.hom_ext
state_before: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
⊢ ((opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv).unop =
    (hc.coconePointUniqueUpToIso hc').op.inv.unop
state_after: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
⊢ ∀ (j : Discrete α),
    c'.ι.app j ≫ ((opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv).unop =
      c'.ι.app j ≫ (hc.coconePointUniqueUpToIso hc').op.inv.unop

tactic: intro ⟨j⟩
state_before: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
⊢ ∀ (j : Discrete α),
    c'.ι.app j ≫ ((opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv).unop =
      c'.ι.app j ≫ (hc.coconePointUniqueUpToIso hc').op.inv.unop
state_after: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ c'.ι.app { as := j } ≫ ((opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv).unop =
    c'.ι.app { as := j } ≫ (hc.coconePointUniqueUpToIso hc').op.inv.unop

tactic: change c'.inj _ ≫ _ = _
state_before: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ c'.ι.app { as := j } ≫ ((opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv).unop =
    c'.ι.app { as := j } ≫ (hc.coconePointUniqueUpToIso hc').op.inv.unop
state_after: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ c'.inj j ≫ ((opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv).unop =
    c'.ι.app { as := j } ≫ (hc.coconePointUniqueUpToIso hc').op.inv.unop

tactic: simp only [unop_op, unop_comp, Discrete.functor_obj, const_obj_obj, Iso.op_inv,
  Quiver.Hom.unop_op, IsColimit.comp_coconePointUniqueUpToIso_inv]
state_before: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ c'.inj j ≫ ((opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv).unop =
    c'.ι.app { as := j } ≫ (hc.coconePointUniqueUpToIso hc').op.inv.unop
state_after: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ c'.inj j ≫ (opCoproductIsoProduct' hc' hf).inv.unop ≫ (opCoproductIsoProduct' hc hf).hom.unop = c.ι.app { as := j }

tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ c'.inj j ≫ (opCoproductIsoProduct' hc' hf).inv.unop ≫ (opCoproductIsoProduct' hc hf).hom.unop = c.ι.app { as := j }
state_after: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ (c'.inj j ≫ (opCoproductIsoProduct' hc' hf).inv.unop ≫ (opCoproductIsoProduct' hc hf).hom.unop).op =
    (c.ι.app { as := j }).op

tactic: simp only [op_comp, op_unop, Quiver.Hom.op_unop, Category.assoc,
  opCoproductIsoProduct'_inv_comp_inj]
state_before: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ (c'.inj j ≫ (opCoproductIsoProduct' hc' hf).inv.unop ≫ (opCoproductIsoProduct' hc hf).hom.unop).op =
    (c.ι.app { as := j }).op
state_after: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ (opCoproductIsoProduct' hc hf).hom ≫ f.proj j = (c.ι.app { as := j }).op

tactic: rw [← opCoproductIsoProduct'_inv_comp_inj hc hf]
state_before: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ (opCoproductIsoProduct' hc hf).hom ≫ f.proj j = (c.ι.app { as := j }).op
state_after: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ (opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc hf).inv ≫ (c.inj j).op = (c.ι.app { as := j }).op

tactic: simp only [Iso.hom_inv_id_assoc]
state_before: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ (opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc hf).inv ≫ (c.inj j).op = (c.ι.app { as := j }).op
state_after: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ (c.inj j).op = (c.ι.app { as := j }).op

tactic: rfl
state_before: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
inst✝ : HasCoproduct Z
c c' : Cofan Z
f : Fan fun x => { unop := Z x }
hc : IsColimit c
hc' : IsColimit c'
hf : IsLimit f
j : α
⊢ (c.inj j).op = (c.ι.app { as := j }).op
state_after: no goals