[GOAL]
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)
X : C
K : Type (max v u)
inst✝ : SmallCategory K
F : K ⥤ Cᵒᵖ ⥤ D
W : Cover J X
i : Cover.Arrow W
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj (op W))
⊢ ∀ ⦃X_1 Y : K⦄ (f : X_1 ⟶ Y),
    ((Functor.const K).obj E.pt).map f ≫
        (fun k => NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W (F.obj k)) i) Y =
      (fun k => NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W (F.obj k)) i) X_1 ≫
        (F ⋙ (evaluation Cᵒᵖ D).obj (op i.Y)).map f
[PROOFSTEP]
intro a b f
[GOAL]
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)
X : C
K : Type (max v u)
inst✝ : SmallCategory K
F : K ⥤ Cᵒᵖ ⥤ D
W : Cover J X
i : Cover.Arrow W
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj (op W))
a b : K
f : a ⟶ b
⊢ ((Functor.const K).obj E.pt).map f ≫ (fun k => NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W (F.obj k)) i) b =
    (fun k => NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W (F.obj k)) i) a ≫
      (F ⋙ (evaluation Cᵒᵖ D).obj (op i.Y)).map f
[PROOFSTEP]
dsimp
[GOAL]
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)
X : C
K : Type (max v u)
inst✝ : SmallCategory K
F : K ⥤ Cᵒᵖ ⥤ D
W : Cover J X
i : Cover.Arrow W
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj (op W))
a b : K
f : a ⟶ b
⊢ 𝟙 E.pt ≫ NatTrans.app E.π b ≫ Multiequalizer.ι (Cover.index W (F.obj b)) i =
    (NatTrans.app E.π a ≫ Multiequalizer.ι (Cover.index W (F.obj a)) i) ≫ NatTrans.app (F.map f) (op i.Y)
[PROOFSTEP]
rw [Category.id_comp, Category.assoc, ← E.w f]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝ : SmallCategory K
F : K ⥤ Cᵒᵖ ⥤ D
W : Cover J X
i : Cover.Arrow W
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj (op W))
a b : K
f : a ⟶ b
⊢ (NatTrans.app E.π a ≫ (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj (op W)).map f) ≫
      Multiequalizer.ι (Cover.index W (F.obj b)) i =
    NatTrans.app E.π a ≫ Multiequalizer.ι (Cover.index W (F.obj a)) i ≫ NatTrans.app (F.map f) (op i.Y)
[PROOFSTEP]
dsimp [diagramNatTrans]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝ : SmallCategory K
F : K ⥤ Cᵒᵖ ⥤ D
W : Cover J X
i : Cover.Arrow W
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj (op W))
a b : K
f : a ⟶ b
⊢ (NatTrans.app E.π a ≫
        Multiequalizer.lift (Cover.index W (F.obj b)) (multiequalizer (Cover.index W (F.obj a)))
          (fun i => Multiequalizer.ι (Cover.index W (F.obj a)) i ≫ NatTrans.app (F.map f) (op i.Y))
          (_ :
            ∀ (i : (Cover.index (op W).unop (F.obj b)).R),
              (fun i => Multiequalizer.ι (Cover.index (op W).unop (F.obj a)) i ≫ NatTrans.app (F.map f) (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index (op W).unop (F.obj b)) i) ≫
                  MulticospanIndex.fst (Cover.index (op W).unop (F.obj b)) i =
                (fun i => Multiequalizer.ι (Cover.index (op W).unop (F.obj a)) i ≫ NatTrans.app (F.map f) (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index (op W).unop (F.obj b)) i) ≫
                  MulticospanIndex.snd (Cover.index (op W).unop (F.obj b)) i)) ≫
      Multiequalizer.ι (Cover.index W (F.obj b)) i =
    NatTrans.app E.π a ≫ Multiequalizer.ι (Cover.index W (F.obj a)) i ≫ NatTrans.app (F.map f) (op i.Y)
[PROOFSTEP]
simp only [Multiequalizer.lift_ι, Category.assoc]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
W : (Cover J X)ᵒᵖ
F : K ⥤ Cᵒᵖ ⥤ D
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
⊢ ∀ (b : (Cover.index W.unop (limit F)).R),
    (fun i =>
            IsLimit.lift (isLimitOfPreserves ((evaluation Cᵒᵖ D).obj (op i.Y)) (limit.isLimit F))
              (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation i E))
          (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) b) ≫
        MulticospanIndex.fst (Cover.index W.unop (limit F)) b =
      (fun i =>
            IsLimit.lift (isLimitOfPreserves ((evaluation Cᵒᵖ D).obj (op i.Y)) (limit.isLimit F))
              (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation i E))
          (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) b) ≫
        MulticospanIndex.snd (Cover.index W.unop (limit F)) b
[PROOFSTEP]
intro i
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
W : (Cover J X)ᵒᵖ
F : K ⥤ Cᵒᵖ ⥤ D
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
i : (Cover.index W.unop (limit F)).R
⊢ (fun i =>
          IsLimit.lift (isLimitOfPreserves ((evaluation Cᵒᵖ D).obj (op i.Y)) (limit.isLimit F))
            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation i E))
        (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i) ≫
      MulticospanIndex.fst (Cover.index W.unop (limit F)) i =
    (fun i =>
          IsLimit.lift (isLimitOfPreserves ((evaluation Cᵒᵖ D).obj (op i.Y)) (limit.isLimit F))
            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation i E))
        (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i) ≫
      MulticospanIndex.snd (Cover.index W.unop (limit F)) i
[PROOFSTEP]
change (_ ≫ _) ≫ _ = (_ ≫ _) ≫ _
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
W : (Cover J X)ᵒᵖ
F : K ⥤ Cᵒᵖ ⥤ D
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
i : (Cover.index W.unop (limit F)).R
⊢ ((IsLimit.liftConeMorphism
            (IsLimit.ofIsoLimit
              (limit.isLimit
                (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y)))
              (evaluateCombinedCones F (fun k => getLimitCone ((Functor.flip F).obj k))
                  (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y)).symm)
            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
              (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i) E)).Hom ≫
        ((Cones.functoriality F
                  ((evaluation Cᵒᵖ D).obj (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y))).mapIso
              (IsLimit.uniqueUpToIso (combinedIsLimit F fun k => getLimitCone ((Functor.flip F).obj k))
                (limit.isLimit F))).hom.Hom) ≫
      MulticospanIndex.fst (Cover.index W.unop (limit F)) i =
    ((IsLimit.liftConeMorphism
            (IsLimit.ofIsoLimit
              (limit.isLimit
                (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y)))
              (evaluateCombinedCones F (fun k => getLimitCone ((Functor.flip F).obj k))
                  (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y)).symm)
            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
              (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i) E)).Hom ≫
        ((Cones.functoriality F
                  ((evaluation Cᵒᵖ D).obj (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y))).mapIso
              (IsLimit.uniqueUpToIso (combinedIsLimit F fun k => getLimitCone ((Functor.flip F).obj k))
                (limit.isLimit F))).hom.Hom) ≫
      MulticospanIndex.snd (Cover.index W.unop (limit F)) i
