l3lab/ntp-mathlib huggingface dataset:
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    

Proof state:
case preservesLimit.H.refine'_2
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k : K
⊢ (((m ≫
            (HasColimit.isoOfNatIso
                (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
                  (limit.isLimit (F ⋙ diagramFunctor J D X.unop)))).hom) ≫
          (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom) ≫
        (HasLimit.isoOfNatIso
            (NatIso.ofComponents fun k =>
                colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k).symm).inv) ≫
      limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) k =
    limit.lift (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) S ≫
      limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) k

Next tactic:
simp only [limit.lift_π, Category.assoc, ← hm]
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    

Proof state:
case preservesLimit.H.refine'_2
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k : K
⊢ m ≫
      (HasColimit.isoOfNatIso
            (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
              (limit.isLimit (F ⋙ diagramFunctor J D X.unop)))).hom ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents fun k =>
                    colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k).symm).inv ≫
            limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) k =
    m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app k

Next tactic:
congr 1
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    congr 1
    

Proof state:
case preservesLimit.H.refine'_2.e_a
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k : K
⊢ (HasColimit.isoOfNatIso
          (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
            (limit.isLimit (F ⋙ diagramFunctor J D X.unop)))).hom ≫
      (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
        (HasLimit.isoOfNatIso
              (NatIso.ofComponents fun k =>
                  colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k).symm).inv ≫
          limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) k =
    ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app k

Next tactic:
refine' colimit.hom_ext (fun k => _)
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    congr 1
    refine' colimit.hom_ext (fun k => _)
    

Proof state:
case preservesLimit.H.refine'_2.e_a
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ colimit.ι (diagram J (limit.cone F).pt X.unop) k ≫
      (HasColimit.isoOfNatIso
            (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
              (limit.isLimit (F ⋙ diagramFunctor J D X.unop)))).hom ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents fun k =>
                    colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k).symm).inv ≫
            limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) k✝ =
    colimit.ι (diagram J (limit.cone F).pt X.unop) k ≫
      ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app k✝

Next tactic:
dsimp [plusMap, plusObj]
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    congr 1
    refine' colimit.hom_ext (fun k => _)
    dsimp [plusMap, plusObj]
    

Proof state:
case preservesLimit.H.refine'_2.e_a
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ colimit.ι (diagram J (limit F) X.unop) k ≫
      (HasColimit.isoOfNatIso
            (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
              (limit.isLimit (F ⋙ diagramFunctor J D X.unop)))).hom ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents fun k =>
                    colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k).symm).inv ≫
            limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) k✝ =
    colimit.ι (diagram J (limit F) X.unop) k ≫ colimMap (diagramNatTrans J (limit.π F k✝) X.unop)

Next tactic:
erw [colimit.ι_map, colimit.ι_desc_assoc, limit.lift_π]
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    congr 1
    refine' colimit.hom_ext (fun k => _)
    dsimp [plusMap, plusObj]
    erw [colimit.ι_map, colimit.ι_desc_assoc, limit.lift_π]
    

