l3lab/ntp-mathlib huggingface dataset:
/-- An auxiliary definition to be used in the proof that `J.plusFunctor D` commutes
with finite limits. -/
def liftToPlusObjLimitObj {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) :
    S.pt ⟶ (J.plusObj (limit F)).obj (op X) :=
  let e := colimitLimitIso (F ⋙ J.diagramFunctor D X)
  let t : J.diagram (limit F) X ≅ limit (F ⋙ J.diagramFunctor D X) :=
    (isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
      (limit.isLimit _)
  let p : (J.plusObj (limit F)).obj (op X) ≅ colimit (limit (F ⋙ J.diagramFunctor D X)) :=
    HasColimit.isoOfNatIso t
  let s :
    colimit (F ⋙ J.diagramFunctor D X).flip ≅ F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X) :=
    NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation _ k)
      (by
        intro i j f
        

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 (op X))
e : colimit (limit (F ⋙ diagramFunctor J D X)) ≅ limit (colimit (Functor.flip (F ⋙ diagramFunctor J D X))) :=
  colimitLimitIso (F ⋙ diagramFunctor J D X)
t : diagram J (limit F) X ≅ limit (F ⋙ diagramFunctor J D X) :=
  IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
    (limit.isLimit (F ⋙ diagramFunctor J D X))
p : (plusObj J (limit F)).obj (op X) ≅ colimit (limit (F ⋙ diagramFunctor J D X)) := HasColimit.isoOfNatIso t
i j : K
f : i ⟶ j
⊢ (colimit (Functor.flip (F ⋙ diagramFunctor J D X))).map f ≫
      ((fun k => colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k) j).hom =
    ((fun k => colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k) i).hom ≫
      (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)).map f

Next tactic:
rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
/-- An auxiliary definition to be used in the proof that `J.plusFunctor D` commutes
with finite limits. -/
def liftToPlusObjLimitObj {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) :
    S.pt ⟶ (J.plusObj (limit F)).obj (op X) :=
  let e := colimitLimitIso (F ⋙ J.diagramFunctor D X)
  let t : J.diagram (limit F) X ≅ limit (F ⋙ J.diagramFunctor D X) :=
    (isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
      (limit.isLimit _)
  let p : (J.plusObj (limit F)).obj (op X) ≅ colimit (limit (F ⋙ J.diagramFunctor D X)) :=
    HasColimit.isoOfNatIso t
  let s :
    colimit (F ⋙ J.diagramFunctor D X).flip ≅ F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X) :=
    NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation _ k)
      (by
        intro i j f
        rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
        

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 (op X))
e : colimit (limit (F ⋙ diagramFunctor J D X)) ≅ limit (colimit (Functor.flip (F ⋙ diagramFunctor J D X))) :=
  colimitLimitIso (F ⋙ diagramFunctor J D X)
t : diagram J (limit F) X ≅ limit (F ⋙ diagramFunctor J D X) :=
  IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
    (limit.isLimit (F ⋙ diagramFunctor J D X))
p : (plusObj J (limit F)).obj (op X) ≅ colimit (limit (F ⋙ diagramFunctor J D X)) := HasColimit.isoOfNatIso t
i j : K
f : i ⟶ j
⊢ ((fun k => colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k) i).inv ≫
      (colimit (Functor.flip (F ⋙ diagramFunctor J D X))).map f =
    (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)).map f ≫
      ((fun k => colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k) j).inv