[PROOFSTEP]
dsimp [evaluateCombinedCones]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
W : (Cover J X)ᵒᵖ
F : K ⥤ Cᵒᵖ ⥤ D
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
i : (Cover.index W.unop (limit F)).R
⊢ ((limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y))
            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
              (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i) E) ≫
          𝟙
            (getLimitCone
                  ((Functor.flip F).obj (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y))).cone.pt) ≫
        NatTrans.app (limit.lift F (combineCones F fun k => getLimitCone ((Functor.flip F).obj k)))
          (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y)) ≫
      MulticospanIndex.fst (Cover.index W.unop (limit F)) i =
    ((limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y))
            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
              (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i) E) ≫
          𝟙
            (getLimitCone
                  ((Functor.flip F).obj (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y))).cone.pt) ≫
        NatTrans.app (limit.lift F (combineCones F fun k => getLimitCone ((Functor.flip F).obj k)))
          (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y)) ≫
      MulticospanIndex.snd (Cover.index W.unop (limit F)) i
[PROOFSTEP]
erw [Category.comp_id, Category.comp_id, Category.assoc, Category.assoc, ← (limit.lift F _).naturality, ←
  (limit.lift F _).naturality, ← Category.assoc, ← Category.assoc]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
W : (Cover J X)ᵒᵖ
F : K ⥤ Cᵒᵖ ⥤ D
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
i : (Cover.index W.unop (limit F)).R
⊢ (limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y))
          (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
            (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i) E) ≫
        (combineCones F fun k => getLimitCone ((Functor.flip F).obj k)).pt.map i.g₁.op) ≫
      NatTrans.app (limit.lift F (combineCones F fun k => getLimitCone ((Functor.flip F).obj k))) (op i.Z) =
    (limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y))
          (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
            (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i) E) ≫
        (combineCones F fun k => getLimitCone ((Functor.flip F).obj k)).pt.map i.g₂.op) ≫
      NatTrans.app (limit.lift F (combineCones F fun k => getLimitCone ((Functor.flip F).obj k))) (op i.Z)
[PROOFSTEP]
congr 1
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
W : (Cover J X)ᵒᵖ
F : K ⥤ Cᵒᵖ ⥤ D
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
i : (Cover.index W.unop (limit F)).R
⊢ limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y))
        (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
          (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i) E) ≫
      (combineCones F fun k => getLimitCone ((Functor.flip F).obj k)).pt.map i.g₁.op =
    limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y))
        (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
          (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i) E) ≫
      (combineCones F fun k => getLimitCone ((Functor.flip F).obj k)).pt.map i.g₂.op
[PROOFSTEP]
refine' limit.hom_ext (fun j => _)
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
W : (Cover J X)ᵒᵖ
F : K ⥤ Cᵒᵖ ⥤ D
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
i : (Cover.index W.unop (limit F)).R
j : K
⊢ (limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y))
          (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
            (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i) E) ≫
        (combineCones F fun k => getLimitCone ((Functor.flip F).obj k)).pt.map i.g₁.op) ≫
      limit.π ((Functor.flip F).obj (op i.Z)) j =
    (limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y))
          (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
            (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i) E) ≫
        (combineCones F fun k => getLimitCone ((Functor.flip F).obj k)).pt.map i.g₂.op) ≫
      limit.π ((Functor.flip F).obj (op i.Z)) j
[PROOFSTEP]
erw [Category.assoc, Category.assoc, limit.lift_π, limit.lift_π, limit.lift_π_assoc, limit.lift_π_assoc, Category.assoc,
  Category.assoc, Multiequalizer.condition]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
W : (Cover J X)ᵒᵖ
F : K ⥤ Cᵒᵖ ⥤ D
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
i : (Cover.index W.unop (limit F)).R
j : K
⊢ NatTrans.app E.π j ≫
      Multiequalizer.ι (Cover.index W.unop (F.obj j)) (MulticospanIndex.sndTo (Cover.index W.unop (F.obj j)) i) ≫
        MulticospanIndex.snd (Cover.index W.unop (F.obj j)) i =
    NatTrans.app E.π j ≫
      Multiequalizer.ι (Cover.index W.unop (F.obj j)) (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i) ≫
        NatTrans.app ((Functor.flip F).map i.g₂.op) j
[PROOFSTEP]
rfl
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
⊢ ∀ (s : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)) (j : K),
    (fun E => liftToDiagramLimitObj F E) s ≫
        NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app s.π j
[PROOFSTEP]
intro E k
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
k : K
⊢ (fun E => liftToDiagramLimitObj F E) E ≫
      NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π k =
    NatTrans.app E.π k
[PROOFSTEP]
dsimp [diagramNatTrans]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
k : K
⊢ liftToDiagramLimitObj F E ≫
      Multiequalizer.lift (Cover.index W.unop (F.obj k)) (multiequalizer (Cover.index W.unop (limit F)))
        (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
        (_ :
          ∀ (i : (Cover.index W.unop (F.obj k)).R),
            (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.fstTo (Cover.index W.unop (F.obj k)) i) ≫
                MulticospanIndex.fst (Cover.index W.unop (F.obj k)) i =
              (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.sndTo (Cover.index W.unop (F.obj k)) i) ≫
                MulticospanIndex.snd (Cover.index W.unop (F.obj k)) i) =
    NatTrans.app E.π k
[PROOFSTEP]
refine' Multiequalizer.hom_ext _ _ _ (fun a => _)
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
k : K
a : (Cover.index W.unop (F.obj k)).L
⊢ (liftToDiagramLimitObj F E ≫
        Multiequalizer.lift (Cover.index W.unop (F.obj k)) (multiequalizer (Cover.index W.unop (limit F)))
          (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
          (_ :
            ∀ (i : (Cover.index W.unop (F.obj k)).R),
              (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index W.unop (F.obj k)) i) ≫
                  MulticospanIndex.fst (Cover.index W.unop (F.obj k)) i =
                (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index W.unop (F.obj k)) i) ≫
                  MulticospanIndex.snd (Cover.index W.unop (F.obj k)) i)) ≫
      Multiequalizer.ι (Cover.index W.unop (F.obj k)) a =
    NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W.unop (F.obj k)) a