Proof state:
case preservesLimit.H.refine'_2.e_a
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ ((Cocones.precompose
                  (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
                      (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom).obj
              (colimit.cocone (limit (F ⋙ diagramFunctor J D X.unop)))).ι.app
        k ≫
      (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
        ((Cones.postcompose
                    (NatIso.ofComponents fun k =>
                          colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop))
                            k).symm.inv).obj
                (limit.cone (colimit (Functor.flip (F ⋙ diagramFunctor J D X.unop))))).π.app
          k✝ =
    (diagramNatTrans J (limit.π F k✝) X.unop).app k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k

Next tactic:
conv_lhs => dsimp
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    congr 1
    refine' colimit.hom_ext (fun k => _)
    dsimp [plusMap, plusObj]
    erw [colimit.ι_map, colimit.ι_desc_assoc, limit.lift_π]
    conv_lhs => 

Proof state:
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
| ((Cocones.precompose
                (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
                    (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom).obj
            (colimit.cocone (limit (F ⋙ diagramFunctor J D X.unop)))).ι.app
      k ≫
    (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
      ((Cones.postcompose
                  (NatIso.ofComponents fun k =>
                        colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop))
                          k).symm.inv).obj
              (limit.cone (colimit (Functor.flip (F ⋙ diagramFunctor J D X.unop))))).π.app
        k✝

Next tactic:
dsimp
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    congr 1
    refine' colimit.hom_ext (fun k => _)
    dsimp [plusMap, plusObj]
    erw [colimit.ι_map, colimit.ι_desc_assoc, limit.lift_π]
    conv_lhs => dsimp
    

Proof state:
case preservesLimit.H.refine'_2.e_a
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ ((IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
                (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom.app
          k ≫
        colimit.ι (limit (F ⋙ diagramFunctor J D X.unop)) k) ≫
      (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
        limit.π (colimit (Functor.flip (F ⋙ diagramFunctor J D X.unop))) k✝ ≫
          (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k✝).hom =
    (diagramNatTrans J (limit.π F k✝) X.unop).app k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k

Next tactic:
simp only [Category.assoc]
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    congr 1
    refine' colimit.hom_ext (fun k => _)
    dsimp [plusMap, plusObj]
    erw [colimit.ι_map, colimit.ι_desc_assoc, limit.lift_π]
    conv_lhs => dsimp
    simp only [Category.assoc]
    

Proof state:
case preservesLimit.H.refine'_2.e_a
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
              (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom.app
        k ≫
      colimit.ι (limit (F ⋙ diagramFunctor J D X.unop)) k ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
          limit.π (colimit (Functor.flip (F ⋙ diagramFunctor J D X.unop))) k✝ ≫
            (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k✝).hom =
    (diagramNatTrans J (limit.π F k✝) X.unop).app k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k

Next tactic:
rw [ι_colimitLimitIso_limit_π_assoc]
instance preservesLimitsOfShape_plusFunctor
    (K : Type max v u) [SmallCategory K] [FinCategory K] [HasLimitsOfShape K D]
    [PreservesLimitsOfShape K (forget D)] [ReflectsLimitsOfShape K (forget D)] :
    PreservesLimitsOfShape K (J.plusFunctor D) := by
  constructor; intro F; apply preservesLimitOfEvaluation; intro X
  apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
  refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
  · intro S k
    apply liftToPlusObjLimitObj_fac
  · intro S m hm
    dsimp [liftToPlusObjLimitObj]
    simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
    refine' limit.hom_ext (fun k => _)
    simp only [limit.lift_π, Category.assoc, ← hm]
    congr 1
    refine' colimit.hom_ext (fun k => _)
    dsimp [plusMap, plusObj]
    erw [colimit.ι_map, colimit.ι_desc_assoc, limit.lift_π]
    conv_lhs => dsimp
    simp only [Category.assoc]
    rw [ι_colimitLimitIso_limit_π_assoc]
    

Proof state:
case preservesLimit.H.refine'_2.e_a
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁹ : Category.{max v u, w} D
inst✝⁸ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
K : Type (max v u)
inst✝⁴ : SmallCategory K
inst✝³ : FinCategory K
inst✝² : HasLimitsOfShape K D
inst✝¹ : PreservesLimitsOfShape K (forget D)
inst✝ : ReflectsLimitsOfShape K (forget D)
F : K ⥤ Cᵒᵖ ⥤ D
X : Cᵒᵖ
S : Cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
m : S.pt ⟶ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).pt
hm : ∀ (j : K), m ≫ ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π.app j = S.π.app j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
              (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom.app
        k ≫
      (limit.π (F ⋙ diagramFunctor J D X.unop) k✝).app k ≫
        (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k).app k✝ ≫
          (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k✝).hom =
    (diagramNatTrans J (limit.π F k✝) X.unop).app k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k

Next tactic:
simp only [NatIso.ofComponents_inv_app, colimitObjIsoColimitCompEvaluation_ι_app_hom,
      Iso.symm_inv]