Theorem: CategoryTheory.Limits.Sigma.ι_reindex_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: dsimp [Sigma.reindex]
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
⊢ ι (f ∘ ↑ε) b ≫ (reindex ε f).hom = ι f (↑ε b)

tactic: simp only [HasColimit.isoOfEquivalence_hom_π, Functor.id_obj, Discrete.functor_obj,
  Function.comp_apply, Discrete.equivalence_functor, Discrete.equivalence_inverse,
  Functor.comp_obj, Discrete.natIso_inv_app, Iso.refl_inv, Category.id_comp]
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
⊢ ι (f ∘ ↑ε) b ≫
      (HasColimit.isoOfEquivalence (Discrete.equivalence ε)
          (Discrete.natIso fun x =>
            Iso.refl ((Discrete.functor f).obj ((Discrete.functor (Discrete.mk ∘ ↑ε)).obj x)))).hom =
    ι f (↑ε b)

tactic: have h := colimit.w (Discrete.functor f) (Discrete.eqToHom' (ε.apply_symm_apply (ε b)))
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
⊢ (Discrete.functor (f ∘ ↑ε)).map ((Equivalence.unit (Discrete.equivalence ε)).app { as := b }) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) } =
    ι f (↑ε b)

tactic: simp only [Discrete.functor_obj] at h
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
h :
  (Discrete.functor f).map (Discrete.eqToHom' (_ : ↑ε (↑ε.symm (↑ε b)) = ↑ε b)) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε b } =
    colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) }
⊢ (Discrete.functor (f ∘ ↑ε)).map ((Equivalence.unit (Discrete.equivalence ε)).app { as := b }) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) } =
    ι f (↑ε b)

tactic: erw [← h, eqToHom_map, eqToHom_map, eqToHom_trans_assoc]
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
h :
  (Discrete.functor f).map (Discrete.eqToHom' (_ : ↑ε (↑ε.symm (↑ε b)) = ↑ε b)) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε b } =
    colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) }
⊢ (Discrete.functor (f ∘ ↑ε)).map ((Equivalence.unit (Discrete.equivalence ε)).app { as := b }) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) } =
    ι f (↑ε b)

tactic: all_goals { simp }
state_before: β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
h :
  (Discrete.functor f).map (Discrete.eqToHom' (_ : ↑ε (↑ε.symm (↑ε b)) = ↑ε b)) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε b } =
    colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) }
⊢ eqToHom (_ : f (↑ε b) = f (↑ε b)) ≫ colimit.ι (Discrete.functor f) { as := ↑ε b } = ι f (↑ε b)

case p
β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
h :
  (Discrete.functor f).map (Discrete.eqToHom' (_ : ↑ε (↑ε.symm (↑ε b)) = ↑ε b)) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε b } =
    colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) }
⊢ { as := b } = { as := ↑ε.symm (↑ε b) }

case p
β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
h :
  (Discrete.functor f).map (Discrete.eqToHom' (_ : ↑ε (↑ε.symm (↑ε b)) = ↑ε b)) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε b } =
    colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) }
⊢ { as := b } = { as := ↑ε.symm (↑ε b) }

case p
β : Type w
C : Type u
inst✝² : Category C
γ : Type v
ε : β ≃ γ
f : γ → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct (f ∘ ↑ε)
b : β
h :
  (Discrete.functor f).map (Discrete.eqToHom' (_ : ↑ε (↑ε.symm (↑ε b)) = ↑ε b)) ≫
      colimit.ι (Discrete.functor f) { as := ↑ε b } =
    colimit.ι (Discrete.functor f) { as := ↑ε (↑ε.symm (↑ε b)) }
⊢ { as := b } = { as := ↑ε.symm (↑ε b) }