[PROOFSTEP]
simp only [Multiequalizer.lift_ι, Multiequalizer.lift_ι_assoc, Category.assoc]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
k : K
a : (Cover.index W.unop (F.obj k)).L
⊢ IsLimit.lift (isLimitOfPreserves ((evaluation Cᵒᵖ D).obj (op a.Y)) (limit.isLimit F))
        (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation a E) ≫
      NatTrans.app (limit.π F k) (op a.Y) =
    NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W.unop (F.obj k)) a
[PROOFSTEP]
change (_ ≫ _) ≫ _ = _
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
k : K
a : (Cover.index W.unop (F.obj k)).L
⊢ ((IsLimit.liftConeMorphism
            (IsLimit.ofIsoLimit (limit.isLimit (F ⋙ (evaluation Cᵒᵖ D).obj (op a.Y)))
              (evaluateCombinedCones F (fun k => getLimitCone ((Functor.flip F).obj k)) (op a.Y)).symm)
            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation a E)).Hom ≫
        ((Cones.functoriality F ((evaluation Cᵒᵖ D).obj (op a.Y))).mapIso
              (IsLimit.uniqueUpToIso (combinedIsLimit F fun k => getLimitCone ((Functor.flip F).obj k))
                (limit.isLimit F))).hom.Hom) ≫
      NatTrans.app (limit.π F k) (op a.Y) =
    NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W.unop (F.obj k)) a
[PROOFSTEP]
dsimp [evaluateCombinedCones]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
k : K
a : (Cover.index W.unop (F.obj k)).L
⊢ ((limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op a.Y)) (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation a E) ≫
          𝟙 (getLimitCone ((Functor.flip F).obj (op a.Y))).cone.pt) ≫
        NatTrans.app (limit.lift F (combineCones F fun k => getLimitCone ((Functor.flip F).obj k))) (op a.Y)) ≫
      NatTrans.app (limit.π F k) (op a.Y) =
    NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W.unop (F.obj k)) a
[PROOFSTEP]
erw [Category.comp_id, Category.assoc, ← NatTrans.comp_app, limit.lift_π, limit.lift_π]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
k : K
a : (Cover.index W.unop (F.obj k)).L
⊢ NatTrans.app (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation a E).π k =
    NatTrans.app E.π k ≫ Multiequalizer.ι (Cover.index W.unop (F.obj k)) a
[PROOFSTEP]
rfl
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
⊢ ∀ (s : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W))
    (m : s.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt),
    (∀ (j : K),
        m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
          NatTrans.app s.π j) →
      m = (fun E => liftToDiagramLimitObj F E) s
[PROOFSTEP]
intro E m hm
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
⊢ m = (fun E => liftToDiagramLimitObj F E) E
[PROOFSTEP]
refine' Multiequalizer.hom_ext _ _ _ (fun a => limit_obj_ext (fun j => _))
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ (m ≫ Multiequalizer.ι (Cover.index W.unop (limit.cone F).pt) a) ≫ NatTrans.app (limit.π F j) (op a.Y) =
    ((fun E => liftToDiagramLimitObj F E) E ≫ Multiequalizer.ι (Cover.index W.unop (limit.cone F).pt) a) ≫
      NatTrans.app (limit.π F j) (op a.Y)
[PROOFSTEP]
delta liftToDiagramLimitObj
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ (m ≫ Multiequalizer.ι (Cover.index W.unop (limit.cone F).pt) a) ≫ NatTrans.app (limit.π F j) (op a.Y) =
    ((fun E =>
            Multiequalizer.lift (Cover.index W.unop (limit F)) E.pt
              (fun i =>
                IsLimit.lift (isLimitOfPreserves ((evaluation Cᵒᵖ D).obj (op i.Y)) (limit.isLimit F))
                  (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation i E))
              (_ :
                ∀ (i : (Cover.index W.unop (limit F)).R),
                  ((IsLimit.liftConeMorphism
                            (IsLimit.ofIsoLimit
                              (limit.isLimit
                                (F ⋙
                                  (evaluation Cᵒᵖ D).obj
                                    (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y)))
                              (evaluateCombinedCones F (fun k => getLimitCone ((Functor.flip F).obj k))
                                  (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y)).symm)
                            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
                              (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i) E)).Hom ≫
                        ((Cones.functoriality F
                                  ((evaluation Cᵒᵖ D).obj
                                    (op (MulticospanIndex.fstTo (Cover.index W.unop (limit F)) i).Y))).mapIso
                              (IsLimit.uniqueUpToIso (combinedIsLimit F fun k => getLimitCone ((Functor.flip F).obj k))
                                (limit.isLimit F))).hom.Hom) ≫
                      MulticospanIndex.fst (Cover.index W.unop (limit F)) i =
                    ((IsLimit.liftConeMorphism
                            (IsLimit.ofIsoLimit
                              (limit.isLimit
                                (F ⋙
                                  (evaluation Cᵒᵖ D).obj
                                    (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y)))
                              (evaluateCombinedCones F (fun k => getLimitCone ((Functor.flip F).obj k))
                                  (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y)).symm)
                            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation
                              (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i) E)).Hom ≫
                        ((Cones.functoriality F
                                  ((evaluation Cᵒᵖ D).obj
                                    (op (MulticospanIndex.sndTo (Cover.index W.unop (limit F)) i).Y))).mapIso
                              (IsLimit.uniqueUpToIso (combinedIsLimit F fun k => getLimitCone ((Functor.flip F).obj k))
                                (limit.isLimit F))).hom.Hom) ≫
                      MulticospanIndex.snd (Cover.index W.unop (limit F)) i))
          E ≫
        Multiequalizer.ι (Cover.index W.unop (limit.cone F).pt) a) ≫
      NatTrans.app (limit.π F j) (op a.Y)
