Theorem: CategoryTheory.GrothendieckTopology.Plus.toPlus_apply
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: dsimp only [toPlus, plusObj]
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ (forget D).map ((toPlus J P).app I.Y.op) (↑x I) = (forget D).map ((plusObj J P).map I.f.op) (mk x)

tactic: delta Cover.toMultiequalizer
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ (forget D).map (Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P I.Y.op.unop) ⊤.op) (↑x I) =
    (forget D).map
      (colimMap (diagramPullback J P I.f.op.unop) ≫
        colimit.pre (diagram J P I.Y.op.unop) (Functor.op (pullback J I.f.op.unop)))
      (mk x)

tactic: dsimp [mk]
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ (forget D).map
      (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op.unop.op) (fun I_1 => P.map I_1.f.op)
          (_ :
            ∀ (I_1 : (Cover.index ⊤ P).R),
              (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I_1) ≫
        colimit.ι (diagram J P I.Y.op.unop) ⊤.op)
      (↑x I) =
    (forget D).map
      (colimMap (diagramPullback J P I.f.op.unop) ≫
        colimit.pre (diagram J P I.Y.op.unop) (Functor.op (pullback J I.f.op.unop)))
      (mk x)

tactic: simp only [← comp_apply, colimit.ι_pre, ι_colimMap_assoc]
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ (forget D).map
      (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
          (_ :
            ∀ (I_1 : (Cover.index ⊤ P).R),
              (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I_1) ≫
        colimit.ι (diagram J P I.Y) ⊤.op)
      (↑x I) =
    (forget D).map (colimMap (diagramPullback J P I.f) ≫ colimit.pre (diagram J P I.Y) (Functor.op (pullback J I.f)))
      ((forget D).map (colimit.ι (diagram J P X) S.op) (↑(Meq.equiv P S).symm x))

tactic: simp only [comp_apply]
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ (forget D).map
      (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
          (_ :
            ∀ (I_1 : (Cover.index ⊤ P).R),
              (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I_1) ≫
        colimit.ι (diagram J P I.Y) ⊤.op)
      (↑x I) =
    (forget D).map
      ((diagramPullback J P I.f).app S.op ≫ colimit.ι (diagram J P I.Y) ((Functor.op (pullback J I.f)).obj S.op))
      (↑(Meq.equiv P S).symm x)

tactic: dsimp only [Functor.op]
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ (forget D).map (colimit.ι (diagram J P I.Y) ⊤.op)
      ((forget D).map
        (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
          (_ :
            ∀ (I_1 : (Cover.index ⊤ P).R),
              (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    (forget D).map (colimit.ι (diagram J P I.Y) ((Functor.op (pullback J I.f)).obj S.op))
      ((forget D).map ((diagramPullback J P I.f).app S.op) (↑(Meq.equiv P S).symm x))

tactic: let e : (J.pullback I.f).obj (unop (op S)) ⟶ ⊤ := homOfLE (OrderTop.le_top _)
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
⊢ (forget D).map (colimit.ι (diagram J P I.Y) ⊤.op)
      ((forget D).map
        (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
          (_ :
            ∀ (I_1 : (Cover.index ⊤ P).R),
              (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    (forget D).map (colimit.ι (diagram J P I.Y) ((pullback J I.f).obj S.op.unop).op)
      ((forget D).map ((diagramPullback J P I.f).app S.op) (↑(Meq.equiv P S).symm x))

tactic: rw [← colimit.w _ e.op]
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
⊢ (forget D).map (colimit.ι (diagram J P I.Y) ⊤.op)
      ((forget D).map
        (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
          (_ :
            ∀ (I_1 : (Cover.index ⊤ P).R),
              (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    (forget D).map (colimit.ι (diagram J P I.Y) ((pullback J I.f).obj S.op.unop).op)
      ((forget D).map ((diagramPullback J P I.f).app S.op) (↑(Meq.equiv P S).symm x))

tactic: simp only [comp_apply]
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
⊢ (forget D).map ((diagram J P I.Y).map e.op ≫ colimit.ι (diagram J P I.Y) ((pullback J I.f).obj S.op.unop).op)
      ((forget D).map
        (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
          (_ :
            ∀ (I_1 : (Cover.index ⊤ P).R),
              (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    (forget D).map (colimit.ι (diagram J P I.Y) ((pullback J I.f).obj S.op.unop).op)
      ((forget D).map ((diagramPullback J P I.f).app S.op) (↑(Meq.equiv P S).symm x))

tactic: apply congr_arg
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
⊢ (forget D).map (colimit.ι (diagram J P I.Y) ((pullback J I.f).obj S.op.unop).op)
      ((forget D).map ((diagram J P I.Y).map (homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)).op)
        ((forget D).map
          (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1))
          (↑x I))) =
    (forget D).map (colimit.ι (diagram J P I.Y) ((pullback J I.f).obj S.op.unop).op)
      ((forget D).map ((diagramPullback J P I.f).app S.op) (↑(Meq.equiv P S).symm x))

tactic: apply Concrete.multiequalizer_ext
state_before: case h
C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
⊢ (forget D).map ((diagram J P I.Y).map (homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)).op)
      ((forget D).map
        (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
          (_ :
            ∀ (I_1 : (Cover.index ⊤ P).R),
              (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I_1))
        (↑x I)) =
    (forget D).map ((diagramPullback J P I.f).app S.op) (↑(Meq.equiv P S).symm x)

tactic: intro i
state_before: case h.h
C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
⊢ ∀ (t : (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P).L),
    (forget D).map (Multiequalizer.ι (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P) t)
        ((forget D).map ((diagram J P I.Y).map (homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)).op)
          ((forget D).map
            (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
              (_ :
                ∀ (I_1 : (Cover.index ⊤ P).R),
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                      MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                    (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                      MulticospanIndex.snd (Cover.index ⊤ P) I_1))
            (↑x I))) =
      (forget D).map (Multiequalizer.ι (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P) t)
        ((forget D).map ((diagramPullback J P I.f).app S.op) (↑(Meq.equiv P S).symm x))

tactic: dsimp [diagram]
state_before: case h.h
C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
i : (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P).L
⊢ (forget D).map (Multiequalizer.ι (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P) i)
      ((forget D).map ((diagram J P I.Y).map (homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)).op)
        ((forget D).map
          (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1))
          (↑x I))) =
    (forget D).map (Multiequalizer.ι (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P) i)
      ((forget D).map ((diagramPullback J P I.f).app S.op) (↑(Meq.equiv P S).symm x))

tactic: simp only [← comp_apply, Category.assoc, Multiequalizer.lift_ι, Category.comp_id,
  Meq.equiv_symm_eq_apply]
state_before: case h.h
C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
i : (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P).L
⊢ (forget D).map (Multiequalizer.ι (Cover.index (Cover.pullback S I.f) P) i)
      ((forget D).map
        (Multiequalizer.lift (Cover.index (Cover.pullback S I.f) P) (multiequalizer (Cover.index ⊤ P))
          (fun I_1 => Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤))))
          (_ :
            ∀ (I_1 : (Cover.index (Cover.pullback S I.f).op.unop P).R),
              Multiequalizer.ι (Cover.index ⊤.op.unop P)
                    (MulticospanIndex.fstTo (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.fst (Cover.index ⊤.op.unop P)
                    (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤)).op.unop) =
                Multiequalizer.ι (Cover.index ⊤.op.unop P)
                    (MulticospanIndex.sndTo (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.snd (Cover.index ⊤.op.unop P)
                    (Cover.Relation.map I_1 (homOfLE (_ : Cover.pullback S I.f ≤ ⊤)).op.unop)))
        ((forget D).map
          (Multiequalizer.lift (Cover.index ⊤ P) (P.obj I.Y.op) (fun I_1 => P.map I_1.f.op)
            (_ :
              ∀ (I_1 : (Cover.index ⊤ P).R),
                (fun I_2 => P.map I_2.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I_1 =
                  (fun I_2 => P.map I_2.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I_1) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I_1))
          (↑x I))) =
    (forget D).map (Multiequalizer.ι (Cover.index (Cover.pullback S I.f) P) i)
      ((forget D).map
        (Multiequalizer.lift (Cover.index (Cover.pullback S I.f) P) (multiequalizer (Cover.index S P))
          (fun I_1 => Multiequalizer.ι (Cover.index S P) (Cover.Arrow.base I_1))
          (_ :
            ∀ (I_1 : (Cover.index ((Functor.op (pullback J I.f)).obj S.op).unop P).R),
              Multiequalizer.ι (Cover.index S.op.unop P)
                    (MulticospanIndex.fstTo (Cover.index S.op.unop P) (Cover.Relation.base I_1)) ≫
                  MulticospanIndex.fst (Cover.index S.op.unop P) (Cover.Relation.base I_1) =
                Multiequalizer.ι (Cover.index S.op.unop P)
                    (MulticospanIndex.sndTo (Cover.index S.op.unop P) (Cover.Relation.base I_1)) ≫
                  MulticospanIndex.snd (Cover.index S.op.unop P) (Cover.Relation.base I_1)))
        (↑(Meq.equiv P S).symm x))

tactic: let RR : S.Relation :=
  ⟨_, _, _, i.f, 𝟙 _, I.f, i.f ≫ I.f, I.hf, Sieve.downward_closed _ I.hf _, by simp⟩
state_before: case h.h
C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
i : (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P).L
⊢ (forget D).map (P.map (Cover.Arrow.map i (homOfLE (_ : Cover.pullback S I.f ≤ ⊤))).f.op) (↑x I) =
    ↑x (Cover.Arrow.base i)

tactic: erw [x.condition RR]
state_before: case h.h
C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
i : (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P).L
RR : Cover.Relation S :=
  { Y₁ := I.Y, Y₂ := i.Y, Z := i.Y, g₁ := i.f, g₂ := 𝟙 i.Y, f₁ := I.f, f₂ := i.f ≫ I.f,
    h₁ := (_ : (Cover.sieve S).arrows I.f), h₂ := (_ : (Cover.sieve S).arrows (i.f ≫ I.f)),
    w := (_ : i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f) }
⊢ (forget D).map (P.map (Cover.Arrow.map i (homOfLE (_ : Cover.pullback S I.f ≤ ⊤))).f.op) (↑x I) =
    ↑x (Cover.Arrow.base i)

tactic: simp
state_before: case h.h
C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
i : (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P).L
RR : Cover.Relation S :=
  { Y₁ := I.Y, Y₂ := i.Y, Z := i.Y, g₁ := i.f, g₂ := 𝟙 i.Y, f₁ := I.f, f₂ := i.f ≫ I.f,
    h₁ := (_ : (Cover.sieve S).arrows I.f), h₂ := (_ : (Cover.sieve S).arrows (i.f ≫ I.f)),
    w := (_ : i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f) }
⊢ (forget D).map (P.map RR.g₂.op) (↑x (MulticospanIndex.sndTo (Cover.index S P) RR)) = ↑x (Cover.Arrow.base i)

tactic: rfl
state_before: case h.h
C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
i : (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P).L
RR : Cover.Relation S :=
  { Y₁ := I.Y, Y₂ := i.Y, Z := i.Y, g₁ := i.f, g₂ := 𝟙 i.Y, f₁ := I.f, f₂ := i.f ≫ I.f,
    h₁ := (_ : (Cover.sieve S).arrows I.f), h₂ := (_ : (Cover.sieve S).arrows (i.f ≫ I.f)),
    w := (_ : i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f) }
⊢ ↑x
      (MulticospanIndex.sndTo (Cover.index S P)
        { Y₁ := I.Y, Y₂ := i.Y, Z := i.Y, g₁ := i.f, g₂ := 𝟙 i.Y, f₁ := I.f, f₂ := i.f ≫ I.f,
          h₁ := (_ : (Cover.sieve S).arrows I.f), h₂ := (_ : (Cover.sieve S).arrows (i.f ≫ I.f)),
          w := (_ : i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f) }) =
    ↑x (Cover.Arrow.base i)

tactic: simp
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
I : Cover.Arrow S
e : (pullback J I.f).obj S.op.unop ⟶ ⊤ := homOfLE (_ : (pullback J I.f).obj S.op.unop ≤ ⊤)
i : (Cover.index ((pullback J I.f).obj S.op.unop).op.unop P).L
⊢ i.f ≫ I.f = 𝟙 i.Y ≫ i.f ≫ I.f