Next tactic:
refine' colimit.hom_ext (fun w => _)
/-- An auxiliary definition to be used in the proof that `J.plusFunctor D` commutes
with finite limits. -/
def liftToPlusObjLimitObj {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) :
    S.pt ⟶ (J.plusObj (limit F)).obj (op X) :=
  let e := colimitLimitIso (F ⋙ J.diagramFunctor D X)
  let t : J.diagram (limit F) X ≅ limit (F ⋙ J.diagramFunctor D X) :=
    (isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
      (limit.isLimit _)
  let p : (J.plusObj (limit F)).obj (op X) ≅ colimit (limit (F ⋙ J.diagramFunctor D X)) :=
    HasColimit.isoOfNatIso t
  let s :
    colimit (F ⋙ J.diagramFunctor D X).flip ≅ F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X) :=
    NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation _ k)
      (by
        intro i j f
        rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
        refine' colimit.hom_ext (fun w => _)
        

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 (op X))
e : colimit (limit (F ⋙ diagramFunctor J D X)) ≅ limit (colimit (Functor.flip (F ⋙ diagramFunctor J D X))) :=
  colimitLimitIso (F ⋙ diagramFunctor J D X)
t : diagram J (limit F) X ≅ limit (F ⋙ diagramFunctor J D X) :=
  IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
    (limit.isLimit (F ⋙ diagramFunctor J D X))
p : (plusObj J (limit F)).obj (op X) ≅ colimit (limit (F ⋙ diagramFunctor J D X)) := HasColimit.isoOfNatIso t
i j : K
f : i ⟶ j
w : (Cover J (op X).unop)ᵒᵖ
⊢ colimit.ι (diagram J (F.obj i) (op X).unop) w ≫
      ((fun k => colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k) i).inv ≫
        (colimit (Functor.flip (F ⋙ diagramFunctor J D X))).map f =
    colimit.ι (diagram J (F.obj i) (op X).unop) w ≫
      (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)).map f ≫
        ((fun k => colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k) j).inv

Next tactic:
dsimp [plusMap]
/-- An auxiliary definition to be used in the proof that `J.plusFunctor D` commutes
with finite limits. -/
def liftToPlusObjLimitObj {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) :
    S.pt ⟶ (J.plusObj (limit F)).obj (op X) :=
  let e := colimitLimitIso (F ⋙ J.diagramFunctor D X)
  let t : J.diagram (limit F) X ≅ limit (F ⋙ J.diagramFunctor D X) :=
    (isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
      (limit.isLimit _)
  let p : (J.plusObj (limit F)).obj (op X) ≅ colimit (limit (F ⋙ J.diagramFunctor D X)) :=
    HasColimit.isoOfNatIso t
  let s :
    colimit (F ⋙ J.diagramFunctor D X).flip ≅ F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X) :=
    NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation _ k)
      (by
        intro i j f
        rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
        refine' colimit.hom_ext (fun w => _)
        dsimp [plusMap]
        

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 (op X))
e : colimit (limit (F ⋙ diagramFunctor J D X)) ≅ limit (colimit (Functor.flip (F ⋙ diagramFunctor J D X))) :=
  colimitLimitIso (F ⋙ diagramFunctor J D X)
t : diagram J (limit F) X ≅ limit (F ⋙ diagramFunctor J D X) :=
  IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
    (limit.isLimit (F ⋙ diagramFunctor J D X))
p : (plusObj J (limit F)).obj (op X) ≅ colimit (limit (F ⋙ diagramFunctor J D X)) := HasColimit.isoOfNatIso t
i j : K
f : i ⟶ j
w : (Cover J (op X).unop)ᵒᵖ
⊢ colimit.ι (diagram J (F.obj i) X) w ≫
      (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) i).inv ≫
        (colimit (Functor.flip (F ⋙ diagramFunctor J D X))).map f =
    colimit.ι (diagram J (F.obj i) X) w ≫
      colimMap (diagramNatTrans J (F.map f) X) ≫
        (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) j).inv

Next tactic:
erw [colimit.ι_map_assoc,
          colimitObjIsoColimitCompEvaluation_ι_inv (F ⋙ J.diagramFunctor D X).flip w j,
          colimitObjIsoColimitCompEvaluation_ι_inv_assoc (F ⋙ J.diagramFunctor D X).flip w i]