[PROOFSTEP]
erw [Multiequalizer.lift_ι, Category.assoc]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ m ≫ Multiequalizer.ι (Cover.index W.unop (limit.cone F).pt) a ≫ NatTrans.app (limit.π F j) (op a.Y) =
    IsLimit.lift (isLimitOfPreserves ((evaluation Cᵒᵖ D).obj (op a.Y)) (limit.isLimit F))
        (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation a E) ≫
      NatTrans.app (limit.π F j) (op a.Y)
[PROOFSTEP]
change _ = (_ ≫ _) ≫ _
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ m ≫ Multiequalizer.ι (Cover.index W.unop (limit.cone F).pt) a ≫ NatTrans.app (limit.π F j) (op a.Y) =
    ((IsLimit.liftConeMorphism
            (IsLimit.ofIsoLimit (limit.isLimit (F ⋙ (evaluation Cᵒᵖ D).obj (op a.Y)))
              (evaluateCombinedCones F (fun k => getLimitCone ((Functor.flip F).obj k)) (op a.Y)).symm)
            (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation a E)).Hom ≫
        ((Cones.functoriality F ((evaluation Cᵒᵖ D).obj (op a.Y))).mapIso
              (IsLimit.uniqueUpToIso (combinedIsLimit F fun k => getLimitCone ((Functor.flip F).obj k))
                (limit.isLimit F))).hom.Hom) ≫
      NatTrans.app (limit.π F j) (op a.Y)
[PROOFSTEP]
dsimp [evaluateCombinedCones]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ m ≫ Multiequalizer.ι (Cover.index W.unop (limit F)) a ≫ NatTrans.app (limit.π F j) (op a.Y) =
    ((limit.lift (F ⋙ (evaluation Cᵒᵖ D).obj (op a.Y)) (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation a E) ≫
          𝟙 (getLimitCone ((Functor.flip F).obj (op a.Y))).cone.pt) ≫
        NatTrans.app (limit.lift F (combineCones F fun k => getLimitCone ((Functor.flip F).obj k))) (op a.Y)) ≫
      NatTrans.app (limit.π F j) (op a.Y)
[PROOFSTEP]
erw [Category.comp_id, Category.assoc, ← NatTrans.comp_app, limit.lift_π, limit.lift_π]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ m ≫ Multiequalizer.ι (Cover.index W.unop (limit F)) a ≫ NatTrans.app (limit.π F j) (op a.Y) =
    NatTrans.app (coneCompEvaluationOfConeCompDiagramFunctorCompEvaluation a E).π j
[PROOFSTEP]
dsimp
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ m ≫ Multiequalizer.ι (Cover.index W.unop (limit F)) a ≫ NatTrans.app (limit.π F j) (op a.Y) =
    NatTrans.app E.π j ≫ Multiequalizer.ι (Cover.index W.unop (F.obj j)) a
[PROOFSTEP]
rw [← hm]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ m ≫ Multiequalizer.ι (Cover.index W.unop (limit F)) a ≫ NatTrans.app (limit.π F j) (op a.Y) =
    (m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j) ≫
      Multiequalizer.ι (Cover.index W.unop (F.obj j)) a
[PROOFSTEP]
dsimp [diagramNatTrans]
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
W : (Cover J X)ᵒᵖ
E : Cone (F ⋙ diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W)
m : E.pt ⟶ ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).pt
hm :
  ∀ (j : K),
    m ≫ NatTrans.app ((diagramFunctor J D X ⋙ (evaluation (Cover J X)ᵒᵖ D).obj W).mapCone (limit.cone F)).π j =
      NatTrans.app E.π j
a : (Cover.index W.unop (limit.cone F).pt).L
j : K
⊢ m ≫ Multiequalizer.ι (Cover.index W.unop (limit F)) a ≫ NatTrans.app (limit.π F j) (op a.Y) =
    (m ≫
        Multiequalizer.lift (Cover.index W.unop (F.obj j)) (multiequalizer (Cover.index W.unop (limit F)))
          (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F j) (op i.Y))
          (_ :
            ∀ (i : (Cover.index W.unop (F.obj j)).R),
              (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F j) (op i.Y))
                    (MulticospanIndex.fstTo (Cover.index W.unop (F.obj j)) i) ≫
                  MulticospanIndex.fst (Cover.index W.unop (F.obj j)) i =
                (fun i => Multiequalizer.ι (Cover.index W.unop (limit F)) i ≫ NatTrans.app (limit.π F j) (op i.Y))
                    (MulticospanIndex.sndTo (Cover.index W.unop (F.obj j)) i) ≫
                  MulticospanIndex.snd (Cover.index W.unop (F.obj j)) i)) ≫
      Multiequalizer.ι (Cover.index W.unop (F.obj j)) a
[PROOFSTEP]
simp
[GOAL]
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)
X : C
K : Type (max v u)
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
⊢ {K_1 : K ⥤ Cᵒᵖ ⥤ D} → PreservesLimit K_1 (diagramFunctor J D X)
[PROOFSTEP]
apply preservesLimit_diagramFunctor.{w, v, u}
[GOAL]
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)
X : C
inst✝ : HasLimits D
⊢ PreservesLimits (diagramFunctor J D X)
[PROOFSTEP]
constructor
[GOAL]
case preservesLimitsOfShape
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)
X : C
inst✝ : HasLimits D
⊢ autoParam
    ({J_1 : Type (max u v)} →
      [inst : Category.{max u v, max u v} J_1] → PreservesLimitsOfShape J_1 (diagramFunctor J D X))
    _auto✝
[PROOFSTEP]
intro _ _
[GOAL]
case preservesLimitsOfShape
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)
X : C
inst✝¹ : HasLimits D
J✝ : Type (max u v)
inst✝ : Category.{max u v, max u v} J✝
⊢ PreservesLimitsOfShape J✝ (diagramFunctor J D X)
[PROOFSTEP]
apply preservesLimitsOfShape_diagramFunctor.{w, v, u}
[GOAL]
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
⊢ ∀ {X_1 Y : K} (f : X_1 ⟶ Y),
    (colimit (Functor.flip (F ⋙ diagramFunctor J D X))).map f ≫
        ((fun k => colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k) Y).hom =
      ((fun k => colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k) X_1).hom ≫
        (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)).map f
