Theorem: CategoryTheory.Abelian.extFunctor_obj
File: Mathlib/Algebra/Homology/DerivedCategory/Ext.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y : C
⊢ ∀ (a b : Ext (Opposite.unop X₁) Y n),
    (fun α => (Ext.mk₀ f.unop).comp α ⋯) (a + b) =
      (fun α => (Ext.mk₀ f.unop).comp α ⋯) a + (fun α => (Ext.mk₀ f.unop).comp α ⋯) b
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
⊢ ((fun X => extFunctorObj (Opposite.unop X) n) X₁).map g ≫
      (fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯)) Y₂ =
    (fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯)) Y₁ ≫
      ((fun X => extFunctorObj (Opposite.unop X) n) X₂).map g
state_after: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ (((fun X => extFunctorObj (Opposite.unop X) n) X₁).map g ≫
        (fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯)) Y₂)
      α =
    ((fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯)) Y₁ ≫
        ((fun X => extFunctorObj (Opposite.unop X) n) X₂).map g)
      α
tactic: ext α
state_before: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ (((fun X => extFunctorObj (Opposite.unop X) n) X₁).map g ≫
        (fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯)) Y₂)
      α =
    ((fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯)) Y₁ ≫
        ((fun X => extFunctorObj (Opposite.unop X) n) X₂).map g)
      α
state_after: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ (AddCommGrp.ofHom ((Ext.mk₀ g).postcomp (Opposite.unop X₁) ⋯) ≫
        AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯))
      α =
    (AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯) ≫
        AddCommGrp.ofHom ((Ext.mk₀ g).postcomp (Opposite.unop X₂) ⋯))
      α
tactic: dsimp
state_before: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ (AddCommGrp.ofHom ((Ext.mk₀ g).postcomp (Opposite.unop X₁) ⋯) ≫
        AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯))
      α =
    (AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯) ≫
        AddCommGrp.ofHom ((Ext.mk₀ g).postcomp (Opposite.unop X₂) ⋯))
      α
state_after: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ (AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯) ≫
        AddCommGrp.ofHom ((Ext.mk₀ g).postcomp (Opposite.unop X₂) ⋯))
      α =
    (AddCommGrp.ofHom ((Ext.mk₀ g).postcomp (Opposite.unop X₁) ⋯) ≫
        AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯))
      α
tactic: symm
state_before: case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ (AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯) ≫
        AddCommGrp.ofHom ((Ext.mk₀ g).postcomp (Opposite.unop X₂) ⋯))
      α =
    (AddCommGrp.ofHom ((Ext.mk₀ g).postcomp (Opposite.unop X₁) ⋯) ≫
        AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯))
      α
state_after: case w.h₁₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ 0 + n = n

case w.h₂₃
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ n + 0 = n

case w.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ 0 + n + 0 = n
tactic: apply Ext.comp_assoc
state_before: case w.h₁₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ 0 + n = n

case w.h₂₃
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ n + 0 = n

case w.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ : Cᵒᵖ
f : X₁ ⟶ X₂
Y₁ Y₂ : C
g : Y₁ ⟶ Y₂
α : ↑(((fun X => extFunctorObj (Opposite.unop X) n) X₁).obj Y₁)
⊢ 0 + n + 0 = n
state_after: no goals
tactic: all_goals omega
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
⊢ { obj := fun X => extFunctorObj (Opposite.unop X) n,
          map := fun {X₁ X₂} f =>
            { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
              naturality := ⋯ } }.map
      (f ≫ f') =
    { obj := fun X => extFunctorObj (Opposite.unop X) n,
            map := fun {X₁ X₂} f =>
              { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                naturality := ⋯ } }.map
        f ≫
      { obj := fun X => extFunctorObj (Opposite.unop X) n,
            map := fun {X₁ X₂} f =>
              { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                naturality := ⋯ } }.map
        f'
state_after: case w.h.w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ (({ obj := fun X => extFunctorObj (Opposite.unop X) n,
                map := fun {X₁ X₂} f =>
                  { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                    naturality := ⋯ } }.map
            (f ≫ f')).app
        Y)
      α =
    (({ obj := fun X => extFunctorObj (Opposite.unop X) n,
                  map := fun {X₁ X₂} f =>
                    { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                      naturality := ⋯ } }.map
              f ≫
            { obj := fun X => extFunctorObj (Opposite.unop X) n,
                  map := fun {X₁ X₂} f =>
                    { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                      naturality := ⋯ } }.map
              f').app
        Y)
      α
tactic: ext Y α
state_before: case w.h.w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ (({ obj := fun X => extFunctorObj (Opposite.unop X) n,
                map := fun {X₁ X₂} f =>
                  { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                    naturality := ⋯ } }.map
            (f ≫ f')).app
        Y)
      α =
    (({ obj := fun X => extFunctorObj (Opposite.unop X) n,
                  map := fun {X₁ X₂} f =>
                    { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                      naturality := ⋯ } }.map
              f ≫
            { obj := fun X => extFunctorObj (Opposite.unop X) n,
                  map := fun {X₁ X₂} f =>
                    { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                      naturality := ⋯ } }.map
              f').app
        Y)
      α
state_after: case w.h.w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ (Ext.mk₀ (f'.unop ≫ f.unop)).comp α ⋯ =
    (AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯) ≫
        AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f'.unop).comp α ⋯) ⋯))
      α
tactic: dsimp
state_before: case w.h.w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ (Ext.mk₀ (f'.unop ≫ f.unop)).comp α ⋯ =
    (AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯) ≫
        AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f'.unop).comp α ⋯) ⋯))
      α
state_after: case w.h.w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ ((Ext.mk₀ f'.unop).comp (Ext.mk₀ f.unop) ⋯).comp α ⋯ =
    (AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯) ≫
        AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f'.unop).comp α ⋯) ⋯))
      α
tactic: rw [← Ext.mk₀_comp_mk₀]
state_before: case w.h.w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ ((Ext.mk₀ f'.unop).comp (Ext.mk₀ f.unop) ⋯).comp α ⋯ =
    (AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯) ≫
        AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f'.unop).comp α ⋯) ⋯))
      α
state_after: case w.h.w.h₂₃
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ 0 + n = n

case w.h.w.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ 0 + 0 + n = n
tactic: apply Ext.comp_assoc
state_before: case w.h.w.h₂₃
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ 0 + n = n

case w.h.w.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
n : ℕ
X₁ X₂ X₃ : Cᵒᵖ
f : X₁ ⟶ X₂
f' : X₂ ⟶ X₃
Y : C
α :
  ↑(({ obj := fun X => extFunctorObj (Opposite.unop X) n,
              map := fun {X₁ X₂} f =>
                { app := fun Y => AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (Ext.mk₀ f.unop).comp α ⋯) ⋯),
                  naturality := ⋯ } }.obj
          X₁).obj
      Y)
⊢ 0 + 0 + n = n
state_after: no goals
tactic: all_goals omega