Theorem: CategoryTheory.Limits.opProductIsoCoproduct'_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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
⊢ (opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv = (hf.conePointUniqueUpToIso hf').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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
⊢ ((opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv).unop =
    (hf.conePointUniqueUpToIso hf').op.inv.unop

tactic: apply hf.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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
⊢ ((opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv).unop =
    (hf.conePointUniqueUpToIso hf').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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
⊢ ∀ (j : Discrete α),
    ((opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv).unop ≫ f.π.app j =
      (hf.conePointUniqueUpToIso hf').op.inv.unop ≫ f.π.app j

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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
⊢ ∀ (j : Discrete α),
    ((opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv).unop ≫ f.π.app j =
      (hf.conePointUniqueUpToIso hf').op.inv.unop ≫ f.π.app j
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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ ((opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv).unop ≫ f.π.app { as := j } =
    (hf.conePointUniqueUpToIso hf').op.inv.unop ≫ f.π.app { as := j }

tactic: change _ ≫ f.proj _ = _
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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ ((opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv).unop ≫ f.π.app { as := j } =
    (hf.conePointUniqueUpToIso hf').op.inv.unop ≫ f.π.app { as := j }
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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ ((opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv).unop ≫ f.proj j =
    (hf.conePointUniqueUpToIso hf').op.inv.unop ≫ f.π.app { as := j }

tactic: simp only [unop_op, unop_comp, Category.assoc, Discrete.functor_obj, Iso.op_inv,
  Quiver.Hom.unop_op, IsLimit.conePointUniqueUpToIso_inv_comp]
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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ ((opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv).unop ≫ f.proj j =
    (hf.conePointUniqueUpToIso hf').op.inv.unop ≫ f.π.app { as := j }
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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ (opProductIsoCoproduct' hf' hc).inv.unop ≫ (opProductIsoCoproduct' hf hc).hom.unop ≫ f.proj j = f'.π.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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ (opProductIsoCoproduct' hf' hc).inv.unop ≫ (opProductIsoCoproduct' hf hc).hom.unop ≫ f.proj j = f'.π.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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ ((opProductIsoCoproduct' hf' hc).inv.unop ≫ (opProductIsoCoproduct' hf hc).hom.unop ≫ f.proj j).op =
    (f'.π.app { as := j }).op

tactic: simp only [op_comp, op_unop, Quiver.Hom.op_unop, proj_comp_opProductIsoCoproduct'_hom]
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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ ((opProductIsoCoproduct' hf' hc).inv.unop ≫ (opProductIsoCoproduct' hf hc).hom.unop ≫ f.proj j).op =
    (f'.π.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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ c.inj j ≫ (opProductIsoCoproduct' hf' hc).inv = (f'.π.app { as := j }).op

tactic: rw [← proj_comp_opProductIsoCoproduct'_hom hf' hc]
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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ c.inj j ≫ (opProductIsoCoproduct' hf' hc).inv = (f'.π.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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ ((f'.proj j).op ≫ (opProductIsoCoproduct' hf' hc).hom) ≫ (opProductIsoCoproduct' hf' hc).inv =
    (f'.π.app { as := j }).op

tactic: simp only [Category.assoc, Iso.hom_inv_id, Category.comp_id]
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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ ((f'.proj j).op ≫ (opProductIsoCoproduct' hf' hc).hom) ≫ (opProductIsoCoproduct' hf' hc).inv =
    (f'.π.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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ (f'.proj j).op = (f'.π.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✝ : HasProduct Z
f f' : Fan Z
c : Cofan fun x => { unop := Z x }
hf : IsLimit f
hf' : IsLimit f'
hc : IsColimit c
j : α
⊢ (f'.proj j).op = (f'.π.app { as := j }).op
state_after: no goals