[PROOFSTEP]
intro i j f
[GOAL]
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
[PROOFSTEP]
rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
[GOAL]
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
[PROOFSTEP]
refine' colimit.hom_ext (fun w => _)
[GOAL]
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
[PROOFSTEP]
dsimp [plusMap]
[GOAL]
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
[PROOFSTEP]
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]
[GOAL]
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)ᵒᵖ
⊢ NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) w) i ≫
      (colimit (Functor.flip (F ⋙ diagramFunctor J D X))).map f =
    NatTrans.app (diagramNatTrans J (F.map f) X) w ≫
      NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) w) j
[PROOFSTEP]
rw [← (colimit.ι (F ⋙ J.diagramFunctor D X).flip w).naturality]
[GOAL]
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 ≫
      NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) w) j =
    NatTrans.app (diagramNatTrans J (F.map f) X) w ≫
      NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) w) j
[PROOFSTEP]
rfl
[GOAL]
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 ≫ NatTrans.app (plusMap J (limit.π F k)) (op X) = NatTrans.app S.π k
[PROOFSTEP]
dsimp only [liftToPlusObjLimitObj]
[GOAL]
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) ≫
      NatTrans.app (plusMap J (limit.π F k)) (op X) =
    NatTrans.app S.π k
[PROOFSTEP]
rw [← (limit.isLimit (F ⋙ J.plusFunctor D ⋙ (evaluation Cᵒᵖ D).obj (op X))).fac S k, Category.assoc]
[GOAL]
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) ≫
        NatTrans.app (plusMap J (limit.π F k)) (op X) =
    IsLimit.lift (limit.isLimit (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X))) S ≫
      NatTrans.app (limit.cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X))).π k
[PROOFSTEP]
congr 1
[GOAL]
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) ≫
      NatTrans.app (plusMap J (limit.π F k)) (op X) =
    NatTrans.app (limit.cone (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X))).π k
[PROOFSTEP]
dsimp
[GOAL]
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) ≫
      NatTrans.app (plusMap J (limit.π F k)) (op X) =
    limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) k
[PROOFSTEP]
rw [Category.assoc, Category.assoc, ← Iso.eq_inv_comp, Iso.inv_comp_eq, Iso.inv_comp_eq]
[GOAL]
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
⊢ NatTrans.app (plusMap J (limit.π F k)) (op X) =
    (HasColimit.isoOfNatIso
          (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
            (limit.isLimit (F ⋙ diagramFunctor J D X)))).hom ≫
      (colimitLimitIso (F ⋙ diagramFunctor J D X)).hom ≫
        (HasLimit.isoOfNatIso
              (NatIso.ofComponents fun k =>
                  colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).symm).inv ≫
          limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) k
[PROOFSTEP]
refine' colimit.hom_ext (fun j => _)
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ colimit.ι (diagram J (limit F) (op X).unop) j ≫ NatTrans.app (plusMap J (limit.π F k)) (op X) =
    colimit.ι (diagram J (limit F) (op X).unop) j ≫
      (HasColimit.isoOfNatIso
            (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
              (limit.isLimit (F ⋙ diagramFunctor J D X)))).hom ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents fun k =>
                    colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).symm).inv ≫
            limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) k
[PROOFSTEP]
dsimp [plusMap]
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ colimit.ι (diagram J (limit F) X) j ≫ colimMap (diagramNatTrans J (limit.π F k) X) =
    colimit.ι (diagram J (limit F) X) j ≫
      (HasColimit.isoOfNatIso
            (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
              (limit.isLimit (F ⋙ diagramFunctor J D X)))).hom ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents fun k =>
                    colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).symm).inv ≫
            limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) k
[PROOFSTEP]
simp only [HasColimit.isoOfNatIso_ι_hom_assoc, ι_colimMap]
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ NatTrans.app (diagramNatTrans J (limit.π F k) X) j ≫ colimit.ι (diagram J (F.obj k) X) j =
    NatTrans.app
        (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X) (limit.isLimit F))
            (limit.isLimit (F ⋙ diagramFunctor J D X))).hom
        j ≫
      colimit.ι (limit (F ⋙ diagramFunctor J D X)) j ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X)).hom ≫
          (HasLimit.isoOfNatIso
                (NatIso.ofComponents fun k =>
                    colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).symm).inv ≫
            limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) k
[PROOFSTEP]
dsimp [IsLimit.conePointUniqueUpToIso, HasLimit.isoOfNatIso, IsLimit.map]
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ Multiequalizer.lift (Cover.index j.unop (F.obj k)) (multiequalizer (Cover.index j.unop (limit F)))
        (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
        (_ :
          ∀ (i : (Cover.index j.unop (F.obj k)).R),
            (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.fstTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.fst (Cover.index j.unop (F.obj k)) i =
              (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.sndTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.snd (Cover.index j.unop (F.obj k)) i) ≫
      colimit.ι (diagram J (F.obj k) X) j =
    NatTrans.app (limit.lift (F ⋙ diagramFunctor J D X) ((diagramFunctor J D X).mapCone (limit.cone F))) j ≫
      colimit.ι (limit (F ⋙ diagramFunctor J D X)) j ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X)).hom ≫
          limit.lift (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X))
              ((Cones.postcompose
                    (NatIso.ofComponents fun k =>
                        colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).hom).obj
                (limit.cone (colimit (Functor.flip (F ⋙ diagramFunctor J D X))))) ≫
            limit.π (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) k