/-- An auxiliary definition to be used in the proof that `J.plusFunctor D` commutes
with finite limits. -/
def liftToPlusObjLimitObj {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) :
    S.pt ⟶ (J.plusObj (limit F)).obj (op X) :=
  let e := colimitLimitIso (F ⋙ J.diagramFunctor D X)
  let t : J.diagram (limit F) X ≅ limit (F ⋙ J.diagramFunctor D X) :=
    (isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
      (limit.isLimit _)
  let p : (J.plusObj (limit F)).obj (op X) ≅ colimit (limit (F ⋙ J.diagramFunctor D X)) :=
    HasColimit.isoOfNatIso t
  let s :
    colimit (F ⋙ J.diagramFunctor D X).flip ≅ F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X) :=
    NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation _ k)
      (by
        intro i j f
        rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
        refine' colimit.hom_ext (fun w => _)
        dsimp [plusMap]
        erw [colimit.ι_map_assoc,
          colimitObjIsoColimitCompEvaluation_ι_inv (F ⋙ J.diagramFunctor D X).flip w j,
          colimitObjIsoColimitCompEvaluation_ι_inv_assoc (F ⋙ J.diagramFunctor D X).flip w i]
        

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 (op X))
e : colimit (limit (F ⋙ diagramFunctor J D X)) ≅ limit (colimit (Functor.flip (F ⋙ diagramFunctor J D X))) :=
  colimitLimitIso (F ⋙ diagramFunctor J D X)
t : diagram J (limit F) X ≅ limit (F ⋙ diagramFunctor J D X) :=
  IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
    (limit.isLimit (F ⋙ diagramFunctor J D X))
p : (plusObj J (limit F)).obj (op X) ≅ colimit (limit (F ⋙ diagramFunctor J D X)) := HasColimit.isoOfNatIso t
i j : K
f : i ⟶ j
w : (Cover J (op X).unop)ᵒᵖ
⊢ (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) w).app i ≫
      (colimit (Functor.flip (F ⋙ diagramFunctor J D X))).map f =
    (diagramNatTrans J (F.map f) X).app w ≫ (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) w).app j

Next tactic:
rw [← (colimit.ι (F ⋙ J.diagramFunctor D X).flip w).naturality]
/-- An auxiliary definition to be used in the proof that `J.plusFunctor D` commutes
with finite limits. -/
def liftToPlusObjLimitObj {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) :
    S.pt ⟶ (J.plusObj (limit F)).obj (op X) :=
  let e := colimitLimitIso (F ⋙ J.diagramFunctor D X)
  let t : J.diagram (limit F) X ≅ limit (F ⋙ J.diagramFunctor D X) :=
    (isLimitOfPreserves (J.diagramFunctor D X) (limit.isLimit F)).conePointUniqueUpToIso
      (limit.isLimit _)
  let p : (J.plusObj (limit F)).obj (op X) ≅ colimit (limit (F ⋙ J.diagramFunctor D X)) :=
    HasColimit.isoOfNatIso t
  let s :
    colimit (F ⋙ J.diagramFunctor D X).flip ≅ F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X) :=
    NatIso.ofComponents (fun k => colimitObjIsoColimitCompEvaluation _ k)
      (by
        intro i j f
        rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
        refine' colimit.hom_ext (fun w => _)
        dsimp [plusMap]
        erw [colimit.ι_map_assoc,
          colimitObjIsoColimitCompEvaluation_ι_inv (F ⋙ J.diagramFunctor D X).flip w j,
          colimitObjIsoColimitCompEvaluation_ι_inv_assoc (F ⋙ J.diagramFunctor D X).flip w i]
        rw [← (colimit.ι (F ⋙ J.diagramFunctor D X).flip w).naturality]
        

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 (op X))
e : colimit (limit (F ⋙ diagramFunctor J D X)) ≅ limit (colimit (Functor.flip (F ⋙ diagramFunctor J D X))) :=
  colimitLimitIso (F ⋙ diagramFunctor J D X)
t : diagram J (limit F) X ≅ limit (F ⋙ diagramFunctor J D X) :=
  IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
    (limit.isLimit (F ⋙ diagramFunctor J D X))
