Theorem: CategoryTheory.Functor.Iteration.Hom.ext'
File: Mathlib/CategoryTheory/SmallObject/Iteration.lean

tactic: cases f
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
iter₁ iter₂ iter₃ : Iteration ε j
f g : iter₁.Hom iter₂
h : f.natTrans = g.natTrans
⊢ f = g
state_after: case mk
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
iter₁ iter₂ iter₃ : Iteration ε j
g : iter₁.Hom iter₂
natTrans✝ : iter₁.F ⟶ iter₂.F
natTrans_app_zero✝ : natTrans✝.app ⟨⊥, ⋯⟩ = iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝ :
  ∀ (i : J) (hi : i < j),
    natTrans✝.app ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫ whiskerRight (natTrans✝.app ⟨i, ⋯⟩) Φ ≫ (iter₂.isoSucc i hi).inv
h :
  { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ }.natTrans =
    g.natTrans
⊢ { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ } = g

tactic: cases g
state_before: case mk
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
iter₁ iter₂ iter₃ : Iteration ε j
g : iter₁.Hom iter₂
natTrans✝ : iter₁.F ⟶ iter₂.F
natTrans_app_zero✝ : natTrans✝.app ⟨⊥, ⋯⟩ = iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝ :
  ∀ (i : J) (hi : i < j),
    natTrans✝.app ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫ whiskerRight (natTrans✝.app ⟨i, ⋯⟩) Φ ≫ (iter₂.isoSucc i hi).inv
h :
  { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ }.natTrans =
    g.natTrans
⊢ { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ } = g
state_after: case mk.mk
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
iter₁ iter₂ iter₃ : Iteration ε j
natTrans✝¹ : iter₁.F ⟶ iter₂.F
natTrans_app_zero✝¹ : natTrans✝¹.app ⟨⊥, ⋯⟩ = iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝¹ :
  ∀ (i : J) (hi : i < j),
    natTrans✝¹.app ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫ whiskerRight (natTrans✝¹.app ⟨i, ⋯⟩) Φ ≫ (iter₂.isoSucc i hi).inv
natTrans✝ : iter₁.F ⟶ iter₂.F
natTrans_app_zero✝ : natTrans✝.app ⟨⊥, ⋯⟩ = iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝ :
  ∀ (i : J) (hi : i < j),
    natTrans✝.app ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫ whiskerRight (natTrans✝.app ⟨i, ⋯⟩) Φ ≫ (iter₂.isoSucc i hi).inv
h :
  { natTrans := natTrans✝¹, natTrans_app_zero := natTrans_app_zero✝¹,
        natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans =
    { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ }.natTrans
⊢ { natTrans := natTrans✝¹, natTrans_app_zero := natTrans_app_zero✝¹, natTrans_app_succ := natTrans_app_succ✝¹ } =
    { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ }

tactic: subst h
state_before: case mk.mk
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
iter₁ iter₂ iter₃ : Iteration ε j
natTrans✝¹ : iter₁.F ⟶ iter₂.F
natTrans_app_zero✝¹ : natTrans✝¹.app ⟨⊥, ⋯⟩ = iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝¹ :
  ∀ (i : J) (hi : i < j),
    natTrans✝¹.app ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫ whiskerRight (natTrans✝¹.app ⟨i, ⋯⟩) Φ ≫ (iter₂.isoSucc i hi).inv
natTrans✝ : iter₁.F ⟶ iter₂.F
natTrans_app_zero✝ : natTrans✝.app ⟨⊥, ⋯⟩ = iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝ :
  ∀ (i : J) (hi : i < j),
    natTrans✝.app ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫ whiskerRight (natTrans✝.app ⟨i, ⋯⟩) Φ ≫ (iter₂.isoSucc i hi).inv
h :
  { natTrans := natTrans✝¹, natTrans_app_zero := natTrans_app_zero✝¹,
        natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans =
    { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ }.natTrans
⊢ { natTrans := natTrans✝¹, natTrans_app_zero := natTrans_app_zero✝¹, natTrans_app_succ := natTrans_app_succ✝¹ } =
    { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ }
state_after: case mk.mk
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
iter₁ iter₂ iter₃ : Iteration ε j
natTrans✝ : iter₁.F ⟶ iter₂.F
natTrans_app_zero✝¹ : natTrans✝.app ⟨⊥, ⋯⟩ = iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝¹ :
  ∀ (i : J) (hi : i < j),
    natTrans✝.app ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫ whiskerRight (natTrans✝.app ⟨i, ⋯⟩) Φ ≫ (iter₂.isoSucc i hi).inv
natTrans_app_zero✝ :
  { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹,
            natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans.app
      ⟨⊥, ⋯⟩ =
    iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝ :
  ∀ (i : J) (hi : i < j),
    { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹,
              natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans.app
        ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫
        whiskerRight
            ({ natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹,
                    natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans.app
              ⟨i, ⋯⟩)
            Φ ≫
          (iter₂.isoSucc i hi).inv
⊢ { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹, natTrans_app_succ := natTrans_app_succ✝¹ } =
    {
      natTrans :=
        { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹,
            natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans,
      natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ }

tactic: rfl
state_before: case mk.mk
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
iter₁ iter₂ iter₃ : Iteration ε j
natTrans✝ : iter₁.F ⟶ iter₂.F
natTrans_app_zero✝¹ : natTrans✝.app ⟨⊥, ⋯⟩ = iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝¹ :
  ∀ (i : J) (hi : i < j),
    natTrans✝.app ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫ whiskerRight (natTrans✝.app ⟨i, ⋯⟩) Φ ≫ (iter₂.isoSucc i hi).inv
natTrans_app_zero✝ :
  { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹,
            natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans.app
      ⟨⊥, ⋯⟩ =
    iter₁.isoZero.hom ≫ iter₂.isoZero.inv
natTrans_app_succ✝ :
  ∀ (i : J) (hi : i < j),
    { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹,
              natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans.app
        ⟨wellOrderSucc i, ⋯⟩ =
      (iter₁.isoSucc i hi).hom ≫
        whiskerRight
            ({ natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹,
                    natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans.app
              ⟨i, ⋯⟩)
            Φ ≫
          (iter₂.isoSucc i hi).inv
⊢ { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹, natTrans_app_succ := natTrans_app_succ✝¹ } =
    {
      natTrans :=
        { natTrans := natTrans✝, natTrans_app_zero := natTrans_app_zero✝¹,
            natTrans_app_succ := natTrans_app_succ✝¹ }.natTrans,
      natTrans_app_zero := natTrans_app_zero✝, natTrans_app_succ := natTrans_app_succ✝ }
state_after: no goals