[PROOFSTEP]
rw [limit.lift_π]
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ Multiequalizer.lift (Cover.index j.unop (F.obj k)) (multiequalizer (Cover.index j.unop (limit F)))
        (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
        (_ :
          ∀ (i : (Cover.index j.unop (F.obj k)).R),
            (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.fstTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.fst (Cover.index j.unop (F.obj k)) i =
              (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.sndTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.snd (Cover.index j.unop (F.obj k)) i) ≫
      colimit.ι (diagram J (F.obj k) X) j =
    NatTrans.app (limit.lift (F ⋙ diagramFunctor J D X) ((diagramFunctor J D X).mapCone (limit.cone F))) j ≫
      colimit.ι (limit (F ⋙ diagramFunctor J D X)) j ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X)).hom ≫
          NatTrans.app
            ((Cones.postcompose
                    (NatIso.ofComponents fun k =>
                        colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).hom).obj
                (limit.cone (colimit (Functor.flip (F ⋙ diagramFunctor J D X))))).π
            k
[PROOFSTEP]
dsimp
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ Multiequalizer.lift (Cover.index j.unop (F.obj k)) (multiequalizer (Cover.index j.unop (limit F)))
        (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
        (_ :
          ∀ (i : (Cover.index j.unop (F.obj k)).R),
            (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.fstTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.fst (Cover.index j.unop (F.obj k)) i =
              (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.sndTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.snd (Cover.index j.unop (F.obj k)) i) ≫
      colimit.ι (diagram J (F.obj k) X) j =
    NatTrans.app (limit.lift (F ⋙ diagramFunctor J D X) ((diagramFunctor J D X).mapCone (limit.cone F))) j ≫
      colimit.ι (limit (F ⋙ diagramFunctor J D X)) j ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X)).hom ≫
          limit.π (colimit (Functor.flip (F ⋙ diagramFunctor J D X))) k ≫
            (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).hom
[PROOFSTEP]
rw [ι_colimitLimitIso_limit_π_assoc]
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ Multiequalizer.lift (Cover.index j.unop (F.obj k)) (multiequalizer (Cover.index j.unop (limit F)))
        (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
        (_ :
          ∀ (i : (Cover.index j.unop (F.obj k)).R),
            (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.fstTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.fst (Cover.index j.unop (F.obj k)) i =
              (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.sndTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.snd (Cover.index j.unop (F.obj k)) i) ≫
      colimit.ι (diagram J (F.obj k) X) j =
    NatTrans.app (limit.lift (F ⋙ diagramFunctor J D X) ((diagramFunctor J D X).mapCone (limit.cone F))) j ≫
      NatTrans.app (limit.π (F ⋙ diagramFunctor J D X) k) j ≫
        NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) j) k ≫
          (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).hom
[PROOFSTEP]
simp_rw [← Category.assoc, ← NatTrans.comp_app]
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ Multiequalizer.lift (Cover.index j.unop (F.obj k)) (multiequalizer (Cover.index j.unop (limit F)))
        (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
        (_ :
          ∀ (i : (Cover.index j.unop (F.obj k)).R),
            (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.fstTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.fst (Cover.index j.unop (F.obj k)) i =
              (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.sndTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.snd (Cover.index j.unop (F.obj k)) i) ≫
      colimit.ι (diagram J (F.obj k) X) j =
    (NatTrans.app
          (limit.lift (F ⋙ diagramFunctor J D X) ((diagramFunctor J D X).mapCone (limit.cone F)) ≫
            limit.π (F ⋙ diagramFunctor J D X) k)
          j ≫
        NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) j) k) ≫
      (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).hom
[PROOFSTEP]
rw [limit.lift_π, Category.assoc]
[GOAL]
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
j : (Cover J (op X).unop)ᵒᵖ
⊢ Multiequalizer.lift (Cover.index j.unop (F.obj k)) (multiequalizer (Cover.index j.unop (limit F)))
        (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
        (_ :
          ∀ (i : (Cover.index j.unop (F.obj k)).R),
            (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.fstTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.fst (Cover.index j.unop (F.obj k)) i =
              (fun i => Multiequalizer.ι (Cover.index j.unop (limit F)) i ≫ NatTrans.app (limit.π F k) (op i.Y))
                  (MulticospanIndex.sndTo (Cover.index j.unop (F.obj k)) i) ≫
                MulticospanIndex.snd (Cover.index j.unop (F.obj k)) i) ≫
      colimit.ι (diagram J (F.obj k) X) j =
    NatTrans.app (NatTrans.app ((diagramFunctor J D X).mapCone (limit.cone F)).π k) j ≫
      NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) j) k ≫
        (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).hom
[PROOFSTEP]
congr 1
[GOAL]
case e_a.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
j : (Cover J (op X).unop)ᵒᵖ
⊢ colimit.ι (diagram J (F.obj k) X) j =
    NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) j) k ≫
      (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).hom
[PROOFSTEP]
rw [← Iso.comp_inv_eq]
[GOAL]
case e_a.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
j : (Cover J (op X).unop)ᵒᵖ
⊢ colimit.ι (diagram J (F.obj k) X) j ≫
      (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X)) k).inv =
    NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) j) k
[PROOFSTEP]
erw [colimit.ι_desc]
[GOAL]
case e_a.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
j : (Cover J (op X).unop)ᵒᵖ
⊢ NatTrans.app (((evaluation K D).obj k).mapCocone (colimit.cocone (Functor.flip (F ⋙ diagramFunctor J D X)))).ι j =
    NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X)) j) k
[PROOFSTEP]
rfl
[GOAL]
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)
⊢ PreservesLimitsOfShape K (plusFunctor J D)
[PROOFSTEP]
constructor
[GOAL]
case preservesLimit
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)
⊢ autoParam ({K_1 : K ⥤ Cᵒᵖ ⥤ D} → PreservesLimit K_1 (plusFunctor J D)) _auto✝
[PROOFSTEP]
intro F
[GOAL]
case preservesLimit
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
⊢ PreservesLimit F (plusFunctor J D)
[PROOFSTEP]
apply preservesLimitOfEvaluation
[GOAL]
case preservesLimit.H
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
⊢ (k : Cᵒᵖ) → PreservesLimit F (plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj k)
[PROOFSTEP]
intro X
[GOAL]
case preservesLimit.H
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ᵒᵖ
⊢ PreservesLimit F (plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X)
[PROOFSTEP]
apply preservesLimitOfPreservesLimitCone (limit.isLimit F)
[GOAL]
case preservesLimit.H
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ᵒᵖ
⊢ IsLimit ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F))
[PROOFSTEP]
refine' ⟨fun S => liftToPlusObjLimitObj.{w, v, u} F X.unop S, _, _⟩
[GOAL]
case preservesLimit.H.refine'_1
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)) (j : K),
    (fun S => liftToPlusObjLimitObj F X.unop S) s ≫
        NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j =
      NatTrans.app s.π j
[PROOFSTEP]
intro S k
[GOAL]
case preservesLimit.H.refine'_1
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)
k : K
⊢ (fun S => liftToPlusObjLimitObj F X.unop S) S ≫
      NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π k =
    NatTrans.app S.π k
[PROOFSTEP]
apply liftToPlusObjLimitObj_fac
[GOAL]
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),
    (∀ (j : K),
        m ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j =
          NatTrans.app s.π j) →
      m = (fun S => liftToPlusObjLimitObj F X.unop S) s