p : (plusObj J (limit F)).obj (op X) ≅ colimit (limit (F ⋙ diagramFunctor J D X)) := HasColimit.isoOfNatIso t
i j : K
f : i ⟶ j
w : (Cover J (op X).unop)ᵒᵖ
⊢ ((Functor.flip (F ⋙ diagramFunctor J D X)).obj w).map f ≫
      (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) w).app j =
    (diagramNatTrans J (F.map f) X).app w ≫ (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) w).app j

Next tactic:
rfl
theorem liftToPlusObjLimitObj_fac {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) (k) :
    liftToPlusObjLimitObj.{w, v, u} F X S ≫ (J.plusMap (limit.π F k)).app (op X) = S.π.app k := by
  

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 (op X))
k : K
⊢ liftToPlusObjLimitObj F X S ≫ (plusMap J (limit.π F k)).app (op X) = S.π.app k

Next tactic:
dsimp only [liftToPlusObjLimitObj]
theorem liftToPlusObjLimitObj_fac {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) (k) :
    liftToPlusObjLimitObj.{w, v, u} F X S ≫ (J.plusMap (limit.π F k)).app (op X) = S.π.app k := by
  dsimp only [liftToPlusObjLimitObj]
  

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 (op X))
k : K
⊢ (limit.lift (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) S ≫
        (HasLimit.isoOfNatIso
              (NatIso.ofComponents fun k =>
                  colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).symm).hom ≫
          (colimitLimitIso (F ⋙ diagramFunctor J D X)).inv ≫
            (HasColimit.isoOfNatIso
                (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
                  (limit.isLimit (F ⋙ diagramFunctor J D X)))).inv) ≫
      (plusMap J (limit.π F k)).app (op X) =
    S.π.app k

Next tactic:
rw [← (limit.isLimit (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))).fac S k,
    Category.assoc]
theorem liftToPlusObjLimitObj_fac {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) (k) :
    liftToPlusObjLimitObj.{w, v, u} F X S ≫ (J.plusMap (limit.π F k)).app (op X) = S.π.app k := by
  dsimp only [liftToPlusObjLimitObj]
  rw [← (limit.isLimit (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))).fac S k,
    Category.assoc]
  

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 (op X))
k : K
⊢ limit.lift (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) S ≫
      ((HasLimit.isoOfNatIso
              (NatIso.ofComponents fun k =>
                  colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).symm).hom ≫
          (colimitLimitIso (F ⋙ diagramFunctor J D X)).inv ≫
            (HasColimit.isoOfNatIso
                (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
                  (limit.isLimit (F ⋙ diagramFunctor J D X)))).inv) ≫
        (plusMap J (limit.π F k)).app (op X) =
    IsLimit.lift (limit.isLimit (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X))) S ≫
      (limit.cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X))).π.app k

Next tactic:
congr 1
theorem liftToPlusObjLimitObj_fac {K : Type max v u} [SmallCategory K] [FinCategory K]
    [HasLimitsOfShape K D] [PreservesLimitsOfShape K (forget D)]
    [ReflectsLimitsOfShape K (forget D)] (F : K ⥤ Cᵒᵖ ⥤ D) (X : C)
    (S : Cone (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))) (k) :
    liftToPlusObjLimitObj.{w, v, u} F X S ≫ (J.plusMap (limit.π F k)).app (op X) = S.π.app k := by
  dsimp only [liftToPlusObjLimitObj]
  rw [← (limit.isLimit (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))).fac S k,
    Category.assoc]
  congr 1
  

Proof state:
case 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 (op X))
k : K
⊢ ((HasLimit.isoOfNatIso
            (NatIso.ofComponents fun k =>
                colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).symm).hom ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X)).inv ≫
          (HasColimit.isoOfNatIso
              (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
                (limit.isLimit (F ⋙ diagramFunctor J D X)))).inv) ≫
      (plusMap J (limit.π F k)).app (op X) =
    (limit.cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X))).π.app k

Next tactic:
dsimp