[PROOFSTEP]
intro S m hm
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
⊢ m = (fun S => liftToPlusObjLimitObj F X.unop S) S
[PROOFSTEP]
dsimp [liftToPlusObjLimitObj]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
⊢ m =
    limit.lift (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) S ≫
      (HasLimit.isoOfNatIso
            (NatIso.ofComponents fun k =>
                colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k).symm).hom ≫
        (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).inv ≫
          (HasColimit.isoOfNatIso
              (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
                (limit.isLimit (F ⋙ diagramFunctor J D X.unop)))).inv
[PROOFSTEP]
simp_rw [← Category.assoc, Iso.eq_comp_inv, ← Iso.comp_inv_eq]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
⊢ ((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.lift (F ⋙ plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X) S
[PROOFSTEP]
refine' limit.hom_ext (fun k => _)
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π 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
[PROOFSTEP]
simp only [limit.lift_π, Category.assoc, ← hm]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π 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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π k
[PROOFSTEP]
congr 1
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π 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 =
    NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π k
[PROOFSTEP]
refine' colimit.hom_ext (fun k => _)
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π 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 ≫
      NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π k✝
[PROOFSTEP]
dsimp [plusMap, plusObj]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π 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)
[PROOFSTEP]
erw [colimit.ι_map, colimit.ι_desc_assoc, limit.lift_π]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ NatTrans.app
        ((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)))).ι
        k ≫
      (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
        NatTrans.app
          ((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))))).π
          k✝ =
    NatTrans.app (diagramNatTrans J (limit.π F k✝) X.unop) k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k
[PROOFSTEP]
conv_lhs => dsimp
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
| NatTrans.app
      ((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)))).ι
      k ≫
    (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
      NatTrans.app
        ((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))))).π
        k✝
[PROOFSTEP]
dsimp
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
| NatTrans.app
      ((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)))).ι
      k ≫
    (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
      NatTrans.app
        ((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))))).π
        k✝
[PROOFSTEP]
dsimp
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
| NatTrans.app
      ((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)))).ι
      k ≫
    (colimitLimitIso (F ⋙ diagramFunctor J D X.unop)).hom ≫
      NatTrans.app
        ((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))))).π
        k✝
[PROOFSTEP]
dsimp
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ (NatTrans.app
          (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
              (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom
          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 =
    NatTrans.app (diagramNatTrans J (limit.π F k✝) X.unop) k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ NatTrans.app
        (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
            (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom
        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 =
    NatTrans.app (diagramNatTrans J (limit.π F k✝) X.unop) k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k
[PROOFSTEP]
rw [ι_colimitLimitIso_limit_π_assoc]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ NatTrans.app
        (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
            (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom
        k ≫
      NatTrans.app (limit.π (F ⋙ diagramFunctor J D X.unop) k✝) k ≫
        NatTrans.app (colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k) k✝ ≫
          (colimitObjIsoColimitCompEvaluation (Functor.flip (F ⋙ diagramFunctor J D X.unop)) k✝).hom =
    NatTrans.app (diagramNatTrans J (limit.π F k✝) X.unop) k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k
[PROOFSTEP]
simp only [NatIso.ofComponents_inv_app, colimitObjIsoColimitCompEvaluation_ι_app_hom, Iso.symm_inv]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ NatTrans.app
        (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
            (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom
        k ≫
      NatTrans.app (limit.π (F ⋙ diagramFunctor J D X.unop) k✝) k ≫
        colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X.unop) ⋙ (evaluation K D).obj k✝) k =
    NatTrans.app (diagramNatTrans J (limit.π F k✝) X.unop) k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k
[PROOFSTEP]
conv_lhs => dsimp [IsLimit.conePointUniqueUpToIso]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
| NatTrans.app
      (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
          (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom
      k ≫
    NatTrans.app (limit.π (F ⋙ diagramFunctor J D X.unop) k✝) k ≫
      colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X.unop) ⋙ (evaluation K D).obj k✝) k
[PROOFSTEP]
dsimp [IsLimit.conePointUniqueUpToIso]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
| NatTrans.app
      (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
          (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom
      k ≫
    NatTrans.app (limit.π (F ⋙ diagramFunctor J D X.unop) k✝) k ≫
      colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X.unop) ⋙ (evaluation K D).obj k✝) k
[PROOFSTEP]
dsimp [IsLimit.conePointUniqueUpToIso]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
| NatTrans.app
      (IsLimit.conePointUniqueUpToIso (isLimitOfPreserves (diagramFunctor J D X.unop) (limit.isLimit F))
          (limit.isLimit (F ⋙ diagramFunctor J D X.unop))).hom
      k ≫
    NatTrans.app (limit.π (F ⋙ diagramFunctor J D X.unop) k✝) k ≫
      colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X.unop) ⋙ (evaluation K D).obj k✝) k
[PROOFSTEP]
dsimp [IsLimit.conePointUniqueUpToIso]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ NatTrans.app (limit.lift (F ⋙ diagramFunctor J D X.unop) ((diagramFunctor J D X.unop).mapCone (limit.cone F))) k ≫
      NatTrans.app (limit.π (F ⋙ diagramFunctor J D X.unop) k✝) k ≫
        colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X.unop) ⋙ (evaluation K D).obj k✝) k =
    NatTrans.app (diagramNatTrans J (limit.π F k✝) X.unop) k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k
[PROOFSTEP]
rw [← Category.assoc, ← NatTrans.comp_app, limit.lift_π]
[GOAL]
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 ≫ NatTrans.app ((plusFunctor J D ⋙ (evaluation Cᵒᵖ D).obj X).mapCone (limit.cone F)).π j = NatTrans.app S.π j
k✝ : K
k : (Cover J X.unop)ᵒᵖ
⊢ NatTrans.app (NatTrans.app ((diagramFunctor J D X.unop).mapCone (limit.cone F)).π k✝) k ≫
      colimit.ι (Functor.flip (F ⋙ diagramFunctor J D X.unop) ⋙ (evaluation K D).obj k✝) k =
    NatTrans.app (diagramNatTrans J (limit.π F k✝) X.unop) k ≫ colimit.ι (diagram J (F.obj k✝) X.unop) k
[PROOFSTEP]
rfl
[GOAL]
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)
inst✝² : HasFiniteLimits D
inst✝¹ : PreservesFiniteLimits (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
⊢ PreservesFiniteLimits (plusFunctor J D)
[PROOFSTEP]
apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{max v u}
[GOAL]
case h
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)
inst✝² : HasFiniteLimits D
inst✝¹ : PreservesFiniteLimits (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
⊢ (J_1 : Type (max v u)) → {𝒥 : SmallCategory J_1} → FinCategory J_1 → PreservesLimitsOfShape J_1 (plusFunctor J D)
[PROOFSTEP]
intro K _ _
[GOAL]
case h
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)
inst✝² : HasFiniteLimits D
inst✝¹ : PreservesFiniteLimits (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
𝒥✝ : SmallCategory K
x✝ : FinCategory K
⊢ PreservesLimitsOfShape K (plusFunctor J D)
[PROOFSTEP]
have : ReflectsLimitsOfShape K (forget D) := reflectsLimitsOfShapeOfReflectsIsomorphisms
[GOAL]
case h
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)
inst✝² : HasFiniteLimits D
inst✝¹ : PreservesFiniteLimits (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
𝒥✝ : SmallCategory K
x✝ : FinCategory K
this : ReflectsLimitsOfShape K (forget D)
⊢ PreservesLimitsOfShape K (plusFunctor J D)
[PROOFSTEP]
apply preservesLimitsOfShape_plusFunctor.{w, v, u}
[GOAL]
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝² : SmallCategory K
inst✝¹ : FinCategory K
inst✝ : HasLimitsOfShape K D
⊢ PreservesLimitsOfShape K (presheafToSheaf J D)
[PROOFSTEP]
constructor
[GOAL]
case preservesLimit
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝² : SmallCategory K
inst✝¹ : FinCategory K
inst✝ : HasLimitsOfShape K D
⊢ autoParam ({K_1 : K ⥤ Cᵒᵖ ⥤ D} → PreservesLimit K_1 (presheafToSheaf J D)) _auto✝
[PROOFSTEP]
intro F
[GOAL]
case preservesLimit
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝² : SmallCategory K
inst✝¹ : FinCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
⊢ PreservesLimit F (presheafToSheaf J D)
[PROOFSTEP]
constructor
[GOAL]
case preservesLimit.preserves
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝² : SmallCategory K
inst✝¹ : FinCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
⊢ {c : Cone F} → IsLimit c → IsLimit ((presheafToSheaf J D).mapCone c)
[PROOFSTEP]
intro S hS
[GOAL]
case preservesLimit.preserves
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝² : SmallCategory K
inst✝¹ : FinCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
S : Cone F
hS : IsLimit S
⊢ IsLimit ((presheafToSheaf J D).mapCone S)
[PROOFSTEP]
apply isLimitOfReflects (sheafToPresheaf J D)
[GOAL]
case preservesLimit.preserves.t
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝² : SmallCategory K
inst✝¹ : FinCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
S : Cone F
hS : IsLimit S
⊢ IsLimit ((sheafToPresheaf J D).mapCone ((presheafToSheaf J D).mapCone S))
[PROOFSTEP]
have : ReflectsLimitsOfShape K (forget D) := reflectsLimitsOfShapeOfReflectsIsomorphisms
[GOAL]
case preservesLimit.preserves.t
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝² : SmallCategory K
inst✝¹ : FinCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
S : Cone F
hS : IsLimit S
this : ReflectsLimitsOfShape K (forget D)
⊢ IsLimit ((sheafToPresheaf J D).mapCone ((presheafToSheaf J D).mapCone S))
[PROOFSTEP]
have : PreservesLimitsOfShape K (presheafToSheaf J D ⋙ sheafToPresheaf J D) :=
  preservesLimitsOfShapeOfNatIso (J.sheafificationIsoPresheafToSheafCompSheafToPreasheaf D)
[GOAL]
case preservesLimit.preserves.t
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁶ : ConcreteCategory D
inst✝⁵ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝² : SmallCategory K
inst✝¹ : FinCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Cᵒᵖ ⥤ D
S : Cone F
hS : IsLimit S
this✝ : ReflectsLimitsOfShape K (forget D)
this : PreservesLimitsOfShape K (presheafToSheaf J D ⋙ sheafToPresheaf J D)
⊢ IsLimit ((sheafToPresheaf J D).mapCone ((presheafToSheaf J D).mapCone S))
[PROOFSTEP]
exact isLimitOfPreserves (presheafToSheaf J D ⋙ sheafToPresheaf J D) hS
[GOAL]
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁸ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁷ : ConcreteCategory D
inst✝⁶ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁵ : PreservesLimits (forget D)
inst✝⁴ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝³ : SmallCategory K
inst✝² : FinCategory K
inst✝¹ : HasLimitsOfShape K D
inst✝ : HasFiniteLimits D
⊢ PreservesFiniteLimits (presheafToSheaf J D)
[PROOFSTEP]
apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{max v u}
[GOAL]
case h
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁸ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁷ : ConcreteCategory D
inst✝⁶ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁵ : PreservesLimits (forget D)
inst✝⁴ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝³ : SmallCategory K
inst✝² : FinCategory K
inst✝¹ : HasLimitsOfShape K D
inst✝ : HasFiniteLimits D
⊢ (J_1 : Type (max v u)) → {𝒥 : SmallCategory J_1} → FinCategory J_1 → PreservesLimitsOfShape J_1 (presheafToSheaf J D)
[PROOFSTEP]
intros
[GOAL]
case h
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 : GrothendieckTopology.Cover J X), HasMultiequalizer (GrothendieckTopology.Cover.index S P)
inst✝⁸ : ∀ (X : C), HasColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ D
inst✝⁷ : ConcreteCategory D
inst✝⁶ : (X : C) → PreservesColimitsOfShape (GrothendieckTopology.Cover J X)ᵒᵖ (forget D)
inst✝⁵ : PreservesLimits (forget D)
inst✝⁴ : ReflectsIsomorphisms (forget D)
K : Type (max v u)
inst✝³ : SmallCategory K
inst✝² : FinCategory K
inst✝¹ : HasLimitsOfShape K D
inst✝ : HasFiniteLimits D
J✝ : Type (max v u)
𝒥✝ : SmallCategory J✝
x✝ : FinCategory J✝
⊢ PreservesLimitsOfShape J✝ (presheafToSheaf J D)
[PROOFSTEP]
infer_instance